@seanmars/tospec 0.22.0 → 0.24.0

package/dist/core/dashboard-hub.js

@@ -0,0 +1,643 @@
+/**
+ * In-memory state of the dashboard hub: one entry per project, keyed by its
+ * root, holding the last snapshot any of its sessions pushed, and per live
+ * session what it is doing (its status, a short activity log, the question it
+ * waits on). Nothing is persisted and nothing is read from disk — a hub
+ * restart starts empty, and every live session re-registers on its next poll.
+ *
+ * The mod cannot listen on a port, so the hub never calls it. Requests the
+ * snapshot does not answer, and every write, wait in a per-project queue
+ * until one of that project's sessions long-polls for them. The page drives a
+ * session in one way only: it answers the question that session asked.
+ */
+import * as crypto from 'node:crypto';
+import * as path from 'node:path';
+import { DASHBOARD_PROTOCOL, canonicalRequestKey, } from './dashboard-routes.js';
+/** A rejected push or poll; `status` is the HTTP answer the server gives. */
+export class HubRequestError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'HubRequestError';
+    }
+}
+/**
+ * The project's identity: two sessions in the same root share one entry. Case
+ * folded on Windows, whose paths are case-insensitive.
+ */
+export function projectKey(root) {
+    const resolved = path.resolve(root);
+    const spelled = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+    return crypto.createHash('sha1').update(spelled).digest('hex').slice(0, 12);
+}
+const OFFLINE_ERROR = 'No Claude Code session is serving this project right now.';
+const READ_ONLY_ERROR = 'This dashboard is bound to a non-loopback address, so it cannot answer for sessions; answer in the terminal.';
+/** Per-session log length: enough for the last few turns, bounded per session. */
+export const ACTIVITY_LOG_LIMIT = 200;
+/** One event's text; the mod cuts to this too, so the bound holds whoever sent it. */
+export const ACTIVITY_TEXT_LIMIT = 500;
+const ACTIVITY_KINDS = new Set(['prompt', 'reply', 'tool', 'ask', 'answer', 'permission']);
+function isNonEmptyString(value, max = 4096) {
+    return typeof value === 'string' && value.length > 0 && value.length <= max;
+}
+function isResponse(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        Number.isInteger(value.status) &&
+        'body' in value);
+}
+function fieldsOf(value) {
+    return typeof value === 'object' && value !== null ? value : {};
+}
+/** A string cut to `max` characters, or undefined for anything that is not one. */
+function clip(value, max) {
+    if (typeof value !== 'string' || value.length === 0)
+        return undefined;
+    return value.length > max ? value.slice(0, max - 1) + '…' : value;
+}
+/** AskUserQuestion's `questions`, kept to what the dashboard draws; null if malformed. */
+function parseQuestions(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 4)
+        return null;
+    const questions = [];
+    for (const raw of value) {
+        const q = fieldsOf(raw);
+        const question = clip(q.question, ACTIVITY_TEXT_LIMIT);
+        if (!question || !Array.isArray(q.options) || q.options.length > 8)
+            return null;
+        const options = [];
+        for (const rawOption of q.options) {
+            const o = fieldsOf(rawOption);
+            const label = clip(o.label, 200);
+            if (!label)
+                return null;
+            options.push({ label, description: clip(o.description, ACTIVITY_TEXT_LIMIT) });
+        }
+        questions.push({ question, header: clip(q.header, 64), multiSelect: q.multiSelect === true, options });
+    }
+    return questions;
+}
+export class DashboardHub {
+    projects = new Map();
+    pending = new Map();
+    asks = new Map();
+    listeners = new Set();
+    now;
+    sessionTtlMs;
+    pollHoldMs;
+    relayTimeoutMs;
+    interactive;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        // A poll is renewed as soon as it answers, so a live session is seen at
+        // least every pollHoldMs; the margin covers a slow reconnect.
+        this.pollHoldMs = options.pollHoldMs ?? 25_000;
+        this.sessionTtlMs = options.sessionTtlMs ?? this.pollHoldMs + 20_000;
+        this.relayTimeoutMs = options.relayTimeoutMs ?? 20_000;
+        this.interactive = options.interactive ?? true;
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    emit(event) {
+        for (const listener of this.listeners)
+            listener(event);
+    }
+    /**
+     * Registers or refreshes a project from a pushed snapshot. The newest push
+     * wins whichever session sent it: every session of a project reads the same
+     * files, so "newest" is the only order that matters.
+     */
+    acceptSnapshot(session, snapshot) {
+        if (!isNonEmptyString(session, 256)) {
+            throw new HubRequestError('expected a session id', 400);
+        }
+        const snap = snapshot;
+        if (typeof snap !== 'object' || snap === null) {
+            throw new HubRequestError('expected a snapshot object', 400);
+        }
+        if (snap.protocol !== DASHBOARD_PROTOCOL) {
+            throw new HubRequestError(`snapshot protocol ${String(snap.protocol)} does not match this dashboard's ${DASHBOARD_PROTOCOL}; run the same tospec version for both`, 409);
+        }
+        if (!isNonEmptyString(snap.root) || !path.isAbsolute(snap.root)) {
+            throw new HubRequestError('expected an absolute snapshot root', 400);
+        }
+        if (typeof snap.entries !== 'object' || snap.entries === null) {
+            throw new HubRequestError('expected snapshot entries', 400);
+        }
+        const entries = new Map();
+        for (const [key, value] of Object.entries(snap.entries)) {
+            if (!isResponse(value))
+                throw new HubRequestError(`malformed snapshot entry ${key}`, 400);
+            entries.set(canonicalRequestKey(key), { status: value.status, body: value.body });
+        }
+        const key = projectKey(snap.root);
+        const existing = this.projects.get(key);
+        const state = existing ?? {
+            key,
+            root: snap.root,
+            entries,
+            updatedAt: 0,
+            updatedBy: session,
+            sessions: new Map(),
+            queue: [],
+            waiters: [],
+            presence: '',
+        };
+        state.root = snap.root;
+        // Replaced, not merged: an on-demand answer cached under the old snapshot
+        // (a rendered file) may describe content that has since changed.
+        state.entries = entries;
+        state.updatedAt = this.now();
+        const pushedByAnother = state.updatedBy !== session;
+        state.updatedBy = session;
+        this.touch(state, session);
+        this.projects.set(key, state);
+        // The list names which session's push is being served, so a push from
+        // another session changes it even when the live set did not.
+        if (!this.refreshPresence(state) && (!existing || pushedByAnother))
+            this.emit({ type: 'projects' });
+        this.emit({ type: 'change', project: key });
+        return key;
+    }
+    /**
+     * Marks a session seen. One that expired and comes back counts as a new
+     * connection, so its `connectedAt` says when this stretch began, and its
+     * log starts over with it.
+     */
+    touch(state, session) {
+        const now = this.now();
+        const known = state.sessions.get(session);
+        if (known && known.lastSeen >= now - this.sessionTtlMs) {
+            known.lastSeen = now;
+            return known;
+        }
+        const fresh = { firstSeen: now, lastSeen: now, status: 'idle', statusSince: now, log: [], seq: 0 };
+        state.sessions.set(session, fresh);
+        return fresh;
+    }
+    /** Broadcasts `projects` when the live session set changed; true if it did. */
+    refreshPresence(state) {
+        const presence = this.liveSessions(state)
+            .map((s) => s.id)
+            .join(',');
+        if (presence === state.presence)
+            return false;
+        state.presence = presence;
+        this.emit({ type: 'projects' });
+        return true;
+    }
+    /**
+     * Hands queued commands to a session, waiting up to `pollHoldMs` for one.
+     * Null means the hub does not know this project (it restarted): the session
+     * should push a snapshot first.
+     */
+    poll(key, session, signal) {
+        if (!isNonEmptyString(key, 64) || !isNonEmptyString(session, 256)) {
+            return Promise.reject(new HubRequestError('expected { project, session }', 400));
+        }
+        const state = this.projects.get(key);
+        if (!state)
+            return Promise.resolve(null);
+        // A poll can introduce a session the hub has not seen push: after a
+        // /clear, the same mod goes on under the next session id.
+        this.touch(state, session);
+        this.refreshPresence(state);
+        if (state.queue.length > 0)
+            return Promise.resolve(state.queue.splice(0));
+        return new Promise((resolve) => {
+            const waiter = {
+                session,
+                deliver: (commands) => {
+                    clearTimeout(timer);
+                    signal?.removeEventListener('abort', onAbort);
+                    const at = state.waiters.indexOf(waiter);
+                    if (at >= 0)
+                        state.waiters.splice(at, 1);
+                    this.touch(state, session);
+                    resolve(commands);
+                },
+            };
+            // A session that hung up must not be handed commands it will never run.
+            const onAbort = () => waiter.deliver([]);
+            const timer = setTimeout(() => waiter.deliver([]), this.pollHoldMs);
+            signal?.addEventListener('abort', onAbort, { once: true });
+            state.waiters.push(waiter);
+        });
+    }
+    /** Settles a relayed request. False when it already timed out or never existed. */
+    reply(id, response) {
+        if (!isNonEmptyString(id, 128) || !isResponse(response)) {
+            throw new HubRequestError('expected { id, status, body }', 400);
+        }
+        const pending = this.pending.get(id);
+        if (!pending)
+            return false;
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        pending.resolve({ status: response.status, body: response.body });
+        return true;
+    }
+    /**
+     * A session ended or unregistered. The project and its snapshot stay, as last
+     * known.
+     *
+     * Its held poll is released first: a waiting poll counts as live, so leaving
+     * it held kept the project online for up to `pollHoldMs` after an explicit
+     * unregister. Released before the delete, since a delivery refreshes the
+     * session's last-seen time.
+     */
+    leave(key, session) {
+        if (!isNonEmptyString(key, 64) || !isNonEmptyString(session, 256)) {
+            throw new HubRequestError('expected { project, session }', 400);
+        }
+        const state = this.projects.get(key);
+        if (!state)
+            return;
+        for (const waiter of state.waiters.filter((w) => w.session === session))
+            waiter.deliver([]);
+        state.sessions.delete(session);
+        this.dropAsksOf(key, session);
+        this.refreshPresence(state);
+    }
+    listProjects() {
+        return [...this.projects.values()]
+            .sort((a, b) => b.updatedAt - a.updatedAt)
+            .map((state) => {
+            const sessions = this.liveSessions(state);
+            return {
+                key: state.key,
+                root: state.root,
+                name: path.basename(state.root) || state.root,
+                updatedAt: new Date(state.updatedAt).toISOString(),
+                updatedBy: state.updatedBy,
+                online: sessions.length > 0,
+                sessions,
+            };
+        });
+    }
+    /**
+     * Serves a read from the snapshot, relaying a miss to a live session. Client
+     * errors are cached like successes (a 404 stays a 404 until the next push);
+     * a 5xx or an offline answer is not, so the next try asks again.
+     */
+    async read(key, requestPath) {
+        const state = this.projects.get(key);
+        if (!state)
+            return { status: 404, body: { error: 'unknown project' } };
+        const cacheKey = canonicalRequestKey(requestPath);
+        const entries = state.entries;
+        const cached = entries.get(cacheKey);
+        if (cached)
+            return cached;
+        const answer = await this.relay(state, { method: 'GET', path: cacheKey });
+        // Into the map it missed in only: a push that landed meanwhile replaced it,
+        // and this answer may predate that push.
+        if (answer.status < 500 && state.entries === entries)
+            entries.set(cacheKey, answer);
+        return answer;
+    }
+    /**
+     * Relays a write. A success empties the cache, so reads that follow ask the
+     * session for the files as they are now rather than for the pre-write
+     * snapshot; the session pushes a fresh one on its own shortly after.
+     */
+    async write(key, request) {
+        const state = this.projects.get(key);
+        if (!state)
+            return { status: 404, body: { error: 'unknown project' } };
+        const answer = await this.relay(state, request);
+        if (answer.status >= 200 && answer.status < 300) {
+            state.entries = new Map();
+            this.emit({ type: 'change', project: key });
+        }
+        return answer;
+    }
+    /** Asks a live session for a fresh snapshot. False when none is live. */
+    requestRefresh(key) {
+        const state = this.projects.get(key);
+        if (!state || !this.isOnline(state))
+            return false;
+        this.enqueue(state, { id: crypto.randomUUID(), kind: 'refresh' });
+        return true;
+    }
+    // --- session activity -------------------------------------------------------
+    /**
+     * Takes a mod's report: its status (`working` from a turn's start to its
+     * end), what it is doing now, and log events. False for a project the hub
+     * does not know, so the mod registers again.
+     */
+    reportActivity(key, session, report) {
+        if (!isNonEmptyString(key, 64) || !isNonEmptyString(session, 256)) {
+            throw new HubRequestError('expected { project, session }', 400);
+        }
+        const state = this.projects.get(key);
+        if (!state)
+            return false;
+        const presence = this.touch(state, session);
+        const fields = fieldsOf(report);
+        if (fields.status === 'working' || fields.status === 'idle') {
+            if (presence.status !== fields.status)
+                presence.statusSince = this.now();
+            presence.status = fields.status;
+            // A finished turn is doing nothing: an action left over would read as work.
+            if (fields.status === 'idle')
+                presence.action = undefined;
+        }
+        // A turn that ended is asking nothing: an ask still open was settled where
+        // the hub could not see it (the terminal), and must not be answered twice.
+        if (fields.status === 'idle') {
+            for (const [id, entry] of this.asks) {
+                if (entry.key === key && entry.session === session && !entry.answer)
+                    this.closeAsk(id, '回合已結束, 問題已撤回');
+            }
+        }
+        if ('action' in fields)
+            presence.action = clip(fields.action, 300);
+        const added = [];
+        for (const raw of Array.isArray(fields.events) ? fields.events.slice(0, ACTIVITY_LOG_LIMIT) : []) {
+            const e = fieldsOf(raw);
+            if (!ACTIVITY_KINDS.has(e.kind))
+                continue;
+            added.push(this.appendEvent(presence, {
+                kind: e.kind,
+                text: clip(e.text, ACTIVITY_TEXT_LIMIT),
+                tool: clip(e.tool, 64),
+                target: clip(e.target, 300),
+                ok: typeof e.ok === 'boolean' ? e.ok : undefined,
+            }));
+        }
+        this.refreshPresence(state);
+        this.emitActivity(state, session, added);
+        return true;
+    }
+    /** A session's summary and log, for a browser opening its panel. */
+    sessionLog(key, session) {
+        const state = this.projects.get(key);
+        const summary = state && this.liveSessions(state).find((s) => s.id === session);
+        if (!state || !summary)
+            return null;
+        return { session: summary, events: [...state.sessions.get(session).log] };
+    }
+    appendEvent(presence, event) {
+        const entry = { seq: ++presence.seq, at: new Date(this.now()).toISOString(), kind: event.kind };
+        // Absent fields stay absent, so a log line is only what was reported.
+        for (const field of ['text', 'tool', 'target', 'ok']) {
+            if (event[field] !== undefined)
+                Object.assign(entry, { [field]: event[field] });
+        }
+        presence.log.push(entry);
+        if (presence.log.length > ACTIVITY_LOG_LIMIT)
+            presence.log.splice(0, presence.log.length - ACTIVITY_LOG_LIMIT);
+        return entry;
+    }
+    emitActivity(state, session, events) {
+        const summary = this.liveSessions(state).find((s) => s.id === session);
+        if (summary)
+            this.emit({ type: 'activity', project: state.key, session: summary, events });
+    }
+    // --- asks: a question or a permission the dashboard may answer --------------------
+    /**
+     * Opens an ask for a session, which then reads as waiting. The terminal asks
+     * the same question at the same time, and the first answer stands: `hold`
+     * says whether the dashboard may answer at all (it is interactive), so the
+     * mod knows whether to wait for it.
+     */
+    openAsk(key, session, ask) {
+        if (!isNonEmptyString(key, 64) || !isNonEmptyString(session, 256)) {
+            throw new HubRequestError('expected { project, session }', 400);
+        }
+        const state = this.projects.get(key);
+        if (!state)
+            throw new HubRequestError('unknown project', 404);
+        const fields = fieldsOf(ask);
+        const id = crypto.randomUUID();
+        let pending;
+        let event;
+        if (fields.kind === 'question') {
+            const questions = parseQuestions(fields.questions);
+            if (!questions)
+                throw new HubRequestError('expected AskUserQuestion questions', 400);
+            pending = { id, kind: 'question', questions };
+            event = { kind: 'ask', text: questions.map((q) => q.question).join(' / ') };
+        }
+        else if (fields.kind === 'permission') {
+            const tool = clip(fields.tool, 64);
+            if (!tool)
+                throw new HubRequestError('expected a tool name', 400);
+            pending = { id, kind: 'permission', tool, target: clip(fields.target, 300) ?? '' };
+            event = { kind: 'permission', tool, target: pending.target, text: '等待確認' };
+        }
+        else {
+            throw new HubRequestError('expected an ask of kind question or permission', 400);
+        }
+        const presence = this.touch(state, session);
+        this.asks.set(id, { key, session, ask: pending, opened: this.now(), waiters: new Set() });
+        const added = this.appendEvent(presence, event);
+        this.emitActivity(state, session, [added]);
+        return { id, hold: this.interactive };
+    }
+    /**
+     * The mod's wait for the dashboard's answer, held up to `pollHoldMs`: a hook
+     * waiting on a `$` call costs it none of its time budget, where one waiting
+     * on its own timer would.
+     */
+    waitAsk(id, signal) {
+        if (!isNonEmptyString(id, 128))
+            return Promise.reject(new HubRequestError('expected { id }', 400));
+        const entry = this.asks.get(id);
+        if (!entry)
+            return Promise.resolve({ closed: 'gone' });
+        if (entry.answer) {
+            this.asks.delete(id);
+            return Promise.resolve({ answer: entry.answer });
+        }
+        return new Promise((resolve) => {
+            const settle = (result) => {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', onAbort);
+                entry.waiters.delete(settle);
+                resolve(result);
+            };
+            const onAbort = () => settle({ pending: true });
+            const timer = setTimeout(() => settle({ pending: true }), this.pollHoldMs);
+            signal?.addEventListener('abort', onAbort, { once: true });
+            entry.waiters.add(settle);
+        });
+    }
+    /** The dashboard's answer to an open ask. */
+    answerAsk(key, session, id, answer) {
+        if (!this.interactive)
+            return { status: 403, body: { error: READ_ONLY_ERROR } };
+        const entry = isNonEmptyString(id, 128) ? this.asks.get(id) : undefined;
+        if (!entry || entry.key !== key || entry.session !== session || entry.answer) {
+            return { status: 404, body: { error: 'This question was already answered or withdrawn.' } };
+        }
+        const fields = fieldsOf(answer);
+        let settled;
+        let text;
+        if (entry.ask.kind === 'question') {
+            const given = fieldsOf(fields.answers);
+            const answers = {};
+            for (const q of entry.ask.questions) {
+                const value = clip(given[q.question], 2_000);
+                if (!value)
+                    return { status: 400, body: { error: `No answer for: ${q.question}` } };
+                answers[q.question] = value;
+            }
+            settled = { kind: 'question', answers };
+            text = Object.values(answers).join(' / ');
+        }
+        else {
+            if (typeof fields.allow !== 'boolean')
+                return { status: 400, body: { error: 'expected { allow: boolean }' } };
+            settled = { kind: 'permission', allow: fields.allow };
+            text = fields.allow ? '允許' : '拒絕';
+        }
+        // Set before the log line, so the summary it broadcasts no longer waits.
+        entry.answer = settled;
+        this.logAskEnd(entry, { kind: 'answer', text: `${text} (dashboard)`, ok: settled.kind === 'permission' ? settled.allow : undefined });
+        // A wait in flight takes it now; otherwise the entry stays, answered, for
+        // the mod's next wait to collect.
+        if (entry.waiters.size > 0) {
+            this.asks.delete(entry.ask.id);
+            for (const deliver of [...entry.waiters])
+                deliver({ answer: settled });
+        }
+        return { status: 200, body: { ok: true } };
+    }
+    /**
+     * Withdraws an ask the dashboard can no longer answer: the person answered
+     * it in the terminal, so the page drops its controls instead of offering a
+     * second answer. An ask the dashboard already answered stays as it is.
+     */
+    closeAsk(id, text = '已在 terminal 回答') {
+        if (!isNonEmptyString(id, 128))
+            throw new HubRequestError('expected { id }', 400);
+        const entry = this.asks.get(id);
+        if (!entry || entry.answer)
+            return;
+        // Removed before the log line, so the summary it broadcasts no longer waits.
+        this.asks.delete(id);
+        this.logAskEnd(entry, { kind: 'answer', text });
+        for (const deliver of [...entry.waiters])
+            deliver({ closed: 'gone' });
+    }
+    logAskEnd(entry, event) {
+        const state = this.projects.get(entry.key);
+        const presence = state?.sessions.get(entry.session);
+        if (!state || !presence)
+            return;
+        this.emitActivity(state, entry.session, [this.appendEvent(presence, event)]);
+    }
+    dropAsksOf(key, session) {
+        for (const [id, entry] of this.asks) {
+            if (entry.key !== key || entry.session !== session)
+                continue;
+            this.asks.delete(id);
+            for (const deliver of [...entry.waiters])
+                deliver({ closed: 'gone' });
+        }
+    }
+    /**
+     * Forgets sessions past their ttl (a session that crashed never says it
+     * left) and broadcasts the change; the server calls it on a timer.
+     */
+    sweep() {
+        for (const state of this.projects.values()) {
+            const live = new Set(this.liveSessions(state).map((s) => s.id));
+            for (const id of [...state.sessions.keys()]) {
+                if (live.has(id))
+                    continue;
+                state.sessions.delete(id);
+                this.dropAsksOf(state.key, id);
+            }
+            this.refreshPresence(state);
+        }
+    }
+    /** Releases every held poll, wait and pending relay; the hub is unusable after. */
+    close() {
+        for (const state of this.projects.values()) {
+            for (const waiter of [...state.waiters])
+                waiter.deliver([]);
+        }
+        for (const [id, pending] of this.pending) {
+            clearTimeout(pending.timer);
+            this.pending.delete(id);
+            pending.resolve({ status: 503, body: { error: 'dashboard is shutting down' } });
+        }
+        for (const [id, entry] of this.asks) {
+            this.asks.delete(id);
+            for (const deliver of [...entry.waiters])
+                deliver({ closed: 'gone' });
+        }
+        this.listeners.clear();
+    }
+    /** Sessions seen within the ttl, or holding a poll; oldest connection first. */
+    liveSessions(state) {
+        const cutoff = this.now() - this.sessionTtlMs;
+        const polling = new Set(state.waiters.map((w) => w.session));
+        return [...state.sessions.entries()]
+            .filter(([id, seen]) => seen.lastSeen >= cutoff || polling.has(id))
+            .sort(([, a], [, b]) => a.firstSeen - b.firstSeen)
+            .map(([id, seen]) => this.summarize(state.key, id, seen));
+    }
+    summarize(key, id, seen) {
+        const ask = this.openAskOf(key, id);
+        const summary = {
+            id,
+            connectedAt: new Date(seen.firstSeen).toISOString(),
+            lastSeenAt: new Date(seen.lastSeen).toISOString(),
+            status: ask ? 'waiting' : seen.status,
+            statusSince: new Date(ask ? ask.opened : seen.statusSince).toISOString(),
+        };
+        if (seen.action && !ask)
+            summary.action = seen.action;
+        if (ask)
+            summary.ask = ask.ask;
+        return summary;
+    }
+    /** The session's oldest ask the dashboard can still answer. */
+    openAskOf(key, session) {
+        let oldest;
+        for (const entry of this.asks.values()) {
+            if (entry.key !== key || entry.session !== session || entry.answer)
+                continue;
+            if (!oldest || entry.opened < oldest.opened)
+                oldest = entry;
+        }
+        return oldest;
+    }
+    isOnline(state) {
+        return this.liveSessions(state).length > 0;
+    }
+    enqueue(state, command) {
+        const waiter = state.waiters[0];
+        if (waiter)
+            waiter.deliver([command]);
+        else
+            state.queue.push(command);
+    }
+    relay(state, request) {
+        if (!this.isOnline(state)) {
+            return Promise.resolve({ status: 503, body: { error: OFFLINE_ERROR, offline: true } });
+        }
+        const command = { id: crypto.randomUUID(), kind: 'query', request };
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(command.id);
+                // Still queued means no session ever took it; drop it so a session
+                // that reconnects later does not run a write nobody is waiting for.
+                const at = state.queue.indexOf(command);
+                if (at >= 0)
+                    state.queue.splice(at, 1);
+                resolve({ status: 504, body: { error: 'the Claude Code session did not answer in time' } });
+            }, this.relayTimeoutMs);
+            this.pending.set(command.id, { resolve, timer });
+            this.enqueue(state, command);
+        });
+    }
+}
+//# sourceMappingURL=dashboard-hub.js.map