codebay 0.14.0 → 0.15.0

package/src/components/SettingsView.svelte

@@ -24,6 +24,7 @@
 	import ListOrdered from '@lucide/svelte/icons/list-ordered';
 	import Boxes from '@lucide/svelte/icons/boxes';
 	import Puzzle from '@lucide/svelte/icons/puzzle';
+	import Plug from '@lucide/svelte/icons/plug';
 	import { Toaster } from 'svelte-french-toast';
 	import { TOAST_OPTIONS } from '../toast.ts';
 	import { flushSync } from 'svelte';
@@ -71,6 +72,10 @@
 		copyIgnorePatterns,
 		builtinCopyIgnore,
 		claudeConfigDir,
+		mcpEnabled,
+		mcpToken,
+		mcpUrl,
+		mcpPrAttribution,
 		gitIdentityEnabled,
 		gitIdentityName,
 		gitIdentityEmail,
@@ -113,6 +118,10 @@
 		copyIgnorePatterns: string;
 		builtinCopyIgnore: string;
 		claudeConfigDir: string;
+		mcpEnabled: boolean;
+		mcpToken: string;
+		mcpUrl: string;
+		mcpPrAttribution: boolean;
 		gitIdentityEnabled: boolean;
 		gitIdentityName: string;
 		gitIdentityEmail: string;
@@ -398,6 +407,57 @@
 		claudeDirFormEl?.requestSubmit();
 	}
 
+	// svelte-ignore state_referenced_locally
+	let mcp = $state(mcpEnabled);
+	// Unlike every other secret here this one round-trips to the client — a human has to copy it.
+	// svelte-ignore state_referenced_locally
+	let mcpTokenValue = $state(mcpToken);
+	let savingMcpToggle = $state(false);
+	let mcpToggleError = $state<string | null>(null);
+	let savingMcpToken = $state(false);
+	let mcpTokenError = $state<string | null>(null);
+	let mcpCopied = $state<string | null>(null);
+
+	const mcpToggleOpts = toggleOpts<{ enabled: boolean; token: string }>({
+		set: (v) => (mcp = v),
+		setSaving: (v) => (savingMcpToggle = v),
+		setError: (v) => (mcpToggleError = v),
+		onSuccess: (data) => (mcpTokenValue = data?.token ?? '')
+	});
+
+	const mcpTokenOpts = saveOpts<{ token: string }>({
+		setSaving: (v) => (savingMcpToken = v),
+		setError: (v) => (mcpTokenError = v),
+		onSuccess: (data) => (mcpTokenValue = data?.token ?? ''),
+		confirmMessage:
+			'Regenerate the MCP token? Any agent already configured with the current token will stop working.'
+	});
+
+	// svelte-ignore state_referenced_locally
+	let mcpAttribution = $state(mcpPrAttribution);
+	let savingMcpAttribution = $state(false);
+	let mcpAttributionError = $state<string | null>(null);
+
+	const mcpAttributionOpts = toggleOpts({
+		set: (v) => (mcpAttribution = v),
+		setSaving: (v) => (savingMcpAttribution = v),
+		setError: (v) => (mcpAttributionError = v)
+	});
+
+	const mcpCommand = $derived(
+		`claude mcp add --transport http codebay ${mcpUrl} --header "Authorization: Bearer ${mcpTokenValue}"`
+	);
+
+	async function copyMcp(label: string, text: string) {
+		try {
+			await navigator.clipboard.writeText(text);
+			mcpCopied = label;
+			setTimeout(() => (mcpCopied = null), 1500);
+		} catch {
+			mcpTokenError = 'Could not copy — select the text and copy it manually.';
+		}
+	}
+
 	// svelte-ignore state_referenced_locally
 	let gitIdentity = $state(gitIdentityEnabled);
 	let savingGitToggle = $state(false);
@@ -1230,6 +1290,116 @@
 			</form>
 		</section>
 
+		<section class="card">
+			<form class="row" method="POST" action="?/mcpToggle" {@attach enhance(mcpToggleOpts)}>
+				<div class="label">
+					<Plug size={20} />
+					<div class="text">
+						<div class="name">MCP server</div>
+						<div class="desc">
+							Expose Codebay to other AI agents over MCP, so they can create sandboxes, run Claude
+							Code in them non-interactively and read back the result. Off by default; the endpoint
+							404s until you turn it on, then authenticates with the bearer token below.
+						</div>
+					</div>
+				</div>
+				<label class="switch">
+					<input
+						type="checkbox"
+						name="enabled"
+						checked={mcp}
+						disabled={savingMcpToggle}
+						onchange={(e) => {
+							mcp = e.currentTarget.checked;
+							e.currentTarget.form?.requestSubmit();
+						}}
+					/>
+					<span class="track"><span class="thumb"></span></span>
+				</label>
+			</form>
+			{#if mcpToggleError}
+				<div class="sub"><div class="msg error">{mcpToggleError}</div></div>
+			{/if}
+
+			{#if mcp}
+				<div class="row divided">
+					<div class="label">
+						<div class="text">
+							<div class="name">Token</div>
+							<div class="desc">
+								Anything holding this token can create containers and run agents with your GitHub
+								and Claude credentials. Treat it like a password.
+							</div>
+						</div>
+					</div>
+					<div class="model-fields">
+						<label class="model-row">
+							<span class="model-label">Bearer</span>
+							<input
+								type="text"
+								class="image-input"
+								value={mcpTokenValue}
+								readonly
+								spellcheck="false"
+								onfocus={(e) => e.currentTarget.select()}
+							/>
+						</label>
+						<div class="mcp-actions">
+							<Button type="button" onclick={() => copyMcp('token', mcpTokenValue)}>
+								{mcpCopied === 'token' ? 'Copied' : 'Copy token'}
+							</Button>
+							<Button type="button" onclick={() => copyMcp('command', mcpCommand)}>
+								{mcpCopied === 'command' ? 'Copied' : 'Copy claude mcp add'}
+							</Button>
+							<form method="POST" action="?/mcpRegenerateToken" {@attach enhance(mcpTokenOpts)}>
+								<Button type="submit" disabled={savingMcpToken}>
+									{savingMcpToken ? 'Regenerating…' : 'Regenerate'}
+								</Button>
+							</form>
+						</div>
+						<code class="mcp-command">{mcpCommand}</code>
+						{#if mcpTokenError}
+							<div class="msg error">{mcpTokenError}</div>
+						{/if}
+					</div>
+				</div>
+
+				<form
+					class="row divided"
+					method="POST"
+					action="?/mcpPrAttributionToggle"
+					{@attach enhance(mcpAttributionOpts)}
+				>
+					<div class="label">
+						<div class="text">
+							<div class="name">Credit Codebay on pull requests</div>
+							<div class="desc">
+								Append a one-line footer to the body of every pull request an agent opens through
+								<code>create_pr</code>. Off by default — an attribution line on your PRs is yours to
+								opt into.
+							</div>
+						</div>
+					</div>
+					<label class="switch">
+						<input
+							type="checkbox"
+							name="enabled"
+							checked={mcpAttribution}
+							disabled={savingMcpAttribution}
+							onchange={(e) => {
+								mcpAttribution = e.currentTarget.checked;
+								e.currentTarget.form?.requestSubmit();
+							}}
+						/>
+						<span class="track"><span class="thumb"></span></span>
+					</label>
+				</form>
+				{#if mcpAttributionError}
+					<div class="sub"><div class="msg error">{mcpAttributionError}</div></div>
+				{/if}
+			{/if}
+		</section>
+
 		<section class="card">
 			<form
 				class="row"
@@ -2693,6 +2863,22 @@
 		flex: 1;
 		min-width: 220px;
 	}
+	.mcp-actions {
+		display: flex;
+		flex-wrap: wrap;
+		gap: 6px;
+	}
+	/* The registration line is long and unbreakable, so it scrolls rather than widening the card. */
+	.mcp-command {
+		display: block;
+		overflow-x: auto;
+		white-space: pre;
+		padding: 6px 8px;
+		border: 1px solid var(--edge);
+		background: var(--panel);
+		font-size: 11px;
+		line-height: 1.5;
+	}
 	.model-row {
 		display: flex;
 		align-items: center;

package/src/components/UiShowcase.svelte

@@ -183,7 +183,8 @@
 		terminal_split: 0,
 		git_branch: cardBranch ? branchName : null,
 		attention: cardAttention,
-		forwarded_ports: demoPorts
+		forwarded_ports: demoPorts,
+		active_run: null
 	});
 
 	const statuses: Instance['status'][] = ['creating', 'running', 'stopped', 'error'];
@@ -234,7 +235,8 @@
 				terminal_split: 0,
 				git_branch: 'main',
 				attention: null,
-				forwarded_ports: []
+				forwarded_ports: [],
+				active_run: null
 			};
 		})
 	);

package/src/container-injections/claude-statusline.ts

@@ -1,5 +1,6 @@
 import { statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
+import { isAbsolute } from 'node:path';
 import { writeContainerFile } from '../lib/container-files.server.ts';
 import {
 	claudeConfigFile,
@@ -34,7 +35,9 @@ const isExistingFile = (p: string): boolean => {
 export function extractScriptPath(command: string): string | null {
 	const token = command
 		.split(/\s+/)
-		.find((t) => (t.startsWith('/') || t.startsWith('~/')) && isExistingFile(expandTilde(t)));
+		// isAbsolute rather than a leading slash, so a Windows `C:…` command is recognised too;
+		// on POSIX the two are equivalent. The file check still rejects a bare root either way.
+		.find((t) => (isAbsolute(t) || t.startsWith('~/')) && isExistingFile(expandTilde(t)));
 	return token ?? null;
 }
 

package/src/container-injections/github-credentials.ts

@@ -51,8 +51,19 @@ export function ghHostBlock(raw: string, host: string): string | null {
 	return rest.slice(0, end === -1 ? rest.length : end).join('\n');
 }
 
+/** Mirrors `gh`'s own resolution order, which is not XDG on Windows. */
+function ghConfigDir(): string {
+	const explicit = process.env.GH_CONFIG_DIR?.trim();
+	if (explicit) return explicit;
+	if (process.platform === 'win32') {
+		return join(process.env.AppData || join(homedir(), 'AppData', 'Roaming'), 'GitHub CLI');
+	}
+	const xdg = process.env.XDG_CONFIG_HOME?.trim();
+	return xdg ? join(xdg, 'gh') : join(homedir(), '.config', 'gh');
+}
+
 async function readGhHostsFile(): Promise<string | null> {
-	const file = join(homedir(), '.config', 'gh', 'hosts.yml');
+	const file = join(ghConfigDir(), 'hosts.yml');
 	if (!existsSync(file)) return null;
 	try {
 		return await readFile(file, 'utf8');

package/src/index.ts

@@ -1,11 +1,15 @@
 import { Mochi, sequence, silenceInternalRoutes } from 'mochi-framework';
 import { routes } from './routes.ts';
-import { basicAuth } from './lib/auth.server.ts';
+import { basicAuth, tokenAuthenticated } from './lib/auth.server.ts';
 import { themeHandle } from './lib/theme.server.ts';
 import { PROXY_PREFIX } from './lib/proxy.server.ts';
+import { resumeRuns } from './lib/agent-runs.server.ts';
+import { warnIfBuildStale } from './lib/build-freshness.server.ts';
+import { LOCK_STALE_MS, acquireDataDirLock } from './lib/data-dir-lock.server.ts';
 import {
 	APP_VERSION,
 	BASIC_AUTH_PASSWORD,
+	DATA_DIR,
 	HOST,
 	PORT,
 	PUBLIC_ORIGIN,
@@ -21,10 +25,32 @@ if (HOST !== '127.0.0.1' && HOST !== 'localhost' && !BASIC_AUTH_PASSWORD) {
 		`⚠ Binding to ${HOST} (non-loopback) without a password — anyone on the network can reach this server.`
 	);
 }
+warnIfBuildStale();
+
+const lock = acquireDataDirLock(DATA_DIR);
+if (!lock.ok) {
+	const who = lock.holder
+		? `pid ${lock.holder.pid} on ${lock.holder.host}, started ${new Date(lock.holder.startedAt).toLocaleString()}`
+		: 'an unknown process';
+	console.error(
+		`✖ Another codebay manager (${who}) is already using ${DATA_DIR}. Two managers on one data dir ` +
+			"poll the same runs and overwrite each other's rows — stop it, or start this one with a " +
+			`different DATA_DIR. A crashed manager's lock (${lock.path}) clears itself after ${LOCK_STALE_MS / 1000}s.`
+	);
+	process.exit(1);
+}
+// A default Ctrl-C skips the exit hooks, and an unreleased lock refuses the restart that follows.
+process.on('exit', () => lock.release());
+for (const signal of ['SIGINT', 'SIGTERM'] as const) {
+	process.on(signal, () => process.exit(signal === 'SIGINT' ? 130 : 143));
+}
 
 // Must precede Mochi.serve(), which is where MOCHI_KEY is read.
 ensureMochiKey();
 
+// Agent runs outlive the process that started them, so re-attach pollers to anything still in flight.
+resumeRuns();
+
 await Mochi.serve({
 	port: PORT,
 	hostname: HOST,
@@ -41,10 +67,9 @@ await Mochi.serve({
 		trustedOrigins: TRUSTED_ORIGINS
 	},
 	filters: {
-		// Containers curl the bridge with no Origin header, which the check would 403;
-		// safe because the route authenticates by token, not ambient browser credentials.
-		'csrf:check': (decision, { url }) =>
-			url.pathname.startsWith('/api/bridge/') ? null : decision,
+		// Containers and MCP clients send no Origin header, which the check would 403; safe because
+		// those routes authenticate by token, not ambient browser credentials.
+		'csrf:check': (decision, { url }) => (tokenAuthenticated(url.pathname) ? null : decision),
 		'consoleLogger:line': (line, ctx) => {
 			const kept = silenceInternalRoutes(line, ctx);
 			if (kept == null) {
@@ -53,8 +78,8 @@ await Mochi.serve({
 			if (ctx.source.name === 'ws:message' && ctx.path.startsWith(PROXY_PREFIX + '/')) {
 				return null;
 			}
-			// These fire on every Claude hook event and carry the bridge token.
-			if (ctx.path.startsWith('/api/bridge/')) {
+			// A line per Claude hook event or JSON-RPC frame is noise, and each would print its token.
+			if (tokenAuthenticated(ctx.path)) {
 				return null;
 			}
 			return kept;

package/src/lib/agent-run-stream.ts

@@ -0,0 +1,246 @@
+/**
+ * Chunk-oriented because the poller tails raw bytes that usually end mid-line, and free of
+ * Node/Bun APIs so it can be unit-tested on its own.
+ */
+
+/** Everything the run row needs, accumulated across chunks. */
+export interface RunStreamState {
+	sessionId: string | null;
+	/** The model Claude actually ran with (an id like `claude-opus-5`), from the `init` event. */
+	model: string | null;
+	lastActivity: string | null;
+	numTurns: number | null;
+	costUsd: number | null;
+	durationMs: number | null;
+	result: string | null;
+	/** Serialized `structured_output`, present only when the caller passed a `--json-schema`. */
+	structuredOutput: string | null;
+	isError: boolean;
+	/** True once the terminal `result` event has been seen, whatever its subtype. */
+	resultSeen: boolean;
+}
+
+export function emptyRunState(): RunStreamState {
+	return {
+		sessionId: null,
+		model: null,
+		lastActivity: null,
+		numTurns: null,
+		costUsd: null,
+		durationMs: null,
+		result: null,
+		structuredOutput: null,
+		isError: false,
+		resultSeen: false
+	};
+}
+
+/** Long enough to identify the step, short enough to sit on one line of a caller's poll output. */
+const ACTIVITY_MAX = 120;
+
+/** The timeline has a whole panel to render into, so it keeps more of each line than the poller. */
+const TIMELINE_MAX = 400;
+
+function truncate(text: string, max = ACTIVITY_MAX): string {
+	const oneLine = text.replace(/\s+/g, ' ').trim();
+	return oneLine.length > max ? oneLine.slice(0, max - 1) + '…' : oneLine;
+}
+
+/** The field that best identifies a call, per tool; anything unlisted falls back to the first string. */
+const TOOL_SUMMARY_FIELDS = [
+	'command',
+	'file_path',
+	'path',
+	'pattern',
+	'description',
+	'query',
+	'url',
+	'prompt'
+];
+
+function summarizeToolInput(input: unknown): string {
+	if (typeof input !== 'object' || input === null) return '';
+	const obj = input as Record<string, unknown>;
+	for (const field of TOOL_SUMMARY_FIELDS) {
+		const value = obj[field];
+		if (typeof value === 'string' && value.trim()) return value;
+	}
+	const first = Object.values(obj).find((v) => typeof v === 'string' && v.trim());
+	return typeof first === 'string' ? first : '';
+}
+
+interface ContentBlock {
+	type?: string;
+	text?: string;
+	name?: string;
+	input?: unknown;
+}
+
+/** The last block wins, so `last_activity` reflects the most recent thing Claude did in the turn. */
+function activityFromBlocks(blocks: ContentBlock[]): string | null {
+	let activity: string | null = null;
+	for (const block of blocks) {
+		if (block.type === 'tool_use' && typeof block.name === 'string') {
+			const arg = summarizeToolInput(block.input);
+			activity = arg ? `${block.name}(${truncate(arg)})` : block.name;
+		} else if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
+			activity = truncate(block.text);
+		}
+	}
+	return activity;
+}
+
+interface StreamEvent {
+	type?: string;
+	subtype?: string;
+	session_id?: string;
+	model?: string;
+	parent_tool_use_id?: string | null;
+	message?: { content?: ContentBlock[] };
+	error?: string;
+	attempt?: number;
+	result?: string;
+	structured_output?: unknown;
+	is_error?: boolean;
+	num_turns?: number;
+	total_cost_usd?: number;
+	duration_ms?: number;
+}
+
+function applyEvent(state: RunStreamState, event: StreamEvent): void {
+	if (typeof event.session_id === 'string' && !state.sessionId) state.sessionId = event.session_id;
+
+	if (event.type === 'system' && event.subtype === 'init' && typeof event.model === 'string') {
+		state.model = event.model;
+		return;
+	}
+
+	if (event.type === 'system' && event.subtype === 'api_retry') {
+		state.lastActivity = `Retrying (${event.error ?? 'error'}), attempt ${event.attempt ?? 1}…`;
+		return;
+	}
+
+	if (event.type === 'assistant' && Array.isArray(event.message?.content)) {
+		// Subagent chatter would otherwise drown out what the main loop is doing.
+		if (event.parent_tool_use_id != null) return;
+		const activity = activityFromBlocks(event.message.content);
+		if (activity) state.lastActivity = activity;
+		return;
+	}
+
+	if (event.type === 'result') {
+		state.resultSeen = true;
+		state.isError = event.is_error === true || event.subtype !== 'success';
+		if (typeof event.result === 'string') state.result = event.result;
+		if (event.structured_output !== undefined && event.structured_output !== null) {
+			state.structuredOutput = JSON.stringify(event.structured_output);
+		}
+		if (typeof event.num_turns === 'number') state.numTurns = event.num_turns;
+		if (typeof event.total_cost_usd === 'number') state.costUsd = event.total_cost_usd;
+		if (typeof event.duration_ms === 'number') state.durationMs = event.duration_ms;
+	}
+}
+
+/**
+ * Folds a chunk of newline-delimited JSON into `state`, returning the incomplete trailing line for
+ * the caller to prepend next time. A line that won't parse is skipped rather than fatal — a torn
+ * write reappears whole on the following pass.
+ */
+export function readRunChunk(
+	state: RunStreamState,
+	carry: string,
+	chunk: string
+): { state: RunStreamState; carry: string } {
+	const lines = (carry + chunk).split('\n');
+	const tail = lines.pop() ?? '';
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			applyEvent(state, JSON.parse(trimmed) as StreamEvent);
+		} catch {
+			// Not a torn line but genuine garbage (a stray shell warning); ignore it.
+		}
+	}
+	return { state, carry: tail };
+}
+
+/** Replays a whole mirror file — how a run's state is rebuilt after the manager restarts. */
+export function readRunFile(text: string): RunStreamState {
+	return readRunChunk(emptyRunState(), '', text).state;
+}
+
+/** One rendered row of the Agent log panel. */
+export interface RunTimelineEntry {
+	kind: 'tool' | 'text' | 'retry' | 'result';
+	/** Tool name, when `kind` is `'tool'`. */
+	name?: string;
+	text: string;
+	/** True for a subagent's message, which the panel indents rather than hides. */
+	subagent?: boolean;
+	isError?: boolean;
+}
+
+function timelineFromEvent(event: StreamEvent): RunTimelineEntry[] {
+	if (event.type === 'system' && event.subtype === 'api_retry') {
+		return [
+			{
+				kind: 'retry',
+				text: `Retrying (${event.error ?? 'error'}), attempt ${event.attempt ?? 1}…`
+			}
+		];
+	}
+	if (event.type === 'assistant' && Array.isArray(event.message?.content)) {
+		const subagent = event.parent_tool_use_id != null;
+		const out: RunTimelineEntry[] = [];
+		for (const block of event.message.content) {
+			if (block.type === 'tool_use' && typeof block.name === 'string') {
+				const arg = summarizeToolInput(block.input);
+				out.push({
+					kind: 'tool',
+					name: block.name,
+					text: truncate(arg, TIMELINE_MAX),
+					subagent
+				});
+			} else if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
+				out.push({ kind: 'text', text: truncate(block.text, TIMELINE_MAX), subagent });
+			}
+		}
+		return out;
+	}
+	if (event.type === 'result') {
+		const isError = event.is_error === true || event.subtype !== 'success';
+		return [
+			{
+				kind: 'result',
+				text: truncate(event.result ?? event.subtype ?? 'finished', TIMELINE_MAX),
+				isError
+			}
+		];
+	}
+	return [];
+}
+
+/**
+ * Flattens a whole mirrored run into the rows the Agent log renders. Separate from `readRunChunk`
+ * because that one only keeps the *latest* of each field — a timeline needs every step.
+ */
+export function parseRunTimeline(text: string): RunTimelineEntry[] {
+	const out: RunTimelineEntry[] = [];
+	for (const line of text.split('\n')) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			for (const entry of timelineFromEvent(JSON.parse(trimmed) as StreamEvent)) {
+				// Claude's closing message arrives twice — once as the final assistant text block and
+				// again as the `result` event's text — so the result supersedes it rather than repeats it.
+				const prev = out.at(-1);
+				if (entry.kind === 'result' && prev?.kind === 'text' && prev.text === entry.text) out.pop();
+				out.push(entry);
+			}
+		} catch {
+			// A torn trailing line; it reappears whole once more bytes land.
+		}
+	}
+	return out;
+}