mcp-copilot-worker 1.0.1

package/src/app.ts

@@ -0,0 +1,344 @@
+import { OutputLogService } from './services/output-log.js';
+import { ProfileManager } from './services/profile-manager.js';
+import { QuestionRegistry } from './services/question-registry.js';
+import { TaskManager } from './services/task-manager.js';
+import { CopilotRuntime } from './services/copilot-runtime.js';
+import { prepareTaskWorkspace } from './services/workspace-isolation.js';
+import { DEFAULT_ISOLATION_MODE, DEFAULT_TIMEOUT_MS } from './config/defaults.js';
+import { buildAnswerBanner, buildMessageBanner } from './mcp/tool-banners.js';
+import { createToolDefinitions, type AnswerAgentInput, type CancelAgentInput, type MessageAgentInput, type SpawnAgentInput } from './mcp/tool-definitions.js';
+import { renderTaskListMarkdown, renderTaskMarkdown } from './mcp/task-markdown.js';
+import { buildSystemStatus } from './mcp/system-status.js';
+import type { ContextFile, TaskRecord } from './types/task.js';
+import { TaskStatus } from './types/task.js';
+import { validateSpawnAgentInput } from './services/spawn-validation.js';
+
+export class CopilotMcpApp {
+  readonly outputLog = new OutputLogService();
+  readonly profileManager = ProfileManager.fromEnvironment();
+  readonly taskManager = new TaskManager({
+    outputLog: this.outputLog,
+    getProfiles: () => this.profileManager.toPersistedState(),
+  });
+  readonly questionRegistry = new QuestionRegistry(this.taskManager);
+  readonly runtime = new CopilotRuntime({
+    taskManager: this.taskManager,
+    profileManager: this.profileManager,
+    questionRegistry: this.questionRegistry,
+  });
+
+  async initialize(cwd: string): Promise<void> {
+    const restored = await this.taskManager.load(cwd);
+    this.profileManager.hydrate(restored.profiles);
+  }
+
+  async listTools() {
+    const modelField = await this.runtime.describeCurrentProfileModels(process.cwd());
+    return createToolDefinitions({
+      messageBanner: buildMessageBanner(this.taskManager),
+      answerBanner: buildAnswerBanner(this.questionRegistry),
+      modelSuggestions: modelField.latestModelIds,
+      modelDescription: modelField.description,
+    });
+  }
+
+  async spawnAgent(input: SpawnAgentInput): Promise<string> {
+    const baseCwd = input.cwd ?? process.cwd();
+    const validated = await validateSpawnAgentInput({ input, baseCwd });
+    const isolationMode = input.isolation_mode ?? DEFAULT_ISOLATION_MODE;
+    const workspace = await prepareTaskWorkspace({
+      baseCwd,
+      taskId: `${Date.now().toString(36)}-workspace`,
+      isolationMode,
+    });
+
+    const task = await this.taskManager.createTask({
+      prompt: input.prompt,
+      cwd: workspace.cwd,
+      baseCwd,
+      model: await this.runtime.resolveRequestedModel(baseCwd, input.model),
+      agentType: input.agent_type,
+      labels: input.labels,
+      contextFiles: validated.contextFiles,
+      dependsOn: input.depends_on,
+      timeoutMs: input.timeout ?? DEFAULT_TIMEOUT_MS,
+      isolationMode,
+    });
+
+    if (task.status === TaskStatus.WAITING) {
+      return [
+        '✅ **Task queued (waiting for dependencies)**',
+        `task_id: \`${task.id}\``,
+        task.outputFilePath ? `output_file: \`${task.outputFilePath}\`` : null,
+        '',
+        '**Monitor:** Read `task:///all` — shows all tasks with status and pending questions in one table.',
+      ].filter(Boolean).join('\n');
+    }
+
+    void this.startTask(task.id).catch(() => {});
+
+    return [
+      '✅ **Task launched**',
+      `task_id: \`${task.id}\``,
+      task.outputFilePath ? `read logs: \`cat -n ${task.outputFilePath}\`` : null,
+      task.outputFilePath ? 'Use `cat -n` to read with line numbers, then on subsequent reads use `tail -n +<N>` to skip already-read lines.' : null,
+      '',
+      '**What to do next:**',
+      '- If you still have more agents to launch, launch them now — all agents run in parallel.',
+      '- Once all agents are launched, run `sleep 30` and then check status.',
+      `- To check status, read the MCP resource \`task:///${task.id}\` — it will show current progress, output, and whether the agent needs input.`,
+      task.outputFilePath ? `- For a quick progress check without reading the full resource, run \`wc -l ${task.outputFilePath}\` — a growing line count means the agent is still working.` : null,
+    ].filter(Boolean).join('\n');
+  }
+
+  async messageAgent(input: MessageAgentInput): Promise<string> {
+    const original = this.taskManager.getTask(input.task_id);
+    if (!original) {
+      throw new Error(`Task not found: ${input.task_id}`);
+    }
+    if (!original.sessionId) {
+      throw new Error(`Task ${input.task_id} has no resumable session`);
+    }
+
+    const task = await this.taskManager.createTask({
+      prompt: input.message ?? 'continue',
+      cwd: input.cwd ?? original.cwd,
+      baseCwd: input.cwd ?? original.baseCwd ?? original.cwd,
+      model: original.model,
+      agentType: original.agentType,
+      labels: [...original.labels, `continued-from:${original.id}`],
+      contextFiles: original.contextFiles,
+      timeoutMs: input.timeout ?? original.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+      sessionId: original.sessionId,
+      parentTaskId: original.id,
+      profileId: original.profileId,
+      profileConfigDir: original.profileConfigDir,
+      isolationMode: original.isolationMode,
+    });
+
+    void this.startTask(task.id).catch(() => {});
+
+    return [
+      '✅ **Message sent**',
+      `task_id: \`${task.id}\``,
+      '',
+      task.outputFilePath ? `read logs: \`cat -n ${task.outputFilePath}\`` : null,
+      task.outputFilePath ? 'Use `cat -n` to read with line numbers, then on subsequent reads use `tail -n +<N>` to skip already-read lines.' : null,
+    ].filter(Boolean).join('\n');
+  }
+
+  async cancelAgent(input: CancelAgentInput): Promise<string> {
+    if (input.task_id === 'all') {
+      if (!input.clear || !input.confirm) {
+        throw new Error('Use clear=true and confirm=true with task_id="all"');
+      }
+
+      const count = await this.taskManager.clearAllTasks();
+      return `✅ Cleared **${count}** tasks from workspace.`;
+    }
+
+    const taskIds = Array.isArray(input.task_id) ? input.task_id : [input.task_id];
+    const results = await Promise.all(taskIds.map((taskId) => this.taskManager.cancelTask(taskId)));
+    return `✅ Cancelled ${results.filter(Boolean).length}/${taskIds.length} task(s).`;
+  }
+
+  async answerAgent(input: AnswerAgentInput): Promise<string> {
+    const rawAnswer = input.answer ?? Object.values(input.answers ?? {})[0];
+    if (!rawAnswer) {
+      throw new Error('Provide answer or answers');
+    }
+
+    const result = this.questionRegistry.submitAnswer(input.task_id, rawAnswer);
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+
+    return [
+      '✅ **Answer submitted**',
+      `task_id: \`${input.task_id}\``,
+      `**Answer:** ${result.resolvedAnswer}`,
+    ].join('\n');
+  }
+
+  listResources() {
+    return [
+      {
+        uri: 'system:///status',
+        name: 'System Status',
+        description: 'Current task and profile counts',
+        mimeType: 'application/json',
+      },
+      {
+        uri: 'task:///all',
+        name: 'All Tasks',
+        description: `${this.taskManager.getAllTasks().length} tracked tasks`,
+        mimeType: 'text/markdown',
+      },
+      ...this.taskManager.getAllTasks().flatMap((task) => ([
+        {
+          uri: `task:///${task.id}`,
+          name: task.id,
+          description: task.status,
+          mimeType: 'text/markdown',
+        },
+        {
+          uri: `task:///${task.id}/session`,
+          name: `${task.id} session`,
+          description: `Execution log for ${task.id}`,
+          mimeType: 'application/json',
+        },
+      ])),
+    ];
+  }
+
+  async readResource(uri: string): Promise<{ mimeType: string; text: string }> {
+    if (uri === 'system:///status') {
+      return {
+        mimeType: 'application/json',
+        text: JSON.stringify(
+          buildSystemStatus({
+            tasks: this.taskManager.getAllTasks(),
+            profiles: this.profileManager.getProfiles(),
+          }),
+          null,
+          2,
+        ),
+      };
+    }
+
+    if (uri === 'task:///all') {
+      return {
+        mimeType: 'text/markdown',
+        text: renderTaskListMarkdown(this.taskManager.getAllTasks()),
+      };
+    }
+
+    if (uri.startsWith('task:///') && uri.endsWith('/session')) {
+      const taskId = uri.slice('task:///'.length, -'/session'.length);
+      const task = this.getTaskOrThrow(taskId);
+      return {
+        mimeType: 'application/json',
+        text: JSON.stringify({
+          taskId: task.id,
+          status: task.status,
+          output: task.output,
+        }),
+      };
+    }
+
+    if (uri.startsWith('task:///')) {
+      const taskId = uri.slice('task:///'.length);
+      const task = this.getTaskOrThrow(taskId);
+      return {
+        mimeType: 'text/markdown',
+        text: renderTaskMarkdown(task),
+      };
+    }
+
+    throw new Error(`Unknown resource URI: ${uri}`);
+  }
+
+  async shutdown(): Promise<void> {
+    await this.runtime.shutdown();
+  }
+
+  listTaskSummaries() {
+    return this.taskManager.getAllTasks().map((task) => this.toMcpTask(task));
+  }
+
+  getTaskSummary(taskId: string) {
+    return this.toMcpTask(this.getTaskOrThrow(taskId));
+  }
+
+  getTaskPayload(taskId: string) {
+    const task = this.getTaskOrThrow(taskId);
+    return {
+      taskId: task.id,
+      status: task.status,
+      output: task.output,
+      error: task.error,
+      outputFilePath: task.outputFilePath,
+      pendingQuestion: task.pendingQuestion,
+    };
+  }
+
+  async cancelTaskById(taskId: string) {
+    const cancelled = await this.taskManager.cancelTask(taskId);
+    if (!cancelled && !this.taskManager.getTask(taskId)) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    return this.getTaskSummary(taskId);
+  }
+
+  private async startTask(taskId: string): Promise<void> {
+    const task = this.taskManager.getTask(taskId);
+    if (!task) {
+      return;
+    }
+
+    try {
+      await this.runtime.runTask(task);
+      const ready = await this.taskManager.releaseReadyTasks();
+      await Promise.all(ready.map((released) => this.startTask(released.id)));
+    } catch (error) {
+      await this.taskManager.updateTask(taskId, {
+        status: TaskStatus.FAILED,
+        error: error instanceof Error ? error.message : String(error),
+        endTime: new Date().toISOString(),
+      }).catch(() => {});
+    }
+  }
+
+  private getTaskOrThrow(taskId: string) {
+    const task = this.taskManager.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+    return task;
+  }
+
+  private toMcpTask(task: TaskRecord) {
+    return {
+      taskId: task.id,
+      status: this.toMcpTaskStatus(task.status),
+      statusMessage: this.buildTaskStatusMessage(task),
+      createdAt: task.createdAt,
+      lastUpdatedAt: task.updatedAt,
+      ttl: task.timeoutMs ?? null,
+      pollInterval: 2_000,
+    };
+  }
+
+  private toMcpTaskStatus(status: TaskStatus): 'working' | 'input_required' | 'completed' | 'failed' | 'cancelled' {
+    switch (status) {
+      case TaskStatus.WAITING_ANSWER:
+        return 'input_required';
+      case TaskStatus.COMPLETED:
+        return 'completed';
+      case TaskStatus.CANCELLED:
+        return 'cancelled';
+      case TaskStatus.FAILED:
+      case TaskStatus.TIMED_OUT:
+      case TaskStatus.RATE_LIMITED:
+        return 'failed';
+      default:
+        return 'working';
+    }
+  }
+
+  private buildTaskStatusMessage(task: TaskRecord): string | undefined {
+    if (task.pendingQuestion?.question) {
+      return task.pendingQuestion.question;
+    }
+    if (task.status === TaskStatus.WAITING && (task.dependsOn?.length ?? 0) > 0) {
+      return `Waiting for dependencies: ${(task.dependsOn ?? []).join(', ')}`;
+    }
+    if (task.error) {
+      return task.error;
+    }
+    if (task.status === TaskStatus.COMPLETED) {
+      return 'Task completed';
+    }
+    return undefined;
+  }
+}

package/src/cli/doctor.ts

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import { execFile } from 'node:child_process';
+import process from 'node:process';
+import { promisify } from 'node:util';
+
+import { CopilotClient } from '@github/copilot-sdk';
+
+import { buildCopilotClientOptions } from '../services/copilot-runtime.js';
+import { ProfileManager } from '../services/profile-manager.js';
+
+const execFileAsync = promisify(execFile);
+
+async function commandVersion(command: string, args: string[] = ['--version']): Promise<string | null> {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, args, { encoding: 'utf8' });
+    return (stdout || stderr).trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+async function inspectProfiles() {
+  const profileManager = ProfileManager.fromEnvironment();
+  const profiles = profileManager.getProfiles();
+
+  return Promise.all(
+    profiles.map(async (profile) => {
+      const client = new CopilotClient(
+        buildCopilotClientOptions({ cwd: process.cwd(), profile }),
+      );
+
+      try {
+        await client.start();
+        const auth = await client.getAuthStatus();
+        const models = auth.isAuthenticated
+          ? await client.listModels().catch(() => [])
+          : [];
+
+        return {
+          id: profile.id,
+          configDir: profile.configDir,
+          authenticated: auth.isAuthenticated,
+          login: auth.login,
+          models: models.slice(0, 10).map((model) => model.id),
+        };
+      } catch (error) {
+        return {
+          id: profile.id,
+          configDir: profile.configDir,
+          authenticated: false,
+          error: error instanceof Error ? error.message : String(error),
+          models: [],
+        };
+      } finally {
+        await client.stop().catch(async () => {
+          await client.forceStop().catch(() => {});
+        });
+      }
+    }),
+  );
+}
+
+async function main(): Promise<void> {
+  const json = process.argv.includes('--json');
+  const inspectedProfiles = await inspectProfiles();
+  const report = {
+    node: process.version,
+    copilot: await commandVersion('copilot'),
+    mcpc: await commandVersion('mcpc'),
+    cwd: process.cwd(),
+    copilotCliPath: buildCopilotClientOptions({
+      cwd: process.cwd(),
+      profile: {
+        id: 'doctor',
+        configDir: process.env.COPILOT_CONFIG_DIRS?.split(',')[0]?.trim() || `${process.env.HOME}/.copilot`,
+        failureCount: 0,
+      },
+    }).cliPath,
+    profiles: inspectedProfiles,
+  };
+
+  if (json) {
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    return;
+  }
+
+  process.stdout.write(`Node: ${report.node}\n`);
+  process.stdout.write(`Copilot CLI: ${report.copilot ?? 'not found'}\n`);
+  process.stdout.write(`Copilot CLI Path: ${report.copilotCliPath}\n`);
+  process.stdout.write(`mcpc: ${report.mcpc ?? 'not found'}\n`);
+  process.stdout.write(`cwd: ${report.cwd}\n`);
+  process.stdout.write('\nProfiles:\n');
+  for (const profile of report.profiles) {
+    process.stdout.write(`- ${profile.id} (${profile.configDir}) authenticated=${String(profile.authenticated)}`);
+    if ('login' in profile && profile.login) {
+      process.stdout.write(` login=${profile.login}`);
+    }
+    if ('error' in profile && profile.error) {
+      process.stdout.write(` error=${profile.error}`);
+    }
+    process.stdout.write('\n');
+    if (profile.models.length > 0) {
+      process.stdout.write(`  models: ${profile.models.join(', ')}\n`);
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/config/defaults.ts

@@ -0,0 +1,3 @@
+export const DEFAULT_MODEL = 'gpt-5.4';
+export const DEFAULT_TIMEOUT_MS = 30 * 60 * 1000;
+export const DEFAULT_ISOLATION_MODE = 'isolated';

package/src/index.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+import { createRequire } from 'node:module';
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CancelTaskRequestSchema,
+  CallToolRequestSchema,
+  GetTaskPayloadRequestSchema,
+  GetTaskRequestSchema,
+  ListTasksRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { CopilotMcpApp } from './app.js';
+
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json') as { version: string };
+
+const app = new CopilotMcpApp();
+const server = new Server(
+  { name: 'mcp-copilot-worker', version: pkg.version },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+      tasks: {
+        list: {},
+        cancel: {},
+      },
+    },
+  },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: (await app.listTools()).map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+  })),
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const tools = await app.listTools();
+  const tool = tools.find((candidate) => candidate.name === request.params.name);
+  if (!tool) {
+    return {
+      content: [{ type: 'text', text: `Unknown tool: ${request.params.name}` }],
+      isError: true as const,
+    };
+  }
+
+  try {
+    const args = tool.validate(request.params.arguments ?? {});
+
+    switch (tool.name) {
+      case 'spawn-agent':
+        return { content: [{ type: 'text', text: await app.spawnAgent(args as never) }] };
+      case 'message-agent':
+        return { content: [{ type: 'text', text: await app.messageAgent(args as never) }] };
+      case 'cancel-agent':
+        return { content: [{ type: 'text', text: await app.cancelAgent(args as never) }] };
+      case 'answer-agent':
+        return { content: [{ type: 'text', text: await app.answerAgent(args as never) }] };
+      default:
+        return {
+          content: [{ type: 'text', text: `Unhandled tool: ${tool.name}` }],
+          isError: true as const,
+        };
+    }
+  } catch (error) {
+    return {
+      content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
+      isError: true as const,
+    };
+  }
+});
+
+server.setRequestHandler(ListResourcesRequestSchema, async () => ({
+  resources: app.listResources(),
+}));
+
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const resource = await app.readResource(request.params.uri);
+  return {
+    contents: [
+      {
+        uri: request.params.uri,
+        mimeType: resource.mimeType,
+        text: resource.text,
+      },
+    ],
+  };
+});
+
+server.setRequestHandler(ListTasksRequestSchema, async () => ({
+  tasks: app.listTaskSummaries(),
+}));
+
+server.setRequestHandler(GetTaskRequestSchema, async (request) => app.getTaskSummary(request.params.taskId));
+
+server.setRequestHandler(GetTaskPayloadRequestSchema, async (request) => app.getTaskPayload(request.params.taskId));
+
+server.setRequestHandler(CancelTaskRequestSchema, async (request) => app.cancelTaskById(request.params.taskId));
+
+async function main(): Promise<void> {
+  await app.initialize(process.cwd());
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  process.stdin.resume();
+
+  const shutdown = async () => {
+    await app.shutdown().catch(() => {});
+    process.exit(0);
+  };
+
+  process.on('SIGINT', () => void shutdown());
+  process.on('SIGTERM', () => void shutdown());
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/mcp/system-status.ts

@@ -0,0 +1,41 @@
+import type { CopilotProfile } from '../services/profile-manager.js';
+import type { TaskRecord } from '../types/task.js';
+import { TaskStatus } from '../types/task.js';
+
+export interface SystemStatus {
+  tasks: {
+    total: number;
+    running: number;
+    waiting: number;
+    waitingAnswer: number;
+    terminal: number;
+  };
+  profiles: {
+    total: number;
+    coolingDown: number;
+  };
+}
+
+export function buildSystemStatus(input: {
+  tasks: TaskRecord[];
+  profiles: CopilotProfile[];
+}): SystemStatus {
+  return {
+    tasks: {
+      total: input.tasks.length,
+      running: input.tasks.filter((task) => task.status === TaskStatus.RUNNING).length,
+      waiting: input.tasks.filter((task) => task.status === TaskStatus.WAITING).length,
+      waitingAnswer: input.tasks.filter((task) => task.status === TaskStatus.WAITING_ANSWER).length,
+      terminal: input.tasks.filter((task) =>
+        task.status === TaskStatus.COMPLETED ||
+        task.status === TaskStatus.FAILED ||
+        task.status === TaskStatus.CANCELLED ||
+        task.status === TaskStatus.TIMED_OUT,
+      ).length,
+    },
+    profiles: {
+      total: input.profiles.length,
+      coolingDown: input.profiles.filter((profile) => profile.cooldownUntil !== undefined).length,
+    },
+  };
+}