cli-copilot-worker 0.1.0

package/src/core/profile-manager.ts

@@ -0,0 +1,220 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import type {
+  CopilotFailureCategory,
+  CopilotProfile,
+  PersistedProfileState,
+} from './types.js';
+
+const DEFAULT_PROFILE_COOLDOWNS: Record<CopilotFailureCategory, number> = {
+  auth: 5 * 60_000,
+  rate_limit: 15 * 60_000,
+  connection: 60_000,
+  transient: 30_000,
+  fatal: 0,
+};
+
+function defaultProfileDir(): string {
+  return join(homedir(), '.copilot');
+}
+
+function dedupeProfileDirs(profileDirs: string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  for (const dir of profileDirs) {
+    const normalized = dir.trim();
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    result.push(normalized);
+  }
+
+  return result.length > 0 ? result : [defaultProfileDir()];
+}
+
+function buildCooldowns(options?: {
+  cooldownMs?: number | undefined;
+  cooldowns?: Partial<Record<CopilotFailureCategory, number>> | undefined;
+}): Record<CopilotFailureCategory, number> {
+  const cooldowns: Record<CopilotFailureCategory, number> = {
+    ...DEFAULT_PROFILE_COOLDOWNS,
+  };
+
+  if (options?.cooldownMs !== undefined) {
+    cooldowns.auth = options.cooldownMs;
+    cooldowns.rate_limit = options.cooldownMs;
+    cooldowns.connection = options.cooldownMs;
+    cooldowns.transient = options.cooldownMs;
+  }
+
+  for (const [category, value] of Object.entries(options?.cooldowns ?? {})) {
+    if (value !== undefined) {
+      cooldowns[category as CopilotFailureCategory] = value;
+    }
+  }
+
+  return cooldowns;
+}
+
+export class ProfileManager {
+  private readonly cooldowns: Record<CopilotFailureCategory, number>;
+  private readonly now: () => number;
+  private readonly profiles: CopilotProfile[];
+  private currentIndex = 0;
+
+  constructor(options?: {
+    profileDirs?: string[] | undefined;
+    cooldownMs?: number | undefined;
+    cooldowns?: Partial<Record<CopilotFailureCategory, number>> | undefined;
+    now?: (() => number) | undefined;
+    persistedProfiles?: PersistedProfileState[] | undefined;
+  }) {
+    this.cooldowns = buildCooldowns({
+      cooldownMs: options?.cooldownMs,
+      cooldowns: options?.cooldowns,
+    });
+    this.now = options?.now ?? Date.now;
+
+    const configuredDirs = dedupeProfileDirs(options?.profileDirs ?? [defaultProfileDir()]);
+    const persistedByDir = new Map(
+      (options?.persistedProfiles ?? []).map((profile) => [profile.configDir, profile]),
+    );
+
+    this.profiles = configuredDirs.map((configDir, index) => {
+      const persisted = persistedByDir.get(configDir);
+      return {
+        id: persisted?.id ?? `profile-${index + 1}`,
+        configDir,
+        cooldownUntil: persisted?.cooldownUntil,
+        failureCount: persisted?.failureCount ?? 0,
+        lastFailureReason: persisted?.lastFailureReason,
+        lastFailureCategory: persisted?.lastFailureCategory,
+        lastFailureAt: persisted?.lastFailureAt,
+        lastSuccessAt: persisted?.lastSuccessAt,
+      };
+    });
+
+    this.currentIndex = this.findFirstAvailableIndex();
+  }
+
+  static fromEnvironment(persistedProfiles?: PersistedProfileState[]): ProfileManager {
+    const raw = process.env.COPILOT_CONFIG_DIRS;
+    const dirs = raw
+      ? raw.split(',').map((entry) => entry.trim()).filter(Boolean)
+      : [defaultProfileDir()];
+
+    return new ProfileManager({ profileDirs: dirs, persistedProfiles });
+  }
+
+  getCandidateProfiles(): CopilotProfile[] {
+    this.resetExpiredCooldowns();
+    return this.profiles
+      .filter((profile) => profile.cooldownUntil === undefined || profile.cooldownUntil <= this.now())
+      .map((profile) => ({ ...profile }));
+  }
+
+  getCurrentProfile(): CopilotProfile {
+    this.resetExpiredCooldowns();
+    const profile = this.profiles[this.currentIndex] ?? this.profiles[0];
+    if (!profile) {
+      throw new Error('No profiles configured');
+    }
+
+    return { ...profile };
+  }
+
+  markFailure(reason: string): void;
+  markFailure(profileId: string, category: CopilotFailureCategory, reason: string): void;
+  markFailure(
+    profileIdOrReason: string,
+    category?: CopilotFailureCategory,
+    reason?: string,
+  ): void {
+    const usingTypedSignature = reason !== undefined;
+    const profile = usingTypedSignature
+      ? this.profiles.find((entry) => entry.id === profileIdOrReason)
+      : this.profiles[this.currentIndex];
+
+    if (!profile) {
+      return;
+    }
+
+    const failureCategory = usingTypedSignature ? category! : 'transient';
+    const failureReason = usingTypedSignature ? reason! : profileIdOrReason;
+
+    profile.failureCount += 1;
+    profile.lastFailureReason = failureReason;
+    profile.lastFailureCategory = failureCategory;
+    profile.lastFailureAt = new Date(this.now()).toISOString();
+
+    const cooldownMs = this.getCooldownMs(failureCategory);
+    profile.cooldownUntil = cooldownMs > 0 ? this.now() + cooldownMs : undefined;
+
+    if (!usingTypedSignature) {
+      const nextIndex = this.findFirstAvailableIndex();
+      if (nextIndex !== -1) {
+        this.currentIndex = nextIndex;
+      }
+    }
+  }
+
+  markSuccess(profileId: string): void {
+    const profile = this.profiles.find((entry) => entry.id === profileId);
+    if (!profile) {
+      return;
+    }
+
+    profile.cooldownUntil = undefined;
+    profile.lastSuccessAt = new Date(this.now()).toISOString();
+
+    const nextIndex = this.findFirstAvailableIndex();
+    if (nextIndex !== -1) {
+      this.currentIndex = nextIndex;
+    }
+  }
+
+  getCooldownMs(category: CopilotFailureCategory): number {
+    return this.cooldowns[category];
+  }
+
+  getProfiles(): CopilotProfile[] {
+    return this.profiles.map((profile) => ({ ...profile }));
+  }
+
+  toPersistedState(): PersistedProfileState[] {
+    return this.profiles.map((profile) => ({
+      id: profile.id,
+      configDir: profile.configDir,
+      cooldownUntil: profile.cooldownUntil,
+      failureCount: profile.failureCount,
+      lastFailureReason: profile.lastFailureReason,
+      lastFailureCategory: profile.lastFailureCategory,
+      lastFailureAt: profile.lastFailureAt,
+      lastSuccessAt: profile.lastSuccessAt,
+    }));
+  }
+
+  private resetExpiredCooldowns(): void {
+    const now = this.now();
+    for (const profile of this.profiles) {
+      if (profile.cooldownUntil !== undefined && profile.cooldownUntil <= now) {
+        profile.cooldownUntil = undefined;
+      }
+    }
+
+    const nextIndex = this.findFirstAvailableIndex();
+    if (nextIndex !== -1) {
+      this.currentIndex = nextIndex;
+    }
+  }
+
+  private findFirstAvailableIndex(): number {
+    const now = this.now();
+    return this.profiles.findIndex(
+      (profile) => profile.cooldownUntil === undefined || profile.cooldownUntil <= now,
+    );
+  }
+}

package/src/core/question-registry.ts

@@ -0,0 +1,191 @@
+import type { PersistentStore } from './store.js';
+import type { PendingQuestion } from './types.js';
+
+interface QuestionBinding {
+  conversationId: string;
+  jobId: string;
+  sessionId: string;
+  question: PendingQuestion;
+  timeout: NodeJS.Timeout;
+  resolve: (value: { answer: string; wasFreeform: boolean }) => void;
+  reject: (error: Error) => void;
+}
+
+function parseAnswer(
+  rawAnswer: string,
+  question: PendingQuestion,
+): { success: boolean; resolvedAnswer?: string; wasFreeform?: boolean; error?: string } {
+  const answer = rawAnswer.trim();
+  if (!answer) {
+    return { success: false, error: 'Answer cannot be empty' };
+  }
+
+  if (question.choices && /^\d+$/.test(answer)) {
+    const index = Number.parseInt(answer, 10) - 1;
+    if (index < 0 || index >= question.choices.length) {
+      return { success: false, error: `Invalid choice. Please enter 1-${question.choices.length}.` };
+    }
+    return {
+      success: true,
+      resolvedAnswer: question.choices[index]!,
+      wasFreeform: false,
+    };
+  }
+
+  if (question.choices?.some((choice) => choice.toLowerCase() === answer.toLowerCase())) {
+    const resolved = question.choices.find((choice) => choice.toLowerCase() === answer.toLowerCase())!;
+    return {
+      success: true,
+      resolvedAnswer: resolved,
+      wasFreeform: false,
+    };
+  }
+
+  if (answer.toUpperCase().startsWith('OTHER:') && question.allowFreeform) {
+    const custom = answer.slice('OTHER:'.length).trim();
+    if (!custom) {
+      return { success: false, error: 'OTHER: requires text after the colon.' };
+    }
+    return {
+      success: true,
+      resolvedAnswer: custom,
+      wasFreeform: true,
+    };
+  }
+
+  if (question.allowFreeform) {
+    return {
+      success: true,
+      resolvedAnswer: answer,
+      wasFreeform: true,
+    };
+  }
+
+  return { success: false, error: 'Invalid answer' };
+}
+
+export class QuestionRegistry {
+  private readonly pending = new Map<string, QuestionBinding>();
+
+  constructor(
+    private readonly store: PersistentStore,
+    private readonly onEvent?: ((conversationId: string, event: string, data: Record<string, unknown>) => void) | undefined,
+    private readonly timeoutMs = 30 * 60 * 1000,
+  ) {}
+
+  async register(input: {
+    conversationId: string;
+    jobId: string;
+    sessionId: string;
+    question: string;
+    choices?: string[] | undefined;
+    allowFreeform?: boolean | undefined;
+  }): Promise<{ answer: string; wasFreeform: boolean }> {
+    this.clear(input.conversationId, 'replaced by a newer question');
+
+    return new Promise((resolve, reject) => {
+      const pendingQuestion: PendingQuestion = {
+        question: input.question,
+        choices: input.choices,
+        allowFreeform: input.allowFreeform ?? true,
+        askedAt: new Date().toISOString(),
+        sessionId: input.sessionId,
+      };
+
+      const timeout = setTimeout(() => {
+        void this.store.appendTranscript({
+          conversationId: input.conversationId,
+          jobId: input.jobId,
+          role: 'error',
+          content: 'Question timed out after 30 minutes.',
+        });
+        this.store.updatePendingQuestion(input.conversationId, undefined, 'failed');
+        this.store.finalizeJob(input.jobId, 'failed', 'Question timed out after 30 minutes');
+        reject(new Error('Question timed out'));
+        this.pending.delete(input.conversationId);
+        void this.store.persist();
+      }, this.timeoutMs);
+      timeout.unref();
+
+      this.pending.set(input.conversationId, {
+        conversationId: input.conversationId,
+        jobId: input.jobId,
+        sessionId: input.sessionId,
+        question: pendingQuestion,
+        timeout,
+        resolve,
+        reject,
+      });
+
+      this.store.updatePendingQuestion(input.conversationId, pendingQuestion, 'waiting_answer');
+      this.store.updateJob(input.jobId, { status: 'waiting_answer' });
+      void this.store.appendTranscript({
+        conversationId: input.conversationId,
+        jobId: input.jobId,
+        role: 'question',
+        content: input.question,
+        data: {
+          choices: input.choices,
+          allowFreeform: input.allowFreeform ?? true,
+        },
+      });
+      this.onEvent?.(input.conversationId, 'question', {
+        conversationId: input.conversationId,
+        question: input.question,
+        choices: input.choices ?? [],
+        allowFreeform: input.allowFreeform ?? true,
+      });
+      void this.store.persist();
+    });
+  }
+
+  submitAnswer(conversationId: string, rawAnswer: string): { success: boolean; resolvedAnswer?: string; error?: string } {
+    const binding = this.pending.get(conversationId);
+    if (!binding) {
+      return { success: false, error: 'No pending question for this conversation' };
+    }
+
+    const parsed = parseAnswer(rawAnswer, binding.question);
+    if (!parsed.success) {
+      return parsed;
+    }
+
+    clearTimeout(binding.timeout);
+    binding.resolve({
+      answer: parsed.resolvedAnswer!,
+      wasFreeform: parsed.wasFreeform!,
+    });
+    this.pending.delete(conversationId);
+    this.store.updatePendingQuestion(conversationId, undefined, 'running');
+    this.store.updateJob(binding.jobId, { status: 'running' });
+    void this.store.appendTranscript({
+      conversationId,
+      jobId: binding.jobId,
+      role: 'answer',
+      content: parsed.resolvedAnswer!,
+    });
+    this.onEvent?.(conversationId, 'answer', {
+      conversationId,
+      answer: parsed.resolvedAnswer!,
+    });
+    void this.store.persist();
+
+    return {
+      success: true,
+      resolvedAnswer: parsed.resolvedAnswer,
+    };
+  }
+
+  clear(conversationId: string, reason: string): void {
+    const binding = this.pending.get(conversationId);
+    if (!binding) {
+      return;
+    }
+
+    clearTimeout(binding.timeout);
+    binding.reject(new Error(reason));
+    this.pending.delete(conversationId);
+    this.store.updatePendingQuestion(conversationId, undefined, 'idle');
+    void this.store.persist();
+  }
+}

package/src/core/store.ts

@@ -0,0 +1,273 @@
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+
+import { generateId } from './ids.js';
+import { ensureStateRoot, logPath, transcriptPath, workspaceIdForCwd } from './paths.js';
+import type {
+  ConversationRecord,
+  CopilotProfile,
+  JobKind,
+  JobAttemptRecord,
+  JobRecord,
+  PendingQuestion,
+  PersistedProfileState,
+  StateFile,
+  TranscriptEntry,
+  ConversationStatus,
+  JobStatus,
+} from './types.js';
+
+const EMPTY_STATE: StateFile = {
+  version: 1,
+  conversations: [],
+  jobs: [],
+  profiles: [],
+};
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+export class PersistentStore {
+  private readonly root = ensureStateRoot();
+  private state: StateFile = structuredClone(EMPTY_STATE);
+
+  async load(): Promise<void> {
+    if (!existsSync(this.root.registryPath)) {
+      this.state = structuredClone(EMPTY_STATE);
+      await this.persist();
+      return;
+    }
+
+    const raw = await readFile(this.root.registryPath, 'utf8');
+    this.state = this.normalizeState(JSON.parse(raw) as StateFile);
+  }
+
+  getProfiles(): PersistedProfileState[] {
+    return [...this.state.profiles];
+  }
+
+  setProfiles(profiles: PersistedProfileState[]): void {
+    this.state.profiles = profiles;
+  }
+
+  listConversations(): ConversationRecord[] {
+    return [...this.state.conversations].sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+  }
+
+  getConversation(conversationId: string): ConversationRecord | undefined {
+    const lowered = conversationId.toLowerCase();
+    return this.state.conversations.find((conversation) => conversation.id.toLowerCase() === lowered);
+  }
+
+  resolveConversation(conversationIdOrPrefix: string): ConversationRecord | undefined {
+    const exact = this.getConversation(conversationIdOrPrefix);
+    if (exact) {
+      return exact;
+    }
+
+    const lowered = conversationIdOrPrefix.toLowerCase();
+    const matches = this.state.conversations.filter((conversation) => conversation.id.toLowerCase().startsWith(lowered));
+    return matches.length === 1 ? matches[0] : undefined;
+  }
+
+  createConversation(input: {
+    cwd: string;
+    model: string;
+  }): ConversationRecord {
+    const timestamp = nowIso();
+    const conversation: ConversationRecord = {
+      id: generateId(),
+      sessionId: generateId(),
+      workspaceId: workspaceIdForCwd(input.cwd),
+      cwd: input.cwd,
+      model: input.model,
+      status: 'idle',
+      createdAt: timestamp,
+      updatedAt: timestamp,
+      hasStarted: false,
+      nextEntryIndex: 1,
+    };
+
+    this.state.conversations.push(conversation);
+    return conversation;
+  }
+
+  updateConversation(conversationId: string, updates: Partial<ConversationRecord>): ConversationRecord {
+    const conversation = this.getConversation(conversationId);
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${conversationId}`);
+    }
+
+    Object.assign(conversation, updates, { updatedAt: nowIso() });
+    return conversation;
+  }
+
+  listJobs(): JobRecord[] {
+    return [...this.state.jobs].sort((left, right) => right.startedAt.localeCompare(left.startedAt));
+  }
+
+  getJob(jobId: string): JobRecord | undefined {
+    const lowered = jobId.toLowerCase();
+    return this.state.jobs.find((job) => job.id.toLowerCase() === lowered);
+  }
+
+  jobsForConversation(conversationId: string): JobRecord[] {
+    return this.state.jobs
+      .filter((job) => job.conversationId === conversationId)
+      .sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+  }
+
+  createJob(input: {
+    conversationId: string;
+    kind: JobKind;
+    inputFilePath: string;
+  }): JobRecord {
+    const conversation = this.getConversation(input.conversationId);
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${input.conversationId}`);
+    }
+
+    const timestamp = nowIso();
+    const turnIndex = this.jobsForConversation(input.conversationId).length + 1;
+    const job: JobRecord = {
+      id: generateId(),
+      conversationId: input.conversationId,
+      kind: input.kind,
+      status: 'running',
+      inputFilePath: input.inputFilePath,
+      createdAt: timestamp,
+      startedAt: timestamp,
+      turnIndex,
+      startEntryIndex: conversation.nextEntryIndex,
+      attempts: [],
+    };
+
+    conversation.lastJobId = job.id;
+    conversation.status = 'running';
+    conversation.updatedAt = timestamp;
+    this.state.jobs.push(job);
+    return job;
+  }
+
+  createJobAttempt(jobId: string, profile: Pick<CopilotProfile, 'id' | 'configDir'>): JobAttemptRecord {
+    const job = this.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+
+    const attempt: JobAttemptRecord = {
+      profileId: profile.id,
+      profileConfigDir: profile.configDir,
+      startedAt: nowIso(),
+      outcome: 'running',
+    };
+    job.attempts.push(attempt);
+    return attempt;
+  }
+
+  finalizeJobAttempt(
+    attempt: JobAttemptRecord,
+    updates: Partial<Omit<JobAttemptRecord, 'profileId' | 'profileConfigDir' | 'startedAt'>>,
+  ): JobAttemptRecord {
+    Object.assign(attempt, updates);
+    return attempt;
+  }
+
+  updateJob(jobId: string, updates: Partial<JobRecord>): JobRecord {
+    const job = this.getJob(jobId);
+    if (!job) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+
+    Object.assign(job, updates);
+    return job;
+  }
+
+  async appendTranscript(input: {
+    conversationId: string;
+    jobId?: string | undefined;
+    role: TranscriptEntry['role'];
+    content: string;
+    data?: Record<string, unknown> | undefined;
+  }): Promise<TranscriptEntry> {
+    const conversation = this.getConversation(input.conversationId);
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${input.conversationId}`);
+    }
+
+    const entry: TranscriptEntry = {
+      index: conversation.nextEntryIndex,
+      conversationId: input.conversationId,
+      jobId: input.jobId,
+      role: input.role,
+      content: input.content,
+      timestamp: nowIso(),
+      data: input.data,
+    };
+
+    conversation.nextEntryIndex += 1;
+    conversation.updatedAt = entry.timestamp;
+    await mkdir(ensureStateRoot().rootDir, { recursive: true });
+    await appendFile(transcriptPath(conversation.cwd, conversation.id), `${JSON.stringify(entry)}\n`);
+
+    const logLine = `[${entry.timestamp}] [${entry.role}] ${entry.content}\n`;
+    await appendFile(logPath(conversation.cwd, conversation.id), logLine);
+    return entry;
+  }
+
+  async readTranscript(conversationId: string): Promise<TranscriptEntry[]> {
+    const conversation = this.resolveConversation(conversationId);
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${conversationId}`);
+    }
+
+    const filePath = transcriptPath(conversation.cwd, conversation.id);
+    if (!existsSync(filePath)) {
+      return [];
+    }
+
+    const raw = await readFile(filePath, 'utf8');
+    return raw
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => JSON.parse(line) as TranscriptEntry);
+  }
+
+  async persist(): Promise<void> {
+    await writeFile(this.root.registryPath, JSON.stringify(this.state, null, 2));
+  }
+
+  updatePendingQuestion(conversationId: string, pendingQuestion: PendingQuestion | undefined, status: ConversationStatus): void {
+    const conversation = this.getConversation(conversationId);
+    if (!conversation) {
+      throw new Error(`Conversation not found: ${conversationId}`);
+    }
+
+    conversation.pendingQuestion = pendingQuestion;
+    conversation.status = status;
+    conversation.updatedAt = nowIso();
+  }
+
+  finalizeJob(jobId: string, status: JobStatus, error?: string): JobRecord {
+    const job = this.updateJob(jobId, {
+      status,
+      error,
+      endedAt: nowIso(),
+    });
+    return job;
+  }
+
+  private normalizeState(state: StateFile): StateFile {
+    return {
+      ...state,
+      conversations: state.conversations ?? [],
+      jobs: (state.jobs ?? []).map((job) => ({
+        ...job,
+        attempts: job.attempts ?? [],
+      })),
+      profiles: state.profiles ?? [],
+    };
+  }
+}