mcp-codex-worker 0.1.0

package/src/services/profile-manager.ts

@@ -0,0 +1,113 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { CODEX_HOME_DIRS_ENV, PROFILE_COOLDOWN_MS } from '../config/defaults.js';
+
+export interface CodexProfile {
+  id: string;
+  codexHome: string;
+  cooldownUntil?: number | undefined;
+  failureCount: number;
+  lastFailureReason?: string | undefined;
+}
+
+interface ProfileManagerOptions {
+  codexHomes?: string[] | undefined;
+  cooldownMs?: number | undefined;
+  now?: (() => number) | undefined;
+}
+
+function defaultCodexHome(): string {
+  return join(homedir(), '.codex');
+}
+
+function dedupeHomes(codexHomes: string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+
+  for (const home of codexHomes) {
+    const normalized = home.trim();
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    result.push(normalized);
+  }
+
+  return result.length > 0 ? result : [defaultCodexHome()];
+}
+
+export class ProfileManager {
+  private readonly cooldownMs: number;
+  private readonly now: () => number;
+  private readonly profiles: CodexProfile[];
+  private currentIndex = 0;
+
+  constructor(options: ProfileManagerOptions = {}) {
+    this.cooldownMs = options.cooldownMs ?? PROFILE_COOLDOWN_MS;
+    this.now = options.now ?? Date.now;
+
+    this.profiles = dedupeHomes(options.codexHomes ?? [defaultCodexHome()]).map((codexHome, index) => ({
+      id: `profile-${index + 1}`,
+      codexHome,
+      failureCount: 0,
+    }));
+    this.currentIndex = this.findFirstAvailableIndex();
+  }
+
+  static fromEnvironment(now?: () => number): ProfileManager {
+    const raw = process.env[CODEX_HOME_DIRS_ENV];
+    const homes = raw
+      ? raw.split(':').map((entry) => entry.trim()).filter(Boolean)
+      : [defaultCodexHome()];
+    return new ProfileManager({ codexHomes: homes, now });
+  }
+
+  getCurrentProfile(): CodexProfile {
+    this.resetExpiredCooldowns();
+    return { ...this.profiles[this.currentIndex]! };
+  }
+
+  getProfiles(): CodexProfile[] {
+    this.resetExpiredCooldowns();
+    return this.profiles.map((profile) => ({ ...profile }));
+  }
+
+  markFailure(reason: string): { rotated: boolean; profile?: CodexProfile } {
+    const current = this.profiles[this.currentIndex];
+    if (!current) {
+      return { rotated: false };
+    }
+
+    current.failureCount += 1;
+    current.lastFailureReason = reason;
+    current.cooldownUntil = this.now() + this.cooldownMs;
+
+    const nextIndex = this.findFirstAvailableIndex();
+    if (nextIndex === -1) {
+      return { rotated: false };
+    }
+
+    this.currentIndex = nextIndex;
+    return { rotated: true, profile: this.getCurrentProfile() };
+  }
+
+  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/types/codex.ts

@@ -0,0 +1,57 @@
+export type RequestId = string | number;
+
+export interface JsonLineRequest {
+  method: string;
+  id: RequestId;
+  params: unknown;
+}
+
+export interface JsonLineNotification {
+  method: string;
+  params: unknown;
+}
+
+export interface JsonLineResponse {
+  id: RequestId;
+  result?: unknown;
+  error?: unknown;
+}
+
+export type JsonLineMessage = JsonLineRequest | JsonLineNotification | JsonLineResponse;
+
+export interface InitializeParams {
+  clientInfo: {
+    name: string;
+    title: string | null;
+    version: string;
+  };
+  capabilities: {
+    experimentalApi: boolean;
+    optOutNotificationMethods?: string[] | null;
+  } | null;
+}
+
+export interface PendingServerRequest {
+  id: RequestId;
+  method: string;
+  params: unknown;
+  createdAt: string;
+  resolvedAt?: string | undefined;
+  response?: unknown;
+  resolutionError?: string | undefined;
+  status: 'pending' | 'resolved' | 'failed';
+}
+
+export interface RuntimeOperation {
+  operationId: string;
+  requestId: RequestId;
+  method: string;
+  threadId?: string | undefined;
+  turnId?: string | undefined;
+  startedAt: string;
+  completedAt?: string | undefined;
+  status: 'running' | 'completed' | 'failed';
+  result?: unknown;
+  error?: string;
+  pendingRequestIds: RequestId[];
+}