Zum Inhalt springen

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

Teil 9: Berechtigungsabfragen in der Seite

Halte die Berechtigungsabfragen von Claude Code mit einem PermissionRequest-Hook an und beantworte sie in der Seite: einmal erlauben, ab jetzt erlauben oder ablehnen. Und versteh, warum das Terminal gleichzeitig seinen eigenen Dialog zeigt.

Quest-Ziele

  • Wissen, welche Befehle im Modus acceptEdits um Erlaubnis fragen
  • Berechtigungsabfragen mit einem PermissionRequest-Hook anhalten
  • Mit allow, allow from now on (updatedPermissions) oder deny (message) antworten
  • Verstehen, warum der eigene Dialog von Claude Code gleichzeitig im Terminal erscheint
  • Die Berechtigungsprüfung einer Frage dem Terminal überlassen

Seit Teil 3 laufen die Sitzungen im Modus acceptEdits: Claude Code ändert die Dateien im Ordner der Site, ohne zu fragen. Bei Befehlen ist das anders. Manche laufen ohne Rückfrage, bei anderen hält Claude Code an und fragt um Erlaubnis. Beim ersten Bau in Teil 5 hat so eine Abfrage zwei Minuten im Terminal gewartet, während die Seite „working“ anzeigte.

Dieser Teil holt Berechtigungsabfragen mit einem zweiten gehaltenen Hook in die Seite, PermissionRequest. Fast alles daran kennst du aus Teil 8: Der Hook fragt den Server und wartet, die Seite zeigt einen Dialog, und die Antwort geht als Ausgabe des Hooks zurück. Neu ist die Antwort selbst (erlauben, ab jetzt erlauben oder ablehnen) und ein Unterschied, den du kennen musst: Während dieser Hook wartet, zeigt das Terminal gleichzeitig den eigenen Dialog von Claude Code.

Manche Befehle brauchen ein Ja, bevor sie laufen. Jetzt kann es aus der Seite kommen.
Manche Befehle brauchen ein Ja, bevor sie laufen. Jetzt kann es aus der Seite kommen.

Welche Befehle fragen

Im Modus acceptEdits gehen Änderungen an Dateien durch, und Befehle, die nur lesen, ebenso. Im Test liefen wc -l *.html und date && uname -s ohne Rückfrage. Befehle, die ins Netz gehen, fragen: curl -sI https://example.com | head -1 hat gefragt. Ebenso Befehle mit bestimmten Shell-Operatoren: In Teil 5 hat (node --check script.js && echo "JS ok") ; ls -la . assets gefragt, mit „This command uses shell operators that require approval for safety“.

Das entscheidet Claude Code, nicht Sitesmith, und seine Regeln können sich von Version zu Version ändern; die Berechtigungen in deinen eigenen Einstellungen von Claude Code reden auch mit. Sitesmith muss die Regeln nicht kennen. Es muss den Moment mitbekommen, in dem Claude Code gleich fragen wird.

Warum ein weiterer Hook

PreToolUse, der die Fragen hält, läuft vor jedem Werkzeug, bevor Claude Code entschieden hat, ob das Werkzeug eine Erlaubnis braucht. Um ihn für Berechtigungen zu nutzen, müsste Sitesmith die Regeln von Claude Code also doch kennen: welcher Befehl nur liest, welcher Operator verdächtig ist, was du in deinen Einstellungen erlaubt hast. PermissionRequest läuft genau dann, wenn Claude Code gleich fragen wird, mit dem Werkzeug und seiner Eingabe und mit den Regeln, die Claude Code für „nicht mehr fragen“ anbieten würde. Dieser letzte Teil ist neu im Ereignis. Ersetze in server/agent.ts HookEvent:

server/agent.ts
/** What a hook sends: Claude Code's hook input (the fields Sitesmith reads). */
export interface HookEvent {
  hook_event_name: string;
  transcript_path?: string;
  source?: string;
  prompt?: string;
  tool_name?: string;
  tool_input?: Record<string, unknown>;
  tool_use_id?: string;
  last_assistant_message?: string;
  /** PermissionRequest: the rules Claude Code would add for "don't ask again" */
  permission_suggestions?: unknown[];
}

Im Konstruktor bekommen die Einstellungen den neuen Hook, mit demselben Tag Geduld wie PreToolUse. Ersetze das Objekt settings:

server/agent.ts
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) }],
    PermissionRequest: [{ matcher: '*', hooks: hook(86400) }],
    Stop: [{ hooks: hook() }],
  },
};

Dasselbe hook.ts kümmert sich darum. Ersetze in server/hook.ts main():

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

Eine Berechtigungsabfrage wird nicht als Ereignis gemeldet: Ihr Werkzeug wurde es schon, durch sein PreToolUse einen Moment vorher, und der Verlauf würde es doppelt zeigen. Ansonsten nimmt sie den Weg einer Frage: wait() fragt den Server, pollt, bis es eine Antwort gibt, und main() schreibt die Ausgabe.

Eine Berechtigung als Ask

Die Seite muss zeigen, was Claude Code tun will. In shared/types.ts bekommt Ask eine zweite Art und AnswerBody eine Entscheidung. Ersetze beide:

shared/types.ts
/** 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 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';
}

In server/agent.ts macht hookAsk() die eine oder die andere Art. Ersetze es:

server/agent.ts
/**
 * 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;
  // 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;
  this.changed(name);
  return { id: ask.id };
}

Bei einer Berechtigung ist summary die Zeile aus describeTool(); bei Bash ist das die eigene Beschreibung des Befehls von Claude Code, etwa „Check that example.com answers“. detail ist der Befehl, die Datei oder die Adresse, je nachdem, was die Eingabe hat. remember sagt, ob Claude Code Regeln für „nicht mehr fragen“ angeboten hat, und der Verlauf bekommt eine Zeile: „Asks for permission: …“.

Die zweite Zeile von hookAsk() verdient einen genaueren Blick. Landet eine Frage im Terminal (ihr Hook hat aufgegeben, oder, ab dem nächsten Teil, du gibst sie selbst dorthin), zeigt Claude Code seinen eigenen Fragedialog, und dieser Dialog geht ebenfalls durch die Berechtigungsprüfung: PermissionRequest feuert, mit AskUserQuestion als Werkzeug. In der Seite wäre das eine Berechtigungsabfrage für „Asking you something“ mit Allow und Deny, und sie zu erlauben, würde keine einzige Frage beantworten. Also gibt hookAsk() sie sofort frei, und die Fragen werden dort beantwortet, wo sie jetzt sind: im Terminal.

Erlauben, ab jetzt, oder ablehnen

answer() bekommt den Fall der Berechtigung vor den Fragen. Ersetze es:

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

Ein PermissionRequest-Hook antwortet nicht mit der permissionDecision aus Teil 8. Die beiden Ereignisse haben jeweils eine eigene Ausgabe, und sie zu verwechseln, passiert leicht. Das schreibt der Hook bei Allow:

json
{
  "hookSpecificOutput": {
    "hookEventName": "PermissionRequest",
    "decision": {
      "behavior": "allow"
    }
  }
}

Und die drei Antworten, dazu der Fall, dass keine kommt:

  • Allow: behavior: "allow". Claude Code führt den Befehl aus, dieses eine Mal.

  • Allow from now on: dasselbe, dazu updatedPermissions, die Regeln aus permission_suggestions des Ereignisses, unverändert zurückgegeben. Es sind die, die der Dialog im Terminal als zweite Option anbietet, etwa „Yes, and don't ask again for: curl -sI https://example.com“. Sitesmith schaut nicht hinein: Claude Code hat sie geschrieben, und Claude Code liest sie. Die Seite bietet den Button nur an, wenn es Vorschläge gibt.

  • Deny: behavior: "deny", mit einer message, die Claude Code als Begründung liest. Seine Runde geht ohne den Befehl weiter; was es als Nächstes tut, ist seine Sache.

  • Keine Entscheidung: Eine Antwort ohne Entscheidung lehnt ab. Ein fehlendes Feld soll nie einen Befehl erlauben.

Der Dialog

In src/askDialog.ts wählt show(), was gezeichnet wird. Ersetze es:

src/askDialog.ts
/** 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 this.renderPermission(ask);
  if (!this.el.open) this.el.showModal();
}

und füg renderPermission() nach send() ein:

src/askDialog.ts
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(
    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());
}

Die Überschrift sagt, um welche Art Ask es geht, das Werkzeug steht fett mit seiner Zusammenfassung da, und der Befehl (oder die Datei, oder die Adresse) darunter in voller Länge, damit du genau siehst, was du erlaubst. Allow hat den Fokus, so wie im Terminal „Yes“ vorausgewählt ist. Escape legt den Dialog beiseite, wie bei einer Frage, und Answer im Panel holt ihn zurück.

Harbor Books soll mit curl prüfen, ob https://example.com antwortet, und die Adresse dann im Footer verlinken: Der Dialog zeigt das Werkzeug, die Beschreibung von Claude Code „Check that example.com answers“ und den ganzen Befehl, mit Deny, Allow from now on und Allow. Der Kopf sagt, dass Claude Code auf dich wartet.Den Screenshot in voller Größe öffnen
Harbor Books soll mit curl prüfen, ob https://example.com antwortet, und die Adresse dann im Footer verlinken: Der Dialog zeigt das Werkzeug, die Beschreibung von Claude Code „Check that example.com answers“ und den ganzen Befehl, mit Deny, Allow from now on und Allow. Der Kopf sagt, dass Claude Code auf dich wartet.

Zwei Dialoge gleichzeitig

Eine Frage wird gehalten, bevor es ihren Dialog gibt: PreToolUse läuft, bevor das Werkzeug läuft, also hat das Terminal nichts zu zeigen, solange die Seite eine Frage hält. Bei einer Berechtigungsabfrage ist das anders. Claude Code führt den PermissionRequest-Hook aus und zeigt gleichzeitig seinen eigenen Dialog im Terminal. Während die Seite die curl-Abfrage von oben hielt, sah das Terminal so aus:

~/sitesmith
# the site's terminal while the page held the prompt for: curl -sI https://example.com | head -1 curl -sI https://example.com | head -1 This command requires approval Do you want to proceed? ❯ 1. Yes   2. Yes, and don’t ask again for: curl -sI https://example.com   3. Yes, and switch to auto mode · auto mode handles these prompts for you   4. No Esc to cancel · Tab to amend# after an Allow in the page, the terminal showed:⎿ Allowed by PermissionRequest hook

Beide Dialoge sind echt, und wer zuerst beantwortet wird, gewinnt. Erlaubst du in der Seite, übernimmt Claude Code die Entscheidung des Hooks, schließt seinen eigenen Dialog und vermerkt, dass der Hook erlaubt hat. Antwortest du im Terminal, macht Claude Code mit dieser Antwort weiter; die des Hooks kommt zu spät, um noch etwas zu ändern.

Den Dialog im Terminal fernzuhalten, geht nicht, und das ist gut so: Er ist das Sicherheitsnetz. Verschwinden Seite oder Server, während eine Abfrage wartet, hat das Terminal sie noch. Aus Versehen hineintippen kann Sitesmith auch nicht: Der Dialog ist kein leeres Eingabefeld, also sagt atEmptyPrompt() aus Teil 5 nein, und nichts wird getippt, solange er zu sehen ist.

Der Fall, in dem das Terminal gewinnt, hat im Code dieses Teils ein loses Ende. Der Server erfährt nicht, dass im Terminal geantwortet wurde, also behält die Seite ihren Dialog (und der Kopf sagt weiter, dass Claude Code wartet), bis die nächste Frage oder Abfrage ihn ersetzt oder du den Lauf stoppst. Ihn dann noch zu beantworten, ändert an Claude Code nichts, es ist längst weitergegangen. Teil 10 bringt dem Server bei zu merken, dass Claude Code weitergemacht hat, und den Dialog selbst zu schließen.

Probier es aus

Starte den Server neu und bitte eine Site um etwas, das das Netz braucht, etwa eine Webschrift zu verwenden und sie in den Ordner der Site herunterzuladen. Wechsle zum Terminal-Tab, bevor du den Auftrag schickst: Hinter dem Dialog der Seite siehst du den eigenen Dialog von Claude Code erscheinen und wieder verschwinden, wenn du in der Seite antwortest.

Im Test sollte Bergblick Ski School die Schrift Fraunces verwenden und mit curl holen. Zwei Abfragen kamen in der Seite an, „Bash · Fetch Fraunces @font-face CSS from Google Fonts“ und „Bash · Download Fraunces Latin woff2 into assets/fonts“. Beide wurden dort erlaubt, und der Lauf war nach 0:20 fertig.

Die Fragen und die Berechtigungsabfragen von Claude Code kommen jetzt in die Seite, und das Terminal ist der Ort, an den sie gehen, wenn die Seite sie nicht annehmen kann. Bisher passiert das still: Die Seite weiß nicht, wann im Terminal etwas wartet, und einen Dialog meldet gar kein Hook, die Vertrauensabfrage eines neuen Ordners. Um diese Fälle geht es im nächsten Teil: Wenn die Seite nicht antworten kann.

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.