@ottocode/server 0.1.173

package/src/routes/config/agents.ts

@@ -0,0 +1,44 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@ottocode/sdk';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import { logger } from '@ottocode/sdk';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+import { discoverAllAgents, getDefault } from './utils.ts';
+
+export function registerAgentsRoute(app: Hono) {
+	app.get('/v1/config/agents', async (c) => {
+		try {
+			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: getDefault(
+						embeddedConfig.agent,
+						embeddedConfig.defaults?.agent,
+						'general',
+					),
+				});
+			}
+
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+
+			const allAgents = await discoverAllAgents(cfg.projectRoot);
+
+			return c.json({
+				agents: allAgents,
+				default: cfg.defaults.agent,
+			});
+		} catch (error) {
+			logger.error('Failed to get agents', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/cwd.ts

@@ -0,0 +1,21 @@
+import type { Hono } from 'hono';
+import { basename } from 'node:path';
+import { logger } from '@ottocode/sdk';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+
+export function registerCwdRoute(app: Hono) {
+	app.get('/v1/config/cwd', (c) => {
+		try {
+			const cwd = process.cwd();
+			const dirName = basename(cwd);
+			return c.json({
+				cwd,
+				dirName,
+			});
+		} catch (error) {
+			logger.error('Failed to get current working directory', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/defaults.ts

@@ -0,0 +1,45 @@
+import type { Hono } from 'hono';
+import { setConfig, loadConfig } from '@ottocode/sdk';
+import { logger } from '@ottocode/sdk';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+
+export function registerDefaultsRoute(app: Hono) {
+	app.patch('/v1/config/defaults', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const body = await c.req.json<{
+				agent?: string;
+				provider?: string;
+				model?: string;
+				toolApproval?: 'auto' | 'dangerous' | 'all';
+				scope?: 'global' | 'local';
+			}>();
+
+			const scope = body.scope || 'global';
+			const updates: Partial<{
+				agent: string;
+				provider: string;
+				model: string;
+				toolApproval: 'auto' | 'dangerous' | 'all';
+			}> = {};
+
+			if (body.agent) updates.agent = body.agent;
+			if (body.provider) updates.provider = body.provider;
+			if (body.model) updates.model = body.model;
+			if (body.toolApproval) updates.toolApproval = body.toolApproval;
+
+			await setConfig(scope, updates, projectRoot);
+
+			const cfg = await loadConfig(projectRoot);
+
+			return c.json({
+				success: true,
+				defaults: cfg.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/index.ts

@@ -0,0 +1,16 @@
+import type { Hono } from 'hono';
+import { registerCwdRoute } from './cwd.ts';
+import { registerMainConfigRoute } from './main.ts';
+import { registerAgentsRoute } from './agents.ts';
+import { registerProvidersRoute } from './providers.ts';
+import { registerModelsRoutes } from './models.ts';
+import { registerDefaultsRoute } from './defaults.ts';
+
+export function registerConfigRoutes(app: Hono) {
+	registerCwdRoute(app);
+	registerMainConfigRoute(app);
+	registerAgentsRoute(app);
+	registerProvidersRoute(app);
+	registerModelsRoutes(app);
+	registerDefaultsRoute(app);
+}

package/src/routes/config/main.ts

@@ -0,0 +1,73 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@ottocode/sdk';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import { logger } from '@ottocode/sdk';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+import {
+	discoverAllAgents,
+	getAuthorizedProviders,
+	getDefault,
+} from './utils.ts';
+
+export function registerMainConfigRoute(app: Hono) {
+	app.get('/v1/config', async (c) => {
+		try {
+			const projectRoot = c.req.query('project') || process.cwd();
+			const embeddedConfig = c.get('embeddedConfig') as
+				| EmbeddedAppConfig
+				| undefined;
+
+			const cfg = await loadConfig(projectRoot);
+
+			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);
+			}
+
+			const authorizedProviders = await getAuthorizedProviders(
+				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',
+			};
+
+			return c.json({
+				agents: allAgents,
+				providers: authorizedProviders,
+				defaults,
+			});
+		} catch (error) {
+			logger.error('Failed to load config', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/models.ts

@@ -0,0 +1,139 @@
+import type { Hono } from 'hono';
+import {
+	loadConfig,
+	catalog,
+	type ProviderId,
+	filterModelsForAuthType,
+} from '@ottocode/sdk';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import { logger } from '@ottocode/sdk';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+import {
+	isProviderAuthorizedHybrid,
+	getAuthorizedProviders,
+	getDefault,
+	getAuthTypeForProvider,
+} from './utils.ts';
+
+export function registerModelsRoutes(app: Hono) {
+	app.get('/v1/config/providers/:provider/models', async (c) => {
+		try {
+			const embeddedConfig = c.get('embeddedConfig') as
+				| EmbeddedAppConfig
+				| undefined;
+			const provider = c.req.param('provider') as ProviderId;
+
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+
+			const authorized = await isProviderAuthorizedHybrid(
+				embeddedConfig,
+				cfg,
+				provider,
+			);
+
+			if (!authorized) {
+				logger.warn('Provider not authorized', { provider });
+				return c.json({ error: 'Provider not authorized' }, 403);
+			}
+
+			const providerCatalog = catalog[provider];
+			if (!providerCatalog) {
+				logger.warn('Provider not found in catalog', { provider });
+				return c.json({ error: 'Provider not found' }, 404);
+			}
+
+			const authType = await getAuthTypeForProvider(
+				embeddedConfig,
+				provider,
+				projectRoot,
+			);
+			const filteredModels = filterModelsForAuthType(
+				provider,
+				providerCatalog.models,
+				authType,
+			);
+
+			return c.json({
+				models: filteredModels.map((m) => ({
+					id: m.id,
+					label: m.label || m.id,
+					toolCall: m.toolCall,
+					reasoningText: m.reasoningText,
+					vision: m.modalities?.input?.includes('image') ?? false,
+				})),
+				default: getDefault(
+					embeddedConfig?.model,
+					embeddedConfig?.defaults?.model,
+					cfg.defaults.model,
+				),
+			});
+		} catch (error) {
+			logger.error('Failed to get provider models', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+
+	app.get('/v1/config/models', async (c) => {
+		try {
+			const embeddedConfig = c.get('embeddedConfig') as
+				| EmbeddedAppConfig
+				| undefined;
+
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+
+			const authorizedProviders = await getAuthorizedProviders(
+				embeddedConfig,
+				cfg,
+			);
+
+			const modelsMap: Record<
+				string,
+				{
+					label: string;
+					models: Array<{
+						id: string;
+						label: string;
+						toolCall?: boolean;
+						reasoningText?: boolean;
+					}>;
+				}
+			> = {};
+
+			for (const provider of authorizedProviders) {
+				const providerCatalog = catalog[provider];
+				if (providerCatalog) {
+					const authType = await getAuthTypeForProvider(
+						embeddedConfig,
+						provider,
+						projectRoot,
+					);
+					const filteredModels = filterModelsForAuthType(
+						provider,
+						providerCatalog.models,
+						authType,
+					);
+					modelsMap[provider] = {
+						label: providerCatalog.label || provider,
+						authType,
+						models: filteredModels.map((m) => ({
+							id: m.id,
+							label: m.label || m.id,
+							toolCall: m.toolCall,
+							reasoningText: m.reasoningText,
+							vision: m.modalities?.input?.includes('image') ?? false,
+						})),
+					};
+				}
+			}
+
+			return c.json(modelsMap);
+		} catch (error) {
+			logger.error('Failed to get all models', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/providers.ts

@@ -0,0 +1,46 @@
+import type { Hono } from 'hono';
+import { loadConfig } from '@ottocode/sdk';
+import type { ProviderId } from '@ottocode/sdk';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import { logger } from '@ottocode/sdk';
+import { serializeError } from '../../runtime/errors/api-error.ts';
+import { getAuthorizedProviders, getDefault } from './utils.ts';
+
+export function registerProvidersRoute(app: Hono) {
+	app.get('/v1/config/providers', async (c) => {
+		try {
+			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: getDefault(
+						embeddedConfig.provider,
+						embeddedConfig.defaults?.provider,
+						undefined,
+					),
+				});
+			}
+
+			const projectRoot = c.req.query('project') || process.cwd();
+			const cfg = await loadConfig(projectRoot);
+
+			const authorizedProviders = await getAuthorizedProviders(undefined, cfg);
+
+			return c.json({
+				providers: authorizedProviders,
+				default: cfg.defaults.provider,
+			});
+		} catch (error) {
+			logger.error('Failed to get providers', error);
+			const errorResponse = serializeError(error);
+			return c.json(errorResponse, errorResponse.error.status || 500);
+		}
+	});
+}

package/src/routes/config/utils.ts

@@ -0,0 +1,120 @@
+import {
+	catalog,
+	type ProviderId,
+	isProviderAuthorized,
+	getGlobalAgentsDir,
+	getAuth,
+} from '@ottocode/sdk';
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import type { EmbeddedAppConfig } from '../../index.ts';
+import type { OttoConfig } from '@ottocode/sdk';
+import { logger } from '@ottocode/sdk';
+import { loadAgentsConfig } from '../../runtime/agent/registry.ts';
+
+export async function isProviderAuthorizedHybrid(
+	embeddedConfig: EmbeddedAppConfig | undefined,
+	fileConfig: OttoConfig,
+	provider: ProviderId,
+): Promise<boolean> {
+	const hasEmbeddedAuth =
+		embeddedConfig?.provider === provider ||
+		(embeddedConfig?.auth && provider in embeddedConfig.auth);
+
+	if (hasEmbeddedAuth) {
+		return true;
+	}
+
+	return await isProviderAuthorized(fileConfig, provider);
+}
+
+export async function getAuthorizedProviders(
+	embeddedConfig: EmbeddedAppConfig | undefined,
+	fileConfig: OttoConfig,
+): Promise<ProviderId[]> {
+	const allProviders = Object.keys(catalog) as ProviderId[];
+	const authorizedProviders: ProviderId[] = [];
+
+	for (const provider of allProviders) {
+		const authorized = await isProviderAuthorizedHybrid(
+			embeddedConfig,
+			fileConfig,
+			provider,
+		);
+		if (authorized) {
+			authorizedProviders.push(provider);
+		}
+	}
+
+	return authorizedProviders;
+}
+
+export function getDefault<T>(
+	embeddedValue: T | undefined,
+	embeddedDefaultValue: T | undefined,
+	fileValue: T,
+): T {
+	return embeddedValue ?? embeddedDefaultValue ?? fileValue;
+}
+
+export async function getAuthTypeForProvider(
+	embeddedConfig: EmbeddedAppConfig | undefined,
+	provider: ProviderId,
+	projectRoot: string,
+): Promise<'api' | 'oauth' | 'wallet' | undefined> {
+	if (embeddedConfig?.auth?.[provider]) {
+		return embeddedConfig.auth[provider].type as 'api' | 'oauth' | 'wallet';
+	}
+	const auth = await getAuth(provider, projectRoot);
+	return auth?.type as 'api' | 'oauth' | 'wallet' | undefined;
+}
+
+export async function discoverAllAgents(
+	projectRoot: string,
+): Promise<string[]> {
+	const builtInAgents = ['general', 'build', 'plan'];
+	const agentSet = new Set<string>(builtInAgents);
+
+	try {
+		const agentsJson = await loadAgentsConfig(projectRoot);
+		for (const agentName of Object.keys(agentsJson)) {
+			if (agentName.trim()) {
+				agentSet.add(agentName);
+			}
+		}
+	} catch (err) {
+		logger.debug('Failed to load agents.json', err);
+	}
+
+	try {
+		const localAgentsPath = join(projectRoot, '.otto', 'agents');
+		const localFiles = await readdir(localAgentsPath).catch(() => []);
+		for (const file of localFiles) {
+			if (file.endsWith('.txt') || file.endsWith('.md')) {
+				const agentName = file.replace(/\.(txt|md)$/, '');
+				if (agentName.trim()) {
+					agentSet.add(agentName);
+				}
+			}
+		}
+	} catch (err) {
+		logger.debug('Failed to read local agents directory', err);
+	}
+
+	try {
+		const globalAgentsPath = getGlobalAgentsDir();
+		const globalFiles = await readdir(globalAgentsPath).catch(() => []);
+		for (const file of globalFiles) {
+			if (file.endsWith('.txt') || file.endsWith('.md')) {
+				const agentName = file.replace(/\.(txt|md)$/, '');
+				if (agentName.trim()) {
+					agentSet.add(agentName);
+				}
+			}
+		}
+	} catch (err) {
+		logger.debug('Failed to read global agents directory', err);
+	}
+
+	return Array.from(agentSet).sort();
+}