codebay 0.3.0 → 0.5.0

package/src/components/TopBar.svelte

@@ -3,6 +3,7 @@
 	import Component from '@lucide/svelte/icons/component';
 	import { isDev } from 'mochi-framework';
 	import type { AuthProvider } from '../types.ts';
+	import type { AvatarArt } from '../avatars/index.ts';
 	import Brand from './Brand.svelte';
 	import SettingsCog from './SettingsCog.svelte';
 	import CredMenu from './CredMenu.svelte';
@@ -11,6 +12,7 @@
 	// Action state is injected so the bar stays presentational and reusable on /debug.
 	let {
 		auth,
+		pet,
 		canDelete = false,
 		ready = true,
 		creating = false,
@@ -18,6 +20,7 @@
 		onDeleteAll
 	}: {
 		auth: AuthProvider[];
+		pet?: AvatarArt;
 		canDelete?: boolean;
 		ready?: boolean;
 		creating?: boolean;
@@ -27,7 +30,7 @@
 </script>
 
 <header class="topbar">
-	<Brand />
+	<Brand {pet} />
 	<div class="topbar-actions">
 		{#if isDev}
 			<Button variant="default" size="sm" icon={Component} href="/debug">Debug</Button>

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

@@ -0,0 +1,74 @@
+import { getOption } from '../lib/db.server.ts';
+import { execInContainer } from '../lib/exec.server.ts';
+import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
+
+/** The option key → Claude env var mapping; order is the field order in Settings. */
+const MODEL_ENV: Array<[key: string, env: string]> = [
+	['manual_opus_model', 'ANTHROPIC_DEFAULT_OPUS_MODEL'],
+	['manual_sonnet_model', 'ANTHROPIC_DEFAULT_SONNET_MODEL'],
+	['manual_haiku_model', 'ANTHROPIC_DEFAULT_HAIKU_MODEL'],
+	['manual_small_fast_model', 'ANTHROPIC_SMALL_FAST_MODEL'],
+	['manual_model', 'ANTHROPIC_MODEL']
+];
+
+/**
+ * Only for the standard (subscription) path — null when disabled, when LiteLLM
+ * owns the models instead, or when no field is filled (nothing to export).
+ */
+export function manualModelConfig(): Record<string, string> | null {
+	if (getOption('manual_model_override_enabled') !== '1') return null;
+	if (getOption('custom_endpoint_enabled') === '1') return null;
+	const filled: Record<string, string> = {};
+	for (const [key, env] of MODEL_ENV) {
+		const value = getOption(key)?.trim();
+		if (value) filled[env] = value;
+	}
+	return Object.keys(filled).length ? filled : null;
+}
+
+const ENV_FILE = '~/.codebay-claude-models-env';
+
+/** Model IDs are non-secret, so every value rides `args` ($1, $2, …) — no stdin. */
+async function injectModels(
+	target: ContainerTarget,
+	config: Record<string, string>
+): Promise<{ ok: boolean; error?: string }> {
+	const entries = Object.entries(config);
+	const writes = entries.map(([env], i) => `printf 'export ${env}=%s\\n' "$${i + 1}"; `).join('');
+	const script =
+		'set -e; f=$(eval echo "' +
+		ENV_FILE +
+		'"); ' +
+		'{ ' +
+		writes +
+		'} > "$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';
+
+	const res = await execInContainer(target, {
+		script,
+		args: ['claude-models', ...entries.map(([, value]) => value)]
+	});
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+/** Sets Claude model env vars on the standard path; skipped when LiteLLM is active. */
+export const claudeCodeModels: Injection = {
+	id: 'claude-code-models',
+	label: 'Model override',
+
+	async apply(target, log) {
+		const config = manualModelConfig();
+		if (!config) return;
+		log(`Injecting Claude model override (${Object.keys(config).join(', ')})…\n`);
+		const result = await injectModels(target, config);
+		log(
+			result.ok
+				? '✓ Claude model override configured in container\n'
+				: `⚠ Claude model override injection failed: ${result.error}\n`
+		);
+	}
+};

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

@@ -0,0 +1,66 @@
+import { getOption } from '../lib/db.server.ts';
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import { mergeClaudeSettingsScript } from './attention-hooks.ts';
+import { readHostClaudeSettings } from './claude-statusline.ts';
+import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
+
+/** The app's own model config (manual override / LiteLLM) exports ANTHROPIC_MODEL, which wins over settings.json. */
+function appOwnsModel(): boolean {
+	return (
+		getOption('manual_model_override_enabled') === '1' ||
+		getOption('custom_endpoint_enabled') === '1'
+	);
+}
+
+/** The `model` default from host ~/.claude/settings.json, or null when unset or app-owned. */
+export async function hostClaudeModel(): Promise<string | null> {
+	if (appOwnsModel()) return null;
+	const settings = await readHostClaudeSettings();
+	const model = settings?.model;
+	return typeof model === 'string' && model.trim() ? model.trim() : null;
+}
+
+async function injectModel(
+	target: ContainerTarget,
+	model: string
+): Promise<{ ok: boolean; error?: string }> {
+	const res = await execInContainer(target, {
+		script: mergeClaudeSettingsScript(),
+		stdin: JSON.stringify({ model })
+	});
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+/** Mirrors the host's default `model` into the container so subscription instances match the host. */
+export const claudeModel: Injection = {
+	id: 'claude-model',
+	label: 'model default',
+
+	auth: {
+		hint: 'set `model` in ~/.claude/settings.json',
+		async status() {
+			const model = await hostClaudeModel();
+			return { available: model !== null, source: model ? '~/.claude/settings.json' : null };
+		}
+	},
+
+	async apply(target, log) {
+		const model = await hostClaudeModel();
+		if (!model) return;
+		log(`Injecting Claude model default (${model})…\n`);
+		const result = await injectModel(target, model);
+		log(
+			result.ok
+				? '✓ Claude model default configured in container\n'
+				: `⚠ Claude model default 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 \'"model"\' "$d/settings.json" && echo 1 || echo 0'
+		);
+	}
+};

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

@@ -2,10 +2,20 @@ import { checkPresence, execInContainer } from '../lib/exec.server.ts';
 import { mergeClaudeSettingsScript } from './attention-hooks.ts';
 import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
 
+/**
+ * Both schemas on purpose: newer `claude` reads the nested `attribution` object, older builds
+ * the root-level `includeCoAuthoredBy` — setting both suppresses the byline across versions.
+ * Empty `commit`/`pr` strings drop the commit trailer and PR footer.
+ */
+export const NO_COAUTHOR_SETTINGS = {
+	includeCoAuthoredBy: false,
+	attribution: { commit: '', pr: '', includeCoAuthoredBy: false }
+};
+
 async function injectNoCoauthor(target: ContainerTarget): Promise<{ ok: boolean; error?: string }> {
 	const res = await execInContainer(target, {
 		script: mergeClaudeSettingsScript(),
-		stdin: JSON.stringify({ includeCoAuthoredBy: false })
+		stdin: JSON.stringify(NO_COAUTHOR_SETTINGS)
 	});
 	return res.ok ? { ok: true } : { ok: false, error: res.error };
 }

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

@@ -1,4 +1,4 @@
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
@@ -15,7 +15,7 @@ interface StatusLineConfig {
 	script?: string;
 }
 
-async function readHostClaudeSettings(): Promise<Record<string, unknown> | null> {
+export async function readHostClaudeSettings(): Promise<Record<string, unknown> | null> {
 	const file = join(homedir(), '.claude', 'settings.json');
 	if (!existsSync(file)) return null;
 	try {
@@ -25,9 +25,23 @@ async function readHostClaudeSettings(): Promise<Record<string, unknown> | null>
 	}
 }
 
-/** A heuristic: a statusLine command is either a script path or a package runner with no file. */
+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 {
+		return statSync(p).isFile();
+	} catch {
+		return false;
+	}
+};
+
+/** A heuristic: a statusLine command is either a script path or an inline snippet with no file. */
 export function extractScriptPath(command: string): string | null {
-	const token = command.split(/\s+/).find((t) => t.startsWith('/') && existsSync(t));
+	const token = command
+		.split(/\s+/)
+		.find((t) => (t.startsWith('/') || t.startsWith('~/')) && isExistingFile(expandTilde(t)));
 	return token ?? null;
 }
 
@@ -37,16 +51,17 @@ export async function readStatusLineConfig(): Promise<StatusLineConfig | null> {
 	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 };
+	const token = extractScriptPath(statusLine.command);
+	if (!token) return { statusLine };
 
 	let script: string;
 	try {
-		script = await readFile(hostPath, 'utf8');
+		script = await readFile(expandTilde(token), 'utf8');
 	} catch {
-		return null;
+		// A false-positive match must not disable the feature — inject the command verbatim.
+		return { statusLine };
 	}
-	const command = statusLine.command.replaceAll(hostPath, CONTAINER_SCRIPT_PATH);
+	const command = statusLine.command.replaceAll(token, CONTAINER_SCRIPT_PATH);
 	return { statusLine: { ...statusLine, command }, script };
 }
 

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

@@ -1,5 +1,6 @@
 import { checkPresence, execInContainer } from '../lib/exec.server.ts';
 import { spawnCapture } from '../lib/spawn.server.ts';
+import { getOption } from '../lib/db.server.ts';
 import type { Injection } from '../lib/injections.server.ts';
 
 interface GitIdentity {
@@ -11,8 +12,29 @@ 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> {
+/**
+ * The toggle is the source of truth, but predates the option: an unset value falls
+ * back to "on when both fields are already filled" so existing overrides keep working.
+ */
+export function gitIdentityEnabled(): boolean {
+	const explicit = getOption('git_identity_enabled');
+	if (explicit === '1') return true;
+	if (explicit === '0') return false;
+	return !!(getOption('git_identity_name')?.trim() && getOption('git_identity_email')?.trim());
+}
+
+/** Both fields are required together — a lone name or email is treated as not configured. */
+function overrideIdentity(): GitIdentity | null {
+	if (!gitIdentityEnabled()) return null;
+	const name = getOption('git_identity_name')?.trim() || '';
+	const email = getOption('git_identity_email')?.trim() || '';
+	return name && email ? { name, email } : null;
+}
+
+/** `--global` so the host fallback reads the host user's identity, not the manager checkout's. */
+export async function readGitIdentity(): Promise<GitIdentity | null> {
+	const override = overrideIdentity();
+	if (override) return override;
 	const [name, email] = await Promise.all([
 		readGitConfig('user.name'),
 		readGitConfig('user.email')
@@ -30,7 +52,12 @@ export const gitIdentity: Injection = {
 		async status() {
 			const identity = await readGitIdentity();
 			return identity
-				? { available: true, source: `git config — ${identity.name}` }
+				? {
+						available: true,
+						source: overrideIdentity()
+							? `Settings override — ${identity.name}`
+							: `git config — ${identity.name}`
+					}
 				: { available: false, source: null };
 		}
 	},

package/src/lib/injections.server.ts

@@ -6,9 +6,11 @@ import { tmux } from '../container-injections/tmux.ts';
 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 { claudeCodeModels } from '../container-injections/claude-code-models.ts';
 import { githubCredentials } from '../container-injections/github-credentials.ts';
 import { attentionHooks } from '../container-injections/attention-hooks.ts';
 import { claudeStatusline } from '../container-injections/claude-statusline.ts';
+import { claudeModel } from '../container-injections/claude-model.ts';
 import { claudeSkipPermissions } from '../container-injections/claude-skip-permissions.ts';
 import { claudeAliases } from '../container-injections/claude-aliases.ts';
 import { claudeNoCoauthor } from '../container-injections/claude-no-coauthor.ts';
@@ -48,9 +50,12 @@ const BASE_INJECTIONS_HEAD: Injection[] = [
 ];
 
 const BASE_INJECTIONS_TAIL: Injection[] = [
+	// Self-skips unless manual override is on and LiteLLM off, so it's safe in the always-run tail.
+	claudeCodeModels,
 	githubCredentials,
 	attentionHooks,
 	claudeStatusline,
+	claudeModel,
 	claudeSkipPermissions,
 	claudeAliases,
 	claudeNoCoauthor,

package/src/lib/instances.server.ts

@@ -104,7 +104,9 @@ export function subscribeLogs(id: string, onChunk: (chunk: string) => void): ()
 export type StreamEvent =
 	| { type: 'instances'; data: Instance[] }
 	| { type: 'health'; data: { id: string; health: InstanceHealth } }
-	| { type: 'preflight'; data: { docker: boolean; cli: boolean } };
+	| { type: 'preflight'; data: { docker: boolean; cli: boolean } }
+	// `name` is the chosen sprite, or null for the default box logo. Lets the header swap live.
+	| { type: 'pet'; data: { name: string | null } };
 
 interface StreamHub {
 	sockets: Set<ServerWebSocket<unknown>>;
@@ -150,6 +152,11 @@ export function broadcastHealth(id: string, health: InstanceHealth): void {
 	broadcast({ type: 'health', data: { id, health } });
 }
 
+/** Called from the settings action so every open dashboard swaps its header logo without a reload. */
+export function broadcastPet(name: string | null): void {
+	broadcast({ type: 'pet', data: { name } });
+}
+
 async function reconcileInstances(force = false): Promise<void> {
 	const list = await listInstances();
 	const listJson = JSON.stringify(list);
@@ -189,6 +196,8 @@ export function streamOpen(ws: ServerWebSocket<unknown>): void {
 	void listInstances().then((list) => sendTo(ws, { type: 'instances', data: list }));
 	for (const snap of currentHealthSnapshots()) sendTo(ws, { type: 'health', data: snap });
 	void backgroundPreflight().then((pf) => sendTo(ws, { type: 'preflight', data: pf }));
+	// Keeps a reconnecting client correct even if the pet changed while it was away.
+	sendTo(ws, { type: 'pet', data: { name: getOption('pet') || null } });
 }
 
 export function streamClose(ws: ServerWebSocket<unknown>): void {

package/src/lib/popup-nav.ts

@@ -0,0 +1,37 @@
+const POPUP_PARAM = 'popup';
+
+/** Assumes `href` has no existing query string. */
+export function withPopupMarker(href: string): string {
+	return `${href}?${POPUP_PARAM}=1`;
+}
+
+export function isPopupPage(): boolean {
+	return new URLSearchParams(location.search).has(POPUP_PARAM);
+}
+
+function closeOrGoHome() {
+	window.close();
+	// Runs only if close() was refused (tab wasn't opened by script) — window.close()
+	// tears the page down near-instantly when it succeeds, so this never fires then.
+	setTimeout(() => {
+		location.href = '/';
+	}, 100);
+}
+
+export function onBackLinkClick(e: MouseEvent) {
+	if (e.defaultPrevented || e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey)
+		return;
+	if (!isPopupPage()) return;
+	e.preventDefault();
+	closeOrGoHome();
+}
+
+export function installPopupBackTrap(): () => void {
+	if (!isPopupPage()) return () => {};
+	// A fresh popup tab has one history entry, so back is otherwise a no-op the
+	// browser just disables — push a duplicate so the first back press fires popstate.
+	history.pushState({}, '', location.href);
+	const onPop = () => closeOrGoHome();
+	window.addEventListener('popstate', onPop);
+	return () => window.removeEventListener('popstate', onPop);
+}

package/src/pages/App.svelte

@@ -3,12 +3,19 @@
 	import '@fontsource-variable/jetbrains-mono';
 	import AppShell from '../components/AppShell.svelte';
 	import type { Instance, Preflight } from '../types.ts';
+	import type { AvatarArt } from '../avatars/index.ts';
 
 	let {
 		preflight,
 		initialPath,
-		snapshot
-	}: { preflight: Preflight; initialPath: string; snapshot: Instance[] } = $props();
+		snapshot,
+		pet
+	}: {
+		preflight: Preflight;
+		initialPath: string;
+		snapshot: Instance[];
+		pet?: AvatarArt;
+	} = $props();
 </script>
 
-<AppShell {preflight} {initialPath} {snapshot} mochi:hydrate />
+<AppShell {preflight} {initialPath} {snapshot} {pet} mochi:hydrate />

package/src/pages/Settings.svelte

@@ -2,13 +2,18 @@
 	import '@fontsource-variable/doto';
 	import '@fontsource-variable/jetbrains-mono';
 	import SettingsView from '../components/SettingsView.svelte';
+	import type { AvatarArt } from '../avatars/index.ts';
 
 	let {
+		pet,
 		defaultImage,
 		builtinImage,
 		disableBuildCache,
 		copyIgnorePatterns,
 		builtinCopyIgnore,
+		gitIdentityEnabled,
+		gitIdentityName,
+		gitIdentityEmail,
 		dockerArch,
 		manualTokensEnabled,
 		githubTokenSet,
@@ -21,16 +26,26 @@
 		customEndpointHaikuModel,
 		customEndpointSmallFastModel,
 		customEndpointModel,
+		manualModelOverrideEnabled,
+		manualOpusModel,
+		manualSonnetModel,
+		manualHaikuModel,
+		manualSmallFastModel,
+		manualModel,
 		hostEnvVarsEnabled,
 		hostEnvVarNames,
 		hostEnvVarPresence,
 		version
 	}: {
+		pet?: AvatarArt;
 		defaultImage: string;
 		builtinImage: string;
 		disableBuildCache: boolean;
 		copyIgnorePatterns: string;
 		builtinCopyIgnore: string;
+		gitIdentityEnabled: boolean;
+		gitIdentityName: string;
+		gitIdentityEmail: string;
 		dockerArch: string | null;
 		manualTokensEnabled: boolean;
 		githubTokenSet: boolean;
@@ -43,6 +58,12 @@
 		customEndpointHaikuModel: string;
 		customEndpointSmallFastModel: string;
 		customEndpointModel: string;
+		manualModelOverrideEnabled: boolean;
+		manualOpusModel: string;
+		manualSonnetModel: string;
+		manualHaikuModel: string;
+		manualSmallFastModel: string;
+		manualModel: string;
 		hostEnvVarsEnabled: boolean;
 		hostEnvVarNames: string[];
 		hostEnvVarPresence: Record<string, boolean>;
@@ -51,11 +72,15 @@
 </script>
 
 <SettingsView
+	{pet}
 	{defaultImage}
 	{builtinImage}
 	{disableBuildCache}
 	{copyIgnorePatterns}
 	{builtinCopyIgnore}
+	{gitIdentityEnabled}
+	{gitIdentityName}
+	{gitIdentityEmail}
 	{dockerArch}
 	{manualTokensEnabled}
 	{githubTokenSet}
@@ -68,6 +93,12 @@
 	{customEndpointHaikuModel}
 	{customEndpointSmallFastModel}
 	{customEndpointModel}
+	{manualModelOverrideEnabled}
+	{manualOpusModel}
+	{manualSonnetModel}
+	{manualHaikuModel}
+	{manualSmallFastModel}
+	{manualModel}
 	{hostEnvVarsEnabled}
 	{hostEnvVarNames}
 	{hostEnvVarPresence}