@ottocode/server 0.1.177 → 0.1.179

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ottocode/server",
-	"version": "0.1.177",
+	"version": "0.1.179",
 	"description": "HTTP API server for ottocode",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -29,8 +29,8 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"dependencies": {
-		"@ottocode/sdk": "0.1.177",
-		"@ottocode/database": "0.1.177",
+		"@ottocode/sdk": "0.1.179",
+		"@ottocode/database": "0.1.179",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9",
 		"zod": "^4.1.8"

package/src/index.ts

@@ -19,6 +19,7 @@ import { registerResearchRoutes } from './routes/research.ts';
 import { registerSessionApprovalRoute } from './routes/session-approval.ts';
 import { registerSetuRoutes } from './routes/setu.ts';
 import { registerAuthRoutes } from './routes/auth.ts';
+import { registerTunnelRoutes } from './routes/tunnel.ts';
 import type { AgentConfigEntry } from './runtime/agent/registry.ts';
 
 const globalTerminalManager = new TerminalManager();
@@ -74,6 +75,7 @@ function initApp() {
 	registerResearchRoutes(app);
 	registerSetuRoutes(app);
 	registerAuthRoutes(app);
+	registerTunnelRoutes(app);
 
 	return app;
 }
@@ -145,6 +147,7 @@ export function createStandaloneApp(_config?: StandaloneAppConfig) {
 	registerResearchRoutes(honoApp);
 	registerSetuRoutes(honoApp);
 	registerAuthRoutes(honoApp);
+	registerTunnelRoutes(honoApp);
 
 	return honoApp;
 }
@@ -244,6 +247,7 @@ export function createEmbeddedApp(config: EmbeddedAppConfig = {}) {
 	registerResearchRoutes(honoApp);
 	registerSetuRoutes(honoApp);
 	registerAuthRoutes(honoApp);
+	registerTunnelRoutes(honoApp);
 
 	return honoApp;
 }
@@ -279,3 +283,6 @@ export {
 	isTraceEnabled,
 } from './runtime/debug/state.ts';
 export { logger } from '@ottocode/sdk';
+
+// Export server state management
+export { setServerPort, getServerPort, getServerInfo } from './state.ts';

package/src/routes/auth.ts

@@ -529,7 +529,10 @@ export function registerAuthRoutes(app: Hono) {
 			if (!sessionId || !copilotDeviceSessions.has(sessionId)) {
 				return c.json({ error: 'Session expired or invalid' }, 400);
 			}
-			const session = copilotDeviceSessions.get(sessionId)!;
+			const session = copilotDeviceSessions.get(sessionId);
+			if (!session) {
+				return c.json({ error: 'Session expired or invalid' }, 400);
+			}
 			const result = await pollForCopilotTokenOnce(session.deviceCode);
 			if (result.status === 'complete') {
 				copilotDeviceSessions.delete(sessionId);

package/src/routes/files.ts

@@ -52,12 +52,7 @@ async function listFilesWithRg(
 	const rgBin = await resolveBinary('rg');
 
 	return new Promise((resolve) => {
-		const args = [
-			'--files',
-			'--hidden',
-			'--glob', '!.git/',
-			'--sort', 'path',
-		];
+		const args = ['--files', '--hidden', '--glob', '!.git/', '--sort', 'path'];
 
 		const proc = spawn(rgBin, args, { cwd: projectRoot });
 		let stdout = '';
@@ -73,7 +68,10 @@ async function listFilesWithRg(
 
 		proc.on('close', (code) => {
 			if (code !== 0 && code !== 1) {
-				logger.warn('rg --files failed, falling back', { stderr } as Record<string, unknown>);
+				logger.warn('rg --files failed, falling back', { stderr } as Record<
+					string,
+					unknown
+				>);
 				resolve({ files: [], truncated: false });
 				return;
 			}
@@ -196,7 +194,10 @@ async function traverseDirectory(
 			}
 		}
 	} catch (err) {
-		logger.warn(`Failed to read directory ${dir}:`, err as Record<string, unknown>);
+		logger.warn(
+			`Failed to read directory ${dir}:`,
+			err as Record<string, unknown>,
+		);
 	}
 
 	return { files: collected, truncated: false };

package/src/routes/root.ts

@@ -1,5 +1,12 @@
 import type { Hono } from 'hono';
+import { getServerInfo } from '../state.ts';
 
 export function registerRootRoutes(app: Hono) {
 	app.get('/', (c) => c.text('otto server running'));
+
+	app.get('/v1/server/info', (c) => {
+		return c.json({
+			...getServerInfo(),
+		});
+	});
 }

package/src/routes/setu.ts

@@ -19,7 +19,8 @@ import {
 	type TopupMethod,
 } from '../runtime/topup/manager.ts';
 
-const SETU_BASE_URL = process.env.SETU_BASE_URL || 'https://api.setu.ottocode.io';
+const SETU_BASE_URL =
+	process.env.SETU_BASE_URL || 'https://api.setu.ottocode.io';
 
 function getSetuBaseUrl(): string {
 	return SETU_BASE_URL.endsWith('/')

package/src/routes/tunnel.ts

@@ -0,0 +1,238 @@
+import type { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import {
+	OttoTunnel,
+	isTunnelBinaryInstalled,
+	generateQRCode,
+	killStaleTunnels,
+	logger,
+} from '@ottocode/sdk';
+import { getServerPort } from '../state.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;
+
+export function registerTunnelRoutes(app: Hono) {
+	app.get('/v1/tunnel/status', async (c) => {
+		const binaryInstalled = await isTunnelBinaryInstalled();
+
+		return c.json({
+			status: tunnelStatus,
+			url: tunnelUrl,
+			error: tunnelError,
+			binaryInstalled,
+			isRunning: activeTunnel?.isRunning ?? false,
+		});
+	});
+
+	app.post('/v1/tunnel/start', 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;
+			}
+
+			logger.debug('Starting tunnel on port:', port);
+
+			// 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;
+				logger.debug('Tunnel progress:', 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);
+		}
+	});
+
+	app.post('/v1/tunnel/register', 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;
+
+			logger.debug('External tunnel registered:', url);
+
+			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);
+		}
+	});
+
+	app.post('/v1/tunnel/stop', 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);
+		}
+	});
+
+	app.get('/v1/tunnel/qr', 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);
+		}
+	});
+
+	app.get('/v1/tunnel/stream', async (c) => {
+		return streamSSE(c, 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/runtime/stream/error-handler.ts

@@ -52,7 +52,7 @@ export function createErrorHandler(
 			'';
 
 		// Also check error message for the exact fiat selection message
-		const errorMessage =
+		const _errorMessage =
 			(errObj?.message as string) ??
 			((errObj?.error as Record<string, unknown>)?.message as string) ??
 			((

package/src/state.ts

@@ -0,0 +1,18 @@
+/**
+ * Server state - tracks runtime information like the server's port
+ * This is the single source of truth for server configuration
+ */
+
+let serverPort: number | null = null;
+
+export function setServerPort(port: number): void {
+	serverPort = port;
+}
+
+export function getServerPort(): number | null {
+	return serverPort;
+}
+
+export function getServerInfo(): { port: number | null } {
+	return { port: serverPort };
+}