codebay 0.0.1 → 0.2.1

package/src/lib/docker.server.ts

@@ -0,0 +1,139 @@
+import { getDocker, resetDocker } from './docker-client.server.ts';
+
+function statusOf(err: unknown): number | undefined {
+	return (err as { statusCode?: number })?.statusCode;
+}
+
+export async function dockerAvailable(): Promise<boolean> {
+	try {
+		await (await getDocker()).ping();
+		return true;
+	} catch {
+		// Re-resolve on the next probe, in case the daemon moved or switched context.
+		resetDocker();
+		return false;
+	}
+}
+
+/** The daemon's arch, not the host's — images are pulled for the daemon, which may be a VM. */
+export async function dockerArch(): Promise<string | null> {
+	try {
+		const arch = (await (await getDocker()).version()).Arch;
+		return arch || null;
+	} catch {
+		return null;
+	}
+}
+
+export async function isRunning(containerId: string): Promise<boolean> {
+	try {
+		const info = await (await getDocker()).getContainer(containerId).inspect();
+		return info.State?.Running === true;
+	} catch {
+		return false; // missing container (404) or daemon unreachable
+	}
+}
+
+/** Reads Docker's live binding table, so it reflects what's actually exposed. */
+export async function publishedContainerPorts(containerId: string): Promise<number[]> {
+	let ports: Record<string, { HostPort?: string }[] | null>;
+	try {
+		const info = await (await getDocker()).getContainer(containerId).inspect();
+		ports = (info.NetworkSettings?.Ports ?? {}) as Record<string, { HostPort?: string }[] | null>;
+	} catch {
+		return [];
+	}
+	const open = new Set<number>();
+	for (const [key, bindings] of Object.entries(ports)) {
+		if (!bindings || bindings.length === 0) continue; // exposed but not published
+		const port = Number.parseInt(key, 10); // "3000/tcp" → 3000
+		if (Number.isInteger(port) && port > 0) open.add(port);
+	}
+	return [...open];
+}
+
+/**
+ * Covers containers codebay has no DB row for, which would otherwise get their port
+ * handed out twice. Stopped containers don't hold a bind, hence the running-only default.
+ */
+export async function hostPortsInUse(): Promise<number[]> {
+	try {
+		const containers = await (await getDocker()).listContainers();
+		const ports = new Set<number>();
+		for (const c of containers) {
+			for (const p of c.Ports ?? []) {
+				if (p.PublicPort) ports.add(p.PublicPort);
+			}
+		}
+		return [...ports];
+	} catch {
+		return [];
+	}
+}
+
+/** Goes through the raw modem because dockerode has no helper for `/build/prune`. */
+export async function pruneBuildCache(): Promise<{ spaceReclaimed: number }> {
+	const docker = await getDocker();
+	const data = await new Promise<{ SpaceReclaimed?: number } | undefined>((resolve, reject) =>
+		docker.modem.dial(
+			{
+				path: '/build/prune?all=true',
+				method: 'POST',
+				statusCodes: { 200: true, 500: 'server error' }
+			},
+			(err: unknown, res: unknown) =>
+				err ? reject(err) : resolve(res as { SpaceReclaimed?: number } | undefined)
+		)
+	);
+	return { spaceReclaimed: data?.SpaceReclaimed ?? 0 };
+}
+
+export async function startContainer(containerId: string): Promise<boolean> {
+	try {
+		await (await getDocker()).getContainer(containerId).start();
+		return true;
+	} catch (err) {
+		return statusOf(err) === 304; // already started
+	}
+}
+
+export async function stopContainer(containerId: string): Promise<boolean> {
+	try {
+		await (await getDocker()).getContainer(containerId).stop();
+		return true;
+	} catch (err) {
+		return statusOf(err) === 304; // already stopped
+	}
+}
+
+/** Named volumes must be listed before removal and dropped by hand — the engine never reaps them. */
+export async function removeContainer(containerId: string): Promise<boolean> {
+	const docker = await getDocker();
+	const container = docker.getContainer(containerId);
+
+	let volumeNames: string[];
+	try {
+		const info = await container.inspect();
+		volumeNames = (info.Mounts ?? [])
+			.filter((m) => m.Type === 'volume' && m.Name)
+			.map((m) => m.Name!);
+	} catch (err) {
+		if (statusOf(err) !== 404) throw err;
+		return true; // no such container — nothing to clean up
+	}
+
+	try {
+		await container.remove({ force: true, v: true });
+	} catch (err) {
+		if (statusOf(err) !== 404) return false; // already absent counts as success
+	}
+
+	for (const name of volumeNames) {
+		try {
+			await docker.getVolume(name).remove({ force: true });
+		} catch {
+			// Already dropped by `v: true` (404) or still shared with another container (409).
+		}
+	}
+	return true;
+}

package/src/lib/exec.server.ts

@@ -0,0 +1,92 @@
+import { Writable } from 'node:stream';
+import { getDocker } from './docker-client.server.ts';
+
+export interface ExecTarget {
+	containerId: string;
+	remoteUser?: string | null;
+}
+
+function collector(): { stream: Writable; text: () => string } {
+	const chunks: Buffer[] = [];
+	return {
+		stream: new Writable({
+			write(chunk, _enc, cb) {
+				chunks.push(Buffer.from(chunk));
+				cb();
+			}
+		}),
+		text: () => Buffer.concat(chunks).toString('utf8')
+	};
+}
+
+const STDIN_ENV = '__CODEBAY_EXEC_STDIN';
+const STDIN_VAR = 'CODEBAY_STDIN';
+
+/**
+ * Real exec stdin is unusable on Bun — dockerode's hijack path needs an `upgrade` event
+ * Bun never emits, and `openStdin` needs full-duplex client HTTP Bun also lacks.
+ */
+function wrapWithStdin(script: string): string {
+	// The carrier is an env var (never argv, so never in `ps`) and is unset so children don't inherit it.
+	return `${STDIN_VAR}="$${STDIN_ENV}"; unset ${STDIN_ENV}\n${script}`;
+}
+
+/**
+ * The one place the `bash -lc` container-exec pattern lives; every injection goes through it.
+ * `stdin` reaches the script as `$CODEBAY_STDIN`, and `args` as `$0`, `$1`, ….
+ */
+export async function execInContainer(
+	target: ExecTarget,
+	opts: { script: string; stdin?: string; args?: string[]; capture?: boolean }
+): Promise<{ ok: boolean; stdout: string; error?: string }> {
+	const user = target.remoteUser?.trim() || 'root';
+	const hasStdin = opts.stdin !== undefined;
+	try {
+		const exec = await (await getDocker()).getContainer(target.containerId).exec({
+			Cmd: [
+				'bash',
+				'-lc',
+				hasStdin ? wrapWithStdin(opts.script) : opts.script,
+				...(opts.args ?? [])
+			],
+			User: user,
+			Env: hasStdin ? [`${STDIN_ENV}=${opts.stdin}`] : undefined,
+			AttachStdout: true,
+			AttachStderr: true,
+			Tty: false // multiplexes stdout/stderr so the demux below can separate them
+		});
+		const stream = await exec.start({});
+
+		const out = collector();
+		const err = collector();
+		exec.modem.demuxStream(stream, out.stream, err.stream);
+		await new Promise<void>((resolve, reject) => {
+			stream.on('end', resolve);
+			stream.on('error', reject);
+		});
+
+		const code = (await exec.inspect()).ExitCode ?? 1;
+		const stdout = opts.capture ? out.text().trim() : '';
+		return code === 0
+			? { ok: true, stdout }
+			: { ok: false, stdout, error: err.text().trim() || `exit ${code}` };
+	} catch (e) {
+		return { ok: false, stdout: '', error: (e as Error).message };
+	}
+}
+
+/** The shape every injection's `check()` uses: a script that echoes `1` or `0`. */
+export async function checkPresence(
+	target: ExecTarget,
+	script: string,
+	args?: string[]
+): Promise<boolean> {
+	const res = await execInContainer(target, { script, args, capture: true });
+	return res.ok && res.stdout === '1';
+}
+
+/** Only for secret-only files; injections mixing secret and non-secret content roll their own. */
+export function writeSecretFileScript(dirExpr: string, filename: string, mode = '600'): string {
+	const path = `${dirExpr}/${filename}`;
+	return `mkdir -p "${dirExpr}"; printf '%s' "$CODEBAY_STDIN" > "${path}"; chmod ${mode} "${path}";`;
+}

package/src/lib/git.server.ts

@@ -0,0 +1,68 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readGhToken } from '../container-injections/github-credentials.ts';
+import { parseRepoUrl } from './repo-url.ts';
+
+/** Reads the bind-mounted host copy, so polling the container's branch costs no `docker exec`. */
+export async function readGitBranch(workspacePath: string): Promise<string | null> {
+	try {
+		const head = (await readFile(join(workspacePath, '.git', 'HEAD'), 'utf8')).trim();
+		const ref = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+		if (ref) return ref[1] ?? null;
+		// Detached HEAD: the file holds a raw commit SHA instead of a ref.
+		return head ? head.slice(0, 7) : null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * The token goes in env-scoped git config, so it lands in neither argv nor the clone's
+ * persisted `.git/config`; `GIT_TERMINAL_PROMPT=0` fails fast instead of blocking on a prompt.
+ */
+export async function cloneRepo(
+	source: string,
+	dest: string,
+	onLog: (chunk: string) => void,
+	opts: { branch?: string } = {}
+): Promise<void> {
+	const parsed = parseRepoUrl(source);
+	if (!parsed) throw new Error(`Invalid repository URL: ${source}`);
+
+	const env: Record<string, string | undefined> = {
+		...process.env,
+		GIT_TERMINAL_PROMPT: '0'
+	};
+
+	// Keyed by host so GitHub Enterprise Server clones authenticate too, not just github.com.
+	const found = await readGhToken(parsed.host);
+	if (found) {
+		const basic = Buffer.from(`x-access-token:${found.token}`).toString('base64');
+		env.GIT_CONFIG_COUNT = '1';
+		env.GIT_CONFIG_KEY_0 = `http.https://${parsed.host}/.extraheader`;
+		env.GIT_CONFIG_VALUE_0 = `Authorization: Basic ${basic}`;
+	}
+
+	const args = ['git', 'clone', '--progress'];
+	if (opts.branch?.trim()) args.push('--branch', opts.branch.trim());
+	args.push(parsed.cloneUrl, dest);
+
+	const proc = Bun.spawn(args, { stdout: 'pipe', stderr: 'pipe', env });
+
+	let stderrTail = '';
+	const decoder = new TextDecoder();
+	const pump = async (stream: ReadableStream<Uint8Array>, capture: boolean) => {
+		for await (const bytes of stream) {
+			const text = decoder.decode(bytes, { stream: true });
+			if (capture) stderrTail = (stderrTail + text).slice(-2000);
+			onLog(text);
+		}
+	};
+
+	await Promise.all([pump(proc.stdout, false), pump(proc.stderr, true)]);
+	const code = await proc.exited;
+	if (code !== 0) {
+		const tail = stderrTail.trim().split('\n').slice(-3).join(' ');
+		throw new Error(`git clone failed (exit ${code})${tail ? `: ${tail}` : ''}`);
+	}
+}

package/src/lib/health.server.ts

@@ -0,0 +1,105 @@
+import { type InstanceRow } from './db.server.ts';
+import { isRunning, publishedContainerPorts } from './docker.server.ts';
+import { broadcastHealth } from './instances.server.ts';
+import { resolveInjections } from './injections.server.ts';
+import type { InstanceHealth } from '../types.ts';
+
+const REFRESH_MS = 5000;
+
+interface Monitor {
+	snapshot: InstanceHealth | null;
+	timer: ReturnType<typeof setInterval>;
+}
+
+// Pin to globalThis so dev-mode hot reload doesn't orphan the interval timers.
+const globalForHealth = globalThis as unknown as { __codebayHealth?: Map<string, Monitor> };
+const monitors: Map<string, Monitor> = (globalForHealth.__codebayHealth ??= new Map());
+
+async function codeServerAccessible(port: number): Promise<boolean> {
+	try {
+		// Any HTTP response at all (200/302/401/…) means the server is listening.
+		await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(2000) });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function check(row: InstanceRow): Promise<InstanceHealth> {
+	const down: InstanceHealth = {
+		containerRunning: false,
+		codeServerAccessible: false,
+		injections: [],
+		openPorts: [],
+		checkedAt: Date.now()
+	};
+	if (!row.container_id || !(await isRunning(row.container_id))) return down;
+
+	// Probes as the recorded remote user, so `$HOME` resolves to the one the injection wrote to.
+	const target = { containerId: row.container_id, remoteUser: row.remote_user, instance: row };
+	const [accessible, openPorts, injectionResults] = await Promise.all([
+		codeServerAccessible(row.host_port),
+		publishedContainerPorts(row.container_id),
+		Promise.all(
+			resolveInjections()
+				.filter((i) => i.check)
+				.map(async (i) => ({
+					id: i.id,
+					label: i.label,
+					ok: await i.check!(target).catch(() => false)
+				}))
+		)
+	]);
+	return {
+		containerRunning: true,
+		codeServerAccessible: accessible,
+		injections: injectionResults,
+		openPorts,
+		checkedAt: Date.now()
+	};
+}
+
+async function tick(row: InstanceRow): Promise<void> {
+	const snapshot = await check(row);
+	const mon = monitors.get(row.id);
+	if (mon) mon.snapshot = snapshot;
+	broadcastHealth(row.id, snapshot);
+	if (!snapshot.containerRunning) stopHealthMonitor(row.id);
+}
+
+function startHealthMonitor(row: InstanceRow): Monitor {
+	const existing = monitors.get(row.id);
+	if (existing) return existing;
+	const mon: Monitor = { snapshot: null, timer: setInterval(() => void tick(row), REFRESH_MS) };
+	monitors.set(row.id, mon);
+	void tick(row); // seed the first snapshot rather than making the UI wait a full interval
+	return mon;
+}
+
+export function stopHealthMonitor(id: string): void {
+	const mon = monitors.get(id);
+	if (!mon) return;
+	clearInterval(mon.timer);
+	monitors.delete(id);
+}
+
+/** Driven from the reconcile loop, so monitors track the container lifecycle automatically. */
+export function syncHealthMonitors(rows: InstanceRow[]): void {
+	const running = new Set(
+		rows.filter((r) => r.status === 'running' && r.container_id).map((r) => r.id)
+	);
+	for (const row of rows) {
+		if (running.has(row.id) && !monitors.has(row.id)) startHealthMonitor(row);
+	}
+	for (const id of [...monitors.keys()]) {
+		if (!running.has(id)) stopHealthMonitor(id);
+	}
+}
+
+export function currentHealthSnapshots(): { id: string; health: InstanceHealth }[] {
+	const out: { id: string; health: InstanceHealth }[] = [];
+	for (const [id, mon] of monitors) {
+		if (mon.snapshot) out.push({ id, health: mon.snapshot });
+	}
+	return out;
+}

package/src/lib/injections.server.ts

@@ -0,0 +1,72 @@
+import type { InstanceRow } from './db.server.ts';
+import type { ExecTarget } from './exec.server.ts';
+import { getOption } from './db.server.ts';
+import { gitSafeDirectory } from '../container-injections/git-safe-directory.ts';
+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 { githubCredentials } from '../container-injections/github-credentials.ts';
+import { attentionHooks } from '../container-injections/attention-hooks.ts';
+import { claudeStatusline } from '../container-injections/claude-statusline.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';
+import { hostEnvVars } from '../container-injections/host-env-vars.ts';
+
+/** Extends `ExecTarget` so exec-user semantics have a single source of truth. */
+export interface ContainerTarget extends ExecTarget {
+	instance: InstanceRow;
+}
+
+/**
+ * Bundles host-side discovery, container `apply()`, and a live `check()` in one module,
+ * so what gets injected and what gets health-probed can never drift apart.
+ */
+export interface Injection {
+	/** Doubles as the health-row key. */
+	id: string;
+	label: string;
+	/** Omit for injections with no host dependency — presence is what draws the setup-UI chip. */
+	auth?: {
+		/** Short instruction shown when unavailable, e.g. "run `gh auth login`". */
+		hint: string;
+		status(): Promise<{ available: boolean; source: string | null }>;
+	};
+	apply(target: ContainerTarget, log: (msg: string) => void): Promise<void>;
+	/** Omit to keep the injection out of the health list. */
+	check?(target: ContainerTarget): Promise<boolean>;
+}
+
+/** Split around the Claude slot, which `resolveInjections()` fills at call time. */
+const BASE_INJECTIONS_HEAD: Injection[] = [
+	// Must stay first — every later git-touching injection depends on safe.directory.
+	gitSafeDirectory,
+	// The package install is the slowest injection, so start it before a folderOpen can find tmux missing.
+	tmux,
+	gitIdentity
+];
+
+const BASE_INJECTIONS_TAIL: Injection[] = [
+	githubCredentials,
+	attentionHooks,
+	claudeStatusline,
+	claudeSkipPermissions,
+	claudeAliases,
+	claudeNoCoauthor,
+	hostEnvVars
+];
+
+/** Resolved per call so toggling the custom-endpoint setting takes effect without a restart. */
+export function resolveInjections(): Injection[] {
+	const claudeInjection =
+		getOption('custom_endpoint_enabled') === '1' ? claudeCodeCustom : claudeCodeCredentials;
+	return [...BASE_INJECTIONS_HEAD, claudeInjection, ...BASE_INJECTIONS_TAIL];
+}
+
+/** @deprecated Use `resolveInjections()`; this ignores settings and is kept for the tests. */
+export const injections: Injection[] = [
+	...BASE_INJECTIONS_HEAD,
+	claudeCodeCredentials,
+	...BASE_INJECTIONS_TAIL
+];