Claude Code in deiner eigenen Web-App · Teil 12 von 16 der Serie
Teil 12: Mehrere Sites gleichzeitig
Lass mehrere Sites nebeneinander arbeiten: Der Server führt von Anfang an alles pro Site, also geht es in diesem Teil um die Seite. Die Seitenleiste zeigt, was das Claude Code jeder Site gerade tut, und der Titel des Tabs zählt die Sites, die auf dich warten.
Claude Code in deiner eigenen Web-AppTeil 12 von 16
Auf dieser Seite
Quest-Ziele
- Verstehen, warum der Server für mehrere Sites gleichzeitig keine Änderung braucht
- In der Seitenleiste zeigen, was das Claude Code jeder Site gerade tut
- Die Sites, die auf dich warten, im Titel des Tabs zählen
- Den Dialog bei der Site lassen, die du ansiehst, und wissen, warum
Claude Code arbeitet pro Site an einem Auftrag nach dem anderen, aber nichts hindert dich daran, drei Sites etwas zu tun zu geben und einer davon zuzusehen. Jede arbeitet in ihrer eigenen Sitzung weiter, und früher oder später hat eine, die du gerade nicht ansiehst, eine Frage. Bisher hättest du das nicht gemerkt: Der Dialog erscheint nur für die offene Site, und die Seitenleiste ist eine schlichte Liste von Namen.
Dieser Teil ist kurz, denn der Server ist längst dafür bereit. Was dazukommt, steckt in der Seite: Die Seitenleiste zeigt, was das Claude Code jeder Site gerade tut, und der Titel des Tabs zählt die Sites, die auf dich warten.
Von Anfang an für mehrere gebaut
Schau dir an, was der Server sich merkt, und fast alles davon gilt pro Site. Das sind die Felder des Agent in server/agent.ts, unverändert:
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;
/** since when no page has been open (0: one is) */
private noPagesSince = 0;sites hält für jede Site einen SiteAgent: ihren Lauf und ihre Warteschlange, was sie getan hat, worauf sie wartet, ob sie feststeckt. pending hält die offenen Asks aller Sites nach ihrer ID, damit der Long Poll eines Hooks seine Frage findet, egal zu welcher Site sie gehört. Terminals führt seinen Zustand pro Sitzung, und jede Site hat eine eigene tmux-Sitzung, die nach ihr benannt ist (Teil 3). Die Umgebung der Sitzung sagt ihren Hooks, für welche Site sie melden:
/** The session's environment: which site its hooks report for, and where they find the server. */
private env(t: Target) {
return this.hooks ? ['-e', `SITESMITH_SITE=${t.name}`, '-e', `SITESMITH_DATA=${this.hooks.data}`] : [];
}Der Hook schickt diesen Namen mit jedem Ereignis und jeder Frage mit, also landet eine Frage von Kiln & Co. im SiteAgent von Kiln & Co. und nirgends sonst. Und die Uhr geht jede Sekunde alle Sites durch:
/** 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);
}
}Ein Lauf nach dem anderen pro Site (Teil 5), aber so viele Sites nebeneinander, wie du willst. Nur die Bildschirme von Sites, bei denen etwas los ist, werden gelesen (Teil 10), Sites, die nichts tun, kosten also so gut wie nichts. Geteilt wird nur, was nicht pro Site sein kann: die offenen Seiten und seit wann es keine mehr gibt.
Von deinem eigenen Terminal aus siehst du alle Sitzungen auf einmal:
$ tmux -L sitesmith ls$ tmux -L sitesmith list-panes -a -F '#{session_name} #{pane_current_command}'
Der erste Befehl listet eine Sitzung pro Site, die eine hat, der zweite, was in jeder läuft: claude oder eine Shell, wenn Claude Code sich beendet hat.
Die Seitenleiste
Die Seite kennt den Zustand jeder Site schon: Der Server schickt ihn an jede offene Seite, und main.ts bewahrt ihn in agents auf. Die Seitenleiste hat nur nie hingeschaut. So sieht src/sidebar.ts jetzt aus:
import { h } from './dom.ts';
import type { AgentState, Site, TerminalState } from '../shared/types.ts';
/** What a site's Claude Code is up to, in a word or two for the list. */
export function siteStatus(agent: AgentState | undefined, term: TerminalState | undefined) {
if (!term?.claude) return null;
if (agent?.ask || agent?.needsTerminal) return { dot: 'ask', text: 'waits for you' };
const busy = agent?.hooked ? agent.busy : term.busy;
if (busy) return { dot: 'busy', text: 'working' };
return { dot: 'on', text: '' };
}
/**
* The list of sites on the left, and the way to a new one. Every site shows what its Claude Code
* does, so a question waiting in one site is seen while you look at another.
*/
export class Sidebar {
readonly el: HTMLElement;
private list = h('nav', { class: 'site-list', 'aria-label': 'Sites' });
constructor() {
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);
}
render(sites: Site[], current: string, agents: Map<string, AgentState>, terminals: TerminalState[]) {
this.list.replaceChildren(...sites.map((s) => {
const status = siteStatus(agents.get(s.name), terminals.find((t) => t.site === s.name));
return h('a', {
class: 'site-link',
href: `#site/${s.name}`,
'aria-current': s.name === current ? 'page' : null,
},
h('span', { class: 'site-title' }, s.title),
h('span', { class: 'site-name' }, s.name),
status ? h('span', { class: 'site-state' },
status.dot === 'ask' ? h('span', { class: 'badge' }, '?') : h('span', { class: `dot ${status.dot}`, 'aria-hidden': 'true' }),
status.text ? h('span', { class: 'site-state-text' }, status.text) : null) : null);
}));
if (!sites.length) this.list.append(h('p', { class: 'hint' }, 'No sites yet.'));
}
}siteStatus() macht aus dem Zustand einer Site ein, zwei Wörter: nichts, wenn Claude Code nicht läuft, ein Fragezeichen und „waits for you“, wenn es wartet (auf die Seite oder im Terminal), „working“, wenn es arbeitet, und einen ruhigen Punkt, wenn es offen ist und nichts tut. Ob es arbeitet, kommt von den Hooks, wenn die Sitzung welche hat, und sonst vom Bildschirm, dieselbe Regel wie in busy() auf dem Server (Teil 7) und im Kopf der Seite (Teil 8).
Der Titel des Tabs
In src/main.ts bringt eine Funktion die Seitenleiste und den Titel auf den neuesten Stand. Füge sie unter dem Dialog ein:
/** The list on the left, and the tab's title: "(2) Sitesmith" while two sites wait for you. */
function overview() {
sidebar.render(sites, page?.name ?? '', agents, terminals);
const waiting = sites.filter((s) => agents.get(s.name)?.ask || agents.get(s.name)?.needsTerminal).length;
const open = page ? sites.find((s) => s.name === page!.name)?.title : null;
document.title = `${waiting ? `(${waiting}) ` : ''}${open ? `${open} · ` : ''}Sitesmith`;
}Der Titel zählt die Sites, die auf dich warten, mit einem Ask oder mit needsTerminal, und nennt die offene Site: „(2) Lumen Café · Sitesmith“. Er steht in der Tableiste des Browsers, auch wenn du gerade in einem anderen Tab bist. Für die Zeit, in der du gar nicht auf den Browser schaust, bringt Teil 13 Benachrichtigungen.
route() ruft sie dort auf, wo es bisher die Seitenleiste gezeichnet hat:
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')));
}
overview();
syncAsk();
}und onEvent() tut es bei jeder Art von Ereignis, denn die Seitenleiste hängt jetzt von allen dreien ab: den Sites, den Sitzungen und dem, was Claude Code tut:
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') {
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();
}Ein Dialog, für die Site, die du ansiehst
syncAsk() bleibt, wie Teil 8 es geschrieben hat:
/** 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);
}Es zeigt das Ask der offenen Site und sonst keins, und das ist Absicht. Ein Dialog für Bergblick über der Seite von Lumen Café würde dich ohne den Zusammenhang entscheiden lassen: die Site, ihre Vorschau, was Claude Code bisher getan hat. Die Hooks halten Claude Code so lange fest wie nötig, eine Site, die wartet, verliert also nichts außer Zeit. Ein Klick auf sie in der Seitenleiste öffnet sie, und ihr Dialog kommt mit ihr.
Probier es aus
Gib zwei Sites einen Auftrag, der etwas zum Fragen übrig lässt („frag mich zuerst, ob …“ funktioniert gut), und öffne eine dritte, während sie arbeiten. Im Test haben Kiln & Co. und Bergblick Ski School gefragt, während die Seite Lumen Café zeigte:
Der Titel des Tabs lautete „(2) Lumen Café · Sitesmith“, und die Seitenleiste zeigte beide mit „? waits for you“.
Ein Klick auf Bergblick Ski School öffnete die Site mit ihrer Frage schon offen, „Claude Code has a question for you“. Als sie beantwortet war, lautete der Titel „(1) Bergblick Ski School · Sitesmith“.
Dann Kiln & Co.: Ihre Frage kam genauso, und nach der Antwort lautete der Titel „Kiln & Co. · Sitesmith“, und niemand wartete mehr.
Was du jetzt hast
Mehrere Sites, die gleichzeitig arbeiten, und eine Seite, die auf einen Blick zeigt, welche arbeitet, welche wartet und wie viele dich brauchen. Der Server brauchte dafür keine Änderung: Dass er von Anfang an alles pro Site führt, hat sich ausgezahlt.
Der Titel hilft, solange der Browser vor dir ist. Im nächsten Teil lernt Sitesmith, dir auf die Schulter zu tippen, wenn er es nicht ist: eine Benachrichtigung und ein Klang, wenn Claude Code auf dich wartet oder fertig ist.
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.
