codebay 0.14.0 → 0.16.0

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

@@ -0,0 +1,52 @@
+import type { Injection } from '../lib/injections.server.ts';
+import { CLAUDE_RESTORE_MOUNT } from '../lib/devcontainer.server.ts';
+import { afterMarker, checkPresence, execInContainer } from '../lib/exec.server.ts';
+
+const RESTORE_MARKER = '__CODEBAY_RESTORE__';
+
+/**
+ * `cp -n` isn't in busybox, so missing files are selected explicitly; the count rides a marker
+ * because the login shell's profile output precedes anything the script prints.
+ */
+export function restoreScript(mountDir: string = CLAUDE_RESTORE_MOUNT): string {
+	return (
+		// The host mirror's modes don't survive the mount, so match the 0600 Claude Code writes.
+		`umask 077; ` +
+		`h=$(eval echo ~$(id -un)); cfg="\${CLAUDE_CONFIG_DIR:-$h/.claude}"; ` +
+		`cd ${mountDir} 2>/dev/null || { printf '%s0\\n' '${RESTORE_MARKER}'; exit 0; }; ` +
+		// Listed to a file, not piped: a pipeline would run the loop in a subshell the count dies with.
+		// Redirecting the loop (rather than word-splitting `find`) also survives a path with spaces.
+		`l="\${TMPDIR:-/tmp}/codebay-restore.$$"; find . -type f > "$l"; n=0; ` +
+		`while IFS= read -r f; do ` +
+		`d="$cfg/\${f#./}"; ` +
+		// A file the container already has is live state; the mirror is only ever a floor.
+		`[ -e "$d" ] && continue; ` +
+		`mkdir -p "$(dirname "$d")" && cp "$f" "$d" && n=$((n + 1)); ` +
+		`done < "$l"; rm -f "$l"; printf '%s%s\\n' '${RESTORE_MARKER}' "$n"`
+	);
+}
+
+/**
+ * A rebuild recreates the container filesystem, so `~/.claude` — and with it every transcript
+ * `/resume` offers — starts empty. The host mirror is bind-mounted back in read-only; this copies
+ * whatever the fresh container is missing out of it.
+ */
+export const claudeHistory: Injection = {
+	id: 'claude-history',
+	label: 'Claude history',
+
+	async apply(target, log) {
+		const res = await execInContainer(target, { script: restoreScript(), capture: true });
+		if (!res.ok) {
+			log(`⚠ Claude history restore failed: ${res.error}\n`);
+			return;
+		}
+		const count = Number(afterMarker(res.stdout, RESTORE_MARKER)?.trim());
+		if (count > 0) log(`✓ Restored ${count} Claude conversation file(s) from a previous build\n`);
+	},
+
+	// The mount, not the copied files, is what the next rebuild restores from; compose configs drop it.
+	async check(target) {
+		return checkPresence(target, `[ -d ${CLAUDE_RESTORE_MOUNT} ] && echo 1 || echo 0`);
+	}
+};

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/container-injections/tmux.ts

@@ -15,13 +15,17 @@ export const INSTALL_SCRIPT =
 	'command -v tmux >/dev/null 2>&1';
 
 /**
- * `mouse on` buys wheel-scroll at the cost of code-server's native drag-select, since tmux
- * takes the mouse — hence `bind m` to toggle it, shadowing mark-pane, unused in a single pane.
+ * `mouse on` buys wheel-scroll and makes tmux — not the browser — own the drag, which is what
+ * survives Claude's screen repaints; `set-clipboard on` then hands the copy to the host via OSC 52,
+ * which `TerminalPane` decodes. `bind m` shadows mark-pane, unused in a single pane.
  */
 export const TMUX_CONF_LINES = [
 	'set -g mouse on',
 	'set -g history-limit 50000',
 	'set -g set-clipboard on',
+	// Only `xterm*` gets the clipboard feature by default, so an image whose TERM is anything
+	// else silently turns `set-clipboard on` into a no-op.
+	"set -as terminal-overrides ',*:Ms=\\E]52;%p1%s;%p2%s\\007'",
 	'set -g allow-passthrough on',
 	'set -g status off',
 	'bind m set -g mouse \\; display-message "mouse: #{?mouse,on,off}"'

package/src/index.ts

@@ -1,11 +1,16 @@
 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 { UPLOAD_MAX_BYTES } from './lib/uploads.server.ts';
 import {
 	APP_VERSION,
 	BASIC_AUTH_PASSWORD,
+	DATA_DIR,
 	HOST,
 	PORT,
 	PUBLIC_ORIGIN,
@@ -21,15 +26,39 @@ 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,
 	// Bun defaults to 10s and aborts slower form POSTs mid-flight; passed through to Bun.serve.
 	idleTimeout: 120,
+	// Bun's own default (128 MiB) is below UPLOAD_MAX_BYTES; passed through to Bun.serve.
+	maxRequestBodySize: UPLOAD_MAX_BYTES,
 	development: process.env.MODE === 'development',
 	htmlShell: './src/shell.html',
 	handle: sequence(basicAuth, themeHandle),
@@ -41,10 +70,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 +81,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,286 @@
+/**
+ * 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.
+ */
+
+/** Claude Code's terminal subtype when every `--json-schema` attempt failed validation. */
+const STRUCTURED_OUTPUT_RETRY_SUBTYPE = 'error_max_structured_output_retries';
+
+/** The tool Claude Code calls to hand back a `--json-schema` payload. */
+const STRUCTURED_OUTPUT_TOOL = 'StructuredOutput';
+
+/** A run's `error` when the agent answered but its schema payload never validated. */
+export const STRUCTURED_OUTPUT_FAILED_ERROR = 'structured_output_failed';
+
+/** 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;
+	/** The last untruncated main-loop text block — the answer to fall back on when the schema fails. */
+	lastAssistantText: string | null;
+	/** Serialized input of the latest `StructuredOutput` call, whether or not it was accepted. */
+	lastStructuredOutputInput: string | null;
+	/** Set on the terminal event: the payload the schema rejected, for a caller to salvage. */
+	rejectedStructuredOutput: string | null;
+	/** True when the run died on `--json-schema` retry exhaustion rather than a crash. */
+	structuredOutputFailed: boolean;
+	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,
+		lastAssistantText: null,
+		lastStructuredOutputInput: null,
+		rejectedStructuredOutput: null,
+		structuredOutputFailed: false,
+		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;
+		for (const block of event.message.content) {
+			if (block.type === 'text' && typeof block.text === 'string' && block.text.trim()) {
+				state.lastAssistantText = block.text.trim();
+			} else if (
+				block.type === 'tool_use' &&
+				block.name === STRUCTURED_OUTPUT_TOOL &&
+				block.input
+			) {
+				state.lastStructuredOutputInput = JSON.stringify(block.input);
+			}
+		}
+		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 (event.subtype === STRUCTURED_OUTPUT_RETRY_SUBTYPE) {
+			state.structuredOutputFailed = true;
+			// Retries only run out once every attempt was rejected, so the latest one is a rejected one.
+			state.rejectedStructuredOutput = state.lastStructuredOutputInput;
+			// Claude Code leaves `result` empty on this subtype, throwing away an answer it did give.
+			if (!state.result?.trim()) state.result = state.lastAssistantText;
+		}
+		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',
+				// A failed subtype often carries an empty `result`, which would render a blank row.
+				text: truncate(event.result?.trim() || 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;
+}