codebay 0.15.0 → 0.16.1

package/src/components/TerminalPane.svelte

@@ -4,6 +4,7 @@
 	import type { Terminal } from '@xterm/xterm';
 	import type { FitAddon } from '@xterm/addon-fit';
 	import RotateCw from '@lucide/svelte/icons/rotate-cw';
+	import { decodeOsc52 } from '../lib/osc52.ts';
 
 	let {
 		id,
@@ -118,6 +119,40 @@
 		}
 	}
 
+	/**
+	 * The Clipboard API is the only path to the *host* clipboard, but it needs a secure context and
+	 * (outside a user gesture) can still reject — hence the legacy textarea fallback behind it.
+	 */
+	async function toClipboard(text: string) {
+		if (!text) return;
+		try {
+			await navigator.clipboard.writeText(text);
+			return;
+		} catch {
+			/* no Clipboard API, or a write the browser refused — fall through */
+		}
+		const ta = document.createElement('textarea');
+		ta.value = text;
+		ta.setAttribute('aria-hidden', 'true');
+		ta.style.position = 'fixed';
+		ta.style.opacity = '0';
+		document.body.appendChild(ta);
+		ta.select();
+		try {
+			document.execCommand('copy');
+		} catch {
+			/* nothing left to try */
+		}
+		ta.remove();
+		if (active && focus) term?.focus();
+	}
+
+	/** A finished drag is both the moment the selection exists and the gesture the clipboard needs. */
+	function copySelection() {
+		const sel = term?.getSelection();
+		if (sel) void toClipboard(sel);
+	}
+
 	function fitSafe() {
 		// A hidden pane (display:none) has no size, so fitting there would throw or size to 0.
 		if (el?.clientWidth > 0 && el?.clientHeight > 0) {
@@ -165,6 +200,21 @@
 			term.open(el);
 			applyTheme();
 			fitSafe();
+			// Without this, tmux's `set-clipboard on` writes land in a handler xterm doesn't have.
+			term.parser.registerOscHandler(52, (data) => {
+				const text = decodeOsc52(data);
+				if (text !== null) void toClipboard(text);
+				return true;
+			});
+			// Chrome keeps Ctrl+Shift+C for devtools, so a browser terminal needs its own copy key.
+			term.attachCustomKeyEventHandler((e) => {
+				if (e.type !== 'keydown' || !term?.hasSelection()) return true;
+				const isCopy =
+					e.ctrlKey && (e.key === 'Insert' || (e.altKey && e.key.toLowerCase() === 'c'));
+				if (!isCopy) return true;
+				copySelection();
+				return false;
+			});
 			term.onData((d) => send(CMD_INPUT + d));
 			term.onResize(({ cols, rows }) => send(CMD_RESIZE + JSON.stringify({ columns: cols, rows })));
 			// The theme cookie flips data-theme on <html>; re-derive xterm's colors when it does.
@@ -182,8 +232,12 @@
 		const sizeObs = new ResizeObserver(() => fitSafe());
 		sizeObs.observe(el);
 
+		// Shift+drag selects in xterm even while tmux owns the mouse; copy it before a repaint clears it.
+		el.addEventListener('mouseup', copySelection);
+
 		return () => {
 			disposed = true;
+			el.removeEventListener('mouseup', copySelection);
 			sizeObs.disconnect();
 			themeObs?.disconnect();
 			scheme.removeEventListener('change', onScheme);

package/src/components/UiShowcase.svelte

@@ -14,6 +14,7 @@
 	import SettingsCog from './SettingsCog.svelte';
 	import TopBar from './TopBar.svelte';
 	import IdeLoader from './IdeLoader.svelte';
+	import DropZone from './DropZone.svelte';
 	import HealthBox from './HealthBox.svelte';
 	import BranchBox from './BranchBox.svelte';
 	import PortsBox from './PortsBox.svelte';
@@ -213,6 +214,8 @@
 	let tabEditingName = $state('');
 	// Renames are applied for real, so the inline editor is inspectable end to end.
 	let tabRenames = $state<Record<string, string>>({});
+	// No container behind the demo, so a stopped tab just stays disabled.
+	let tabStopping = $state<string[]>([]);
 
 	const demoTabs = $derived(
 		Array.from({ length: tabCount }, (_, i): Instance => {
@@ -463,6 +466,15 @@
 			{/snippet}
 		</ComponentDemo>
 
+		<ComponentDemo
+			title="DropZone"
+			note="Shown while a file drag is over an instance; the page decides when."
+		>
+			<div class="loader-stage">
+				<DropZone />
+			</div>
+		</ComponentDemo>
+
 		<ComponentDemo title="HealthBox">
 			<HealthBox
 				health={demoHealth}
@@ -555,6 +567,12 @@
 					bind:editingName={tabEditingName}
 					onreload={() => toast('Reload editor (demo)')}
 					onselect={(id) => (tabActive = demoTabs.findIndex((t) => t.id === id))}
+					stopping={tabStopping}
+					onstop={(id) => {
+						tabStopping = [...tabStopping, id];
+						toast(`Stop ${id} (demo)`);
+					}}
+					ondropfiles={(id, files) => toast(`Drop ${files.length} file(s) on ${id} (demo)`)}
 					onstartrename={(inst) => {
 						tabEditingId = inst.id;
 						tabEditingName = inst.name;
@@ -677,7 +695,7 @@
 	.showcase :global(.fields input[type='checkbox']) {
 		accent-color: var(--ink);
 	}
-	/* IdeLoader is an inset:0 overlay, so give it a sized, positioned stage. */
+	/* IdeLoader and DropZone are inset:0 overlays, so give them a sized, positioned stage. */
 	.loader-stage {
 		position: relative;
 		width: 100%;

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

@@ -49,7 +49,7 @@ const CHECK_SCRIPT = 'command -v claude >/dev/null 2>&1 && echo 1 || echo 0';
  */
 export const claudeCodeInstall: Injection = {
 	id: 'claude-code-install',
-	label: 'Claude Code',
+	label: 'Claude Code installed',
 	modes: ['terminal'],
 
 	async apply(target, log) {

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/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

@@ -6,6 +6,7 @@ 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,
@@ -56,6 +57,8 @@ await Mochi.serve({
 	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),

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

@@ -3,6 +3,15 @@
  * 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;
@@ -15,6 +24,14 @@ export interface RunStreamState {
 	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;
@@ -30,6 +47,10 @@ export function emptyRunState(): RunStreamState {
 		durationMs: null,
 		result: null,
 		structuredOutput: null,
+		lastAssistantText: null,
+		lastStructuredOutputInput: null,
+		rejectedStructuredOutput: null,
+		structuredOutputFailed: false,
 		isError: false,
 		resultSeen: false
 	};
@@ -123,6 +144,17 @@ function applyEvent(state: RunStreamState, event: StreamEvent): void {
 	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;
@@ -135,6 +167,13 @@ function applyEvent(state: RunStreamState, event: StreamEvent): void {
 		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;
@@ -213,7 +252,8 @@ function timelineFromEvent(event: StreamEvent): RunTimelineEntry[] {
 		return [
 			{
 				kind: 'result',
-				text: truncate(event.result ?? event.subtype ?? 'finished', TIMELINE_MAX),
+				// 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
 			}
 		];

package/src/lib/agent-runs.server.ts

@@ -40,6 +40,7 @@ import {
 	type ClaudePermissionMode
 } from '../types.ts';
 import {
+	STRUCTURED_OUTPUT_FAILED_ERROR,
 	emptyRunState,
 	parseRunTimeline,
 	readRunChunk,
@@ -312,6 +313,9 @@ export function runDetail(row: AgentRunRow) {
 		structured_output: row.structured_output
 			? (JSON.parse(row.structured_output) as unknown)
 			: null,
+		rejected_structured_output: row.rejected_structured_output
+			? (JSON.parse(row.rejected_structured_output) as unknown)
+			: null,
 		is_error: row.is_error === 1,
 		error: row.error,
 		exit_code: row.exit_code,
@@ -537,15 +541,21 @@ function poll(row: AgentRunRow, instance: InstanceRow): Promise<void> {
 				is_error: failed ? 1 : 0,
 				result: state.result,
 				structured_output: state.structuredOutput,
+				rejected_structured_output: state.rejectedStructuredOutput,
 				duration_ms: state.durationMs ?? (row.started_at ? Date.now() - row.started_at : null),
 				num_turns: state.numTurns,
 				cost_usd: state.costUsd,
 				session_id: state.sessionId,
 				model: state.model,
 				last_activity: state.lastActivity,
-				// The stream's own result text is the better message when claude exited cleanly but
-				// reported a failure; stderr only carries anything when it crashed outright.
-				error: failed ? stderr || state.result || `claude exited ${exitCode}` : null
+				// A schema failure gets its own marker so a caller can tell "answered but the payload
+				// never validated" (result holds that answer) from "claude crashed"; otherwise the
+				// stream's own result text beats stderr, which only fills in on an outright crash.
+				error: failed
+					? state.structuredOutputFailed
+						? STRUCTURED_OUTPUT_FAILED_ERROR
+						: stderr || state.result || `claude exited ${exitCode}`
+					: null
 			});
 			return;
 		}
@@ -614,6 +624,7 @@ export function startRun(
 		options: JSON.stringify(opts),
 		result: null,
 		structured_output: null,
+		rejected_structured_output: null,
 		last_activity: null,
 		is_error: 0,
 		exit_code: null,

package/src/lib/config.server.ts

@@ -48,12 +48,18 @@ export const APP_VERSION: string = (() => {
 	}
 })();
 
-/** Per-instance working copies live here: <INSTANCES_DIR>/<id>/workspace. */
+/** Per-instance state lives here: <INSTANCES_DIR>/<id>/<repo-or-folder-name> is the working copy. */
 export const INSTANCES_DIR = join(DATA_DIR, 'instances');
 
 /** Extracted Claude Code logs, in one flat folder that outlives the instances they came from. */
 export const LOGS_DIR = join(DATA_DIR, 'logs');
 
+/**
+ * The container's Claude config dir mirrored at its original layout, so it can be mounted back in
+ * after a rebuild. Sibling of the working copy, so it dies with the instance — unlike LOGS_DIR.
+ */
+export const claudeMirrorDir = (id: string): string => join(INSTANCES_DIR, id, 'claude');
+
 export const DB_PATH = join(DATA_DIR, 'app.sqlite');
 
 export const PORT_BASE = 8001;
@@ -144,6 +150,15 @@ export function binShim(binDir: string, name: string): string | null {
 	return null;
 }
 
+/**
+ * The CLI's `node` shebang resolves to Bun under Bun, and Bun loads `bunfig.toml` from cwd — so a
+ * workspace cwd would run the repo's `preload` on the host; not tmpdir, since that's world-writable.
+ */
+export function devcontainerCwd(): string {
+	mkdirSync(DATA_DIR, { recursive: true });
+	return DATA_DIR;
+}
+
 /**
  * An argv rather than a path, because the `devcontainer.js` fallback leads with a
  * `#!/usr/bin/env node` shebang that Windows doesn't honour — there it only runs when handed to

package/src/lib/db.server.ts

@@ -230,6 +230,8 @@ export interface AgentRunRow {
 	result: string | null;
 	/** JSON string, only when the caller passed a `--json-schema`. */
 	structured_output: string | null;
+	/** JSON string of the last schema-rejected `StructuredOutput` input, so a caller can salvage it. */
+	rejected_structured_output: string | null;
 	/** Latest tool call or assistant line, so a poller can see progress mid-run. */
 	last_activity: string | null;
 	is_error: number;
@@ -249,8 +251,8 @@ const OPEN_RUN_STATUSES = "('queued', 'running')";
 export function insertRun(row: AgentRunRow): void {
 	db.query(
 		`INSERT INTO agent_runs
-       (id, instance_id, prompt, status, session_id, model, resume_session_id, options, result, structured_output, last_activity, is_error, exit_code, cost_usd, duration_ms, num_turns, error, created_at, started_at, finished_at)
-     VALUES ($id, $instance_id, $prompt, $status, $session_id, $model, $resume_session_id, $options, $result, $structured_output, $last_activity, $is_error, $exit_code, $cost_usd, $duration_ms, $num_turns, $error, $created_at, $started_at, $finished_at)`
+       (id, instance_id, prompt, status, session_id, model, resume_session_id, options, result, structured_output, rejected_structured_output, last_activity, is_error, exit_code, cost_usd, duration_ms, num_turns, error, created_at, started_at, finished_at)
+     VALUES ($id, $instance_id, $prompt, $status, $session_id, $model, $resume_session_id, $options, $result, $structured_output, $rejected_structured_output, $last_activity, $is_error, $exit_code, $cost_usd, $duration_ms, $num_turns, $error, $created_at, $started_at, $finished_at)`
 	).run({
 		$id: row.id,
 		$instance_id: row.instance_id,
@@ -262,6 +264,7 @@ export function insertRun(row: AgentRunRow): void {
 		$options: row.options,
 		$result: row.result,
 		$structured_output: row.structured_output,
+		$rejected_structured_output: row.rejected_structured_output,
 		$last_activity: row.last_activity,
 		$is_error: row.is_error,
 		$exit_code: row.exit_code,
@@ -307,6 +310,7 @@ const UPDATABLE_RUN_COLUMNS = [
 	'model',
 	'result',
 	'structured_output',
+	'rejected_structured_output',
 	'last_activity',
 	'is_error',
 	'exit_code',

package/src/lib/devcontainer.server.ts

@@ -15,6 +15,7 @@ import {
 	PUBLISH_HOST,
 	TTYD_PORT,
 	devcontainerBin,
+	devcontainerCwd,
 	dockerEnv
 } from './config.server.ts';
 import { spawnCapture } from './spawn.server.ts';
@@ -117,7 +118,10 @@ const MANAGER_GIT_EXCLUDES = [
 	'/.devcontainer/codebay-ttyd/',
 	'/.devcontainer/codebay-claude/',
 	'/.devcontainer/codebay-terminal.sh',
-	'/.vscode/tasks.json'
+	'/.vscode/tasks.json',
+	// Self-excluding on top of this (see uploads.server.ts), so an already-running instance whose
+	// info/exclude predates the upload feature still hides the folder until its next rebuild.
+	'/codebay-inbox/'
 ];
 
 /** Bound the manager-owned block so a rebuild can replace it without touching the user's own lines. */
@@ -378,7 +382,8 @@ let cliProbeWarned = false;
 
 export async function devcontainerCliAvailable(): Promise<boolean> {
 	const argv = devcontainerBin();
-	const available = (await spawnCapture([...argv, '--version'])) !== null;
+	const available =
+		(await spawnCapture([...argv, '--version'], { cwd: devcontainerCwd() })) !== null;
 	if (!available && !cliProbeWarned) {
 		console.warn(`⚠ devcontainer CLI probe failed — could not run: ${argv.join(' ')}`);
 	}
@@ -536,6 +541,7 @@ type DevcontainerConfig = {
 	postStartCommand?: unknown;
 	runArgs?: string[];
 	containerEnv?: Record<string, string>;
+	mounts?: unknown[];
 	[key: string]: unknown;
 };
 
@@ -594,7 +600,8 @@ export async function writeOverrideConfig(
 	defaultImage: string = DEFAULT_IMAGE,
 	mode: InstanceMode = 'ide',
 	permissionMode: ClaudePermissionMode = 'default',
-	envVars: { name: string; value: string }[] = []
+	envVars: { name: string; value: string }[] = [],
+	claudeRestoreDir: string | null = null
 ): Promise<{ imageSource: string; configPath: string | null; overrideConfigPath: string }> {
 	const isTerminal = mode === 'terminal';
 	const canonical = findDevcontainerConfig(workspaceDir);
@@ -681,6 +688,19 @@ export async function writeOverrideConfig(
 		};
 	}
 
+	// Read-only so the container can't rewrite its own history; claude-history copies out of it.
+	// Our entry is re-rendered rather than merged (like appPort) so it can never accumulate, while
+	// the project's own mounts — string or object form — pass through untouched.
+	if (claudeRestoreDir) {
+		const existingMounts = Array.isArray(config.mounts) ? config.mounts : [];
+		config.mounts = [
+			...existingMounts.filter((m) => !isClaudeRestoreMount(m)),
+			// Docker Desktop takes a Windows path with forward slashes; a backslash would have to
+			// survive both JSON escaping and the CLI's comma-separated --mount parser.
+			`source=${claudeRestoreDir.replaceAll('\\', '/')},target=${CLAUDE_RESTORE_MOUNT},type=bind,readonly`
+		];
+	}
+
 	await mkdir(join(workspaceDir, '.devcontainer'), { recursive: true }).catch(() => {});
 	await writeFile(target, JSON.stringify(config, null, 2) + '\n', 'utf8');
 
@@ -707,6 +727,19 @@ export async function writeOverrideConfig(
 	return { imageSource, configPath: canonical, overrideConfigPath: target };
 }
 
+/** Where the instance's host-side Claude mirror is mounted, for `claude-history` to restore from. */
+export const CLAUDE_RESTORE_MOUNT = '/codebay/claude-restore';
+
+/** Matches our own entry in either devcontainer.json mount form, so the rewrite stays idempotent. */
+function isClaudeRestoreMount(mount: unknown): boolean {
+	if (typeof mount === 'string') return mount.split(',').includes(`target=${CLAUDE_RESTORE_MOUNT}`);
+	return (
+		typeof mount === 'object' &&
+		mount !== null &&
+		(mount as { target?: unknown }).target === CLAUDE_RESTORE_MOUNT
+	);
+}
+
 /** `codebay-tmux` has been injected into every config this manager has ever written. */
 const OVERRIDE_FINGERPRINT = TMUX_FEATURE_DIR;
 
@@ -1001,7 +1034,7 @@ export async function devcontainerUp(
 	opts: UpOptions = {}
 ): Promise<UpResult> {
 	const proc = Bun.spawn(devcontainerUpArgs(workspaceDir, opts), {
-		cwd: workspaceDir,
+		cwd: devcontainerCwd(),
 		stdout: 'pipe',
 		stderr: 'pipe',
 		env: devcontainerUpEnv()

package/src/lib/injections.server.ts

@@ -8,6 +8,7 @@ import { gitIdentity } from '../container-injections/git-identity.ts';
 import { claudeCodeCredentials } from '../container-injections/claude-code-credentials.ts';
 import { claudeCodeCustom } from '../container-injections/claude-code-custom.ts';
 import { claudeCodeSkills } from '../container-injections/claude-code-skills.ts';
+import { claudeHistory } from '../container-injections/claude-history.ts';
 import { claudeCodeIdeExtension } from '../container-injections/claude-code-ide-extension.ts';
 import { codeServerDark } from '../container-injections/code-server-dark.ts';
 import { claudeCodeInstall } from '../container-injections/claude-code-install.ts';
@@ -70,7 +71,10 @@ function buildStages(claudeInjection: Injection): Injection[][] {
 			claudeInjection,
 			claudeCodeSkills,
 			claudeCodeIdeExtension,
-			claudeEffortLevel
+			claudeEffortLevel,
+			// Only writes `projects/**` + `history.jsonl`, which no other injection touches, and
+			// lands before the injections-done sentinel releases the launcher's `claude`.
+			claudeHistory
 		],
 		// git-identity needs stage 1's safe.directory; ttyd shares the apt/dpkg lock with tmux and
 		// the /usr/local/bin symlink with claude-code-install, so it trails both. code-server-dark

package/src/lib/instances.server.ts

@@ -1,6 +1,8 @@
+import { mkdirSync } from 'node:fs';
 import { rm, stat } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import {
+	claudeMirrorDir,
 	CODE_SERVER_PORT,
 	DATA_DIR,
 	DEFAULT_COPY_IGNORE,
@@ -74,6 +76,7 @@ import { runCapturePass, stopLogCapture, syncLogCapture } from './log-capture.se
 import { currentRunSummaries, runSummary, setRunChangeHook, stopRun } from './agent-runs.server.ts';
 import { isHostPortBindable, pickBindablePort } from './ports.server.ts';
 import { pickAvatar, pickUniqueAvatar } from '../avatars/pick.server.ts';
+import { uploadEnabled } from './uploads.server.ts';
 import type { ServerWebSocket } from 'bun';
 import {
 	isInstanceFilter,
@@ -203,7 +206,9 @@ export type StreamEvent =
 	// The global default editor surface, so the picker's toggle follows a settings change.
 	| { type: 'default-mode'; data: { mode: InstanceMode } }
 	// The colour scheme, so a change in the settings popup repaints the window behind it.
-	| { type: 'theme'; data: { value: Theme } };
+	| { type: 'theme'; data: { value: Theme } }
+	// Arms/disarms the drop zones on every open page when the setting flips.
+	| { type: 'upload-enabled'; data: { enabled: boolean } };
 
 interface StreamHub {
 	sockets: Set<ServerWebSocket<unknown>>;
@@ -277,6 +282,11 @@ export function broadcastTheme(value: Theme): void {
 	broadcast({ type: 'theme', data: { value } });
 }
 
+/** Settings opens in its own popup, so every open dashboard/IDE tab needs the new toggle pushed. */
+export function broadcastUploadEnabled(enabled: boolean): void {
+	broadcast({ type: 'upload-enabled', data: { enabled } });
+}
+
 async function reconcileInstances(force = false): Promise<void> {
 	const list = await listInstances();
 	const listJson = JSON.stringify(list);
@@ -327,6 +337,8 @@ export function streamOpen(ws: ServerWebSocket<unknown>): void {
 	});
 	// Same, for the default mode the picker's toggle seeds from.
 	sendTo(ws, { type: 'default-mode', data: { mode: getDefaultMode() } });
+	// Same, for the upload toggle, so a reconnecting client's drop zones match the current setting.
+	sendTo(ws, { type: 'upload-enabled', data: { enabled: uploadEnabled() } });
 }
 
 export function streamClose(ws: ServerWebSocket<unknown>): void {
@@ -493,6 +505,10 @@ async function provision(row: InstanceRow, opts: { noCache?: boolean } = {}): Pr
 		}));
 		appendLog(row.id, `Injecting ${surfaceLabel(row.mode)} (host port ${row.host_port})\n`);
 		const defaultImage = getOption('default_image') ?? DEFAULT_IMAGE;
+		// Mounted read-only for claude-history to restore from, so it has to exist before the boot —
+		// and it has to be mounted *after* the drain above, or a rebuild would restore a stale mirror.
+		const mirrorDir = claudeMirrorDir(row.id);
+		mkdirSync(mirrorDir, { recursive: true });
 		const { imageSource, configPath, overrideConfigPath } = await writeOverrideConfig(
 			row.workspace_path,
 			row.host_port,
@@ -500,7 +516,8 @@ async function provision(row: InstanceRow, opts: { noCache?: boolean } = {}): Pr
 			defaultImage,
 			row.mode,
 			getClaudePermissionMode(),
-			customEnvVarsConfig()?.vars ?? []
+			customEnvVarsConfig()?.vars ?? [],
+			mirrorDir
 		);
 		updateInstance(row.id, { image_source: imageSource });
 
@@ -908,8 +925,8 @@ export async function deleteInstance(id: string): Promise<void> {
 	await cancelActiveRun(id, 'the sandbox was deleted');
 	stopHealthMonitor(id);
 	// Mirror the tail of the session before the transcripts die with the container; the periodic
-	// chain is stopped first so it can't race this last pass. Retention outlives the instance —
-	// <LOGS_DIR>/*-<id>.jsonl is deliberately left on disk.
+	// chain is stopped first so it can't race this last pass. The flat <LOGS_DIR>/*-<id>.jsonl
+	// archive is deliberately left on disk; the per-instance mirror goes with the instance below.
 	stopLogCapture(id);
 	if (row.container_id) {
 		await runCapturePass(row).catch(() => undefined);