codebay 0.13.0 → 0.15.0

package/src/components/SettingsView.svelte

@@ -10,6 +10,7 @@
 	import ThemePicker from './ThemePicker.svelte';
 	import Layers from '@lucide/svelte/icons/layers';
 	import FolderMinus from '@lucide/svelte/icons/folder-minus';
+	import FolderCog from '@lucide/svelte/icons/folder-cog';
 	import Trash2 from '@lucide/svelte/icons/trash-2';
 	import Hammer from '@lucide/svelte/icons/hammer';
 	import KeyRound from '@lucide/svelte/icons/key-round';
@@ -23,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';
@@ -69,6 +71,11 @@
 		disableBuildCache,
 		copyIgnorePatterns,
 		builtinCopyIgnore,
+		claudeConfigDir,
+		mcpEnabled,
+		mcpToken,
+		mcpUrl,
+		mcpPrAttribution,
 		gitIdentityEnabled,
 		gitIdentityName,
 		gitIdentityEmail,
@@ -110,6 +117,11 @@
 		disableBuildCache: boolean;
 		copyIgnorePatterns: string;
 		builtinCopyIgnore: string;
+		claudeConfigDir: string;
+		mcpEnabled: boolean;
+		mcpToken: string;
+		mcpUrl: string;
+		mcpPrAttribution: boolean;
 		gitIdentityEnabled: boolean;
 		gitIdentityName: string;
 		gitIdentityEmail: string;
@@ -372,6 +384,80 @@
 		copyIgnoreFormEl?.requestSubmit();
 	}
 
+	// Blank means "use ~/.claude" — the host dir the Claude config injections read from.
+	// svelte-ignore state_referenced_locally
+	let claudeDir = $state(claudeConfigDir);
+	let savingClaudeDir = $state(false);
+	let claudeDirError = $state<string | null>(null);
+	let claudeDirSaved = $state(false);
+	let claudeDirFormEl: HTMLFormElement | undefined;
+
+	const claudeDirOpts = saveOpts<{ dir: string }>({
+		setSaving: (v) => (savingClaudeDir = v),
+		setError: (v) => (claudeDirError = v),
+		setMsg: (v) => (claudeDirSaved = !!v),
+		onSuccess: (data) => {
+			claudeDir = data?.dir ?? claudeDir;
+			claudeDirSaved = true;
+		}
+	});
+
+	function resetClaudeDir() {
+		flushSync(() => (claudeDir = ''));
+		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);
@@ -1156,6 +1242,164 @@
 			</form>
 		</section>
 
+		<section class="card">
+			<form
+				class="row image-row"
+				method="POST"
+				action="?/claudeConfigDir"
+				bind:this={claudeDirFormEl}
+				{@attach enhance(claudeDirOpts)}
+			>
+				<div class="label">
+					<FolderCog size={20} />
+					<div class="text">
+						<div class="name">Claude config directory</div>
+						<div class="desc">
+							Host directory the Claude Code injections read from — credentials, statusLine, output
+							styles, and global skills / <code>CLAUDE.md</code>. Leave blank to use
+							<code>~/.claude</code>. Takes effect for instances created from now on.
+						</div>
+					</div>
+				</div>
+				<div class="image-controls">
+					<input
+						type="text"
+						name="dir"
+						class="image-input"
+						bind:value={claudeDir}
+						spellcheck="false"
+						autocapitalize="off"
+						autocorrect="off"
+						placeholder="~/.claude"
+					/>
+					<Button type="submit" disabled={savingClaudeDir}>Save</Button>
+					<Button
+						type="button"
+						icon={RotateCcw}
+						disabled={savingClaudeDir}
+						onclick={resetClaudeDir}
+						title="Reset to default (~/.claude)"
+						aria-label="Reset to default Claude config directory"
+					/>
+				</div>
+				{#if claudeDirError}
+					<div class="msg error">{claudeDirError}</div>
+				{:else if claudeDirSaved}
+					<div class="msg ok">Saved.</div>
+				{/if}
+			</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"
@@ -2619,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-code-credentials.ts

@@ -1,7 +1,6 @@
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { hostClaudeFile } from '../lib/host-claude.server.ts';
 import { CLAUDE_CODE_TOKEN, CLAUDE_KEYCHAIN_SERVICE } from '../lib/config.server.ts';
 import { getOption } from '../lib/db.server.ts';
 import { checkPresence } from '../lib/exec.server.ts';
@@ -84,7 +83,7 @@ async function locateClaudeCredentials(): Promise<{ creds: string; source: strin
 		}
 	}
 
-	const file = join(homedir(), '.claude', '.credentials.json');
+	const file = hostClaudeFile('.credentials.json');
 	if (existsSync(file)) {
 		const raw = (await readFile(file, 'utf8')).trim();
 		if (isValid(raw)) return { creds: raw, source: '~/.claude/.credentials.json' };

package/src/container-injections/claude-code-skills.ts

@@ -0,0 +1,125 @@
+import { existsSync } from 'node:fs';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { posix } from 'node:path';
+import { checkPresence } from '../lib/exec.server.ts';
+import { writeContainerFileBytes } from '../lib/container-files.server.ts';
+import { claudeConfigFile } from '../lib/claude-settings.server.ts';
+import { hostClaudeFile } from '../lib/host-claude.server.ts';
+import type { Injection } from '../lib/injections.server.ts';
+
+/**
+ * The env-var stdin carrier caps a single write near 128 KB (Linux `MAX_ARG_STRLEN`); base64
+ * inflates ~4/3, so a raw file over this is skipped rather than failing the whole injection.
+ */
+const MAX_FILE_BYTES = 90_000;
+
+interface HostFile {
+	/** Path relative to the host Claude dir, e.g. `CLAUDE.md` or `skills/foo/SKILL.md`. */
+	rel: string;
+	bytes: Buffer;
+	/** True when any execute bit is set on the host, so container scripts stay runnable. */
+	exec: boolean;
+	oversized: boolean;
+}
+
+/** Recursively lists every file under a host dir, as `skills/<subpath>` entries. */
+async function walkSkills(dir: string, rel: string, out: HostFile[]): Promise<void> {
+	let entries;
+	try {
+		entries = await readdir(dir, { withFileTypes: true });
+	} catch {
+		return;
+	}
+	for (const entry of entries) {
+		const abs = posix.join(dir, entry.name);
+		const childRel = posix.join(rel, entry.name);
+		if (entry.isDirectory()) {
+			await walkSkills(abs, childRel, out);
+		} else if (entry.isFile()) {
+			const info = await stat(abs);
+			out.push({
+				rel: childRel,
+				bytes: info.size > MAX_FILE_BYTES ? Buffer.alloc(0) : await readFile(abs),
+				exec: (info.mode & 0o111) !== 0,
+				oversized: info.size > MAX_FILE_BYTES
+			});
+		}
+	}
+}
+
+/** Cheap presence probe for the setup-UI chip — never reads file contents. */
+export async function hasHostSkillFiles(): Promise<boolean> {
+	if (existsSync(hostClaudeFile('CLAUDE.md'))) return true;
+	try {
+		return (await readdir(hostClaudeFile('skills'))).length > 0;
+	} catch {
+		return false;
+	}
+}
+
+/** The host global CLAUDE.md plus every file under the host skills dir. */
+export async function collectHostSkillFiles(): Promise<HostFile[]> {
+	const files: HostFile[] = [];
+	const claudeMd = hostClaudeFile('CLAUDE.md');
+	if (existsSync(claudeMd)) {
+		const info = await stat(claudeMd);
+		if (info.isFile()) {
+			files.push({
+				rel: 'CLAUDE.md',
+				bytes: info.size > MAX_FILE_BYTES ? Buffer.alloc(0) : await readFile(claudeMd),
+				exec: false,
+				oversized: info.size > MAX_FILE_BYTES
+			});
+		}
+	}
+	await walkSkills(hostClaudeFile('skills'), 'skills', files);
+	return files;
+}
+
+export const claudeCodeSkills: Injection = {
+	id: 'claude-code-skills',
+	label: 'skills & CLAUDE.md',
+
+	auth: {
+		hint: 'add skills or a CLAUDE.md to your host ~/.claude',
+		async status() {
+			const available = await hasHostSkillFiles();
+			return { available, source: available ? '~/.claude' : null };
+		}
+	},
+
+	async apply(target, log) {
+		const files = await collectHostSkillFiles();
+		if (!files.length) {
+			log('⚠ No global skills or CLAUDE.md found on host; skipped\n');
+			return;
+		}
+		log(`Injecting ${files.length} global skill/CLAUDE.md file(s)…\n`);
+		let failed = 0;
+		for (const file of files) {
+			if (file.oversized) {
+				log(`⚠ Skipped ${file.rel} (larger than ${MAX_FILE_BYTES} bytes)\n`);
+				continue;
+			}
+			const dest = claudeConfigFile(file.rel, file.exec ? '755' : '644');
+			const wrote = await writeContainerFileBytes(target, dest, file.bytes);
+			if (!wrote.ok) {
+				failed++;
+				log(`⚠ Failed to write ${file.rel}: ${wrote.error}\n`);
+			}
+		}
+		log(
+			failed
+				? `⚠ ${failed} skill file(s) failed to inject\n`
+				: '✓ Global skills & CLAUDE.md injected\n'
+		);
+	},
+
+	async check(target) {
+		return checkPresence(
+			target,
+			'h=$(eval echo ~$(id -un)); d="${CLAUDE_CONFIG_DIR:-$h/.claude}"; ' +
+				'if [ -s "$d/CLAUDE.md" ] || [ -n "$(ls -A "$d/skills" 2>/dev/null)" ]; then echo 1; else echo 0; fi'
+		);
+	}
+};

package/src/container-injections/claude-output-style.ts

@@ -1,5 +1,4 @@
 import { readdir, readFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { getOption } from '../lib/db.server.ts';
 import { writeContainerFile } from '../lib/container-files.server.ts';
@@ -8,7 +7,7 @@ import {
 	mergeClaudeSettings,
 	readClaudeSettings
 } from '../lib/claude-settings.server.ts';
-import { readHostClaudeSettings } from './claude-statusline.ts';
+import { hostClaudeFile, readHostClaudeSettings } from '../lib/host-claude.server.ts';
 import { normalizeOutputStyle } from '../types.ts';
 import type { ClaudeOutputStyle } from '../types.ts';
 import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
@@ -29,7 +28,7 @@ export async function resolveEffectiveOutputStyle(): Promise<string | null> {
 
 /** The host's custom output-style definitions, so a non-built-in name resolves inside the container. */
 export async function readHostOutputStyleFiles(): Promise<{ name: string; content: string }[]> {
-	const dir = join(homedir(), '.claude', 'output-styles');
+	const dir = hostClaudeFile('output-styles');
 	let names: string[];
 	try {
 		names = (await readdir(dir)).filter((n) => n.endsWith('.md'));

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

@@ -1,15 +1,18 @@
-import { existsSync, statSync } from 'node:fs';
+import { statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { isAbsolute } from 'node:path';
 import { writeContainerFile } from '../lib/container-files.server.ts';
 import {
 	claudeConfigFile,
 	mergeClaudeSettings,
 	readClaudeSettings
 } from '../lib/claude-settings.server.ts';
+import { expandTilde, readHostClaudeSettings } from '../lib/host-claude.server.ts';
 import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
 
+// Re-exported so the modules and tests that historically imported these from here keep working.
+export { expandTilde, readHostClaudeSettings };
+
 /** Left unexpanded — Claude Code invokes this long after the injection has finished. */
 const CONTAINER_SCRIPT_PATH = '${CLAUDE_CONFIG_DIR:-$HOME/.claude}/statusline.sh';
 
@@ -19,19 +22,6 @@ interface StatusLineConfig {
 	script?: string;
 }
 
-export async function readHostClaudeSettings(): Promise<Record<string, unknown> | null> {
-	const file = join(homedir(), '.claude', 'settings.json');
-	if (!existsSync(file)) return null;
-	try {
-		return JSON.parse(await readFile(file, 'utf8')) as Record<string, unknown>;
-	} catch {
-		return null;
-	}
-}
-
-export const expandTilde = (p: string): string =>
-	p.startsWith('~/') ? join(homedir(), p.slice(2)) : p;
-
 /** Only a real file counts — else jq's `//` operator and a bare `/` resolve to the root dir. */
 const isExistingFile = (p: string): boolean => {
 	try {
@@ -45,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;