codebay 0.0.1 → 0.2.1

package/src/container-injections/git-safe-directory.ts

@@ -0,0 +1,18 @@
+import { execInContainer } from '../lib/exec.server.ts';
+import type { Injection } from '../lib/injections.server.ts';
+
+/**
+ * The copied `.git` is owned by a different UID than the container user, so without this
+ * git aborts every command with "dubious ownership". `*` is safe in a single-tenant sandbox.
+ */
+export const gitSafeDirectory: Injection = {
+	id: 'git-safe-directory',
+	label: 'git safe.directory',
+
+	async apply(target, log) {
+		const res = await execInContainer(target, {
+			script: "git config --global --add safe.directory '*'"
+		});
+		if (!res.ok) log(`⚠ git safe.directory setup failed: ${res.error}\n`);
+	}
+};

package/src/container-injections/github-credentials.ts

@@ -0,0 +1,162 @@
+import { readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { GITHUB_TOKEN } from '../lib/config.server.ts';
+import { getOption } from '../lib/db.server.ts';
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import { spawnCapture } from '../lib/spawn.server.ts';
+import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
+
+/** The only host the Settings and env-var overrides apply to; Enterprise hosts come from `gh`. */
+const GH_HOST = 'github.com';
+
+/** A blank field falls through to the env var, so a user can set just one provider. */
+function manualGithubToken(): string | null {
+	if (getOption('manual_tokens_enabled') !== '1') return null;
+	return getOption('manual_github_token')?.trim() || null;
+}
+
+interface GhCredentials {
+	host: string;
+	token: string;
+	user?: string;
+	/** Defaults to https when unknown. */
+	gitProtocol?: string;
+}
+
+/** Falls back to `gh`, which transparently spans all its storage backends. */
+export async function readGhToken(
+	host: string = GH_HOST
+): Promise<{ token: string; source: string } | null> {
+	if (host === GH_HOST) {
+		const manual = manualGithubToken();
+		if (manual) return { token: manual, source: 'Settings — manual token' };
+		if (GITHUB_TOKEN) return { token: GITHUB_TOKEN, source: 'CODEBAY_GITHUB_TOKEN env var' };
+	}
+	const token = await spawnCapture(['gh', 'auth', 'token', '--hostname', host]);
+	return token ? { token, source: `GitHub CLI — ${host}` } : null;
+}
+
+export function parseGhHosts(raw: string): string[] {
+	return [...raw.matchAll(/^([A-Za-z0-9._-]+):$/gm)].map((m) => m[1]!);
+}
+
+export function ghHostBlock(raw: string, host: string): string | null {
+	const lines = raw.split('\n');
+	const start = lines.findIndex((l) => l === `${host}:`);
+	if (start === -1) return null;
+	const rest = lines.slice(start + 1);
+	const end = rest.findIndex((l) => /^\S/.test(l));
+	return rest.slice(0, end === -1 ? rest.length : end).join('\n');
+}
+
+async function readGhHostsFile(): Promise<string | null> {
+	const file = join(homedir(), '.config', 'gh', 'hosts.yml');
+	if (!existsSync(file)) return null;
+	try {
+		return await readFile(file, 'utf8');
+	} catch {
+		return null;
+	}
+}
+
+async function readGhHosts(): Promise<string[]> {
+	const raw = await readGhHostsFile();
+	if (!raw) return [];
+	// These keys get interpolated into a shell script, so only hostname-shaped ones may pass.
+	return parseGhHosts(raw).filter((h) => /^[A-Za-z0-9.-]+$/.test(h));
+}
+
+/** A line parse suffices instead of a YAML dependency, since the token isn't in this file. */
+async function readGhHostMeta(host: string): Promise<{ user?: string; gitProtocol?: string }> {
+	const raw = await readGhHostsFile();
+	if (!raw) return {};
+	const block = ghHostBlock(raw, host);
+	if (!block) return {};
+	const user = block.match(/^\s+user:\s*(\S+)/m)?.[1];
+	const gitProtocol = block.match(/^\s+git_protocol:\s*(\S+)/m)?.[1];
+	return { user, gitProtocol };
+}
+
+/** `github.com` is included unconditionally so the manual/env override works with no `gh` setup. */
+async function readAllGhCredentials(): Promise<GhCredentials[]> {
+	const configured = await readGhHosts();
+	const hosts = [...new Set([GH_HOST, ...configured])];
+	const creds = await Promise.all(
+		hosts.map(async (host): Promise<GhCredentials | null> => {
+			const found = await readGhToken(host);
+			if (!found) return null;
+			const meta = await readGhHostMeta(host);
+			return { host, token: found.token, ...meta };
+		})
+	);
+	return creds.filter((c): c is GhCredentials => c !== null);
+}
+
+/**
+ * Staging hosts.yml still authorizes `gh` if it's installed later. The whole file body
+ * rides the single `stdin` channel, because it may hold more than one host's token.
+ */
+async function injectGhCredentials(
+	target: ContainerTarget,
+	credsList: GhCredentials[]
+): Promise<{ ok: boolean; error?: string }> {
+	const body = credsList
+		.map(({ host, token, user, gitProtocol }) => {
+			const protocol = gitProtocol || 'https';
+			return (
+				`${host}:\n` +
+				`    oauth_token: ${token}\n` +
+				`    git_protocol: ${protocol}\n` +
+				(user ? `    user: ${user}\n` : '')
+			);
+		})
+		.join('');
+	const setupGit = credsList
+		.map(
+			({ host }) =>
+				`command -v gh >/dev/null 2>&1 && gh auth setup-git --hostname ${host} 2>/dev/null || true; `
+		)
+		.join('');
+	const script =
+		'set -e; d=~/.config/gh; mkdir -p "$d"; ' +
+		'printf \'%s\' "$CODEBAY_STDIN" > "$d/hosts.yml"; chmod 600 "$d/hosts.yml"; ' +
+		setupGit;
+	const res = await execInContainer(target, { script, stdin: body, args: ['gh-inject'] });
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+export const githubCredentials: Injection = {
+	id: 'github-credentials',
+	label: 'GitHub CLI',
+
+	auth: {
+		hint: 'run `gh auth login`',
+		async status() {
+			const credsList = await readAllGhCredentials();
+			return credsList.length
+				? { available: true, source: `GitHub CLI — ${credsList.map((c) => c.host).join(', ')}` }
+				: { available: false, source: null };
+		}
+	},
+
+	async apply(target, log) {
+		const credsList = await readAllGhCredentials();
+		if (!credsList.length) {
+			log('⚠ No GitHub CLI credentials found on host; skipped gh injection\n');
+			return;
+		}
+		log(`Injecting GitHub CLI credentials for ${credsList.map((c) => c.host).join(', ')}…\n`);
+		const injected = await injectGhCredentials(target, credsList);
+		log(
+			injected.ok
+				? '✓ GitHub CLI authorized in container\n'
+				: `⚠ gh auth injection failed: ${injected.error}\n`
+		);
+	},
+
+	async check(target) {
+		return checkPresence(target, '[ -s ~/.config/gh/hosts.yml ] && echo 1 || echo 0');
+	}
+};

package/src/container-injections/host-env-vars.ts

@@ -0,0 +1,108 @@
+import { getOption } from '../lib/db.server.ts';
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import type { ContainerTarget, Injection } from '../lib/injections.server.ts';
+
+const ENV_FILE = '~/.codebay-host-env';
+
+interface ResolvedVar {
+	name: string;
+	value: string;
+}
+
+/** Exported so `/settings` computes host presence from the same parse the injection uses. */
+export function parseHostEnvVarNames(raw: string | null): string[] {
+	try {
+		const parsed = JSON.parse(raw ?? '[]');
+		return Array.isArray(parsed) ? parsed.filter((n): n is string => typeof n === 'string') : [];
+	} catch {
+		return [];
+	}
+}
+
+/** Reports presence only — a value must never cross to the client. */
+export function hostEnvVarPresence(names: string[]): Record<string, boolean> {
+	return Object.fromEntries(
+		names.map((name) => [name, Bun.env[name] !== undefined && Bun.env[name] !== ''])
+	);
+}
+
+/** Null means "skip the injection"; `missing` lets `apply()` log names without logging values. */
+export function hostEnvVarsConfig(): {
+	names: string[];
+	resolved: ResolvedVar[];
+	missing: string[];
+} | null {
+	if (getOption('host_env_vars_enabled') !== '1') return null;
+	const names = parseHostEnvVarNames(getOption('host_env_var_names'));
+	if (!names.length) return null;
+	const resolved: ResolvedVar[] = [];
+	const missing: string[] = [];
+	for (const name of names) {
+		const value = Bun.env[name];
+		if (value !== undefined && value !== '') resolved.push({ name, value });
+		else missing.push(name);
+	}
+	if (!resolved.length) return null;
+	return { names, resolved, missing };
+}
+
+/** Values ride `stdin` as one payload, so they reach neither argv nor `docker inspect`. */
+async function injectHostEnvVars(
+	target: ContainerTarget,
+	resolved: ResolvedVar[]
+): Promise<{ ok: boolean; error?: string }> {
+	// Every interactive shell sources this file, so values must be single-quoted to stay literal.
+	const payload = resolved
+		.map(({ name, value }) => `export ${name}='${value.replaceAll("'", "'\\''")}'`)
+		.join('\n');
+	const script =
+		'set -e; f=$(eval echo "' +
+		ENV_FILE +
+		'"); ' +
+		'printf \'%s\\n\' "$CODEBAY_STDIN" > "$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,
+		stdin: payload,
+		args: ['host-env-vars']
+	});
+	return res.ok ? { ok: true } : { ok: false, error: res.error };
+}
+
+/**
+ * Only names are persisted — values are read fresh from this process's env at apply time.
+ * No `auth` block on purpose: this is opt-in, so it must not flag the required-auth chip.
+ */
+export const hostEnvVars: Injection = {
+	id: 'host-env-vars',
+	label: 'host env vars',
+
+	async apply(target, log) {
+		const config = hostEnvVarsConfig();
+		if (!config) {
+			log('⚠ Host env vars not configured (disabled or none resolve on host); skipped\n');
+			return;
+		}
+		log(
+			`Injecting ${config.resolved.length} host env var(s): ${config.resolved.map((r) => r.name).join(', ')}…\n`
+		);
+		if (config.missing.length) {
+			log(`⚠ Not set on host, skipped: ${config.missing.join(', ')}\n`);
+		}
+		const result = await injectHostEnvVars(target, config.resolved);
+		log(
+			result.ok
+				? '✓ host env vars injected\n'
+				: `⚠ host env vars 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/tmux.ts

@@ -0,0 +1,67 @@
+import { checkPresence, execInContainer } from '../lib/exec.server.ts';
+import type { Injection } from '../lib/injections.server.ts';
+
+/** apt-get is the real path (the default image is Debian); the rest cover project images. */
+export const INSTALL_SCRIPT =
+	'if command -v tmux >/dev/null 2>&1; then exit 0; fi; ' +
+	'export DEBIAN_FRONTEND=noninteractive; ' +
+	'if command -v apt-get >/dev/null 2>&1; then apt-get update -y >/dev/null && apt-get install -y --no-install-recommends tmux >/dev/null; ' +
+	'elif command -v apk >/dev/null 2>&1; then apk add --no-cache tmux >/dev/null; ' +
+	'elif command -v dnf >/dev/null 2>&1; then dnf install -y tmux >/dev/null; ' +
+	'elif command -v microdnf >/dev/null 2>&1; then microdnf install -y tmux >/dev/null; ' +
+	'elif command -v yum >/dev/null 2>&1; then yum install -y tmux >/dev/null; ' +
+	'else echo "no supported package manager (tried apt-get/apk/dnf/microdnf/yum)" >&2; exit 1; fi; ' +
+	'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.
+ */
+export const TMUX_CONF_LINES = [
+	'set -g mouse on',
+	'set -g history-limit 50000',
+	'set -g set-clipboard on',
+	'set -g allow-passthrough on',
+	'set -g status off',
+	'bind m set -g mouse \\; display-message "mouse: #{?mouse,on,off}"'
+];
+
+/** Lines arrive as `$@` so no conf text is interpolated into the loop body. */
+const CONF_SCRIPT =
+	'h=$(eval echo ~$(id -un)); f="$h/.tmux.conf"; ' +
+	'for line in "$@"; do ' +
+	'grep -qF "$line" "$f" 2>/dev/null || printf \'%s\\n\' "$line" >> "$f"; ' +
+	'done';
+
+const CHECK_SCRIPT = 'command -v tmux >/dev/null 2>&1 && echo 1 || echo 0';
+
+/**
+ * The runtime fallback to the build-time `codebay-tmux` feature, which is the primary
+ * install; failure is non-fatal because the terminal task guards on `command -v tmux`.
+ */
+export const tmux: Injection = {
+	id: 'tmux',
+	label: 'tmux',
+
+	async apply(target, log) {
+		log('Installing tmux…\n');
+		// Omitting remoteUser runs as root, which the package install needs.
+		const install = await execInContainer(
+			{ containerId: target.containerId },
+			{ script: INSTALL_SCRIPT }
+		);
+		if (!install.ok) {
+			log(`⚠ tmux install failed: ${install.error} — terminal falls back to non-persistent mode\n`);
+			return;
+		}
+		const conf = await execInContainer(target, {
+			script: CONF_SCRIPT,
+			args: ['tmux-conf', ...TMUX_CONF_LINES]
+		});
+		log(conf.ok ? '✓ tmux installed\n' : `⚠ tmux conf setup failed: ${conf.error}\n`);
+	},
+
+	async check(target) {
+		return checkPresence(target, CHECK_SCRIPT);
+	}
+};

package/src/fontsource.d.ts

@@ -0,0 +1,3 @@
+// Side-effect CSS imports from @fontsource packages have no type declarations.
+declare module '@fontsource-variable/*';
+declare module '@fontsource/*';

package/src/index.ts

@@ -0,0 +1,81 @@
+import { Mochi, sequence, silenceInternalRoutes } from 'mochi-framework';
+import { routes } from './routes.ts';
+import { basicAuth } from './lib/auth.server.ts';
+import { themeHandle } from './lib/theme.server.ts';
+import { PROXY_PREFIX } from './lib/proxy.server.ts';
+import {
+	BASIC_AUTH_PASSWORD,
+	HOST,
+	PORT,
+	PUBLIC_ORIGIN,
+	TRUSTED_ORIGINS,
+	ensureMochiKey
+} from './lib/config.server.ts';
+
+if (!BASIC_AUTH_PASSWORD) {
+	console.warn('⚠ BASIC_AUTH_PASSWORD is not set — the UI and all instances are unprotected.');
+}
+if (HOST !== '127.0.0.1' && HOST !== 'localhost' && !BASIC_AUTH_PASSWORD) {
+	console.warn(
+		`⚠ Binding to ${HOST} (non-loopback) without a password — anyone on the network can reach this server.`
+	);
+}
+
+// Must precede Mochi.serve(), which is where MOCHI_KEY is read.
+ensureMochiKey();
+
+await Mochi.serve({
+	port: PORT,
+	hostname: HOST,
+	development: process.env.MODE === 'development',
+	htmlShell: './src/shell.html',
+	handle: sequence(basicAuth, themeHandle),
+	// Without a pinned origin, Mochi's CSRF check refuses every form POST in production.
+	proxy: {
+		origin: PUBLIC_ORIGIN
+	},
+	csrf: {
+		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,
+		'consoleLogger:line': (line, ctx) => {
+			const kept = silenceInternalRoutes(line, ctx);
+			if (kept == null) {
+				return null;
+			}
+			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/')) {
+				return null;
+			}
+			return kept;
+		},
+		// Dormant while trailingSlash is off, but keeps code-server's subpath safe if it returns.
+		'trailingSlash:redirect': (computed, { url }) =>
+			url.pathname.startsWith(PROXY_PREFIX + '/') ? null : computed
+	},
+	routes
+});
+
+const url = 'http://localhost:' + PORT;
+console.log(`Server running at ${url} (bound to ${HOST})`);
+
+if (process.env.DISABLE_OPEN_BROWSER !== '1') {
+	const openCmd =
+		process.platform === 'darwin'
+			? ['open', url]
+			: process.platform === 'win32'
+				? ['cmd', '/c', 'start', '', url]
+				: ['xdg-open', url];
+	try {
+		Bun.spawn(openCmd, { stdout: 'ignore', stderr: 'ignore' });
+	} catch {
+		// Best-effort — a headless host has nothing to open.
+	}
+}

package/src/lib/auth.server.ts

@@ -0,0 +1,95 @@
+import type { Handle } from 'mochi-framework';
+import { BASIC_AUTH_PASSWORD, BASIC_AUTH_USERNAME } from './config.server.ts';
+import { timingSafeEqualStr } from './crypto.server.ts';
+
+const REALM = 'Codebay';
+
+const MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
+
+/**
+ * A cross-origin page can't set this without a CORS preflight this server never answers.
+ * Basic Auth alone wouldn't stop CSRF — browsers auto-attach cached credentials.
+ */
+const CSRF_HEADER = 'x-codebay-request';
+
+function challenge(): Response {
+	return new Response('Authentication required', {
+		status: 401,
+		headers: { 'WWW-Authenticate': `Basic realm="${REALM}", charset="UTF-8"` }
+	});
+}
+
+function csrfRejected(): Response {
+	return new Response('Forbidden', { status: 403 });
+}
+
+/**
+ * WS handshakes are GETs that slip past the CSRF check, and browsers attach cached
+ * credentials cross-origin without a preflight. A missing Origin means a non-browser client.
+ */
+function wsOriginOk(request: Request): boolean {
+	const origin = request.headers.get('origin');
+	if (origin == null) return true;
+	try {
+		return new URL(origin).host === request.headers.get('host');
+	} catch {
+		return false;
+	}
+}
+
+/** `Mochi.ws` routes are dispatched by Bun directly and never reach `basicAuth`. */
+export function wsUpgradeAllowed(request: Request): boolean {
+	if (!wsOriginOk(request)) return false;
+	if (!BASIC_AUTH_PASSWORD) return true;
+	return credentialsOk(request.headers.get('Authorization'));
+}
+
+function credentialsOk(header: string | null): boolean {
+	if (!header?.startsWith('Basic ')) return false;
+	let decoded: string;
+	try {
+		decoded = atob(header.slice(6).trim());
+	} catch {
+		return false;
+	}
+	const sep = decoded.indexOf(':');
+	if (sep === -1) return false;
+	const user = decoded.slice(0, sep);
+	const pass = decoded.slice(sep + 1);
+	// Both halves must always run — an `&&` short-circuit would leak which one failed by timing.
+	const userOk = timingSafeEqualStr(user, BASIC_AUTH_USERNAME);
+	const passOk = timingSafeEqualStr(pass, BASIC_AUTH_PASSWORD);
+	return userOk && passOk;
+}
+
+/**
+ * The CSRF guard runs even with no password set: on an unauthenticated localhost
+ * server it's the only thing between a malicious page and the destructive endpoints.
+ */
+export const basicAuth: Handle = async ({ event, resolve }) => {
+	const path = new URL(event.request.url).pathname;
+
+	// Containers can carry neither the app password nor the CSRF header; the route checks a token.
+	if (path.startsWith('/api/bridge/')) return resolve(event);
+
+	// Covers the `/p/:id/*` proxy relay only; `Mochi.ws` routes call `wsUpgradeAllowed` themselves.
+	if (
+		event.request.headers.get('upgrade')?.toLowerCase() === 'websocket' &&
+		!wsOriginOk(event.request)
+	) {
+		return csrfRejected();
+	}
+
+	// Scoped to /api/ so it never touches the request shapes code-server itself generates.
+	if (
+		path.startsWith('/api/') &&
+		MUTATING_METHODS.has(event.request.method) &&
+		event.request.headers.get(CSRF_HEADER) == null
+	) {
+		return csrfRejected();
+	}
+
+	if (!BASIC_AUTH_PASSWORD) return resolve(event);
+	if (credentialsOk(event.request.headers.get('Authorization'))) return resolve(event);
+	return challenge();
+};

package/src/lib/bridge.server.ts

@@ -0,0 +1,34 @@
+import { triggerReconcile } from './instances.server.ts';
+
+/** UI-only state: it drives a tab pulse and is never persisted. */
+export type AttentionState = 'done' | 'waiting';
+
+// Pin to globalThis so dev-mode hot reload doesn't drop pending signals.
+const globalForAttention = globalThis as unknown as {
+	__codebayAttention?: Map<string, AttentionState>;
+};
+const attention: Map<string, AttentionState> = (globalForAttention.__codebayAttention ??=
+	new Map());
+
+export function getAttention(id: string): AttentionState | null {
+	return attention.get(id) ?? null;
+}
+
+export function setAttention(id: string, state: AttentionState): void {
+	if (attention.get(id) === state) {
+		console.log(`[attention] setAttention id=${id} state=${state} — no change, skipping reconcile`);
+		return;
+	}
+	attention.set(id, state);
+	console.log(`[attention] setAttention id=${id} state=${state} → reconcile`);
+	triggerReconcile();
+}
+
+export function clearAttention(id: string): void {
+	if (!attention.delete(id)) {
+		console.log(`[attention] clearAttention id=${id} — nothing set, skipping reconcile`);
+		return;
+	}
+	console.log(`[attention] clearAttention id=${id} → reconcile`);
+	triggerReconcile();
+}