@agi-cli/server 0.1.89 → 0.1.90

package/package.json

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

package/src/index.ts

@@ -1,6 +1,8 @@
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
 import type { ProviderId, AuthInfo } from '@agi-cli/sdk';
+import { TerminalManager } from '@agi-cli/sdk';
+import { setTerminalManager } from '@agi-cli/sdk';
 import { registerRootRoutes } from './routes/root.ts';
 import { registerOpenApiRoute } from './routes/openapi.ts';
 import { registerSessionsRoutes } from './routes/sessions.ts';
@@ -10,8 +12,12 @@ import { registerAskRoutes } from './routes/ask.ts';
 import { registerConfigRoutes } from './routes/config/index.ts';
 import { registerFilesRoutes } from './routes/files.ts';
 import { registerGitRoutes } from './routes/git/index.ts';
+import { registerTerminalsRoutes } from './routes/terminals.ts';
 import type { AgentConfigEntry } from './runtime/agent-registry.ts';
 
+const globalTerminalManager = new TerminalManager();
+setTerminalManager(globalTerminalManager);
+
 function initApp() {
 	const app = new Hono();
 
@@ -55,6 +61,7 @@ function initApp() {
 	registerConfigRoutes(app);
 	registerFilesRoutes(app);
 	registerGitRoutes(app);
+	registerTerminalsRoutes(app, globalTerminalManager);
 
 	return app;
 }
@@ -119,6 +126,7 @@ export function createStandaloneApp(_config?: StandaloneAppConfig) {
 	registerConfigRoutes(honoApp);
 	registerFilesRoutes(honoApp);
 	registerGitRoutes(honoApp);
+	registerTerminalsRoutes(honoApp, globalTerminalManager);
 
 	return honoApp;
 }
@@ -211,6 +219,7 @@ export function createEmbeddedApp(config: EmbeddedAppConfig = {}) {
 	registerConfigRoutes(honoApp);
 	registerFilesRoutes(honoApp);
 	registerGitRoutes(honoApp);
+	registerTerminalsRoutes(honoApp, globalTerminalManager);
 
 	return honoApp;
 }

package/src/openapi/paths/terminals.ts

@@ -0,0 +1,226 @@
+export const terminalsPath = {
+	'/v1/terminals': {
+		get: {
+			operationId: 'getTerminals',
+			summary: 'List all terminals',
+			description: 'Get a list of all active terminal sessions',
+			responses: {
+				'200': {
+					description: 'List of terminals',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									terminals: {
+										type: 'array',
+										items: {
+											$ref: '#/components/schemas/Terminal',
+										},
+									},
+									count: {
+										type: 'integer',
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		post: {
+			operationId: 'postTerminals',
+			summary: 'Create a new terminal',
+			description: 'Spawn a new terminal process',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							required: ['command', 'purpose'],
+							properties: {
+								command: {
+									type: 'string',
+									description: 'Command to execute',
+								},
+								args: {
+									type: 'array',
+									items: { type: 'string' },
+									description: 'Command arguments',
+								},
+								purpose: {
+									type: 'string',
+									description: 'Description of terminal purpose',
+								},
+								cwd: {
+									type: 'string',
+									description: 'Working directory',
+								},
+								title: {
+									type: 'string',
+									description: 'Terminal title',
+								},
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'Terminal created',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									terminalId: { type: 'string' },
+									pid: { type: 'integer' },
+									purpose: { type: 'string' },
+									command: { type: 'string' },
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+	'/v1/terminals/{id}': {
+		get: {
+			operationId: 'getTerminalsById',
+			summary: 'Get terminal details',
+			description: 'Get information about a specific terminal',
+			parameters: [
+				{
+					name: 'id',
+					in: 'path',
+					required: true,
+					schema: { type: 'string' },
+				},
+			],
+			responses: {
+				'200': {
+					description: 'Terminal details',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									terminal: {
+										$ref: '#/components/schemas/Terminal',
+									},
+								},
+							},
+						},
+					},
+				},
+				'404': {
+					description: 'Terminal not found',
+				},
+			},
+		},
+		delete: {
+			operationId: 'deleteTerminalsById',
+			summary: 'Kill terminal',
+			description: 'Terminate a running terminal process',
+			parameters: [
+				{
+					name: 'id',
+					in: 'path',
+					required: true,
+					schema: { type: 'string' },
+				},
+			],
+			responses: {
+				'200': {
+					description: 'Terminal killed',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: { type: 'boolean' },
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+	'/v1/terminals/{id}/output': {
+		get: {
+			operationId: 'getTerminalsByIdOutput',
+			summary: 'Stream terminal output',
+			description: 'Get real-time terminal output via SSE',
+			parameters: [
+				{
+					name: 'id',
+					in: 'path',
+					required: true,
+					schema: { type: 'string' },
+				},
+			],
+			responses: {
+				'200': {
+					description: 'SSE stream of terminal output',
+					content: {
+						'text/event-stream': {
+							schema: {
+								type: 'string',
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+	'/v1/terminals/{id}/input': {
+		post: {
+			operationId: 'postTerminalsByIdInput',
+			summary: 'Send input to terminal',
+			description: 'Write data to terminal stdin',
+			parameters: [
+				{
+					name: 'id',
+					in: 'path',
+					required: true,
+					schema: { type: 'string' },
+				},
+			],
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							required: ['input'],
+							properties: {
+								input: {
+									type: 'string',
+									description: 'Input to send to terminal',
+								},
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'Input sent',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: { type: 'boolean' },
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+	},
+};

package/src/openapi/schemas.ts

@@ -290,4 +290,30 @@ export const schemas = {
 		},
 		required: ['hash', 'message', 'filesChanged', 'insertions', 'deletions'],
 	},
+	Terminal: {
+		type: 'object',
+		properties: {
+			id: { type: 'string' },
+			pid: { type: 'integer' },
+			command: { type: 'string' },
+			args: {
+				type: 'array',
+				items: { type: 'string' },
+			},
+			cwd: { type: 'string' },
+			purpose: { type: 'string' },
+			createdBy: {
+				type: 'string',
+				enum: ['user', 'llm'],
+			},
+			title: { type: 'string' },
+			status: {
+				type: 'string',
+				enum: ['running', 'exited'],
+			},
+			exitCode: { type: 'integer' },
+			createdAt: { type: 'string', format: 'date-time' },
+			uptime: { type: 'integer' },
+		},
+	},
 } as const;

package/src/openapi/spec.ts

@@ -7,6 +7,8 @@ import { sessionsPaths } from './paths/sessions';
 import { streamPaths } from './paths/stream';
 import { schemas } from './schemas';
 
+import { terminalsPath } from './paths/terminals';
+
 export function getOpenAPISpec() {
 	const spec = {
 		openapi: '3.0.3',
@@ -24,6 +26,7 @@ export function getOpenAPISpec() {
 			{ name: 'config' },
 			{ name: 'files' },
 			{ name: 'git' },
+			{ name: 'terminals' },
 		],
 		paths: {
 			...askPaths,
@@ -33,6 +36,7 @@ export function getOpenAPISpec() {
 			...configPaths,
 			...filesPaths,
 			...gitPaths,
+			...terminalsPath,
 		},
 		components: {
 			schemas,

package/src/presets.ts

@@ -19,6 +19,7 @@ export const BUILTIN_AGENTS = {
 			'bash',
 			'update_plan',
 			'grep',
+			'terminal',
 			'git_status',
 			'git_diff',
 			'ripgrep',
@@ -50,6 +51,7 @@ export const BUILTIN_AGENTS = {
 			'tree',
 			'bash',
 			'ripgrep',
+			'terminal',
 			'websearch',
 			'update_plan',
 			'progress_update',
@@ -64,6 +66,7 @@ export const BUILTIN_TOOLS = [
 	'ls',
 	'tree',
 	'bash',
+	'terminal',
 	'grep',
 	'ripgrep',
 	'git_status',

package/src/routes/terminals.ts

@@ -0,0 +1,201 @@
+import type { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import type { TerminalManager } from '@agi-cli/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 {
+			console.log('[API] POST /v1/terminals called');
+			const body = await c.req.json();
+			console.log('[API] Request body:', 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();
+
+			console.log('[API] Creating terminal with:', {
+				command: resolvedCommand,
+				args,
+				purpose,
+				cwd: resolvedCwd,
+			});
+
+			const terminal = terminalManager.create({
+				command: resolvedCommand,
+				args: args || [],
+				purpose,
+				cwd: resolvedCwd,
+				createdBy: 'user',
+				title,
+			});
+
+			console.log('[API] Terminal created successfully:', terminal.id);
+
+			return c.json({
+				terminalId: terminal.id,
+				pid: terminal.pid,
+				purpose: terminal.purpose,
+				command: terminal.command,
+			});
+		} catch (error) {
+			console.error('[API] Error creating terminal:', error);
+			console.error(
+				'[API] Error stack:',
+				error instanceof Error ? error.stack : 'No stack',
+			);
+			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');
+		console.log('[SSE] Client connecting to terminal:', id);
+		const terminal = terminalManager.get(id);
+
+		if (!terminal) {
+			console.error('[SSE] Terminal not found:', id);
+			return c.json({ error: 'Terminal not found' }, 404);
+		}
+
+		return streamSSE(c, async (stream) => {
+			console.log('[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();
+				console.log('[SSE] Sending history, 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) {
+					console.error('[SSE] Error writing event:', error);
+				}
+			};
+
+			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() {
+				console.log('[SSE] Client disconnected:', 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);
+		}
+	});
+}

package/src/runtime/agent-registry.ts

@@ -122,6 +122,7 @@ const defaultToolExtras: Record<string, string[]> = {
 		'glob',
 		'ripgrep',
 		'git_status',
+		'terminal',
 		'apply_patch',
 		'websearch',
 	],

package/src/runtime/message-service.ts

@@ -327,7 +327,8 @@ async function touchSessionLastActive(args: {
 		await db
 			.update(sessions)
 			.set({ updatedAt: Date.now() })
-			.where(eq(sessions.id, sessionId));
+			.where(eq(sessions.id, sessionId))
+			.run();
 	} catch (err) {
 		debugLog('[touchSessionLastActive] Error:', err);
 	}

package/src/runtime/prompt.ts

@@ -11,6 +11,7 @@ import ANTHROPIC_SPOOF_PROMPT from '@agi-cli/sdk/prompts/providers/anthropicSpoo
 	type: 'text',
 };
 
+import { getTerminalManager } from '@agi-cli/sdk';
 export async function composeSystemPrompt(options: {
 	provider: string;
 	model?: string;
@@ -72,6 +73,15 @@ export async function composeSystemPrompt(options: {
 		parts.push(userContextBlock);
 	}
 
+	// Add terminal context if available
+	const terminalManager = getTerminalManager();
+	if (terminalManager) {
+		const terminalContext = terminalManager.getContext();
+		if (terminalContext) {
+			parts.push(terminalContext);
+		}
+	}
+
 	const composed = parts.filter(Boolean).join('\n\n').trim();
 	if (composed) return composed;