Zum Inhalt springen

Claude Code in deiner eigenen Web-App · Teil 14 von 16 der Serie

Teil 14: Dateien und Bilder für Claude Code

Gib Claude Code mit einem Auftrag ein Logo, Fotos oder ein PDF: mit einem Knopf ausgewählt oder irgendwo auf die Seite gezogen, mit sauberem Namen und Größenlimit in den Ordner assets/ der Site gestreamt und im Auftrag genannt, damit Claude Code sie zuerst ansieht.

Quest-Ziele

  • Eine Datei mit einem einfachen PUT hochladen und direkt auf die Platte streamen
  • Dateinamen säubern, andere Typen ablehnen und die Größe zählen, während die Bytes ankommen
  • Nichts zurücklassen, wenn ein Upload abbricht
  • Die Dateien im Auftrag nennen, damit Claude Code sie liest, bevor es anfängt
  • Dateien mit einem Knopf hinzufügen oder sie irgendwo auf die Seite der Site ziehen

Mit Worten kommt man weit, aber manches ist schneller gezeigt als beschrieben: das Logo der Bäckerei, ein Foto vom Schaufenster, die Preisliste vom letzten Jahr als PDF, eine Skizze auf einer Serviette. Claude Code kann sich all das ansehen. Sein Werkzeug Read zeigt ihm Bilder und PDFs, nicht nur Text, also funktioniert ein Auftrag wie „nimm die Farben aus dem Logo“, solange das Logo irgendwo liegt, wo Claude Code es lesen kann.

In diesem Teil geht es also darum, eine Datei aus deinem Browser in den Ordner der Site zu bringen und Claude Code zu sagen, dass sie da ist. Der Ordner ist aus zwei Gründen der richtige Ort. Dateien in dem Ordner, in dem es arbeitet, liest Claude Code ohne zu fragen, während Lesen woanders erst eine Berechtigungsabfrage bringen kann. Und die Datei ist für die Site gedacht: Die CLAUDE.md aus Teil 2 sagt schon, dass Bilder und andere Dateien nach assets/ gehören, ein Logo dort ist also gleich so verwendbar, wie es ist.

Ein Logo, auf die Seite gezogen, landet im Ordner der Site, wo Claude Code es findet.
Ein Logo, auf die Seite gezogen, landet im Ordner der Site, wo Claude Code es findet.

Ein Upload als einfaches PUT

Seite und Server brauchen zwei neue Dinge, über die sie reden können. In shared/types.ts bekommt ein Auftrag eine Liste von Dateien und ein Upload eine Antwort:

shared/types.ts
/** A request typed into the page. */
export interface RequestBody {
  text: string;
  /** plan first: Claude Code shows its plan for approval before it changes anything */
  plan?: boolean;
  /** files you added for this request, as paths in the site's folder (assets/…) */
  files?: string[];
}

/** The answer to an upload: where the file went in the site's folder. */
export interface Uploaded {
  file: string;
}

In server/main.ts ergänzt du Uploaded im Typ-Import oben und ersetzt die Route für Aufträge durch diese beiden Routen:

server/main.ts
// requests: Claude Code works on the site
['POST', /^\/api\/sites\/([^/]+)\/requests$/, async (req, res, m) => {
  if (!terminals.available) throw new HttpError(409, 'Sessions need tmux.');
  const site = sites.get(m[1]);
  const { text, plan, files } = await readJson<RequestBody>(req);
  // only files that are really in the site's assets/ folder
  const added = (Array.isArray(files) ? files : []).map(String)
    .filter((f) => /^assets\/[a-z0-9_-][a-z0-9._-]*$/.test(f) && fs.existsSync(path.join(sites.dir(site.name), f)));
  try {
    send(res, 201, agent.run(target(site.name), runTitle(site), requestText(site, String(text ?? ''), plan === true, added), plan === true));
  } catch (err) { throw new HttpError(409, (err as Error).message); }
}],
// files for Claude Code: the body is the file itself
['PUT', /^\/api\/sites\/([^/]+)\/files\/([^/]+)$/, async (req, res, m) => {
  const site = sites.get(m[1]);
  const file = await sites.receive(site.name, decodeURIComponent(m[2]), req);
  send(res, 201, { file } satisfies Uploaded);
}],

Der Upload ist ein PUT an /api/sites/<site>/files/<name>, und sein Body ist die Datei, Byte für Byte. Kein Formular, keine Multipart-Kodierung mit Grenzen, die man zerlegen müsste: Die Anfrage ist ein Strom von Bytes, und der kann auf die Platte, während er ankommt. Der Name reist in der Adresse, von der Seite kodiert, und der Server dekodiert ihn. Eine Datei pro Anfrage; mehrere schickt die Seite nacheinander.

Der Auftrag nimmt jetzt die Liste der Dateien entgegen, die die Seite mitschickt. Der Server traut dieser Liste nicht. Er behält nur Pfade der Form assets/<einfacher Name> (Kleinbuchstaben, Ziffern, Punkte, Binde- und Unterstriche, und kein Punkt am Anfang, damit nie eine versteckte Datei genannt wird), die es im Ordner der Site gibt, und verwirft den Rest wortlos. Die Liste landet in dem Text, den Claude Code als seine Anweisungen liest, also dürfen dort nur Namen hinein, die der Server selbst vergeben hat.

Beide Routen stehen hinter den Prüfungen, die jede Route seit Teil 2 hat: Der Host-Header muss unserer sein, und alles außer einem GET nimmt der Server von einem Browser nur an, wenn es von unserer eigenen Seite kommt. Eine Site in der Vorschau kann keine Dateien hochladen, das siehst du gleich.

Eine Datei entgegennehmen

Die Arbeit passiert in server/sites.ts. Oben braucht die Datei ein paar Importe mehr, die Liste dessen, was hereindarf, das Limit und eine Funktion für saubere Namen:

server/sites.ts
import fs from 'node:fs';
import type http from 'node:http';
import path from 'node:path';
import { Transform } from 'node:stream';
import { pipeline } from 'node:stream/promises';
import type { NewSite, Site } from '../shared/types.ts';
import { HttpError } from './http.ts';

/** Site names are folder names, addresses and (later) tmux session names: keep them plain. */
export const NAME = /^[a-z0-9][a-z0-9-]{0,39}$/;
/** Sitesmith's own files in a site's folder. */
export const OWN = '.sitesmith';
const META = `${OWN}/site.json`;
/** What can be added for Claude Code: pictures, PDFs and plain text, which its Read tool can show it. */
const UPLOADS = /\.(png|jpe?g|webp|gif|svg|pdf|txt|md|csv)$/i;
const MAX_UPLOAD = 20 * 1024 ** 2;

/** "Logo Final (2).PNG" -> "logo-final-2.png"; a name without Latin letters becomes "file.png" */
function fileName(name: string) {
  const ext = path.extname(name).toLowerCase().replace(/[^a-z0-9.]/g, '');
  const base = path.basename(name, path.extname(name)).toLowerCase().normalize('NFKD').replace(/[\u0300-\u036f]/g, '')
    .replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '');
  return `${base || 'file'}${ext}`;
}

fileName macht aus dem, wie der Browser die Datei nennt, einen Namen, der in einem Ordner, einer URL und einem Shell-Befehl sicher ist. Sie nimmt den Namen auseinander: Die Endung bleibt, kleingeschrieben, und nur der Teil davor wird gesäubert. path.basename wirft jeden Ordner davor weg, ../../ eingeschlossen, also kann ein Name nie aus assets/ hinausführen. normalize('NFKD') zerlegt einen Buchstaben mit Akzent in den Buchstaben und den Akzent, und der nächste Schritt entfernt die Akzente, so wird aus „Über“ ein „uber“ statt eines Bindestrichs. Alles andere, was kein einfacher Buchstabe, keine Ziffer, kein Binde- oder Unterstrich ist, wird zum Bindestrich, Punkte eingeschlossen, und Bindestriche an beiden Enden fallen weg. So wird aus „Logo Final (2).PNG“ logo-final-2.png, und der gesäuberte Teil beginnt nie mit einem Punkt: Kein Upload kann zu einer versteckten Datei wie .htaccess werden. Ein Name ganz ohne lateinische Buchstaben oder Ziffern, etwa ein Foto mit griechischem oder japanischem Namen, behält nichts übrig und wird zu file mit seiner Endung, zum Beispiel file.png.

UPLOADS listet, womit Claude Code etwas anfangen kann: Bilder (SVG ist für Claude Code Text und für den Browser ein Bild), PDFs und einfacher Text. Die Methode, die eine Datei entgegennimmt, kommt in die Klasse Sites, nach list():

server/sites.ts
/**
 * A file for Claude Code, streamed into the site's assets/ folder. A name that is taken gets a
 * number; a broken or too large upload leaves nothing behind.
 */
async receive(name: string, original: string, req: http.IncomingMessage) {
  const clean = fileName(original);
  if (!UPLOADS.test(clean)) throw new HttpError(415, 'Pictures, PDFs and text files only (png, jpg, webp, gif, svg, pdf, txt, md, csv).');
  if (Number(req.headers['content-length'] ?? 0) > MAX_UPLOAD) throw new HttpError(413, 'Files up to 20 MB.');
  const dir = path.join(this.dir(name), 'assets');
  fs.mkdirSync(dir, { recursive: true });
  const ext = path.extname(clean);
  let file = clean;
  for (let i = 2; fs.existsSync(path.join(dir, file)); i++) file = `${path.basename(clean, ext)}-${i}${ext}`;
  const tmp = path.join(dir, `.${file}.upload`);
  let size = 0;
  // the Content-Length can lie: count what really arrives
  const limit = new Transform({
    transform(chunk: Buffer, _enc, done) {
      size += chunk.length;
      done(size > MAX_UPLOAD ? new HttpError(413, 'Files up to 20 MB.') : null, chunk);
    },
  });
  try {
    await pipeline(req, limit, fs.createWriteStream(tmp));
    fs.renameSync(tmp, path.join(dir, file));
  } catch (err) {
    fs.rmSync(tmp, { force: true });
    throw err;
  }
  return `assets/${file}`;
}

Sie liest sich wie eine Checkliste.

  • Der Typ, an der Endung des sauberen Namens. Alles andere wird mit 415 abgelehnt, bevor ein Byte des Bodys gelesen ist.

  • Die Größe, wie angekündigt. Ein Browser schickt die Länge des Bodys im Header Content-Length mit, und eine Datei, die mehr als 20 MB ankündigt, wird sofort abgelehnt.

  • Die Größe, wie sie ankommt. Ein Header ist nur eine Behauptung. Ein Client kann weniger ankündigen, als er schickt, oder den Body in Stücken senden, ohne etwas anzukündigen. Deshalb sitzt ein Transform-Stream zwischen Anfrage und Datei und zählt jedes Stück, das vorbeikommt. Sobald die Summe das Limit überschreitet, schlägt er mit 413 fehl; pipeline hält dann alle drei Streams an.

  • Ein freier Name. Ist logo.png vergeben, wird die Datei zu logo-2.png, dann zu logo-3.png. Nichts, was Claude Code oder du dort abgelegt habt, wird überschrieben.

  • Nichts Halbes. Die Bytes gehen in eine temporäre Datei, .logo.png.upload, und erst ein vollständiger Upload wird auf seinen echten Namen umbenannt. Ein Umbenennen innerhalb eines Ordners ist für das Dateisystem ein einziger Schritt, also liegt unter dem echten Namen nie eine halbe Datei, über die die Vorschau oder Claude Code stolpern könnten. Geht etwas schief, wird die temporäre Datei gelöscht und der Fehler an die Route weitergereicht, die mit seinem Status antwortet. Der temporäre Name beginnt mit einem Punkt, also liefert ihn der Vorschau-Server, der keine versteckten Dateien zeigt, nie aus, und kein sauberer Name kann je gleich lauten.

Zwanzig Megabyte reichen gut für ein Logo und die Fotos einer kleinen Website. Ein Foto direkt aus der Kamera kann größer sein, und das macht man für eine Webseite ohnehin besser vorher kleiner.

Hier die Wächter bei der Arbeit, mit curl gegen den laufenden Server:

~/sitesmith
$ curl -X PUT --data-binary @evil.sh localhost:5400/api/sites/maras-bakery/files/evil.sh{"error":"Pictures, PDFs and text files only (png, jpg, webp, gif, svg, pdf, txt, md, csv)."}$ curl -X PUT --data-binary @logo.svg "localhost:5400/api/sites/maras-bakery/files/..%2F..%2FÜber%20Uns.SVG"{"file":"assets/uber-uns.svg"}# big.png has 21 MB$ curl -X PUT --data-binary @big.png localhost:5400/api/sites/maras-bakery/files/big.png{"error":"Files up to 20 MB."}$ curl -X PUT --data-binary @logo.svg -H 'origin: http://localhost:5402' localhost:5400/api/sites/maras-bakery/files/x.svg{"error":"forbidden"}

Ein Shell-Skript wird wegen seines Typs abgelehnt. Der zweite Upload versucht, mit einem kodierten ../../ im Namen aus dem Ordner zu klettern, und landet in assets/uber-uns.svg: keine Ordner, keine Großbuchstaben, kein Umlaut, kein Leerzeichen. Eine Datei mit 21 MB scheitert an ihrer Content-Length. Und die letzte Anfrage gibt vor, von einer Site in der Vorschau auf Port 5402 zu kommen: forbidden, von der Origin-Prüfung aus Teil 2, bevor die Route überhaupt angeschaut wird.

Claude Code Bescheid sagen

Eine Datei in assets/ genügt nicht: Claude Code muss wissen, dass sie für diesen Auftrag gedacht ist. In server/requests.ts bekommt requestText die Liste und setzt sie direkt unter deine Worte:

server/requests.ts
/**
 * What Claude Code gets for a request: the user's words, framed by what Sitesmith needs. It goes
 * into .sitesmith/request.md; the folder's CLAUDE.md says what the site is and how it is built.
 */
export function requestText(site: Site, text: string, plan = false, files: string[] = []) {
  const task = site.built
    ? 'Change the site in this folder as follows:'
    : 'Build the first version of the site in this folder (CLAUDE.md says what it is about). The user adds:';
  return `# A request from Sitesmith

${task}

${text.trim() || '(nothing: use your own judgement)'}
${files.length ? `
The user added these files for this request. Look at each of them before you start (the Read
tool shows you pictures and PDFs), and use them where they fit:

${files.map((f) => `- ${f}`).join('\n')}
` : ''}
If something important is open (the style, the sections, the tone of the texts), ask before you
build, with AskUserQuestion: two to four options per question, the one you recommend first. For a
question about the layout, give each option a small sketch of the page in plain text as its
preview. Don't ask about details you can decide well yourself.

${plan ? `You are in plan mode: first make a plan (what you will build or change, file by file, in a
few short points) and present it with ExitPlanMode. Sitesmith shows it to the user for approval.

` : ''}When you are done, say in two or three sentences what you built or changed.
`;
}

„Look at each of them before you start“ ist der wichtige Teil. Claude Code fände ein Logo in assets/ früher oder später auch allein, aber du willst, dass es hinschaut, bevor es sich für Farben und ein Layout entscheidet, nicht danach. Der Hinweis auf das Werkzeug Read sagt ihm, wie.

Im Verlauf zeigt sich das als eigene Zeile: describeTool aus Teil 6 sagt schon Looking at statt Reading, wenn Claude Code ein Bild liest. Im echten Lauf für diesen Teil ging eine Datei namens „Mara Logo.png“ mit einem Auftrag an Mara's Bakery, und der Verlauf sah so aus:

  • Asked from the page: Changing the site

  • Claude Code started

  • Read the request file and list project contents

  • Read project notes, site config, index page and assets

  • Looking at mara-logo.png

  • Sample dominant colours from the logo (eine Berechtigung, auf der Seite erlaubt)

  • Asking you something (Layout und Ton)

  • Writing index.html

  • Writing style.css

  • Check that referenced local files exist (eine Berechtigung)

  • I built the Mara's Bakery one-pager in index.html … the palette (cream, green, caramel, crust brown) is sampled from the logo …

Claude Code hat sich das Logo angesehen und ist dann einen Schritt weiter gegangen als nur hinzuschauen: Es hat einen kleinen Befehl ausgeführt, um die Farben im Bild zu messen, wofür es eine Berechtigung brauchte, und die Palette aus dem Ergebnis gebaut. Nach 37 Sekunden war der Lauf fertig.

Dateien auf der Seite

Die Seite braucht einen Ort, um Dateien auszuwählen und die zu zeigen, die auf die nächsten Auftrag warten. Leg src/attachments.ts an:

src/attachments.ts
import { h } from './dom.ts';
import type { Uploaded } from '../shared/types.ts';

const IMAGE = /\.(png|jpe?g|webp|gif|svg)$/i;

/**
 * Files for the next request: chosen with "Add files" or dropped anywhere on the site's page.
 * Each one goes straight into the site's assets/ folder; the request names them, so Claude Code
 * looks at them before it starts.
 */
export class Attachments {
  readonly el: HTMLElement;
  /** paths in the site's folder (assets/…), in the order they were added */
  files: string[] = [];
  private site: string;
  private previewBase: string;
  private list = h('div', { class: 'files' });
  private input = h('input', { type: 'file', multiple: true, hidden: true, accept: 'image/*,.pdf,.txt,.md,.csv' });
  private msg = h('p', { class: 'hint bad', 'aria-live': 'polite' });

  /** `previewBase`: the site on the preview server, where the thumbnails come from */
  constructor(site: string, previewBase: string) {
    this.site = site;
    this.previewBase = previewBase;
    this.input.onchange = () => { void this.add([...(this.input.files ?? [])]); this.input.value = ''; };
    this.el = h('div', { class: 'attachments' },
      this.list,
      h('div', { class: 'actions' },
        h('button', { type: 'button', class: 'small', onclick: () => this.input.click() }, 'Add files'),
        h('span', { class: 'hint' }, 'or drop them on the page')),
      this.input, this.msg);
  }

  /** Uploads files one after the other; each one shows up as soon as it is there. */
  async add(files: File[]) {
    this.msg.textContent = '';
    for (const file of files) {
      try {
        const res = await fetch(`/api/sites/${this.site}/files/${encodeURIComponent(file.name)}`, { method: 'PUT', body: file });
        const data = await res.json() as Uploaded & { error?: string };
        if (!res.ok) throw new Error(data.error ?? `HTTP ${res.status}`);
        this.files.push(data.file);
        this.render();
      } catch (err) { this.msg.textContent = `${file.name}: ${(err as Error).message}`; }
    }
  }

  /** The request went out with them. */
  clear() {
    this.files = [];
    this.render();
  }

  private render() {
    this.list.replaceChildren(...this.files.map((f) => h('span', { class: 'file-chip' },
      IMAGE.test(f) ? h('img', { src: `${this.previewBase}${f}`, alt: '' }) : null,
      h('span', { class: 'file-name' }, f.slice('assets/'.length)),
      h('button', { type: 'button', 'aria-label': `Leave ${f} out`, onclick: () => { this.files = this.files.filter((x) => x !== f); this.render(); } }, '×'))));
  }
}

/** Files dragged over the element: a hint covers the page, a drop hands them over. */

Auswählen. Das Auswählen übernimmt ein Dateifeld, aber dessen Aussehen lässt sich kaum gestalten, also bleibt es versteckt, und der Knopf Add files klickt es an. Seine Liste accept lässt den Dateidialog des Browsers zuerst Bilder, PDFs und Textdateien anbieten. Das ist eine Bequemlichkeit für dich, keine Prüfung: Entscheiden tut der Server.

Hochladen. add schickt die Dateien eine nach der anderen, und jede erscheint als Chip, sobald sie da ist. Wird eine abgelehnt, stehen ihr Name und die Begründung des Servers darunter, und die nächste geht trotzdem los.

Die Chips. Ein Bild bekommt ein Vorschaubild, und das kommt vom Vorschau-Server, wo die Datei jetzt ohnehin liegt. Die eigene Adresse der Seite liefert nie Dateien der Sites aus, aus dem Grund aus Teil 2: Eine Site ist Code, den Claude Code geschrieben hat, und der gehört nicht auf den Origin der Seite. Das × lässt eine Datei aus dem Auftrag heraus. Die Datei bleibt in assets/; sie gehört jetzt zur Site.

Unter der Klasse, in derselben Datei, kommt das Ablageziel:

src/attachments.ts
  const hint = h('div', { class: 'drop-hint', hidden: true }, 'Drop the files for Claude Code');
  let depth = 0;
  const hasFiles = (e: DragEvent) => Boolean(e.dataTransfer?.types.includes('Files'));
  el.addEventListener('dragenter', (e) => { if (hasFiles(e)) { depth++; hint.hidden = false; } });
  el.addEventListener('dragleave', () => { if (--depth <= 0) { depth = 0; hint.hidden = true; } });
  el.addEventListener('dragover', (e) => { if (hasFiles(e)) e.preventDefault(); });
  el.addEventListener('drop', (e) => {
    if (!hasFiles(e)) return;
    e.preventDefault();
    depth = 0;
    hint.hidden = true;
    onFiles([...(e.dataTransfer?.files ?? [])]);
  });
  el.append(hint);
}

Zieht man eine Datei über die Seite, soll ein Hinweis sie bedecken, und der Hinweis soll verschwinden, wenn die Datei die Seite wieder verlässt. Das klingt nach zwei Ereignissen, aber dragenter und dragleave feuern für jedes Element, das der Zeiger überquert: Vom Textfeld zum Knopf darunter ist ein Verlassen und ein Betreten. Mit einem einfachen Merker würde der Hinweis flackern. Deshalb zählt depth Betreten minus Verlassen, und der Hinweis geht, wenn die Zahl wieder bei null ist.

hasFiles sorgt dafür, dass nur Dateien zählen, nicht ein Stück Text, das aus einem anderen Fenster herübergezogen wird. preventDefault bei dragover sagt dem Browser, dass ein Ablegen hier willkommen ist; ohne das würde der Browser die Datei selbst öffnen und Sitesmith verlassen. Der Hinweis liegt mit pointer-events: none aus style.css fest über der ganzen Seite, damit er den Ereignissen, auf die er reagiert, nie im Weg ist.

Die Chips kommen in das Auftragsfeld. Hier ist src/requestBox.ts vollständig:

src/requestBox.ts
import { api } from './api.ts';
import type { Attachments } from './attachments.ts';
import { h } from './dom.ts';
import type { RequestBody, Site } from '../shared/types.ts';

/** Where you tell Claude Code what to build or change. */
export class RequestBox {
  readonly el: HTMLFormElement;
  private url: string;
  private label = h('h2', {}, 'What should Claude Code build?');
  private text = h('textarea', { rows: 5, 'aria-label': 'Your request' });
  private go = h('button', { type: 'submit', class: 'primary' }, 'Build the site');
  private plan = h('input', { type: 'checkbox' });
  private msg = h('p', { class: 'hint bad', 'aria-live': 'polite' });
  private busy = false;
  private attachments: Attachments;

  constructor(site: string, attachments: Attachments) {
    this.url = `/api/sites/${site}/requests`;
    this.attachments = attachments;
    this.el = h('form', { class: 'panel request' },
      this.label, this.text, attachments.el,
      h('div', { class: 'actions' },
        h('label', { class: 'check', title: 'Claude Code shows you its plan before it changes anything' }, this.plan, 'Plan first'),
        this.go),
      this.msg);
    this.el.onsubmit = (e) => { e.preventDefault(); void this.send(); };
    this.text.onkeydown = (e) => { if (e.key === 'Enter' && (e.ctrlKey || e.metaKey)) { e.preventDefault(); void this.send(); } };
  }

  /** A built site gets changes; a new one its first version. Nothing goes out while a run is on. */
  update(site: Site | null, busy: boolean) {
    this.busy = busy;
    const built = Boolean(site?.built);
    this.label.textContent = built ? 'What should Claude Code change?' : 'What should Claude Code build?';
    this.text.placeholder = built
      ? 'Make the header smaller, add a page with the opening hours…'
      : 'A warm, simple one-pager: the breads of the week, opening hours, where to find us…';
    this.go.textContent = built ? 'Send to Claude Code' : 'Build the site';
    this.go.disabled = busy || !site;
  }

  private async send() {
    if (this.busy) return;
    this.msg.textContent = '';
    const body: RequestBody = { text: this.text.value, plan: this.plan.checked, files: this.attachments.files };
    try {
      await api('POST', this.url, body);
      this.text.value = '';
      this.attachments.clear();
    } catch (err) { this.msg.textContent = (err as Error).message; }
  }
}

Das Feld bekommt die Anhänge von außen, zeigt sie unter dem Text, schickt ihre Pfade mit dem Auftrag mit und leert die Liste, sobald der Auftrag hinaus ist. Schlägt der Auftrag fehl, bleiben die Chips, und nichts muss neu hinzugefügt werden.

Zuletzt importierst du in src/sitePage.ts Attachments und dropTarget aus ./attachments.ts und ersetzt den Konstruktor:

src/sitePage.ts
constructor(name: string, config: Config) {
  this.name = name;
  this.config = config;
  this.session = new SessionControls(name, config.terminals);
  this.terminal = new TerminalView(name, config.pty);
  const attachments = new Attachments(name, this.previewUrl);
  this.request = new RequestBox(name, attachments);
  this.agent = new AgentPanel(name);
  this.tabs = {
    preview: h('button', { type: 'button', class: 'tab', role: 'tab', onclick: () => this.show('preview') }, 'Preview'),
    terminal: h('button', { type: 'button', class: 'tab', role: 'tab', onclick: () => this.show('terminal') }, 'Terminal'),
  };
  this.el = h('section', { class: 'site-page' },
    h('header', { class: 'site-head' },
      h('div', { class: 'site-head-text' }, this.heading, this.about),
      this.session.el,
      h('a', { class: 'button small', href: this.previewUrl, target: '_blank', rel: 'noopener' }, 'Open in a new tab')),
    h('div', { class: 'site-body' },
      h('div', { class: 'work' }, this.request.el, this.agent.el),
      h('div', { class: 'view' },
        h('div', { class: 'tabs', role: 'tablist' }, this.tabs.preview, this.tabs.terminal),
        this.preview, this.terminal.el)));
  this.show('preview');
  dropTarget(this.el, (files) => void attachments.add(files));
}

Die Anhänge bekommen die Vorschau-Adresse der Site für ihre Vorschaubilder, und die ganze Seite der Site wird zum Ablageziel, damit du eine Datei ablegen kannst, wo deine Maus gerade ist.

Probier es aus

Öffne eine Site, zieh ein Bild auf die Seite und schreib, was Claude Code damit machen soll:

Ein Logo wartet auf den nächsten Auftrag, als Chip mit seinem Vorschaubild vom Vorschau-Server. Es heißt mara-logo-2.png, weil ein mara-logo.png aus einem früheren Lauf schon in assets/ lag.Den Screenshot in voller Größe öffnen
Ein Logo wartet auf den nächsten Auftrag, als Chip mit seinem Vorschaubild vom Vorschau-Server. Es heißt mara-logo-2.png, weil ein mara-logo.png aus einem früheren Lauf schon in assets/ lag.

Was du jetzt hast

Claude Code ist nicht mehr nur auf deine Worte angewiesen. Ein Logo, ein Foto oder ein PDF kommt mit einem sauberen Namen in den Ordner der Site, nichts Halbes oder zu Großes bleibt zurück, und der Auftrag sagt Claude Code, dass es zuerst hinschauen soll. Auf der Seite ist das ein Knopf oder ein Ablegen, egal wo auf der Seite der Site du gerade bist.

Bisher hat Claude jede Site über dein Abo gebaut. Der nächste Teil gibt einer Site ein anderes Gehirn: ein lokales Modell, über Ollama, und alles andere an Sitesmith bleibt, wie es ist.

Kommentare

Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.

Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.