@ottocode/server 0.1.264 → 0.1.266

package/src/routes/git/staging-service.ts

@@ -0,0 +1,111 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import type { Context } from 'hono';
+import {
+	gitDeleteSchema,
+	gitRestoreSchema,
+	gitStageSchema,
+	gitUnstageSchema,
+} from './schemas.ts';
+import { validateAndGetGitRoot } from './utils.ts';
+
+const execFileAsync = promisify(execFile);
+
+type StagingAction = 'stage' | 'unstage' | 'restore' | 'delete';
+
+const actionConfig: Record<
+	StagingAction,
+	{
+		schema: typeof gitStageSchema;
+		command: (files: string[]) => string[];
+		dataKey: 'staged' | 'unstaged' | 'restored' | 'deleted';
+		fallbackError: string;
+	}
+> = {
+	stage: {
+		schema: gitStageSchema,
+		command: (files) => ['add', ...files],
+		dataKey: 'staged',
+		fallbackError: 'Failed to stage files',
+	},
+	unstage: {
+		schema: gitUnstageSchema,
+		command: (files) => ['reset', 'HEAD', '--', ...files],
+		dataKey: 'unstaged',
+		fallbackError: 'Failed to unstage files',
+	},
+	restore: {
+		schema: gitRestoreSchema,
+		command: (files) => ['restore', '--', ...files],
+		dataKey: 'restored',
+		fallbackError: 'Failed to restore files',
+	},
+	delete: {
+		schema: gitDeleteSchema,
+		command: (files) => ['clean', '-f', '--', ...files],
+		dataKey: 'deleted',
+		fallbackError: 'Failed to delete files',
+	},
+};
+
+async function handleStagingAction(c: Context, action: StagingAction) {
+	const config = actionConfig[action];
+	try {
+		const body = await c.req.json();
+		const { files, project } = config.schema.parse(body);
+		const requestedPath = project || process.cwd();
+
+		const validation = await validateAndGetGitRoot(requestedPath);
+		if ('error' in validation) {
+			return c.json(
+				{ status: 'error', error: validation.error, code: validation.code },
+				400,
+			);
+		}
+
+		if (files.length === 0) {
+			return c.json(
+				{
+					status: 'error',
+					error: 'No files specified',
+				},
+				400,
+			);
+		}
+
+		await execFileAsync('git', config.command(files), {
+			cwd: validation.gitRoot,
+		});
+
+		return c.json({
+			status: 'ok',
+			data: {
+				[config.dataKey]: files,
+			},
+		});
+	} catch (error) {
+		return c.json(
+			{
+				status: 'error',
+				error: error instanceof Error ? error.message : config.fallbackError,
+			},
+			500,
+		);
+	}
+}
+
+export function handleStageFiles(c: Context) {
+	return handleStagingAction(c, 'stage');
+}
+
+export function handleUnstageFiles(c: Context) {
+	return handleStagingAction(c, 'unstage');
+}
+
+export function handleRestoreFiles(c: Context) {
+	return handleStagingAction(c, 'restore');
+}
+
+export function handleDeleteFiles(c: Context) {
+	return handleStagingAction(c, 'delete');
+}

package/src/routes/git/staging.ts

@@ -1,16 +1,11 @@
 import type { Hono } from 'hono';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import {
-	gitStageSchema,
-	gitUnstageSchema,
-	gitRestoreSchema,
-	gitDeleteSchema,
-} from './schemas.ts';
-import { validateAndGetGitRoot } from './utils.ts';
 import { openApiRoute } from '../../openapi/route.ts';
-
-const execFileAsync = promisify(execFile);
+import {
+	handleDeleteFiles,
+	handleRestoreFiles,
+	handleStageFiles,
+	handleUnstageFiles,
+} from './staging-service.ts';
 
 export function registerStagingRoutes(app: Hono) {
 	openApiRoute(
@@ -104,52 +99,7 @@ export function registerStagingRoutes(app: Hono) {
 				},
 			},
 		},
-		async (c) => {
-			try {
-				const body = await c.req.json();
-				const { files, project } = gitStageSchema.parse(body);
-
-				const requestedPath = project || process.cwd();
-
-				const validation = await validateAndGetGitRoot(requestedPath);
-				if ('error' in validation) {
-					return c.json(
-						{ status: 'error', error: validation.error, code: validation.code },
-						400,
-					);
-				}
-
-				const { gitRoot } = validation;
-
-				if (files.length === 0) {
-					return c.json(
-						{
-							status: 'error',
-							error: 'No files specified',
-						},
-						400,
-					);
-				}
-
-				await execFileAsync('git', ['add', ...files], { cwd: gitRoot });
-
-				return c.json({
-					status: 'ok',
-					data: {
-						staged: files,
-					},
-				});
-			} catch (error) {
-				return c.json(
-					{
-						status: 'error',
-						error:
-							error instanceof Error ? error.message : 'Failed to stage files',
-					},
-					500,
-				);
-			}
-		},
+		handleStageFiles,
 	);
 
 	openApiRoute(
@@ -243,56 +193,7 @@ export function registerStagingRoutes(app: Hono) {
 				},
 			},
 		},
-		async (c) => {
-			try {
-				const body = await c.req.json();
-				const { files, project } = gitUnstageSchema.parse(body);
-
-				const requestedPath = project || process.cwd();
-
-				const validation = await validateAndGetGitRoot(requestedPath);
-				if ('error' in validation) {
-					return c.json(
-						{ status: 'error', error: validation.error, code: validation.code },
-						400,
-					);
-				}
-
-				const { gitRoot } = validation;
-
-				if (files.length === 0) {
-					return c.json(
-						{
-							status: 'error',
-							error: 'No files specified',
-						},
-						400,
-					);
-				}
-
-				await execFileAsync('git', ['reset', 'HEAD', '--', ...files], {
-					cwd: gitRoot,
-				});
-
-				return c.json({
-					status: 'ok',
-					data: {
-						unstaged: files,
-					},
-				});
-			} catch (error) {
-				return c.json(
-					{
-						status: 'error',
-						error:
-							error instanceof Error
-								? error.message
-								: 'Failed to unstage files',
-					},
-					500,
-				);
-			}
-		},
+		handleUnstageFiles,
 	);
 
 	openApiRoute(
@@ -380,56 +281,7 @@ export function registerStagingRoutes(app: Hono) {
 				},
 			},
 		},
-		async (c) => {
-			try {
-				const body = await c.req.json();
-				const { files, project } = gitRestoreSchema.parse(body);
-
-				const requestedPath = project || process.cwd();
-
-				const validation = await validateAndGetGitRoot(requestedPath);
-				if ('error' in validation) {
-					return c.json(
-						{ status: 'error', error: validation.error, code: validation.code },
-						400,
-					);
-				}
-
-				const { gitRoot } = validation;
-
-				if (files.length === 0) {
-					return c.json(
-						{
-							status: 'error',
-							error: 'No files specified',
-						},
-						400,
-					);
-				}
-
-				await execFileAsync('git', ['restore', '--', ...files], {
-					cwd: gitRoot,
-				});
-
-				return c.json({
-					status: 'ok',
-					data: {
-						restored: files,
-					},
-				});
-			} catch (error) {
-				return c.json(
-					{
-						status: 'error',
-						error:
-							error instanceof Error
-								? error.message
-								: 'Failed to restore files',
-					},
-					500,
-				);
-			}
-		},
+		handleRestoreFiles,
 	);
 
 	openApiRoute(
@@ -517,53 +369,6 @@ export function registerStagingRoutes(app: Hono) {
 				},
 			},
 		},
-		async (c) => {
-			try {
-				const body = await c.req.json();
-				const { files, project } = gitDeleteSchema.parse(body);
-
-				const requestedPath = project || process.cwd();
-
-				const validation = await validateAndGetGitRoot(requestedPath);
-				if ('error' in validation) {
-					return c.json(
-						{ status: 'error', error: validation.error, code: validation.code },
-						400,
-					);
-				}
-
-				const { gitRoot } = validation;
-
-				if (files.length === 0) {
-					return c.json(
-						{
-							status: 'error',
-							error: 'No files specified',
-						},
-						400,
-					);
-				}
-
-				await execFileAsync('git', ['clean', '-f', '--', ...files], {
-					cwd: gitRoot,
-				});
-
-				return c.json({
-					status: 'ok',
-					data: {
-						deleted: files,
-					},
-				});
-			} catch (error) {
-				return c.json(
-					{
-						status: 'error',
-						error:
-							error instanceof Error ? error.message : 'Failed to delete files',
-					},
-					500,
-				);
-			}
-		},
+		handleDeleteFiles,
 	);
 }

package/src/routes/mcp/auth.ts

@@ -0,0 +1,338 @@
+import type { Hono } from 'hono';
+import { openApiRoute } from '../../openapi/route.ts';
+import {
+	completeMCPAuth,
+	getMCPAuthStatus,
+	initiateMCPAuth,
+	revokeMCPAuth,
+} from './service.ts';
+import { copilotMCPOAuthStore, copilotMCPSessions } from './state.ts';
+
+export function registerMCPAuthRoutes(app: Hono) {
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/mcp/servers/{name}/auth',
+			tags: ['mcp'],
+			operationId: 'initiateMCPAuth',
+			summary: 'Initiate auth for an MCP server',
+			parameters: [
+				{
+					in: 'path',
+					name: 'name',
+					required: true,
+					schema: {
+						type: 'string',
+					},
+					description: 'MCP server name',
+				},
+			],
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									ok: {
+										type: 'boolean',
+									},
+									name: {
+										type: 'string',
+									},
+									authUrl: {
+										type: 'string',
+									},
+									authType: {
+										type: 'string',
+									},
+									authenticated: {
+										type: 'boolean',
+									},
+									sessionId: {
+										type: 'string',
+									},
+									userCode: {
+										type: 'string',
+									},
+									verificationUri: {
+										type: 'string',
+									},
+									interval: {
+										type: 'integer',
+									},
+									message: {
+										type: 'string',
+									},
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['ok'],
+							},
+						},
+					},
+				},
+				'404': {
+					description: 'Bad Request',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			const result = await initiateMCPAuth({
+				name: c.req.param('name'),
+				oAuthStore: copilotMCPOAuthStore,
+				sessions: copilotMCPSessions,
+			});
+			return result.ok
+				? c.json(result.body)
+				: c.json(result.body, result.status);
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'post',
+			path: '/v1/mcp/servers/{name}/auth/callback',
+			tags: ['mcp'],
+			operationId: 'completeMCPAuth',
+			summary: 'Complete MCP server auth callback',
+			parameters: [
+				{
+					in: 'path',
+					name: 'name',
+					required: true,
+					schema: {
+						type: 'string',
+					},
+					description: 'MCP server name',
+				},
+			],
+			requestBody: {
+				required: true,
+				content: {
+					'application/json': {
+						schema: {
+							type: 'object',
+							properties: {
+								code: {
+									type: 'string',
+								},
+								sessionId: {
+									type: 'string',
+								},
+							},
+						},
+					},
+				},
+			},
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									ok: {
+										type: 'boolean',
+									},
+									status: {
+										type: 'string',
+										enum: ['complete', 'pending', 'error'],
+									},
+									name: {
+										type: 'string',
+									},
+									connected: {
+										type: 'boolean',
+									},
+									tools: {
+										type: 'array',
+										items: {
+											type: 'object',
+											properties: {
+												name: {
+													type: 'string',
+												},
+												description: {
+													type: 'string',
+												},
+											},
+										},
+									},
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['ok'],
+							},
+						},
+					},
+				},
+				'400': {
+					description: 'Bad Request',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			const result = await completeMCPAuth({
+				name: c.req.param('name'),
+				body: await c.req.json(),
+				oAuthStore: copilotMCPOAuthStore,
+				sessions: copilotMCPSessions,
+			});
+			return result.ok
+				? c.json(result.body)
+				: c.json(result.body, result.status);
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'get',
+			path: '/v1/mcp/servers/{name}/auth/status',
+			tags: ['mcp'],
+			operationId: 'getMCPAuthStatus',
+			summary: 'Get auth status for an MCP server',
+			parameters: [
+				{
+					in: 'path',
+					name: 'name',
+					required: true,
+					schema: {
+						type: 'string',
+					},
+					description: 'MCP server name',
+				},
+			],
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									authenticated: {
+										type: 'boolean',
+									},
+									authType: {
+										type: 'string',
+									},
+								},
+								required: ['authenticated'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			return c.json(
+				await getMCPAuthStatus({
+					name: c.req.param('name'),
+					oAuthStore: copilotMCPOAuthStore,
+				}),
+			);
+		},
+	);
+
+	openApiRoute(
+		app,
+		{
+			method: 'delete',
+			path: '/v1/mcp/servers/{name}/auth',
+			tags: ['mcp'],
+			operationId: 'revokeMCPAuth',
+			summary: 'Revoke auth for an MCP server',
+			parameters: [
+				{
+					in: 'path',
+					name: 'name',
+					required: true,
+					schema: {
+						type: 'string',
+					},
+					description: 'MCP server name',
+				},
+			],
+			responses: {
+				'200': {
+					description: 'OK',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									ok: {
+										type: 'boolean',
+									},
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['ok'],
+							},
+						},
+					},
+				},
+				'400': {
+					description: 'Bad Request',
+					content: {
+						'application/json': {
+							schema: {
+								type: 'object',
+								properties: {
+									error: {
+										type: 'string',
+									},
+								},
+								required: ['error'],
+							},
+						},
+					},
+				},
+			},
+		},
+		async (c) => {
+			const result = await revokeMCPAuth({
+				name: c.req.param('name'),
+				oAuthStore: copilotMCPOAuthStore,
+			});
+			return result.ok
+				? c.json(result.body)
+				: c.json(result.body, result.status);
+		},
+	);
+}