@ottocode/server 0.1.265 → 0.1.267

package/src/routes/tunnel/service.ts

@@ -0,0 +1,217 @@
+import type { Context } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import {
+	generateQRCode,
+	isTunnelBinaryInstalled,
+	killStaleTunnels,
+	logger,
+	OttoTunnel,
+} from '@ottocode/sdk';
+import { getServerPort } from '../../state.ts';
+
+type TunnelStatus = 'idle' | 'starting' | 'connected' | 'error';
+
+let activeTunnel: OttoTunnel | null = null;
+let tunnelUrl: string | null = null;
+let tunnelStatus: TunnelStatus = 'idle';
+let tunnelError: string | null = null;
+let progressMessage: string | null = null;
+
+export async function getTunnelStatus() {
+	const binaryInstalled = await isTunnelBinaryInstalled();
+
+	return {
+		status: tunnelStatus,
+		url: tunnelUrl,
+		error: tunnelError,
+		binaryInstalled,
+		isRunning: activeTunnel?.isRunning ?? false,
+	};
+}
+
+export async function startTunnel(requestedPort?: number) {
+	if (activeTunnel?.isRunning) {
+		return {
+			ok: true,
+			url: tunnelUrl,
+			message: 'Tunnel already running',
+		};
+	}
+
+	try {
+		const port = requestedPort || getServerPort() || 9100;
+
+		await killStaleTunnels();
+
+		tunnelStatus = 'starting';
+		tunnelError = null;
+		progressMessage = 'Initializing...';
+
+		activeTunnel = new OttoTunnel();
+
+		const url = await activeTunnel.start(port, (msg) => {
+			progressMessage = msg;
+		});
+
+		tunnelUrl = url;
+		tunnelStatus = 'connected';
+		progressMessage = null;
+
+		activeTunnel.on('error', (err) => {
+			logger.error('Tunnel error:', err);
+			tunnelError = err.message;
+			tunnelStatus = 'error';
+		});
+
+		activeTunnel.on('exit', () => {
+			tunnelStatus = 'idle';
+			tunnelUrl = null;
+			activeTunnel = null;
+		});
+
+		return {
+			ok: true,
+			url: tunnelUrl,
+			message: 'Tunnel started',
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		tunnelStatus = 'error';
+		tunnelError = message;
+		progressMessage = null;
+
+		logger.error('Failed to start tunnel:', error);
+		return { ok: false, error: message };
+	}
+}
+
+export function registerExternalTunnel(url?: string) {
+	if (!url) {
+		return { ok: false, error: 'URL is required' };
+	}
+
+	tunnelUrl = url;
+	tunnelStatus = 'connected';
+	tunnelError = null;
+	progressMessage = null;
+
+	return {
+		ok: true,
+		url: tunnelUrl,
+		message: 'External tunnel registered',
+	};
+}
+
+export function stopTunnel() {
+	if (!activeTunnel) {
+		return { ok: true, message: 'No tunnel running' };
+	}
+
+	try {
+		activeTunnel.stop();
+		activeTunnel = null;
+		tunnelUrl = null;
+		tunnelStatus = 'idle';
+		tunnelError = null;
+
+		return { ok: true, message: 'Tunnel stopped' };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { ok: false, error: message };
+	}
+}
+
+export async function getTunnelQRCode() {
+	if (!tunnelUrl) {
+		return { ok: false, error: 'No tunnel URL available' };
+	}
+
+	try {
+		const qrCode = await generateQRCode(tunnelUrl);
+		return {
+			ok: true,
+			url: tunnelUrl,
+			qrCode,
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return { ok: false, error: message };
+	}
+}
+
+export async function handleTunnelStream(c: Context) {
+	return streamSSE(c as Context, async (stream) => {
+		const sendEvent = async (data: Record<string, unknown>) => {
+			try {
+				await stream.write(`data: ${JSON.stringify(data)}\n\n`);
+			} catch (error) {
+				logger.error('SSE error writing event', error);
+			}
+		};
+
+		await sendEvent({
+			type: 'status',
+			status: tunnelStatus,
+			url: tunnelUrl,
+			error: tunnelError,
+			progress: progressMessage,
+		});
+
+		const interval = setInterval(async () => {
+			await sendEvent({
+				type: 'status',
+				status: tunnelStatus,
+				url: tunnelUrl,
+				error: tunnelError,
+				progress: progressMessage,
+			});
+		}, 1000);
+
+		const onAbort = () => {
+			clearInterval(interval);
+			stream.close();
+		};
+
+		c.req.raw.signal.addEventListener('abort', onAbort, { once: true });
+
+		await new Promise<void>((resolve) => {
+			c.req.raw.signal.addEventListener('abort', () => resolve(), {
+				once: true,
+			});
+		});
+
+		clearInterval(interval);
+	});
+}
+
+export function stopActiveTunnel() {
+	if (activeTunnel) {
+		activeTunnel.stop();
+		activeTunnel = null;
+		tunnelUrl = null;
+		tunnelStatus = 'idle';
+	}
+}
+
+export function setExternalTunnel(tunnel: OttoTunnel, url: string) {
+	activeTunnel = tunnel;
+	tunnelUrl = url;
+	tunnelStatus = 'connected';
+	tunnelError = null;
+	progressMessage = null;
+
+	tunnel.on('error', (err) => {
+		tunnelError = err.message;
+		tunnelStatus = 'error';
+	});
+
+	tunnel.on('exit', () => {
+		tunnelStatus = 'idle';
+		tunnelUrl = null;
+		activeTunnel = null;
+	});
+}
+
+export function getActiveTunnelUrl(): string | null {
+	return tunnelUrl;
+}

package/src/routes/tunnel.ts

@@ -1,21 +1,18 @@
 import type { Hono } from 'hono';
-import type { Context } from 'hono';
-import { streamSSE } from 'hono/streaming';
-import {
-	OttoTunnel,
-	isTunnelBinaryInstalled,
-	generateQRCode,
-	killStaleTunnels,
-	logger,
-} from '@ottocode/sdk';
-import { getServerPort } from '../state.ts';
 import { openApiRoute } from '../openapi/route.ts';
-
-let activeTunnel: OttoTunnel | null = null;
-let tunnelUrl: string | null = null;
-let tunnelStatus: 'idle' | 'starting' | 'connected' | 'error' = 'idle';
-let tunnelError: string | null = null;
-let progressMessage: string | null = null;
+import {
+	getActiveTunnelUrl,
+	getTunnelQRCode,
+	getTunnelStatus,
+	handleTunnelStream,
+	registerExternalTunnel,
+	setExternalTunnel,
+	startTunnel,
+	stopActiveTunnel,
+	stopTunnel,
+} from './tunnel/service.ts';
+
+export { getActiveTunnelUrl, setExternalTunnel, stopActiveTunnel };
 
 export function registerTunnelRoutes(app: Hono) {
 	openApiRoute(
@@ -60,17 +57,7 @@ export function registerTunnelRoutes(app: Hono) {
 				},
 			},
 		},
-		async (c) => {
-			const binaryInstalled = await isTunnelBinaryInstalled();
-
-			return c.json({
-				status: tunnelStatus,
-				url: tunnelUrl,
-				error: tunnelError,
-				binaryInstalled,
-				isRunning: activeTunnel?.isRunning ?? false,
-			});
-		},
+		async (c) => c.json(await getTunnelStatus()),
 	);
 
 	openApiRoute(
@@ -125,66 +112,11 @@ export function registerTunnelRoutes(app: Hono) {
 			},
 		},
 		async (c) => {
-			if (activeTunnel?.isRunning) {
-				return c.json({
-					ok: true,
-					url: tunnelUrl,
-					message: 'Tunnel already running',
-				});
-			}
-
-			try {
-				const body = await c.req.json().catch(() => ({}));
-				let port = body.port;
-
-				// Use server's known port if not explicitly provided
-				if (!port) {
-					port = getServerPort() || 9100;
-				}
-
-				// Kill any stale tunnel processes first
-				await killStaleTunnels();
-
-				tunnelStatus = 'starting';
-				tunnelError = null;
-				progressMessage = 'Initializing...';
-
-				activeTunnel = new OttoTunnel();
-
-				const url = await activeTunnel.start(port, (msg) => {
-					progressMessage = msg;
-				});
-
-				tunnelUrl = url;
-				tunnelStatus = 'connected';
-				progressMessage = null;
-
-				activeTunnel.on('error', (err) => {
-					logger.error('Tunnel error:', err);
-					tunnelError = err.message;
-					tunnelStatus = 'error';
-				});
-
-				activeTunnel.on('exit', () => {
-					tunnelStatus = 'idle';
-					tunnelUrl = null;
-					activeTunnel = null;
-				});
-
-				return c.json({
-					ok: true,
-					url: tunnelUrl,
-					message: 'Tunnel started',
-				});
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				tunnelStatus = 'error';
-				tunnelError = message;
-				progressMessage = null;
-
-				logger.error('Failed to start tunnel:', error);
-				return c.json({ ok: false, error: message }, 500);
-			}
+			const body: { port?: number } = await c.req
+				.json<{ port?: number }>()
+				.catch(() => ({}));
+			const result = await startTunnel(body.port);
+			return c.json(result, result.ok ? 200 : 500);
 		},
 	);
 
@@ -254,29 +186,11 @@ export function registerTunnelRoutes(app: Hono) {
 			},
 		},
 		async (c) => {
-			try {
-				const body = await c.req.json().catch(() => ({}));
-				const { url } = body;
-
-				if (!url) {
-					return c.json({ ok: false, error: 'URL is required' }, 400);
-				}
-
-				tunnelUrl = url;
-				tunnelStatus = 'connected';
-				tunnelError = null;
-				progressMessage = null;
-
-				return c.json({
-					ok: true,
-					url: tunnelUrl,
-					message: 'External tunnel registered',
-				});
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				logger.error('Failed to register external tunnel:', error);
-				return c.json({ ok: false, error: message }, 500);
-			}
+			const body: { url?: string } = await c.req
+				.json<{ url?: string }>()
+				.catch(() => ({}));
+			const result = registerExternalTunnel(body.url);
+			return c.json(result, result.ok ? 200 : 400);
 		},
 	);
 
@@ -310,23 +224,9 @@ export function registerTunnelRoutes(app: Hono) {
 				},
 			},
 		},
-		async (c) => {
-			if (!activeTunnel) {
-				return c.json({ ok: true, message: 'No tunnel running' });
-			}
-
-			try {
-				activeTunnel.stop();
-				activeTunnel = null;
-				tunnelUrl = null;
-				tunnelStatus = 'idle';
-				tunnelError = null;
-
-				return c.json({ ok: true, message: 'Tunnel stopped' });
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				return c.json({ ok: false, error: message }, 500);
-			}
+		(c) => {
+			const result = stopTunnel();
+			return c.json(result, result.ok ? 200 : 500);
 		},
 	);
 
@@ -380,69 +280,11 @@ export function registerTunnelRoutes(app: Hono) {
 			},
 		},
 		async (c) => {
-			if (!tunnelUrl) {
-				return c.json({ ok: false, error: 'No tunnel URL available' }, 400);
-			}
-
-			try {
-				const qrCode = await generateQRCode(tunnelUrl);
-				return c.json({
-					ok: true,
-					url: tunnelUrl,
-					qrCode,
-				});
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				return c.json({ ok: false, error: message }, 500);
-			}
+			const result = await getTunnelQRCode();
+			return c.json(result, result.ok ? 200 : 400);
 		},
 	);
 
-	const handleTunnelStream = async (c: Context) => {
-		return streamSSE(c as Context, async (stream) => {
-			const sendEvent = async (data: Record<string, unknown>) => {
-				try {
-					await stream.write(`data: ${JSON.stringify(data)}\n\n`);
-				} catch (error) {
-					logger.error('SSE error writing event', error);
-				}
-			};
-
-			await sendEvent({
-				type: 'status',
-				status: tunnelStatus,
-				url: tunnelUrl,
-				error: tunnelError,
-				progress: progressMessage,
-			});
-
-			const interval = setInterval(async () => {
-				await sendEvent({
-					type: 'status',
-					status: tunnelStatus,
-					url: tunnelUrl,
-					error: tunnelError,
-					progress: progressMessage,
-				});
-			}, 1000);
-
-			const onAbort = () => {
-				clearInterval(interval);
-				stream.close();
-			};
-
-			c.req.raw.signal.addEventListener('abort', onAbort, { once: true });
-
-			await new Promise<void>((resolve) => {
-				c.req.raw.signal.addEventListener('abort', () => resolve(), {
-					once: true,
-				});
-			});
-
-			clearInterval(interval);
-		});
-	};
-
 	const tunnelStreamRoute = {
 		tags: ['tunnel'],
 		summary: 'Subscribe to tunnel status stream',
@@ -479,35 +321,3 @@ export function registerTunnelRoutes(app: Hono) {
 		handleTunnelStream,
 	);
 }
-
-export function stopActiveTunnel() {
-	if (activeTunnel) {
-		activeTunnel.stop();
-		activeTunnel = null;
-		tunnelUrl = null;
-		tunnelStatus = 'idle';
-	}
-}
-
-export function setExternalTunnel(tunnel: OttoTunnel, url: string) {
-	activeTunnel = tunnel;
-	tunnelUrl = url;
-	tunnelStatus = 'connected';
-	tunnelError = null;
-	progressMessage = null;
-
-	tunnel.on('error', (err) => {
-		tunnelError = err.message;
-		tunnelStatus = 'error';
-	});
-
-	tunnel.on('exit', () => {
-		tunnelStatus = 'idle';
-		tunnelUrl = null;
-		activeTunnel = null;
-	});
-}
-
-export function getActiveTunnelUrl(): string | null {
-	return tunnelUrl;
-}

package/src/runtime/agent/registry-prompts.ts

@@ -0,0 +1,147 @@
+import { getGlobalAgentsDir } from '@ottocode/sdk';
+// Embed default agent prompts; only user overrides read from disk.
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import AGENT_BUILD from '@ottocode/sdk/prompts/agents/build.txt' with {
+	type: 'text',
+};
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import AGENT_PLAN from '@ottocode/sdk/prompts/agents/plan.txt' with {
+	type: 'text',
+};
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import AGENT_GENERAL from '@ottocode/sdk/prompts/agents/general.txt' with {
+	type: 'text',
+};
+// eslint-disable-next-line @typescript-eslint/consistent-type-imports
+import AGENT_INIT from '@ottocode/sdk/prompts/agents/init.txt' with {
+	type: 'text',
+};
+import AGENT_RESEARCH from '@ottocode/sdk/prompts/agents/research.txt' with {
+	type: 'text',
+};
+
+type PromptResolution = {
+	prompt: string;
+	source: string;
+};
+
+const EMBEDDED_AGENT_PROMPTS: Record<string, string> = {
+	build: AGENT_BUILD,
+	plan: AGENT_PLAN,
+	general: AGENT_GENERAL,
+	init: AGENT_INIT,
+	research: AGENT_RESEARCH,
+};
+
+function normalizePath(path: string): string {
+	return path.replace(/\\/g, '/');
+}
+
+export function getAgentPromptCandidates(
+	projectRoot: string,
+	name: string,
+): string[] {
+	const globalAgentsDir = getGlobalAgentsDir();
+	return [
+		normalizePath(`${projectRoot}/.otto/agents/${name}/agent.md`),
+		normalizePath(`${projectRoot}/.otto/agents/${name}.md`),
+		normalizePath(`${projectRoot}/.otto/agents/${name}/agent.txt`),
+		normalizePath(`${projectRoot}/.otto/agents/${name}.txt`),
+		normalizePath(`${globalAgentsDir}/${name}/agent.md`),
+		normalizePath(`${globalAgentsDir}/${name}.md`),
+		normalizePath(`${globalAgentsDir}/${name}/agent.txt`),
+		normalizePath(`${globalAgentsDir}/${name}.txt`),
+	];
+}
+
+async function readFirstNonEmptyFile(
+	candidates: string[],
+	sourcePrefix: string,
+): Promise<PromptResolution | undefined> {
+	for (const candidate of candidates) {
+		try {
+			const file = Bun.file(candidate);
+			if (!(await file.exists())) continue;
+			const text = await file.text();
+			if (!text.trim()) continue;
+			return {
+				prompt: text,
+				source: `${sourcePrefix}:${candidate}`,
+			};
+		} catch {}
+	}
+	return undefined;
+}
+
+function isPromptPathReference(value: string): boolean {
+	return (
+		/[.](md|txt)$/i.test(value) ||
+		value.startsWith('.') ||
+		value.startsWith('/') ||
+		value.startsWith('~/')
+	);
+}
+
+function getPromptReferenceCandidates(
+	projectRoot: string,
+	reference: string,
+): string[] {
+	if (reference.startsWith('~/')) {
+		const home = process.env.HOME || process.env.USERPROFILE || '';
+		return [normalizePath(`${home}/${reference.slice(2)}`)];
+	}
+	if (reference.startsWith('/')) return [normalizePath(reference)];
+	return [normalizePath(`${projectRoot}/${reference}`)];
+}
+
+async function resolveAgentsJsonPrompt(
+	projectRoot: string,
+	promptValue: string | undefined,
+): Promise<PromptResolution | undefined> {
+	const prompt = promptValue?.trim();
+	if (!prompt) return undefined;
+
+	if (!isPromptPathReference(prompt)) {
+		return {
+			prompt,
+			source: 'agents.json:inline',
+		};
+	}
+
+	return readFirstNonEmptyFile(
+		getPromptReferenceCandidates(projectRoot, prompt),
+		'agents.json:file',
+	);
+}
+
+function resolveEmbeddedPrompt(name: string): PromptResolution {
+	const prompt = EMBEDDED_AGENT_PROMPTS[name]?.trim();
+	if (prompt) {
+		return {
+			prompt,
+			source: `fallback:embedded:${name}.txt`,
+		};
+	}
+
+	return {
+		prompt: (AGENT_BUILD || '').trim(),
+		source: 'fallback:embedded:build.txt',
+	};
+}
+
+export async function resolveAgentPrompt(args: {
+	projectRoot: string;
+	name: string;
+	entryPrompt?: string;
+}): Promise<PromptResolution> {
+	const filePrompt = await readFirstNonEmptyFile(
+		getAgentPromptCandidates(args.projectRoot, args.name),
+		'file',
+	);
+	const agentsJsonPrompt = await resolveAgentsJsonPrompt(
+		args.projectRoot,
+		args.entryPrompt,
+	);
+
+	return agentsJsonPrompt ?? filePrompt ?? resolveEmbeddedPrompt(args.name);
+}