@ottocode/server 0.1.173

package/src/routes/setu.ts

@@ -0,0 +1,346 @@
+import type { Hono } from 'hono';
+import {
+	fetchSetuBalance,
+	getPublicKeyFromPrivate,
+	getAuth,
+	loadConfig,
+	fetchSolanaUsdcBalance,
+} from '@ottocode/sdk';
+import { logger } from '@ottocode/sdk';
+import { serializeError } from '../runtime/errors/api-error.ts';
+import { Keypair } from '@solana/web3.js';
+import bs58 from 'bs58';
+import nacl from 'tweetnacl';
+import { publish } from '../events/bus.ts';
+import {
+	resolveTopupMethodSelection,
+	rejectTopupSelection,
+	getPendingTopup,
+	type TopupMethod,
+} from '../runtime/topup/manager.ts';
+
+const SETU_BASE_URL = process.env.SETU_BASE_URL || 'https://api.setu.nitish.sh';
+
+function getSetuBaseUrl(): string {
+	return SETU_BASE_URL.endsWith('/')
+		? SETU_BASE_URL.slice(0, -1)
+		: SETU_BASE_URL;
+}
+
+async function getSetuPrivateKey(): Promise<string | null> {
+	if (process.env.SETU_PRIVATE_KEY) {
+		return process.env.SETU_PRIVATE_KEY;
+	}
+
+	try {
+		const cfg = await loadConfig(process.cwd());
+		const auth = await getAuth('setu', cfg.projectRoot);
+		if (auth?.type === 'wallet' && auth.secret) {
+			return auth.secret;
+		}
+	} catch {}
+
+	return null;
+}
+
+function signNonce(nonce: string, privateKeyBytes: Uint8Array): string {
+	const data = new TextEncoder().encode(nonce);
+	const signature = nacl.sign.detached(data, privateKeyBytes);
+	return bs58.encode(signature);
+}
+
+function buildWalletHeaders(privateKey: string): Record<string, string> {
+	const privateKeyBytes = bs58.decode(privateKey);
+	const keypair = Keypair.fromSecretKey(privateKeyBytes);
+	const walletAddress = keypair.publicKey.toBase58();
+	const nonce = Date.now().toString();
+	const signature = signNonce(nonce, privateKeyBytes);
+	return {
+		'x-wallet-address': walletAddress,
+		'x-wallet-nonce': nonce,
+		'x-wallet-signature': signature,
+	};
+}
+
+export function registerSetuRoutes(app: Hono) {
+	app.get('/v1/setu/balance', async (c) => {
+		try {
+			const privateKey = await getSetuPrivateKey();
+			if (!privateKey) {
+				return c.json({ error: 'Setu wallet not configured' }, 401);
+			}
+
+			const balance = await fetchSetuBalance({ privateKey });
+			if (!balance) {
+				return c.json({ error: 'Failed to fetch balance from Setu' }, 502);
+			}
+
+			return c.json(balance);
+		} catch (error) {
+			logger.error('Failed to fetch Setu balance', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/setu/wallet', async (c) => {
+		try {
+			const privateKey = await getSetuPrivateKey();
+			if (!privateKey) {
+				return c.json(
+					{ error: 'Setu wallet not configured', configured: false },
+					200,
+				);
+			}
+
+			const publicKey = getPublicKeyFromPrivate(privateKey);
+			if (!publicKey) {
+				return c.json({ error: 'Invalid private key', configured: false }, 200);
+			}
+
+			return c.json({
+				configured: true,
+				publicKey,
+			});
+		} catch (error) {
+			logger.error('Failed to get Setu wallet info', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/setu/usdc-balance', async (c) => {
+		try {
+			const privateKey = await getSetuPrivateKey();
+			if (!privateKey) {
+				return c.json({ error: 'Setu wallet not configured' }, 401);
+			}
+
+			const network =
+				(c.req.query('network') as 'mainnet' | 'devnet') || 'mainnet';
+
+			const balance = await fetchSolanaUsdcBalance({ privateKey }, network);
+			if (!balance) {
+				return c.json(
+					{ error: 'Failed to fetch USDC balance from Solana' },
+					502,
+				);
+			}
+
+			return c.json(balance);
+		} catch (error) {
+			logger.error('Failed to fetch USDC balance', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/setu/topup/polar/estimate', async (c) => {
+		try {
+			const amount = c.req.query('amount');
+			if (!amount) {
+				return c.json({ error: 'Missing amount parameter' }, 400);
+			}
+
+			const baseUrl = getSetuBaseUrl();
+			const response = await fetch(
+				`${baseUrl}/v1/topup/polar/estimate?amount=${amount}`,
+				{
+					method: 'GET',
+					headers: { 'Content-Type': 'application/json' },
+				},
+			);
+
+			const data = await response.json();
+			if (!response.ok) {
+				return c.json(data, response.status as 400 | 500);
+			}
+
+			return c.json(data);
+		} catch (error) {
+			logger.error('Failed to get Polar estimate', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.post('/v1/setu/topup/polar', async (c) => {
+		try {
+			const privateKey = await getSetuPrivateKey();
+			if (!privateKey) {
+				return c.json({ error: 'Setu wallet not configured' }, 401);
+			}
+
+			const body = await c.req.json();
+			const { amount, successUrl } = body as {
+				amount: number;
+				successUrl: string;
+			};
+
+			if (!amount || typeof amount !== 'number') {
+				return c.json({ error: 'Invalid amount' }, 400);
+			}
+
+			if (!successUrl || typeof successUrl !== 'string') {
+				return c.json({ error: 'Missing successUrl' }, 400);
+			}
+
+			const walletHeaders = buildWalletHeaders(privateKey);
+			const baseUrl = getSetuBaseUrl();
+
+			const response = await fetch(`${baseUrl}/v1/topup/polar`, {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					...walletHeaders,
+				},
+				body: JSON.stringify({ amount, successUrl }),
+			});
+
+			const data = await response.json();
+			if (!response.ok) {
+				return c.json(data, response.status as 400 | 500);
+			}
+
+			return c.json(data);
+		} catch (error) {
+			logger.error('Failed to create Polar checkout', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.post('/v1/setu/topup/select', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { sessionId, method } = body as {
+				sessionId: string;
+				method: TopupMethod;
+			};
+
+			if (!sessionId || typeof sessionId !== 'string') {
+				return c.json({ error: 'Missing sessionId' }, 400);
+			}
+
+			if (!method || !['crypto', 'fiat'].includes(method)) {
+				return c.json(
+					{ error: 'Invalid method, must be "crypto" or "fiat"' },
+					400,
+				);
+			}
+
+			const resolved = resolveTopupMethodSelection(sessionId, method);
+			if (!resolved) {
+				return c.json(
+					{ error: 'No pending topup request found for this session' },
+					404,
+				);
+			}
+
+			publish({
+				type: 'setu.topup.method_selected',
+				sessionId,
+				payload: { method },
+			});
+
+			return c.json({ success: true, method });
+		} catch (error) {
+			logger.error('Failed to select topup method', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.post('/v1/setu/topup/cancel', async (c) => {
+		try {
+			const body = await c.req.json();
+			const { sessionId, reason } = body as {
+				sessionId: string;
+				reason?: string;
+			};
+
+			if (!sessionId || typeof sessionId !== 'string') {
+				return c.json({ error: 'Missing sessionId' }, 400);
+			}
+
+			const rejected = rejectTopupSelection(
+				sessionId,
+				reason ?? 'User cancelled',
+			);
+			if (!rejected) {
+				return c.json(
+					{ error: 'No pending topup request found for this session' },
+					404,
+				);
+			}
+
+			publish({
+				type: 'setu.topup.cancelled',
+				sessionId,
+				payload: { reason: reason ?? 'User cancelled' },
+			});
+
+			return c.json({ success: true });
+		} catch (error) {
+			logger.error('Failed to cancel topup', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/setu/topup/pending', async (c) => {
+		try {
+			const sessionId = c.req.query('sessionId');
+			if (!sessionId) {
+				return c.json({ error: 'Missing sessionId parameter' }, 400);
+			}
+
+			const pending = getPendingTopup(sessionId);
+			if (!pending) {
+				return c.json({ hasPending: false });
+			}
+
+			return c.json({
+				hasPending: true,
+				sessionId: pending.sessionId,
+				messageId: pending.messageId,
+				amountUsd: pending.amountUsd,
+				currentBalance: pending.currentBalance,
+				createdAt: pending.createdAt,
+			});
+		} catch (error) {
+			logger.error('Failed to get pending topup', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/setu/topup/polar/status', async (c) => {
+		try {
+			const checkoutId = c.req.query('checkoutId');
+			if (!checkoutId) {
+				return c.json({ error: 'Missing checkoutId parameter' }, 400);
+			}
+
+			const baseUrl = getSetuBaseUrl();
+			const response = await fetch(
+				`${baseUrl}/v1/topup/polar/status?checkoutId=${checkoutId}`,
+				{
+					method: 'GET',
+					headers: { 'Content-Type': 'application/json' },
+				},
+			);
+
+			const data = await response.json();
+			if (!response.ok) {
+				return c.json(data, response.status as 400 | 500);
+			}
+
+			return c.json(data);
+		} catch (error) {
+			logger.error('Failed to check Polar status', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/terminals.ts

@@ -0,0 +1,227 @@
+import type { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import type { TerminalManager } from '@ottocode/sdk';
+import { logger } from '@ottocode/sdk';
+
+export function registerTerminalsRoutes(
+	app: Hono,
+	terminalManager: TerminalManager,
+) {
+	app.get('/v1/terminals', async (c) => {
+		const terminals = terminalManager.list();
+		return c.json({
+			terminals: terminals.map((t) => t.toJSON()),
+			count: terminals.length,
+		});
+	});
+
+	app.post('/v1/terminals', async (c) => {
+		try {
+			logger.debug('POST /v1/terminals called');
+			const body = await c.req.json();
+			logger.debug('Creating terminal request received', body);
+			const { command, args, purpose, cwd, title } = body;
+
+			if (!command || !purpose) {
+				return c.json({ error: 'command and purpose are required' }, 400);
+			}
+
+			let resolvedCommand = command;
+			if (command === 'bash' || command === 'sh' || command === 'shell') {
+				resolvedCommand = process.env.SHELL || '/bin/bash';
+			}
+			const resolvedCwd = cwd || process.cwd();
+
+			logger.debug('Creating terminal', {
+				command: resolvedCommand,
+				args,
+				purpose,
+				cwd: resolvedCwd,
+			});
+
+			const terminal = terminalManager.create({
+				command: resolvedCommand,
+				args: args || [],
+				purpose,
+				cwd: resolvedCwd,
+				createdBy: 'user',
+				title,
+			});
+
+			logger.debug('Terminal created successfully', { id: terminal.id });
+
+			return c.json({
+				terminalId: terminal.id,
+				pid: terminal.pid,
+				purpose: terminal.purpose,
+				command: terminal.command,
+			});
+		} catch (error) {
+			logger.error('Error creating terminal', error);
+			const message = error instanceof Error ? error.message : String(error);
+			return c.json({ error: message }, 500);
+		}
+	});
+
+	app.get('/v1/terminals/:id', async (c) => {
+		const id = c.req.param('id');
+		const terminal = terminalManager.get(id);
+
+		if (!terminal) {
+			return c.json({ error: 'Terminal not found' }, 404);
+		}
+
+		return c.json({ terminal: terminal.toJSON() });
+	});
+
+	app.get('/v1/terminals/:id/output', async (c) => {
+		const id = c.req.param('id');
+		logger.debug('SSE client connecting to terminal', { id });
+		const terminal = terminalManager.get(id);
+
+		if (!terminal) {
+			logger.debug('SSE terminal not found', { id });
+			return c.json({ error: 'Terminal not found' }, 404);
+		}
+
+		return streamSSE(c, async (stream) => {
+			logger.debug('SSE stream started for terminal', { id });
+			// Send historical buffer first (unless skipHistory is set)
+			const skipHistory = c.req.query('skipHistory') === 'true';
+			if (!skipHistory) {
+				const history = terminal.read();
+				logger.debug('SSE sending terminal history', {
+					id,
+					lines: history.length,
+				});
+				for (const line of history) {
+					await stream.write(
+						`data: ${JSON.stringify({ type: 'data', line })}\n\n`,
+					);
+				}
+			}
+
+			const sendEvent = async (payload: Record<string, unknown>) => {
+				try {
+					await stream.write(`data: ${JSON.stringify(payload)}\n\n`);
+				} catch (error) {
+					logger.error('SSE error writing event', error, { id });
+				}
+			};
+
+			const onData = (line: string) => {
+				void sendEvent({ type: 'data', line });
+			};
+
+			let resolveStream: (() => void) | null = null;
+			let finished = false;
+
+			function cleanup() {
+				terminal.removeDataListener(onData);
+				terminal.removeExitListener(onExit);
+				c.req.raw.signal.removeEventListener('abort', onAbort);
+			}
+
+			function finish() {
+				if (finished) {
+					return;
+				}
+				finished = true;
+				cleanup();
+				resolveStream?.();
+			}
+
+			async function onExit(exitCode: number) {
+				try {
+					await sendEvent({ type: 'exit', exitCode });
+				} finally {
+					stream.close();
+					finish();
+				}
+			}
+
+			function onAbort() {
+				logger.debug('SSE client disconnected from terminal', {
+					id: terminal.id,
+				});
+				stream.close();
+				finish();
+			}
+
+			terminal.onData(onData);
+			terminal.onExit(onExit);
+
+			c.req.raw.signal.addEventListener('abort', onAbort, { once: true });
+
+			const waitForClose = new Promise<void>((resolve) => {
+				resolveStream = resolve;
+			});
+
+			if (terminal.status === 'exited') {
+				void onExit(terminal.exitCode ?? 0);
+			}
+
+			await waitForClose;
+		});
+	});
+
+	app.post('/v1/terminals/:id/input', async (c) => {
+		const id = c.req.param('id');
+		const terminal = terminalManager.get(id);
+
+		if (!terminal) {
+			return c.json({ error: 'Terminal not found' }, 404);
+		}
+
+		try {
+			const body = await c.req.json();
+			const { input } = body;
+
+			if (!input) {
+				return c.json({ error: 'input is required' }, 400);
+			}
+
+			terminal.write(input);
+			return c.json({ success: true });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return c.json({ error: message }, 500);
+		}
+	});
+
+	app.delete('/v1/terminals/:id', async (c) => {
+		const id = c.req.param('id');
+
+		try {
+			await terminalManager.kill(id);
+			return c.json({ success: true });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return c.json({ error: message }, 500);
+		}
+	});
+
+	app.post('/v1/terminals/:id/resize', async (c) => {
+		const id = c.req.param('id');
+		const terminal = terminalManager.get(id);
+
+		if (!terminal) {
+			return c.json({ error: 'Terminal not found' }, 404);
+		}
+
+		try {
+			const body = await c.req.json();
+			const { cols, rows } = body;
+
+			if (!cols || !rows || cols < 1 || rows < 1) {
+				return c.json({ error: 'valid cols and rows are required' }, 400);
+			}
+
+			terminal.resize(cols, rows);
+			return c.json({ success: true });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			return c.json({ error: message }, 500);
+		}
+	});
+}