codebay 0.13.0 → 0.15.0

package/src/mcp/tools.server.ts

@@ -0,0 +1,494 @@
+import * as v from 'valibot';
+import type { McpServer } from 'tmcp';
+import { tool } from 'tmcp/utils';
+import {
+	createInstance,
+	deleteInstance,
+	listInstances,
+	sanitizeInstance,
+	subscribeLogs
+} from '../lib/instances.server.ts';
+import { getInstance, getRun, listRuns, type AgentRunRow } from '../lib/db.server.ts';
+import {
+	PROMPT_MAX_BYTES,
+	pollRunNow,
+	readRunLog,
+	runDetail,
+	startRun,
+	stopRun
+} from '../lib/agent-runs.server.ts';
+import {
+	WRITE_FILE_MAX_BYTES,
+	createPr,
+	execCommand,
+	gitDiff,
+	gitPush,
+	readWorkspaceFile,
+	writeWorkspaceFile
+} from '../lib/sandbox-ops.server.ts';
+import { currentHealthSnapshots } from '../lib/health.server.ts';
+import { proxyPathFor } from '../lib/proxy.server.ts';
+import { PUBLIC_ORIGIN } from '../lib/config.server.ts';
+import { CLAUDE_PERMISSION_MODES, normalizeMode } from '../types.ts';
+
+/** Long-polling `get_run` past this would start tripping MCP clients' own request timeouts. */
+const MAX_WAIT_SECONDS = 60;
+
+const sandboxId = v.pipe(v.string(), v.minLength(1), v.description('The sandbox id.'));
+
+function requireInstance(id: string) {
+	const row = getInstance(id);
+	if (!row) throw new Error(`No sandbox with id ${id}`);
+	return row;
+}
+
+/** Every tool that touches the container needs one that is actually up. */
+function requireRunning(id: string) {
+	const row = requireInstance(id);
+	if (!row.container_id || row.status !== 'running') {
+		throw new Error(
+			row.status === 'creating'
+				? 'the sandbox is still building — poll get_sandbox until status is "running"'
+				: `the sandbox is ${row.status}, not running`
+		);
+	}
+	return row;
+}
+
+/** The IDE link is what makes a sandbox inspectable by a human, so every sandbox payload carries it. */
+const ideUrl = (id: string) => `${PUBLIC_ORIGIN}${proxyPathFor(id)}`;
+
+function sandboxPayload(row: ReturnType<typeof requireInstance>) {
+	return { ...sanitizeInstance(row), ide_url: ideUrl(row.id) };
+}
+
+/** The prompt is left out: the caller wrote it, and it can be as large as the carrier allows. */
+function runPayload(run: AgentRunRow) {
+	const { id, instance_id, prompt: _prompt, ...detail } = runDetail(run);
+	return { run_id: id, sandbox_id: instance_id, ...detail };
+}
+
+/**
+ * A failed call reaches the model as readable content rather than a JSON-RPC protocol error: the
+ * caller is an agent, and "that sandbox is still building" is information it can act on.
+ */
+function safe<T>(run: (input: T) => unknown) {
+	return async (input: T) => {
+		try {
+			return tool.text(JSON.stringify(await run(input), null, 2));
+		} catch (err) {
+			return tool.error((err as Error).message);
+		}
+	};
+}
+
+const runOptions = {
+	resume_session_id: v.optional(
+		v.pipe(
+			v.string(),
+			v.description('Continue a previous run’s Claude session instead of starting fresh.')
+		)
+	),
+	model: v.optional(
+		v.pipe(
+			v.string(),
+			v.description(
+				'Model alias or id, e.g. "sonnet". Omit for the sandbox default. The run reports the id ' +
+					'Claude actually used as `model` once it starts.'
+			)
+		)
+	),
+	max_turns: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1))),
+	json_schema: v.optional(
+		v.pipe(
+			v.string(),
+			v.description(
+				'A JSON Schema (as a string). When set, the run’s structured_output matches it.'
+			)
+		)
+	),
+	permission_mode: v.optional(
+		v.pipe(
+			v.picklist(CLAUDE_PERMISSION_MODES),
+			v.description(
+				'Tightens what Claude may do. Omit for full autonomy, which is the default for MCP runs.'
+			)
+		)
+	),
+	timeout_minutes: v.optional(v.pipe(v.number(), v.minValue(1), v.maxValue(240)))
+};
+
+type RunOptionInput = v.InferInput<v.ObjectSchema<typeof runOptions, undefined>>;
+
+// The byte limits are enforced at runtime (startRun, writeWorkspaceFile) and only documented here:
+// a `v.check` can't be rendered into the JSON Schema an MCP client reads.
+const promptSchema = (description: string) =>
+	v.pipe(
+		v.string(),
+		v.minLength(1),
+		v.description(
+			`${description} At most ${PROMPT_MAX_BYTES} bytes of UTF-8; refer to a workspace file for anything larger.`
+		)
+	);
+
+function toStartOptions(input: RunOptionInput) {
+	return {
+		resumeSessionId: input.resume_session_id,
+		model: input.model,
+		maxTurns: input.max_turns,
+		jsonSchema: input.json_schema,
+		permissionMode: input.permission_mode,
+		timeoutMs: input.timeout_minutes ? input.timeout_minutes * 60_000 : undefined
+	};
+}
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export function registerTools(server: McpServer<v.GenericSchema>): void {
+	/** Registers a tool whose handler returns a plain payload; `safe` serialises it and traps errors. */
+	function define<E extends v.ObjectEntries>(
+		options: { name: string; description: string; schema: v.ObjectSchema<E, undefined> },
+		run: (input: v.InferInput<v.ObjectSchema<E, undefined>>) => unknown
+	): void {
+		server.tool(options, safe(run));
+	}
+
+	define(
+		{
+			name: 'create_sandbox',
+			description:
+				'Create an isolated devcontainer sandbox from a Git repo URL or a local folder path on ' +
+				'the Codebay host. Returns immediately while the container builds in the background; poll ' +
+				'get_sandbox until status is "running". Pass a prompt to queue an agent run that starts ' +
+				'as soon as the sandbox is up.',
+			schema: v.object({
+				source: v.pipe(
+					v.string(),
+					v.minLength(1),
+					v.description('A Git repo URL (cloned) or an absolute local folder path (copied).')
+				),
+				name: v.optional(v.string()),
+				branch: v.optional(v.pipe(v.string(), v.description('Branch to check out after cloning.'))),
+				mode: v.optional(v.picklist(['ide', 'terminal'] as const)),
+				prompt: v.optional(promptSchema('Queues an agent run once the sandbox is running.')),
+				...runOptions
+			})
+		},
+		async (input) => {
+			const instance = await createInstance(input.source, input.name, {
+				branch: input.branch,
+				mode: input.mode ? normalizeMode(input.mode) : undefined
+			});
+			// The sandbox exists once createInstance returns, so a failed run must not swallow its id —
+			// the caller would retry and leak the first one.
+			let run: AgentRunRow | null = null;
+			let runError: string | undefined;
+			try {
+				if (input.prompt) run = startRun(instance, input.prompt, toStartOptions(input));
+			} catch (err) {
+				runError = err instanceof Error ? err.message : String(err);
+			}
+			return {
+				sandbox: sandboxPayload(instance),
+				run: run ? runPayload(run) : null,
+				...(runError ? { run_error: runError } : {}),
+				note: 'The sandbox is building. Poll get_sandbox until status is "running".'
+			};
+		}
+	);
+
+	define(
+		{
+			name: 'list_sandboxes',
+			description:
+				'List every sandbox Codebay is managing, with its status and any run currently in flight.',
+			schema: v.object({
+				status: v.optional(v.picklist(['creating', 'running', 'stopped', 'error'] as const))
+			})
+		},
+		async (input) => {
+			const all = await listInstances();
+			const rows = input.status ? all.filter((i) => i.status === input.status) : all;
+			return {
+				sandboxes: rows.map((row) => ({ ...row, ide_url: ideUrl(row.id) }))
+			};
+		}
+	);
+
+	define(
+		{
+			name: 'get_sandbox',
+			description:
+				'Full detail for one sandbox: status, health probes, forwarded ports and its active run.',
+			schema: v.object({ sandbox_id: sandboxId })
+		},
+		async (input) => {
+			const row = requireInstance(input.sandbox_id);
+			const health = currentHealthSnapshots().find((s) => s.id === row.id)?.health ?? null;
+			const runs = listRuns(row.id, 5);
+			return {
+				sandbox: sandboxPayload(row),
+				health,
+				runs: runs.map(runPayload)
+			};
+		}
+	);
+
+	define(
+		{
+			name: 'delete_sandbox',
+			description:
+				'Destroy a sandbox: cancels any active run, removes the container and its workspace copy. ' +
+				'Mirrored run transcripts are kept.',
+			schema: v.object({ sandbox_id: sandboxId })
+		},
+		async (input) => {
+			requireInstance(input.sandbox_id);
+			await deleteInstance(input.sandbox_id);
+			return { deleted: input.sandbox_id };
+		}
+	);
+
+	define(
+		{
+			name: 'run_agent',
+			description:
+				'Run Claude Code non-interactively against the sandbox and return a run handle. The run ' +
+				'continues in the background; poll get_run for progress and the final result. Only one ' +
+				'run at a time per sandbox.',
+			schema: v.object({
+				sandbox_id: sandboxId,
+				prompt: promptSchema('What Claude should do.'),
+				...runOptions
+			})
+		},
+		(input) => {
+			const row = requireInstance(input.sandbox_id);
+			return { run: runPayload(startRun(row, input.prompt, toStartOptions(input))) };
+		}
+	);
+
+	define(
+		{
+			name: 'get_run',
+			description:
+				'Status and result of an agent run. While it is still going you get the live session id, ' +
+				'model, turn count, cost and what Claude is doing right now. Set wait_seconds to block until it ' +
+				'finishes instead of polling.',
+			schema: v.object({
+				run_id: v.pipe(v.string(), v.minLength(1)),
+				wait_seconds: v.optional(
+					v.pipe(
+						v.number(),
+						v.integer(),
+						v.minValue(0),
+						v.maxValue(MAX_WAIT_SECONDS),
+						v.description('Block up to this long for the run to finish before answering.')
+					)
+				)
+			})
+		},
+		async (input) => {
+			if (!getRun(input.run_id)) throw new Error(`No run with id ${input.run_id}`);
+			const deadline = Date.now() + (input.wait_seconds ?? 0) * 1000;
+			let run = await pollRunNow(input.run_id);
+			while (
+				run &&
+				(run.status === 'running' || run.status === 'queued') &&
+				Date.now() < deadline
+			) {
+				await sleep(2000);
+				run = await pollRunNow(input.run_id);
+			}
+			return { run: runPayload(run!) };
+		}
+	);
+
+	define(
+		{
+			name: 'list_runs',
+			description: 'Run history for a sandbox, newest first.',
+			schema: v.object({
+				sandbox_id: sandboxId,
+				limit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(100)))
+			})
+		},
+		(input) => {
+			requireInstance(input.sandbox_id);
+			return { runs: listRuns(input.sandbox_id, input.limit ?? 20).map(runPayload) };
+		}
+	);
+
+	define(
+		{
+			name: 'stop_run',
+			description:
+				'Cancel an agent run. Sends SIGINT first so Claude can end its turn cleanly, then ' +
+				'escalates if it does not exit.',
+			schema: v.object({ run_id: v.pipe(v.string(), v.minLength(1)) })
+		},
+		async (input) => ({ run: runPayload(await stopRun(input.run_id)) })
+	);
+
+	define(
+		{
+			name: 'get_diff',
+			description:
+				'The sandbox workspace’s uncommitted changes as a unified diff, plus a porcelain ' +
+				'status summary and the current branch. This is how you see what an agent run actually did.',
+			schema: v.object({
+				sandbox_id: sandboxId,
+				base: v.optional(
+					v.pipe(v.string(), v.description('Diff against this ref instead of the working tree.'))
+				),
+				staged: v.optional(v.boolean())
+			})
+		},
+		async (input) =>
+			await gitDiff(requireRunning(input.sandbox_id), {
+				base: input.base,
+				staged: input.staged
+			})
+	);
+
+	define(
+		{
+			name: 'read_file',
+			description:
+				'Read a file from the sandbox workspace, by path relative to the workspace root.',
+			schema: v.object({ sandbox_id: sandboxId, path: v.pipe(v.string(), v.minLength(1)) })
+		},
+		async (input) => ({
+			path: input.path,
+			content: await readWorkspaceFile(requireRunning(input.sandbox_id), input.path)
+		})
+	);
+
+	define(
+		{
+			name: 'write_file',
+			description:
+				'Write a file into the sandbox workspace, creating parent directories as needed. Useful ' +
+				`for seeding config or fixtures before prompting Claude. Content is capped at ${WRITE_FILE_MAX_BYTES} ` +
+				'bytes per call; build anything larger inside the sandbox with exec_command.',
+			schema: v.object({
+				sandbox_id: sandboxId,
+				path: v.pipe(v.string(), v.minLength(1)),
+				content: v.pipe(
+					v.string(),
+					v.description(`The file's full UTF-8 text, at most ${WRITE_FILE_MAX_BYTES} bytes.`)
+				)
+			})
+		},
+		async (input) => {
+			await writeWorkspaceFile(requireRunning(input.sandbox_id), input.path, input.content);
+			return { path: input.path, written: true };
+		}
+	);
+
+	define(
+		{
+			name: 'exec_command',
+			description:
+				'Run a shell command in the sandbox, from the workspace root, and capture its output. ' +
+				'Bounded by timeout_seconds (default 120).',
+			schema: v.object({
+				sandbox_id: sandboxId,
+				command: v.pipe(v.string(), v.minLength(1)),
+				cwd: v.optional(
+					v.pipe(v.string(), v.description('Run from here instead of the workspace root.'))
+				),
+				timeout_seconds: v.optional(
+					v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(3600))
+				)
+			})
+		},
+		async (input) =>
+			await execCommand(requireRunning(input.sandbox_id), input.command, {
+				timeoutSeconds: input.timeout_seconds,
+				cwd: input.cwd
+			})
+	);
+
+	define(
+		{
+			name: 'git_push',
+			description:
+				'Commit any pending changes and push the sandbox branch to origin. Git and gh are already ' +
+				'authenticated inside the container, so no credentials are needed here.',
+			schema: v.object({
+				sandbox_id: sandboxId,
+				branch: v.optional(
+					v.pipe(v.string(), v.description('Branch to push to; defaults to the current one.'))
+				),
+				commit_message: v.optional(
+					v.pipe(
+						v.string(),
+						v.description('Commit everything outstanding under this message first.')
+					)
+				),
+				force: v.optional(v.pipe(v.boolean(), v.description('Push with --force-with-lease.')))
+			})
+		},
+		async (input) =>
+			await gitPush(requireRunning(input.sandbox_id), {
+				branch: input.branch,
+				commitMessage: input.commit_message,
+				force: input.force
+			})
+	);
+
+	define(
+		{
+			name: 'create_pr',
+			description: 'Open a pull request from the sandbox branch using the container’s gh CLI.',
+			schema: v.object({
+				sandbox_id: sandboxId,
+				title: v.pipe(v.string(), v.minLength(1)),
+				body: v.optional(v.string()),
+				base: v.optional(v.string()),
+				draft: v.optional(v.boolean())
+			})
+		},
+		async (input) =>
+			await createPr(requireRunning(input.sandbox_id), {
+				title: input.title,
+				body: input.body,
+				base: input.base,
+				draft: input.draft
+			})
+	);
+
+	define(
+		{
+			name: 'get_logs',
+			description:
+				'Logs for a sandbox. kind "boot" is the provisioning log (why a build failed); kind "run" ' +
+				'is the mirrored event stream of an agent run.',
+			schema: v.object({
+				sandbox_id: sandboxId,
+				kind: v.picklist(['boot', 'run'] as const),
+				run_id: v.optional(v.string()),
+				tail: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(2000)))
+			})
+		},
+		(input) => {
+			requireInstance(input.sandbox_id);
+			const tail = input.tail ?? 200;
+			if (input.kind === 'run') {
+				if (!input.run_id) throw new Error('run_id is required for kind "run"');
+				// Resolve through the DB so the id is a known token, never a path fragment.
+				const run = getRun(input.run_id);
+				if (!run || run.instance_id !== input.sandbox_id) {
+					throw new Error(`No run ${input.run_id} in sandbox ${input.sandbox_id}`);
+				}
+				return { kind: 'run', run_id: run.id, log: readRunLog(run.id, tail) };
+			}
+			// subscribeLogs replays the buffer synchronously before it starts streaming, so
+			// unsubscribing straight away leaves us with exactly the captured boot log.
+			const lines: string[] = [];
+			subscribeLogs(input.sandbox_id, (chunk) => lines.push(chunk))();
+			return { kind: 'boot', log: lines.join('').split('\n').slice(-tail).join('\n') };
+		}
+	);
+}

package/src/pages/Settings.svelte

@@ -21,6 +21,11 @@
 		disableBuildCache,
 		copyIgnorePatterns,
 		builtinCopyIgnore,
+		claudeConfigDir,
+		mcpEnabled,
+		mcpToken,
+		mcpUrl,
+		mcpPrAttribution,
 		gitIdentityEnabled,
 		gitIdentityName,
 		gitIdentityEmail,
@@ -62,6 +67,11 @@
 		disableBuildCache: boolean;
 		copyIgnorePatterns: string;
 		builtinCopyIgnore: string;
+		claudeConfigDir: string;
+		mcpEnabled: boolean;
+		mcpToken: string;
+		mcpUrl: string;
+		mcpPrAttribution: boolean;
 		gitIdentityEnabled: boolean;
 		gitIdentityName: string;
 		gitIdentityEmail: string;
@@ -106,6 +116,11 @@
 	{disableBuildCache}
 	{copyIgnorePatterns}
 	{builtinCopyIgnore}
+	{claudeConfigDir}
+	{mcpEnabled}
+	{mcpToken}
+	{mcpUrl}
+	{mcpPrAttribution}
 	{gitIdentityEnabled}
 	{gitIdentityName}
 	{gitIdentityEmail}

package/src/routes.ts

@@ -60,14 +60,30 @@ import {
 	deleteFolderHistory,
 	getInstance,
 	getOption,
+	listRuns,
 	listFolderHistory,
 	setOption
 } from './lib/db.server.ts';
-import { APP_VERSION, DEFAULT_COPY_IGNORE, DEFAULT_IMAGE } from './lib/config.server.ts';
+import {
+	APP_VERSION,
+	DEFAULT_COPY_IGNORE,
+	DEFAULT_IMAGE,
+	PUBLIC_ORIGIN
+} from './lib/config.server.ts';
 import { wsUpgradeAllowed } from './lib/auth.server.ts';
+import {
+	MCP_PATH,
+	getMcpToken,
+	mcpEnabled,
+	regenerateMcpToken,
+	setMcpEnabled
+} from './lib/mcp-auth.server.ts';
 import { clearAttention, setAttention } from './lib/bridge.server.ts';
 import { timingSafeEqualStr } from './lib/crypto.server.ts';
 import { proxyRoutes } from './lib/proxy.server.ts';
+import { runDetail, runTimeline } from './lib/agent-runs.server.ts';
+import { PR_ATTRIBUTION_KEY, prAttributionEnabled } from './lib/sandbox-ops.server.ts';
+import { mcpRoutes } from './mcp/routes.server.ts';
 import {
 	isInstanceFilter,
 	isTheme,
@@ -112,6 +128,9 @@ function currentFilter(): InstanceFilter {
 	return isInstanceFilter(v) ? v : 'all';
 }
 
+/** A ceiling on how many run timelines one Agent log request can pull off disk. */
+const MAX_OPEN_TIMELINES = 10;
+
 /** Lets a route handler just `throw` for both validation and business-logic failures. */
 async function mutate(fn: () => Promise<unknown> | unknown): Promise<Response> {
 	try {
@@ -214,8 +233,16 @@ export const routes: Record<string, MochiRouteValue> = {
 				// An explicit empty string (as opposed to unset) means "copy everything".
 				copyIgnorePatterns: getOption('copy_ignore_patterns') ?? DEFAULT_COPY_IGNORE,
 				builtinCopyIgnore: DEFAULT_COPY_IGNORE,
+				// Blank means "use ~/.claude"; the host dir credentials/skills/statusLine read from.
+				claudeConfigDir: getOption('claude_config_dir') ?? '',
 				// Not secrets, so the actual values (not just a "set" flag) go to the client.
 				// Blank means "no override" — fall back to the host's git config.
+				mcpEnabled: mcpEnabled(),
+				// The one secret here that IS sent to the client: copying it into an MCP client is
+				// the whole point of it existing.
+				mcpToken: mcpEnabled() ? getMcpToken() : '',
+				mcpUrl: `${PUBLIC_ORIGIN}${MCP_PATH}`,
+				mcpPrAttribution: prAttributionEnabled(),
 				gitIdentityEnabled: gitIdentityEnabled(),
 				gitIdentityName: getOption('git_identity_name') ?? '',
 				gitIdentityEmail: getOption('git_identity_email') ?? '',
@@ -334,6 +361,27 @@ export const routes: Record<string, MochiRouteValue> = {
 				return success({ patterns });
 			},
 
+			// The host directory Claude config injections read from; blank falls back to ~/.claude.
+			claudeConfigDir: ({ formData }) => {
+				const dir = str(formData, 'dir').trim();
+				setOption('claude_config_dir', dir);
+				return success({ dir });
+			},
+
+			mcpToggle: ({ formData }) => {
+				const enabled = onChecked(formData, 'enabled');
+				setMcpEnabled(enabled);
+				return success({ enabled, token: enabled ? getMcpToken() : '' });
+			},
+			// Rotating breaks every client already configured with the old token, so the UI confirms.
+			mcpRegenerateToken: () => success({ token: regenerateMcpToken() }),
+
+			mcpPrAttributionToggle: ({ formData }) => {
+				const enabled = onChecked(formData, 'enabled');
+				setOption(PR_ATTRIBUTION_KEY, enabled ? '1' : '0');
+				return success({ enabled });
+			},
+
 			gitIdentityToggle: ({ formData }) => {
 				const enabled = onChecked(formData, 'enabled');
 				setOption('git_identity_enabled', enabled ? '1' : '0');
@@ -630,6 +678,27 @@ export const routes: Record<string, MochiRouteValue> = {
 		return { ok: true };
 	}),
 
+	// GET-only, so the CSRF header guard doesn't apply; the Basic Auth gate still does.
+	'/api/instances/:id/agent-log': Mochi.api(({ method, params, url }) => {
+		if (method !== 'GET') return apiError(405, 'Method Not Allowed');
+		if (!getInstance(params.id!)) return apiError(404, 'Instance not found');
+		const runs = listRuns(params.id!, 20);
+		const known = new Set(runs.map((r) => r.id));
+		// The panel asks for whichever runs it has expanded; with none named it opens on the newest.
+		const wanted = (url.searchParams.get('run_ids') ?? '')
+			.split(',')
+			.filter((rid) => known.has(rid));
+		const ids = (wanted.length ? wanted : runs.slice(0, 1).map((r) => r.id)).slice(
+			0,
+			MAX_OPEN_TIMELINES
+		);
+		return json({
+			runs: runs.map(runDetail),
+			// Keyed by run id: one request refreshes every expanded box at once.
+			timelines: Object.fromEntries(ids.map((rid) => [rid, runTimeline(rid)]))
+		});
+	}),
+
 	'/api/instances/:id/attention/clear': mutationRoute('POST', ({ params }) => {
 		clearAttention(params.id!);
 		return { ok: true };
@@ -686,6 +755,8 @@ export const routes: Record<string, MochiRouteValue> = {
 
 	...proxyRoutes,
 
+	...mcpRoutes,
+
 	...(process.env.MODE === 'development'
 		? {
 				'/debug': Mochi.page('./src/pages/UI.svelte', {

package/src/shell.html

@@ -3,6 +3,7 @@
 	<head>
 		<meta charset="utf-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1" />
+		<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
 		<title>Codebay</title>
 		<style>
 			/* Each themed variable is defined once as light-dark(light, dark). With no

package/src/types.ts

@@ -29,6 +29,21 @@ export interface Instance {
 	git_branch: string | null;
 	attention: 'done' | 'waiting' | null;
 	forwarded_ports: PortForward[];
+	/** The newest unfinished MCP-driven run, or null when nothing is running in this sandbox. */
+	active_run: AgentRunSummary | null;
+}
+
+export type AgentRunStatus = 'queued' | 'running' | 'done' | 'error' | 'cancelled';
+
+/** The slice of an agent run the dashboard renders; the prompt and result never ride the stream. */
+export interface AgentRunSummary {
+	id: string;
+	instance_id: string;
+	status: AgentRunStatus;
+	last_activity: string | null;
+	started_at: number | null;
+	finished_at: number | null;
+	is_error: boolean;
 }
 
 /** `'ide'` serves full code-server; `'terminal'` serves only ttyd + Claude Code. */

package/.mochi/svelte-client/HydratableIsland-zrdsrsmg.js

@@ -1 +0,0 @@
-import{mb as a}from"/_mochi/client/chunk-phf7v5jj.js";import"/_mochi/client/chunk-0mc09cyb.js";export{a as registerComponent};