@ottocode/server 0.1.200 → 0.1.201

package/package.json

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

package/src/index.ts

@@ -20,6 +20,7 @@ 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 { registerMCPRoutes } from './routes/mcp.ts';
 import { registerProviderUsageRoutes } from './routes/provider-usage.ts';
 import type { AgentConfigEntry } from './runtime/agent/registry.ts';
 
@@ -77,6 +78,7 @@ function initApp() {
 	registerSetuRoutes(app);
 	registerAuthRoutes(app);
 	registerTunnelRoutes(app);
+	registerMCPRoutes(app);
 	registerProviderUsageRoutes(app);
 
 	return app;
@@ -150,6 +152,7 @@ export function createStandaloneApp(_config?: StandaloneAppConfig) {
 	registerSetuRoutes(honoApp);
 	registerAuthRoutes(honoApp);
 	registerTunnelRoutes(honoApp);
+	registerMCPRoutes(honoApp);
 	registerProviderUsageRoutes(honoApp);
 
 	return honoApp;
@@ -251,6 +254,7 @@ export function createEmbeddedApp(config: EmbeddedAppConfig = {}) {
 	registerSetuRoutes(honoApp);
 	registerAuthRoutes(honoApp);
 	registerTunnelRoutes(honoApp);
+	registerMCPRoutes(honoApp);
 	registerProviderUsageRoutes(honoApp);
 
 	return honoApp;

package/src/presets.ts

@@ -18,7 +18,6 @@ export const BUILTIN_AGENTS = {
 			'tree',
 			'bash',
 			'update_todos',
-			'grep',
 			'terminal',
 			'git_status',
 			'git_diff',
@@ -67,7 +66,6 @@ export const BUILTIN_TOOLS = [
 	'tree',
 	'bash',
 	'terminal',
-	'grep',
 	'ripgrep',
 	'git_status',
 	'git_diff',

package/src/routes/mcp.ts

@@ -0,0 +1,278 @@
+import type { Hono } from 'hono';
+import {
+	getMCPManager,
+	initializeMCP,
+	loadMCPConfig,
+	getGlobalConfigDir,
+	MCPClientWrapper,
+	addMCPServerToConfig,
+	removeMCPServerFromConfig,
+} from '@ottocode/sdk';
+
+export function registerMCPRoutes(app: Hono) {
+	app.get('/v1/mcp/servers', async (c) => {
+		const projectRoot = process.cwd();
+		const config = await loadMCPConfig(projectRoot, getGlobalConfigDir());
+		const manager = getMCPManager();
+		const statuses = manager ? await manager.getStatusAsync() : [];
+
+		const servers = config.servers.map((s) => {
+			const status = statuses.find((st) => st.name === s.name);
+			return {
+				name: s.name,
+				transport: s.transport ?? 'stdio',
+				command: s.command,
+				args: s.args ?? [],
+				url: s.url,
+				disabled: s.disabled ?? false,
+				connected: status?.connected ?? false,
+				tools: status?.tools ?? [],
+				authRequired: status?.authRequired ?? false,
+				authenticated: status?.authenticated ?? false,
+			};
+		});
+
+		return c.json({ servers });
+	});
+
+	app.post('/v1/mcp/servers', async (c) => {
+		const projectRoot = process.cwd();
+		const body = await c.req.json();
+
+		const { name, transport, command, args, env, url, headers, oauth } = body;
+		if (!name) {
+			return c.json({ ok: false, error: 'name is required' }, 400);
+		}
+
+		const t = transport ?? 'stdio';
+		if (t === 'stdio' && !command) {
+			return c.json(
+				{ ok: false, error: 'command is required for stdio transport' },
+				400,
+			);
+		}
+		if ((t === 'http' || t === 'sse') && !url) {
+			return c.json(
+				{ ok: false, error: 'url is required for http/sse transport' },
+				400,
+			);
+		}
+
+		const serverConfig = {
+			name: String(name),
+			transport: t,
+			...(command ? { command: String(command) } : {}),
+			...(Array.isArray(args) ? { args: args.map(String) } : {}),
+			...(env && typeof env === 'object' ? { env } : {}),
+			...(url ? { url: String(url) } : {}),
+			...(headers && typeof headers === 'object' ? { headers } : {}),
+			...(oauth && typeof oauth === 'object' ? { oauth } : {}),
+		};
+
+		try {
+			await addMCPServerToConfig(projectRoot, serverConfig);
+			return c.json({ ok: true, server: serverConfig });
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return c.json({ ok: false, error: msg }, 500);
+		}
+	});
+
+	app.delete('/v1/mcp/servers/:name', async (c) => {
+		const name = c.req.param('name');
+		const projectRoot = process.cwd();
+
+		try {
+			const manager = getMCPManager();
+			if (manager) {
+				await manager.stopServer(name);
+			}
+
+			const removed = await removeMCPServerFromConfig(projectRoot, name);
+			if (!removed) {
+				return c.json({ ok: false, error: `Server "${name}" not found` }, 404);
+			}
+			return c.json({ ok: true, name });
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return c.json({ ok: false, error: msg }, 500);
+		}
+	});
+
+	app.post('/v1/mcp/servers/:name/start', async (c) => {
+		const name = c.req.param('name');
+		const projectRoot = process.cwd();
+		const config = await loadMCPConfig(projectRoot, getGlobalConfigDir());
+		const serverConfig = config.servers.find((s) => s.name === name);
+
+		if (!serverConfig) {
+			return c.json({ ok: false, error: `Server "${name}" not found` }, 404);
+		}
+
+		try {
+			let manager = getMCPManager();
+			if (!manager) {
+				manager = await initializeMCP({ servers: [] });
+			}
+			await manager.restartServer(serverConfig);
+			const status = (await manager.getStatusAsync()).find(
+				(s) => s.name === name,
+			);
+			return c.json({
+				ok: true,
+				name,
+				connected: status?.connected ?? false,
+				tools: status?.tools ?? [],
+				authRequired: status?.authRequired ?? false,
+				authUrl: manager.getAuthUrl(name),
+			});
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return c.json({ ok: false, error: msg }, 500);
+		}
+	});
+
+	app.post('/v1/mcp/servers/:name/stop', async (c) => {
+		const name = c.req.param('name');
+		const manager = getMCPManager();
+
+		if (!manager) {
+			return c.json({ ok: false, error: 'No MCP manager active' }, 400);
+		}
+
+		try {
+			await manager.stopServer(name);
+			return c.json({ ok: true, name, connected: false });
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return c.json({ ok: false, error: msg }, 500);
+		}
+	});
+
+	app.post('/v1/mcp/servers/:name/auth', async (c) => {
+		const name = c.req.param('name');
+		const projectRoot = process.cwd();
+		const config = await loadMCPConfig(projectRoot, getGlobalConfigDir());
+		const serverConfig = config.servers.find((s) => s.name === name);
+
+		if (!serverConfig) {
+			return c.json({ ok: false, error: `Server "${name}" not found` }, 404);
+		}
+
+		try {
+			let manager = getMCPManager();
+			if (!manager) {
+				manager = await initializeMCP({ servers: [] });
+			}
+
+			const authUrl = await manager.initiateAuth(serverConfig);
+			if (authUrl) {
+				return c.json({ ok: true, authUrl, name });
+			}
+			return c.json({
+				ok: true,
+				name,
+				message: 'Already authenticated or no auth required',
+			});
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return c.json({ ok: false, error: msg }, 500);
+		}
+	});
+
+	app.post('/v1/mcp/servers/:name/auth/callback', async (c) => {
+		const name = c.req.param('name');
+		const body = await c.req.json();
+		const { code } = body;
+
+		if (!code) {
+			return c.json({ ok: false, error: 'code is required' }, 400);
+		}
+
+		const manager = getMCPManager();
+		if (!manager) {
+			return c.json({ ok: false, error: 'No MCP manager active' }, 400);
+		}
+
+		try {
+			const success = await manager.completeAuth(name, String(code));
+			if (success) {
+				const status = (await manager.getStatusAsync()).find(
+					(s) => s.name === name,
+				);
+				return c.json({
+					ok: true,
+					name,
+					connected: status?.connected ?? false,
+					tools: status?.tools ?? [],
+				});
+			}
+			return c.json({ ok: false, error: 'Auth completion failed' }, 500);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return c.json({ ok: false, error: msg }, 500);
+		}
+	});
+
+	app.get('/v1/mcp/servers/:name/auth/status', async (c) => {
+		const name = c.req.param('name');
+		const manager = getMCPManager();
+
+		if (!manager) {
+			return c.json({ authenticated: false });
+		}
+
+		try {
+			const status = await manager.getAuthStatus(name);
+			return c.json(status);
+		} catch {
+			return c.json({ authenticated: false });
+		}
+	});
+
+	app.delete('/v1/mcp/servers/:name/auth', async (c) => {
+		const name = c.req.param('name');
+		const manager = getMCPManager();
+
+		if (!manager) {
+			return c.json({ ok: false, error: 'No MCP manager active' }, 400);
+		}
+
+		try {
+			await manager.revokeAuth(name);
+			return c.json({ ok: true, name });
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return c.json({ ok: false, error: msg }, 500);
+		}
+	});
+
+	app.post('/v1/mcp/servers/:name/test', async (c) => {
+		const name = c.req.param('name');
+		const projectRoot = process.cwd();
+		const config = await loadMCPConfig(projectRoot, getGlobalConfigDir());
+		const serverConfig = config.servers.find((s) => s.name === name);
+
+		if (!serverConfig) {
+			return c.json({ ok: false, error: `Server "${name}" not found` }, 404);
+		}
+
+		const client = new MCPClientWrapper(serverConfig);
+		try {
+			await client.connect();
+			const tools = await client.listTools();
+			await client.disconnect();
+			return c.json({
+				ok: true,
+				name,
+				tools: tools.map((t) => ({
+					name: t.name,
+					description: t.description,
+				})),
+			});
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			return c.json({ ok: false, error: msg }, 500);
+		}
+	});
+}

package/src/runtime/agent/runner-setup.ts

@@ -160,8 +160,10 @@ export async function setupRunner(opts: RunOpts): Promise<SetupResult> {
 
 	toolsTimer.end({ count: allTools.length });
 	const allowedNames = new Set([...(agentCfg.tools || []), 'finish']);
-	const gated = allTools.filter((tool) => allowedNames.has(tool.name));
-	debugLog(`[tools] ${gated.length} allowed tools`);
+	const gated = allTools.filter(
+		(tool) => allowedNames.has(tool.name) || tool.name.includes('__'),
+	);
+	debugLog(`[tools] ${gated.length} allowed tools (including MCP)`);
 
 	debugLog(`[RUNNER] About to create model with provider: ${opts.provider}`);
 	debugLog(`[RUNNER] About to create model ID: ${opts.model}`);

package/src/runtime/message/tool-history-tracker.ts

@@ -71,7 +71,6 @@ function describeToolResult(info: ToolResultInfo): TargetDescriptor | null {
 		case 'read':
 			return describeRead(info);
 		case 'glob':
-		case 'grep':
 			return describePatternTool(info, toolName);
 		case 'write':
 			return describeWrite(info);

package/src/runtime/tools/mapping.ts

@@ -25,8 +25,7 @@ export const CANONICAL_TO_PASCAL: Record<string, string> = {
 
 	// Search operations
 	glob: 'Glob',
-	ripgrep: 'Grep', // Maps to Grep for Claude Code compatibility
-	grep: 'Grep',
+	ripgrep: 'Grep',
 
 	// Execution
 	bash: 'Bash',