Zum Inhalt springen

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

Teil 2: Ein Server und eine Seite

Richte das Projekt Sitesmith ein: einen kleinen Node-Server, der TypeScript direkt ausführt, jede Site in einem Ordner verwaltet und Änderungen an die Seite schickt, einen Vorschau-Server auf einem eigenen Port und eine schlichte TypeScript-Seite, gebaut mit Vite.

Quest-Ziele

  • Ein TypeScript-Projekt einrichten, das Node ohne Build-Schritt ausführt
  • Jede Site in einem eigenen Ordner verwalten, mit einer CLAUDE.md, die Claude Code sagt, worum es geht
  • Änderungen mit Server-Sent Events und einer Ordnerüberwachung an jede offene Seite schicken
  • Fremde Webseiten und die Sites selbst von der API fernhalten
  • Die Sites von einem zweiten Server auf einem eigenen Port zeigen
  • Die Seite aus ein paar kleinen TypeScript-Klassen bauen, ohne Framework

Claude Code braucht einen Ort zum Arbeiten und etwas, worin man seine Arbeit sieht. Dieser Teil baut beides, bevor Claude Code dazukommt: einen Server, der für jede Site einen Ordner verwaltet, eine Seite, die die Sites auflistet und die geöffnete zeigt, und eine Vorschau, die die Dateien jeder Site so ausliefert, wie sie sind.

Es ist der längste Teil der Serie, weil hier das ganze Projekt entsteht. Das meiste ist gewöhnliche Web-Klempnerei. Zwei Stücke zählen aber für alles, was folgt: wer mit dem Server reden darf und wo die Sites angezeigt werden. Claude Code wird Code in diese Ordner schreiben, und dieser Code läuft in deinem Browser.

Ein kleiner Server zwischen der Seite und den Ordnern, und ein zweiter, der zeigt, was darin liegt.
Ein kleiner Server zwischen der Seite und den Ordnern, und ein zweiter, der zeigt, was darin liegt.

Das Projekt

Leg einen Ordner sitesmith an und darin die Datei package.json:

package.json
{
  "name": "sitesmith",
  "private": true,
  "version": "1.0.0",
  "description": "Describe a website, Claude Code builds it, the page shows it and asks you what Claude Code asks",
  "type": "module",
  "engines": {
    "node": ">=24"
  },
  "scripts": {
    "server": "node server/main.ts",
    "dev": "vite",
    "build": "vite build",
    "start": "vite build && node server/main.ts",
    "typecheck": "tsc --noEmit"
  },
  "devDependencies": {
    "@types/node": "^24.10.1",
    "typescript": "^7.0.2",
    "vite": "^8.3.5"
  }
}

Der Server hat noch keine Abhängigkeiten: Die Module http, fs und path von Node reichen. TypeScript prüft nur die Typen, Vite baut die Seite, und @types/node beschreibt beiden die Module von Node. Die Skripte:

  • server startet den Server. node server/main.ts führt die TypeScript-Datei so aus, wie sie ist: Node 24 entfernt die Typen und führt aus, was übrig bleibt.

  • dev startet den Entwicklungsserver von Vite für die Seite, der sie bei jeder Änderung neu lädt.

  • build baut die Seite nach dist/. start tut das und startet danach den Server, der die gebaute Seite selbst ausliefert.

  • typecheck lässt den Compiler über alles laufen, ohne eine Datei zu schreiben.

Daneben kommt tsconfig.json:

tsconfig.json
{
  "compilerOptions": {
    "target": "ES2023",
    "lib": ["ES2023", "DOM", "DOM.Iterable"],
    "module": "NodeNext",
    "moduleResolution": "NodeNext",
    "allowImportingTsExtensions": true,
    "erasableSyntaxOnly": true,
    "verbatimModuleSyntax": true,
    "noEmit": true,
    "strict": true,
    "noUnusedLocals": true,
    "skipLibCheck": true,
    "types": ["node", "vite/client"]
  },
  "include": ["server", "shared", "src", "vite.config.ts"]
}

Node kann TypeScript ausführen, weil es die Typen entfernt und den Rest ausführt. Das klappt nur bei Syntax, die nichts als Typen ist. Ein paar Features von TypeScript erzeugen eigenen Code: Enums, Namespaces und Parameter Properties wie constructor(public status: number). Node lehnt sie ab. erasableSyntaxOnly lässt auch den Compiler sie ablehnen, sodass du es im Editor erfährst und nicht erst beim Start des Servers. Die Wirkung siehst du an den Klassen dieses Projekts: Sie deklarieren ihre Felder und weisen sie im Konstruktor zu.

  • allowImportingTsExtensions: Imports nennen die echte Datei, ./http.ts, weil Node genau nach dieser Datei sucht.

  • verbatimModuleSyntax: Ein Import, der nur Typen holt, muss import type heißen. Solche Imports lässt Node komplett weg. Ein normaler Import von etwas, das nur als Typ existiert, bliebe im Code stehen und würde beim Laden des Moduls scheitern.

  • noEmit: Der Compiler prüft nur; er schreibt nie JavaScript.

  • types: die Typen von Node für den Server und die von Vite für die Seite, damit sie ihr Stylesheet importieren darf.

Eine Konfiguration deckt den Server, die Seite und die gemeinsamen Typen ab. Jetzt vite.config.ts:

vite.config.ts
import { defineConfig } from 'vite';

// `npm run dev` serves the page with hot reload on 5401 and forwards /api to the server
// (`npm run server`, 5400). `npm start` builds the page into dist/, which the server serves itself.
export default defineConfig({
  server: {
    port: 5401,
    strictPort: true,
    proxy: { '/api': { target: 'http://127.0.0.1:5400', ws: true } },
  },
  build: { outDir: 'dist', emptyOutDir: true },
});

Während du an der Seite arbeitest, laufen zwei Server: Vite auf Port 5401 liefert die Seite aus und lädt sie neu, wenn du etwas änderst, und dein Server auf 5400 beantwortet die API. Der Proxy leitet jede Anfrage an /api von 5401 an 5400 weiter. So fragt die Seite immer ihre eigene Adresse, egal ob sie von Vite kommt oder von deinem Server. ws: true leitet auch WebSocket-Verbindungen weiter; das Terminal aus Teil 4 braucht eine. strictPort lässt Vite abbrechen, wenn 5401 belegt ist, statt auf einen anderen Port auszuweichen: Der Server lässt nur Seiten von 5400 und 5401 herein, wie du gleich siehst.

Die Seite selbst beginnt in index.html:

index.html
<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="color-scheme" content="dark" />
    <title>Sitesmith</title>
    <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 16 16'%3E%3Crect width='16' height='16' rx='3' fill='%23ff8a3d'/%3E%3Cpath d='M3 6h10v2H9v4H7V8H3z' fill='%23181410'/%3E%3C/svg%3E" />
  </head>
  <body>
    <div id="app"></div>
    <script type="module" src="/src/main.ts"></script>
  </body>
</html>

Ein leeres #app und das Skript; Vite folgt dem Skript zu allem anderen. Das Icon ist ein kleines SVG direkt im Link, es gibt also keine Datei dafür auszuliefern. color-scheme sagt dem Browser, dass die Seite dunkel ist, damit er Scrollbalken und Formularelemente passend zeichnet. Zum Schluss .gitignore:

.gitignore
node_modules/
dist/
.data/
sites/

In sites/ landet, was Claude Code baut, in .data/ ab Teil 6, was der Server für sich aufbewahrt. Beides gehört nicht ins Repository der App. Installier die Pakete:

~/sitesmith
$ npm installadded 19 packages in 517ms

Was Server und Seite teilen

Beide Seiten importieren dieselben Typen aus shared/types.ts:

shared/types.ts
/** What the server and the page both know about. */

/** A site: one folder in sites/, which Claude Code builds. */
export interface Site {
  /** the folder's name: also the site's address in the page and in the preview */
  name: string;
  title: string;
  description: string;
  created: number;
  /** whether it has an index.html yet */
  built: boolean;
}

export interface NewSite {
  name: string;
  title: string;
  description: string;
}

export interface Config {
  /** the preview server's port: the sites are shown from there, never from the page's own address */
  previewPort: number;
}

/** What the server tells every open page, over server-sent events. */
export type ServerEvent =
  | { type: 'sites'; sites: Site[] }
  | { type: 'files'; site: string };

Eine Site ist ein Ordner. Ihr name ist der Name des Ordners und zugleich die Adresse der Site auf der Seite und in der Vorschau. built sagt, ob es schon eine index.html gibt. Config ist, was die Seite beim Start wissen muss, bisher nur den Port der Vorschau. ServerEvent zählt alles auf, was der Server an die Seite schickt; spätere Teile ergänzen es.

HTTP-Helfer

server/http.ts enthält die Kleinigkeiten, die jede Route braucht. Die erste Hälfte:

server/http.ts
import fs from 'node:fs';
import path from 'node:path';
import type http from 'node:http';

/** An error with the HTTP status it should answer with. */
export class HttpError extends Error {
  status: number;
  constructor(status: number, message: string) {
    super(message);
    this.status = status;
  }
}

export function send(res: http.ServerResponse, status: number, body: unknown) {
  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
  res.end(JSON.stringify(body));
}

/** The request's JSON body (at most 1 MB). */
export async function readJson<T>(req: http.IncomingMessage): Promise<Partial<T>> {
  const chunks: Buffer[] = [];
  let size = 0;
  for await (const chunk of req as AsyncIterable<Buffer>) {
    size += chunk.length;
    if (size > 1024 ** 2) throw new HttpError(413, 'request too large');
    chunks.push(chunk);
  }
  // bytes first, text at the end: a character can be split between two chunks
  const raw = Buffer.concat(chunks).toString('utf8');
  if (!raw) return {};
  try { return JSON.parse(raw) as Partial<T>; } catch { throw new HttpError(400, 'not JSON'); }
}

HttpError trägt einen Status, sodass eine Route einfach new HttpError(404, …) werfen kann und der Server daraus an einer Stelle eine Antwort macht. Beachte, wie status als Feld deklariert und im Konstruktor zugewiesen wird: Das ist die Regel der entfernbaren Syntax von oben. send antwortet mit JSON und no-store, damit der Browser nie eine alte Liste zeigt. readJson sammelt den Body einer Anfrage als Bytes und zählt mit: Über 1 MB gibt es mit 413 auf. Erst am Ende werden die Bytes zu Text. In UTF-8 kann ein Zeichen mehrere Bytes brauchen, und ein Body kommt in Stücken an, also kann ein Zeichen auf zwei davon verteilt sein; Stück für Stück dekodiert, käme es kaputt heraus. Auf alles, was kein JSON ist, antwortet es mit 400. readJson gibt ein Partial zurück, denn was ankommt, hat jemand anderes geschrieben: Die Routen prüfen jedes Feld, bevor sie es benutzen.

Die zweite Hälfte liefert Dateien aus:

server/http.ts
const TYPES: Record<string, string> = {
  '.html': 'text/html; charset=utf-8',
  '.css': 'text/css; charset=utf-8',
  '.js': 'text/javascript; charset=utf-8',
  '.json': 'application/json; charset=utf-8',
  '.svg': 'image/svg+xml',
  '.png': 'image/png',
  '.jpg': 'image/jpeg',
  '.jpeg': 'image/jpeg',
  '.webp': 'image/webp',
  '.gif': 'image/gif',
  '.ico': 'image/x-icon',
  '.woff2': 'font/woff2',
  '.txt': 'text/plain; charset=utf-8',
};

export function sendFile(res: http.ServerResponse, file: string, headers: Record<string, string> = {}) {
  res.writeHead(200, { 'content-type': TYPES[path.extname(file).toLowerCase()] ?? 'application/octet-stream', ...headers });
  fs.createReadStream(file).pipe(res);
}

/**
 * The file a URL path points to inside `root`, or null. Decoding and normalizing first, then
 * checking the result is still inside, keeps `/../` and `%2e%2e` out of the rest of the disk.
 */
export function fileIn(root: string, urlPath: string) {
  let rel: string;
  try { rel = decodeURIComponent(urlPath); } catch { return null; }
  let file = path.resolve(root, `.${path.posix.normalize(`/${rel}`)}`);
  if (file !== root && !file.startsWith(root + path.sep)) return null;
  try {
    if (fs.statSync(file).isDirectory()) file = path.join(file, 'index.html');
    return fs.statSync(file).isFile() ? file : null;
  } catch { return null; }
}

sendFile wählt den Content-Type nach der Endung und streamt die Datei. fileIn ist die eine Funktion zwischen einer URL und deiner Festplatte, es lohnt sich also, genau hinzusehen. Ein URL-Pfad ist Text aus dem Browser, und er kann .. enthalten, im Klartext oder kodiert als %2e%2e. Also dekodiert fileIn zuerst. Dann normalisiert es den Pfad, als finge er bei / an, über das man nicht hinauskommt: Aus /../../etc/passwd wird /etc/passwd. Das Ergebnis kommt unter root, und fileIn prüft noch einmal, dass es wirklich darin liegt. Ein Ordner bedeutet die index.html darin, und alles, was keine Datei ist, ergibt null, worauf der Aufrufer mit 404 antwortet.

Die Sites

Jede Site ist ein Ordner in sites/. Beginn server/sites.ts mit den Regeln dafür:

server/sites.ts
import fs from 'node:fs';
import path from 'node:path';
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 Claude Code reads first in every site's folder: what the folder is and how it is built. */
const guide = (s: NewSite) => `# ${s.title}

This folder is a website that Claude Code builds for Sitesmith, a web app that shows it in a preview.

${s.description}

- The site is static: \`index.html\` at the top of this folder, other pages next to it, styles in
  \`style.css\`, scripts in \`script.js\`, pictures and other files in \`assets/\`.
- No build step, no packages and no files from other servers: everything the site needs is in this
  folder, so the preview shows it as it is.
- \`${OWN}/\` belongs to Sitesmith. Requests arrive there; leave the rest of it alone.
`;

NAME erlaubt einen Kleinbuchstaben oder eine Ziffer, danach bis zu 39 weitere davon oder Bindestriche. Der Name einer Site wird zum Ordnernamen, zu einem Teil von URLs und ab Teil 3 zum Namen einer tmux-Sitzung, wo . und : eine eigene Bedeutung haben. Das enge Muster hält alle drei einfach, und der Server prüft jeden Namen, den er bekommt, dagegen. OWN ist der eigene Ordner von Sitesmith in einer Site: Er enthält jetzt site.json und ab Teil 5 die Aufträge.

guide schreibt die CLAUDE.md der Site. Claude Code liest eine CLAUDE.md von selbst, sobald es in einem Ordner startet, also sagt Sitesmith ihm hier, was der Ordner ist: den Titel, die Beschreibung, die du angegeben hast, und drei Hausregeln. Die Site ist statisch und in sich vollständig, weil die Vorschau die Dateien des Ordners so ausliefert, wie sie sind: Kein Build-Schritt läuft, und nichts kommt von anderen Servern. Und .sitesmith/ gehört Sitesmith. Die Datei gehört danach der Site, du kannst sie also ändern wie jede andere.

Der Rest der Datei ist die Klasse, die die Ordner verwaltet:

server/sites.ts
export class Sites {
  readonly root: string;

  constructor(root: string) {
    this.root = root;
    fs.mkdirSync(root, { recursive: true });
  }

  dir(name: string) {
    return path.join(this.root, name);
  }

  read(name: string): Site | null {
    if (!NAME.test(name)) return null;
    try {
      const meta = JSON.parse(fs.readFileSync(path.join(this.dir(name), META), 'utf8')) as Omit<Site, 'name' | 'built'>;
      return { ...meta, name, built: fs.existsSync(path.join(this.dir(name), 'index.html')) };
    } catch { return null; }
  }

  /** The site, or a 404 for the page. */
  get(name: string): Site {
    const site = this.read(name);
    if (!site) throw new HttpError(404, `There is no site called ${name}.`);
    return site;
  }

  /** Newest first. */
  list(): Site[] {
    return fs.readdirSync(this.root)
      .map((name) => this.read(name))
      .filter((s): s is Site => s !== null)
      .sort((a, b) => b.created - a.created);
  }

  create(req: Partial<NewSite>): Site {
    const name = String(req.name ?? '').trim();
    const title = String(req.title ?? '').trim();
    const description = String(req.description ?? '').trim();
    if (!NAME.test(name)) throw new HttpError(400, 'The name needs lowercase letters, digits and dashes (up to 40).');
    if (!title) throw new HttpError(400, 'Give the site a title.');
    const dir = this.dir(name);
    if (fs.existsSync(dir)) throw new HttpError(409, `There is already a site called ${name}.`);
    fs.mkdirSync(path.join(dir, OWN), { recursive: true });
    fs.writeFileSync(path.join(dir, 'CLAUDE.md'), guide({ name, title, description }));
    fs.writeFileSync(path.join(dir, META), `${JSON.stringify({ title, description, created: Date.now() }, null, 2)}\n`);
    return this.get(name);
  }
}
  • read gibt null für alles zurück, was kein gültiger Name ist oder keine lesbare site.json hat. Ein Ordner, den du von Hand in sites/ anlegst, zählt nicht als Site.

  • built wird bei jedem Lesen ermittelt, daraus, ob index.html existiert. Es kann nicht veralten: Claude Code schreibt die Datei, nicht der Server, und niemand muss dem Server Bescheid geben.

  • list gibt alle Sites zurück, die neueste zuerst.

  • create prüft die Felder, lehnt einen vorhandenen Namen mit 409 ab, legt den Ordner mit .sitesmith/ darin an und schreibt CLAUDE.md und site.json.

Der Server

server/main.ts ist das Herz des Servers: seine Optionen, die Live-Updates, die Prüfung, wer fragen darf, die Routen und die Vorschau. Die Datei wächst in fast jedem Teil, deshalb kommt sie hier in Stücken, von oben nach unten. Der Anfang:

server/main.ts
/**
 * Sitesmith's server: the API, live updates over server-sent events, the built page (dist/), and a
 * second server on a port of its own that shows the sites. It listens on this machine only.
 *
 *   node server/main.ts [--port 5400] [--sites ./sites]
 */
import fs from 'node:fs';
import http from 'node:http';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import type { Config, NewSite, ServerEvent } from '../shared/types.ts';
import { HttpError, fileIn, readJson, send, sendFile } from './http.ts';
import { NAME, OWN, Sites } from './sites.ts';

const APP = path.dirname(path.dirname(fileURLToPath(import.meta.url)));

function option(name: string, fallback: string) {
  const i = process.argv.indexOf(name);
  return i > 0 && process.argv[i + 1] ? process.argv[i + 1] : fallback;
}
const PORT = Number(option('--port', '5400'));
const PREVIEW_PORT = PORT + 2;
/** Vite's dev server (`npm run dev`), which forwards /api here */
const DEV_PORT = 5401;
const DIST = path.join(APP, 'dist');

const sites = new Sites(path.resolve(option('--sites', path.join(APP, 'sites'))));
const config: Config = { previewPort: PREVIEW_PORT };

APP ist der Projektordner, ermittelt aus der URL der Datei selbst, damit es egal ist, von wo du den Server startest. option liest --port und --sites von der Kommandozeile; für zwei Optionen lohnt keine Bibliothek. Der Port der Seite ist 5400, der der Vorschau zwei darüber, 5402. Der dazwischen, 5401, gehört Vite. Die Sites landen in sites/ im Projekt, wenn du keinen anderen Ordner angibst.

Als Nächstes die Live-Updates:

server/main.ts
/* ------------------------------------------------------------------ */
/* live updates                                                         */
/* ------------------------------------------------------------------ */

const clients = new Set<http.ServerResponse>();

function broadcast(ev: ServerEvent) {
  const data = `data: ${JSON.stringify(ev)}\n\n`;
  for (const c of clients) c.write(data);
}

/**
 * Claude Code will write the sites' files from its own process, so the folder itself says what
 * changed. A build writes many files at once: one event per site after a quiet moment.
 */
const quiet = new Map<string, NodeJS.Timeout>();
fs.watch(sites.root, { recursive: true }, (_type, file) => {
  const [name, sub] = String(file ?? '').split(path.sep);
  if (!NAME.test(name) || sub === OWN) return;
  clearTimeout(quiet.get(name));
  quiet.set(name, setTimeout(() => {
    quiet.delete(name);
    broadcast({ type: 'files', site: name });
    broadcast({ type: 'sites', sites: sites.list() });
  }, 200));
});

Die Seite muss von Änderungen erfahren, die sie nicht selbst gemacht hat: eine Site, die in einem anderen Tab angelegt wurde, und vor allem die Dateien, die Claude Code schreibt. Das tut es aus seinem eigenen Prozess; der Server bekommt diese Schreibvorgänge nie zu sehen. Zwei Dinge kümmern sich darum.

Server-Sent Events. Jede offene Seite hält eine lange GET-Anfrage offen, und der Server schreibt Zeilen der Form data: <json> in die Antwort. Das ist einfach, es geht nur vom Server zur Seite, und mehr braucht es hier nicht, und die EventSource des Browsers verbindet sich von selbst neu, wenn die Verbindung abreißt. broadcast schreibt ein Ereignis an jede offene Seite.

Eine Überwachung des Ordners. fs.watch mit recursive meldet jede Änderung unterhalb von sites/, egal wer sie gemacht hat. Der erste Teil des geänderten Pfads ist der Name der Site. Änderungen in .sitesmith/ sind die von Sitesmith selbst und werden übersprungen. Ein Build schreibt viele Dateien in kurzer Zeit, deshalb bekommt jede Site einen Timer, der bei jeder Änderung von vorn beginnt. Erst nach 200 Millisekunden Ruhe schickt der Server ein files-Ereignis, das die offene Seite ihre Vorschau neu laden lässt, und eine frische Liste, weil sich built der Site geändert haben kann.

Dann der Teil, der den Server bewacht:

server/main.ts
/* ------------------------------------------------------------------ */
/* who may ask                                                          */
/* ------------------------------------------------------------------ */

/** Where the page comes from: this server, or Vite's dev server. */
const ORIGINS = new Set([PORT, DEV_PORT].flatMap((p) => [`http://localhost:${p}`, `http://127.0.0.1:${p}`]));
const HOSTS = new Set([...ORIGINS].map((o) => new URL(o).host));

/**
 * Only this machine, and only our own page. The Host check stops DNS rebinding (a foreign web site
 * whose name suddenly points to 127.0.0.1); the Origin check stops the pages of other sites, and
 * the previewed sites, from sending us anything but a GET, which changes nothing.
 */
function allowed(req: http.IncomingMessage) {
  if (!HOSTS.has(req.headers.host ?? '')) return false;
  const origin = req.headers.origin;
  return req.method === 'GET' || req.method === 'HEAD' || origin === undefined || ORIGINS.has(origin);
}

Der Server lauscht nur auf 127.0.0.1, kein anderer Computer erreicht ihn also. Aber jede Webseite, die du öffnest, läuft in einem Browser auf diesem Computer, und eine Webseite kann Anfragen an localhost schicken. Diese zwei Prüfungen halten solche Anfragen draußen:

  • Host. Dein Browser nennt im Header Host die Adresse, die er angefragt hat: localhost:5400, oder 5401 über Vite. Ein Trick namens DNS Rebinding geht so: Eine fremde Site lädt ihre Seite und lässt dann ihren eigenen Namen auf 127.0.0.1 zeigen. Die Anfragen ihrer Seite erreichen jetzt deinen Server und gelten als die eigenen der Seite, aber sie sagen weiterhin Host: attacker.example:5400. Sie werden abgelehnt.

  • Origin. Bei jeder Anfrage, die etwas ändern kann, zum Beispiel einem POST, schickt der Browser einen Header Origin mit, der die Seite nennt, von der sie kommt. Nur die Seite von Sitesmith, von 5400 oder 5401, kommt durch. GET und HEAD dürfen passieren: Hier ändern sie nichts, und der Browser lässt eine fremde Seite die Antwort nicht lesen. Eine Anfrage ganz ohne Origin kommt gar nicht von einer Webseite: Sie stammt von curl oder ab Teil 6 von einem der Hooks von Claude Code.

Die Routen:

server/main.ts
/* ------------------------------------------------------------------ */
/* the API                                                              */
/* ------------------------------------------------------------------ */

type Route = [method: string, path: RegExp, handler: (req: http.IncomingMessage, res: http.ServerResponse, m: RegExpMatchArray) => unknown];

const routes: Route[] = [
  ['GET', /^\/api\/config$/, (_req, res) => send(res, 200, config)],
  ['GET', /^\/api\/sites$/, (_req, res) => send(res, 200, sites.list())],
  ['POST', /^\/api\/sites$/, async (req, res) => {
    const site = sites.create(await readJson<NewSite>(req));
    broadcast({ type: 'sites', sites: sites.list() });
    send(res, 201, site);
  }],
  ['GET', /^\/api\/sites\/([^/]+)$/, (_req, res, m) => send(res, 200, sites.get(m[1]))],

  // live updates: one long response per open page, an event per `data:` line
  ['GET', /^\/api\/events$/, (req, res) => {
    res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store' });
    res.write(`data: ${JSON.stringify({ type: 'sites', sites: sites.list() } satisfies ServerEvent)}\n\n`);
    clients.add(res);
    // a comment now and then, so no proxy on the way closes a quiet connection
    const ping = setInterval(() => res.write(': ping\n\n'), 20000);
    req.on('close', () => { clearInterval(ping); clients.delete(res); });
  }],
];

Eine Route ist eine Methode, ein Muster und ein Handler, und der Handler bekommt den Treffer, sodass m[1] der Name der Site ist. Vier Routen liefern die Konfiguration, listen die Sites auf, legen eine an und liefern eine. Das Anlegen verschickt die neue Liste, damit jede offene Seite die neue Site zeigt, auch die, die sie angelegt hat.

/api/events ist der Stream. Seine Antwort endet nie: Sie beginnt mit dem Typ text/event-stream und der aktuellen Liste, damit eine Seite, die sich gerade verbunden hat oder nach einem Neustart des Servers neu verbunden ist, von der Wahrheit ausgeht. Dann kommt die Antwort zu clients. Eine Kommentarzeile (: ping) alle 20 Sekunden hält alles auf dem Weg, etwa einen Proxy, davon ab, eine stille Verbindung zu schließen. Geht die Seite weg, nimmt close sie wieder heraus.

Der Server, der all das benutzt:

server/main.ts
const server = http.createServer(async (req, res) => {
  const url = new URL(req.url ?? '/', 'http://localhost');
  try {
    if (!allowed(req)) throw new HttpError(403, 'forbidden');
    if (url.pathname.startsWith('/api/')) {
      const route = routes.find(([method, re]) => method === req.method && re.test(url.pathname));
      if (!route) throw new HttpError(404, 'not found');
      await route[2](req, res, url.pathname.match(route[1])!);
      return;
    }
    // the page: its built files, and index.html for every other address
    if (!fs.existsSync(path.join(DIST, 'index.html'))) {
      throw new HttpError(503, `The page is not built: run npm run build, or use the dev server on port ${DEV_PORT}.`);
    }
    sendFile(res, fileIn(DIST, url.pathname) ?? path.join(DIST, 'index.html'), { 'cache-control': 'no-cache' });
  } catch (err) {
    const status = err instanceof HttpError ? err.status : 500;
    if (status === 500) console.error(err);
    if (!res.headersSent) send(res, status, { error: err instanceof Error ? err.message : String(err) });
    else res.end();
  }
});

Jede Anfrage geht zuerst durch allowed. Pfade unter /api/ gehen an die erste Route, die zu Methode und Pfad passt, oder bekommen eine 404. Alles andere ist die Seite: die Datei aus dist/, falls es eine gibt, sonst index.html. Ist die Seite nicht gebaut, sagt eine 503, was zu tun ist. Fehler werden an einer Stelle zu Antworten: Ein HttpError wird zu seinem Status und seiner Meldung als JSON, die die Seite so anzeigt, wie sie ist; alles andere wird zu einer 500 und landet auch in der Konsole. Hatte die Antwort schon begonnen, wie beim Event-Stream, wird sie nur beendet.

Die Vorschau

Das letzte Stück der Datei liefert die Sites aus:

server/main.ts
/* ------------------------------------------------------------------ */
/* the preview                                                          */
/* ------------------------------------------------------------------ */

const PREVIEW_HOSTS = new Set([`localhost:${PREVIEW_PORT}`, `127.0.0.1:${PREVIEW_PORT}`]);
const MISSING = '<!doctype html><meta charset="utf-8"><title>Not here</title><body style="font:15px system-ui;color:#888;padding:2rem">Nothing here (yet).</body>';

/** Whether a path names a hidden file or folder: decoded first, %2e is a dot and %2f a slash too. */
function hiddenPath(urlPath: string) {
  try { return decodeURIComponent(urlPath).split('/').some((part) => part.startsWith('.')); } catch { return true; }
}

/**
 * The sites, at /<name>/ on a port of their own. A site is code Claude Code wrote: served from the
 * page's own address, its scripts could call the API just like the page does. From another port
 * it is another origin, and allowed() turns it away. Hidden files (.sitesmith/ with the requests)
 * are not shown.
 */
const preview = http.createServer((req, res) => {
  const url = new URL(req.url ?? '/', 'http://localhost');
  const [, name = '', ...rest] = url.pathname.split('/');
  const site = PREVIEW_HOSTS.has(req.headers.host ?? '') ? sites.read(name) : null;
  // /<name> without the slash: the site's relative links need it
  if (site && !rest.length) { res.writeHead(302, { location: `/${name}/` }); res.end(); return; }
  const file = site && !hiddenPath(rest.join('/')) ? fileIn(sites.dir(name), rest.join('/')) : null;
  if (!file) { res.writeHead(404, { 'content-type': 'text/html; charset=utf-8' }); res.end(MISSING); return; }
  sendFile(res, file, { 'cache-control': 'no-store' });
});

Die Sites sind die Arbeit von Claude Code: HTML, CSS und JavaScript, das in deinem Browser läuft, wenn du sie ansiehst. Von der eigenen Adresse der Seite ausgeliefert, etwa unter localhost:5400/sites/…, stünde das Skript einer Site genau dort, wo die Seite von Sitesmith steht. Es könnte Anfragen an die API schicken, Sites anlegen und ab Teil 5 Aufträge in Claude Code tippen. Die Origin-Prüfung ließe das alles durch, denn der Origin wäre der der Seite.

Deshalb bekommen die Sites einen eigenen Server, auf Port 5402. Für einen Browser ist ein anderer Port ein anderer Origin: Das Skript einer Site kann weder die Seite noch die Antworten der API lesen, und allowed weist alles ab, was es schickt. Der Rest des Vorschau-Servers:

  • Er prüft ebenfalls den Header Host, gegen denselben Rebinding-Trick.

  • Eine URL ist /<name>/<pfad>, und der Name muss eine Site sein. /harbor-books ohne Schrägstrich wird auf /harbor-books/ umgeleitet: Eine Seite unter der ersten Adresse, deren Link style.css sagt, würde /style.css laden; mit dem Schrägstrich lädt sie /harbor-books/style.css.

  • Ein Pfad mit einem Teil, der mit einem Punkt beginnt, wird abgelehnt, damit .sitesmith/ und andere versteckte Dateien nicht in der Vorschau auftauchen. hiddenPath dekodiert den ganzen Pfad, bevor es hinsieht, denn auch %2e ist ein Punkt und %2f ein Schrägstrich: /harbor-books/%2esitesmith/ oder /harbor-books/x%2f.sitesmith%2fsite.json kämen an einer Prüfung des rohen Pfads vorbei. Ein Pfad, der sich nicht dekodieren lässt, gilt als versteckt.

  • fileIn erledigt den Rest, und no-store sorgt dafür, dass der Browser die Datei immer so lädt, wie sie jetzt ist: Claude Code hat sie vielleicht vor einer Sekunde geändert.

Das Ende der Datei startet beide Server:

server/main.ts
server.listen(PORT, '127.0.0.1', () => console.log(`Sitesmith: http://localhost:${PORT}/`));
preview.listen(PREVIEW_PORT, '127.0.0.1');

function shutdown() {
  for (const c of clients) c.end();
  server.close();
  preview.close();
  setTimeout(() => process.exit(0), 300).unref();
}
process.on('SIGINT', shutdown);
process.on('SIGTERM', shutdown);

Beide lauschen auf 127.0.0.1, kein anderer Computer in deinem Netz erreicht sie also; Teil 16 öffnet das mit Absicht, mit einem Token. shutdown läuft bei Strg+C: Es beendet zuerst die Event-Streams, weil server.close() sonst ewig auf sie warten würde, und beendet den Prozess spätestens nach 300 Millisekunden.

Die Seite

Die Seite ist schlichtes TypeScript, ohne Framework: eine Handvoll Klassen, von denen jede ein Stück der Seite besitzt, und ein Helfer, der Elemente baut. Fang mit dem Helfer an, src/dom.ts:

src/dom.ts
type Child = Node | string | null | undefined | false;
type Props = Record<string, unknown>;

/**
 * Creates an element: h('button', { class: 'primary', onclick: go }, 'Build it').
 * `on…` functions become listeners, known properties are set as properties, the rest as
 * attributes; null, undefined and false leave a prop or a child out.
 */
export function h<K extends keyof HTMLElementTagNameMap>(tag: K, props: Props = {}, ...children: Child[]): HTMLElementTagNameMap[K] {
  const el = document.createElement(tag);
  for (const [key, value] of Object.entries(props)) {
    if (value === undefined || value === null || value === false) continue;
    if (key === 'class') el.className = String(value);
    else if (key.startsWith('on') && typeof value === 'function') el.addEventListener(key.slice(2), value as EventListener);
    else if (key in el && !key.includes('-')) (el as unknown as Record<string, unknown>)[key] = value;
    else el.setAttribute(key, value === true ? '' : String(value));
  }
  el.append(...children.filter((c): c is Node | string => c !== null && c !== undefined && c !== false));
  return el;
}

h(tag, props, ...children) erzeugt ein Element. class wird zum Klassennamen, und eine Funktion unter einem Namen, der mit on beginnt, wird zu einem Event-Listener: onclick hört auf click. Ein Name, den das Element als Property kennt, etwa value, hidden oder maxLength, wird als diese Property gesetzt, also versteckt hidden: true das Element. Alles andere, zum Beispiel aria-label, wird zum Attribut. null, undefined und false lassen eine Prop oder ein Kind weg, sodass cond ? x : null direkt funktioniert. Strings werden zu Text, nie zu HTML: Der Titel einer Site kann kein Markup in die Seite schmuggeln.

src/api.ts redet mit dem Server:

src/api.ts
import type { ServerEvent } from '../shared/types.ts';

/** A call to the server's API; its error message, if it sends one, becomes the Error's. */
export async function api<T>(method: string, url: string, body?: unknown): Promise<T> {
  const res = await fetch(url, {
    method,
    headers: body === undefined ? {} : { 'content-type': 'application/json' },
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  const data = await res.json().catch(() => ({}));
  if (!res.ok) throw new Error((data as { error?: string }).error ?? `${method} ${url}: HTTP ${res.status}`);
  return data as T;
}

/** Server-sent events. EventSource reconnects by itself after a lost connection. */
export function events(onEvent: (ev: ServerEvent) => void, onLost: () => void, onBack: () => void) {
  const source = new EventSource('/api/events');
  source.onmessage = (m) => onEvent(JSON.parse(m.data) as ServerEvent);
  source.onerror = onLost;
  source.onopen = onBack;
  return source;
}

api schickt JSON und gibt JSON zurück. Lehnt der Server ab, wird seine Meldung zu der des Fehlers, sodass die Seite „There is already a site called harbor-books.“ genau so zeigen kann, wie der Server es geschrieben hat. events öffnet den Stream; onLost läuft, wenn die Verbindung abreißt, onBack, wenn sie wieder steht. Das Neuverbinden selbst erledigt der Browser.

src/main.ts setzt die Seite zusammen:

src/main.ts
import './style.css';
import { api, events } from './api.ts';
import { h } from './dom.ts';
import { newSiteForm } from './newSite.ts';
import { Sidebar } from './sidebar.ts';
import { SitePage } from './sitePage.ts';
import type { Config, ServerEvent, Site } from '../shared/types.ts';

/**
 * The page: the sites on the left, the open one on the right. Addresses: #new, #site/<name>.
 * Everything that changes comes from the server's events, whoever changed it.
 */
async function start() {
  const config = await api<Config>('GET', '/api/config');
  const sidebar = new Sidebar();
  const main = h('main', { class: 'main' });
  const offline = h('p', { class: 'offline', hidden: true }, 'The server is not answering. Waiting for it…');
  document.querySelector('#app')!.append(sidebar.el, main, offline);

  let sites: Site[] = [];
  let page: SitePage | null = null;

  function route() {
    const hash = decodeURIComponent(location.hash.slice(1));
    const name = hash.startsWith('site/') ? hash.slice(5) : '';
    if (page && page.name === name) return;
    page?.dispose();
    page = null;
    if (hash === 'new') main.replaceChildren(newSiteForm((site) => { location.hash = `site/${site.name}`; }));
    else if (name) {
      page = new SitePage(name, config);
      page.update(sites);
      main.replaceChildren(page.el);
    } else {
      main.replaceChildren(h('div', { class: 'welcome' },
        h('h1', {}, 'Describe a site, Claude Code builds it.'),
        h('p', {}, 'Pick a site on the left, or start a new one.'),
        h('a', { class: 'button primary', href: '#new' }, 'New site')));
    }
    sidebar.render(sites, name);
  }

  function onEvent(ev: ServerEvent) {
    if (ev.type === 'sites') {
      sites = ev.sites;
      sidebar.render(sites, page?.name ?? '');
      page?.update(sites);
    } else if (ev.type === 'files' && ev.site === page?.name) page.filesChanged();
  }

  events(onEvent, () => { offline.hidden = false; }, () => { offline.hidden = true; });
  window.addEventListener('hashchange', route);
  route();
}

void start();

Die Adressen der Seite sind Hashes: #new ist das Formular für eine neue Site, #site/<name> eine Site, alles andere die Begrüßung. Ein Wechsel des Hashs lädt nichts vom Server, und ein Neuladen oder ein Lesezeichen kommt an dieselbe Stelle zurück. route baut, was die Adresse verlangt, lässt eine offene Site aber in Ruhe, wenn die Adresse sie noch nennt.

onEvent ist nach dem Start der einzige Weg, auf dem Daten hereinkommen. Eine neue Liste ersetzt die alte überall, und ein files-Ereignis erreicht die Seite dieser Site. Die Seite aktualisiert sich nie selbst nach ihren eigenen Aktionen: Legt sie eine Site an, kommt die neue Liste über dasselbe Ereignis zurück, das jede andere offene Seite bekommt. Mit nur einem Weg hinein können zwei Tabs nicht uneins sein. Der Hinweis offline erscheint, solange der Stream weg ist.

Die Liste links ist src/sidebar.ts:

src/sidebar.ts
import { h } from './dom.ts';
import type { Site } from '../shared/types.ts';

/** The list of sites on the left, and the way to a new one. */
export class Sidebar {
  readonly el: HTMLElement;
  private list = h('nav', { class: 'site-list', 'aria-label': 'Sites' });

  constructor() {
    this.el = h('aside', { class: 'sidebar' },
      h('a', { class: 'brand', href: '#' }, h('span', { class: 'brand-mark', 'aria-hidden': 'true' }), 'Sitesmith'),
      h('a', { class: 'button primary', href: '#new' }, 'New site'),
      this.list);
  }

  render(sites: Site[], current: string) {
    this.list.replaceChildren(...sites.map((s) => h('a', {
      class: 'site-link',
      href: `#site/${s.name}`,
      'aria-current': s.name === current ? 'page' : null,
    }, h('span', { class: 'site-title' }, s.title), h('span', { class: 'site-name' }, s.name))));
    if (!sites.length) this.list.append(h('p', { class: 'hint' }, 'No sites yet.'));
  }
}

Der Name der App, der Button für eine neue Site und ein Link für jede Site mit Titel und Namen. aria-current markiert die geöffnete, fürs Stylesheet und für Screenreader. render läuft bei jeder neuen Liste.

Das Formular für eine neue Site, src/newSite.ts:

src/newSite.ts
import { api } from './api.ts';
import { h } from './dom.ts';
import type { NewSite, Site } from '../shared/types.ts';

/** "Mara's Bakery & Café" -> "maras-bakery-cafe" */
const slug = (title: string) => title.toLowerCase().normalize('NFKD').replace(/[\u0300-\u036f'’]/g, '')
  .replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40).replace(/-+$/, '');

function field(label: string, input: HTMLElement, hint?: string) {
  return h('label', { class: 'field' }, h('span', { class: 'field-label' }, label), input, hint ? h('span', { class: 'hint' }, hint) : null);
}

/** The form for a new site: a title, its folder name (filled in from the title) and what it is about. */
export function newSiteForm(onCreated: (site: Site) => void) {
  const title = h('input', { required: true, maxLength: 80, autocomplete: 'off', placeholder: 'Mara’s Bakery' });
  const name = h('input', { required: true, maxLength: 40, pattern: '[a-z0-9][a-z0-9\\-]*', autocomplete: 'off', placeholder: 'maras-bakery' });
  const description = h('textarea', { rows: 6, placeholder: 'A small bakery in Graz: opening hours, the breads of the week, how to order a cake…' });
  const msg = h('p', { class: 'hint bad', 'aria-live': 'polite' });
  let ownName = false;
  title.oninput = () => { if (!ownName) name.value = slug(title.value); };
  name.oninput = () => { ownName = true; };

  const form = h('form', { class: 'panel new-site' },
    h('h1', {}, 'A new site'),
    field('Title', title),
    field('Name', name, 'Its folder and its address: lowercase letters, digits and dashes.'),
    field('What is it about?', description, 'Claude Code reads this before it builds anything.'),
    h('div', { class: 'actions' }, h('button', { type: 'submit', class: 'primary' }, 'Create the site')),
    msg);
  form.onsubmit = async (e) => {
    e.preventDefault();
    msg.textContent = '';
    const body: NewSite = { name: name.value, title: title.value, description: description.value };
    try { onCreated(await api<Site>('POST', '/api/sites', body)); } catch (err) { msg.textContent = (err as Error).message; }
  };
  requestAnimationFrame(() => title.focus());
  return form;
}

Drei Felder. Der Name füllt sich aus dem Titel, über slug: Kleinbuchstaben; NFKD zerlegt ein é in ein e und einen Akzent, und das erste replace wirft die Akzente (die Zeichen von U+0300 bis U+036F) zusammen mit Apostrophen hinaus, geraden wie typografischen, damit aus „Mara’s Bakery“ maras-bakery wird und nicht mara-s-bakery; alles andere, was kein Buchstabe und keine Ziffer ist, wird zum Bindestrich, und das Ergebnis wird auf 40 Zeichen gekürzt. Tippst du selbst ins Namensfeld, folgt es dem Titel nicht mehr. pattern lässt den Browser auf einen falschen Namen hinweisen, bevor etwas verschickt wird. Der Server prüft trotzdem noch einmal, und seine Meldung landet unter dem Formular. Ist die Site angelegt, wechselt die Adresse zu ihr.

Zuletzt die Seite einer Site, src/sitePage.ts:

src/sitePage.ts
import { h } from './dom.ts';
import type { Config, Site } from '../shared/types.ts';

/** One site: what it is about, and the site itself in a frame. */
export class SitePage {
  readonly el: HTMLElement;
  readonly name: string;
  private config: Config;
  private site: Site | null = null;
  private heading = h('h1', { class: 'site-heading' });
  private about = h('p', { class: 'site-about' });
  private frame = h('iframe', { class: 'preview-frame', title: 'The site', sandbox: 'allow-scripts allow-same-origin allow-forms allow-popups' });
  private empty = h('div', { class: 'preview-empty' }, h('p', {}, 'Nothing built yet.'));

  constructor(name: string, config: Config) {
    this.name = name;
    this.config = config;
    this.el = h('section', { class: 'site-page' },
      h('header', { class: 'site-head' },
        h('div', { class: 'site-head-text' }, this.heading, this.about),
        h('a', { class: 'button small', href: this.previewUrl, target: '_blank', rel: 'noopener' }, 'Open in a new tab')),
      h('div', { class: 'preview' }, this.frame, this.empty));
  }

  /**
   * The site on the preview server: the same host name as the page (so it also works when the
   * page is opened from another machine later), but its own port.
   */
  get previewUrl() {
    return `${location.protocol}//${location.hostname}:${this.config.previewPort}/${this.name}/`;
  }

  /** The list of sites changed (or arrived). */
  update(sites: Site[]) {
    const site = sites.find((s) => s.name === this.name) ?? null;
    const wasBuilt = this.site?.built;
    this.site = site;
    this.heading.textContent = site?.title ?? this.name;
    this.about.textContent = site ? site.description : 'There is no site of this name.';
    this.frame.hidden = !site?.built;
    this.empty.hidden = Boolean(site?.built);
    if (site?.built && !wasBuilt) this.frame.src = this.previewUrl;
  }

  /** Files of this site changed on disk: show the new state. */
  filesChanged() {
    // setting src again navigates the frame again, even to the same address
    if (this.site?.built) this.frame.src = this.previewUrl;
  }

  dispose() {}
}

Ein Kopf mit dem Titel, der Beschreibung und einem Link, der die Site in einem neuen Tab öffnet, darunter die Vorschau: ein Frame auf dem Vorschau-Server oder „Nothing built yet“. previewUrl nimmt den Hostnamen der Seite mit dem Port der Vorschau, damit sie auch funktioniert, wenn die Seite in Teil 16 von einem anderen Computer aus geöffnet wird. update läuft bei jeder Liste. Es zeigt den Frame, sobald die Site gebaut ist, und lädt ihn in dem Moment, in dem sie es wird. filesChanged setzt src neu, was den Frame auch bei derselben Adresse neu lädt. dispose ist vorerst leer; spätere Teile schließen dort die Verbindung des Terminals.

Der Frame ist eine Sandbox mit vier Erlaubnissen: Skripte, sein eigener Origin, Formulare und Pop-ups. Ein Frame in einer Sandbox ohne allow-same-origin bekommt einen anonymen Origin, ohne Speicher und Cookies, und eine Site, die sie benutzt, geht kaputt. Hier ist es sicher, das zu erlauben, weil der Origin des Frames der der Vorschau ist und nicht der der Seite. Auf dem eigenen Origin der Seite würden Skripte und Same-Origin zusammen den Frame seine eigene Sandbox aufheben lassen. Was die Sandbox weiterhin verhindert: Die Site kann den Tab von Sitesmith nicht woandershin navigieren, und sie kann keine Dialoge wie alert öffnen.

Bauen und starten

Wenn alle Dateien da sind und style.css aus dem Download in src/ liegt, prüf die Typen und bau die Seite:

~/sitesmith
$ npx tsc --noEmit$ npm run build> sitesmith@1.0.0 build> vite buildvite v8.3.8 building client environment for production...transforming...✓ 10 modules transformed.rendering chunks...computing gzip size...dist/index.html                  0.67 kB │ gzip: 0.43 kBdist/assets/index-BeBPfUyA.css  11.57 kB │ gzip: 3.35 kBdist/assets/index-DxC1l3U9.js    5.30 kB │ gzip: 2.45 kB✓ built in 129ms

Der Compiler sagt nichts, wenn alles stimmt, und Vite baut die Seite zu etwa 5 kB JavaScript und 12 kB CSS. Es gibt zwei Wege, Sitesmith zu starten:

~/sitesmith
# working on the page: the server in one terminal …$ npm run server# … and Vite in a second one, then open http://localhost:5401$ npm run dev# or build the page once and let the server serve it at http://localhost:5400$ npm start

Wenn du an der Seite arbeitest, lass den Server und Vite nebeneinander laufen und öffne http://localhost:5401: Die Seite lädt bei jeder Änderung neu, den Server startest du nach einer Änderung an seinem Code von Hand neu (Strg+C, dann wieder starten). Wenn du die App nur benutzt, baut npm start die Seite einmal und liefert alles unter http://localhost:5400 aus. Öffne sie und klick auf New site:

Das Formular für eine neue Site: der Titel, der aus dem Titel gebildete Name und worum es auf der Site geht. Die Seitenleiste zeigt schon Sites aus späteren Teilen der Serie.

Leg die Site an. Ihr Ordner erscheint in sites/, mit CLAUDE.md und .sitesmith/site.json, und die Seite zeigt „Nothing built yet“. Claude Code baut bis Teil 5 nichts, aber der Vorschau ist egal, wer die Dateien schreibt. Schreib eine index.html von Hand:

~/sitesmith
$ echo '<h1>Harbor Books</h1><p>Written by hand, for now.</p>' > sites/harbor-books/index.html

Einen Moment später zeigt der Frame sie an: Die Ordnerüberwachung hat die neue Datei bemerkt, der Server hat ein files-Ereignis und eine neue Liste geschickt, und die Seite hat die Vorschau geladen. Hat eine Site echten Inhalt, sieht das so aus:

Eine Site in der Vorschau: das Lumen Café, von Claude Code in einem späteren Teil der Serie gebaut, wie die anderen Sites in der Seitenleiste auch. Eine von Hand geschriebene index.html erscheint jetzt schon genauso.Den Screenshot in voller Größe öffnen
Eine Site in der Vorschau: das Lumen Café, von Claude Code in einem späteren Teil der Serie gebaut, wie die anderen Sites in der Seitenleiste auch. Eine von Hand geschriebene index.html erscheint jetzt schon genauso.

Was du jetzt hast

Einen Server, der jede Site in einem Ordner mit eigener CLAUDE.md verwaltet, jeder offenen Seite sagt, was sich geändert hat, nur seine eigene Seite hereinlässt und die Sites von einem eigenen Origin aus zeigt. Und eine Seite aus ein paar kleinen Klassen, die die Sites auflistet und sie zeigt, während sich ihre Dateien ändern.

Was fehlt, ist der, der baut. Im nächsten Teil zieht Claude Code ein: eine tmux-Sitzung pro Site, gestartet und beendet aus dem Kopf der Site.

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.