Claude Code in deiner eigenen Web-App · Teil 10 von 16 der Serie
Teil 10: Wenn die Seite nicht antworten kann
Keine Seite offen, der Tab zu, der Server startet neu, ein unbekannter Dialog: alle Wege, auf denen eine Frage die Seite verfehlt, und wie jeder in der Seite oder im Terminal endet, nie im Warten auf niemanden. Dazu der Vertrauensdialog, vom Bildschirm gelesen und mit Tasten beantwortet.
Claude Code in deiner eigenen Web-AppTeil 10 von 16
Auf dieser Seite
Quest-Ziele
- Alle Wege durchgehen, auf denen eine Frage die Seite verfehlen kann, und für jeden festlegen, wo er endet
- Den Vertrauensdialog eines neuen Ordners in der Seite zeigen und mit den Pfeiltasten beantworten
- Eine Frage oder eine Berechtigungsabfrage mit einem Button ans Terminal zurückgeben
- Den Dialog der Seite schließen, wenn Claude Code ohne sie weitergemacht hat
- Fragen einen Neustart des Servers überstehen lassen und ans Terminal geben, wenn keine Seite mehr offen ist
- Erkennen, wenn Claude Code auf etwas wartet, das nur das Terminal zeigt, und das Terminal nach vorne holen
Seit den Teilen 8 und 9 erscheinen die Fragen und Berechtigungsabfragen von Claude Code in der Seite. Hinter jedem dieser Dialoge steht ein Hook, der Claude Code festhält, bis die Seite antwortet, und er ist geduldig: Sitesmith hat ihm einen ganzen Tag gegeben. Diese Geduld ist es, die die Dialoge möglich macht. Sie ist aber auch ein Versprechen, das die Seite halten muss, denn eine Seite, die nie antwortet, lässt Claude Code in einem Terminal warten, auf das niemand schaut.
Es gibt mehr Wege, auf denen die Seite nicht antwortet, als man denkt. Niemand hat sie offen. Der Tab wird geschlossen, während ein Dialog wartet. Der Server startet neu. Du antwortest lieber im Terminal. Oder Claude Code zeigt etwas, von dem die Seite noch nie gehört hat. Dieser Teil geht sie alle durch, und jeder endet an einem von zwei Orten: in der Seite oder im eigenen Dialog von Claude Code im Terminal, den die Seite dir dann vor die Nase holt.
Unterwegs zieht noch ein Dialog in die Seite ein: der Vertrauensdialog eines neuen Ordners. Kein Hook meldet ihn, also liest der Server ihn vom Bildschirm ab und beantwortet ihn mit Tasten.
Alle Wege, auf denen eine Frage die Seite verfehlt
Hier sind die Fälle, und was Sitesmith in jedem tut, wenn dieser Teil fertig ist:
Keine Seite ist offen, wenn Claude Code fragt. Niemand könnte antworten, also lässt der Server den Hook sofort los (das hat schon Teil 8 getan), und Claude Code fragt in seinem Terminal. Neu: Öffnest du die Site später, beginnt die Seite auf dem Tab Terminal, mit der Frage darin.
Die Seite verschwindet, während ein Dialog wartet. Du schließt den Tab, der Laptop geht schlafen, die Verbindung reißt ab. Nach 15 Sekunden ohne jede Seite gibt der Server die Frage ans Terminal.
Der Server startet neu, während ein Dialog wartet. Der neue Server hat von der Frage nie gehört. Der Hook merkt das und fragt noch einmal, und der Dialog kommt zurück. Antwortet eine Minute lang kein Server, gibt der Hook auf, und Claude Code fragt im Terminal.
Du gibst sie zurück. Ein neuer Button, Answer in the terminal, lässt eine Frage, eine Berechtigungsabfrage oder den Vertrauensdialog los und schaltet die Seite auf den Tab Terminal.
Sie wird im Terminal beantwortet. Eine Berechtigungsabfrage ist im Terminal gleichzeitig offen wie in der Seite (Teil 9), und du kannst sie dort beantworten. Sobald Claude Code weitermacht, schließt sich der Dialog der Seite.
Claude Code zeigt etwas, das die Seite nicht kennt. Einen Dialog ohne Hook, ein Menü, das jemand im Terminal geöffnet hat, Text, der eingetippt und nie abgeschickt wurde. Nach ein paar ruhigen Sekunden holt die Seite den Tab Terminal nach vorne und sagt, dass Claude Code dort auf dich wartet.
Der Vertrauensdialog. Kein Hook meldet ihn. Der Server findet ihn auf dem Bildschirm, die Seite zeigt ihn, und deine Antwort geht als Pfeiltasten und Enter an Claude Code.
Claude Code beendet sich. Was gewartet hat, wird losgelassen, und ein Lauf, der gerade unterwegs war, scheitert mit „Claude Code exited.“
Das meiste davon passiert in der Uhr des Servers, der Methode, die sich jede Sekunde jede Site ansieht. Zuerst braucht der Server aber ein paar neue Dinge, über die er Buch führt.
Was der Server sich merkt
Ersetze in shared/types.ts Ask, AnswerBody und AgentState. Der Vertrauensdialog kommt zu den Dingen dazu, auf die Claude Code warten kann, die Antwort der Seite bekommt zwei neue Felder, und der Zustand, den die Seite erhält, sagt, ob Claude Code im Terminal wartet:
/** What Claude Code waits for the page to answer. */
export type Ask =
| { id: string; kind: 'questions'; questions: Question[]; since: number }
| {
id: string;
kind: 'permission';
tool: string;
/** one line about what it wants to do */
summary: string;
/** the command, the file or the address */
detail?: string;
/** whether Claude Code offers a rule for "from now on" */
remember: boolean;
since: number;
}
/** the trust dialog of a folder Claude Code has never worked in */
| { id: string; kind: 'trust'; dir: string; since: number };
/** The page's answer: per question text, the chosen labels (joined with ", ") or your own words. */
export interface AnswerBody {
id: string;
answers?: Record<string, string>;
/** for a permission prompt */
decision?: 'allow' | 'always' | 'deny';
/** for the trust dialog */
trust?: boolean;
/** hand it back: Claude Code asks in the terminal instead */
terminal?: boolean;
}
/** 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;
/** whether its session reports through the hooks (one you started yourself does not) */
hooked: boolean;
/** working, by the hooks or by the screen */
busy: boolean;
/** the last things it did, oldest first */
activity: Activity[];
/** what it waits for you to answer */
ask: Ask | null;
/** it waits for something only the terminal can show: the page brings the terminal on screen */
needsTerminal: boolean;
}needsTerminal ist das Flag, um das sich dieser Teil dreht. Was nur das Terminal zeigt, kann die Seite nicht beantworten, also tut sie das Nächstbeste: Sie zeigt dir das Terminal.
Ersetze in server/agent.ts Pending. Das Hook-Ereignis eines wartenden Asks wird optional, denn den Vertrauensdialog meldet kein Hook:
/** Something Claude Code waits for, with the hook that holds it. */
interface Pending {
ask: Ask;
site: string;
/** the hook's event (none for the trust dialog, which no hook reports) */
event: HookEvent | null;
result: WaitResult | null;
/** the hook's long polls, waiting for the result */
waiters: ((r: WaitResult) => void)[];
}SiteAgent bekommt unter ask zwei Felder:
/** what Claude Code waits for the page to answer */
ask: Pending | null;
/** it waits for something in the terminal that the page can't show */
needsTerminal: boolean;
/** since when it has been neither working nor at its empty prompt (0: it is one of them) */
strandedSince: number;Ersetze site(), busy() und state(). Die neuen Felder beginnen mit false und 0; ein Claude Code, das im Terminal wartet, arbeitet auch nicht, also sagt busy() nein; und state() gibt das Flag an die Seiten weiter:
private site(name: string) {
let s = this.sites.get(name);
if (!s) {
s = { run: null, queue: [], delivering: false, hooked: false, hookBusy: false, quietSince: 0, transcript: null, transcriptPos: 0, activity: [], ask: null, needsTerminal: false, strandedSince: 0, sent: '' };
this.sites.set(name, s);
}
return s;
}
/**
* Working: with the hooks, between a prompt and the end of its turn (exact, the moment it
* happens); without them, while the screen moves (a few seconds late).
*/
private busy(name: string) {
const term = this.terminals.get(name);
const s = this.site(name);
// waiting for your answer is not working
if (s.ask || s.needsTerminal) return false;
return Boolean(term?.claude && (s.hooked ? s.hookBusy : term.busy));
}
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, hooked: s.hooked, busy: this.busy(name),
activity: s.activity, ask: s.ask?.ask ?? null, needsTerminal: s.needsTerminal,
};
}Das letzte neue Feld gehört zum Agent selbst und kommt unter pages: seit wann keine Seite mehr offen ist.
/** how many pages are open */
private pages: () => number;
/** since when no page has been open (0: one is) */
private noPagesSince = 0;Jede Sekunde ein genauerer Blick
Bevor die Uhr die Sites durchgeht, notiert sie, ob überhaupt eine Seite offen ist:
/** Once a second: queued runs go out, and the state of the current one is checked. */
private async tick() {
if (this.pages()) this.noPagesSince = 0;
else if (!this.noPagesSince) this.noPagesSince = Date.now();
for (const [name, s] of this.sites) {
try { await this.check(name, s); } catch { /* a hiccup of tmux: next second */ }
this.changed(name);
}
}check() ändert sich von oben bis unten, deshalb kommt die Methode in zwei Hälften. Hier ist die erste:
private async check(name: string, s: SiteAgent) {
// no page for a while: what waits for one goes to the terminal
if (s.ask && this.noPagesSince && Date.now() - this.noPagesSince > 15000) {
this.settle(s.ask, { status: 'release' });
s.needsTerminal = true;
}
if (s.queue.length) await this.deliver(name);
const run = s.run;
const since = run ? Date.now() - run.sentAt : 0;
const term = this.terminals.get(name);
if (!term?.claude) {
s.hookBusy = false;
s.needsTerminal = false;
if (s.ask) this.settle(s.ask, { status: 'release' });
if (live(run) && !term && since > 5000) this.end(name, 'failed', 'The session ended.');
if (live(run) && term && since > 8000) this.end(name, 'failed', 'Claude Code exited.');
return;
}
// only the screens of sites with something going on are read
if (!live(run) && !s.queue.length && !s.ask && !s.needsTerminal && !s.hookBusy) return;
// the trust dialog of a new folder comes before any hook: only the screen shows it
const trust = /Yes, I trust this folder/.test(await this.terminals.screen({ name }));
// (not when it was handed to the terminal: it is answered there)
if (trust && !s.ask && !s.needsTerminal) {
const ask: Ask = { id: crypto.randomUUID(), kind: 'trust', dir: run?.target.dir ?? '', since: Date.now() };
s.ask = { ask, site: name, event: null, result: null, waiters: [] };
this.pending.set(ask.id, s.ask);
} else if (!trust && s.ask?.ask.kind === 'trust') this.settle(s.ask, { status: 'answered', output: null });
if (s.ask) { s.needsTerminal = false; s.strandedSince = 0; return; }Von oben nach unten:
15 Sekunden keine Seite. Was wartet, wird losgelassen: Sein Hook endet ohne Antwort, und Claude Code fragt im Terminal. Außerdem geht
needsTerminalhoch: Was ans Terminal ging, bleibt dort, und öffnest du die Site wieder, beginnt ihre Seite auf dem Tab Terminal. Warum nicht sofort? Ein Neuladen der Seite oder eine kurze Unterbrechung der Verbindung soll dich den Dialog nicht kosten. Die Verbindung der Seite zum Server kommt nach ein paar Sekunden von selbst zurück (Teil 2), und der Dialog mit ihr.Claude Code läuft nicht. Es gibt keine Sitzung, oder sie zeigt eine Shell, weil Claude Code sich beendet hat. Dann kann nichts warten: Was gewartet hat, wird losgelassen, und ein Lauf, der unterwegs war, scheitert nach ein paar Sekunden Schonfrist. Diese Zeilen standen vorher weiter unten. Sie wandern nach oben, weil alles darunter ein laufendes Claude Code braucht.
Nur Sites, bei denen etwas los ist, bekommen ihren Bildschirm gelesen: ein Lauf auf dem Weg oder unterwegs, etwas, das wartet, oder Hooks, die „beschäftigt“ sagen. Eine Site, die nichts tut, kostet nichts.
Der Vertrauensdialog. Zeigt der Bildschirm „Yes, I trust this folder“, macht der Server daraus ein eigenes Ask, mit dem Ordner, um den es geht (dem des Laufs, falls es einen gibt). Es hat keinen Hook und kein Ereignis. Nur nicht, solange
needsTerminaloben ist: Dann wurde der Dialog ans Terminal gegeben (mit dem Button weiter unten oder weil keine Seite offen war), und er wird dort beantwortet, statt wieder in die Seite zu kommen. Ist die Zeile vom Bildschirm verschwunden, wurde der Dialog beantwortet, in der Seite oder im Terminal, und das Ask ist erledigt.Solange die Seite etwas festhält, wird der Bildschirm nicht weiter beurteilt. Bei einer festgehaltenen Berechtigungsabfrage steht auch der eigene Dialog von Claude Code auf dem Bildschirm, bei einer festgehaltenen Frage gar nichts. Beides heißt nicht, dass Claude Code feststeckt.
Den Vertrauensdialog beantworten
Das findet der Server auf dem Bildschirm der Sitzung einer neuen Site; Teil 3 hat es mit capture-pane eingefangen:
$ tmux -L sitesmith capture-pane -p -t =maras-bakery: 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
Teil 1 hat ihn von Hand mit Down und Enter beantwortet, denn der Cursor steht am Anfang auf „No, exit“. Der Server könnte dasselbe tun, aber nur, solange der Cursor noch dort steht, wo er angefangen hat, und in einem Terminal, in das jeder hineinschauen kann, muss das nicht so sein. Also zählt er vom Bildschirm aus. Füge diese Methode nach answer() zum Agent hinzu:
/**
* The trust dialog, answered with the arrow keys and Enter: from where its cursor (❯) is now to
* the line we want. No hook reports this dialog, so the screen is all there is.
*/
private async answerTrust(t: Target, yes: boolean) {
const lines = (await this.terminals.screen(t)).split('\n');
const cursor = lines.findIndex((l) => /^\s*❯/.test(l));
const want = lines.findIndex((l) => (yes ? /Yes, I trust this folder/ : /No, exit/).test(l));
if (cursor < 0 || want < 0) throw new Error('The trust dialog is no longer on screen.');
for (let i = 0; i < Math.abs(want - cursor); i++) await this.terminals.keys(t, want > cursor ? 'Down' : 'Up');
await this.terminals.keys(t, 'Enter');
this.note(t.name, { kind: 'note', text: yes ? 'You trusted this folder' : 'You did not trust this folder: Claude Code ended' });
}Sie sucht die Zeile mit dem Cursor des Dialogs, ❯, und die Zeile, die du gewählt hast, drückt so oft Down oder Up, wie die beiden auseinanderliegen, und dann Enter. Fehlt eine der beiden Zeilen, ist der Dialog inzwischen verschwunden, und die Seite erfährt das.
answer() ruft sie auf. Ersetze die Methode:
/**
* The page's answer, as the hook's output for Claude Code.
*
* Questions: "allow" the tool, with its input extended by `answers` (per question text, the
* chosen labels or your own words). Claude Code takes that as your answer and never shows its
* own dialog.
*
* Permissions: a decision, "allow" or "deny" (with a message for Claude Code). "Allow from now on"
* allows and adds the rules Claude Code suggested, as its own "don't ask again" would.
*/
async answer(t: Target, req: Partial<AnswerBody>) {
const name = t.name;
const s = this.site(name);
const p = s.ask;
if (!p || p.ask.id !== req.id) throw new Error('That question is no longer open.');
const ask = p.ask;
// handed back: the hook ends without output, and Claude Code shows its own dialog
if (req.terminal) {
this.settle(p, { status: 'release' });
this.note(name, { kind: 'note', text: 'You answer in the terminal' });
s.needsTerminal = true;
this.changed(name);
return;
}
if (ask.kind === 'trust') {
await this.answerTrust(t, req.trust === true);
this.settle(p, { status: 'answered', output: null });
return;
}
if (ask.kind === 'permission') {
const decision = req.decision ?? 'deny';
this.note(name, { kind: 'prompt', text: `${decision === 'deny' ? 'You denied' : 'You allowed'}: ${ask.summary}` });
const out = decision === 'deny'
? { behavior: 'deny', message: 'The user denied this in Sitesmith.' }
: { behavior: 'allow', ...(decision === 'always' && p.event?.permission_suggestions?.length ? { updatedPermissions: p.event.permission_suggestions } : {}) };
this.settle(p, { status: 'answered', output: { hookSpecificOutput: { hookEventName: 'PermissionRequest', decision: out } } });
return;
}
const answers: Record<string, string> = {};
for (const q of ask.questions) {
const a = String(req.answers?.[q.question] ?? '').trim();
if (!a) throw new Error(`Answer “${q.question}” first.`);
answers[q.question] = a;
}
this.note(name, { kind: 'prompt', text: `You answered: ${short(Object.values(answers).join(' · '))}` });
this.settle(p, {
status: 'answered',
output: {
hookSpecificOutput: {
hookEventName: 'PreToolUse',
permissionDecision: 'allow',
permissionDecisionReason: 'Answered in Sitesmith',
updatedInput: { ...p.event?.tool_input, answers },
},
},
});
}Oben sind drei Dinge neu. Die Methode bekommt jetzt das Target der Site und ist async, denn der Vertrauensdialog wird über tmux beantwortet, und das braucht die Sitzung und einen Moment Zeit. Eine Antwort auf den Vertrauensdialog wird ohne Ausgabe erledigt, weil kein Hook auf sie wartet.
Und eine Antwort kann jetzt auch gar keine Antwort sein. terminal: true erledigt das Ask als release: Der Long Poll des Hooks erfährt es, der Hook endet ohne Ausgabe, und Claude Code macht weiter, als hätte es keinen Hook gegeben. Es zeigt seinen eigenen Dialog im Terminal. Bei einer Berechtigungsabfrage war dieser Dialog die ganze Zeit schon da. Bei einer Frage zeichnet Claude Code jetzt seinen eigenen Fragedialog, der unterwegs am Hook PermissionRequest vorbeikommt, und den überlässt hookAsk() seit Teil 9 dem Terminal. In jedem Fall geht needsTerminal sofort hoch, damit die Seite folgen kann, ohne auf die Uhr zu warten.
Beim Vertrauensdialog tut das Flag noch etwas. Dieser Dialog hat keinen Hook, den man loslassen könnte: Sein Ask ist einfach weg, und der Dialog selbst stand die ganze Zeit auf dem Bildschirm. Solange needsTerminal oben ist, macht check() daraus kein neues Ask (das ist das !s.needsTerminal in seiner Bedingung), er bleibt also im Terminal, bis du ihn dort beantwortest.
Weiter unten ist aus p.event. ein p.event?. geworden, weil ein Ask jetzt auch ohne Ereignis sein kann. Die Route in server/main.ts gibt das Target mit und wartet:
// the page answers what Claude Code asks
['POST', /^\/api\/sites\/([^/]+)\/answer$/, async (req, res, m) => {
const site = sites.get(m[1]);
try { await agent.answer(target(site.name), await readJson<AnswerBody>(req)); } catch (err) { throw new HttpError(409, (err as Error).message); }
send(res, 200, agent.state(site.name));
}],Wählst du No, exit, tut Claude Code genau das: Es beendet sich, die Sitzung fällt auf ihre Shell zurück, und der Lauf scheitert ein paar Sekunden später mit „Claude Code exited.“
In der Seite
Der Dialog in src/askDialog.ts lernt, der Seite Bescheid zu geben, wenn eine Antwort ans Terminal ging. Füge unter dismissed ein Feld hinzu:
/** the ask put aside with Escape */
dismissed: string | null = null;
/** the answer went to the terminal: the page shows it */
onTerminal: (site: string) => void = () => {};In show() bekommt der Vertrauensdialog eine eigene Darstellung:
/** Shows a site's ask; nothing happens when it is already on screen, so choices made stay. */
show(site: string, title: string, ask: Ask) {
if (this.el.open && this.ask?.id === ask.id) return;
this.ask = ask;
this.site = site;
this.dismissed = null;
this.msg.textContent = '';
this.sub.textContent = title;
if (ask.kind === 'questions') this.renderQuestions(ask.questions);
else if (ask.kind === 'permission') this.renderPermission(ask);
else this.renderTrust(ask.dir);
if (!this.el.open) this.el.showModal();
}Ersetze send() und füge darunter den Button und den Vertrauensdialog hinzu:
private async send(body: Omit<AnswerBody, 'id'>) {
if (!this.ask) return;
this.msg.textContent = '';
const buttons = [...this.foot.querySelectorAll('button')];
buttons.forEach((b) => { b.disabled = true; });
try {
await api('POST', `/api/sites/${this.site}/answer`, { id: this.ask.id, ...body });
if (body.terminal) this.onTerminal(this.site);
this.close();
} catch (err) {
this.msg.textContent = (err as Error).message;
buttons.forEach((b) => { b.disabled = false; });
}
}
/** "Answer in the terminal": Claude Code shows its own dialog there instead. */
private terminalButton() {
return h('button', { type: 'button', class: 'ghost left', onclick: () => void this.send({ terminal: true }) }, 'Answer in the terminal');
}
private renderTrust(dir: string) {
this.heading.textContent = 'Claude Code asks whether you trust this folder';
this.body.replaceChildren(
h('p', {}, 'It works in this folder for the first time. Trusting it lets Claude Code read, edit and run files here, as in your own projects.'),
h('pre', { class: 'ask-detail' }, dir || 'this site’s folder'));
const yes = h('button', { type: 'button', class: 'primary', onclick: () => void this.send({ trust: true }) }, 'Yes, I trust this folder');
this.foot.replaceChildren(this.terminalButton(),
h('button', { type: 'button', class: 'ghost danger', onclick: () => void this.send({ trust: false }) }, 'No, exit'), yes);
requestAnimationFrame(() => yes.focus());
}terminalButton() baut für jeden Dialog, der gerade gezeigt wird, einen frischen Button Answer in the terminal. Er schickt terminal: true, und sobald der Server das angenommen hat, ruft send() onTerminal auf. Der Vertrauensdialog zeigt den Ordner und die beiden Möglichkeiten des echten Dialogs, mit dem Fokus auf Ja.
Die beiden anderen Dialoge bekommen den Button als ersten in ihre Fußzeile, wo ihn die Klasse left von den Antworten wegschiebt:
private renderPermission(ask: Extract<Ask, { kind: 'permission' }>) {
this.heading.textContent = 'Claude Code asks for permission';
this.body.replaceChildren(
h('p', {}, h('strong', {}, ask.tool), ask.summary !== ask.tool ? ` · ${ask.summary}` : ''),
ask.detail ? h('pre', { class: 'ask-detail' }, ask.detail) : '');
const allow = h('button', { type: 'button', class: 'primary', onclick: () => void this.send({ decision: 'allow' }) }, 'Allow');
this.foot.replaceChildren(
this.terminalButton(),
h('button', { type: 'button', class: 'ghost danger', onclick: () => void this.send({ decision: 'deny' }) }, 'Deny'),
ask.remember ? h('button', { type: 'button', onclick: () => void this.send({ decision: 'always' }) }, 'Allow from now on') : '',
allow);
requestAnimationFrame(() => allow.focus());
}
private renderQuestions(questions: Question[]) {
this.heading.textContent = questions.length > 1 ? 'Claude Code has questions for you' : 'Claude Code has a question for you';
const go = h('button', { type: 'button', class: 'primary' }, questions.length > 1 ? 'Send the answers' : 'Send the answer');
const fields: QuestionField[] = [];
const sync = () => { go.disabled = fields.some((f) => !f.value()); };
questions.forEach((q, i) => fields.push(new QuestionField(q, i, questions.length, sync)));
go.onclick = () => void this.send({ answers: Object.fromEntries(fields.map((f) => [f.q.question, f.value()])) });
this.body.replaceChildren(...fields.map((f) => f.el));
this.foot.replaceChildren(this.terminalButton(), go);
sync();
requestAnimationFrame(() => fields[0]?.focus());
}Füge in src/main.ts unter der Zeile, die den Dialog anlegt, eine Zeile hinzu: Die Seite antwortet auf onTerminal, indem sie die offene Site auf ihren Tab Terminal schaltet.
const dialog = new AskDialog();
dialog.onTerminal = (site) => { if (page?.name === site) page.show('terminal'); };Damit ist der Button abgedeckt. Für alle anderen Wege ins Terminal gibt es needsTerminal im Zustand, und agentChanged() in src/sitePage.ts achtet darauf:
/** What Claude Code does for this site changed. */
agentChanged(state: AgentState) {
// Claude Code waits for something only the terminal shows: bring it on screen, once
if (state.needsTerminal && !this.agentState?.needsTerminal) this.show('terminal');
this.agentState = state;
this.agent.update(state);
this.session.update(this.termState, state);
this.request.update(this.site, isLive(state.run));
}Sie schaltet um, wenn das Flag hochgeht, nicht so lange, wie es oben bleibt. Du kannst also zur Vorschau zurück, während Claude Code wartet. Eine gerade angelegte Site-Seite hat noch keinen Zustand: Öffnest du eine Site, deren Claude Code im Terminal wartet, beginnt sie auf dem Tab Terminal.
Das Panel in src/agentPanel.ts bekommt eine Zeile, die das sagt. Füge das Feld unter waiting hinzu:
private inTerminal = h('p', { class: 'actions', hidden: true },
h('span', { class: 'dot ask', 'aria-hidden': 'true' }), 'Claude Code waits for you in the terminal.');setz es im Konstruktor hinter this.waiting ins Panel:
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.waiting, this.inTerminal, this.feed, this.summary, this.reply, this.msg);und zeig oder verbirg es in update(), direkt unter der Zeile für waiting:
this.waiting.hidden = !state?.ask;
this.inTerminal.hidden = !state?.needsTerminal;Auch der Kopf in src/session.ts zählt es als Warten:
/** The session's state; with the hooks, whether Claude Code works is theirs to say (they know first). */
update(state: TerminalState | undefined, agent?: AgentState) {
this.state = state;
const busy = Boolean(state?.claude && (agent?.hooked ? agent.busy : state.busy));
const waits = Boolean(state?.claude && (agent?.ask || agent?.needsTerminal));
this.dot.className = `dot${waits ? ' ask' : busy ? ' busy' : state?.claude ? ' on' : ''}`;
this.text.textContent = !state ? 'No session' : waits ? 'Claude Code waits for you' : busy ? 'Claude Code is working' : state.claude ? 'Claude Code is open' : 'Claude Code has exited';
this.start.hidden = Boolean(state?.claude);
this.end.hidden = !state;
// "Continue" only when the folder has a conversation to continue (asked when the session changes)
const key = `${Boolean(state)}-${Boolean(state?.claude)}`;
if (key === this.asked) return;
this.asked = key;
this.resume.hidden = true;
if (!state?.claude) void api<{ conversation: boolean }>('GET', this.url).then((r) => { this.resume.hidden = !r.conversation || Boolean(this.state?.claude); }, () => undefined);
}In einem anderen Lauf, bei Kiln & Co., hat der Tab Terminal nach dem Button das hier gezeigt, und das hat Claude Code gesagt, als die Frage dort mit Down und Enter beantwortet war:
# Kiln & Co.: the Terminal tab, 6 s after "Answer in the terminal" ☐ Button colourWhich accent colour should the buttons get?❯ 1. Terracotta (Recommended) Keeps the current clay orange, #b5582f. Matches the mugs and the warm cream background. 2. Glaze teal Deep blue-green, #2e4a4f, the same as the glaze on the mugs and bowls. Cooler and calmer.# … 5. Type something. 6. Chat about thisEnter to select · ↑/↓ to navigate · Esc to cancel# Down and Enter, typed in the Terminal tab:● Answered Claude's questions: ⎿ · Which accent colour should the buttons get? → Glaze teal
Der Lauf ging weiter und endete wie gewohnt, nach insgesamt einer halben Minute. Claude Code nimmt die Antwort, als wäre die Seite nie beteiligt gewesen.
Festgefahren, wo nur das Terminal hinsieht
Der Button und der Vertrauensdialog sind Fälle, von denen der Server weiß. Den letzten Fall muss er selbst herausfinden: Claude Code wartet auf etwas, und niemand hat dem Server gesagt, worauf. Die zweite Hälfte von check() folgt direkt auf die erste:
const atPrompt = await this.terminals.atEmptyPrompt({ name });
// a turn that ends without a Stop hook (Escape in the terminal, an error): the hooks still say
// busy, but the screen has sat still at an empty prompt for a while
if (s.hookBusy && !term.busy && atPrompt) {
if (!s.quietSince) s.quietSince = Date.now();
if (Date.now() - s.quietSince > 12000) {
s.hookBusy = false;
if (live(run)) this.end(name, 'stopped', 'The turn ended without a word: interrupted, or an error.');
}
} else s.quietSince = 0;
// neither working nor at its prompt: a dialog the page doesn't know, or text typed in and
// not sent. After a few quiet seconds (at once for a question handed to the terminal), the
// page brings the terminal on screen. Back at its prompt, it no longer waits.
if (atPrompt) {
s.strandedSince = 0;
s.needsTerminal = false;
} else if (!term.busy) {
if (!s.strandedSince) s.strandedSince = Date.now();
if (Date.now() - s.strandedSince > 4000) s.needsTerminal = true;
} else s.strandedSince = 0;
// with the hooks, the Stop hook ends the run; without them, only the screen can tell
if (s.hooked || !live(run)) 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) && atPrompt) this.end(name, 'done');
}atEmptyPrompt() liest den Bildschirm einmal, und seine Antwort, atPrompt, wird dreimal verwendet. Die erste Verwendung, die Runde, die ohne Stop-Hook endet, ist die Regel aus Teil 7, unverändert.
Die zweite ist neu. Claude Code ist festgefahren, wenn es weder arbeitet (der Bildschirm steht still) noch an seinem leeren Prompt steht. Etwas hält es fest, und weil die Seite nichts festhält (dieser Fall ist in der ersten Hälfte schon ausgestiegen), ist es etwas, das nur das Terminal zeigt: ein Dialog ohne Hook oder Text, den jemand ins Terminal getippt und nie abgeschickt hat. Nach vier Sekunden davon geht needsTerminal hoch. Zurück am Prompt geht es wieder runter.
Warum überhaupt warten? Zwischen zwei Schritten kann der Bildschirm von Claude Code einen Moment stillstehen, ohne dass Claude Code auf irgendwen wartet, und dafür soll die Seite nicht zum Terminal springen. Eine Frage, die du zurückgegeben hast, überspringt das Warten, denn answer() hat das Flag schon gesetzt.
Die dritte Verwendung ist das Ende einer Runde aus Teil 5 für Sitzungen ohne Hooks, das jetzt den Bildschirm von oben nimmt, statt ihn noch einmal zu lesen.
Claude Code hat weitergemacht
Eine Berechtigungsabfrage ist doppelt offen, in der Seite und im Terminal (Teil 9), und die Antwort, die zuerst kommt, gewinnt. Kommt sie aus dem Terminal, macht Claude Code weiter, und Teil 9 hat den Dialog der Seite stehen lassen, beantwortbar, aber sinnlos. Er muss weg, und wann, erfährt der Server aus dem nächsten Hook-Ereignis. Der Anfang von hookEvent() bekommt zwei neue Zeilen, direkt nach readTranscript:
/** A hook reported something. */
hookEvent(name: string, ev: HookEvent) {
const s = this.site(name);
s.hooked = true;
if (ev.transcript_path && ev.transcript_path !== s.transcript) {
s.transcript = ev.transcript_path;
// a continued conversation: only what comes from now on
try { s.transcriptPos = fs.statSync(ev.transcript_path).size; } catch { s.transcriptPos = 0; }
}
this.readTranscript(name);
this.moveOn(name, ev);
// whatever waited in the terminal was answered there: Claude Code goes on
if (ev.hook_event_name !== 'SessionStart') s.needsTerminal = false;
const run = s.run;Die erste ruft eine neue Methode auf. Füge sie nach hookAsk() ein:
/**
* Claude Code went on past what the page still shows: it was answered in the terminal, or the
* hook gave up. A new prompt, the end of its turn, or another tool: the page's dialog goes.
*/
private moveOn(name: string, ev: HookEvent) {
const p = this.site(name).ask;
if (!p || p.ask.kind === 'trust') return;
const past = ev.hook_event_name === 'Stop' || ev.hook_event_name === 'UserPromptSubmit'
|| (ev.hook_event_name === 'PreToolUse' && (p.ask.kind === 'permission' || ev.tool_use_id !== p.event?.tool_use_id));
if (past) this.settle(p, { status: 'release' });
}Drei Ereignisse heißen, dass Claude Code an dem vorbei ist, was die Seite noch zeigt: das Ende seiner Runde, ein neuer Prompt und ein neues Werkzeug. Bei einer Berechtigungsabfrage ist jedes PreToolUse danach ein neues Werkzeug, denn das PreToolUse ihres eigenen Werkzeugs kam vor der Abfrage. Bei einer Frage ist es anders: Ihr eigenes PreToolUse ist genau der Hook, der sie festhält, also zählt nur ein Werkzeug mit einer anderen tool_use_id. Das deckt auch einen Hook ab, der aus irgendeinem Grund ohne die Seite zu Ende ging: Claude Code macht weiter, und die Seite folgt. Der Vertrauensdialog bleibt außen vor, denn sein Ende sieht man auf dem Bildschirm.
Die Zeile nach moveOn tut dasselbe für needsTerminal: Jedes Ereignis außer SessionStart heißt, dass Claude Code nicht mehr im Terminal wartet. Ein Start sagt nur, dass Claude Code läuft, nicht, dass etwas beantwortet wurde.
Auch hookAsk() bekommt zwei Zeilen:
/**
* A hook holds Claude Code for the page: a question or a permission prompt. With no page open,
* nobody could answer: Claude Code asks in the terminal instead.
*/
hookAsk(name: string, ev: HookEvent): { id: string } | { release: true } {
if (this.pages() === 0) return { release: true };
// a question that went to the terminal shows there as Claude Code's own dialog, which asks
// for permission too: that one is answered in the terminal
if (ev.hook_event_name === 'PermissionRequest' && ev.tool_name === 'AskUserQuestion') return { release: true };
const s = this.site(name);
s.hooked = true;
// the same question again: the hook lost its connection and asks once more
if (ev.tool_use_id && s.ask?.event?.tool_use_id === ev.tool_use_id) return { id: s.ask.ask.id };
// a newer question replaces an older one that is still open
if (s.ask) this.settle(s.ask, { status: 'release' });
const id = crypto.randomUUID();
let ask: Ask;
if (ev.hook_event_name === 'PermissionRequest') {
const input = ev.tool_input ?? {};
const detail = [input.command, input.file_path, input.url].find((v) => typeof v === 'string') as string | undefined;
const summary = describeTool(String(ev.tool_name), input);
ask = { id, kind: 'permission', tool: String(ev.tool_name), summary, detail, remember: Boolean(ev.permission_suggestions?.length), since: Date.now() };
this.note(name, { kind: 'note', text: `Asks for permission: ${summary}` });
} else {
ask = { id, kind: 'questions', questions: (ev.tool_input?.questions ?? []) as Question[], since: Date.now() };
}
const p: Pending = { ask, site: name, event: ev, result: null, waiters: [] };
this.pending.set(ask.id, p);
s.ask = p;
s.needsTerminal = false;
this.changed(name);
return { id: ask.id };
}Ein neues Ask löscht needsTerminal: Claude Code fragt etwas Neues, also ist vorbei, was es im Terminal festgehalten hat. Und eine Frage, die der Server schon hält, wird nicht zweimal angenommen. Das passiert, wenn der Server die Frage angenommen hat, seine Antwort an den Hook aber verloren ging: Der Hook kennt die ID nicht und fragt noch einmal, mit demselben Ereignis. Die tool_use_id verrät es, und der Hook bekommt die ID, die ihm gefehlt hat, statt eines zweiten Dialogs, der den ersten ersetzt. Das Ereignis einer Berechtigungsabfrage hat keine tool_use_id, das trifft also nur auf Fragen zu.
Als Letztes auf dem Server settle(). Nach dem Ergebnis des Vertrauensdialogs fragt niemand, es bliebe also für immer in pending. Es geht sofort:
/** The question is settled: whoever waits for it hears how. */
private settle(p: Pending, r: WaitResult) {
p.result = r;
const s = this.site(p.site);
if (s.ask === p) s.ask = null;
for (const w of p.waiters.splice(0)) w(r);
// nobody waits for the trust dialog's answer: it is given with keys
if (!p.event) this.pending.delete(p.ask.id);
this.changed(p.site);
}Ein Server, der neu startet
Du wirst den Server neu starten, nach einer Änderung an seinem Code oder weil er abgestürzt ist. Claude Code merkt davon nichts, denn seine Sitzungen gehören tmux (Teil 3). Ein festgehaltener Hook merkt es schon: Sein Long Poll bricht ab, und der Server, der zurückkommt, hat von seiner Frage nie gehört. Füge in server/hook.ts sleep hinzu und ersetze wait():
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
/**
* Holds Claude Code until the page answers. The server keeps each wait open for up to 25 seconds
* and then says "pending": the hook simply asks again. A server that restarts has forgotten the
* question (404): the hook asks it again. A server that is gone gets a minute to come back.
* Returns what Claude Code should get, or null to let it ask in the terminal.
*/
async function wait(base: string, event: HookInput): Promise<unknown> {
let id: string | null = null;
let lost = 0;
for (;;) {
try {
if (!id) {
const asked = await call(`${base}/api/hooks/ask`, 'POST', { site, event }, 5000);
if (!asked || asked.release) return null;
id = String(asked.id);
}
const r = await call(`${base}/api/hooks/wait/${encodeURIComponent(id)}`, 'GET', undefined, 35000);
lost = 0;
if (!r) { id = null; continue; }
if (r.status === 'release') return null;
if (r.status === 'answered') return r.output;
} catch {
if (++lost > 12) return null;
await sleep(5000);
}
}
}Der Hook merkt sich jetzt zwei Dinge: die ID seiner Frage und wie oft er hintereinander keinen Server gefunden hat. Jede Runde stellt die Frage, wenn es noch keine ID gibt, und wartet dann auf die Antwort. Ein 404 heißt, dass ein Server da ist, die ID aber nicht kennt: Er hat neu gestartet. Der Hook vergisst die ID und fragt noch einmal, und der neue Server zeigt die Frage als neuen Dialog. Was du im alten schon ausgewählt hattest, ist weg, aber die Frage ist wieder da.
Gar keine Antwort, weil der Server weg ist oder der Aufruf zu lange gedauert hat, zählt als verloren, und der Hook versucht es fünf Sekunden später wieder, bis zu zwölfmal hintereinander: etwa eine Minute. Scheitert auch der letzte Versuch, gibt er auf und gibt null zurück: keine Ausgabe, und Claude Code fragt im Terminal. Eine Minute reicht für einen Neustart gut, und sie ist kurz genug, dass Claude Code nicht an einem Server hängt, der für immer weg ist.
Zwei Dinge solltest du wissen. Der Hook hat den Server beim Start über server.json gefunden und behält diese Adresse: Ein Server, der auf demselben Port zurückkommt, wird wiedergefunden, einer auf einem anderen Port nicht. Und der neue Server zeigt die Frage nur, wenn eine Seite verbunden ist. Die Seite verbindet sich in ihrem eigenen Takt neu, und ist der Hook schneller, sieht der Server keine Seite und lässt die Frage ans Terminal gehen, wie im ersten Fall der Liste. Im Test unten war die Seite zuerst zurück.
Probier es aus
Starte den Server neu, lade die Seite neu und geh die Fälle durch:
Eine neue Site. Leg eine an und schick ihren ersten Auftrag. Statt einer Sitzung, die still am Vertrauensdialog wartet, zeigt die Seite den Dialog (siehe den Screenshot oben). Im Test ging Kiln & Co. durch drei Dialoge in der Seite, den Vertrauensdialog, die Fragen von Claude Code und eine Berechtigungsabfrage, und war nach 53 Sekunden fertig.
Eine Frage zurückgeben. Schick einen Auftrag, der etwas offenlässt, und wähle Answer in the terminal, wenn die Frage kommt. Der Tab Terminal kommt nach vorne; antworte dort mit den Pfeiltasten und Enter.
Keine Seite. Schließ die Seite und schick einen Auftrag mit
curl, wie in Teil 5. Die Frage geht direkt ans Terminal, und wenn du die Site öffnest, beginnt die Seite auf dem Tab Terminal. Im Test stand im Zustand der SiteneedsTerminal: true.Ein Neustart. Halte den Server mit Strg+C an, während eine Frage in der Seite offen ist, und starte ihn wieder. Im Test kam der Server um 12:57:53 zurück, während eine Frage zu den Kurspreisen wartete. 5,4 Sekunden später hatte der Hook noch einmal gefragt, der Dialog war wieder da, und Claude Code machte mit der Antwort weiter, die dort gegeben wurde.
Ein geschlossener Tab. Schließ die Seite, während eine Frage offen ist, warte zwanzig Sekunden und schau mit
tmux -L sitesmith attach -t <site>hinein: Die Frage wartet im Terminal.
Was du jetzt hast
Eine Seite, die nicht antworten kann, lässt Claude Code nicht mehr auf sich warten. Jede Frage landet dort, wo sie beantwortet werden kann: in der Seite, solange eine da ist, im Terminal, wenn keine da ist oder wenn du es so willst. Und die Seite weiß, wann Claude Code im Terminal wartet, sagt es und zeigt dir das Terminal.
Eine Regel hat den ganzen Teil getragen: Im Zweifel geht es zurück an den eigenen Dialog von Claude Code. Der ist immer da, er funktioniert immer, und die Hooks waren nie mehr als ein schnellerer Weg um ihn herum.
Im nächsten Teil zeigt Claude Code seinen Plan, bevor es etwas ändert, und du gibst ihn in der Seite frei. Dafür muss der Server den Modus von Claude Code umschalten, und das hat bisher nur deine Tastatur getan.
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.

