Zum Inhalt springen

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

Teil 8: Die Fragen von Claude Code in der Seite

Das Herz von Sitesmith: Ein PreToolUse-Hook hält Claude Code an, wenn es eine Frage stellt, der Server gibt die Frage an die Seite, und deine Antwort geht als Ausgabe des Hooks zurück, sodass Claude Code weitermacht, als hättest du im Terminal geantwortet.

Quest-Ziele

  • Claude Code einladen, vor dem Bauen zu fragen, mit Skizzen als Vorschau
  • Den ganzen Weg verfolgen: Hook, Server, Seite, Antwort, Ausgabe des Hooks
  • Einen Hook mit Long Polling halten und ihm einen Tag Geduld geben
  • AskUserQuestion mit permissionDecision und updatedInput beantworten
  • Die Fragen in einem Dialog zeigen, mit Optionen, „Other“ und Vorschau
  • Aufs Terminal zurückfallen, wann immer die Seite nicht antworten kann

Claude Code fragt nach. Bevor es eine Site baut, möchte es vielleicht wissen, welcher Stil dir gefällt, welche Seiten die Site haben soll, wie ihre Texte klingen sollen. Dafür hat es ein Werkzeug, AskUserQuestion, und im Terminal zeigt es die Fragen als Dialog: Optionen, die du mit den Pfeiltasten wählst, und eine Zeile für deine eigene Antwort.

Bisher wartet dieser Dialog im Terminal, während die Seite „working“ anzeigt. Dieser Teil holt die Fragen von Claude Code in die Seite: als Dialog mit denselben Optionen, den Vorschauen, die Claude Code dafür gezeichnet hat, und einem Feld für deine eigenen Worte. Deine Antwort geht zurück an Claude Code, als hättest du sie im Terminal gegeben, und der eigene Dialog von Claude Code öffnet sich nie.

Möglich macht das eine Eigenschaft von Hooks: Claude Code wartet auf sie. Ein PreToolUse-Hook läuft, bevor ein Werkzeug läuft, und solange der Hook läuft, wartet das Werkzeug. Der Hook kann Claude Code also anhalten, die Frage an die Seite geben, auf deine Antwort warten, so lange es dauert, und diese Antwort dann als seine Ausgabe an Claude Code übergeben. In diesem Teil dreht sich alles um diesen Hin- und Rückweg, und er ist das Herz von Sitesmith: Die nächsten Teile schicken Berechtigungsabfragen und Pläne auf demselben Weg.

Eine Frage reist von Claude Code über einen Hook zur Seite, und die Antwort kommt auf demselben Weg zurück.
Eine Frage reist von Claude Code über einen Hook zur Seite, und die Antwort kommt auf demselben Weg zurück.

Zu Fragen einladen

Claude Code fragt, wenn es meint, dass etwas offen ist, und bisher hat der Auftrag ihm gesagt, es solle bauen. Lade in server/requests.ts zu Fragen ein:

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)'}

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

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

Der neue Absatz sagt, wann es fragen soll (wenn etwas Wichtiges offen ist), wie (mit AskUserQuestion, zwei bis vier Optionen, die empfohlene zuerst) und wonach nicht. Der letzte Satz ist wichtig: Ein Modell, das zum Fragen eingeladen wurde, fragt gern nach allem.

Der Satz über das Layout nutzt ein Feld des Werkzeugs, das die Dokumentation der Hooks nicht beschreibt: Eine Option von AskUserQuestion kann eine preview mitbringen, einen kurzen Text, der mit ihr gezeigt wird. Eine Skizze der Seite aus reinem Text passt gut hinein, und die Seite wird sie neben den Optionen zeigen. Im Test hat Haiku Bergblick, Harbor Books und Tidepool nach denselben vier Dingen gefragt: dem Stil, dem Layout (mit Skizzen), den Seiten und dem Ton der Texte.

Der Hin- und Rückweg

Vor dem Code einmal der ganze Weg, von dem Moment, in dem Claude Code beschließt zu fragen, bis es mit deiner Antwort weitermacht:

  1. Claude Code ruft AskUserQuestion auf. Bevor das Werkzeug läuft, führt Claude Code die PreToolUse-Hooks aus. Der Matcher von Sitesmith ist *, also startet server/hook.ts und liest das Ereignis von stdin: den Namen des Werkzeugs und seine Eingabe mit den Fragen. Claude Code wartet, bis der Hook endet.

  2. Der Hook meldet, dann fragt er. Wie jedes Ereignis geht auch dieses zuerst an /api/hooks/event, und der Verlauf zeigt „Asking you something“. Weil es eine Frage ist, schickt der Hook sie danach an /api/hooks/ask. Der Server hebt sie als offene Frage der Site auf, gibt ihr eine ID, schickt den neuen Zustand an jede offene Seite und antwortet mit der ID.

  3. Der Hook wartet. Er ruft /api/hooks/wait/<id> auf. Der Server hält diese Anfrage offen, bis es eine Antwort gibt, oder 25 Sekunden lang, und antwortet dann „pending“; der Hook fragt sofort wieder. Das ist Long Polling: Der Hook wartet immer an einer offenen Anfrage, also kann die Antwort losgehen, sobald es sie gibt.

  4. Die Seite zeigt den Dialog. Der neue Zustand erreicht die Seite über ihre Server-Sent Events. Der Zustand der geöffneten Site trägt die Frage, und die Seite öffnet dafür einen Dialog.

  5. Du antwortest. Die Seite schickt deine Wahl an /api/sites/<site>/answer.

  6. Der Server erledigt die Frage. Er macht aus deinen Antworten die Ausgabe des Hooks, beendet damit den offenen Long Poll und sagt den Seiten, dass nichts mehr wartet. Der Dialog schließt sich, in jedem Fenster, das ihn zeigt.

  7. Der Hook antwortet Claude Code. Er schreibt die Ausgabe als JSON nach stdout und endet mit Exit-Code 0.

  8. Claude Code macht weiter. Die Ausgabe sagt: Erlaube das Werkzeug, mit einer Eingabe, die so geändert ist, dass sie deine Antworten enthält. AskUserQuestion läuft mit den schon gegebenen Antworten, zeigt keinen Dialog und reicht sie als deine an das Modell weiter. Die Runde geht weiter.

Geht unterwegs etwas schief (kein Server, keine Seite, ein Fehler), endet der Hook ohne Ausgabe, und Claude Code zeigt seinen eigenen Dialog im Terminal, als gäbe es keinen Hook. Das ist die Regel aus Teil 6, und sie ist es, die die Seite verlässlich macht: Im schlimmsten Fall bleibt das Terminal.

Was der Hook bekommt

Hier die Eingabe des Hooks für Tidepool, die Surfschule im Screenshot weiter unten, mit zwei ihrer vier Fragen (gekürzt, mit neutralen Pfaden):

json
{
  "session_id": "…",
  "transcript_path": "/home/you/.claude/projects/…/….jsonl",
  "cwd": "/home/you/sitesmith/sites/tidepool",
  "hook_event_name": "PreToolUse",
  "tool_name": "AskUserQuestion",
  "tool_input": {
    "questions": [
      {
        "question": "Which visual style should the Tidepool site have?",
        "header": "Style",
        "options": [
          { "label": "Sunny & sandy (Recommended)", "description": "Warm sand and sea-blue palette, rounded shapes, bright photo-led look. Feels like a beach school." },
          { "label": "Deep ocean", "description": "Dark navy and teal, bold type, moody photography. More dramatic, more 'surf brand'." },
          { "label": "Minimal & calm", "description": "White space, one accent colour, thin type. Lets the photos and the café van speak." }
        ]
      },
      {
        "question": "Which pages should the first version include?",
        "header": "Pages",
        "options": [
          { "label": "Courses & camps (Recommended)", "description": "…" },
          { "label": "Rental & café", "description": "…" },
          { "label": "Contact & find us", "description": "…" },
          { "label": "About the school", "description": "…" }
        ],
        "multiSelect": true
      }
    ]
  },
  "tool_use_id": "…"
}

Sitesmith liest tool_name und tool_input. Die Fragen stehen in tool_input.questions, jede mit ihrem Text, einem kurzen header, ihren Optionen mit Label und Beschreibung und multiSelect, wenn du mehrere wählen darfst. Die Frage zum Layout, die hier fehlt, hatte außerdem an jeder Option eine preview.

Der Hook hält Claude Code an

Ersetze server/hook.ts durch:

server/hook.ts
/**
 * What Claude Code runs for its hooks, in the sessions Sitesmith starts: it reads the event from
 * stdin and posts it to the server. The session's environment names the site (SITESMITH_SITE) and
 * the server's data folder (SITESMITH_DATA), where server.json says on which port it listens.
 *
 * Most events are only reported. A question (AskUserQuestion) is held: the hook waits until the
 * page has answered, and hands the answers to Claude Code as its output, so Claude Code's own
 * dialog never opens.
 *
 * A hook must never get in Claude Code's way: whatever goes wrong (no server, a timeout, odd
 * input), it ends quietly with exit code 0 and no output, and Claude Code carries on as if there
 * were no hook: it asks in the terminal.
 */
import fs from 'node:fs';
import path from 'node:path';

interface HookInput {
  hook_event_name: string;
  tool_name?: string;
}

const site = process.env.SITESMITH_SITE;
const data = process.env.SITESMITH_DATA;

async function stdin() {
  let raw = '';
  for await (const chunk of process.stdin) raw += chunk;
  return raw;
}

function serverUrl() {
  try {
    const { port } = JSON.parse(fs.readFileSync(path.join(data!, 'server.json'), 'utf8')) as { port: number };
    return `http://127.0.0.1:${port}`;
  } catch { return null; }
}

/** A call to the server; null when it answers 404. */
async function call(url: string, method: string, body: unknown, ms: number) {
  const res = await fetch(url, {
    method,
    headers: body === undefined ? {} : { 'content-type': 'application/json' },
    body: body === undefined ? undefined : JSON.stringify(body),
    signal: AbortSignal.timeout(ms),
  });
  if (res.status === 404) return null;
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  return res.json() as Promise<Record<string, unknown>>;
}

/**
 * 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. Returns what Claude Code should get, or
 * null to let it ask in the terminal.
 */
async function wait(base: string, event: HookInput): Promise<unknown> {
  const asked = await call(`${base}/api/hooks/ask`, 'POST', { site, event }, 5000);
  if (!asked || asked.release) return null;
  for (;;) {
    const r = await call(`${base}/api/hooks/wait/${encodeURIComponent(String(asked.id))}`, 'GET', undefined, 35000);
    if (!r || r.status === 'release') return null;
    if (r.status === 'answered') return r.output;
  }
}

async function main() {
  const raw = await stdin();
  if (!site || !data) return;
  const base = serverUrl();
  if (!base) return;
  const event = JSON.parse(raw) as HookInput;
  // every event is reported, a question too
  await call(`${base}/api/hooks/event`, 'POST', { site, event }, 2000).catch(() => undefined);
  if (event.hook_event_name === 'PreToolUse' && event.tool_name === 'AskUserQuestion') {
    const output = await wait(base, event);
    if (output) process.stdout.write(JSON.stringify(output));
  }
}

await main().catch(() => undefined);
process.exit(0);

main() meldet jedes Ereignis wie bisher, jetzt über call(); scheitert die Meldung, wird das übergangen, und eine Frage wird trotzdem gestellt. Danach wartet es, beim PreToolUse von AskUserQuestion und nur dort, auf die Seite, und wenn wait() eine Ausgabe bringt, schreibt es sie nach stdout. Die letzte Zeile bleibt, wie sie war: Exit-Code 0, immer.

call() ist eine Anfrage mit Zeitlimit. Eine 404 heißt, dass der Server nicht weiß, wovon der Hook spricht, und kommt als null zurück; jeder andere Fehler wirft.

wait() fragt einmal und pollt dann, bis die Frage beantwortet oder freigegeben ist. Achte auf die zwei Zeitlimits: Der Server hält jeden Poll 25 Sekunden lang, der Hook gibt jedem 35. Ein „pending“ kommt also immer an, bevor die Geduld des Hooks für diese Anfrage endet. Vergehen 35 Sekunden ganz ohne Antwort, stimmt mit dem Server etwas nicht: Die Anfrage wird abgebrochen, der Fehler beendet den Hook still, und die Frage geht ans Terminal.

Warum nicht eine Anfrage, die stundenlang offen bleibt? Weil eine Anfrage, die seit einer Stunde offen ist, eine langsame Antwort nicht von einer toten Verbindung unterscheiden kann. Polls von 25 Sekunden halten beide Seiten sicher, dass die andere noch da ist. Ein Server, der anhält, während der Hook wartet, fällt spätestens beim nächsten Poll auf: Der Hook endet, und das Terminal übernimmt. (Teil 10 macht den Hook geduldiger mit einem Server, der nur neu startet.)

Was auch immer den Hook ohne Ausgabe beendet (eine Freigabe, eine 404, ein Fehler), er endet mit 0 und schreibt nichts. Für Claude Code ist das ein Hook ohne Entscheidung, und es macht weiter, als gäbe es keinen Hook: Es zeigt seinen eigenen Dialog.

Ein Tag Geduld

Claude Code wartet nicht ewig auf einen Hook: Es bricht ihn nach seinem timeout ab, nach zehn Minuten, wenn die Einstellungen nichts anderes sagen. Eine Frage kann leicht länger warten, wenn du zum Mittagessen gegangen bist. Ersetze in server/agent.ts den Anfang der Klasse Agent bis zum Ende des Konstruktors:

server/agent.ts
export class Agent {
  /** the settings file with the hooks, passed to every session with --settings */
  readonly settingsFile: string;
  private terminals: Terminals;
  private emit: (ev: ServerEvent) => void;
  private sites = new Map<string, SiteAgent>();
  private pending = new Map<string, Pending>();
  /** how many pages are open */
  private pages: () => number;

  constructor(app: string, data: string, terminals: Terminals, emit: (ev: ServerEvent) => void, pages: () => number) {
    this.terminals = terminals;
    this.emit = emit;
    this.pages = pages;
    // the hook script runs on the Node that runs this server; quoted for the shell Claude Code uses
    const quote = (s: string) => `'${s.replace(/'/g, `'\\''`)}'`;
    const command = `${quote(process.execPath)} --disable-warning=ExperimentalWarning ${quote(path.join(app, 'server', 'hook.ts'))}`;
    const hook = (timeout?: number) => [{ type: 'command', command, ...(timeout ? { timeout } : {}) }];
    const settings = {
      hooks: {
        SessionStart: [{ hooks: hook() }],
        UserPromptSubmit: [{ hooks: hook() }],
        // a question may wait for hours: Claude Code cancels a hook after `timeout` seconds
        PreToolUse: [{ matcher: '*', hooks: hook(86400) }],
        Stop: [{ hooks: hook() }],
      },
    };
    this.settingsFile = path.join(data, 'claude-hooks.json');
    fs.mkdirSync(data, { recursive: true });
    fs.writeFileSync(this.settingsFile, `${JSON.stringify(settings, null, 2)}\n`);
    terminals.setHooks(this.settingsFile, data);
    // 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();
  }

hook() nimmt jetzt ein Timeout in Sekunden, und PreToolUse bekommt 86400: einen Tag. Das gilt für jedes Werkzeug, denn der Matcher ist *, aber der Hook jedes anderen Werkzeugs endet einen Moment nach seiner Meldung, also nutzt es nur eine Frage je aus.

Der Konstruktor bekommt außerdem pages, eine Funktion, die sagt, wie viele Seiten offen sind, und die Klasse eine Map dessen, was wartet, nach ID. In server/main.ts ist die Zahl der Seiten die Zahl der Verbindungen zu /api/events: eine pro offener Seite. Ersetze die Zeile, die den Agenten anlegt:

server/main.ts
const agent = new Agent(APP, DATA, terminals, broadcast, () => clients.size);

Was wartet, auf dem Server

Zuerst die Typen, die Seite und Server teilen. Ersetze in shared/types.ts AgentState durch das hier, mit den neuen Typen davor:

shared/types.ts
/** One of Claude Code's questions (AskUserQuestion's input). */
export interface Question {
  question: string;
  /** a short label, shown as a chip */
  header?: string;
  options: { label: string; description?: string; preview?: string }[];
  multiSelect?: boolean;
}

/** What Claude Code waits for the page to answer. */
export type Ask = { id: string; kind: 'questions'; questions: Question[]; 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>;
}

/** 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;
}

Question ist eine Frage, wie AskUserQuestion sie nimmt, mit den Feldern, die die Seite braucht. Ask ist etwas, worauf Claude Code wartet, damit die Seite es beantwortet, mit einer ID und dem Zeitpunkt, an dem es begann; vorerst gibt es eine Art, Fragen, und der nächste Teil fügt eine zweite hinzu. AnswerBody ist, was die Seite zurückschickt: pro Fragetext die Antwort. Und AgentState sagt der Seite, was sie dich fragen soll.

Nimm in server/agent.ts AnswerBody, Ask und Question in den Import aus ../shared/types.ts auf und setz diese zwei Typen hinter HookEvent:

server/agent.ts
/** How a held hook ends: with the output for Claude Code, or released to the terminal. */
type WaitResult = { status: 'answered'; output: unknown } | { status: 'release' } | { status: 'pending' };

/** Something Claude Code waits for, with the hook that holds it. */
interface Pending {
  ask: Ask;
  site: string;
  event: HookEvent;
  result: WaitResult | null;
  /** the hook's long polls, waiting for the result */
  waiters: ((r: WaitResult) => void)[];
}

WaitResult ist, wie ein gehaltener Hook endet: answered, mit der Ausgabe für Claude Code; release, wenn der Hook ohne Ausgabe enden soll, damit Claude Code im Terminal fragt; oder pending, noch nichts, frag noch einmal. Pending ist die Seite des Servers an einem gehaltenen Hook: das Ask, das die Seiten sehen, das Ereignis des Hooks (die Antwort braucht dessen tool_input), das Ergebnis, sobald es eines gibt, und die Long Polls, die darauf warten.

Eine Site hat höchstens ein offenes Ask. Füg das Feld in SiteAgent nach activity ein:

server/agent.ts
/** what Claude Code waits for the page to answer */
ask: Pending | null;

und ersetze site(), busy() und state():

server/agent.ts
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, 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) 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 };
}

Während Claude Code auf dich wartet, arbeitet es nicht, und busy() sagt das auch. state() gibt das offene Ask an die Seiten weiter.

Jetzt das Herzstück. Füg diese drei Methoden in die Klasse ein, nach hookEvent():

server/agent.ts
/**
 * A hook holds Claude Code for the page: a question. 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 };
  const s = this.site(name);
  s.hooked = true;
  // a newer question replaces an older one that is still open
  if (s.ask) this.settle(s.ask, { status: 'release' });
  const questions = (ev.tool_input?.questions ?? []) as Question[];
  const ask: Ask = { id: crypto.randomUUID(), kind: 'questions', questions, since: Date.now() };
  const p: Pending = { ask, site: name, event: ev, result: null, waiters: [] };
  this.pending.set(ask.id, p);
  s.ask = p;
  this.changed(name);
  return { id: ask.id };
}

/**
 * The hook's long poll: the answer, 'release' (the terminal asks), or 'pending' after `ms`, when
 * the hook simply asks again. Null: no such question (the server restarted).
 */
hookWait(id: string, ms = 25000): Promise<WaitResult> | null {
  const p = this.pending.get(id);
  if (!p) return null;
  if (p.result) { this.pending.delete(id); return Promise.resolve(p.result); }
  return new Promise((resolve) => {
    const done = (r: WaitResult) => { clearTimeout(timer); this.pending.delete(id); resolve(r); };
    const timer = setTimeout(() => {
      p.waiters = p.waiters.filter((w) => w !== done);
      resolve({ status: 'pending' });
    }, ms);
    p.waiters.push(done);
  });
}

/** 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);
  this.changed(p.site);
}

hookAsk() beantwortet den ersten Aufruf des Hooks. Ist keine Seite offen, gibt es die Frage sofort frei: Niemand könnte sie beantworten, und Claude Code soll nicht auf niemanden warten. Sonst legt es das Ask mit einer frischen ID an, hebt es doppelt auf (in pending unter seiner ID, für den Hook, und als ask der Site, für die Seiten) und sagt es den Seiten. Eine Frage, die noch offen ist, wenn eine neue kommt, wird freigegeben: Es zählt die neuere.

hookWait() ist der Long Poll. Ist das Ergebnis schon da, weil die Frage zwischen zwei Polls erledigt wurde, kommt es sofort zurück. Sonst wartet der Poll als Promise, das settle() mit dem Ergebnis auflöst oder der Timer nach 25 Sekunden mit pending. Ein Ergebnis wird einmal ausgegeben: Der Poll, der es bekommt, nimmt die Frage aus pending. Eine ID, die der Server nicht kennt, ergibt null, und die Route macht daraus eine 404. Das passiert nach einem Neustart des Servers: Die Map lebte in seinem Speicher.

settle() beendet das Warten: Es hebt das Ergebnis für einen Poll auf, der später kommt, löscht das Ask der Site, gibt das Ergebnis an jeden Poll, der gerade wartet, und sagt es den Seiten.

Die Antwort

Füg answer() nach settle() ein:

server/agent.ts
/**
 * The page's answers. They go back as the hook's output: "allow" the tool, with its input
 * extended by `answers` (per question text, the chosen labels or your own words). Claude Code
 * takes that as the user's answer and never shows its own dialog.
 */
answer(name: string, req: Partial<AnswerBody>) {
  const p = this.site(name).ask;
  if (!p || p.ask.id !== req.id) throw new Error('That question is no longer open.');
  const answers: Record<string, string> = {};
  for (const q of p.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 },
      },
    },
  });
}

Es prüft, dass die Antwort zu der Frage gehört, die offen ist (eine Antwort auf eine, die schon weg ist, bekommt „That question is no longer open“), und dass jede Frage eine Antwort hat. Es notiert deine Wahl im Verlauf und erledigt die Frage mit der Ausgabe für Claude Code. Hättest du bei jeder der vier Fragen von Tidepool die empfohlene Option gewählt, würde der Hook das hier schreiben:

json
{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "allow",
    "permissionDecisionReason": "Answered in Sitesmith",
    "updatedInput": {
      "questions": ["… the four questions, unchanged …"],
      "answers": {
        "Which visual style should the Tidepool site have?": "Sunny & sandy (Recommended)",
        "Which layout should the home page use?": "Hero + cards (Recommended)",
        "Which pages should the first version include?": "Courses & camps (Recommended)",
        "What tone should the texts have?": "Friendly & relaxed (Recommended)"
      }
    }
  }
}

Feld für Feld:

  • hookSpecificOutput.hookEventName nennt das Ereignis, für das diese Ausgabe gilt: PreToolUse.

  • permissionDecision: "allow" lässt das Werkzeug laufen, ohne um Erlaubnis zu fragen.

  • permissionDecisionReason ist eine kurze Begründung, fürs Protokoll.

  • updatedInput tritt an die Stelle der Eingabe des Werkzeugs. Deshalb ist es die ursprüngliche Eingabe, ausgebreitet, mit answers dazu: pro Fragetext deine Antwort. Bei einer Frage mit mehreren Antworten werden die Labels mit Komma und Leerzeichen verbunden, etwa "Courses & camps (Recommended), Rental & café"; mit „Other“ treten deine eigenen Worte an die Stelle eines Labels.

Ein "allow" allein reicht nicht. Erst die Antworten in updatedInput machen aus dem Aufruf des Werkzeugs deine Antwort: Das Werkzeug findet seine Fragen beantwortet vor und hat nichts mehr zu fragen.

Stop lässt los

Eine Frage gehört zu der Runde, die sie gestellt hat. Stoppst du den Lauf, muss auch die Frage gehen. Ersetze stop():

server/agent.ts
/** Interrupts Claude Code: Escape in its session, as you would press it. */
async stop(t: Target) {
  const s = this.site(t.name);
  s.queue = [];
  // a question or a permission prompt the page holds goes with the turn
  if (s.ask) this.settle(s.ask, { status: 'release' });
  await this.terminals.keys(t, 'Escape').catch(() => undefined);
  // an interrupted turn ends without a Stop hook
  s.hookBusy = false;
  this.end(t.name, 'stopped');
  this.changed(t.name);
}

Bevor es Escape drückt, erledigt stop() das offene Ask mit release. Damit ist das Ask der Site weg, der Dialog schließt sich in jeder Seite, und ein Hook, der noch wartet, endet ohne Ausgabe. Ohne diese Zeile bliebe der Dialog in der Seite stehen, obwohl der Lauf gestoppt ist. Der Kommentar nennt schon Berechtigungsabfragen: Die bringt der nächste Teil, und sie gehen denselben Weg.

Die Routen

Nimm in server/main.ts AnswerBody in den Import aus ../shared/types.ts auf und ersetze die Route der Hooks durch diese vier, die Route der Seite zuerst:

server/main.ts
// the page answers what Claude Code asks
['POST', /^\/api\/sites\/([^/]+)\/answer$/, async (req, res, m) => {
  const site = sites.get(m[1]);
  try { agent.answer(site.name, await readJson<AnswerBody>(req)); } catch (err) { throw new HttpError(409, (err as Error).message); }
  send(res, 200, agent.state(site.name));
}],

// Claude Code's hooks (server/hook.ts) report here, and wait here for the page's answers
['POST', /^\/api\/hooks\/event$/, async (req, res) => {
  const { site, event } = await readJson<{ site: string; event: HookEvent }>(req);
  if (site && sites.read(String(site)) && event?.hook_event_name) agent.hookEvent(String(site), event);
  send(res, 200, {});
}],
['POST', /^\/api\/hooks\/ask$/, async (req, res) => {
  const { site, event } = await readJson<{ site: string; event: HookEvent }>(req);
  if (!site || !sites.read(String(site)) || !event?.hook_event_name) throw new HttpError(400, 'site and event');
  send(res, 200, agent.hookAsk(String(site), event));
}],
['GET', /^\/api\/hooks\/wait\/([\w-]+)$/, async (_req, res, m) => {
  const wait = agent.hookWait(m[1]);
  if (!wait) throw new HttpError(404, 'no such question');
  send(res, 200, await wait);
}],

Die Seite antwortet über /api/sites/<site>/answer, und eine abgelehnte Antwort wird zu einer 409 mit ihrer Meldung. Die Hooks benutzen /api/hooks/ask und /api/hooks/wait/<id>. Die Warte-Route wartet einfach auf den Long Poll, und eine Frage, die der Server nicht kennt, wird zu der 404, die dem Hook sagt, sie dem Terminal zu überlassen.

Der Dialog

Leg src/askDialog.ts an. Die Datei hat zwei Klassen. Die erste ist der Teil des Dialogs für eine Frage:

src/askDialog.ts
import { api } from './api.ts';
import { h } from './dom.ts';
import type { AnswerBody, Ask, Question } from '../shared/types.ts';

/**
 * One question's controls: its options (radio buttons, or checkboxes for multiSelect), "Other"
 * with your own words, and the preview of the option in focus.
 */
class QuestionField {
  readonly el: HTMLFieldSetElement;
  readonly q: Question;
  private inputs: HTMLInputElement[] = [];
  private other: HTMLInputElement;
  private otherText = h('input', { type: 'text', autocomplete: 'off', placeholder: 'Your own answer', 'aria-label': 'Your own answer' });
  private preview = h('pre', { class: 'ask-preview', hidden: true });

  constructor(q: Question, index: number, count: number, onChange: () => void) {
    this.q = q;
    const multi = Boolean(q.multiSelect);
    const name = `q${index}`;
    const withPreview = q.options.some((o) => o.preview);
    const opts = h('div', { class: 'opts', role: multi ? 'group' : 'radiogroup' });
    q.options.forEach((o, i) => {
      const input = h('input', { type: multi ? 'checkbox' : 'radio', name, value: o.label });
      input.onchange = () => { this.showPreview(o.preview); onChange(); };
      input.onfocus = () => this.showPreview(o.preview);
      this.inputs.push(input);
      opts.append(h('label', { class: 'opt' }, input, h('span', {},
        h('span', { class: 'opt-label' }, o.label),
        o.description ? h('span', { class: 'opt-desc' }, o.description) : null)));
      if (i === 0 && o.preview) this.showPreview(o.preview);
    });
    this.other = h('input', { type: multi ? 'checkbox' : 'radio', name });
    this.other.onchange = () => { if (this.other.checked) this.otherText.focus(); this.showPreview(undefined); onChange(); };
    this.otherText.oninput = () => { if (this.otherText.value && !this.other.checked) this.other.checked = true; onChange(); };
    opts.append(h('label', { class: 'opt' }, this.other, h('span', {}, h('span', { class: 'opt-label' }, 'Other'), this.otherText)));
    this.el = h('fieldset', { class: `ask-q${withPreview ? ' with-preview' : ''}` },
      h('legend', {},
        count > 1 ? h('span', { class: 'hint' }, `${index + 1}/${count}`) : null,
        q.header ? h('span', { class: 'chip' }, q.header) : null,
        h('span', {}, q.question),
        multi ? h('span', { class: 'hint' }, 'choose any number') : null),
      h('div', { class: 'ask-grid' }, opts, withPreview ? this.preview : null));
  }

  private showPreview(text: string | undefined) {
    this.preview.hidden = !text;
    this.preview.textContent = text ?? '';
  }

  /** The answer as Claude Code takes it: the chosen labels joined with ", ", or your own words. */
  value() {
    const picked = this.inputs.filter((i) => i.checked).map((i) => i.value);
    const own = this.other.checked ? this.otherText.value.trim() : '';
    return [...picked, ...(own ? [own] : [])].join(', ');
  }

  focus() { this.inputs[0]?.focus(); }
}

Jede Frage ist ein <fieldset>. Seine Legende zeigt, wo sie steht („2/4“), den Header als Chip, die Frage und „choose any number“, wenn du mehrere wählen darfst. Die Optionen sind Radiobuttons, oder Checkboxen bei multiSelect, mit einem Namen pro Frage, damit sich die Radiobuttons gegenseitig ausschließen. „Other“ ist eine weitere davon, mit einem Textfeld; wer darin tippt, hakt sie an.

Hat irgendeine Option eine Vorschau, bekommt die Frage die Klasse with-preview, die Optionen und ein Vorschaufeld nebeneinanderstellt. Das Feld zeigt die Vorschau der Option, die den Fokus hat oder zuletzt gewählt wurde, und am Anfang die der ersten Option. value() ist die Antwort, wie Claude Code sie nimmt: die gewählten Labels und deine eigenen Worte, mit „, “ verbunden, oder ein leerer String, solange nichts gewählt ist.

Die zweite Klasse ist der Dialog selbst. Füg sie darunter an:

src/askDialog.ts
/**
 * What Claude Code asks, as a dialog in the page. The server holds Claude Code (through its hook)
 * while the dialog is open. Escape puts the dialog aside; it stays open on the server, and the
 * page offers it again.
 */
export class AskDialog {
  readonly el: HTMLDialogElement;
  private heading = h('h2', { id: 'ask-title' });
  private sub = h('p', { class: 'ask-sub' });
  private body = h('div', { class: 'ask-body' });
  private foot = h('footer', { class: 'ask-foot' });
  private msg = h('p', { class: 'hint bad', 'aria-live': 'polite' });
  private ask: Ask | null = null;
  private site = '';
  /** the ask put aside with Escape */
  dismissed: string | null = null;

  constructor() {
    this.el = h('dialog', { class: 'ask', 'aria-labelledby': 'ask-title' },
      h('div', { class: 'ask-inner' },
        h('header', { class: 'ask-head' }, this.heading, this.sub),
        h('div', { class: 'ask-scroll' }, this.body, this.msg),
        this.foot));
    this.el.addEventListener('cancel', () => { this.dismissed = this.ask?.id ?? null; });
    document.body.append(this.el);
  }

  /** 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;
    this.renderQuestions(ask.questions);
    if (!this.el.open) this.el.showModal();
  }

  /** The ask is gone: answered here, in another window, or in the terminal. */
  close(id?: string) {
    if (id && this.ask?.id !== id) return;
    if (this.el.open) this.el.close();
    this.ask = null;
  }

  get openId() { return this.el.open ? this.ask?.id ?? null : null; }

  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 });
      this.close();
    } catch (err) {
      this.msg.textContent = (err as Error).message;
      buttons.forEach((b) => { b.disabled = false; });
    }
  }

  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(go);
    sync();
    requestAnimationFrame(() => fields[0]?.focus());
  }
}

Es ist ein natives <dialog>, geöffnet mit showModal(): Es liegt über der Seite, hält den Fokus in sich und schließt sich bei Escape mit einem cancel-Ereignis. renderQuestions() baut ein Feld pro Frage und einen einzigen Button, der deaktiviert bleibt, bis jede Frage eine Antwort hat.

show() tut nichts, wenn dasselbe Ask schon zu sehen ist. Der Zustand einer Site kommt bei jeder Änderung neu an (eine neue Zeile im Verlauf, das Ende eines Polls), und den Dialog jedes Mal neu zu zeichnen, würde wegwerfen, was du angehakt hast.

Escape lehnt nicht ab. Der cancel-Handler merkt sich das Ask als dismissed; der Dialog schließt sich, aber die Frage bleibt auf dem Server offen, und Claude Code wartet weiter. Vielleicht willst du dir die Vorschau oder das Terminal ansehen, bevor du antwortest. Das Panel bietet den Dialog wieder an.

send() deaktiviert die Buttons, solange die Antwort unterwegs ist. Ist sie angekommen, schließt sich der Dialog; bei einem Fehler erscheint die Meldung, und die Buttons kommen zurück.

Der erste Bau von Tidepool Surf School: vier Fragen in einem Dialog. Jede Option kommt mit der Beschreibung von Claude Code, „Other“ nimmt deine eigenen Worte, und die Frage zum Layout zeigt die Skizze, die Claude Code als Vorschau ihrer ersten Option gezeichnet hat.Den Screenshot in voller Größe öffnen
Der erste Bau von Tidepool Surf School: vier Fragen in einem Dialog. Jede Option kommt mit der Beschreibung von Claude Code, „Other“ nimmt deine eigenen Worte, und die Frage zum Layout zeigt die Skizze, die Claude Code als Vorschau ihrer ersten Option gezeichnet hat.

In die Seite

src/main.ts legt den einen Dialog der Seite an und entscheidet, wann er erscheint. Ersetze die Datei durch:

src/main.ts
import './style.css';
import { api, events } from './api.ts';
import { AskDialog } from './askDialog.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;
  const dialog = new AskDialog();

  /** What the open site's Claude Code waits for, as a dialog (unless you put it aside). */
  function syncAsk() {
    const ask = page ? agents.get(page.name)?.ask : null;
    if (!page || !ask) { dialog.close(); return; }
    if (dialog.dismissed === ask.id) return;
    dialog.show(page.name, sites.find((s) => s.name === page!.name)?.title ?? page.name, ask);
  }

  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);
      page.onAnswer = () => { dialog.dismissed = null; syncAsk(); };
      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);
    syncAsk();
  }

  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);
      syncAsk();
    } 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();

syncAsk() läuft, wann immer der Zustand einer Site ankommt und wann immer du eine andere Site öffnest. Es zeigt das Ask der geöffneten Site, außer du hast es beiseitegelegt, und schließt den Dialog, wenn es nichts zu fragen gibt. Nur die Fragen der geöffneten Site erscheinen: Die Frage einer anderen Site wartet, bis du diese öffnest (Teil 12 lässt die Seitenleiste darauf zeigen). onAnswer vergisst das Beiseitelegen und zeigt den Dialog wieder.

Das Panel bekommt die Zeile mit dem Answer-Button. Ersetze in src/agentPanel.ts die Klasse von ihrem Anfang bis zum Ende von update():

src/agentPanel.ts
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 feed = h('ol', { class: 'feed', 'aria-label': 'What Claude Code does', 'aria-live': 'polite' });
  private summary = h('div', { class: 'summary md', hidden: true });
  private replyText = h('input', { type: 'text', autocomplete: 'off', placeholder: 'Reply to Claude Code…', 'aria-label': 'Reply to Claude Code' });
  private reply = h('form', { class: 'reply', hidden: true }, this.replyText, h('button', { type: 'submit', class: 'small' }, 'Send'));
  private site: string;
  private waiting: HTMLElement;
  /** the page shows the dialog again ("Answer") */
  onAnswer: () => void = () => {};
  private msg = h('p', { class: 'hint bad', 'aria-live': 'polite' });
  private timer = 0;

  constructor(site: string) {
    this.site = site;
    this.url = `/api/sites/${site}/stop`;
    this.stopBtn.onclick = () => void this.stop();
    this.reply.onsubmit = (e) => { e.preventDefault(); void this.send(); };
    this.waiting = h('div', { class: 'actions', hidden: true },
      h('span', { class: 'dot ask', 'aria-hidden': 'true' }), h('span', {}, 'Claude Code waits for your answer.'),
      h('button', { type: 'button', class: 'small primary', onclick: () => this.onAnswer() }, 'Answer'));
    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.feed, this.summary, this.reply, 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());
    this.waiting.hidden = !state?.ask;
    if (run.status === 'working') this.timer = window.setInterval(() => { this.status.textContent = statusText(run, Date.now()); }, 1000);
    this.stopBtn.hidden = !isLive(run) || run.status === 'queued';
    // what it did for this run, the last few lines; at the end, what it said last instead
    const live = isLive(run);
    const mine = state!.activity.filter((a) => a.t >= run.queued - 1000).slice(-9);
    this.feed.replaceChildren(...mine.map((a) => h('li', { class: a.kind }, a.text)));
    this.feed.hidden = !mine.length || (!live && Boolean(run.summary));
    this.summary.hidden = live || !run.summary;
    if (!live && run.summary) this.summary.innerHTML = markdown(run.summary);
    this.reply.hidden = live;
  }

Der Kopf sagt „Claude Code waits for you“, solange eine Frage offen ist, und bei Sitzungen mit Hooks nimmt er „working“ jetzt aus dem Zustand des Agenten, denn die Hooks wissen es zuerst. Ersetze in src/session.ts update():

src/session.ts
/** 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);
  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);
}

Der Rest von update() ist wie in Teil 3. Ab jetzt läuft es auch bei jeder Änderung am Zustand des Agenten, viele Male in einer Runde, und deshalb fragt es den Server nur dann nach einem Gespräch, wenn sich der Zustand der Sitzung selbst ändert.

src/sitePage.ts reicht beide Zustände weiter. Füg ein Feld neben agentState ein:

src/sitePage.ts
private termState: TerminalState | undefined;

und ersetze agentChanged() und terminals(), mit dem Setter für onAnswer davor:

src/sitePage.ts
/** "Answer": the page shows the dialog that was put aside. */
set onAnswer(fn: () => void) { this.agent.onAnswer = fn; }

/** What Claude Code does for this site changed. */
agentChanged(state: AgentState) {
  this.agentState = state;
  this.agent.update(state);
  this.session.update(this.termState, state);
  this.request.update(this.site, isLive(state.run));
}

/** The sessions changed: this site's, or none. */
terminals(list: TerminalState[]) {
  const state = list.find((t) => t.site === this.name);
  this.termState = state;
  this.session.update(state, this.agentState);
  this.terminal.update(state);
}

Probier es aus

Starte den Server neu, leg eine neue Site an und schick ihren ersten Auftrag mit einer Zeile wie „ask me before you build“. Im Test kam für Bergblick Ski School Folgendes: ein Dialog mit vier Fragen, zu Stil, Layout, Seiten und Ton, und in der Frage zum Layout eine Skizze der Startseite als Vorschau der empfohlenen Option. Nach Send the answers schloss sich der Dialog, der Verlauf ging mit der Arbeit von Claude Code weiter, und der Lauf war nach 0:56 fertig.

Zwei Dinge kannst du noch ausprobieren:

  • Drück Escape, während der Dialog offen ist. Der Dialog verschwindet, das Panel sagt „Claude Code waits for your answer“, und Answer holt den Dialog zurück. Claude Code hat die ganze Zeit gewartet.

  • Schließ alle Tabs mit Sitesmith und lass eine Frage kommen, während keine Seite offen ist (schick den Auftrag mit curl, wie in Teil 5). hookAsk() gibt sie frei, und die Frage erscheint im Terminal als der eigene Dialog von Claude Code. Sieh sie dir mit tmux -L sitesmith attach -t <site> an. Auch das wurde im Test ausprobiert.

Das ist der Hin- und Rückweg, auf dem der Rest der Serie aufbaut. Eine Frage ist das Freundlichste, worauf Claude Code warten kann. Die andere Art ist eine Berechtigungsabfrage: Claude Code will einen Befehl ausführen, den es nicht ohne Nachfrage ausführen darf. Der nächste Teil, Berechtigungsabfragen in der Seite, schickt sie auf demselben Weg, mit einem Unterschied, auf den es ankommt: Das Terminal zeigt gleichzeitig seinen eigenen Dialog.

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.