cli-copilot-worker 0.1.1 → 0.1.3

package/src/core/model-catalog.ts

@@ -0,0 +1,136 @@
+export interface ModelCatalogInput {
+  id: string;
+  name?: string | undefined;
+  policyState?: 'enabled' | 'disabled' | 'unconfigured' | undefined;
+}
+
+export interface ModelAliasMapping {
+  alias: string;
+  canonical: string;
+}
+
+export interface ModelCatalog {
+  latestModelIds: string[];
+  aliasMappings: ModelAliasMapping[];
+}
+
+const MANUALLY_EXCLUDED_MODEL_IDS = new Set(['gpt-4.1', 'claude-opus-4.6-fast']);
+
+interface ParsedModelId {
+  family: string;
+  version: number[];
+}
+
+function isSelectableModel(model: ModelCatalogInput): boolean {
+  return (
+    model.policyState !== 'disabled' &&
+    model.policyState !== 'unconfigured' &&
+    !MANUALLY_EXCLUDED_MODEL_IDS.has(model.id)
+  );
+}
+
+function parseModelId(id: string): ParsedModelId | undefined {
+  const match = /^(.*)-(\d+(?:\.\d+)?)(?:-(.+))?$/.exec(id);
+  if (!match) {
+    return undefined;
+  }
+
+  const prefix = match[1];
+  const version = match[2];
+  const suffix = match[3];
+  if (!prefix || !version) {
+    return undefined;
+  }
+
+  const major = version.split('.')[0];
+  const familyBase = prefix.includes('-') ? prefix : `${prefix}-${major}`;
+  return {
+    family: suffix ? `${familyBase}-${suffix}` : familyBase,
+    version: version.split('.').map((part) => Number.parseInt(part, 10)),
+  };
+}
+
+function compareVersions(left: number[], right: number[]): number {
+  const length = Math.max(left.length, right.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left[index] ?? 0;
+    const rightPart = right[index] ?? 0;
+    if (leftPart !== rightPart) {
+      return leftPart - rightPart;
+    }
+  }
+
+  return 0;
+}
+
+export function buildModelCatalog(models: ModelCatalogInput[]): ModelCatalog {
+  const selectable = models.filter(isSelectableModel);
+  const latestByFamily = new Map<string, { id: string; version: number[] }>();
+  const passthrough = new Set<string>();
+
+  for (const model of selectable) {
+    const parsed = parseModelId(model.id);
+    if (!parsed) {
+      passthrough.add(model.id);
+      continue;
+    }
+
+    const existing = latestByFamily.get(parsed.family);
+    if (!existing || compareVersions(parsed.version, existing.version) > 0) {
+      latestByFamily.set(parsed.family, { id: model.id, version: parsed.version });
+    }
+  }
+
+  const aliasMappings = selectable
+    .map((model) => {
+      const parsed = parseModelId(model.id);
+      if (!parsed) {
+        return undefined;
+      }
+
+      const canonical = latestByFamily.get(parsed.family)?.id;
+      if (!canonical || canonical === model.id) {
+        return undefined;
+      }
+
+      return {
+        alias: model.id,
+        canonical,
+      };
+    })
+    .filter((mapping): mapping is ModelAliasMapping => mapping !== undefined)
+    .sort((left, right) => left.alias.localeCompare(right.alias));
+
+  const latestModelIds = [
+    ...new Set([
+      ...passthrough,
+      ...[...latestByFamily.values()].map((entry) => entry.id),
+    ]),
+  ].sort((left, right) => left.localeCompare(right));
+
+  return {
+    latestModelIds,
+    aliasMappings,
+  };
+}
+
+export function resolveModelAlias(requestedModel: string, catalog: ModelCatalog): string | undefined {
+  if (catalog.latestModelIds.includes(requestedModel)) {
+    return requestedModel;
+  }
+
+  return catalog.aliasMappings.find((mapping) => mapping.alias === requestedModel)?.canonical;
+}
+
+export function describeAllowedModels(catalog: ModelCatalog): string {
+  const allowed = catalog.latestModelIds.join(', ');
+  if (catalog.aliasMappings.length === 0) {
+    return `Allowed models: ${allowed}`;
+  }
+
+  const aliases = catalog.aliasMappings
+    .map((mapping) => `${mapping.alias} -> ${mapping.canonical}`)
+    .join(', ');
+
+  return `Allowed models: ${allowed}. Accepted legacy aliases: ${aliases}`;
+}

package/src/core/profile-manager.ts

@@ -103,7 +103,7 @@ export class ProfileManager {
   static fromEnvironment(persistedProfiles?: PersistedProfileState[]): ProfileManager {
     const raw = process.env.COPILOT_CONFIG_DIRS;
     const dirs = raw
-      ? raw.split(',').map((entry) => entry.trim()).filter(Boolean)
+      ? raw.split(':').map((entry) => entry.trim()).filter(Boolean)
       : [defaultProfileDir()];
 
     return new ProfileManager({ profileDirs: dirs, persistedProfiles });

package/src/daemon/service.ts

@@ -1,10 +1,17 @@
 import { unlink, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 
-import { approveAll, type CopilotClient, type CopilotSession } from '@github/copilot-sdk';
+import { approveAll, type CopilotClient, type CopilotSession, type ModelInfo } from '@github/copilot-sdk';
 
 import { buildAuthenticatedClient } from '../core/copilot.js';
 import { classifyCopilotStartupFailure, classifySessionErrorEvent } from '../core/failure-classifier.js';
+import { startFleetModeIfEnabled } from '../core/fleet-mode.js';
+import {
+  buildModelCatalog,
+  describeAllowedModels,
+  resolveModelAlias,
+  type ModelCatalogInput,
+} from '../core/model-catalog.js';
 import { ensureStateRoot } from '../core/paths.js';
 import { ProfileFaultPlanner } from '../core/profile-faults.js';
 import { ProfileManager } from '../core/profile-manager.js';
@@ -97,6 +104,7 @@ export class CliCopilotWorkerService {
     await this.store.load();
     this.profileManager = ProfileManager.fromEnvironment(this.store.getProfiles());
     this.faultPlanner = ProfileFaultPlanner.fromEnvironment();
+    this.reconcilePendingQuestions();
     this.store.setProfiles(this.profileManager.toPersistedState());
     await this.store.persist();
   }
@@ -123,6 +131,7 @@ export class CliCopilotWorkerService {
 
   async shutdown(): Promise<Record<string, unknown>> {
     for (const execution of this.activeExecutions.values()) {
+      this.clearPendingQuestion(execution.conversationId, execution.jobId, 'failed');
       await execution.session.abort().catch(() => {});
       await execution.session.disconnect().catch(() => {});
       await execution.client.stop().catch(async () => {
@@ -150,9 +159,10 @@ export class CliCopilotWorkerService {
   }
 
   async run(args: RunRequest, writer?: EventWriter): Promise<Record<string, unknown>> {
+    const resolvedModel = await this.resolveRequestedModel(args.cwd, args.model);
     const conversation = this.store.createConversation({
       cwd: args.cwd,
-      model: args.model ?? DEFAULT_MODEL,
+      model: resolvedModel,
     });
     const job = this.store.createJob({
       conversationId: conversation.id,
@@ -386,6 +396,7 @@ export class CliCopilotWorkerService {
           failureMessage: 'Job cancelled.',
         });
       }
+      this.clearPendingQuestion(job.conversationId, job.id, 'cancelled');
       await execution.session.abort().catch(() => {});
       await execution.session.disconnect().catch(() => {});
       await execution.client.stop().catch(async () => {
@@ -397,6 +408,7 @@ export class CliCopilotWorkerService {
     this.store.finalizeJob(job.id, 'cancelled');
     this.store.updateConversation(job.conversationId, {
       status: 'cancelled',
+      pendingQuestion: undefined,
     });
     await this.store.appendTranscript({
       conversationId: job.conversationId,
@@ -488,7 +500,16 @@ export class CliCopilotWorkerService {
       message: `Running ${job.kind} on ${conversation.id}`,
     });
 
-    const profiles = this.planProfiles(conversation);
+    let profiles: CopilotProfile[];
+    try {
+      profiles = await this.planExecutionProfiles(conversation);
+    } catch (error) {
+      const failure = classifyCopilotStartupFailure(error);
+      await this.finalizeJobFailure(job.id, conversation.id, failure.message);
+      rejectDone(new Error(failure.message));
+      return;
+    }
+
     if (profiles.length === 0) {
       const failure = classifyCopilotStartupFailure(
         new Error('No eligible Copilot profiles are available. All configured profiles are cooling down or unavailable.'),
@@ -670,6 +691,7 @@ export class CliCopilotWorkerService {
             clearTimeout(timeout);
           }
           input.writer?.event('error', { message: failure.message });
+          this.clearPendingQuestion(input.conversation.id, input.job.id, 'failed');
           await this.recordAttemptFailure({
             conversationId: input.conversation.id,
             jobId: input.job.id,
@@ -707,6 +729,7 @@ export class CliCopilotWorkerService {
             lastError: undefined,
             profileId: input.profile.id,
             profileConfigDir: input.profile.configDir,
+            pendingQuestion: undefined,
           });
           await this.store.appendTranscript({
             conversationId: input.conversation.id,
@@ -798,6 +821,16 @@ export class CliCopilotWorkerService {
 
         void this.persistState()
           .then(async () => {
+            const fleetStarted = await startFleetModeIfEnabled(session, input.content);
+            if (fleetStarted) {
+              await this.store.appendTranscript({
+                conversationId: input.conversation.id,
+                jobId: input.job.id,
+                role: 'status',
+                content: 'Fleet mode started.',
+              });
+              input.writer?.event('status', { message: 'Fleet mode started.' });
+            }
             await session.send({ prompt: input.content });
           })
           .catch((error) => {
@@ -846,6 +879,28 @@ export class CliCopilotWorkerService {
     return prioritized;
   }
 
+  private async planExecutionProfiles(conversation: ConversationRecord): Promise<CopilotProfile[]> {
+    const prioritized = this.planProfiles(conversation);
+    if (conversation.hasStarted) {
+      return prioritized;
+    }
+
+    const supported = await this.filterProfilesByModelSupport(
+      conversation.cwd,
+      prioritized,
+      conversation.model,
+    );
+
+    if (supported.length > 0) {
+      return supported;
+    }
+
+    const catalog = await this.loadModelCatalogForProfiles(conversation.cwd, prioritized);
+    throw new Error(
+      `Unsupported model "${conversation.model}" for the configured Copilot profiles. ${describeAllowedModels(catalog)}`,
+    );
+  }
+
   private async getOrCreateClient(cwd: string, profile: CopilotProfile): Promise<{ client: CopilotClient; clientKey: string }> {
     const clientKey = `${cwd}:${profile.configDir}`;
     let client = this.clients.get(clientKey);
@@ -867,6 +922,75 @@ export class CliCopilotWorkerService {
     this.clients.delete(clientKey);
   }
 
+  private async resolveRequestedModel(cwd: string, requestedModel?: string): Promise<string> {
+    const profiles = this.profileManager.getCandidateProfiles();
+    if (profiles.length === 0) {
+      throw new Error('No eligible Copilot profiles are available. All configured profiles are cooling down or unavailable.');
+    }
+
+    const catalog = await this.loadModelCatalogForProfiles(cwd, profiles);
+    const rawModel = requestedModel ?? DEFAULT_MODEL;
+    const resolved = resolveModelAlias(rawModel, catalog);
+    if (!resolved) {
+      throw new Error(`Unsupported model "${rawModel}". ${describeAllowedModels(catalog)}`);
+    }
+
+    return resolved;
+  }
+
+  private async filterProfilesByModelSupport(
+    cwd: string,
+    profiles: CopilotProfile[],
+    model: string,
+  ): Promise<CopilotProfile[]> {
+    const supportChecks = await Promise.all(
+      profiles.map(async (profile) => ({
+        profile,
+        supports: await this.profileSupportsModel(cwd, profile, model),
+      })),
+    );
+
+    return supportChecks
+      .filter((entry) => entry.supports)
+      .map((entry) => entry.profile);
+  }
+
+  private async profileSupportsModel(cwd: string, profile: CopilotProfile, model: string): Promise<boolean> {
+    try {
+      const catalog = await this.loadModelCatalogForProfiles(cwd, [profile]);
+      return catalog.latestModelIds.includes(model);
+    } catch {
+      return false;
+    }
+  }
+
+  private async loadModelCatalogForProfiles(cwd: string, profiles: CopilotProfile[]) {
+    const settled = await Promise.allSettled(
+      profiles.map(async (profile) => {
+        const { client } = await this.getOrCreateClient(cwd, profile);
+        return await client.listModels();
+      }),
+    );
+
+    const models = settled
+      .flatMap((result) => (result.status === 'fulfilled' ? result.value : []))
+      .map((model) => this.toModelCatalogInput(model));
+
+    if (models.length === 0) {
+      throw new Error('No selectable Copilot models are available from the configured profiles.');
+    }
+
+    return buildModelCatalog(models);
+  }
+
+  private toModelCatalogInput(model: ModelInfo): ModelCatalogInput {
+    return {
+      id: model.id,
+      name: model.name,
+      policyState: model.policy?.state,
+    };
+  }
+
   private async recordAttemptFailure(input: {
     conversationId: string;
     jobId: string;
@@ -900,6 +1024,7 @@ export class CliCopilotWorkerService {
     this.store.updateConversation(conversationId, {
       status: 'failed',
       lastError: message,
+      pendingQuestion: undefined,
     });
     await this.store.appendTranscript({
       conversationId,
@@ -947,6 +1072,37 @@ export class CliCopilotWorkerService {
     await this.store.persist();
   }
 
+  private clearPendingQuestion(
+    conversationId: string,
+    jobId: string,
+    status: ConversationRecord['status'],
+  ): void {
+    this.questionRegistry.clear(conversationId, 'Conversation is no longer waiting for an answer.');
+    this.store.updateConversation(conversationId, {
+      pendingQuestion: undefined,
+      status,
+    });
+    this.store.updateJob(jobId, {
+      status: status === 'cancelled' ? 'cancelled' : 'failed',
+    });
+  }
+
+  private reconcilePendingQuestions(): void {
+    for (const conversation of this.store.listConversations()) {
+      if (!conversation.pendingQuestion) {
+        continue;
+      }
+
+      if (conversation.status === 'waiting_answer') {
+        continue;
+      }
+
+      this.store.updateConversation(conversation.id, {
+        pendingQuestion: undefined,
+      });
+    }
+  }
+
   private resolveProfile(conversation: ConversationRecord) {
     if (conversation.profileConfigDir && conversation.profileId) {
       const match = this.profileManager

package/src/output.ts

@@ -22,6 +22,18 @@ export function resolveOutputFormat(explicit?: string | undefined): OutputFormat
   throw new Error(`Invalid output format: ${explicit}. Use "text" or "json".`);
 }
 
+export function resolveFollowOutputFormat(explicit?: string | undefined): OutputFormat {
+  if (explicit === 'json') {
+    throw new Error('--follow only supports text output');
+  }
+
+  if (!explicit) {
+    return 'text';
+  }
+
+  return resolveOutputFormat(explicit);
+}
+
 export function printJson(data: unknown): void {
   process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
 }