@agi-cli/server 0.1.55 → 0.1.57

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agi-cli/server",
-	"version": "0.1.55",
+	"version": "0.1.57",
 	"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.55",
-		"@agi-cli/database": "0.1.55",
+		"@agi-cli/sdk": "0.1.57",
+		"@agi-cli/database": "0.1.57",
 		"drizzle-orm": "^0.44.5",
 		"hono": "^4.9.9"
 	},

package/src/index.ts

@@ -1,6 +1,6 @@
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
-import type { ProviderId } from '@agi-cli/sdk';
+import type { ProviderId, AuthInfo } from '@agi-cli/sdk';
 import { registerRootRoutes } from './routes/root.ts';
 import { registerOpenApiRoute } from './routes/openapi.ts';
 import { registerSessionsRoutes } from './routes/sessions.ts';
@@ -9,6 +9,7 @@ import { registerSessionStreamRoute } from './routes/session-stream.ts';
 import { registerAskRoutes } from './routes/ask.ts';
 import { registerConfigRoutes } from './routes/config.ts';
 import { registerGitRoutes } from './routes/git.ts';
+import type { AgentConfigEntry } from './runtime/agent-registry.ts';
 
 function initApp() {
 	const app = new Hono();
@@ -117,16 +118,48 @@ export function createStandaloneApp(_config?: StandaloneAppConfig) {
 	return honoApp;
 }
 
+/**
+ * Embedded app configuration with hybrid fallback:
+ * 1. Injected config (highest priority)
+ * 2. Environment variables
+ * 3. auth.json/config.json files (fallback)
+ *
+ * All fields are optional - if not provided, falls back to files/env
+ */
 export type EmbeddedAppConfig = {
-	provider: ProviderId;
-	model: string;
-	apiKey: string;
+	/** Primary provider (optional - falls back to config.json or env) */
+	provider?: ProviderId;
+	/** Primary model (optional - falls back to config.json) */
+	model?: string;
+	/** Primary API key (optional - falls back to env vars or auth.json) */
+	apiKey?: string;
+	/** Default agent (optional - falls back to config.json) */
 	agent?: string;
+	/** Multi-provider auth (optional - falls back to auth.json) */
+	auth?: Record<string, { apiKey: string } | AuthInfo>;
+	/** Custom agents (optional - falls back to .agi/agents/) */
+	agents?: Record<
+		string,
+		Omit<AgentConfigEntry, 'tools'> & { tools?: readonly string[] | string[] }
+	>;
+	/** Default settings (optional - falls back to config.json) */
+	defaults?: {
+		provider?: ProviderId;
+		model?: string;
+		agent?: string;
+	};
 };
 
-export function createEmbeddedApp(_config: EmbeddedAppConfig) {
+export function createEmbeddedApp(config: EmbeddedAppConfig = {}) {
 	const honoApp = new Hono();
 
+	// Store injected config in Hono context for routes to access
+	// Config can be empty - routes will fall back to files/env
+	honoApp.use('*', async (c, next) => {
+		c.set('embeddedConfig', config);
+		await next();
+	});
+
 	// Enable CORS for all localhost ports (for web UI on random ports)
 	honoApp.use(
 		'*',
@@ -163,6 +196,7 @@ export function createEmbeddedApp(_config: EmbeddedAppConfig) {
 	registerSessionMessagesRoutes(honoApp);
 	registerSessionStreamRoute(honoApp);
 	registerAskRoutes(honoApp);
+	registerConfigRoutes(honoApp);
 	registerGitRoutes(honoApp);
 
 	return honoApp;
@@ -181,3 +215,9 @@ export {
 } from './runtime/ask-service.ts';
 export { registerSessionsRoutes } from './routes/sessions.ts';
 export { registerAskRoutes } from './routes/ask.ts';
+export {
+	BUILTIN_AGENTS,
+	BUILTIN_TOOLS,
+	type BuiltinAgent,
+	type BuiltinTool,
+} from './presets.ts';

package/src/presets.ts

@@ -0,0 +1,81 @@
+import AGENT_BUILD from '@agi-cli/sdk/prompts/agents/build.txt' with {
+	type: 'text',
+};
+import AGENT_PLAN from '@agi-cli/sdk/prompts/agents/plan.txt' with {
+	type: 'text',
+};
+import AGENT_GENERAL from '@agi-cli/sdk/prompts/agents/general.txt' with {
+	type: 'text',
+};
+
+export const BUILTIN_AGENTS = {
+	build: {
+		prompt: AGENT_BUILD,
+		tools: [
+			'read',
+			'write',
+			'ls',
+			'tree',
+			'bash',
+			'update_plan',
+			'grep',
+			'git_status',
+			'git_diff',
+			'ripgrep',
+			'apply_patch',
+			'websearch',
+			'progress_update',
+			'finish',
+		] as string[],
+	},
+	plan: {
+		prompt: AGENT_PLAN,
+		tools: [
+			'read',
+			'ls',
+			'tree',
+			'ripgrep',
+			'update_plan',
+			'websearch',
+			'progress_update',
+			'finish',
+		] as string[],
+	},
+	general: {
+		prompt: AGENT_GENERAL,
+		tools: [
+			'read',
+			'write',
+			'ls',
+			'tree',
+			'bash',
+			'ripgrep',
+			'websearch',
+			'update_plan',
+			'progress_update',
+			'finish',
+		] as string[],
+	},
+};
+
+export const BUILTIN_TOOLS = [
+	'read',
+	'write',
+	'ls',
+	'tree',
+	'bash',
+	'grep',
+	'ripgrep',
+	'git_status',
+	'git_diff',
+	'git_commit',
+	'apply_patch',
+	'update_plan',
+	'edit',
+	'websearch',
+	'progress_update',
+	'finish',
+] as const;
+
+export type BuiltinAgent = keyof typeof BUILTIN_AGENTS;
+export type BuiltinTool = (typeof BUILTIN_TOOLS)[number];

package/src/routes/ask.ts

@@ -5,6 +5,7 @@ import type {
 	InjectableCredentials,
 } from '../runtime/ask-service.ts';
 import { AskServiceError, handleAskRequest } from '../runtime/ask-service.ts';
+import type { EmbeddedAppConfig } from '../index.ts';
 
 export function registerAskRoutes(app: Hono) {
 	app.post('/v1/ask', async (c) => {
@@ -18,6 +19,57 @@ export function registerAskRoutes(app: Hono) {
 			return c.json({ error: 'Prompt is required.' }, 400);
 		}
 
+		const embeddedConfig = c.get('embeddedConfig') as
+			| EmbeddedAppConfig
+			| undefined;
+
+		// Hybrid fallback: Use embedded config if provided, otherwise fall back to files/env
+		let injectableConfig: InjectableConfig | undefined;
+		let injectableCredentials: InjectableCredentials | undefined;
+		let skipFileConfig = false;
+
+		if (embeddedConfig && Object.keys(embeddedConfig).length > 0) {
+			// Has embedded config - build injectable config from it
+			const hasDefaults =
+				embeddedConfig.defaults ||
+				embeddedConfig.provider ||
+				embeddedConfig.model ||
+				embeddedConfig.agent;
+
+			if (hasDefaults) {
+				injectableConfig = {
+					defaults: embeddedConfig.defaults || {
+						agent: embeddedConfig.agent,
+						provider: embeddedConfig.provider,
+						model: embeddedConfig.model,
+					},
+				};
+			}
+
+			// Convert embedded auth to injectable credentials
+			const hasAuth = embeddedConfig.auth || embeddedConfig.apiKey;
+			if (hasAuth) {
+				if (embeddedConfig.auth) {
+					injectableCredentials = {};
+					for (const [provider, auth] of Object.entries(embeddedConfig.auth)) {
+						if ('apiKey' in auth) {
+							injectableCredentials[provider] = { apiKey: auth.apiKey };
+						} else {
+							injectableCredentials[provider] = auth;
+						}
+					}
+				} else if (embeddedConfig.apiKey && embeddedConfig.provider) {
+					injectableCredentials = {
+						[embeddedConfig.provider]: { apiKey: embeddedConfig.apiKey },
+					};
+				}
+
+				// Only skip file config if we have credentials injected
+				skipFileConfig = true;
+			}
+			// If no auth provided, skipFileConfig stays false -> will use ensureProviderEnv -> auth.json fallback
+		}
+
 		const request: AskServerRequest = {
 			projectRoot,
 			prompt,
@@ -29,17 +81,20 @@ export function registerAskRoutes(app: Hono) {
 			last: Boolean(body.last),
 			jsonMode: Boolean(body.jsonMode),
 			skipFileConfig:
-				typeof body.skipFileConfig === 'boolean'
+				skipFileConfig ||
+				(typeof body.skipFileConfig === 'boolean'
 					? body.skipFileConfig
-					: undefined,
+					: false),
 			config:
-				body.config && typeof body.config === 'object'
+				injectableConfig ||
+				(body.config && typeof body.config === 'object'
 					? (body.config as InjectableConfig)
-					: undefined,
+					: undefined),
 			credentials:
-				body.credentials && typeof body.credentials === 'object'
+				injectableCredentials ||
+				(body.credentials && typeof body.credentials === 'object'
 					? (body.credentials as InjectableCredentials)
-					: undefined,
+					: undefined),
 			agentPrompt:
 				typeof body.agentPrompt === 'string' ? body.agentPrompt : undefined,
 			tools: Array.isArray(body.tools) ? body.tools : undefined,

package/src/routes/config.ts

@@ -3,6 +3,7 @@ import { loadConfig } from '@agi-cli/sdk';
 import { catalog, type ProviderId, isProviderAuthorized } from '@agi-cli/sdk';
 import { readdir } from 'node:fs/promises';
 import { join, basename } from 'node:path';
+import type { EmbeddedAppConfig } from '../index.ts';
 
 export function registerConfigRoutes(app: Hono) {
 	// Get working directory info
@@ -18,8 +19,14 @@ export function registerConfigRoutes(app: Hono) {
 	// Get full config (agents, providers, models, defaults)
 	app.get('/v1/config', async (c) => {
 		const projectRoot = c.req.query('project') || process.cwd();
+		const embeddedConfig = c.get('embeddedConfig') as
+			| EmbeddedAppConfig
+			| undefined;
+
+		// Always load file config as base/fallback
 		const cfg = await loadConfig(projectRoot);
 
+		// Hybrid mode: Merge embedded config with file config
 		const builtInAgents = ['general', 'build', 'plan'];
 		let customAgents: string[] = [];
 
@@ -31,25 +38,71 @@ export function registerConfigRoutes(app: Hono) {
 				.map((f) => f.replace('.txt', ''));
 		} catch {}
 
+		// Agents: Embedded custom agents + file-based agents
+		const fileAgents = [...builtInAgents, ...customAgents];
+		const embeddedAgents = embeddedConfig?.agents
+			? Object.keys(embeddedConfig.agents)
+			: [];
+		const allAgents = Array.from(new Set([...embeddedAgents, ...fileAgents]));
+
+		// Providers: Check both embedded and file-based auth
 		const allProviders = Object.keys(catalog) as ProviderId[];
 		const authorizedProviders: ProviderId[] = [];
 
 		for (const provider of allProviders) {
-			const authorized = await isProviderAuthorized(cfg, provider);
-			if (authorized) {
+			// Check embedded auth first
+			const hasEmbeddedAuth =
+				embeddedConfig?.provider === provider ||
+				(embeddedConfig?.auth && provider in embeddedConfig.auth);
+
+			// Fallback to file-based auth
+			const hasFileAuth = await isProviderAuthorized(cfg, provider);
+
+			if (hasEmbeddedAuth || hasFileAuth) {
 				authorizedProviders.push(provider);
 			}
 		}
 
+		// Defaults: Embedded overrides file config
+		const defaults = {
+			agent:
+				embeddedConfig?.defaults?.agent ||
+				embeddedConfig?.agent ||
+				cfg.defaults.agent,
+			provider:
+				embeddedConfig?.defaults?.provider ||
+				embeddedConfig?.provider ||
+				cfg.defaults.provider,
+			model:
+				embeddedConfig?.defaults?.model ||
+				embeddedConfig?.model ||
+				cfg.defaults.model,
+		};
+
 		return c.json({
-			agents: [...builtInAgents, ...customAgents],
+			agents: allAgents,
 			providers: authorizedProviders,
-			defaults: cfg.defaults,
+			defaults,
 		});
 	});
 
 	// Get available agents
 	app.get('/v1/config/agents', async (c) => {
+		const embeddedConfig = c.get('embeddedConfig') as
+			| EmbeddedAppConfig
+			| undefined;
+
+		if (embeddedConfig) {
+			const agents = embeddedConfig.agents
+				? Object.keys(embeddedConfig.agents)
+				: ['general', 'build', 'plan'];
+			return c.json({
+				agents,
+				default:
+					embeddedConfig.agent || embeddedConfig.defaults?.agent || 'general',
+			});
+		}
+
 		const projectRoot = c.req.query('project') || process.cwd();
 		const cfg = await loadConfig(projectRoot);
 
@@ -76,6 +129,21 @@ export function registerConfigRoutes(app: Hono) {
 
 	// Get available providers (only authorized ones)
 	app.get('/v1/config/providers', async (c) => {
+		const embeddedConfig = c.get('embeddedConfig') as
+			| EmbeddedAppConfig
+			| undefined;
+
+		if (embeddedConfig) {
+			const providers = embeddedConfig.auth
+				? (Object.keys(embeddedConfig.auth) as ProviderId[])
+				: [embeddedConfig.provider];
+
+			return c.json({
+				providers,
+				default: embeddedConfig.defaults?.provider || embeddedConfig.provider,
+			});
+		}
+
 		const projectRoot = c.req.query('project') || process.cwd();
 		const cfg = await loadConfig(projectRoot);
 
@@ -97,9 +165,39 @@ export function registerConfigRoutes(app: Hono) {
 
 	// Get available models for a provider
 	app.get('/v1/config/providers/:provider/models', async (c) => {
+		const embeddedConfig = c.get('embeddedConfig') as
+			| EmbeddedAppConfig
+			| undefined;
+		const provider = c.req.param('provider') as ProviderId;
+
+		if (embeddedConfig) {
+			// Check if provider is authorized in embedded mode
+			const hasAuth =
+				embeddedConfig.provider === provider ||
+				(embeddedConfig.auth && provider in embeddedConfig.auth);
+
+			if (!hasAuth) {
+				return c.json({ error: 'Provider not authorized' }, 403);
+			}
+
+			const providerCatalog = catalog[provider];
+			if (!providerCatalog) {
+				return c.json({ error: 'Provider not found' }, 404);
+			}
+
+			return c.json({
+				models: providerCatalog.models.map((m) => ({
+					id: m.id,
+					label: m.label || m.id,
+					toolCall: m.toolCall,
+					reasoning: m.reasoning,
+				})),
+				default: embeddedConfig.model || embeddedConfig.defaults?.model,
+			});
+		}
+
 		const projectRoot = c.req.query('project') || process.cwd();
 		const cfg = await loadConfig(projectRoot);
-		const provider = c.req.param('provider') as ProviderId;
 
 		const authorized = await isProviderAuthorized(cfg, provider);
 		if (!authorized) {

package/src/routes/git.ts

@@ -90,8 +90,18 @@ function detectLanguage(filePath: string): string {
 	return languageMap[ext] || 'plaintext';
 }
 
+// Helper function to check if path is in a git repository
+async function isGitRepository(path: string): Promise<boolean> {
+	try {
+		await execFileAsync('git', ['rev-parse', '--git-dir'], { cwd: path });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
 // Helper function to find git root directory
-async function findGitRoot(startPath: string): Promise<string> {
+async function findGitRoot(startPath: string): Promise<string | null> {
 	try {
 		const { stdout } = await execFileAsync(
 			'git',
@@ -99,10 +109,28 @@ async function findGitRoot(startPath: string): Promise<string> {
 			{ cwd: startPath },
 		);
 		return stdout.trim();
-	} catch (_error) {
-		// If not in a git repository, return the original path
-		return startPath;
+	} catch {
+		return null;
+	}
+}
+
+// Helper to validate git repo and get root
+async function validateAndGetGitRoot(
+	path: string,
+): Promise<{ gitRoot: string } | { error: string; code: string }> {
+	if (!(await isGitRepository(path))) {
+		return { error: 'Not a git repository', code: 'NOT_A_GIT_REPO' };
+	}
+
+	const gitRoot = await findGitRoot(path);
+	if (!gitRoot) {
+		return {
+			error: 'Could not find git repository root',
+			code: 'GIT_ROOT_NOT_FOUND',
+		};
 	}
+
+	return { gitRoot };
 }
 
 // Git status parsing
@@ -231,7 +259,16 @@ export function registerGitRoutes(app: Hono) {
 			});
 
 			const requestedPath = query.project || process.cwd();
-			const gitRoot = await findGitRoot(requestedPath);
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
 
 			// Get git status
 			const { stdout: statusOutput } = await execFileAsync(
@@ -290,12 +327,12 @@ export function registerGitRoutes(app: Hono) {
 				data: status,
 			});
 		} catch (error) {
-			console.error('Git status error:', error);
+			const errorMessage =
+				error instanceof Error ? error.message : 'Failed to get git status';
 			return c.json(
 				{
 					status: 'error',
-					error:
-						error instanceof Error ? error.message : 'Failed to get git status',
+					error: errorMessage,
 				},
 				500,
 			);
@@ -312,7 +349,16 @@ export function registerGitRoutes(app: Hono) {
 			});
 
 			const requestedPath = query.project || process.cwd();
-			const gitRoot = await findGitRoot(requestedPath);
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
 			const file = query.file;
 			const staged = query.staged;
 
@@ -349,7 +395,6 @@ export function registerGitRoutes(app: Hono) {
 					insertions = lines.length;
 					deletions = 0;
 				} catch (err) {
-					console.error('Error reading new file:', err);
 					diffOutput = `Error reading file: ${err instanceof Error ? err.message : 'Unknown error'}`;
 				}
 			} else {
@@ -403,15 +448,9 @@ export function registerGitRoutes(app: Hono) {
 				},
 			});
 		} catch (error) {
-			console.error('Git diff error:', error);
-			return c.json(
-				{
-					status: 'error',
-					error:
-						error instanceof Error ? error.message : 'Failed to get git diff',
-				},
-				500,
-			);
+			const errorMessage =
+				error instanceof Error ? error.message : 'Failed to get git diff';
+			return c.json({ status: 'error', error: errorMessage }, 500);
 		}
 	});
 
@@ -504,7 +543,6 @@ Generate only the commit message, nothing else.`;
 				},
 			});
 		} catch (error) {
-			console.error('Generate commit message error:', error);
 			return c.json(
 				{
 					status: 'error',
@@ -538,7 +576,6 @@ Generate only the commit message, nothing else.`;
 				},
 			});
 		} catch (error) {
-			console.error('Git stage error:', error);
 			return c.json(
 				{
 					status: 'error',
@@ -579,7 +616,6 @@ Generate only the commit message, nothing else.`;
 				},
 			});
 		} catch (error) {
-			console.error('Git unstage error:', error);
 			return c.json(
 				{
 					status: 'error',
@@ -656,7 +692,6 @@ Generate only the commit message, nothing else.`;
 				},
 			});
 		} catch (error) {
-			console.error('Git commit error:', error);
 			return c.json(
 				{
 					status: 'error',
@@ -675,7 +710,16 @@ Generate only the commit message, nothing else.`;
 			});
 
 			const requestedPath = query.project || process.cwd();
-			const gitRoot = await findGitRoot(requestedPath);
+
+			const validation = await validateAndGetGitRoot(requestedPath);
+			if ('error' in validation) {
+				return c.json(
+					{ status: 'error', error: validation.error, code: validation.code },
+					400,
+				);
+			}
+
+			const { gitRoot } = validation;
 
 			const branch = await getCurrentBranch(gitRoot);
 			const { ahead, behind } = await getAheadBehind(gitRoot);
@@ -720,7 +764,6 @@ Generate only the commit message, nothing else.`;
 				},
 			});
 		} catch (error) {
-			console.error('Git branch error:', error);
 			return c.json(
 				{
 					status: 'error',

package/src/routes/session-stream.ts

@@ -24,10 +24,15 @@ export function registerSessionStreamRoute(app: Hono) {
 				const unsubscribe = subscribe(sessionId, write);
 				// Initial ping
 				controller.enqueue(encoder.encode(`: connected ${sessionId}\n\n`));
+				// Heartbeat every 5s to prevent idle timeout (Bun default is 10s)
 				const hb = setInterval(() => {
-					// Comment line as heartbeat to keep connection alive
-					controller.enqueue(encoder.encode(`: hb ${Date.now()}\n\n`));
-				}, 15000);
+					try {
+						controller.enqueue(encoder.encode(`: hb ${Date.now()}\n\n`));
+					} catch {
+						// Controller might be closed
+						clearInterval(hb);
+					}
+				}, 5000);
 
 				const signal = c.req.raw?.signal as AbortSignal | undefined;
 				signal?.addEventListener('abort', () => {