codebay 0.0.1 → 0.2.1

package/src/lib/config.server.ts

@@ -0,0 +1,140 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+/** Defaults outside the project tree; a relative `DATA_DIR` resolves against cwd. */
+export const DATA_DIR = process.env.DATA_DIR
+	? isAbsolute(process.env.DATA_DIR)
+		? process.env.DATA_DIR
+		: resolve(process.cwd(), process.env.DATA_DIR)
+	: join(homedir(), '.codebay');
+
+/**
+ * Without a stable key Mochi mints a random one per boot, so anything it signed
+ * stops verifying after a restart. Must run before `Mochi.serve()` reads the env.
+ */
+export function ensureMochiKey(): void {
+	if (process.env.MOCHI_KEY?.trim()) {
+		return;
+	}
+	const keyPath = join(DATA_DIR, 'mochi-key');
+	try {
+		if (existsSync(keyPath)) {
+			const existing = readFileSync(keyPath, 'utf8').trim();
+			if (existing) {
+				process.env.MOCHI_KEY = existing;
+				return;
+			}
+		}
+		const key = randomBytes(32).toString('base64url');
+		mkdirSync(DATA_DIR, { recursive: true });
+		writeFileSync(keyPath, key + '\n', { mode: 0o600 });
+		process.env.MOCHI_KEY = key;
+	} catch (err) {
+		console.warn(`⚠ Could not persist a MOCHI_KEY in ${DATA_DIR}: ${(err as Error).message}`);
+	}
+}
+
+/** Read relative to this module, not cwd, because under `bunx codebay` cwd is the user's folder. */
+export const APP_VERSION: string = (() => {
+	try {
+		const path = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
+		const version = JSON.parse(readFileSync(path, 'utf8')).version;
+		return typeof version === 'string' ? version : 'unknown';
+	} catch {
+		return 'unknown';
+	}
+})();
+
+/** Per-instance working copies live here: <INSTANCES_DIR>/<id>/workspace. */
+export const INSTANCES_DIR = join(DATA_DIR, 'instances');
+
+export const DB_PATH = join(DATA_DIR, 'app.sqlite');
+
+export const PORT_BASE = 8001;
+export const PORT_MAX = 8999;
+
+/** Inside the container, not on the host. */
+export const CODE_SERVER_PORT = 8080;
+
+/** `base:ubuntu` is multi-arch, unlike the `universal` images, which are amd64-only. */
+export const DEFAULT_IMAGE = 'mcr.microsoft.com/devcontainers/base:ubuntu';
+
+/** An unset/empty password disables the gate entirely (local dev). */
+export const BASIC_AUTH_USERNAME = process.env.BASIC_AUTH_USERNAME || 'admin';
+export const BASIC_AUTH_PASSWORD = process.env.BASIC_AUTH_PASSWORD || '';
+
+/** Loopback by default so an instance with no password isn't exposed to the LAN. */
+export const HOST = process.env.HOST || '127.0.0.1';
+
+/**
+ * Forwarded app ports follow the server's bind; code-server's own port never does
+ * (it runs with auth disabled). Anything but `0.0.0.0` degrades to loopback rather
+ * than risking an appPort string Docker rejects.
+ */
+export const PUBLISH_HOST = HOST === '0.0.0.0' ? '0.0.0.0' : '127.0.0.1';
+
+export const PORT = Number(process.env.PORT) || 6969;
+
+/** Mochi's CSRF origin check compares against these; override when behind a proxy. */
+export const PUBLIC_ORIGIN = process.env.PUBLIC_ORIGIN?.trim() || `http://localhost:${PORT}`;
+export const TRUSTED_ORIGINS = (process.env.TRUSTED_ORIGINS || '')
+	.split(',')
+	.map((o) => o.trim())
+	.filter(Boolean);
+
+/**
+ * Set to skip host-credential discovery, e.g. on a server with no Keychain.
+ * A token entered in Settings still outranks these; see the credential injections.
+ */
+export const CLAUDE_CODE_TOKEN =
+	(process.env.CODEBAY_CLAUDE_CODE_TOKEN ?? process.env.DCM_CLAUDE_CODE_TOKEN)?.trim() || '';
+export const GITHUB_TOKEN =
+	(process.env.CODEBAY_GITHUB_TOKEN ?? process.env.DCM_GITHUB_TOKEN)?.trim() || '';
+
+/** macOS only — the Linux fallback (~/.claude/.credentials.json) has no service name. */
+export const CLAUDE_KEYCHAIN_SERVICE =
+	process.env.CODEBAY_CLAUDE_KEYCHAIN_SERVICE?.trim() || 'Claude Code-credentials';
+
+/**
+ * `.git` is deliberately absent so each instance keeps its history/remote.
+ * An explicit empty string (as opposed to unset) means "copy everything".
+ */
+export const DEFAULT_COPY_IGNORE = 'node_modules';
+
+export function parseCopyIgnore(raw: string): Set<string> {
+	return new Set(
+		raw
+			.split(',')
+			.map((p) => p.trim())
+			.filter(Boolean)
+	);
+}
+
+/** When unset, the docker/devcontainer CLIs resolve the current Docker context themselves. */
+export const DOCKER_HOST = process.env.DOCKER_HOST?.trim() || '';
+
+/** Keeps spawned `docker`/`devcontainer` processes pointed at the same daemon we use. */
+export function dockerEnv(): Record<string, string | undefined> {
+	return DOCKER_HOST ? { ...process.env, DOCKER_HOST } : process.env;
+}
+
+/**
+ * Resolved from our own dependency tree, not cwd, because under `bunx codebay`
+ * cwd is the user's arbitrary folder.
+ */
+export function devcontainerBin(): string {
+	try {
+		const pkgJson = fileURLToPath(import.meta.resolve('@devcontainers/cli/package.json'));
+		const shim = join(dirname(pkgJson), '..', '..', '.bin', 'devcontainer');
+		if (existsSync(shim)) return shim;
+		const pkg = JSON.parse(readFileSync(pkgJson, 'utf8'));
+		const rel = typeof pkg.bin === 'string' ? pkg.bin : pkg.bin?.devcontainer;
+		if (rel) return join(dirname(pkgJson), rel);
+	} catch {
+		// Fall through to the dev-checkout path below.
+	}
+	return join(process.cwd(), 'node_modules', '.bin', 'devcontainer');
+}

package/src/lib/crypto.server.ts

@@ -0,0 +1,12 @@
+/**
+ * A plain `===` short-circuits on the first differing byte, leaking length and prefix
+ * through timing. Hashing first makes both sides fixed-width, so even the lengths don't leak.
+ */
+export function timingSafeEqualStr(a: string, b: string): boolean {
+	const ah = Bun.SHA256.hash(a, 'hex');
+	const bh = Bun.SHA256.hash(b, 'hex');
+	// No early exit — the loop must run its full length on every call.
+	let diff = ah.length ^ bh.length;
+	for (let i = 0; i < ah.length; i++) diff |= ah.charCodeAt(i) ^ bh.charCodeAt(i);
+	return diff === 0;
+}

package/src/lib/db.server.ts

@@ -0,0 +1,196 @@
+import { Database } from 'bun:sqlite';
+import { migrate, getMigrations } from '@zihaolam/bun-sqlite-migrations';
+import { mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { DATA_DIR, DB_PATH } from './config.server.ts';
+import type { FolderHistoryEntry } from '../types.ts';
+
+// db.server.ts lives in src/lib, so ../../migrations resolves to the repo root.
+const MIGRATIONS_DIR = join(import.meta.dir, '../../migrations');
+
+export type InstanceStatus = 'creating' | 'running' | 'stopped' | 'error';
+
+export interface InstanceRow {
+	id: string;
+	name: string;
+	source_path: string;
+	workspace_path: string;
+	host_port: number;
+	container_id: string | null;
+	remote_workspace_folder: string | null;
+	status: InstanceStatus;
+	error: string | null;
+	created_at: number;
+	/** Per-instance secret the in-container Claude hook uses to authenticate to the bridge. */
+	bridge_token: string;
+	/** Container user the workspace runs as; needed to exec health checks in its home dir. */
+	remote_user: string | null;
+	/** `'local'` when the folder shipped its own config, else the injected image; null pre-dates this. */
+	image_source: string | null;
+}
+
+export interface PortForwardRow {
+	instance_id: string;
+	container_port: number;
+	host_port: number;
+	created_at: number;
+}
+
+// Pin the connection to globalThis so dev-mode hot reload doesn't reopen it.
+const globalForDb = globalThis as unknown as { __codebayDb?: Database };
+
+function open(): Database {
+	mkdirSync(DATA_DIR, { recursive: true });
+	const database = new Database(DB_PATH, { create: true });
+	database.run('PRAGMA journal_mode = WAL;');
+	migrate(database, getMigrations(MIGRATIONS_DIR));
+	return database;
+}
+
+export const db: Database = (globalForDb.__codebayDb ??= open());
+
+export function closeDb(): void {
+	globalForDb.__codebayDb?.close();
+	globalForDb.__codebayDb = undefined;
+}
+
+export function insertInstance(row: InstanceRow): void {
+	db.query(
+		`INSERT INTO instances
+       (id, name, source_path, workspace_path, host_port, container_id, remote_workspace_folder, status, error, created_at, bridge_token, remote_user, image_source)
+     VALUES ($id, $name, $source_path, $workspace_path, $host_port, $container_id, $remote_workspace_folder, $status, $error, $created_at, $bridge_token, $remote_user, $image_source)`
+	).run({
+		$id: row.id,
+		$name: row.name,
+		$source_path: row.source_path,
+		$workspace_path: row.workspace_path,
+		$host_port: row.host_port,
+		$container_id: row.container_id,
+		$remote_workspace_folder: row.remote_workspace_folder,
+		$status: row.status,
+		$error: row.error,
+		$created_at: row.created_at,
+		$bridge_token: row.bridge_token,
+		$remote_user: row.remote_user,
+		$image_source: row.image_source
+	});
+}
+
+export function getInstance(id: string): InstanceRow | null {
+	return db.query('SELECT * FROM instances WHERE id = $id').get({ $id: id }) as InstanceRow | null;
+}
+
+export function allInstances(): InstanceRow[] {
+	return db.query('SELECT * FROM instances ORDER BY created_at DESC').all() as InstanceRow[];
+}
+
+export function usedPorts(): number[] {
+	// Both tables publish host ports, so allocation has to see the union of them.
+	const rows = db
+		.query('SELECT host_port FROM instances UNION SELECT host_port FROM port_forwards')
+		.all() as { host_port: number }[];
+	return rows.map((r) => r.host_port);
+}
+
+export function listForwards(instanceId: string): PortForwardRow[] {
+	return db
+		.query('SELECT * FROM port_forwards WHERE instance_id = $id ORDER BY container_port')
+		.all({ $id: instanceId }) as PortForwardRow[];
+}
+
+export function allForwards(): PortForwardRow[] {
+	return db.query('SELECT * FROM port_forwards ORDER BY container_port').all() as PortForwardRow[];
+}
+
+export function insertForward(row: PortForwardRow): void {
+	db.query(
+		`INSERT INTO port_forwards (instance_id, container_port, host_port, created_at)
+     VALUES ($instance_id, $container_port, $host_port, $created_at)`
+	).run({
+		$instance_id: row.instance_id,
+		$container_port: row.container_port,
+		$host_port: row.host_port,
+		$created_at: row.created_at
+	});
+}
+
+export function deleteForward(instanceId: string, containerPort: number): void {
+	db.query('DELETE FROM port_forwards WHERE instance_id = $id AND container_port = $port').run({
+		$id: instanceId,
+		$port: containerPort
+	});
+}
+
+export function deleteForwards(instanceId: string): void {
+	db.query('DELETE FROM port_forwards WHERE instance_id = $id').run({ $id: instanceId });
+}
+
+/** The allowlist that keeps `updateInstance` from interpolating arbitrary column names. */
+const UPDATABLE_COLUMNS = [
+	'name',
+	'container_id',
+	'remote_workspace_folder',
+	'status',
+	'error',
+	'remote_user',
+	'image_source'
+] as const;
+
+type UpdatableColumn = (typeof UPDATABLE_COLUMNS)[number];
+
+export function updateInstance(
+	id: string,
+	patch: Partial<Pick<InstanceRow, UpdatableColumn>>
+): void {
+	const sets: string[] = [];
+	const params: Record<string, string | number | null> = { $id: id };
+	for (const col of UPDATABLE_COLUMNS) {
+		if (col in patch) {
+			sets.push(`${col} = $${col}`);
+			params[`$${col}`] = patch[col] ?? null;
+		}
+	}
+	if (sets.length === 0) return;
+	db.query(`UPDATE instances SET ${sets.join(', ')} WHERE id = $id`).run(params);
+}
+
+export function deleteInstanceRow(id: string): void {
+	db.query('DELETE FROM instances WHERE id = $id').run({ $id: id });
+}
+
+export function recordFolder(source_path: string, name: string): void {
+	db.query(
+		`INSERT INTO folder_history (source_path, name, last_used_at)
+     VALUES ($source_path, $name, $last_used_at)
+     ON CONFLICT(source_path) DO UPDATE SET
+       name = excluded.name,
+       last_used_at = excluded.last_used_at`
+	).run({ $source_path: source_path, $name: name, $last_used_at: Date.now() });
+}
+
+export function listFolderHistory(): FolderHistoryEntry[] {
+	return db
+		.query('SELECT * FROM folder_history ORDER BY last_used_at DESC')
+		.all() as FolderHistoryEntry[];
+}
+
+export function deleteFolderHistory(source_path: string): void {
+	db.query('DELETE FROM folder_history WHERE source_path = $source_path').run({
+		$source_path: source_path
+	});
+}
+
+export function getOption(key: string): string | null {
+	const row = db.query('SELECT value FROM options WHERE key = $key').get({ $key: key }) as {
+		value: string;
+	} | null;
+	return row?.value ?? null;
+}
+
+export function setOption(key: string, value: string): void {
+	db.query(
+		`INSERT INTO options (key, value)
+     VALUES ($key, $value)
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+	).run({ $key: key, $value: value });
+}