Claude Code in deiner eigenen Web-App · Teil 5 von 16 der Serie
Teil 5: Einen Auftrag eintippen
Lass die Seite Aufträge schicken: Der Text kommt in eine Datei im Ordner der Site, und Sitesmith tippt eine kurze Zeile in Claude Code, aber erst, wenn der Bildschirm ein leeres Eingabefeld zeigt.
Claude Code in deiner eigenen Web-AppTeil 5 von 16
Auf dieser Seite
Quest-Ziele
- Claude Code einen Auftrag beliebiger Länge über eine Datei und eine kurze Zeile übergeben
- Den Bildschirm von Claude Code samt Farben lesen, um ein leeres Eingabefeld von allem anderen zu unterscheiden
- In eine Sitzung tippen, ohne aus Versehen einen Dialog zu beantworten
- Läufe pro Site führen: eine Warteschlange, eine Zustellung zur Zeit, ein Status für die Seite
- Allein am Bildschirm erkennen, wann eine Runde vorbei ist, und sehen, wo das nicht reicht
- Eine erste Site aus der Seite heraus bauen
Die Seite zeigt die Sitzung jeder Site und lässt dich hineintippen. Jetzt tippt Sitesmith: Ein Feld neben der Vorschau nimmt auf, was du willst, Build the site schickt es ab, und ein Panel unter dem Feld zeigt, wie Claude Code vorankommt.
Von außen in ein Terminalprogramm zu tippen ist einfach, das hat Teil 1 gezeigt: send-keys, dann Enter. Schwierig ist der Moment. Claude Code wartet nicht immer auf eine Nachricht, und Tasten, die ankommen, während es etwas anderes zeigt, gelten als Antwort darauf. Der größte Teil dieses Teils dreht sich um eine Frage: Kann ich jetzt gefahrlos tippen?
Der Auftrag reist in einer Datei
Ein Auftrag aus der Seite kann lang sein und mehrere Zeilen haben. In Claude Code getippt, wäre jeder Zeilenumbruch ein Enter, das abschickt, was davor stand, und ein langer Text, der auf einmal ankommt, sieht für Claude Code wie eingefügt aus. Beides willst du nicht, und beides hängt davon ab, wie das Claude Code von heute mit seiner Eingabe umgeht.
Deshalb tippt Sitesmith den Auftrag nicht. Es schreibt ihn nach .sitesmith/request.md im Ordner der Site und tippt jedes Mal dieselbe kurze Zeile: Do what .sitesmith/request.md says.
Claude Code liest die Datei mit seinem Werkzeug Read, wie jede andere Datei. Deine Worte gehen nie über die Tastatur, also kann nichts darin für eine Taste oder einen Befehl gehalten werden: Ein Auftrag, der mit / oder ! beginnt, ist einfach Text in einer Datei. Der Ordner .sitesmith/ gehört Sitesmith seit Teil 2, und der Vorschau-Server zeigt keine versteckten Ordner.
Der Text um deine Worte herum kommt aus einer neuen Datei, server/requests.ts:
import type { Site } from '../shared/types.ts';
/** The page's name for a run of this site. */
export const runTitle = (site: Site) => (site.built ? 'Changing the site' : 'Building the site');
/**
* 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) {
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)'}
When you are done, say in two or three sentences what you built or changed.
`;
}Eine neue Site bekommt „bau die erste Version“, mit einem Verweis auf CLAUDE.md, wo Teil 2 Titel und Beschreibung der Site hineingeschrieben hat. Eine Site mit index.html bekommt „ändere die Site“. Ein leeres Feld geht auch: Dann entscheidet Claude Code selbst. Die letzte Zeile bittet am Ende um einen kurzen Bericht, den Teil 7 in der Seite zeigen wird.
Wann ist Tippen sicher?
Claude Code zeigt neben seinem Eingabefeld vieles, und manches davon nimmt Tasten an. Zwei davon begegnen dir in diesem Teil, der Vertrauensdialog eines neuen Ordners und eine Berechtigungsabfrage:
# The trust dialog of a folder Claude Code has never seen: Enter picks "No, exit" Accessing workspace: ~/sitesmith/sites/maras-bakery Quick safety check: Is this a project you created or one you trust? (Like your own code, a well-known open source project, or work from your team). If not, take a moment to review what's in this folder first. Claude Code'll be able to read, edit, and execute files here. Security guide ❯ No, exit Yes, I trust this folder Enter to confirm · Esc to cancel# A permission prompt: Enter says "Yes" Bash command Syntax-check the script and list files (node --check script.js && echo "JS ok") ; ls -la . assets 2>/dev/null This command uses shell operators that require approval for safety Do you want to proceed? ❯ 1. Yes 2. Yes, and switch to auto mode · auto mode handles these prompts for you 3. No Esc to cancel · Tab to amend
Beide haben ein ❯ vor der gewählten Option, und beide nehmen Enter als „die hier“. Im Vertrauensdialog würde die Zeile von Sitesmith mit einem Enter auf No, exit enden, und Claude Code würde sich beenden. In der Berechtigungsabfrage würde das Enter Yes zu einem Befehl sagen, den niemand gelesen hat. Tasten, die ankommen, während Claude Code arbeitet, sind nicht besser: Sie landen mitten in seiner Arbeit in seinem Eingabefeld.
Bleibt ein einziger sicherer Moment: Claude Code wartet an einem leeren Eingabefeld. So sieht das am Ende einer Runde aus, und das steht auf dem Bildschirm, wenn du auch seine Farben ansiehst:
# The bottom of the screen at the end of a turn: the input box, between two rules✻ Brewed for 27s · done 13:33────────────────────────────────────────────────────────────❯────────────────────────────────────────────────────────────# An empty box as capture-pane -e shows it, made visible with cat -v: the hint is dim (^[[2m)^[[39m❯ ^[[2mTry "write a test for <filepath>"^[[0m# Claude Code may offer your last prompt in an empty box, dim as well: the box counts as empty^[[39m❯ ^[[2mDo what .sitesmith/request.md says.^[[0m
Drei Dinge fallen auf. Das Eingabefeld ist eine Zeile, die mit ❯ beginnt, mit einer Linie aus ─ direkt darüber und direkt darunter; die Dialoge haben auch ein ❯, aber nie zwischen zwei Linien. Ein leeres Feld ist auf dem Bildschirm oft nicht leer: Claude Code zeigt einen Hinweis (Try "…") oder bietet deine letzte Eingabe noch einmal an. Und dieser Text ist blass: Er beginnt mit ESC[2m, der Escape-Sequenz für schwachen Text (SGR 2), während getippter Text normal gezeichnet wird. Ohne Farben sehen ein Hinweis und ein getippter Text gleich aus. Mit ihnen nicht.
Das reicht für eine Prüfung. Füg in server/terminals.ts unter den Konstanten oben zwei Helfer ein:
/** Claude Code's input box sits between two rules of ─ */
const RULE = /^─{10,}$/;
/** a screen line without its colours */
const plain = (line: string) => line.replace(/\x1b\[[0-9;:]*m/g, '').trim();Und nach end() zwei kleine Methoden und die Prüfung selbst:
/** The screen as text, without colours. */
screen(t: { name: string }) {
return this.tmux('capture-pane', '-p', '-t', pane(t.name));
}
/** Keys by tmux's names: Escape, Enter, Down, BTab (Shift+Tab)… */
async keys(t: { name: string }, ...keys: string[]) {
await this.tmux('send-keys', '-t', pane(t.name), ...keys);
}/**
* Whether Claude Code waits at an empty input box, the only safe moment to type: keys sent at
* anything else would answer it (Enter approves a permission prompt). The box is the last ❯ line
* between two rules; its dialogs have a ❯ too, but not between rules. A hint in an empty box is
* dim (SGR 2), typed text is not. Anything else on screen counts as "not ready", so a changed
* look of Claude Code makes Sitesmith wait rather than guess.
*/
async atEmptyPrompt(t: { name: string }) {
const lines = (await this.tmux('capture-pane', '-p', '-e', '-t', pane(t.name))).split('\n');
const box = lines.findLast((line, i) => plain(line).startsWith('❯')
&& RULE.test(plain(lines[i - 1] ?? '')) && RULE.test(plain(lines[i + 1] ?? '')));
if (box === undefined) return false;
const rest = box.slice(box.indexOf('❯') + 1).replace(/^[\s\u00a0]+/, '');
return !plain(rest) || rest.startsWith('\x1b[2m');
}screen() liefert den Bildschirm als einfachen Text; Teil 10 liest damit Dialoge. keys() schickt Tasten mit ihren tmux-Namen, etwa Escape für den Stop-Knopf weiter unten. atEmptyPrompt() geht in vier Schritten vor:
Den Bildschirm mit Farben holen.
capture-pane -pgibt aus, was der Bereich gerade zeigt, eine Zeile pro Bildschirmzeile, und-elässt die Escape-Sequenzen für Farben und Stile drin. Der Scrollback über dem Bildschirm gehört nicht dazu, das unterste Feld auf dem Bildschirm ist also das aktuelle.Das Feld finden.
findLastsucht die unterste Zeile, die ohne ihre Farben mit❯beginnt und direkt darüber und darunter eine Linie aus mindestens zehn─hat. Deine früheren Nachrichten im Gespräch beginnen auch mit❯, aber um sie stehen keine Linien, und um die Optionen eines Dialogs auch nicht.Kein Feld, kein Tippen. Passt keine Zeile, lautet die Antwort
false. Ein Dialog, ein Bildschirm mitten im Neuzeichnen, ein beendetes Claude Code: Alles das landet hier.Ansehen, was auf das
❯folgt. Die Leerzeichen danach fallen weg, auch geschützte. Bleiben nur Farbcodes übrig, ist das Feld leer. Beginnt der Rest mit der blassen Sequenz\x1b[2m, ist es ein Hinweis oder ein Vorschlag, und das Feld ist ebenfalls leer. Alles andere ist Text, den jemand getippt hat, vielleicht du im Tab Terminal, und Sitesmith tippt nicht darüber.
Beachte, was die Prüfung nicht tut: Sie versucht nicht, Dialoge zu erkennen. Sie erkennt genau eine Sache, das leere Feld, und behandelt alles andere als „nicht jetzt“. Zeichnet eine neue Version von Claude Code ihr Feld anders, tippt Sitesmith nichts und wartet. Ein Auftrag, der wartet, ist lästig. Tasten, die die falsche Frage beantworten, können Schaden anrichten.
Ist das Feld leer, schickt type() die Zeile. Füg es nach atEmptyPrompt() ein:
/**
* Types one short line into Claude Code's input box and sends it. Only call it at an empty
* prompt. A long or multi-line text would arrive as a paste, so requests travel in a file.
*/
async type(t: { name: string }, line: string) {
// out of scroll mode first, where the first key only returns to the live screen
await this.tmux('copy-mode', '-q', '-t', pane(t.name)).catch(() => undefined);
await this.tmux('send-keys', '-t', pane(t.name), '-l', line);
// a moment for the input box to take the text, or Enter can arrive first
await new Promise((r) => setTimeout(r, 300));
await this.tmux('send-keys', '-t', pane(t.name), 'Enter');
}Zuerst
copy-mode -q. Hat jemand die Sitzung in der Seite zurückgescrollt, ist tmux im Copy-Modus, in dem eine Taste nur zum laufenden Bildschirm zurückführt (Teil 4), und der erste Buchstabe der Zeile ginge verloren.-qverlässt den Copy-Modus. Sollte der Befehl scheitern, sorgt dascatchdafür, dass der Auftrag trotzdem weitergeht.send-keys -lschickt den Text wörtlich. Ohne-lwürde tmux ein Argument, das der Name einer Taste ist, etwaEnter, als diese Taste lesen.Vor dem Enter kommt eine Pause von 300 Millisekunden. Das Eingabefeld braucht einen Moment, um den Text aufzunehmen, und ein Enter, das zu früh kommt, kann ihn überholen: Die Zeile steht dann im Feld und ist nicht abgeschickt.
Läufe
Ein Auftrag aus der Seite wird zu einem Lauf: Er wartet, bis Claude Code frei ist, geht hinein, wird bearbeitet und endet. Die Seite muss wissen, wo jeder Lauf steht. Füg in shared/types.ts nach TerminalState drei Typen ein und erweitere ServerEvent um den Zustand des Agenten:
/** A request from the page, from the moment it is asked until Claude Code's turn is over. */
export interface Run {
id: string;
title: string;
/**
* queued: waits until Claude Code is free; starting: typed in (or the session is starting);
* working: Claude Code works on it; then done, stopped or failed
*/
status: 'queued' | 'starting' | 'working' | 'done' | 'stopped' | 'failed';
queued: number;
started?: number;
ended?: number;
error?: string;
}
/** What Claude Code does for a site, as far as the page needs to know. */
export interface AgentState {
site: string;
/** the current run, or the last one */
run: Run | null;
}
/** A request typed into the page. */
export interface RequestBody {
text: string;
}
/** What the server tells every open page, over server-sent events. */
export type ServerEvent =
| { type: 'sites'; sites: Site[] }
| { type: 'files'; site: string }
| { type: 'terminals'; terminals: TerminalState[] }
| { type: 'agent'; state: AgentState };Jetzt das Herzstück dieses Teils, server/agent.ts. Die Datei ist lang, deshalb kommt sie hier in Stücken, von oben nach unten. Zuerst die Konstanten und das, was der Server pro Site aufhebt:
import crypto from 'node:crypto';
import fs from 'node:fs';
import path from 'node:path';
import type { AgentState, Run, ServerEvent } from '../shared/types.ts';
import { OWN } from './sites.ts';
import type { Target, Terminals } from './terminals.ts';
/** Where a request's text goes, in the site's folder. */
export const REQUEST = `${OWN}/request.md`;
/** The one short line typed into Claude Code for every request. */
const COMMAND = `Do what ${REQUEST} says.`;
/** A run, with what only the server needs. */
interface Job extends Run {
target: Target;
/** when its line was typed in (or its session started) */
sentAt: number;
}
interface SiteAgent {
/** the current run, or the last one */
run: Job | null;
/** runs waiting until Claude Code is free */
queue: Job[];
/** a run is being started or typed in right now */
delivering: boolean;
/** the state last sent to the pages */
sent: string;
}
const pub = (j: Job): Run => ({ id: j.id, title: j.title, status: j.status, queued: j.queued, started: j.started, ended: j.ended, error: j.error });
const live = (r: Run | null) => Boolean(r && (r.status === 'starting' || r.status === 'working'));COMMAND ist die Zeile von oben. Ein Job ist ein Lauf plus das, was nur der Server braucht: den Ordner der Site und wann ihre Zeile hineinging. Ein SiteAgent hält den aktuellen Lauf einer Site, ihre Warteschlange und ein Flag für eine Sperre, die gleich vorkommt. sent merkt sich den Zustand, der zuletzt an die Seiten ging, damit ein unveränderter Zustand nicht noch einmal rausgeht. pub() kürzt einen Job auf das, was die Seite sieht, und live() sagt, ob ein Lauf hineingegangen und noch nicht vorbei ist.
/**
* Claude Code at work for the page. A request becomes a run: its text goes into a file in the
* site's folder, and as soon as Claude Code is free, one short line is typed into the site's
* session. What happens then, this part can only read from the screen.
*/
export class Agent {
private terminals: Terminals;
private emit: (ev: ServerEvent) => void;
private sites = new Map<string, SiteAgent>();
constructor(terminals: Terminals, emit: (ev: ServerEvent) => void) {
this.terminals = terminals;
this.emit = emit;
// once a second, and never twice at the same time: a check that waits for tmux takes a moment
const loop = async () => { await this.tick().catch(() => undefined); setTimeout(loop, 1000).unref(); };
void loop();
}
private site(name: string) {
let s = this.sites.get(name);
if (!s) {
s = { run: null, queue: [], delivering: false, sent: '' };
this.sites.set(name, s);
}
return s;
}
state(name: string): AgentState {
const s = this.site(name);
// a queued run is the one that matters: there is one only when the last one is over
const run = s.queue[0] ?? s.run;
return { site: name, run: run ? pub(run) : null };
}
list() {
return [...this.sites.keys()].map((name) => this.state(name));
}
/** Sends the site's state to the pages, if it changed. */
private changed(name: string) {
const state = this.state(name);
const json = JSON.stringify(state);
const s = this.site(name);
if (json === s.sent) return;
s.sent = json;
this.emit({ type: 'agent', state });
}
/** The run that is on its way or underway, if any. */
active(name: string) {
const s = this.sites.get(name);
if (!s) return null;
return s.queue[0] ?? (live(s.run) ? s.run : null);
}Der Konstruktor startet eine Uhr, die einmal pro Sekunde tick() ausführt. Das ist kein setInterval: Ein Tick wartet auf tmux und kann länger als eine Sekunde dauern, deshalb wird der nächste erst geplant, wenn der letzte fertig ist, und zwei laufen nie gleichzeitig. unref() sorgt dafür, dass die Uhr den Prozess nicht offen hält, wenn der Server herunterfährt.
state() ist das, was die Seite bekommt. Wartet ein Lauf in der Schlange, ist er der, den sie zeigen soll, denn ein neuer Lauf wird nur angenommen, wenn der letzte vorbei ist. changed() schickt den Zustand über die Server-Sent Events aus Teil 2 an alle Seiten, aber nur, wenn er sich vom letzten unterscheidet. active() findet einen Lauf, der wartet oder gerade läuft.
/** Asks Claude Code for something. One run at a time per site. */
run(t: Target, title: string, request: string): Run {
const on = this.active(t.name);
if (on) throw new Error(`Claude Code is still on “${on.title}”. Wait until it is done, or stop it.`);
fs.mkdirSync(path.join(t.dir, OWN), { recursive: true });
fs.writeFileSync(path.join(t.dir, REQUEST), `${request.trim()}\n`);
const job: Job = { id: crypto.randomUUID(), title, status: 'queued', queued: Date.now(), target: t, sentAt: 0 };
this.site(t.name).queue.push(job);
void this.deliver(t.name);
this.changed(t.name);
return pub(job);
}run() ist das, was die Route aufruft. Ein Lauf pro Site zur Zeit: Solange einer läuft, wird ein zweiter Auftrag mit einer Meldung abgelehnt, die die Seite zeigt. Sonst kommt der Auftrag in die Datei, der Job in die Warteschlange, und der Server versucht, ihn sofort zuzustellen.
/**
* Sends the next queued run, when Claude Code can take it. No session: one starts, with the
* line as its first message (continuing the folder's last conversation, if it has one). Claude
* Code exited: it starts again in place of the shell. Claude Code waits at an empty prompt: the
* line is typed in. Anything else: try again next second.
*/
private async deliver(name: string) {
const s = this.site(name);
// one at a time: run() and the clock both call this, and starting or typing takes a moment
if (s.delivering) return;
s.delivering = true;
try { await this.deliverNext(name, s); } finally { s.delivering = false; }
}
private async deliverNext(name: string, s: SiteAgent) {
const job = s.queue[0];
if (!job) return;
await this.terminals.poll();
const term = this.terminals.get(name);
const resume = this.terminals.hasConversation(job.target.dir);
try {
if (!term) await this.terminals.start(job.target, { prompt: COMMAND, resume });
else if (!term.claude) await this.terminals.respawn(job.target, { prompt: COMMAND, resume });
else {
if (term.busy || !(await this.terminals.atEmptyPrompt(job.target))) return;
// it may have been taken while we looked
if (s.queue[0] !== job) return;
await this.terminals.type(job.target, COMMAND);
}
} catch (err) {
s.queue.shift();
s.run = job;
this.end(name, 'failed', (err as Error).message);
return;
}
s.queue.shift();
s.run = job;
job.status = 'starting';
job.started = job.sentAt = Date.now();
this.changed(name);
}Das Zustellen ist der Schritt, der die Tastatur berührt, und der Kommentar darüber zählt seine Fälle auf:
Keine Sitzung: Eine startet, mit der Zeile als erster Nachricht an Claude Code (
claude "Do what …"), und mit--continue, wenn der Ordner ein Gespräch von früher hat. Getippt wird nichts, also muss auch nichts auf das Feld warten. In einem neuen Ordner kommt zuerst der Vertrauensdialog, und die erste Nachricht wartet dahinter.Claude Code hat sich beendet, und in der Sitzung wartet eine Shell: Es startet auf dieselbe Weise neu, an Stelle der Shell.
Claude Code wartet an einem leeren Feld: Die Zeile wird getippt.
Alles andere (es arbeitet, ein Dialog, Text im Feld): Nichts passiert, und die Uhr versucht es eine Sekunde später noch einmal.
Die Sperre gibt es, weil zwei Stellen zustellen: run() sofort und die Uhr jede Sekunde. Eine Sitzung zu starten oder zu tippen dauert einen Moment, und ohne Sperre könnte mittendrin ein Tick kommen, den Job noch vorn in der Schlange finden und die Zeile ein zweites Mal tippen. Mit Sperre kehrt ein zweiter Aufruf, während einer läuft, einfach zurück. Aus demselben Grund prüft deliverNext() nach seinem Blick auf den Bildschirm noch einmal, ob der Job noch vorn in der Schlange steht: Ein Klick auf Stop kann sie inzwischen geleert haben.
Scheitert tmux, endet der Lauf als fehlgeschlagen, mit der Meldung von tmux. Sonst verlässt er die Schlange als starting, mit der Zeit, zu der seine Zeile hineinging.
private end(name: string, status: 'done' | 'stopped' | 'failed', error?: string) {
const run = this.site(name).run;
if (!run || run.ended) return;
run.status = status;
run.ended = Date.now();
if (error) run.error = error;
this.changed(name);
}
/** Interrupts Claude Code: Escape in its session, as you would press it. */
async stop(t: Target) {
const s = this.site(t.name);
s.queue = [];
await this.terminals.keys(t, 'Escape').catch(() => undefined);
this.end(t.name, 'stopped');
this.changed(t.name);
}end() schließt den aktuellen Lauf ab, einmal. stop() ist der Stop-Knopf der Seite: Er leert die Schlange und drückt Escape in der Sitzung, so wie du Claude Code auch an der Tastatur unterbrichst. Was Claude Code bis dahin geändert hat, bleibt.
/** Once a second: queued runs go out, and the screen says how the current one is doing. */
private async tick() {
for (const [name, s] of this.sites) {
try { await this.check(name, s); } catch { /* a hiccup of tmux: next second */ }
this.changed(name);
}
}
private async check(name: string, s: SiteAgent) {
if (s.queue.length) await this.deliver(name);
const run = s.run;
if (!run || !live(run)) return;
const term = this.terminals.get(name);
const since = Date.now() - run.sentAt;
if (!term) { if (since > 5000) this.end(name, 'failed', 'The session ended.'); return; }
if (!term.claude) { if (since > 8000) this.end(name, 'failed', 'Claude Code exited.'); return; }
if (term.busy) { run.status = 'working'; return; }
// quiet again, at an empty prompt: the turn is over. A turn too short to count as busy ends
// the same way, once it has had time to start.
if ((run.status === 'working' || since > 15000) && await this.terminals.atEmptyPrompt(run.target)) this.end(name, 'done');
}
}check() läuft jede Sekunde für jede Site. Zuerst gehen wartende Läufe hinaus. Dann beurteilt es den aktuellen Lauf, und in diesem Teil hat es dafür nur den Bildschirm, über das, was Teil 3 schon misst: ob Claude Code noch in der Sitzung läuft und ob sich sein Bildschirm ständig ändert (busy, vom Spinner).
Die Sitzung ist weg: Der Lauf ist fehlgeschlagen. Allerdings nicht vor fünf Sekunden, denn ein einzelner Blick auf tmux, der scheitert, sieht genauso aus wie gar keine Sitzung.
Eine Shell statt Claude Code: Es hat sich beendet, und der Lauf ist fehlgeschlagen. Die Schonfrist ist hier länger, weil Claude Code in einer Login-Shell startet und tmux in den ersten Momenten die Shell sieht.
Der Bildschirm bewegt sich: Der Lauf ist
working.Der Bildschirm steht still und zeigt ein leeres Feld: Die Runde ist vorbei, und der Lauf ist
done. Dafür braucht es entweder vorher eine Phaseworkingoder 15 Sekunden, seit die Zeile hineinging. Eine Runde, die so kurz ist, dass der Bildschirm nie als beschäftigt galt, endet so, und ein Lauf, der gerade erst hineingegangen ist, gilt nicht als fertig, bevor Claude Code überhaupt angefangen hat.
Hier kommt der Bildschirm an seine Grenzen. Er kennt „bewegt sich“ und „steht still an einem leeren Feld“, und ein Dialog ist keins von beiden: Während Claude Code im Terminal auf eine Antwort wartet, sagt der Lauf weiter working, und nichts in der Seite sagt dir, warum. Beim ersten Bau unten wirst du das sehen. Der Bildschirm sagt auch nicht, was Claude Code tut, nur dass es etwas tut. Der nächste Teil bringt eine bessere Quelle.
Routen
Importiere in server/main.ts den Agenten und die Auftragstexte:
import fs from 'node:fs';
import http from 'node:http';
import path from 'node:path';
import { fileURLToPath } from 'node:url';
import { WebSocketServer } from 'ws';
import type { Config, NewSite, RequestBody, ServerEvent } from '../shared/types.ts';
import { Agent } from './agent.ts';
import { HttpError, fileIn, readJson, send, sendFile } from './http.ts';
import { requestText, runTitle } from './requests.ts';
import { NAME, OWN, Sites } from './sites.ts';
import { Terminals, type Target } from './terminals.ts';Leg den Agenten direkt nach dem Einrichten der Terminals an:
const terminals = new Terminals(APP, broadcast);
await terminals.init();
config.terminals = terminals.available;
config.pty = terminals.canAttach;
const agent = new Agent(terminals, broadcast);Dann kommen zwei Routen nach den Routen der Sitzung dazu. Die Route des Event-Streams darunter, hier ganz gezeigt, bekommt eine Zeile mehr: Sie schickt die Zustände der Agenten gleich nach den Sitzungen, damit eine Seite, die mitten in einem Lauf aufgeht, ihn sofort sieht:
// 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 } = await readJson<RequestBody>(req);
try {
send(res, 201, agent.run(target(site.name), runTitle(site), requestText(site, String(text ?? ''))));
} catch (err) { throw new HttpError(409, (err as Error).message); }
}],
['POST', /^\/api\/sites\/([^/]+)\/stop$/, async (_req, res, m) => {
await agent.stop(target(m[1]));
send(res, 200, agent.state(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`);
res.write(`data: ${JSON.stringify({ type: 'terminals', terminals: terminals.list() } satisfies ServerEvent)}\n\n`);
for (const state of agent.list()) res.write(`data: ${JSON.stringify({ type: 'agent', state } 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); });
}],Ein Auftrag braucht tmux und eine Site, die es gibt. Lehnt run() ihn ab, weil ein Lauf läuft, bekommt die Seite eine 409 mit der Meldung. Stop antwortet mit dem neuen Zustand.
Die Seite
Das Feld, in das du den Auftrag schreibst, src/requestBox.ts:
import { api } from './api.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 msg = h('p', { class: 'hint bad', 'aria-live': 'polite' });
private busy = false;
constructor(site: string) {
this.url = `/api/sites/${site}/requests`;
this.el = h('form', { class: 'panel request' },
this.label, this.text,
h('div', { class: 'actions' }, h('span', { class: 'hint' }, 'Ctrl+Enter sends'), 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 };
try {
await api('POST', this.url, body);
this.text.value = '';
} catch (err) { this.msg.textContent = (err as Error).message; }
}
}Titel und Knopf richten sich nach der Site: Build the site, solange sie keine index.html hat, danach Send to Claude Code. Während ein Lauf läuft, ist der Knopf aus. Strg+Enter (Cmd+Enter auf dem Mac) schickt ebenfalls ab. Ein angenommener Auftrag leert das Feld; ein abgelehnter lässt deinen Text stehen und zeigt darunter die Meldung des Servers.
Unter dem Feld zeigt src/agentPanel.ts den Lauf:
import { api } from './api.ts';
import { h } from './dom.ts';
import type { AgentState, Run } from '../shared/types.ts';
export const isLive = (r: Run | null | undefined) => Boolean(r && ['queued', 'starting', 'working'].includes(r.status));
/** 75 -> "1:15" */
const clock = (ms: number) => {
const s = Math.max(0, Math.round(ms / 1000));
return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`;
};
function statusText(r: Run, now: number) {
switch (r.status) {
case 'queued': return 'Waiting until Claude Code is free';
case 'starting': return 'Starting';
case 'working': return `Working for ${clock(now - (r.started ?? now))}`;
case 'done': return `Done after ${clock((r.ended ?? now) - (r.started ?? now))}`;
case 'stopped': return 'Stopped';
case 'failed': return r.error ? `Failed: ${r.error}` : 'Failed';
}
}
/** The current (or last) run: what it is, how long Claude Code has worked on it, and Stop. */
export class AgentPanel {
readonly el: HTMLElement;
private url: string;
private title = h('h2', { class: 'agent-title' });
private status = h('p', { class: 'agent-status' });
private stopBtn = h('button', { type: 'button', class: 'small ghost' }, 'Stop');
private msg = h('p', { class: 'hint bad', 'aria-live': 'polite' });
private timer = 0;
constructor(site: string) {
this.url = `/api/sites/${site}/stop`;
this.stopBtn.onclick = () => void this.stop();
this.el = h('section', { class: 'panel agent', 'aria-label': 'Claude Code', hidden: true },
h('header', { class: 'agent-head' }, h('div', {}, this.title, this.status), this.stopBtn),
this.msg);
}
update(state: AgentState | undefined) {
const run = state?.run ?? null;
clearInterval(this.timer);
this.el.hidden = !run;
if (!run) return;
this.el.dataset.status = run.status;
this.title.textContent = run.title;
this.status.textContent = statusText(run, Date.now());
if (run.status === 'working') this.timer = window.setInterval(() => { this.status.textContent = statusText(run, Date.now()); }, 1000);
this.stopBtn.hidden = !isLive(run) || run.status === 'queued';
}
private async stop() {
if (!confirm('Stop Claude Code? It ends its turn where it is; what it changed so far stays.')) return;
try { await api('POST', this.url); } catch (err) { this.msg.textContent = (err as Error).message; }
}
dispose() { clearInterval(this.timer); }
}Das Panel zeigt den Titel des Laufs und eine Statuszeile, die mitzählt, während Claude Code arbeitet. Stop fragt nach, bevor es etwas tut, und ist nur da, solange ein Lauf unterwegs ist.
In src/sitePage.ts nehmen das Feld und das Panel die linke Seite ein, neben den Tabs. Ersetze den Anfang der Datei bis zum Ende des Konstruktors:
import { AgentPanel, isLive } from './agentPanel.ts';
import { h } from './dom.ts';
import { RequestBox } from './requestBox.ts';
import { SessionControls } from './session.ts';
import { TerminalView } from './terminalView.ts';
import type { AgentState, Config, Site, TerminalState } from '../shared/types.ts';
type Tab = 'preview' | 'terminal';
/**
* One site: what it is about; on the left what you ask Claude Code and what it does; on the right
* the site itself or its terminal.
*/
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.'));
private preview = h('div', { class: 'preview' }, this.frame, this.empty);
private session: SessionControls;
private terminal: TerminalView;
private request: RequestBox;
private agent: AgentPanel;
private agentState: AgentState | undefined;
private tabs: Record<Tab, HTMLButtonElement>;
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);
this.request = new RequestBox(name);
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');
}Ersetze update(), das jetzt dem Feld sagt, ob ein Lauf läuft, und füg danach agentChanged() ein:
/** 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;
this.request.update(site, isLive(this.agentState?.run));
}
/** What Claude Code does for this site changed. */
agentChanged(state: AgentState) {
this.agentState = state;
this.agent.update(state);
this.request.update(this.site, isLive(state.run));
}dispose() hält auch die Uhr des Panels an:
/** The page shows another site. */
dispose() {
this.terminal.dispose();
this.agent.dispose();
}Zuletzt hebt src/main.ts die Zustände der Agenten auf, von denen es hört, und reicht sie an die offene Site weiter:
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 { AgentState, Config, ServerEvent, Site, TerminalState } 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 terminals: TerminalState[] = [];
const agents = new Map<string, AgentState>();
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);
page.terminals(terminals);
const state = agents.get(name);
if (state) page.agentChanged(state);
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 === 'terminals') {
terminals = ev.terminals;
page?.terminals(terminals);
} else if (ev.type === 'agent') {
agents.set(ev.state.site, ev.state);
if (ev.state.site === page?.name) page.agentChanged(ev.state);
} 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 Seite hebt die Zustände aller Sites auf, nicht nur den der offenen, weil ein Zustand nur kommt, wenn er sich ändert. Wechselst du mitten in ihrem Lauf zu einer Site, ist ihr Zustand schon zur Hand.
Der erste Bau
Starte npm start, leg eine Site an, schreib ins Feld, was du willst, oder lass es leer, und klick auf Build the site. Hier ist der erste Bau des Lumen Café, gestartet mit curl, das dasselbe JSON schickt wie die Seite, und was danach geschah:
$ curl -s -X POST -d '{"text":"Keep it to one page, warm colours."}' localhost:5400/api/sites/lumen-cafe/requests{"id":"53972648-…","title":"Building the site","status":"queued","queued":1795091449284}# The folder was new: Claude Code showed the trust dialog first, answered by hand in the Terminal tab.# Then the status said "working" for two minutes, while Claude Code waited at this prompt: ● Running 1 shell command… ⎿ $ (node --check script.js && echo "JS ok") ; ls -la . assets 2>/dev/null Bash command Syntax-check the script and list files (node --check script.js && echo "JS ok") ; ls -la . assets 2>/dev/null This command uses shell operators that require approval for safety Do you want to proceed? ❯ 1. Yes 2. Yes, and switch to auto mode · auto mode handles these prompts for you 3. No Esc to cancel · Tab to amend# After Enter (Yes) in the Terminal tab, the run was done 5 seconds later. In the folder now:# CLAUDE.md index.html script.js style.css. The end of Claude Code's last message on the screen: index.html, style.css and a small script.js for the mobile menu, with sections for the hero, about, menu, events and visit info. The page uses no outside files, and the script passes a syntax check, but I have not opened it in a browser. I left out the street address, opening hours beyond breakfast until 2 pm, and prices because the brief didn't give them. The visit section and the menu card text are placeholders to replace with real details.✻ Brewed for 27s · done 13:33# … and under it, the empty input box
Die Antwort sagt queued: Der Lauf wartet auf seine Zustellung, die einen Moment später folgt. Eine neue Site hat meist noch keine Sitzung, also startet eine, mit der Zeile als erster Nachricht. Dann kamen zwei Unterbrechungen, von denen die Seite nichts wusste. Der Ordner war neu, also fragte Claude Code zuerst, ob es ihm vertrauen soll, und das musste im Tab Terminal beantwortet werden. Später wollte es einen Befehl mit Shell-Operatoren ausführen, den acceptEdits nicht ohne Nachfrage durchlässt, und wartete auf ein Ja. Zwei Minuten lang sagte die Seite Working, weil der Bildschirm nicht mehr hergab. Nach Enter im Tab Terminal machte Claude Code fertig, sein Bildschirm kam an einem leeren Feld zur Ruhe, und der Lauf war erledigt.
Sitesmith tippt jetzt für dich, und nur dann, wenn Claude Code bereit dafür ist. Was es über die Arbeit erfährt, erfährt es allerdings aus einem Bild des Bildschirms: bewegt sich oder steht still, Feld oder kein Feld. Das reicht, um einen Auftrag zuzustellen und zu erkennen, wann Claude Code fertig ist, und es sagt nichts darüber, was Claude Code tut. Im nächsten Teil fängt Claude Code an, es dem Server selbst zu sagen, über seine Hooks.
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.
