cli-copilot-worker 0.1.0

package/src/doctor.ts

@@ -0,0 +1,82 @@
+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 './core/copilot.js';
+import { stateRootDir } from './core/paths.js';
+import { ProfileManager } from './core/profile-manager.js';
+import { PersistentStore } from './core/store.js';
+import { daemonIsRunning } from './daemon/client.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;
+  }
+}
+
+export async function inspectDoctor(): Promise<Record<string, unknown>> {
+  const store = new PersistentStore();
+  await store.load();
+  const profileManager = ProfileManager.fromEnvironment(store.getProfiles());
+  const profiles = profileManager.getProfiles();
+  const inspectedProfiles = await Promise.all(
+    profiles.map(async (profile) => {
+      const health = {
+        id: profile.id,
+        configDir: profile.configDir,
+        cooldownUntil: profile.cooldownUntil,
+        failureCount: profile.failureCount,
+        lastFailureReason: profile.lastFailureReason,
+        lastFailureCategory: profile.lastFailureCategory,
+        lastFailureAt: profile.lastFailureAt,
+        lastSuccessAt: profile.lastSuccessAt,
+      };
+      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 {
+          ...health,
+          authenticated: auth.isAuthenticated,
+          login: auth.login,
+          models: models.slice(0, 10).map((model) => model.id),
+        };
+      } catch (error) {
+        return {
+          ...health,
+          authenticated: false,
+          error: error instanceof Error ? error.message : String(error),
+          models: [],
+        };
+      } finally {
+        await client.stop().catch(async () => {
+          await client.forceStop().catch(() => {});
+        });
+      }
+    }),
+  );
+
+  return {
+    node: process.version,
+    copilot: await commandVersion('copilot'),
+    mcpc: await commandVersion('mcpc'),
+    cwd: process.cwd(),
+    daemonRunning: await daemonIsRunning(),
+    stateRoot: stateRootDir(),
+    profiles: inspectedProfiles,
+  };
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { sendDaemonRequest, ensureDaemonMeta, daemonIsRunning } from './daemon/client.js';
+export { CliCopilotWorkerService } from './daemon/service.js';
+export { PersistentStore } from './core/store.js';

package/src/output.ts

@@ -0,0 +1,391 @@
+import { homedir } from 'node:os';
+import process from 'node:process';
+
+import type { PendingQuestion, TranscriptEntry } from './core/types.js';
+
+export type OutputFormat = 'text' | 'json';
+
+export interface EventPrinter {
+  onEvent: (event: string, data: Record<string, unknown>) => void;
+  finish: () => void;
+}
+
+export function resolveOutputFormat(explicit?: string | undefined): OutputFormat {
+  if (!explicit) {
+    return process.stdout.isTTY ? 'text' : 'json';
+  }
+
+  if (explicit === 'text' || explicit === 'json') {
+    return explicit;
+  }
+
+  throw new Error(`Invalid output format: ${explicit}. Use "text" or "json".`);
+}
+
+export function printJson(data: unknown): void {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+
+export function shortenPath(path: string): string {
+  const home = homedir();
+  return path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+}
+
+export function formatActions(actions?: Record<string, unknown> | undefined): string {
+  const lines = Object.entries(actions ?? {})
+    .filter(([, value]) => typeof value === 'string' && value.length > 0)
+    .map(([name, value]) => `- ${name}: ${String(value)}`);
+
+  return lines.length > 0 ? lines.join('\n') : '- none';
+}
+
+export function formatPendingQuestion(question?: PendingQuestion | undefined): string {
+  if (!question) {
+    return 'No pending question.';
+  }
+
+  const lines = [
+    question.question,
+  ];
+
+  if (question.choices && question.choices.length > 0) {
+    lines.push('');
+    question.choices.forEach((choice, index) => {
+      lines.push(`${index + 1}. ${choice}`);
+    });
+  }
+
+  lines.push('');
+  lines.push(`Freeform allowed: ${question.allowFreeform ? 'yes' : 'no'}`);
+  return lines.join('\n');
+}
+
+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 numberValue(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+
+function trimText(value: string, maxLength = 140): string {
+  if (value.length <= maxLength) {
+    return value;
+  }
+
+  return `${value.slice(0, maxLength - 1)}…`;
+}
+
+function formatOutcomeDetails(attempt: Record<string, unknown>): string | undefined {
+  const category = stringValue(attempt.failureCategory);
+  const message = stringValue(attempt.failureMessage);
+
+  if (!category && !message) {
+    return undefined;
+  }
+
+  if (category && message) {
+    return `[${category}] ${trimText(message)}`;
+  }
+
+  return category ? `[${category}]` : trimText(message!);
+}
+
+function formatAttemptMeta(attempt: Record<string, unknown>): string[] {
+  const lines: string[] = [];
+  const startedAt = stringValue(attempt.startedAt);
+  const endedAt = stringValue(attempt.endedAt);
+  const sessionErrorType = stringValue(attempt.sessionErrorType);
+  const sessionStatusCode = numberValue(attempt.sessionStatusCode);
+
+  if (startedAt) {
+    lines.push(`started: ${startedAt}`);
+  }
+
+  if (endedAt) {
+    lines.push(`ended: ${endedAt}`);
+  }
+
+  if (sessionErrorType || sessionStatusCode !== undefined) {
+    const sessionBits: string[] = [];
+    if (sessionErrorType) {
+      sessionBits.push(`type=${sessionErrorType}`);
+    }
+    if (sessionStatusCode !== undefined) {
+      sessionBits.push(`status=${sessionStatusCode}`);
+    }
+    lines.push(`session: ${sessionBits.join(' ')}`);
+  }
+
+  return lines;
+}
+
+export function formatAttemptHistory(attempts: unknown): string {
+  const records = Array.isArray(attempts)
+    ? attempts.filter(isRecord)
+    : [];
+
+  if (records.length === 0) {
+    return '';
+  }
+
+  const lines: string[] = ['Attempts:'];
+  const firstProfile = stringValue(records[0]?.profileId);
+  const lastProfile = stringValue(records[records.length - 1]?.profileId);
+  const firstConfigDir = stringValue(records[0]?.profileConfigDir);
+  const lastConfigDir = stringValue(records[records.length - 1]?.profileConfigDir);
+
+  if (
+    records.length > 1 &&
+    firstProfile &&
+    lastProfile &&
+    firstProfile !== lastProfile
+  ) {
+    const from = firstConfigDir ? `${firstProfile} ${shortenPath(firstConfigDir)}` : firstProfile;
+    const to = lastConfigDir ? `${lastProfile} ${shortenPath(lastConfigDir)}` : lastProfile;
+    lines.push(`Failover: ${from} -> ${to}`);
+  }
+
+  records.forEach((attempt, index) => {
+    const profileId = stringValue(attempt.profileId) ?? 'unknown';
+    const configDir = stringValue(attempt.profileConfigDir);
+    const outcome = stringValue(attempt.outcome) ?? 'unknown';
+    const outcomeDetails = formatOutcomeDetails(attempt);
+
+    const headlineParts = [`- ${index + 1}. ${profileId}`];
+    if (configDir) {
+      headlineParts.push(shortenPath(configDir));
+    }
+    headlineParts.push(outcome);
+    if (outcomeDetails) {
+      headlineParts.push(outcomeDetails);
+    }
+
+    lines.push(headlineParts.join(' '));
+    for (const detail of formatAttemptMeta(attempt)) {
+      lines.push(`  ${detail}`);
+    }
+  });
+
+  return lines.join('\n');
+}
+
+function formatModelSummary(models: unknown): string | undefined {
+  if (!Array.isArray(models) || models.length === 0) {
+    return undefined;
+  }
+
+  const ids = models.filter((model): model is string => typeof model === 'string' && model.length > 0);
+  if (ids.length === 0) {
+    return undefined;
+  }
+
+  const preview = ids.slice(0, 3);
+  const suffix = ids.length > preview.length ? ', …' : '';
+  return `models=${ids.length} [${preview.join(', ')}${suffix}]`;
+}
+
+function formatHealthSummary(profile: Record<string, unknown>, now = Date.now()): string {
+  const cooldownUntil = numberValue(profile.cooldownUntil);
+  const failureCount = numberValue(profile.failureCount);
+  const lastFailureCategory = stringValue(profile.lastFailureCategory);
+  const lastFailureReason = stringValue(profile.lastFailureReason);
+  const lastSuccessAt = stringValue(profile.lastSuccessAt);
+
+  if (cooldownUntil !== undefined && cooldownUntil > now) {
+    const parts = [
+      'cooling-down',
+      `until=${new Date(cooldownUntil).toISOString()}`,
+    ];
+    if (lastFailureCategory || lastFailureReason) {
+      parts.push(`lastFailure=${formatOutcomeDetails({
+        failureCategory: lastFailureCategory,
+        failureMessage: lastFailureReason,
+      }) ?? 'unknown'}`);
+    }
+    if (failureCount !== undefined) {
+      parts.push(`failures=${failureCount}`);
+    }
+    return parts.join(' ');
+  }
+
+  const parts = [failureCount && failureCount > 0 ? 'degraded' : 'healthy'];
+  if (failureCount !== undefined) {
+    parts.push(`failures=${failureCount}`);
+  }
+  if (lastFailureCategory || lastFailureReason) {
+    parts.push(`lastFailure=${formatOutcomeDetails({
+      failureCategory: lastFailureCategory,
+      failureMessage: lastFailureReason,
+    }) ?? 'unknown'}`);
+  }
+  if (lastSuccessAt) {
+    parts.push(`lastSuccess=${lastSuccessAt}`);
+  }
+  return parts.join(' ');
+}
+
+export function formatProfileSummary(
+  profile: Record<string, unknown>,
+  options?: {
+    includeAuth?: boolean | undefined;
+    includeHealth?: boolean | undefined;
+    includeModels?: boolean | undefined;
+    now?: number | undefined;
+  },
+): string {
+  const parts = [
+    `- ${stringValue(profile.id) ?? 'unknown'}`,
+    stringValue(profile.configDir) ? shortenPath(stringValue(profile.configDir)!) : undefined,
+  ].filter((part): part is string => part !== undefined);
+
+  if (options?.includeAuth) {
+    parts.push(`authenticated=${String(profile.authenticated ?? false)}`);
+    const login = stringValue(profile.login);
+    if (login) {
+      parts.push(`login=${login}`);
+    }
+  }
+
+  if (options?.includeModels) {
+    const models = formatModelSummary(profile.models);
+    if (models) {
+      parts.push(models);
+    }
+  }
+
+  if (options?.includeHealth ?? true) {
+    parts.push(`health=${formatHealthSummary(profile, options?.now)}`);
+  }
+
+  const error = stringValue(profile.error);
+  if (error) {
+    parts.push(`error=${trimText(error)}`);
+  }
+
+  return parts.join(' ');
+}
+
+export function formatProfilesSection(
+  profiles: unknown,
+  options?: {
+    includeAuth?: boolean | undefined;
+    includeHealth?: boolean | undefined;
+    includeModels?: boolean | undefined;
+    now?: number | undefined;
+  },
+): string {
+  const items = Array.isArray(profiles)
+    ? profiles.filter(isRecord)
+    : [];
+
+  if (items.length === 0) {
+    return '';
+  }
+
+  return [
+    'Profiles:',
+    ...items.map((profile) => formatProfileSummary(profile, options)),
+  ].join('\n');
+}
+
+type TranscriptRenderableEntry = Pick<TranscriptEntry, 'index' | 'role' | 'content' | 'timestamp' | 'data'>;
+
+export function formatEntries(entries: TranscriptRenderableEntry[]): string {
+  if (entries.length === 0) {
+    return 'No transcript entries.';
+  }
+
+  return entries
+    .map((entry) => {
+      const header = `${entry.index}. ${entry.role} @ ${entry.timestamp}`;
+      const content = entry.content.trim().length > 0 ? entry.content : JSON.stringify(entry.data ?? {});
+      const body = content
+        .split('\n')
+        .map((line) => `   ${line}`)
+        .join('\n');
+      return `${header}\n${body}`;
+    })
+    .join('\n\n');
+}
+
+export function createEventPrinter(enabled: boolean): EventPrinter {
+  let assistantOpen = false;
+
+  const ensureNewline = () => {
+    if (assistantOpen) {
+      process.stdout.write('\n');
+      assistantOpen = false;
+    }
+  };
+
+  return {
+    onEvent(event, data) {
+      if (!enabled) {
+        return;
+      }
+
+      switch (event) {
+        case 'assistant.delta': {
+          const text = typeof data.text === 'string' ? data.text : '';
+          if (!text) {
+            return;
+          }
+          process.stdout.write(text);
+          assistantOpen = !text.endsWith('\n');
+          return;
+        }
+        case 'status': {
+          ensureNewline();
+          const message = typeof data.message === 'string' ? data.message : JSON.stringify(data);
+          process.stdout.write(`[status] ${message}\n`);
+          return;
+        }
+        case 'tool.start': {
+          ensureNewline();
+          process.stdout.write(`[tool] start ${String(data.toolName ?? 'unknown')}\n`);
+          return;
+        }
+        case 'tool.complete': {
+          ensureNewline();
+          process.stdout.write(
+            `[tool] complete ${String(data.toolName ?? 'unknown')} success=${String(data.success ?? false)}\n`,
+          );
+          return;
+        }
+        case 'question': {
+          ensureNewline();
+          const question = typeof data.question === 'string' ? data.question : 'Question requested';
+          process.stdout.write(`[question] ${question}\n`);
+          const choices = Array.isArray(data.choices) ? data.choices.filter((item): item is string => typeof item === 'string') : [];
+          choices.forEach((choice, index) => {
+            process.stdout.write(`  ${index + 1}. ${choice}\n`);
+          });
+          process.stdout.write(`  freeform=${String(data.allowFreeform ?? true)}\n`);
+          return;
+        }
+        case 'answer': {
+          ensureNewline();
+          process.stdout.write(`[answer] ${String(data.answer ?? 'submitted')}\n`);
+          return;
+        }
+        case 'error': {
+          ensureNewline();
+          process.stdout.write(`[error] ${String(data.message ?? JSON.stringify(data))}\n`);
+          return;
+        }
+        default: {
+          ensureNewline();
+          process.stdout.write(`[${event}] ${JSON.stringify(data)}\n`);
+        }
+      }
+    },
+    finish() {
+      ensureNewline();
+    },
+  };
+}