cli-copilot-worker 0.1.0

package/src/core/copilot.ts

@@ -0,0 +1,75 @@
+import { accessSync, constants } from 'node:fs';
+import { delimiter, join } from 'node:path';
+
+import { CopilotClient, type CopilotClientOptions } from '@github/copilot-sdk';
+
+import type { CopilotProfile } from './types.js';
+
+function canExecute(path: string): boolean {
+  try {
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function resolveCopilotCliPath(explicitPath?: string): string {
+  if (explicitPath && canExecute(explicitPath)) {
+    return explicitPath;
+  }
+
+  const configuredPath = process.env.COPILOT_CLI_PATH;
+  if (configuredPath && canExecute(configuredPath)) {
+    return configuredPath;
+  }
+
+  for (const segment of (process.env.PATH ?? '').split(delimiter)) {
+    if (!segment) {
+      continue;
+    }
+
+    const candidate = join(segment, 'copilot');
+    if (canExecute(candidate)) {
+      return candidate;
+    }
+  }
+
+  return explicitPath ?? configuredPath ?? 'copilot';
+}
+
+export function buildCopilotClientOptions(input: {
+  cwd: string;
+  profile: CopilotProfile;
+  cliPath?: string | undefined;
+}): CopilotClientOptions {
+  return {
+    cliPath: resolveCopilotCliPath(input.cliPath),
+    cliArgs: ['--config-dir', input.profile.configDir],
+    cwd: input.cwd,
+    useLoggedInUser: true,
+    useStdio: false,
+    autoStart: true,
+    autoRestart: false,
+    logLevel: 'error',
+  };
+}
+
+export async function buildAuthenticatedClient(input: {
+  cwd: string;
+  profile: CopilotProfile;
+  cliPath?: string | undefined;
+}): Promise<CopilotClient> {
+  const client = new CopilotClient(buildCopilotClientOptions(input));
+  await client.start();
+  const auth = await client.getAuthStatus();
+  if (!auth.isAuthenticated) {
+    await client.stop().catch(async () => {
+      await client.forceStop().catch(() => {});
+    });
+    throw new Error(
+      `Copilot profile "${input.profile.configDir}" is not authenticated. Run \`copilot login --config-dir ${input.profile.configDir}\`.`,
+    );
+  }
+  return client;
+}

package/src/core/failure-classifier.ts

@@ -0,0 +1,202 @@
+import type { CopilotFailureInfo, CopilotFailureCategory } from './types.js';
+
+export interface SessionErrorPayload {
+  errorType?: string | undefined;
+  message: string;
+  statusCode?: number | undefined;
+}
+
+const RATE_LIMIT_ERROR_TYPES = new Set(['quota', 'rate_limit', 'ratelimit']);
+const AUTH_ERROR_TYPES = new Set(['auth', 'authentication', 'authorization']);
+const CONNECTION_ERROR_TYPES = new Set(['connection', 'connect', 'network']);
+const TRANSIENT_ERROR_TYPES = new Set(['timeout', 'transient', 'temporary']);
+
+function normalizeMessage(input: unknown): string {
+  if (input instanceof Error) {
+    return input.message || input.name;
+  }
+
+  if (typeof input === 'string') {
+    return input;
+  }
+
+  if (input && typeof input === 'object' && 'message' in input) {
+    const value = (input as { message?: unknown }).message;
+    if (typeof value === 'string' && value.length > 0) {
+      return value;
+    }
+  }
+
+  return 'Unknown Copilot failure';
+}
+
+function buildFailureInfo(
+  category: CopilotFailureCategory,
+  message: string,
+  details?: Pick<CopilotFailureInfo, 'sessionErrorType' | 'sessionStatusCode'>,
+): CopilotFailureInfo {
+  return {
+    category,
+    retryable: category !== 'fatal',
+    message,
+    ...details,
+  };
+}
+
+function classifyStatusCode(statusCode: number | undefined): CopilotFailureCategory | undefined {
+  if (statusCode === undefined) {
+    return undefined;
+  }
+
+  if (statusCode === 429) {
+    return 'rate_limit';
+  }
+
+  if (statusCode === 401 || statusCode === 403) {
+    return 'auth';
+  }
+
+  if (statusCode >= 500 && statusCode <= 599) {
+    return 'transient';
+  }
+
+  return undefined;
+}
+
+function normalizeErrorType(errorType: string): string {
+  return errorType.toLowerCase().trim();
+}
+
+function compactErrorType(errorType: string): string {
+  return normalizeErrorType(errorType).replace(/[^a-z0-9]+/g, '');
+}
+
+function matchesErrorType(errorType: string, prefixes: string[], includes: string[] = []): boolean {
+  const normalized = normalizeErrorType(errorType);
+  const compact = compactErrorType(errorType);
+
+  return prefixes.some((prefix) => {
+    const normalizedPrefix = normalizeErrorType(prefix);
+    const compactPrefix = normalizedPrefix.replace(/[^a-z0-9]+/g, '');
+    return (
+      normalized === normalizedPrefix ||
+      normalized.startsWith(`${normalizedPrefix}_`) ||
+      normalized.startsWith(`${normalizedPrefix}-`) ||
+      compact === compactPrefix ||
+      compact.startsWith(compactPrefix)
+    );
+  }) || includes.some((fragment) => normalized.includes(fragment) || compact.includes(fragment.replace(/[^a-z0-9]+/g, '')));
+}
+
+function classifyTextualFailure(message: string): CopilotFailureCategory {
+  const text = message.toLowerCase();
+
+  if (
+    (text.includes('config dir') || text.includes('config directory') || text.includes('profile dir') || text.includes('profile directory')) &&
+    (
+      text.includes('invalid') ||
+      text.includes('missing') ||
+      text.includes('bad') ||
+      text.includes('not found') ||
+      text.includes('unreadable') ||
+      text.includes('permission denied')
+    )
+  ) {
+    return 'auth';
+  }
+
+  if (
+    text.includes('unauth') ||
+    text.includes('not authenticated') ||
+    text.includes('authentication') ||
+    text.includes('authorization') ||
+    text.includes('invalid token') ||
+    text.includes('token expired')
+  ) {
+    return 'auth';
+  }
+
+  if (
+    text.includes('429') ||
+    text.includes('rate limit') ||
+    text.includes('rate_limit') ||
+    text.includes('quota')
+  ) {
+    return 'rate_limit';
+  }
+
+  if (
+    text.includes('connect') ||
+    text.includes('connection') ||
+    text.includes('socket') ||
+    text.includes('network') ||
+    text.includes('cli server exited') ||
+    text.includes('exited with code') ||
+    text.includes('spawn ') ||
+    text.includes('econnrefused') ||
+    text.includes('econnreset')
+  ) {
+    return 'connection';
+  }
+
+  if (
+    text.includes('timeout') ||
+    text.includes('temporarily') ||
+    text.includes('temporary') ||
+    text.includes('try again')
+  ) {
+    return 'transient';
+  }
+
+  return 'fatal';
+}
+
+export function classifySessionErrorEvent(input: SessionErrorPayload): CopilotFailureInfo {
+  const errorType = input.errorType?.trim() ?? '';
+  const statusCodeCategory = classifyStatusCode(input.statusCode);
+
+  if (statusCodeCategory === 'rate_limit' || matchesErrorType(errorType, ['rate_limit', 'quota'], ['ratelimit', 'rate limit'])) {
+    return buildFailureInfo('rate_limit', input.message, {
+      sessionErrorType: input.errorType,
+      sessionStatusCode: input.statusCode,
+    });
+  }
+
+  if (statusCodeCategory === 'auth' || matchesErrorType(errorType, ['auth', 'authentication', 'authorization'], ['auth', 'login'])) {
+    return buildFailureInfo('auth', input.message, {
+      sessionErrorType: input.errorType,
+      sessionStatusCode: input.statusCode,
+    });
+  }
+
+  if (statusCodeCategory === 'transient') {
+    return buildFailureInfo('transient', input.message, {
+      sessionErrorType: input.errorType,
+      sessionStatusCode: input.statusCode,
+    });
+  }
+
+  if (matchesErrorType(errorType, ['connection', 'connect', 'network'], ['connection', 'socket'])) {
+    return buildFailureInfo('connection', input.message, {
+      sessionErrorType: input.errorType,
+      sessionStatusCode: input.statusCode,
+    });
+  }
+
+  if (matchesErrorType(errorType, ['timeout', 'transient', 'temporary'], ['retry', 'temporary'])) {
+    return buildFailureInfo('transient', input.message, {
+      sessionErrorType: input.errorType,
+      sessionStatusCode: input.statusCode,
+    });
+  }
+
+  return buildFailureInfo(classifyTextualFailure(input.message), input.message, {
+    sessionErrorType: input.errorType,
+    sessionStatusCode: input.statusCode,
+  });
+}
+
+export function classifyCopilotStartupFailure(error: unknown): CopilotFailureInfo {
+  const message = normalizeMessage(error);
+  return buildFailureInfo(classifyTextualFailure(message), message);
+}

package/src/core/ids.ts

@@ -0,0 +1,11 @@
+import { adjectives, animals, uniqueNamesGenerator } from 'unique-names-generator';
+
+export function generateId(): string {
+  const suffix = Date.now().toString().slice(-4);
+  return uniqueNamesGenerator({
+    dictionaries: [adjectives, animals],
+    separator: '-',
+    length: 2,
+    style: 'lowerCase',
+  }) + `-${suffix}`;
+}

package/src/core/markdown.ts

@@ -0,0 +1,19 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+export interface MarkdownInput {
+  path: string;
+  content: string;
+}
+
+export async function readMarkdownFile(filePath: string, cwd = process.cwd()): Promise<MarkdownInput> {
+  const absolutePath = resolve(cwd, filePath);
+  const content = (await readFile(absolutePath, 'utf8')).trim();
+  if (!content) {
+    throw new Error(`Markdown file is empty: ${filePath}`);
+  }
+  return {
+    path: absolutePath,
+    content,
+  };
+}

package/src/core/paths.ts

@@ -0,0 +1,56 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export interface StatePaths {
+  rootDir: string;
+  registryPath: string;
+  daemonMetaPath: string;
+  socketPath: string;
+}
+
+export function stateRootDir(): string {
+  const explicitRoot = process.env.CLI_COPILOT_WORKER_STATE_DIR?.trim();
+  return explicitRoot || join(homedir(), '.cli-copilot-worker');
+}
+
+export function ensureStateRoot(): StatePaths {
+  const rootDir = stateRootDir();
+  mkdirSync(rootDir, { recursive: true });
+  return {
+    rootDir,
+    registryPath: join(rootDir, 'registry.json'),
+    daemonMetaPath: join(rootDir, 'daemon.json'),
+    socketPath: join(rootDir, 'daemon.sock'),
+  };
+}
+
+export function workspaceIdForCwd(cwd: string): string {
+  return createHash('sha256').update(cwd).digest('hex').slice(0, 12);
+}
+
+export function workspaceDir(cwd: string): string {
+  return join(ensureStateRoot().rootDir, 'workspaces', workspaceIdForCwd(cwd));
+}
+
+export function ensureWorkspaceDirs(cwd: string): { workspaceDir: string; transcriptDir: string; logDir: string } {
+  const base = workspaceDir(cwd);
+  const transcriptDir = join(base, 'transcripts');
+  const logDir = join(base, 'logs');
+  mkdirSync(transcriptDir, { recursive: true });
+  mkdirSync(logDir, { recursive: true });
+  return { workspaceDir: base, transcriptDir, logDir };
+}
+
+export function transcriptPath(cwd: string, conversationId: string): string {
+  return join(ensureWorkspaceDirs(cwd).transcriptDir, `${conversationId}.jsonl`);
+}
+
+export function logPath(cwd: string, conversationId: string): string {
+  return join(ensureWorkspaceDirs(cwd).logDir, `${conversationId}.log`);
+}
+
+export function buildDaemonToken(): string {
+  return randomUUID();
+}

package/src/core/profile-faults.ts

@@ -0,0 +1,140 @@
+import type { CopilotProfile, CopilotFailureCategory } from './types.js';
+
+export interface InjectedProfileFault {
+  category: CopilotFailureCategory;
+  remaining?: number | undefined;
+  message?: string | undefined;
+  errorType?: string | undefined;
+  statusCode?: number | undefined;
+}
+
+type StoredFault = InjectedProfileFault & {
+  remaining?: number | undefined;
+};
+
+function defaultErrorType(category: CopilotFailureCategory): string {
+  switch (category) {
+    case 'auth':
+      return 'authentication';
+    case 'rate_limit':
+      return 'rate_limit';
+    case 'connection':
+      return 'connection';
+    case 'transient':
+      return 'transient';
+    case 'fatal':
+      return 'fatal';
+  }
+}
+
+function defaultStatusCode(category: CopilotFailureCategory): number | undefined {
+  switch (category) {
+    case 'auth':
+      return 401;
+    case 'rate_limit':
+      return 429;
+    case 'connection':
+      return undefined;
+    case 'transient':
+      return 504;
+    case 'fatal':
+      return undefined;
+  }
+}
+
+function defaultMessage(profile: Pick<CopilotProfile, 'id' | 'configDir'>, category: CopilotFailureCategory): string {
+  return `Injected ${category} failure for profile ${profile.id} (${profile.configDir})`;
+}
+
+function normalizeFault(value: unknown): StoredFault | undefined {
+  if (typeof value === 'string') {
+    return { category: value as CopilotFailureCategory };
+  }
+
+  if (!value || typeof value !== 'object') {
+    return undefined;
+  }
+
+  const raw = value as Partial<InjectedProfileFault> & { category?: unknown };
+  if (typeof raw.category !== 'string') {
+    return undefined;
+  }
+
+  const remaining = typeof raw.remaining === 'number' && Number.isFinite(raw.remaining)
+    ? Math.max(0, Math.trunc(raw.remaining))
+    : undefined;
+
+  return {
+    category: raw.category as CopilotFailureCategory,
+    remaining,
+    message: typeof raw.message === 'string' ? raw.message : undefined,
+    errorType: typeof raw.errorType === 'string' ? raw.errorType : undefined,
+    statusCode: typeof raw.statusCode === 'number' && Number.isFinite(raw.statusCode)
+      ? Math.trunc(raw.statusCode)
+      : undefined,
+  };
+}
+
+export class ProfileFaultPlanner {
+  private readonly faults = new Map<string, StoredFault>();
+
+  constructor(raw = process.env.CLI_COPILOT_WORKER_PROFILE_FAULTS) {
+    if (!raw) {
+      return;
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw) as unknown;
+    } catch (error) {
+      throw new Error(`Failed to parse CLI_COPILOT_WORKER_PROFILE_FAULTS: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    if (!parsed || typeof parsed !== 'object') {
+      throw new Error('CLI_COPILOT_WORKER_PROFILE_FAULTS must be a JSON object');
+    }
+
+    for (const [key, value] of Object.entries(parsed as Record<string, unknown>)) {
+      const fault = normalizeFault(value);
+      if (fault) {
+        this.faults.set(key, fault);
+      }
+    }
+  }
+
+  static fromEnvironment(): ProfileFaultPlanner {
+    return new ProfileFaultPlanner();
+  }
+
+  takeFault(profile: Pick<CopilotProfile, 'id' | 'configDir'>): InjectedProfileFault | undefined {
+    const fault = this.findFault(profile);
+    if (!fault) {
+      return undefined;
+    }
+
+    if (fault.remaining !== undefined) {
+      fault.remaining -= 1;
+      if (fault.remaining <= 0) {
+        this.faults.delete(profile.configDir);
+        this.faults.delete(profile.id);
+      }
+    }
+
+    return {
+      category: fault.category,
+      remaining: fault.remaining,
+      message: fault.message ?? defaultMessage(profile, fault.category),
+      errorType: fault.errorType ?? defaultErrorType(fault.category),
+      statusCode: fault.statusCode ?? defaultStatusCode(fault.category),
+    };
+  }
+
+  private findFault(profile: Pick<CopilotProfile, 'id' | 'configDir'>): StoredFault | undefined {
+    const byConfigDir = this.faults.get(profile.configDir);
+    if (byConfigDir) {
+      return byConfigDir;
+    }
+
+    return this.faults.get(profile.id);
+  }
+}