cli-copilot-worker 0.1.0

package/src/cli.ts

@@ -0,0 +1,881 @@
+#!/usr/bin/env node
+
+import { resolve as resolvePath } from 'node:path';
+import process from 'node:process';
+
+import { Command } from 'commander';
+
+import pkg from '../package.json' with { type: 'json' };
+import { readMarkdownFile } from './core/markdown.js';
+import { daemonIsRunning, ensureDaemonMeta, sendDaemonRequest } from './daemon/client.js';
+import { runDaemonServer } from './daemon/server.js';
+import { inspectDoctor } from './doctor.js';
+import {
+  createEventPrinter,
+  formatActions,
+  formatAttemptHistory,
+  formatEntries,
+  formatPendingQuestion,
+  formatProfileSummary,
+  formatProfilesSection,
+  printJson,
+  resolveOutputFormat,
+  shortenPath,
+  type OutputFormat,
+} from './output.js';
+
+interface GlobalOptions {
+  output?: string | undefined;
+}
+
+interface ReadResponse {
+  conversation: {
+    id: string;
+    status: string;
+    cwd: string;
+    model: string;
+    pendingQuestion?: {
+      question: string;
+      choices?: string[] | undefined;
+      allowFreeform: boolean;
+      askedAt: string;
+      sessionId: string;
+    } | undefined;
+    lastJobId?: string | undefined;
+  };
+  meta: {
+    totalEntries: number;
+    returnedEntries: number;
+    tokenBudget: number;
+    approxTokens: number;
+    nextActions: Record<string, unknown>;
+  };
+  entries: Array<{
+    index: number;
+    role: 'user' | 'assistant' | 'tool_use' | 'tool_result' | 'question' | 'answer' | 'status' | 'error';
+    content: string;
+    timestamp: string;
+    data?: Record<string, unknown> | undefined;
+  }>;
+}
+
+function getOutputFormat(program: Command): OutputFormat {
+  return resolveOutputFormat((program.opts() as GlobalOptions).output);
+}
+
+function parseInteger(value: string | undefined, label: string): number | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+
+  const parsed = Number.parseInt(value, 10);
+  if (Number.isNaN(parsed)) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+
+  return parsed;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+
+function extractPendingQuestion(result: Record<string, unknown>): ReadResponse['conversation']['pendingQuestion'] | undefined {
+  const candidates: unknown[] = [
+    result.pendingQuestion,
+    isRecord(result.conversation) ? result.conversation.pendingQuestion : undefined,
+  ];
+
+  for (const candidate of candidates) {
+    if (!isRecord(candidate)) {
+      continue;
+    }
+
+    if (typeof candidate.question === 'string' && typeof candidate.allowFreeform === 'boolean' && typeof candidate.askedAt === 'string' && typeof candidate.sessionId === 'string') {
+      return candidate as ReadResponse['conversation']['pendingQuestion'];
+    }
+  }
+
+  return undefined;
+}
+
+function extractAttempts(result: unknown): unknown {
+  if (!isRecord(result)) {
+    return undefined;
+  }
+
+  if (Array.isArray(result.attempts)) {
+    return result.attempts;
+  }
+
+  if (isRecord(result.job) && Array.isArray(result.job.attempts)) {
+    return result.job.attempts;
+  }
+
+  if (isRecord(result.conversation) && Array.isArray(result.conversation.attempts)) {
+    return result.conversation.attempts;
+  }
+
+  return undefined;
+}
+
+function formatProfileIdentity(result: Record<string, unknown>): string | undefined {
+  const sources = [
+    result,
+    isRecord(result.conversation) ? result.conversation : undefined,
+    isRecord(result.job) ? result.job : undefined,
+  ].filter((source): source is Record<string, unknown> => source !== undefined);
+
+  for (const source of sources) {
+    const hasProfileSignals =
+      source.activeProfileId !== undefined ||
+      source.currentProfileId !== undefined ||
+      source.profileId !== undefined ||
+      source.activeProfileConfigDir !== undefined ||
+      source.currentProfileConfigDir !== undefined ||
+      source.profileConfigDir !== undefined ||
+      source.cooldownUntil !== undefined ||
+      source.failureCount !== undefined ||
+      source.lastFailureCategory !== undefined ||
+      source.lastFailureReason !== undefined ||
+      source.authenticated !== undefined ||
+      source.login !== undefined ||
+      source.models !== undefined;
+
+    if (!hasProfileSignals) {
+      continue;
+    }
+
+    const id = stringValue(source.activeProfileId)
+      ?? stringValue(source.currentProfileId)
+      ?? stringValue(source.profileId)
+      ?? stringValue(source.id);
+    const configDir = stringValue(source.activeProfileConfigDir)
+      ?? stringValue(source.currentProfileConfigDir)
+      ?? stringValue(source.profileConfigDir)
+      ?? stringValue(source.configDir);
+
+    if (id || configDir) {
+      return [
+        id ?? 'unknown',
+        configDir ? shortenPath(configDir) : undefined,
+      ].filter((part): part is string => part !== undefined).join(' ');
+    }
+  }
+
+  return undefined;
+}
+
+function formatPrimitiveFields(result: Record<string, unknown>, excludeKeys: string[]): string[] {
+  return Object.entries(result)
+    .filter(([key, value]) => !excludeKeys.includes(key) && (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean'))
+    .map(([key, value]) => `${key}: ${String(value)}`);
+}
+
+function renderAttemptsSection(result: unknown): string {
+  return formatAttemptHistory(extractAttempts(result));
+}
+
+function renderProfilesSection(result: Record<string, unknown>, options?: Parameters<typeof formatProfilesSection>[1]): string {
+  return formatProfilesSection(result.profiles, options);
+}
+
+function indentBlock(text: string, prefix = '  '): string {
+  return text.split('\n').map((line) => `${prefix}${line}`).join('\n');
+}
+
+function renderRunLikeResult(result: Record<string, unknown>): string {
+  const lines = [
+    `Conversation: ${String(result.conversationId ?? 'unknown')}`,
+    `Job: ${String(result.jobId ?? 'unknown')}`,
+    `Status: ${String(result.status ?? 'unknown')}`,
+  ];
+
+  const profile = formatProfileIdentity(result);
+  if (profile) {
+    lines.push('');
+    lines.push(`Profile: ${profile}`);
+  }
+
+  const attempts = renderAttemptsSection(result);
+  if (attempts) {
+    lines.push('');
+    lines.push(attempts);
+  }
+
+  const pendingQuestion = extractPendingQuestion(result);
+  if (pendingQuestion) {
+    lines.push('');
+    lines.push('Pending Question:');
+    lines.push(formatPendingQuestion(pendingQuestion));
+  }
+
+  lines.push('');
+  lines.push('Actions:');
+  lines.push(formatActions(result.actions as Record<string, unknown> | undefined));
+  return lines.join('\n');
+}
+
+function renderListResult(result: Record<string, unknown>): string {
+  const conversations = Array.isArray(result.conversations)
+    ? result.conversations as Array<Record<string, unknown>>
+    : [];
+
+  if (conversations.length === 0) {
+    return 'No conversations.';
+  }
+
+  return conversations
+    .map((conversation) => {
+      const pending = typeof conversation.pendingQuestion === 'string' ? ' pending-question' : '';
+      return [
+        `${String(conversation.id)}  ${String(conversation.status)}${pending}`,
+        `  cwd: ${shortenPath(String(conversation.cwd ?? ''))}`,
+        `  model: ${String(conversation.model ?? '')}`,
+        `  updated: ${String(conversation.updatedAt ?? '')}`,
+      ].join('\n');
+    })
+    .join('\n\n');
+}
+
+function renderInfoResult(result: Record<string, unknown>): string {
+  const conversation = result.conversation as Record<string, unknown>;
+  const jobs = Array.isArray(result.jobs) ? result.jobs as Array<Record<string, unknown>> : [];
+
+  const lines = [
+    `Conversation: ${String(conversation.id ?? 'unknown')}`,
+    `Status: ${String(conversation.status ?? 'unknown')}`,
+    `Model: ${String(conversation.model ?? 'unknown')}`,
+    `cwd: ${shortenPath(String(conversation.cwd ?? ''))}`,
+    `Created: ${String(conversation.createdAt ?? '')}`,
+    `Updated: ${String(conversation.updatedAt ?? '')}`,
+  ];
+
+  const profile = formatProfileIdentity(conversation);
+  if (profile) {
+    lines.push('');
+    lines.push(`Profile: ${profile}`);
+  }
+
+  const pendingQuestion = extractPendingQuestion(conversation);
+  if (pendingQuestion) {
+    lines.push('');
+    lines.push('Pending Question:');
+    lines.push(formatPendingQuestion(pendingQuestion));
+  }
+
+  lines.push('');
+  lines.push('Jobs:');
+  if (jobs.length === 0) {
+    lines.push('- none');
+  } else {
+    jobs.forEach((job) => {
+      const jobProfile = formatProfileIdentity(job);
+      const attempts = renderAttemptsSection(job);
+      lines.push(
+        [
+          `- ${String(job.id)} ${String(job.kind)} ${String(job.status)} started=${String(job.startedAt ?? '')}`,
+          jobProfile ? `profile=${jobProfile}` : undefined,
+          Array.isArray(job.attempts) ? `attempts=${job.attempts.length}` : undefined,
+          job.error ? `error=${String(job.error)}` : undefined,
+        ].filter((part): part is string => part !== undefined).join(' '),
+      );
+      if (attempts) {
+        lines.push(indentBlock(attempts));
+      }
+    });
+  }
+
+  return lines.join('\n');
+}
+
+function renderJobResult(result: Record<string, unknown>): string {
+  const job = result.job as Record<string, unknown>;
+  const lines = [
+    `Job: ${String(job.id ?? 'unknown')}`,
+    `Conversation: ${String(job.conversationId ?? 'unknown')}`,
+    `Kind: ${String(job.kind ?? 'unknown')}`,
+    `Status: ${String(job.status ?? 'unknown')}`,
+    `Input: ${shortenPath(String(job.inputFilePath ?? ''))}`,
+    `Started: ${String(job.startedAt ?? '')}`,
+  ];
+
+  if (job.endedAt) {
+    lines.push(`Ended: ${String(job.endedAt)}`);
+  }
+  if (job.error) {
+    lines.push(`Error: ${String(job.error)}`);
+  }
+
+  const attempts = renderAttemptsSection(result);
+  if (attempts) {
+    lines.push('');
+    lines.push(attempts);
+  }
+
+  const pendingQuestion = extractPendingQuestion(result);
+  if (pendingQuestion) {
+    lines.push('');
+    lines.push('Pending Question:');
+    lines.push(formatPendingQuestion(pendingQuestion));
+  }
+
+  lines.push('');
+  lines.push('Actions:');
+  lines.push(formatActions({
+    ...(result.actions as Record<string, unknown> | undefined),
+    answer: job.status === 'waiting_answer'
+      ? `cli-copilot-worker answer ${String(job.conversationId)} answer.md`
+      : null,
+  }));
+  return lines.join('\n');
+}
+
+function renderReadResult(result: ReadResponse): string {
+  const lines = [
+    `Conversation: ${result.conversation.id}`,
+    `Status: ${result.conversation.status}`,
+    `cwd: ${shortenPath(result.conversation.cwd)}`,
+    `Model: ${result.conversation.model}`,
+    `Entries: ${result.meta.returnedEntries}/${result.meta.totalEntries}`,
+    `Approx Tokens: ${result.meta.approxTokens}/${result.meta.tokenBudget}`,
+  ];
+
+  const profile = formatProfileIdentity(result.conversation);
+  if (profile) {
+    lines.push('');
+    lines.push(`Profile: ${profile}`);
+  }
+
+  const pendingQuestion = extractPendingQuestion(result.conversation);
+  if (pendingQuestion) {
+    lines.push('');
+    lines.push('Pending Question:');
+    lines.push(formatPendingQuestion(pendingQuestion));
+  }
+
+  const attempts = renderAttemptsSection(result);
+  if (attempts) {
+    lines.push('');
+    lines.push(attempts);
+  }
+
+  lines.push('');
+  lines.push(formatEntries(result.entries));
+
+  lines.push('');
+  lines.push('Actions:');
+  lines.push(formatActions(result.meta.nextActions));
+  return lines.join('\n');
+}
+
+function renderDaemonResult(result: Record<string, unknown>): string {
+  const lines = formatPrimitiveFields(result, ['profiles', 'attempts', 'jobs']);
+
+  const profiles = renderProfilesSection(result, { includeHealth: true });
+  if (profiles) {
+    if (lines.length > 0) {
+      lines.push('');
+    }
+    lines.push(profiles);
+  }
+
+  const attempts = renderAttemptsSection(result);
+  if (attempts) {
+    if (lines.length > 0) {
+      lines.push('');
+    }
+    lines.push(attempts);
+  }
+
+  return lines.join('\n');
+}
+
+async function readRequestPayload(filePath: string): Promise<{ path: string; content: string }> {
+  return await readMarkdownFile(filePath, process.cwd());
+}
+
+async function handleRun(taskPath: string, options: { cwd?: string; model?: string; timeout?: string; async?: boolean }, program: Command): Promise<void> {
+  const payload = await readRequestPayload(taskPath);
+  const output = getOutputFormat(program);
+  const eventPrinter = createEventPrinter(output === 'text' && !options.async && (process.stdout.isTTY ?? false));
+  const result = await sendDaemonRequest(
+    'run',
+    {
+      inputFilePath: payload.path,
+      content: payload.content,
+      cwd: resolvePath(options.cwd ?? process.cwd()),
+      model: options.model,
+      timeoutMs: parseInteger(options.timeout, 'timeout'),
+      async: options.async ?? false,
+    },
+    { onEvent: eventPrinter.onEvent },
+  );
+  eventPrinter.finish();
+
+  if (output === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(`${renderRunLikeResult(result)}\n`);
+}
+
+async function handleSend(conversationId: string, messagePath: string, options: { timeout?: string; async?: boolean }, program: Command): Promise<void> {
+  const payload = await readRequestPayload(messagePath);
+  const output = getOutputFormat(program);
+  const eventPrinter = createEventPrinter(output === 'text' && !options.async && (process.stdout.isTTY ?? false));
+  const result = await sendDaemonRequest(
+    'send',
+    {
+      conversationId,
+      inputFilePath: payload.path,
+      content: payload.content,
+      timeoutMs: parseInteger(options.timeout, 'timeout'),
+      async: options.async ?? false,
+    },
+    { onEvent: eventPrinter.onEvent },
+  );
+  eventPrinter.finish();
+
+  if (output === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(`${renderRunLikeResult(result)}\n`);
+}
+
+async function handleAnswer(conversationId: string, answerPath: string, program: Command): Promise<void> {
+  const payload = await readRequestPayload(answerPath);
+  const result = await sendDaemonRequest('answer', {
+    conversationId,
+    inputFilePath: payload.path,
+    content: payload.content,
+  });
+
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(
+    [
+      `Conversation: ${String(result.conversationId ?? conversationId)}`,
+      `Status: ${String(result.status ?? 'submitted')}`,
+      `Answer: ${String(result.answer ?? '')}`,
+      '',
+      'Actions:',
+      `- read: cli-copilot-worker read ${String(result.conversationId ?? conversationId)} --follow`,
+      `- info: cli-copilot-worker info ${String(result.conversationId ?? conversationId)}`,
+    ].join('\n') + '\n',
+  );
+}
+
+async function handleRead(conversationId: string, options: {
+  from?: string;
+  to?: string;
+  after?: string;
+  before?: string;
+  tokens?: string;
+  detail?: 'standard' | 'verbose' | 'full' | 'meta';
+  follow?: boolean;
+}, program: Command): Promise<void> {
+  const output = getOutputFormat(program);
+  if (options.follow && output === 'json') {
+    throw new Error('--follow only supports text output');
+  }
+
+  let after = parseInteger(options.after, 'after');
+  let firstPass = true;
+
+  while (true) {
+    const result = await sendDaemonRequest('read', {
+      conversationId,
+      from: firstPass ? parseInteger(options.from, 'from') : undefined,
+      to: firstPass ? parseInteger(options.to, 'to') : undefined,
+      after,
+      before: firstPass ? parseInteger(options.before, 'before') : undefined,
+      tokens: parseInteger(options.tokens, 'tokens'),
+      detail: options.detail,
+    }) as unknown as ReadResponse;
+
+    if (output === 'json') {
+      printJson(result);
+      return;
+    }
+
+    if (firstPass || result.entries.length > 0) {
+      process.stdout.write(`${renderReadResult(result)}\n`);
+    }
+
+    if (!options.follow) {
+      return;
+    }
+
+    const lastEntry = result.entries[result.entries.length - 1];
+    after = lastEntry?.index ?? after;
+    firstPass = false;
+
+    if (result.conversation.status !== 'running') {
+      return;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
+}
+
+async function handleList(program: Command): Promise<void> {
+  const result = await sendDaemonRequest('list');
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(`${renderListResult(result)}\n`);
+}
+
+async function handleInfo(conversationId: string, program: Command): Promise<void> {
+  const result = await sendDaemonRequest('info', { conversationId });
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(`${renderInfoResult(result)}\n`);
+}
+
+async function handleJobStatus(jobId: string, program: Command): Promise<void> {
+  const result = await sendDaemonRequest('job.status', { jobId });
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(`${renderJobResult(result)}\n`);
+}
+
+async function handleJobList(program: Command): Promise<void> {
+  const result = await sendDaemonRequest('job.list');
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  const jobs = Array.isArray(result.jobs) ? result.jobs as Array<Record<string, unknown>> : [];
+  if (jobs.length === 0) {
+    process.stdout.write('No jobs.\n');
+    return;
+  }
+
+  const lines = jobs.map((job) =>
+    `${String(job.id)}  ${String(job.kind)}  ${String(job.status)}  conversation=${String(job.conversationId)}`,
+  );
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+async function handleJobWait(jobId: string, options: { timeout?: string; interval?: string }, program: Command): Promise<void> {
+  const result = await sendDaemonRequest('job.wait', {
+    jobId,
+    timeoutSeconds: parseInteger(options.timeout, 'timeout'),
+    intervalSeconds: parseInteger(options.interval, 'interval'),
+  });
+
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(`${renderJobResult(result)}\n`);
+}
+
+async function handleJobRead(jobId: string, program: Command): Promise<void> {
+  const result = await sendDaemonRequest('job.read', { jobId });
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  const job = result.job as Record<string, unknown>;
+  const entries = Array.isArray(result.entries) ? result.entries as ReadResponse['entries'] : [];
+  const attempts = renderAttemptsSection(result);
+  const pendingQuestion = extractPendingQuestion(result);
+  const profile = formatProfileIdentity(job);
+  process.stdout.write(
+    [
+      `Job: ${String(job.id ?? jobId)}`,
+      `Conversation: ${String(job.conversationId ?? 'unknown')}`,
+      `Status: ${String(job.status ?? 'unknown')}`,
+      `Kind: ${String(job.kind ?? 'unknown')}`,
+      `Started: ${String(job.startedAt ?? '')}`,
+      ...(job.endedAt ? [`Ended: ${String(job.endedAt)}`] : []),
+      ...(profile ? [`Profile: ${profile}`] : []),
+      '',
+      ...(attempts ? [attempts, ''] : []),
+      ...(pendingQuestion
+        ? ['Pending Question:', formatPendingQuestion(pendingQuestion), '']
+        : []),
+      formatEntries(entries),
+    ].join('\n') + '\n',
+  );
+}
+
+async function handleJobCancel(jobId: string, program: Command): Promise<void> {
+  const result = await sendDaemonRequest('job.cancel', { jobId });
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(`${renderJobResult(result)}\n`);
+}
+
+async function handleDaemonStart(program: Command): Promise<void> {
+  const meta = await ensureDaemonMeta();
+  const result = await sendDaemonRequest('daemon.status');
+  const payload = { ...result, pid: meta.pid, startedAt: meta.startedAt };
+  if (getOutputFormat(program) === 'json') {
+    printJson(payload);
+    return;
+  }
+
+  process.stdout.write(`${renderDaemonResult(payload)}\n`);
+}
+
+async function handleDaemonStatus(program: Command): Promise<void> {
+  if (!await daemonIsRunning()) {
+    const result = { status: 'stopped' };
+    if (getOutputFormat(program) === 'json') {
+      printJson(result);
+      return;
+    }
+
+    process.stdout.write('status: stopped\n');
+    return;
+  }
+
+  const result = await sendDaemonRequest('daemon.status');
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(`${renderDaemonResult(result)}\n`);
+}
+
+async function handleDaemonStop(program: Command): Promise<void> {
+  if (!await daemonIsRunning()) {
+    const result = { status: 'stopped' };
+    if (getOutputFormat(program) === 'json') {
+      printJson(result);
+      return;
+    }
+
+    process.stdout.write('status: stopped\n');
+    return;
+  }
+
+  const result = await sendDaemonRequest('daemon.stop');
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  process.stdout.write(`${renderDaemonResult(result)}\n`);
+}
+
+async function handleDoctor(program: Command): Promise<void> {
+  const result = await inspectDoctor();
+  if (getOutputFormat(program) === 'json') {
+    printJson(result);
+    return;
+  }
+
+  const profiles = Array.isArray(result.profiles) ? result.profiles as Array<Record<string, unknown>> : [];
+  const now = Date.now();
+  process.stdout.write(
+    [
+      `Node: ${String(result.node ?? '')}`,
+      `Copilot CLI: ${String(result.copilot ?? 'not found')}`,
+      `mcpc: ${String(result.mcpc ?? 'not found')}`,
+      `Daemon running: ${String(result.daemonRunning ?? false)}`,
+      `State root: ${shortenPath(String(result.stateRoot ?? ''))}`,
+      '',
+      'Profiles:',
+      ...(profiles.length > 0
+        ? profiles.map((profile) =>
+            formatProfileSummary(profile, {
+              includeAuth: true,
+              includeModels: true,
+              includeHealth: true,
+              now,
+            }),
+          )
+        : ['- none']),
+    ].join('\n') + '\n',
+  );
+}
+
+const program = new Command();
+
+program
+  .name('cli-copilot-worker')
+  .description('Copilot-only worker CLI')
+  .version(pkg.version)
+  .option('--output <format>', 'Output format: text or json');
+
+program
+  .command('run')
+  .argument('<task.md>')
+  .description('Run a Markdown task file')
+  .option('--cwd <dir>', 'Working directory for the Copilot session')
+  .option('--model <id>', 'Copilot model id')
+  .option('--timeout <ms>', 'Timeout in milliseconds')
+  .option('--async', 'Return immediately and keep the job in the daemon')
+  .action(async (taskPath, options) => {
+    await handleRun(taskPath, options, program);
+  });
+
+program
+  .command('send')
+  .argument('<conversation-id>')
+  .argument('<message.md>')
+  .description('Send a Markdown follow-up message to an existing conversation')
+  .option('--timeout <ms>', 'Timeout in milliseconds')
+  .option('--async', 'Return immediately and keep the job in the daemon')
+  .action(async (conversationId, messagePath, options) => {
+    await handleSend(conversationId, messagePath, options, program);
+  });
+
+program
+  .command('answer')
+  .argument('<conversation-id>')
+  .argument('<answer.md>')
+  .description('Answer a pending Copilot question from a Markdown file')
+  .action(async (conversationId, answerPath) => {
+    await handleAnswer(conversationId, answerPath, program);
+  });
+
+program
+  .command('read')
+  .argument('<conversation-id>')
+  .description('Read a conversation transcript')
+  .option('--from <n>', 'First transcript entry index')
+  .option('--to <n>', 'Last transcript entry index')
+  .option('--after <n>', 'Only show entries after index N')
+  .option('--before <n>', 'Only show entries before index N')
+  .option('--tokens <n>', 'Approx token budget for the returned slice')
+  .option('--detail <level>', 'Detail level: standard, verbose, full, meta')
+  .option('--follow', 'Poll for new transcript entries while the conversation is running')
+  .action(async (conversationId, options) => {
+    await handleRead(conversationId, options, program);
+  });
+
+program
+  .command('list')
+  .description('List conversations')
+  .action(async () => {
+    await handleList(program);
+  });
+
+program
+  .command('info')
+  .argument('<conversation-id>')
+  .description('Show conversation metadata')
+  .action(async (conversationId) => {
+    await handleInfo(conversationId, program);
+  });
+
+const job = program
+  .command('job')
+  .description('Inspect background jobs');
+
+job
+  .command('list')
+  .description('List jobs')
+  .action(async () => {
+    await handleJobList(program);
+  });
+
+job
+  .command('status')
+  .argument('<job-id>')
+  .description('Show job status')
+  .action(async (jobId) => {
+    await handleJobStatus(jobId, program);
+  });
+
+job
+  .command('wait')
+  .argument('<job-id>')
+  .description('Wait for an async job to finish')
+  .option('--timeout <seconds>', 'Timeout in seconds')
+  .option('--interval <seconds>', 'Polling interval in seconds')
+  .action(async (jobId, options) => {
+    await handleJobWait(jobId, options, program);
+  });
+
+job
+  .command('read')
+  .argument('<job-id>')
+  .description('Read transcript entries for a single job')
+  .action(async (jobId) => {
+    await handleJobRead(jobId, program);
+  });
+
+job
+  .command('cancel')
+  .argument('<job-id>')
+  .description('Cancel a running job')
+  .action(async (jobId) => {
+    await handleJobCancel(jobId, program);
+  });
+
+const daemon = program
+  .command('daemon')
+  .description('Manage the local cli-copilot-worker daemon');
+
+daemon
+  .command('start')
+  .description('Start the daemon if it is not already running')
+  .action(async () => {
+    await handleDaemonStart(program);
+  });
+
+daemon
+  .command('status')
+  .description('Show daemon status')
+  .action(async () => {
+    await handleDaemonStatus(program);
+  });
+
+daemon
+  .command('stop')
+  .description('Stop the daemon')
+  .action(async () => {
+    await handleDaemonStop(program);
+  });
+
+program
+  .command('doctor')
+  .description('Check local environment and Copilot auth')
+  .action(async () => {
+    await handleDoctor(program);
+  });
+
+program
+  .command('daemon-run', { hidden: true })
+  .description('Internal daemon entrypoint')
+  .action(async () => {
+    await runDaemonServer();
+  });
+
+await program.parseAsync(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`${message}\n`);
+  process.exit(1);
+});