codebay 0.0.1 → 0.2.0

package/src/container-injections/attention-hooks.ts

@@ -0,0 +1,117 @@
+import { PORT } from '../lib/config.server.ts';
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
+
+function bridgeUrl(): string {
+	return `http://host.docker.internal:${PORT}/api/bridge/attention`;
+}
+
+/** Read by curl as `-H @<file>` so the token never reaches argv, where `ps` would show it. */
+const HEADER_FILE = '${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.bridge-header';
+
+/** Claude discards hook stdout/stderr, so a silently-failing ping would leave no other trace. */
+const HOOK_LOG = '${CLAUDE_CONFIG_DIR:-$HOME/.claude}/.bridge-hook.log';
+
+/**
+ * `-f` is deliberately absent so a 4xx still yields an HTTP status to log rather than
+ * curl bailing early; `curl_exit` then separates "unreachable" from "answered with a status".
+ */
+function hookFor(id: string, state: 'done' | 'waiting' | 'busy') {
+	const url = `${bridgeUrl()}?id=${encodeURIComponent(id)}&state=${state}`;
+	const command =
+		`log="${HOOK_LOG}"; ` +
+		// The Content-Type is for Mochi's CSRF guard, which reads a bodiless POST as a form submit.
+		`http=$(curl -sS -m 5 -o /dev/null -w '%{http_code}' -X POST -H 'Content-Type: application/json' -H @"${HEADER_FILE}" '${url}' 2>>"$log"); ` +
+		`rc=$?; ` +
+		`printf '[%s] state=${state} http=%s curl_exit=%s\\n' "$(date -Is 2>/dev/null || date)" "$http" "$rc" >> "$log" 2>/dev/null; ` +
+		// Keep the log bounded without a race window that could lose the file.
+		`t=$(tail -n 500 "$log" 2>/dev/null) && printf '%s\\n' "$t" > "$log" 2>/dev/null; ` +
+		`true`;
+	return [
+		{
+			hooks: [
+				{
+					type: 'command',
+					command
+				}
+			]
+		}
+	];
+}
+
+/** Carries no token — that lives in the mode-600 header file `writeBridgeHeader` stages. */
+export function attentionHookSettings(id: string): string {
+	const settings = {
+		hooks: {
+			Stop: hookFor(id, 'done'),
+			Notification: hookFor(id, 'waiting'),
+			UserPromptSubmit: hookFor(id, 'busy')
+		}
+	};
+	return JSON.stringify(settings, null, 2);
+}
+
+/** Stored as a whole header line so curl can consume the file directly with `-H @`. */
+async function writeBridgeHeader(
+	target: ContainerTarget,
+	token: string
+): Promise<{ ok: boolean; error?: string }> {
+	const script =
+		'h=$(eval echo ~$(id -un)); d="${CLAUDE_CONFIG_DIR:-$h/.claude}"; mkdir -p "$d"; ' +
+		'f="$d/.bridge-header"; printf \'X-Bridge-Token: %s\\n\' "$CODEBAY_STDIN" > "$f"; chmod 600 "$f"';
+	const res = await execInContainer(target, { script, stdin: token });
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+/** Merging rather than overwriting is what lets the settings.json injections compose in any order. */
+export function mergeClaudeSettingsScript(): string {
+	return (
+		'h=$(eval echo ~$(id -un)); d="${CLAUDE_CONFIG_DIR:-$h/.claude}"; mkdir -p "$d"; ' +
+		'f="$d/settings.json"; new="$CODEBAY_STDIN"; ' +
+		'if command -v jq >/dev/null 2>&1 && [ -s "$f" ] && ' +
+		'merged=$(printf \'%s\' "$new" | jq -s \'.[0] * .[1]\' "$f" - 2>/dev/null); then ' +
+		'printf \'%s\' "$merged" > "$f"; else printf \'%s\' "$new" > "$f"; fi; ' +
+		'chmod 644 "$f"'
+	);
+}
+
+async function injectClaudeHooks(
+	target: ContainerTarget,
+	settingsJson: string
+): Promise<{ ok: boolean; error?: string }> {
+	const res = await execInContainer(target, {
+		script: mergeClaudeSettingsScript(),
+		stdin: settingsJson
+	});
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+export const attentionHooks: Injection = {
+	id: 'attention-hooks',
+	label: 'Claude hooks',
+
+	async apply(target, log) {
+		log('Injecting Claude attention hooks…\n');
+		const header = await writeBridgeHeader(target, target.instance.bridge_token);
+		if (!header.ok) {
+			log(`⚠ Claude hook injection failed: ${header.error}\n`);
+			return;
+		}
+		const settings = attentionHookSettings(target.instance.id);
+		const hooks = await injectClaudeHooks(target, settings);
+		log(
+			hooks.ok
+				? '✓ Claude attention hooks installed\n'
+				: `⚠ Claude hook injection failed: ${hooks.error}\n`
+		);
+	},
+
+	async check(target) {
+		return checkPresence(
+			target,
+			'h=$(eval echo ~$(id -un)); d="${CLAUDE_CONFIG_DIR:-$h/.claude}"; ' +
+				'[ -s "$d/settings.json" ] && grep -q "$1" "$d/settings.json" && echo 1 || echo 0',
+			['attention-check', target.instance.id]
+		);
+	}
+};

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

@@ -0,0 +1,43 @@
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import type { Injection } from '../lib/injections.server.ts';
+
+/** Both resolve `claude`, which `claude-skip-permissions` also aliases, so the two compose. */
+const ALIAS_LINES = [
+	"alias c200='CLAUDE_CODE_DISABLE_1M_CONTEXT=1 claude'",
+	"alias cs='claude --model sonnet'"
+];
+
+/** Lines arrive as `$@` so no alias text is interpolated into the loop body. */
+const APPLY_SCRIPT =
+	'h=$(eval echo ~$(id -un)); ' +
+	'for line in "$@"; do ' +
+	'for f in "$h/.bashrc" "$h/.zshrc"; do ' +
+	'grep -qF "$line" "$f" 2>/dev/null || printf \'%s\\n\' "$line" >> "$f"; ' +
+	'done; ' +
+	'done';
+
+const CHECK_SCRIPT =
+	'h=$(eval echo ~$(id -un)); ' +
+	'for line in "$@"; do ' +
+	'grep -qF "$line" "$h/.bashrc" 2>/dev/null || grep -qF "$line" "$h/.zshrc" 2>/dev/null || ' +
+	'{ echo 0; exit 0; }; ' +
+	'done; ' +
+	'echo 1';
+
+export const claudeAliases: Injection = {
+	id: 'claude-aliases',
+	label: 'claude aliases',
+
+	async apply(target, log) {
+		log('Installing c200 / cs claude aliases…\n');
+		const res = await execInContainer(target, {
+			script: APPLY_SCRIPT,
+			args: ['claude-aliases', ...ALIAS_LINES]
+		});
+		log(res.ok ? '✓ claude aliases installed\n' : `⚠ claude aliases setup failed: ${res.error}\n`);
+	},
+
+	async check(target) {
+		return checkPresence(target, CHECK_SCRIPT, ['claude-aliases', ...ALIAS_LINES]);
+	}
+};

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

@@ -0,0 +1,145 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { CLAUDE_CODE_TOKEN, CLAUDE_KEYCHAIN_SERVICE } from '../lib/config.server.ts';
+import { getOption } from '../lib/db.server.ts';
+import { checkPresence, execInContainer, writeSecretFileScript } from '../lib/exec.server.ts';
+import { spawnCapture } from '../lib/spawn.server.ts';
+import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
+
+/** A blank field falls through to the env var, so a user can set just one provider. */
+function manualClaudeToken(): string | null {
+	if (getOption('manual_tokens_enabled') !== '1') return null;
+	return getOption('manual_claude_code_token')?.trim() || null;
+}
+
+/**
+ * `claude` reports "Not logged in" without these, however valid the access token —
+ * `scopes` is what flips it (checked against claude 2.1.215; `expiresAt` doesn't matter).
+ */
+const TOKEN_SCOPES = [
+	'user:file_upload',
+	'user:inference',
+	'user:mcp_servers',
+	'user:profile',
+	'user:sessions:claude_code'
+];
+
+export function tokenCredentials(accessToken: string): string {
+	return JSON.stringify({ claudeAiOauth: { accessToken, scopes: TOKEN_SCOPES } });
+}
+
+/**
+ * A stale access token is still worth injecting — `claude` refreshes it in-container —
+ * so expiry is judged by the refresh token whenever its expiry is known.
+ */
+export function isValid(json: string): boolean {
+	try {
+		const data = JSON.parse(json) as {
+			claudeAiOauth?: { accessToken?: string; expiresAt?: number; refreshTokenExpiresAt?: number };
+		};
+		const oauth = data.claudeAiOauth;
+		if (!oauth?.accessToken) return false;
+		const expiry = oauth.refreshTokenExpiresAt ?? oauth.expiresAt;
+		if (typeof expiry === 'number' && expiry <= Date.now()) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * `[ -s ]` isn't enough: on a rejected refresh `claude` blanks the tokens in place
+ * rather than deleting the file. Whitespace is stripped so compact and pretty JSON both match.
+ */
+export const LIVE_CREDENTIALS_TEST =
+	'[ -s "$f" ] && tr -d \'[:space:]\' < "$f" | grep -q \'"accessToken":"[^"]\'';
+
+/** macOS keeps these in the login Keychain; everything else uses ~/.claude/.credentials.json. */
+async function locateClaudeCredentials(): Promise<{ creds: string; source: string } | null> {
+	const manual = manualClaudeToken();
+	if (manual) {
+		return { creds: tokenCredentials(manual), source: 'Settings — manual token' };
+	}
+	if (CLAUDE_CODE_TOKEN) {
+		return {
+			creds: tokenCredentials(CLAUDE_CODE_TOKEN),
+			source: 'CODEBAY_CLAUDE_CODE_TOKEN env var'
+		};
+	}
+
+	if (process.platform === 'darwin') {
+		const out = await spawnCapture([
+			'security',
+			'find-generic-password',
+			'-s',
+			CLAUDE_KEYCHAIN_SERVICE,
+			'-w'
+		]);
+		if (out && isValid(out)) {
+			return { creds: out, source: `macOS Keychain — "${CLAUDE_KEYCHAIN_SERVICE}"` };
+		}
+	}
+
+	const file = join(homedir(), '.claude', '.credentials.json');
+	if (existsSync(file)) {
+		const raw = (await readFile(file, 'utf8')).trim();
+		if (isValid(raw)) return { creds: raw, source: '~/.claude/.credentials.json' };
+	}
+	return null;
+}
+
+/** `hasCompletedOnboarding` is what stops `claude` re-running its first-run setup wizard. */
+async function injectClaudeCredentials(
+	target: ContainerTarget,
+	creds: string
+): Promise<{ ok: boolean; error?: string }> {
+	const script =
+		'h=$(eval echo ~$(id -un)); d="${CLAUDE_CONFIG_DIR:-$h/.claude}"; ' +
+		writeSecretFileScript('$d', '.credentials.json', '600') +
+		' cfg="${CLAUDE_CONFIG_DIR:+$CLAUDE_CONFIG_DIR/.claude.json}"; cfg="${cfg:-$h/.claude.json}"; ' +
+		'printf \'%s\' \'{"hasCompletedOnboarding":true}\' > "$cfg"; chmod 644 "$cfg"';
+	const res = await execInContainer(target, { script, stdin: creds });
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+/**
+ * Caveat: refresh tokens rotate, so snapshotting a live login hands one lineage to two
+ * `claude` installs and whichever refreshes first logs the other out. Only `setup-token` fixes it.
+ */
+export const claudeCodeCredentials: Injection = {
+	id: 'claude-code-credentials',
+	label: 'Claude Code',
+
+	auth: {
+		hint: 'run `claude` and sign in',
+		async status() {
+			const found = await locateClaudeCredentials();
+			return { available: found !== null, source: found?.source ?? null };
+		}
+	},
+
+	async apply(target, log) {
+		const found = await locateClaudeCredentials();
+		if (!found) {
+			log('⚠ No Claude Code credentials found on host; skipped auth injection\n');
+			return;
+		}
+		log('Injecting Claude Code credentials…\n');
+		const injected = await injectClaudeCredentials(target, found.creds);
+		log(
+			injected.ok
+				? '✓ Claude Code authorized in container\n'
+				: `⚠ Claude auth injection failed: ${injected.error}\n`
+		);
+	},
+
+	async check(target) {
+		return checkPresence(
+			target,
+			'h=$(eval echo ~$(id -un)); d="${CLAUDE_CONFIG_DIR:-$h/.claude}"; f="$d/.credentials.json"; ' +
+				`if ${LIVE_CREDENTIALS_TEST}; then echo 1; else echo 0; fi`
+		);
+	}
+};

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

@@ -0,0 +1,125 @@
+import { getOption } from '../lib/db.server.ts';
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
+
+/** Mirrors the reference launcher script (claude-code.sh); each is overridable in Settings. */
+export const DEFAULT_OPUS_MODEL = 'eu.anthropic.claude-opus-4-8';
+export const DEFAULT_SONNET_MODEL = 'eu.anthropic.claude-sonnet-4-6';
+export const DEFAULT_HAIKU_MODEL = 'eu.anthropic.claude-haiku-4-5-20251001-v1:0';
+export const DEFAULT_SMALL_FAST_MODEL = 'eu.anthropic.claude-haiku-4-5-20251001-v1:0';
+export const DEFAULT_MODEL = 'opusplan';
+
+/** Null means "skip the injection" — disabled, or a blank base URL or token. */
+export function customEndpointConfig(): {
+	baseUrl: string;
+	token: string;
+	opusModel: string;
+	sonnetModel: string;
+	haikuModel: string;
+	smallFastModel: string;
+	defaultModel: string;
+} | null {
+	if (getOption('custom_endpoint_enabled') !== '1') return null;
+	const baseUrl = getOption('custom_endpoint_base_url')?.trim() || '';
+	const token = getOption('custom_endpoint_token')?.trim() || '';
+	if (!baseUrl || !token) return null;
+	return {
+		baseUrl,
+		token,
+		opusModel: getOption('custom_endpoint_opus_model')?.trim() || DEFAULT_OPUS_MODEL,
+		sonnetModel: getOption('custom_endpoint_sonnet_model')?.trim() || DEFAULT_SONNET_MODEL,
+		haikuModel: getOption('custom_endpoint_haiku_model')?.trim() || DEFAULT_HAIKU_MODEL,
+		smallFastModel:
+			getOption('custom_endpoint_small_fast_model')?.trim() || DEFAULT_SMALL_FAST_MODEL,
+		defaultModel: getOption('custom_endpoint_model')?.trim() || DEFAULT_MODEL
+	};
+}
+
+const ENV_FILE = '~/.codebay-claude-env';
+
+/**
+ * Non-secret values ride `args`, so nothing needs hand-quoting; only the token uses `stdin`.
+ * The file mixes secret and non-secret content, hence no `writeSecretFileScript`.
+ */
+async function injectCustomEndpoint(
+	target: ContainerTarget,
+	config: NonNullable<ReturnType<typeof customEndpointConfig>>
+): Promise<{ ok: boolean; error?: string }> {
+	const script =
+		'set -e; f=$(eval echo "' +
+		ENV_FILE +
+		'"); ' +
+		'{ ' +
+		"printf '%s\\n' " +
+		"'export DISABLE_AUTOUPDATER=1' " +
+		"'export CLAUDE_CODE_USE_BEDROCK=1' " +
+		"'export CLAUDE_CODE_SKIP_BEDROCK_AUTH=1'; " +
+		'printf \'export ANTHROPIC_BEDROCK_BASE_URL=%s\\n\' "$1"; ' +
+		'printf \'export ANTHROPIC_AUTH_TOKEN=%s\\n\' "$CODEBAY_STDIN"; ' +
+		'printf \'export ANTHROPIC_DEFAULT_OPUS_MODEL=%s\\n\' "$2"; ' +
+		'printf \'export ANTHROPIC_DEFAULT_SONNET_MODEL=%s\\n\' "$3"; ' +
+		'printf \'export ANTHROPIC_DEFAULT_HAIKU_MODEL=%s\\n\' "$4"; ' +
+		'printf \'export ANTHROPIC_SMALL_FAST_MODEL=%s\\n\' "$5"; ' +
+		'printf \'export ANTHROPIC_MODEL=%s\\n\' "$6"; ' +
+		'} > "$f"; chmod 600 "$f"; ' +
+		// The grep guard keeps a re-apply from stacking duplicate source lines.
+		'h=$(eval echo ~$(id -un)); src="[ -f \\"$f\\" ] && . \\"$f\\""; ' +
+		'for rc in "$h/.bashrc" "$h/.zshrc"; do ' +
+		'grep -qF "$src" "$rc" 2>/dev/null || printf \'%s\\n\' "$src" >> "$rc"; ' +
+		'done; ' +
+		// `hasCompletedOnboarding` is what suppresses `claude`'s first-run wizard.
+		'h=$(eval echo ~$(id -un)); ' +
+		'cfg="${CLAUDE_CONFIG_DIR:+$CLAUDE_CONFIG_DIR/.claude.json}"; cfg="${cfg:-$h/.claude.json}"; ' +
+		'printf \'%s\' \'{"hasCompletedOnboarding":true}\' > "$cfg"; chmod 644 "$cfg"';
+
+	const res = await execInContainer(target, {
+		script,
+		stdin: config.token,
+		args: [
+			'claude-custom',
+			config.baseUrl,
+			config.opusModel,
+			config.sonnetModel,
+			config.haikuModel,
+			config.smallFastModel,
+			config.defaultModel
+		]
+	});
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+/** Replaces `claude-code-credentials` in the registry when the custom-endpoint setting is on. */
+export const claudeCodeCustom: Injection = {
+	id: 'claude-code-custom',
+	label: 'LiteLLM + Bedrock',
+
+	auth: {
+		hint: 'set the LiteLLM URL + token in Settings',
+		async status() {
+			const config = customEndpointConfig();
+			return {
+				available: config !== null,
+				source: config ? config.baseUrl : null
+			};
+		}
+	},
+
+	async apply(target, log) {
+		const config = customEndpointConfig();
+		if (!config) {
+			log('⚠ LiteLLM + Bedrock not configured (base URL or token missing); skipped\n');
+			return;
+		}
+		log(`Injecting LiteLLM + Bedrock endpoint (${config.baseUrl})…\n`);
+		const result = await injectCustomEndpoint(target, config);
+		log(
+			result.ok
+				? '✓ LiteLLM + Bedrock endpoint configured in container\n'
+				: `⚠ LiteLLM + Bedrock injection failed: ${result.error}\n`
+		);
+	},
+
+	async check(target) {
+		return checkPresence(target, `f=$(eval echo "${ENV_FILE}"); [ -s "$f" ] && echo 1 || echo 0`);
+	}
+};

package/src/container-injections/claude-no-coauthor.ts

@@ -0,0 +1,35 @@
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import { mergeClaudeSettingsScript } from './attention-hooks.ts';
+import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
+
+async function injectNoCoauthor(target: ContainerTarget): Promise<{ ok: boolean; error?: string }> {
+	const res = await execInContainer(target, {
+		script: mergeClaudeSettingsScript(),
+		stdin: JSON.stringify({ includeCoAuthoredBy: false })
+	});
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+/** A Codebay-wide default rather than an opt-in setting, hence no `auth` block. */
+export const claudeNoCoauthor: Injection = {
+	id: 'claude-no-coauthor',
+	label: 'no co-author byline',
+
+	async apply(target, log) {
+		log('Disabling Claude co-author commit byline…\n');
+		const result = await injectNoCoauthor(target);
+		log(
+			result.ok
+				? '✓ Claude co-author byline disabled\n'
+				: `⚠ Claude co-author byline injection failed: ${result.error}\n`
+		);
+	},
+
+	async check(target) {
+		return checkPresence(
+			target,
+			'h=$(eval echo ~$(id -un)); d="${CLAUDE_CONFIG_DIR:-$h/.claude}"; ' +
+				'[ -s "$d/settings.json" ] && grep -q includeCoAuthoredBy "$d/settings.json" && echo 1 || echo 0'
+		);
+	}
+};

package/src/container-injections/claude-skip-permissions.ts

@@ -0,0 +1,38 @@
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import type { Injection } from '../lib/injections.server.ts';
+
+const ALIAS_LINE = "alias claude='claude --dangerously-skip-permissions'";
+
+/** Both rc files, since either shell may be the one code-server opens. */
+const APPLY_SCRIPT =
+	'h=$(eval echo ~$(id -un)); ' +
+	`line="${ALIAS_LINE}"; ` +
+	'for f in "$h/.bashrc" "$h/.zshrc"; do ' +
+	'grep -qF "$line" "$f" 2>/dev/null || printf \'%s\\n\' "$line" >> "$f"; ' +
+	'done';
+
+const CHECK_SCRIPT =
+	'h=$(eval echo ~$(id -un)); ' +
+	`line="${ALIAS_LINE}"; ` +
+	'if grep -qF "$line" "$h/.bashrc" 2>/dev/null || grep -qF "$line" "$h/.zshrc" 2>/dev/null; ' +
+	'then echo 1; else echo 0; fi';
+
+/** Safe here only because instances are throwaway, single-tenant sandboxes. */
+export const claudeSkipPermissions: Injection = {
+	id: 'claude-skip-permissions',
+	label: 'claude skip-permissions alias',
+
+	async apply(target, log) {
+		log('Installing claude --dangerously-skip-permissions alias…\n');
+		const res = await execInContainer(target, { script: APPLY_SCRIPT });
+		log(
+			res.ok
+				? '✓ claude skip-permissions alias installed\n'
+				: `⚠ claude alias setup failed: ${res.error}\n`
+		);
+	},
+
+	async check(target) {
+		return checkPresence(target, CHECK_SCRIPT);
+	}
+};

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

@@ -0,0 +1,109 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import { mergeClaudeSettingsScript } from './attention-hooks.ts';
+import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
+
+/** Left unexpanded — Claude Code invokes this long after the injection has finished. */
+const CONTAINER_SCRIPT_PATH = '${CLAUDE_CONFIG_DIR:-$HOME/.claude}/statusline.sh';
+
+interface StatusLineConfig {
+	statusLine: Record<string, unknown>;
+	/** Only set when `command` references a script file. */
+	script?: string;
+}
+
+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;
+	}
+}
+
+/** A heuristic: a statusLine command is either a script path or a package runner with no file. */
+export function extractScriptPath(command: string): string | null {
+	const token = command.split(/\s+/).find((t) => t.startsWith('/') && existsSync(t));
+	return token ?? null;
+}
+
+/** A referenced script is read and its command rewritten, since the host path won't exist inside. */
+export async function readStatusLineConfig(): Promise<StatusLineConfig | null> {
+	const settings = await readHostClaudeSettings();
+	const statusLine = settings?.statusLine as { type?: string; command?: string } | undefined;
+	if (!statusLine || statusLine.type !== 'command' || !statusLine.command) return null;
+
+	const hostPath = extractScriptPath(statusLine.command);
+	if (!hostPath) return { statusLine };
+
+	let script: string;
+	try {
+		script = await readFile(hostPath, 'utf8');
+	} catch {
+		return null;
+	}
+	const command = statusLine.command.replaceAll(hostPath, CONTAINER_SCRIPT_PATH);
+	return { statusLine: { ...statusLine, command }, script };
+}
+
+/** Two execs rather than one, because `execInContainer` carries a single `stdin` payload per call. */
+async function injectStatusLine(
+	target: ContainerTarget,
+	config: StatusLineConfig
+): Promise<{ ok: boolean; error?: string }> {
+	if (config.script) {
+		const writeScript =
+			'h=$(eval echo ~$(id -un)); d="${CLAUDE_CONFIG_DIR:-$h/.claude}"; mkdir -p "$d"; ' +
+			'printf \'%s\' "$CODEBAY_STDIN" > "$d/statusline.sh"; chmod 755 "$d/statusline.sh"';
+		const res = await execInContainer(target, { script: writeScript, stdin: config.script });
+		if (!res.ok) return { ok: false, error: res.error };
+	}
+	const res = await execInContainer(target, {
+		script: mergeClaudeSettingsScript(),
+		stdin: JSON.stringify({ statusLine: config.statusLine })
+	});
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+export const claudeStatusline: Injection = {
+	id: 'claude-statusline',
+	label: 'statusLine',
+
+	auth: {
+		hint: 'configure `statusLine` in ~/.claude/settings.json',
+		async status() {
+			const config = await readStatusLineConfig();
+			return {
+				available: config !== null,
+				source: config ? '~/.claude/settings.json' : null
+			};
+		}
+	},
+
+	async apply(target, log) {
+		const config = await readStatusLineConfig();
+		if (!config) {
+			log('⚠ No statusLine configured on host; skipped\n');
+			return;
+		}
+		log('Injecting Claude Code statusLine…\n');
+		const result = await injectStatusLine(target, config);
+		log(
+			result.ok
+				? '✓ statusLine installed in container\n'
+				: `⚠ statusLine injection failed: ${result.error}\n`
+		);
+	},
+
+	async check(target) {
+		return checkPresence(
+			target,
+			'h=$(eval echo ~$(id -un)); d="${CLAUDE_CONFIG_DIR:-$h/.claude}"; ' +
+				'[ -s "$d/settings.json" ] && grep -q statusLine "$d/settings.json" && echo 1 || echo 0'
+		);
+	}
+};

package/src/container-injections/git-identity.ts

@@ -0,0 +1,63 @@
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import { spawnCapture } from '../lib/spawn.server.ts';
+import type { Injection } from '../lib/injections.server.ts';
+
+interface GitIdentity {
+	name: string;
+	email: string;
+}
+
+function readGitConfig(key: string): Promise<string | null> {
+	return spawnCapture(['git', 'config', '--global', '--get', key]);
+}
+
+/** `--global` so this reads the host user's identity, not the manager checkout's override. */
+async function readGitIdentity(): Promise<GitIdentity | null> {
+	const [name, email] = await Promise.all([
+		readGitConfig('user.name'),
+		readGitConfig('user.email')
+	]);
+	return name && email ? { name, email } : null;
+}
+
+/** Without this, `git commit` in the container fails outright or commits as `root@<container>`. */
+export const gitIdentity: Injection = {
+	id: 'git-identity',
+	label: 'git identity',
+
+	auth: {
+		hint: 'run `git config --global user.name/.email`',
+		async status() {
+			const identity = await readGitIdentity();
+			return identity
+				? { available: true, source: `git config — ${identity.name}` }
+				: { available: false, source: null };
+		}
+	},
+
+	async apply(target, log) {
+		const identity = await readGitIdentity();
+		if (!identity) {
+			log('⚠ No global git identity found on host; skipped git identity injection\n');
+			return;
+		}
+		log('Injecting git identity…\n');
+		// Passed as args so a name with spaces or quotes needs no escaping.
+		const res = await execInContainer(target, {
+			script: 'git config --global user.name "$1"; git config --global user.email "$2"',
+			args: ['git-identity', identity.name, identity.email]
+		});
+		log(
+			res.ok
+				? `✓ git identity set to ${identity.name} <${identity.email}>\n`
+				: `⚠ git identity injection failed: ${res.error}\n`
+		);
+	},
+
+	async check(target) {
+		return checkPresence(
+			target,
+			'[ -n "$(git config --global user.name)" ] && [ -n "$(git config --global user.email)" ] && echo 1 || echo 0'
+		);
+	}
+};