codebay 0.0.1 → 0.2.1

package/src/lib/proxy.server.ts

@@ -0,0 +1,170 @@
+import { Mochi, type MochiApiEvent, type MochiRouteValue, type MochiWsData } from 'mochi-framework';
+import type { ServerWebSocket } from 'bun';
+import { getInstance } from './db.server.ts';
+
+export const PROXY_PREFIX = '/p';
+
+/** Internal sentinel, never hit directly: proxied upgrades tag themselves with it so
+ * Mochi's shared websocket dispatcher routes them to the relay below. */
+const PROXY_WS_PATTERN = '/__codebay_proxy_ws';
+
+export function proxyPathFor(id: string): string {
+	return `${PROXY_PREFIX}/${id}/`;
+}
+
+/** Null unless the instance is running, since a stopped container publishes nothing. */
+function upstreamPort(id: string): number | null {
+	const row = getInstance(id);
+	if (!row || row.status !== 'running') return null;
+	return row.host_port;
+}
+
+/** Bun's wildcard routes expose `:id` but not the `*` capture, so strip the prefix by hand. */
+function restOf(pathname: string, id: string): string {
+	return pathname.slice(`${PROXY_PREFIX}/${id}`.length) || '/';
+}
+
+type Frame = string | Buffer;
+
+/** The cast gets past the DOM `send` overload's strict typing. */
+function sendFrame(socket: { send: (data: never) => unknown }, frame: Frame): void {
+	socket.send(frame as never);
+}
+
+/** Only 1000 and 3000–4999 may be passed to `.close()`; anything else throws. */
+function safeClose(
+	ws: { close: (code?: number, reason?: string) => void },
+	code: number,
+	reason: string
+): void {
+	try {
+		if (code === 1000 || (code >= 3000 && code <= 4999)) ws.close(code, reason);
+		else ws.close();
+	} catch {
+		/* already closed */
+	}
+}
+
+interface RelayState {
+	upstreamWsUrl: string;
+	client?: WebSocket;
+	/** Frames received from the browser before the upstream socket is open. */
+	pending: Frame[];
+}
+
+async function proxyHttp(event: MochiApiEvent, port: number, rest: string): Promise<Response> {
+	const headers = new Headers(event.request.headers);
+	headers.set('host', `127.0.0.1:${port}`);
+	headers.delete('accept-encoding'); // ask for an unencoded body so we can stream it verbatim
+	// code-server runs with `--auth none`, so forwarding this would only leak the app password.
+	// `cookie` is deliberately kept: the manager sets none, so every cookie here is code-server's.
+	headers.delete('authorization');
+	const hasBody = event.method !== 'GET' && event.method !== 'HEAD';
+	let upstream: Response;
+	try {
+		upstream = await fetch(`http://127.0.0.1:${port}${rest}${event.url.search}`, {
+			method: event.method,
+			headers,
+			body: hasBody ? event.request.body : undefined,
+			redirect: 'manual',
+			// @ts-expect-error Bun streams request bodies with duplex: 'half'.
+			duplex: 'half'
+		});
+	} catch (err) {
+		// Usually just code-server not having bound its port yet; letting it escape would
+		// render a 500 stack trace inside the IDE iframe.
+		console.warn(`[proxy] upstream 127.0.0.1:${port}${rest} unreachable:`, (err as Error).message);
+		return new Response('code-server is not accepting connections yet', {
+			status: 503,
+			headers: { 'retry-after': '1', 'cache-control': 'no-store' }
+		});
+	}
+
+	const resHeaders = new Headers(upstream.headers);
+	resHeaders.delete('content-encoding'); // body is already decoded by fetch
+	resHeaders.delete('transfer-encoding'); // Bun re-frames the streamed body
+	resHeaders.delete('content-length'); // may not match after re-framing; let Bun set it
+	return new Response(upstream.body, {
+		status: upstream.status,
+		statusText: upstream.statusText,
+		headers: resHeaders
+	});
+}
+
+function proxyUpgrade(event: MochiApiEvent, port: number, rest: string): Response {
+	const data: MochiWsData<RelayState> = {
+		__mochiRoutePattern: PROXY_WS_PATTERN,
+		__mochiOpenedAt: performance.now(),
+		__mochiPath: event.url.pathname,
+		user: { upstreamWsUrl: `ws://127.0.0.1:${port}${rest}${event.url.search}`, pending: [] }
+	};
+	// Bun's Server is typed with a fixed WebSocketData; Mochi casts the same way for its own upgrades.
+	const ok = (
+		event.server as unknown as {
+			upgrade: (req: Request, opts: { data: MochiWsData<RelayState> }) => boolean;
+		}
+	).upgrade(event.request, { data });
+	if (!ok) return new Response('WebSocket upgrade failed', { status: 426 });
+	// Bun already sent the real 101; this is ignored, but Mochi's resolve chain reads a status.
+	return new Response(null, { status: 101 });
+}
+
+/** Ordinary routes, so the global Basic Auth handle wraps them — WS upgrades included. */
+export const proxyRoutes: Record<string, MochiRouteValue> = {
+	// code-server emits relative URLs, so the mount has to end in a slash.
+	[`${PROXY_PREFIX}/:id`]: Mochi.api(({ url }) => {
+		return new Response(null, {
+			status: 308,
+			headers: { Location: `${url.pathname}/${url.search}` }
+		});
+	}),
+
+	[`${PROXY_PREFIX}/:id/*`]: Mochi.api(async (event) => {
+		const port = upstreamPort(event.params.id!);
+		if (port === null) return new Response('Instance not running', { status: 502 });
+
+		const rest = restOf(event.url.pathname, event.params.id!);
+
+		// An upgrade is a GET carrying `Upgrade: websocket`, so Bun routes it here too.
+		if (event.request.headers.get('upgrade')?.toLowerCase() === 'websocket') {
+			return proxyUpgrade(event, port, rest);
+		}
+		return proxyHttp(event, port, rest);
+	}),
+
+	// `upgrade: () => false` rejects anyone who navigates to the sentinel directly.
+	[PROXY_WS_PATTERN]: Mochi.ws<RelayState>({
+		upgrade: () => false,
+		open(ws: ServerWebSocket<MochiWsData<RelayState>>) {
+			const state = ws.data.user;
+			const client = new WebSocket(state.upstreamWsUrl);
+			client.binaryType = 'arraybuffer';
+			state.client = client;
+
+			client.onopen = () => {
+				for (const frame of state.pending) sendFrame(client, frame);
+				state.pending = [];
+			};
+			client.onmessage = (e) => {
+				try {
+					ws.send(e.data);
+				} catch {
+					/* browser socket closed */
+				}
+			};
+			client.onclose = (e) => safeClose(ws, e.code, e.reason);
+			client.onerror = () => safeClose(ws, 1011, 'upstream error');
+		},
+		message(ws: ServerWebSocket<MochiWsData<RelayState>>, message) {
+			const state = ws.data.user;
+			if (state.client && state.client.readyState === WebSocket.OPEN)
+				sendFrame(state.client, message);
+			else state.pending.push(message);
+		},
+		close(ws: ServerWebSocket<MochiWsData<RelayState>>) {
+			// `client` is always set in open() before any close is relayed.
+			const client = ws.data.user.client;
+			if (client) safeClose(client, 1000, '');
+		}
+	})
+};

package/src/lib/repo-url.ts

@@ -0,0 +1,60 @@
+// Pure string logic with no server imports, because the client bundle uses it too.
+
+export interface ParsedRepo {
+	host: string;
+	owner: string;
+	/** `.git` suffix stripped. */
+	repo: string;
+	/** Normalized to `https://<host>/<owner>/<repo>.git` regardless of the input form. */
+	cloneUrl: string;
+}
+
+const SEGMENT = /^[A-Za-z0-9._-]+$/;
+
+/** Null for anything unrecognized, which is how a local folder path is told apart from a URL. */
+export function parseRepoUrl(input: string): ParsedRepo | null {
+	const raw = input.trim();
+	if (!raw) return null;
+
+	let host: string | undefined;
+	let path: string | undefined;
+
+	const scp = raw.match(/^[A-Za-z0-9._-]+@([A-Za-z0-9.-]+):(.+)$/);
+	if (scp) {
+		host = scp[1];
+		path = scp[2];
+	} else if (/^[a-z][a-z0-9+.-]*:\/\//i.test(raw)) {
+		let url: URL;
+		try {
+			url = new URL(raw);
+		} catch {
+			return null;
+		}
+		if (url.protocol !== 'http:' && url.protocol !== 'https:' && url.protocol !== 'ssh:') {
+			return null;
+		}
+		host = url.hostname;
+		path = url.pathname;
+	} else {
+		// Schemeless: require a dotted host as the first segment so bare/relative paths don't match.
+		const m = raw.match(/^([A-Za-z0-9-]+\.[A-Za-z0-9.-]+)\/(.+)$/);
+		if (!m) return null;
+		host = m[1];
+		path = m[2];
+	}
+
+	if (!host || !path) return null;
+
+	const segments = path
+		.replace(/\.git$/i, '')
+		.split('/')
+		.filter(Boolean);
+	const [owner, repo] = segments;
+	if (!owner || !repo || !SEGMENT.test(owner) || !SEGMENT.test(repo)) return null;
+
+	return { host, owner, repo, cloneUrl: `https://${host}/${owner}/${repo}.git` };
+}
+
+export function isRepoUrl(input: string): boolean {
+	return parseRepoUrl(input) !== null;
+}

package/src/lib/spawn.server.ts

@@ -0,0 +1,14 @@
+/** Null on anything short of a clean run with output, so callers need no error branch. */
+export async function spawnCapture(
+	cmd: string[],
+	opts?: { env?: Record<string, string | undefined> }
+): Promise<string | null> {
+	try {
+		const proc = Bun.spawn(cmd, { stdout: 'pipe', stderr: 'ignore', env: opts?.env });
+		const [out, code] = await Promise.all([new Response(proc.stdout).text(), proc.exited]);
+		const value = out.trim();
+		return code === 0 && value ? value : null;
+	} catch {
+		return null; // binary not installed on the host
+	}
+}

package/src/lib/theme.server.ts

@@ -0,0 +1,22 @@
+import { getRequestContext, type Handle } from 'mochi-framework';
+
+/** Anything but an explicit choice is left untouched, so the CSS falls through to `prefers-color-scheme`. */
+export function injectThemeAttribute(html: string, cookieValue: string | undefined): string {
+	if (cookieValue !== 'dark' && cookieValue !== 'light') return html;
+	return html.replace('<html', `<html data-theme="${cookieValue}"`);
+}
+
+/** Rewrites the tag server-side so the first paint has no flash of the wrong theme. */
+export const themeHandle: Handle = ({ event, resolve }) =>
+	resolve(event, {
+		transformPage: ({ html }) => {
+			// Mochi's fetch-fallback path also lands here, and it runs outside requestContext.
+			let cookieValue: string | undefined;
+			try {
+				cookieValue = getRequestContext().cookies.get('theme');
+			} catch {
+				return html;
+			}
+			return injectThemeAttribute(html, cookieValue);
+		}
+	});

package/src/live.ts

@@ -0,0 +1,50 @@
+import type { StreamEvent } from './lib/instances.server.ts';
+
+/**
+ * WebSockets don't auto-reconnect the way EventSource does, hence the backoff loop.
+ * Browser-only — call it from inside an `$effect`.
+ */
+export function liveSocket(
+	path: string,
+	onMessage: (data: string) => void,
+	onOpen?: () => void
+): () => void {
+	let ws: WebSocket | null = null;
+	let timer: ReturnType<typeof setTimeout> | null = null;
+	let closed = false;
+
+	const connect = () => {
+		const proto = location.protocol === 'https:' ? 'wss:' : 'ws:';
+		ws = new WebSocket(`${proto}//${location.host}${path}`);
+		ws.onopen = () => onOpen?.();
+		ws.onmessage = (e) => onMessage(e.data as string);
+		ws.onclose = () => {
+			if (!closed) timer = setTimeout(connect, 1000);
+		};
+		ws.onerror = () => ws?.close();
+	};
+	connect();
+
+	return () => {
+		closed = true;
+		if (timer) clearTimeout(timer);
+		ws?.close();
+	};
+}
+
+/** Malformed frames are dropped silently rather than surfaced to the caller. */
+export function liveStream(onEvent: (event: StreamEvent) => void, onOpen?: () => void): () => void {
+	return liveSocket(
+		'/api/stream',
+		(raw) => {
+			let msg: StreamEvent;
+			try {
+				msg = JSON.parse(raw) as StreamEvent;
+			} catch {
+				return; // ignore malformed frame
+			}
+			onEvent(msg);
+		},
+		onOpen
+	);
+}

package/src/pages/App.svelte

@@ -0,0 +1,14 @@
+<script lang="ts">
+	import '@fontsource-variable/doto';
+	import '@fontsource-variable/jetbrains-mono';
+	import AppShell from '../components/AppShell.svelte';
+	import type { Instance, Preflight } from '../types.ts';
+
+	let {
+		preflight,
+		initialPath,
+		snapshot
+	}: { preflight: Preflight; initialPath: string; snapshot: Instance[] } = $props();
+</script>
+
+<AppShell {preflight} {initialPath} {snapshot} mochi:hydrate />

package/src/pages/Avatars.svelte

@@ -0,0 +1,9 @@
+<script lang="ts">
+	import '@fontsource-variable/doto';
+	import '@fontsource-variable/jetbrains-mono';
+	import AvatarsView from '../components/AvatarsView.svelte';
+
+	let { namePlaceholder }: { namePlaceholder: string } = $props();
+</script>
+
+<AvatarsView {namePlaceholder} mochi:hydrate />

package/src/pages/Instance.svelte

@@ -0,0 +1,9 @@
+<script lang="ts">
+	import '@fontsource-variable/doto';
+	import '@fontsource-variable/jetbrains-mono';
+	import InstanceView from '../components/InstanceView.svelte';
+
+	let { id, injectionChecks }: { id: string; injectionChecks: number } = $props();
+</script>
+
+<InstanceView {id} {injectionChecks} mochi:hydrate />

package/src/pages/Settings.svelte

@@ -0,0 +1,76 @@
+<script lang="ts">
+	import '@fontsource-variable/doto';
+	import '@fontsource-variable/jetbrains-mono';
+	import SettingsView from '../components/SettingsView.svelte';
+
+	let {
+		defaultImage,
+		builtinImage,
+		disableBuildCache,
+		copyIgnorePatterns,
+		builtinCopyIgnore,
+		dockerArch,
+		manualTokensEnabled,
+		githubTokenSet,
+		claudeTokenSet,
+		customEndpointEnabled,
+		customEndpointBaseUrl,
+		customEndpointTokenSet,
+		customEndpointOpusModel,
+		customEndpointSonnetModel,
+		customEndpointHaikuModel,
+		customEndpointSmallFastModel,
+		customEndpointModel,
+		hostEnvVarsEnabled,
+		hostEnvVarNames,
+		hostEnvVarPresence,
+		version
+	}: {
+		defaultImage: string;
+		builtinImage: string;
+		disableBuildCache: boolean;
+		copyIgnorePatterns: string;
+		builtinCopyIgnore: string;
+		dockerArch: string | null;
+		manualTokensEnabled: boolean;
+		githubTokenSet: boolean;
+		claudeTokenSet: boolean;
+		customEndpointEnabled: boolean;
+		customEndpointBaseUrl: string;
+		customEndpointTokenSet: boolean;
+		customEndpointOpusModel: string;
+		customEndpointSonnetModel: string;
+		customEndpointHaikuModel: string;
+		customEndpointSmallFastModel: string;
+		customEndpointModel: string;
+		hostEnvVarsEnabled: boolean;
+		hostEnvVarNames: string[];
+		hostEnvVarPresence: Record<string, boolean>;
+		version: string;
+	} = $props();
+</script>
+
+<SettingsView
+	{defaultImage}
+	{builtinImage}
+	{disableBuildCache}
+	{copyIgnorePatterns}
+	{builtinCopyIgnore}
+	{dockerArch}
+	{manualTokensEnabled}
+	{githubTokenSet}
+	{claudeTokenSet}
+	{customEndpointEnabled}
+	{customEndpointBaseUrl}
+	{customEndpointTokenSet}
+	{customEndpointOpusModel}
+	{customEndpointSonnetModel}
+	{customEndpointHaikuModel}
+	{customEndpointSmallFastModel}
+	{customEndpointModel}
+	{hostEnvVarsEnabled}
+	{hostEnvVarNames}
+	{hostEnvVarPresence}
+	{version}
+	mochi:hydrate
+/>

package/src/pages/UI.svelte

@@ -0,0 +1,10 @@
+<script lang="ts">
+	import '@fontsource-variable/doto';
+	import '@fontsource-variable/jetbrains-mono';
+	import type { Preflight } from '../types.ts';
+	import UiShowcase from '../components/UiShowcase.svelte';
+
+	let { preflight }: { preflight: Preflight } = $props();
+</script>
+
+<UiShowcase {preflight} mochi:hydrate />