@ottocode/server 0.1.260 → 0.1.261

package/src/routes/config/debug.ts

@@ -1,39 +1,168 @@
 import type { Hono } from 'hono';
 import { logger, readDebugConfig, writeDebugConfig } from '@ottocode/sdk';
 import { serializeError } from '../../runtime/errors/api-error.ts';
+import { openApiRoute } from '../../openapi/route.ts';
 
 export function registerDebugConfigRoute(app: Hono) {
-	app.get('/v1/config/debug', async (c) => {
-		try {
-			const debug = await readDebugConfig();
-			return c.json(debug);
-		} catch (error) {
-			logger.error('Failed to load debug config', error);
-			const errorResponse = serializeError(error);
-			return c.json(errorResponse, errorResponse.error.status || 500);
-		}
-	});
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/config/debug',
+			tags: ['config'],
+			operationId: 'getDebugConfig',
+			summary: 'Get debug configuration',
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									enabled: {
+										type: 'boolean',
+									},
+									scopes: {
+										type: 'array',
+										items: {
+											type: 'string',
+										},
+									},
+									logPath: {
+										type: 'string',
+									},
+									sessionsDir: {
+										type: 'string',
+									},
+									debugDir: {
+										type: 'string',
+									},
+								},
+								required: [
+									'enabled',
+									'scopes',
+									'logPath',
+									'sessionsDir',
+									'debugDir',
+								],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const debug = await readDebugConfig();
+				return c.json(debug);
+			} catch (error) {
+				logger.error('Failed to load debug config', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
 
-	app.patch('/v1/config/debug', async (c) => {
-		try {
-			const body = await c.req.json<{
-				enabled?: boolean;
-				scopes?: string[];
-			}>();
+	openApiRoute(
+		app,
+		{
+			method: 'patch',
+			path: '/v1/config/debug',
+			tags: ['config'],
+			operationId: 'updateDebugConfig',
+			summary: 'Update debug configuration',
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								enabled: {
+									type: 'boolean',
+								},
+								scopes: {
+									type: 'array',
+									items: {
+										type: 'string',
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: {
+										type: 'boolean',
+									},
+									debug: {
+										type: 'object',
+										properties: {
+											enabled: {
+												type: 'boolean',
+											},
+											scopes: {
+												type: 'array',
+												items: {
+													type: 'string',
+												},
+											},
+											logPath: {
+												type: 'string',
+											},
+											sessionsDir: {
+												type: 'string',
+											},
+											debugDir: {
+												type: 'string',
+											},
+										},
+										required: [
+											'enabled',
+											'scopes',
+											'logPath',
+											'sessionsDir',
+											'debugDir',
+										],
+									},
+								},
+								required: ['success', 'debug'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const body = await c.req.json<{
+					enabled?: boolean;
+					scopes?: string[];
+				}>();
 
-			await writeDebugConfig({
-				enabled: body.enabled,
-				scopes: Array.isArray(body.scopes)
-					? body.scopes.map((scope) => scope.trim()).filter(Boolean)
-					: body.scopes,
-			});
+				await writeDebugConfig({
+					enabled: body.enabled,
+					scopes: Array.isArray(body.scopes)
+						? body.scopes.map((scope) => scope.trim()).filter(Boolean)
+						: body.scopes,
+				});
 
-			const debug = await readDebugConfig();
-			return c.json({ success: true, debug });
-		} catch (error) {
-			logger.error('Failed to update debug config', error);
-			const errorResponse = serializeError(error);
-			return c.json(errorResponse, errorResponse.error.status || 500);
-		}
-	});
+				const debug = await readDebugConfig();
+				return c.json({ success: true, debug });
+			} catch (error) {
+				logger.error('Failed to update debug config', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
 }

package/src/routes/config/defaults.ts

@@ -8,77 +8,195 @@ import {
 } from '@ottocode/sdk';
 import { logger } from '@ottocode/sdk';
 import { serializeError } from '../../runtime/errors/api-error.ts';
+import { openApiRoute } from '../../openapi/route.ts';
 
 export function registerDefaultsRoute(app: Hono) {
-	app.patch('/v1/config/defaults', async (c) => {
-		try {
-			const projectRoot = c.req.query('project') || process.cwd();
-			const cfg = await loadConfig(projectRoot);
-			const body = await c.req.json<{
-				agent?: string;
-				provider?: string;
-				model?: string;
-				toolApproval?: 'auto' | 'dangerous' | 'all' | 'yolo';
-				guidedMode?: boolean;
-				reasoningText?: boolean;
-				reasoningLevel?: ReasoningLevel;
-				theme?: string;
-				fullWidthContent?: boolean;
-				autoCompactThresholdTokens?: number | null;
-				scope?: 'global' | 'local';
-			}>();
+	openApiRoute(
+		app,
+		{
+			method: 'patch',
+			path: '/v1/config/defaults',
+			tags: ['config'],
+			operationId: 'updateDefaults',
+			summary: 'Update default configuration',
+			description: 'Update the default agent, provider, and/or model',
+			parameters: [
+				{
+					in: 'query',
+					name: 'project',
+					required: false,
+					schema: {
+						type: 'string',
+					},
+					description:
+						'Project root override (defaults to current working directory).',
+				},
+			],
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								agent: {
+									type: 'string',
+								},
+								provider: {
+									type: 'string',
+								},
+								model: {
+									type: 'string',
+								},
+								fullWidthContent: {
+									type: 'boolean',
+								},
+								autoCompactThresholdTokens: {
+									type: 'integer',
+									nullable: true,
+								},
+								reasoningText: {
+									type: 'boolean',
+								},
+								reasoningLevel: {
+									type: 'string',
+									enum: ['minimal', 'low', 'medium', 'high', 'max', 'xhigh'],
+								},
+								scope: {
+									type: 'string',
+									enum: ['global', 'local'],
+									default: 'local',
+								},
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									success: {
+										type: 'boolean',
+									},
+									defaults: {
+										type: 'object',
+										properties: {
+											agent: {
+												type: 'string',
+											},
+											provider: {
+												type: 'string',
+											},
+											model: {
+												type: 'string',
+											},
+											fullWidthContent: {
+												type: 'boolean',
+											},
+											autoCompactThresholdTokens: {
+												type: 'integer',
+												nullable: true,
+											},
+											reasoningText: {
+												type: 'boolean',
+											},
+											reasoningLevel: {
+												type: 'string',
+												enum: [
+													'minimal',
+													'low',
+													'medium',
+													'high',
+													'max',
+													'xhigh',
+												],
+											},
+										},
+										required: ['agent', 'provider', 'model'],
+									},
+								},
+								required: ['success', 'defaults'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const projectRoot = c.req.query('project') || process.cwd();
+				const cfg = await loadConfig(projectRoot);
+				const body = await c.req.json<{
+					agent?: string;
+					provider?: string;
+					model?: string;
+					toolApproval?: 'auto' | 'dangerous' | 'all' | 'yolo';
+					guidedMode?: boolean;
+					reasoningText?: boolean;
+					reasoningLevel?: ReasoningLevel;
+					theme?: string;
+					fullWidthContent?: boolean;
+					autoCompactThresholdTokens?: number | null;
+					scope?: 'global' | 'local';
+				}>();
 
-			const scope = body.scope || 'global';
-			const updates: Partial<{
-				agent: string;
-				provider: ProviderId;
-				model: string;
-				toolApproval: 'auto' | 'dangerous' | 'all' | 'yolo';
-				guidedMode: boolean;
-				reasoningText: boolean;
-				reasoningLevel: ReasoningLevel;
-				theme: string;
-				fullWidthContent: boolean;
-				autoCompactThresholdTokens: number | null;
-			}> = {};
+				const scope = body.scope || 'global';
+				const updates: Partial<{
+					agent: string;
+					provider: ProviderId;
+					model: string;
+					toolApproval: 'auto' | 'dangerous' | 'all' | 'yolo';
+					guidedMode: boolean;
+					reasoningText: boolean;
+					reasoningLevel: ReasoningLevel;
+					theme: string;
+					fullWidthContent: boolean;
+					autoCompactThresholdTokens: number | null;
+				}> = {};
 
-			if (body.agent) updates.agent = body.agent;
-			if (body.provider) {
-				if (!hasConfiguredProvider(cfg, body.provider)) {
-					return c.json({ error: `Invalid provider: ${body.provider}` }, 400);
+				if (body.agent) updates.agent = body.agent;
+				if (body.provider) {
+					if (!hasConfiguredProvider(cfg, body.provider)) {
+						return c.json({ error: `Invalid provider: ${body.provider}` }, 400);
+					}
+					updates.provider = body.provider as ProviderId;
 				}
-				updates.provider = body.provider as ProviderId;
-			}
-			if (body.model) updates.model = body.model;
-			if (body.toolApproval) updates.toolApproval = body.toolApproval;
-			if (body.guidedMode !== undefined) updates.guidedMode = body.guidedMode;
-			if (body.reasoningText !== undefined)
-				updates.reasoningText = body.reasoningText;
-			if (body.reasoningLevel) updates.reasoningLevel = body.reasoningLevel;
-			if (body.theme) updates.theme = body.theme;
-			if (body.fullWidthContent !== undefined)
-				updates.fullWidthContent = body.fullWidthContent;
-			if (body.autoCompactThresholdTokens !== undefined) {
-				const threshold = body.autoCompactThresholdTokens;
-				if (threshold === null) {
-					updates.autoCompactThresholdTokens = null;
-				} else if (Number.isFinite(threshold) && threshold > 0) {
-					updates.autoCompactThresholdTokens = Math.floor(threshold);
+				if (body.model) updates.model = body.model;
+				if (body.toolApproval) updates.toolApproval = body.toolApproval;
+				if (body.guidedMode !== undefined) updates.guidedMode = body.guidedMode;
+				if (body.reasoningText !== undefined)
+					updates.reasoningText = body.reasoningText;
+				if (body.reasoningLevel) updates.reasoningLevel = body.reasoningLevel;
+				if (body.theme) updates.theme = body.theme;
+				if (body.fullWidthContent !== undefined)
+					updates.fullWidthContent = body.fullWidthContent;
+				if (body.autoCompactThresholdTokens !== undefined) {
+					const threshold = body.autoCompactThresholdTokens;
+					if (threshold === null) {
+						updates.autoCompactThresholdTokens = null;
+					} else if (Number.isFinite(threshold) && threshold > 0) {
+						updates.autoCompactThresholdTokens = Math.floor(threshold);
+					}
 				}
-			}
 
-			await setConfig(scope, updates, projectRoot);
+				await setConfig(scope, updates, projectRoot);
 
-			const nextCfg = await loadConfig(projectRoot);
+				const nextCfg = await loadConfig(projectRoot);
 
-			return c.json({
-				success: true,
-				defaults: nextCfg.defaults,
-			});
-		} catch (error) {
-			logger.error('Failed to update defaults', error);
-			const errorResponse = serializeError(error);
-			return c.json(errorResponse, errorResponse.error.status || 500);
-		}
-	});
+				return c.json({
+					success: true,
+					defaults: nextCfg.defaults,
+				});
+			} catch (error) {
+				logger.error('Failed to update defaults', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
 }

package/src/routes/config/main.ts

@@ -9,86 +9,122 @@ import {
 	getDefault,
 	getProviderDetails,
 } from './utils.ts';
+import { openApiRoute } from '../../openapi/route.ts';
 
 export function registerMainConfigRoute(app: Hono) {
-	app.get('/v1/config', async (c) => {
-		try {
-			const projectRoot = c.req.query('project') || process.cwd();
-			const embeddedConfig = (
-				c as unknown as {
-					get: (key: 'embeddedConfig') => EmbeddedAppConfig | undefined;
-				}
-			).get('embeddedConfig');
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/config',
+			tags: ['config'],
+			operationId: 'getConfig',
+			summary: 'Get full configuration',
+			description: 'Returns agents, authorized providers, models, and defaults',
+			parameters: [
+				{
+					in: 'query',
+					name: 'project',
+					required: false,
+					schema: {
+						type: 'string',
+					},
+					description:
+						'Project root override (defaults to current working directory).',
+				},
+			],
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								$ref: '#/components/schemas/Config',
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			try {
+				const projectRoot = c.req.query('project') || process.cwd();
+				const embeddedConfig = (
+					c as unknown as {
+						get: (key: 'embeddedConfig') => EmbeddedAppConfig | undefined;
+					}
+				).get('embeddedConfig');
 
-			const cfg = await loadConfig(projectRoot);
+				const cfg = await loadConfig(projectRoot);
 
-			let allAgents: string[];
+				let allAgents: string[];
 
-			if (embeddedConfig?.agents) {
-				const embeddedAgents = Object.keys(embeddedConfig.agents);
-				const fileAgents = await discoverAllAgents(cfg.projectRoot);
-				allAgents = Array.from(
-					new Set([...embeddedAgents, ...fileAgents]),
-				).sort();
-			} else {
-				allAgents = await discoverAllAgents(cfg.projectRoot);
-			}
+				if (embeddedConfig?.agents) {
+					const embeddedAgents = Object.keys(embeddedConfig.agents);
+					const fileAgents = await discoverAllAgents(cfg.projectRoot);
+					allAgents = Array.from(
+						new Set([...embeddedAgents, ...fileAgents]),
+					).sort();
+				} else {
+					allAgents = await discoverAllAgents(cfg.projectRoot);
+				}
 
-			const authorizedProviders = await getAuthorizedProviders(
-				embeddedConfig,
-				cfg,
-			);
-			const providerDetails = await getProviderDetails(embeddedConfig, cfg);
+				const authorizedProviders = await getAuthorizedProviders(
+					embeddedConfig,
+					cfg,
+				);
+				const providerDetails = await getProviderDetails(embeddedConfig, cfg);
 
-			const defaults = {
-				agent: getDefault(
-					embeddedConfig?.agent,
-					embeddedConfig?.defaults?.agent,
-					cfg.defaults.agent,
-				),
-				provider: getDefault(
-					embeddedConfig?.provider,
-					embeddedConfig?.defaults?.provider,
-					cfg.defaults.provider,
-				),
-				model: getDefault(
-					embeddedConfig?.model,
-					embeddedConfig?.defaults?.model,
-					cfg.defaults.model,
-				),
-				toolApproval: getDefault(
-					undefined,
-					embeddedConfig?.defaults?.toolApproval,
-					cfg.defaults.toolApproval,
-				) as 'auto' | 'dangerous' | 'all' | 'yolo',
-				guidedMode: cfg.defaults.guidedMode ?? false,
-				reasoningText: cfg.defaults.reasoningText ?? true,
-				reasoningLevel: cfg.defaults.reasoningLevel ?? 'high',
-				theme: cfg.defaults.theme,
-				fullWidthContent:
-					getDefault(
+				const defaults = {
+					agent: getDefault(
+						embeddedConfig?.agent,
+						embeddedConfig?.defaults?.agent,
+						cfg.defaults.agent,
+					),
+					provider: getDefault(
+						embeddedConfig?.provider,
+						embeddedConfig?.defaults?.provider,
+						cfg.defaults.provider,
+					),
+					model: getDefault(
+						embeddedConfig?.model,
+						embeddedConfig?.defaults?.model,
+						cfg.defaults.model,
+					),
+					toolApproval: getDefault(
 						undefined,
-						embeddedConfig?.defaults?.fullWidthContent,
-						cfg.defaults.fullWidthContent,
-					) ?? false,
-				autoCompactThresholdTokens:
-					getDefault(
-						undefined,
-						embeddedConfig?.defaults?.autoCompactThresholdTokens,
-						cfg.defaults.autoCompactThresholdTokens,
-					) ?? null,
-			};
+						embeddedConfig?.defaults?.toolApproval,
+						cfg.defaults.toolApproval,
+					) as 'auto' | 'dangerous' | 'all' | 'yolo',
+					guidedMode: cfg.defaults.guidedMode ?? false,
+					reasoningText: cfg.defaults.reasoningText ?? true,
+					reasoningLevel: cfg.defaults.reasoningLevel ?? 'high',
+					theme: cfg.defaults.theme,
+					fullWidthContent:
+						getDefault(
+							undefined,
+							embeddedConfig?.defaults?.fullWidthContent,
+							cfg.defaults.fullWidthContent,
+						) ?? false,
+					autoCompactThresholdTokens:
+						getDefault(
+							undefined,
+							embeddedConfig?.defaults?.autoCompactThresholdTokens,
+							cfg.defaults.autoCompactThresholdTokens,
+						) ?? null,
+				};
 
-			return c.json({
-				agents: allAgents,
-				providers: authorizedProviders,
-				providerDetails,
-				defaults,
-			});
-		} catch (error) {
-			logger.error('Failed to load config', error);
-			const errorResponse = serializeError(error);
-			return c.json(errorResponse, errorResponse.error.status || 500);
-		}
-	});
+				return c.json({
+					agents: allAgents,
+					providers: authorizedProviders,
+					providerDetails,
+					defaults,
+				});
+			} catch (error) {
+				logger.error('Failed to load config', error);
+				const errorResponse = serializeError(error);
+				return c.json(errorResponse, errorResponse.error.status || 500);
+			}
+		},
+	);
 }