Claude Code in deiner eigenen Web-App · Teil 13 von 16 der Serie
Teil 13: Sag mir Bescheid, wenn es mich braucht
Ein Schalter in der Seitenleiste schaltet Browser-Benachrichtigungen und einen kurzen Klang ein: für eine Frage in einer Site, die du gerade nicht ansiehst, und für das Ende eines Laufs, während der Tab im Hintergrund liegt. Ein Klick auf die Benachrichtigung öffnet die Site.
Claude Code in deiner eigenen Web-AppTeil 13 von 16
Auf dieser Seite
Quest-Ziele
- Mit einem Klick um die Erlaubnis für Benachrichtigungen bitten und die Wahl behalten
- Wissen, warum Benachrichtigungen eine sichere Seite brauchen und warum localhost eine ist
- Mit der Web Audio API einen kurzen Klang spielen, sobald der Browser Ton erlaubt
- Entscheiden, wann eine Änderung eine Meldung wert ist: Du bist weg, sie ist neu, und nur einmal
- Eine Benachrichtigung pro Site behalten und die Site mit einem Klick darauf öffnen
Seit Teil 12 zeigt die Seitenleiste, welche Site auf dich wartet, und der Titel des Tabs zählt sie. Das hilft, solange du auf die Seite schaust. Aber ein Bau dauert eine Minute oder länger, und so lange schaut niemand dem Verlauf zu. Du wechselst in deinen Editor oder deine Mails, und die Frage, die Claude Code inzwischen gestellt hat, wartet geduldig, notfalls stundenlang: Der Hook aus Teil 8 hält sie bis zu einem Tag fest.
In diesem Teil meldet sich die Seite zu Wort. Ein Schalter unten in der Seitenleiste schaltet zwei Dinge ein, die der Browser jeder Seite anbietet: eine Benachrichtigung auf deinem Desktop und einen kurzen Klang. Am Server ändert sich gar nichts. Die Seite bekommt jede Änderung jeder Site längst über die Server-Sent Events mit; sie muss nur entscheiden, welche es wert sind, dich zu unterbrechen.
In diesem Teil gibt es keinen Screenshot: Eine Benachrichtigung zeichnet dein Betriebssystem, außerhalb der Seite, und sie sieht auf jedem Desktop anders aus. Sie nennt die Site, worauf Claude Code wartet, und eine Zeile Details, zum Beispiel Bergblick Ski School: Claude Code has a question for you über der Frage selbst.
Was eine Benachrichtigung sagt
Alles kommt in eine neue Datei. Leg src/notify.ts an und beginne sie mit den Texten der Benachrichtigungen:
import { h } from './dom.ts';
import type { AgentState } from '../shared/types.ts';
const KEY = 'sitesmith:notify';
/** What the notification says when Claude Code starts waiting for you. */
function askText(state: AgentState) {
const ask = state.ask;
if (state.needsTerminal && !ask) return { title: 'waits for you in the terminal', body: 'It asks something the page can’t show.' };
switch (ask?.kind) {
case 'questions': return { title: ask.questions.length > 1 ? 'has questions for you' : 'has a question for you', body: ask.questions[0]?.question ?? '' };
case 'permission': return { title: 'asks for permission', body: ask.summary };
case 'plan': return { title: 'has a plan for you to approve', body: '' };
case 'trust': return { title: 'asks whether you trust the folder', body: ask.dir };
}
return null;
}askText macht aus dem Zustand der Site einen Titel und einen Text, ein Fall für jede Art von Ask aus den Teilen 8 bis 11. Eine Frage zeigt ihren eigenen Text, eine Berechtigungsabfrage die Zusammenfassung in einer Zeile aus describeTool und der Vertrauensdialog den Ordner. Ein Plan bekommt keinen Text: Er ist eine Seite Markdown, und eine Benachrichtigung hat Platz für ein, zwei Zeilen. Die erste Zeile deckt den Fall aus Teil 10 ab, in dem Claude Code auf etwas wartet, das nur das Terminal zeigen kann.
Der Schalter
Darunter beginnt die Klasse, mit dem Knopf und dem, was sie braucht, bevor etwas angezeigt oder gespielt werden kann:
/**
* Tells you when Claude Code needs you while you look elsewhere: a browser notification (with
* your permission) and a short sound. Questions in another site count as elsewhere too; the end
* of a run only when the tab is in the background. Clicking the notification opens the site.
*/
export class Notifier {
readonly el: HTMLButtonElement;
private on = false;
private audio: AudioContext | null = null;
private seen = new Set<string>();
constructor() {
this.el = h('button', { type: 'button', class: 'small ghost', onclick: () => void this.toggle() });
try { this.on = localStorage.getItem(KEY) === 'on'; } catch { /* storage blocked: off */ }
this.render();
}
/** Notifications need a secure page (https, or localhost) and the browser's permission. */
private get available() { return 'Notification' in window && window.isSecureContext; }
private render() {
if (!this.available) {
this.el.textContent = 'Sound on';
this.el.title = 'Browser notifications need https or localhost: only the sound is left here';
} else if (Notification.permission === 'denied') {
this.el.textContent = 'Notifications blocked';
this.el.title = 'Allow notifications for this page in the browser’s site settings';
} else this.el.textContent = this.on ? 'Notifications on' : 'Notify me';
this.el.setAttribute('aria-pressed', String(this.on));
}
/** A click: the browser asks for permission, and the sound may play from now on. */
private async toggle() {
this.on = !this.on;
if (this.on) {
this.unlockSound();
if (this.available && Notification.permission === 'default') this.on = (await Notification.requestPermission()) === 'granted';
}
try { localStorage.setItem(KEY, this.on ? 'on' : 'off'); } catch { /* not remembered */ }
this.render();
}
/** Browsers start audio only after a click on the page. */
unlockSound() {
this.audio ??= new AudioContext();
void this.audio.resume();
}Verfügbar. Browser bieten Benachrichtigungen nur einem sicheren Kontext an: einer Seite, die über HTTPS geladen wurde, oder einer vom eigenen Rechner. http://localhost und http://127.0.0.1 gelten als sicher, weil nichts zwischen Browser und Server sie lesen oder verändern könnte. Auf localhost:5400 funktioniert hier also alles. Von einem anderen Rechner über einfaches HTTP geöffnet, wie in Teil 16, funktioniert es nicht, und der Knopf heißt dann Sound on: Dort bleibt nur der Klang.
Die Erlaubnis. Eine Seite darf Benachrichtigungen erst zeigen, wenn du es erlaubt hast, und der Browser fragt dich im Namen der Seite, wenn sie Notification.requestPermission() aufruft. Dieser Aufruf steht mit Absicht in toggle, das bei einem Klick läuft: Browser erwarten, dass eine Bitte um Erlaubnis auf etwas folgt, das du getan hast, und manche ignorieren sie sonst. Die Antwort hebt der Browser auf. War sie nein, fragt er nicht noch einmal, und der Knopf heißt Notifications blocked, bis du es in den Website-Einstellungen änderst.
Gemerkt. Ob der Schalter an ist, kommt in den localStorage, damit ein Neuladen es behält. Beide Zugriffe stehen in einem try: Ein Browser kann den Speicher sperren, und dann ist der Schalter nach dem Neuladen eben aus.
Ton. Browser lassen eine Seite keinen Lärm machen, bevor du auf sie geklickt hast, damit niemand von einer Werbung beschallt wird, die er nie angefasst hat. Ein AudioContext, der vorher entsteht, startet angehalten, und resume() wirkt erst ab einem Klick. unlockSound legt den Kontext einmal an und setzt ihn fort. Der Schalter ruft es auf, und gleich auch ein Listener für den ersten Klick irgendwo auf der Seite.
Ein Klang ohne Sounddatei
Der Klang entsteht an Ort und Stelle, mit der Web Audio API. Füg der Klasse die Methode hinzu:
/** Two rising notes for "it waits for you", one soft note for "it is done". */
private chime(kind: 'ask' | 'done') {
const ctx = this.audio;
if (!ctx || ctx.state !== 'running') return;
const notes = kind === 'ask' ? [660, 880] : [520];
notes.forEach((freq, i) => {
const t = ctx.currentTime + i * 0.16;
const osc = ctx.createOscillator();
const gain = ctx.createGain();
osc.type = 'sine';
osc.frequency.value = freq;
gain.gain.setValueAtTime(0, t);
gain.gain.linearRampToValueAtTime(0.18, t + 0.02);
gain.gain.exponentialRampToValueAtTime(0.001, t + 0.45);
osc.connect(gain).connect(ctx.destination);
osc.start(t);
osc.stop(t + 0.5);
});
}Ein Oszillator erzeugt einen Ton mit einer Frequenz; ein Gain-Knoten bestimmt seine Lautstärke. Für jeden Ton steigt die Lautstärke innerhalb von 20 Millisekunden von null auf 0,18, damit er ohne Knacken beginnt, und klingt dann über die nächsten 430 aus. Das Ausklingen ist exponentiell, das klingt wie eine angeschlagene Glocke, und eine Exponentialkurve erreicht nie null, daher die 0,001. Jeder Oszillator wird nach einer halben Sekunde gestoppt und dann vom Browser weggeräumt; ein neuer Ton braucht einen neuen.
„Es wartet auf dich“ sind zwei steigende Töne, 660 und 880 Hz, 160 Millisekunden auseinander. „Es ist fertig“ ist ein einzelner, tieferer Ton. Nach einem Tag kennst du den Unterschied und schaust beim zweiten nicht mehr auf. Läuft der Kontext noch nicht, weil seit dem Laden der Seite niemand geklickt hat, bleibt chime still, statt einen Klang für später aufzuheben.
Wann du Bescheid bekommst
Der Rest der Klasse entscheidet. Füg die beiden übrigen Methoden hinzu:
private show(site: string, siteTitle: string, title: string, body: string, kind: 'ask' | 'done') {
this.chime(kind);
if (!this.available || Notification.permission !== 'granted') return;
// one notification per site: a newer one replaces the older
const n = new Notification(`${siteTitle}: Claude Code ${title}`, { body, tag: `sitesmith-${site}` });
n.onclick = () => {
window.focus();
location.hash = `site/${site}`;
n.close();
};
}
/** A site's state changed: is this something to tell you about? */
agentChanged(prev: AgentState | undefined, next: AgentState, siteTitle: string, isOpen: boolean) {
if (!this.on) return;
const away = document.hidden || !isOpen;
const waits = next.ask?.id ?? (next.needsTerminal ? `terminal-${next.run?.id}` : null);
if (waits && !this.seen.has(waits) && away) {
this.seen.add(waits);
const text = askText(next);
if (text) this.show(next.site, siteTitle, text.title, text.body, 'ask');
}
const run = next.run;
const ended = run && ['done', 'failed', 'stopped'].includes(run.status) && prev?.run?.id === run.id && prev.run.status !== run.status;
if (ended && run.status !== 'stopped' && document.hidden && !this.seen.has(`end-${run.id}-${run.ended}`)) {
this.seen.add(`end-${run.id}-${run.ended}`);
this.show(next.site, siteTitle, run.status === 'done' ? 'is done' : 'could not finish', (run.summary ?? run.error ?? '').slice(0, 160), 'done');
}
}
}agentChanged wird für jeden Zustand aufgerufen, den der Server schickt, und das sind viele: Jedes Werkzeug, das Claude Code benutzt, schickt einen. Die meisten davon sind keine Neuigkeit. Drei Regeln sortieren sie aus.
Nur wenn du weg bist. away ist wahr, wenn der Tab verborgen ist, hinter einem anderen Tab oder in einem minimierten Fenster, oder wenn die Site nicht die ist, die auf der Seite offen ist. Der zweite Fall zählt seit Teil 12: Der Dialog erscheint nur für die offene Site, eine Frage in einer anderen wäre sonst bloß ein Fragezeichen in der Seitenleiste.
Nur einmal. Jedes Ask hat eine ID, und seen hält die fest, die schon gemeldet sind. Eine Site, die das Terminal braucht, bekommt eine ID aus ihrem Lauf, damit auch das nur einmal gemeldet wird. Ohne das hörtest du den Klang bei jeder Datei, die Claude Code liest, während die Frage wartet.
Das Ende nur im Hintergrund. Ein Lauf ist zu Ende, wenn der vorige Zustand denselben Lauf mit einem anderen Status hatte und der neue Status done, failed oder stopped ist. Stopped bleibt außen vor: Das warst meistens du, mit dem Stop-Knopf oder Escape im Terminal. Und das Ende wird nur gemeldet, solange der Tab verborgen ist. Hast du die Seite vor dir, zeigen der Verlauf und die Zusammenfassung es schon, und eine Benachrichtigung für jede fertige Änderung wäre Lärm. Ihr Text ist der Anfang der Zusammenfassung von Claude Code aus Teil 7.
show spielt zuerst den Klang, damit der auch dort funktioniert, wo Benachrichtigungen es nicht tun. Dann erzeugt es die Benachrichtigung mit einem tag. Benachrichtigungen mit demselben Tag ersetzen einander, also hat jede Site höchstens eine auf deinem Bildschirm: Ein späteres „is done“ derselben Site tritt an die Stelle der Frage von vorhin. Ein Klick darauf holt das Fenster nach vorn und schaltet die Seite auf die Site um, über dieselbe Adresse #site/…, die auch die Links der Seitenleiste benutzen.
Einbauen
Der Schalter kommt unten in die Seitenleiste. In src/sidebar.ts nimmt der Konstruktor, was dort stehen soll:
export class Sidebar {
readonly el: HTMLElement;
private list = h('nav', { class: 'site-list', 'aria-label': 'Sites' });
/** `foot`: what goes at the bottom (the notifications switch) */
constructor(...foot: HTMLElement[]) {
this.el = h('aside', { class: 'sidebar' },
h('a', { class: 'brand', href: '#' }, h('span', { class: 'brand-mark', 'aria-hidden': 'true' }), 'Sitesmith'),
h('a', { class: 'button primary', href: '#new' }, 'New site'),
this.list,
h('div', { class: 'sidebar-foot' }, ...foot));
}Die Klasse sidebar-foot steht schon in style.css: Auf einem breiten Bildschirm schiebt sie den Schalter nach ganz unten, auf einem schmalen setzt sie ihn ans Ende der oberen Leiste.
In src/main.ts importierst du den Notifier und legst ihn am Anfang von start() an:
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 { Notifier } from './notify.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 notifier = new Notifier();
// any click may start the sound (browsers allow audio only after one)
document.addEventListener('pointerdown', () => notifier.unlockSound(), { once: true });
const sidebar = new Sidebar(notifier.el);
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);Der Listener mit once: true schaltet den Ton mit deinem ersten Klick irgendwo auf der Seite frei, damit der Klang nach einem Neuladen funktioniert, auch wenn du den Schalter nie wieder anfasst. Und onEvent reicht jeden neuen Zustand an den Notifier weiter, bevor er den alten in der Map ersetzt:
function onEvent(ev: ServerEvent) {
if (ev.type === 'sites') {
sites = ev.sites;
page?.update(sites);
overview();
} else if (ev.type === 'terminals') {
terminals = ev.terminals;
page?.terminals(terminals);
overview();
} else if (ev.type === 'agent') {
const title = sites.find((s) => s.name === ev.state.site)?.title ?? ev.state.site;
notifier.agentChanged(agents.get(ev.state.site), ev.state, title, page?.name === ev.state.site);
agents.set(ev.state.site, ev.state);
if (ev.state.site === page?.name) page.agentChanged(ev.state);
overview();
syncAsk();
} else if (ev.type === 'files' && ev.site === page?.name) page.filesChanged();
}Auf die Reihenfolge kommt es an: agents.get(…) liefert noch den vorigen Zustand, und nur so sieht der Notifier, dass ein Lauf gerade zu Ende gegangen ist.
Probier es aus
Bau die Seite neu oder lass den Dev-Server sie neu laden und klick auf Notify me. Der Browser fragt, ob die Seite Benachrichtigungen zeigen darf; erlaube es, und der Knopf heißt Notifications on. Dann schick einer Site einen Auftrag, der etwas offenlässt, etwa einen neuen Abschnitt, ohne zu sagen, was hineinkommt, und wechsle zu einer anderen Site oder in einen anderen Tab, während Claude Code arbeitet.
Für diese Serie lief die Seite in einem Headless-Chromium, das keinen Desktop hat, auf dem es etwas zeigen könnte. Der Test hat Notification deshalb belauscht, aufgeschrieben, was die Seite anzeigen lassen wollte, und die Oszillatoren gezählt, die der Klang gestartet hat:
# Headless Chromium, notifications granted, Notification and the oscillators spied onswitch: Notifications onafter the question: [{"title":"Bergblick Ski School: Claude Code has a question for you","body":"Should the footer link to the Schladming tourism office?"}] chime oscillators: 2after the end: [… ,{"title":"Bergblick Ski School: Claude Code is done","body":"I added a \"Schladming tourism office\" link to the footer on all three pages …"}] chime oscillators: 3
Die Frage in Bergblick Ski School kam mit ihrer Benachrichtigung und zwei Tönen. Als der Lauf mit dem Tab im Hintergrund zu Ende ging, folgte die zweite Benachrichtigung, mit dem Anfang der Zusammenfassung als Text, und ein weiterer Ton: drei Oszillatoren insgesamt.
Was du jetzt hast
Sitesmith ruft dich, wenn es dich braucht: mit einer Benachrichtigung, die du anklicken kannst, und einem Klang, den du unterscheiden lernst, für Fragen in jeder Site, die du gerade nicht ansiehst, und für das Ende der Arbeit, während du etwas anderes tust. Eine neue Datei und ein paar Zeilen, um sie einzubauen, alles davon in der Seite.
Bisher hatte Claude Code nur deine Worte. Im nächsten Teil gibst du ihm Dateien: das Logo der Bäckerei, Fotos, eine Speisekarte als PDF, auf die Seite gezogen und im Auftrag genannt, damit Claude Code sie ansieht, bevor es anfängt.
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.