@cydm/happy-elves 0.1.0-beta.254 → 0.1.0-beta.259

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.254",
+  "version": "0.1.0-beta.259",
   "private": true,
   "type": "module"
 }

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.254",
+  "version": "0.1.0-beta.259",
   "private": true,
   "type": "module"
 }

package/apps/relay/dist/projections.js

@@ -21,17 +21,47 @@ function primitiveSupport(value) {
 function historyModel(value) {
     return value === "append-only" || value === "authoritative-linear" ? value : undefined;
 }
+function stringField(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function agentModelOptions(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const seen = new Set();
+    const models = value.flatMap((item) => {
+        if (!isRecord(item))
+            return [];
+        const id = stringField(item.id);
+        if (!id || seen.has(id))
+            return [];
+        seen.add(id);
+        const label = stringField(item.label);
+        const reason = stringField(item.reason);
+        return [{
+                id,
+                ...(label ? { label } : {}),
+                ...(item.unavailable === true ? { unavailable: true } : {}),
+                ...(reason ? { reason } : {}),
+            }];
+    });
+    return models.length > 0 ? models : undefined;
+}
 export function normalizeMachineCapabilities(value) {
     const record = isRecord(value) ? value : {};
     const agents = Array.isArray(record.agents)
         ? record.agents.flatMap((agent) => {
             if (!isRecord(agent) || typeof agent.id !== "string" || typeof agent.label !== "string")
                 return [];
+            const agentHistoryModel = historyModel(agent.historyModel);
+            const defaultModel = stringField(agent.defaultModel);
+            const models = agentModelOptions(agent.models);
             return [{
                     id: agent.id,
                     label: agent.label,
                     ...(typeof agent.command === "string" ? { command: agent.command } : {}),
-                    ...(historyModel(agent.historyModel) ? { historyModel: historyModel(agent.historyModel) } : {}),
+                    ...(agentHistoryModel ? { historyModel: agentHistoryModel } : {}),
+                    ...(defaultModel ? { defaultModel } : {}),
+                    ...(models ? { models } : {}),
                     ...(isRecord(agent.sessionPrimitives)
                         ? {
                             sessionPrimitives: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.254",
+  "version": "0.1.0-beta.259",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {

package/packages/runtime-cli/dist/codex-app-server.d.ts

@@ -1,4 +1,4 @@
-import type { RuntimePromptMode, RuntimeTurn } from "../../runtime/dist/index.js";
+import type { RuntimeModelOption, RuntimePromptMode, RuntimeTurn } from "../../runtime/dist/index.js";
 import type { RuntimePermissionMode } from "./permissions.js";
 export declare class CodexAppServerSession {
     private readonly command;
@@ -20,7 +20,12 @@ export declare class CodexAppServerSession {
     threadId: string | null;
     constructor(command: string, cwd: string, threadId?: string, onThreadIdChanged?: ((threadId: string) => void) | undefined, restartableEmptyThread?: boolean, initialModel?: string | undefined);
     ensure(permissionMode?: RuntimePermissionMode, model?: string): Promise<string>;
+    discoverRuntimeOptions(): Promise<{
+        defaultModel?: string;
+        models?: RuntimeModelOption[];
+    } | undefined>;
     private ensureCurrentPermission;
+    private loadAllModelListPages;
     private ensurePermission;
     private startNewThread;
     private canRestartEmptyThread;
@@ -56,4 +61,12 @@ export declare class CodexAppServerSession {
     private noteTurnActivity;
     private emptyCompletionFailure;
 }
+export declare function discoverCodexRuntimeOptions(input: {
+    command: string;
+    cwd: string;
+    timeoutMs?: number;
+}): Promise<{
+    defaultModel?: string;
+    models?: RuntimeModelOption[];
+} | undefined>;
 //# sourceMappingURL=codex-app-server.d.ts.map

package/packages/runtime-cli/dist/codex-app-server.js

@@ -33,9 +33,43 @@ export class CodexAppServerSession {
     async ensure(permissionMode, model) {
         return await this.ensurePermission(normalizeCodexPermissionMode(permissionMode), normalizeModel(model ?? this.initialModel));
     }
+    async discoverRuntimeOptions() {
+        if (!this.rpc)
+            await this.connect();
+        return codexRuntimeOptionsFromModelList(await this.loadAllModelListPages());
+    }
     async ensureCurrentPermission() {
         return await this.ensurePermission(normalizeCodexPermissionMode(this.appliedPermissionMode), this.appliedModel ?? normalizeModel(this.initialModel));
     }
+    async loadAllModelListPages() {
+        const models = [];
+        const seenModelIds = new Set();
+        const seenCursors = new Set();
+        let cursor;
+        for (let pageCount = 0; pageCount < CODEX_MODEL_LIST_PAGE_SAFETY_LIMIT; pageCount += 1) {
+            const result = await this.request("model/list", {
+                limit: CODEX_MODEL_LIST_PAGE_LIMIT,
+                ...(cursor !== undefined ? { cursor } : {}),
+            });
+            for (const model of codexModelsFromModelList(result)) {
+                const id = codexModelId(model);
+                if (id && seenModelIds.has(id))
+                    continue;
+                if (id)
+                    seenModelIds.add(id);
+                models.push(model);
+            }
+            const nextCursor = codexModelListNextCursor(result);
+            if (nextCursor === undefined)
+                return { data: models };
+            if (seenCursors.has(nextCursor)) {
+                throw new Error(`Codex model/list returned repeated cursor ${JSON.stringify(nextCursor)}`);
+            }
+            seenCursors.add(nextCursor);
+            cursor = nextCursor;
+        }
+        throw new Error(`Codex model/list exceeded the ${CODEX_MODEL_LIST_PAGE_SAFETY_LIMIT} page safety limit`);
+    }
     async ensurePermission(permissionMode, model) {
         const hadProcess = Boolean(this.rpc);
         if (!this.rpc)
@@ -349,6 +383,27 @@ export class CodexAppServerSession {
         return `Codex turn completed without assistant output after runtime errors${detail ? `: ${detail}` : ""}`;
     }
 }
+const CODEX_MODEL_LIST_PAGE_LIMIT = 100;
+const CODEX_MODEL_LIST_PAGE_SAFETY_LIMIT = 100;
+const CODEX_PROVIDER_DISCOVERY_TIMEOUT_MS = 5_000;
+export async function discoverCodexRuntimeOptions(input) {
+    const discovery = new CodexAppServerSession(input.command, input.cwd);
+    const timeoutMs = Math.max(1, input.timeoutMs ?? CODEX_PROVIDER_DISCOVERY_TIMEOUT_MS);
+    let timeout;
+    try {
+        return await Promise.race([
+            discovery.discoverRuntimeOptions(),
+            new Promise((_, reject) => {
+                timeout = setTimeout(() => reject(new Error(`Codex provider model discovery timed out after ${timeoutMs}ms`)), timeoutMs);
+            }),
+        ]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+        await discovery.close();
+    }
+}
 function codexStderrMessage(text) {
     try {
         const parsed = JSON.parse(text);
@@ -415,4 +470,49 @@ function numberField(record, ...keys) {
 function normalizeModel(value) {
     return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
+function codexModelsFromModelList(value) {
+    const record = recordFrom(value);
+    return Array.isArray(record.models)
+        ? record.models
+        : Array.isArray(record.items)
+            ? record.items
+            : Array.isArray(record.data)
+                ? record.data
+                : [];
+}
+function codexModelId(value) {
+    return stringField(recordFrom(value), "id", "key", "name");
+}
+function codexModelListNextCursor(value) {
+    const nextCursor = recordFrom(value).nextCursor;
+    if (nextCursor === undefined || nextCursor === null)
+        return undefined;
+    if (typeof nextCursor !== "string" || nextCursor.length === 0) {
+        throw new Error("Codex model/list returned an invalid nextCursor");
+    }
+    return nextCursor;
+}
+function codexRuntimeOptionsFromModelList(value) {
+    const rawModels = codexModelsFromModelList(value);
+    const seen = new Set();
+    const models = rawModels.flatMap((item) => {
+        const model = recordFrom(item);
+        const id = codexModelId(model)?.trim();
+        if (!id || seen.has(id))
+            return [];
+        seen.add(id);
+        const label = stringField(model, "label", "displayName", "name");
+        return [{ id, ...(label ? { label } : {}) }];
+    });
+    if (models.length === 0)
+        return undefined;
+    const defaultModel = rawModels
+        .map((item) => recordFrom(item))
+        .find((item) => item.isDefault === true);
+    const defaultModelId = defaultModel ? codexModelId(defaultModel)?.trim() : undefined;
+    return {
+        ...(defaultModelId ? { defaultModel: defaultModelId } : {}),
+        models,
+    };
+}
 //# sourceMappingURL=codex-app-server.js.map

package/packages/runtime-cli/dist/index.d.ts

@@ -5,7 +5,11 @@ export type CliRuntimeProviderOptions = {
     cwd: string;
     stateDir: string;
     codexCommand?: string;
+    /** Maximum total time for the provider-level Codex catalog probe. */
+    codexDiscoveryTimeoutMs?: number;
     claudeCommand?: string;
 };
-export declare function createCliRuntimeProvider(options: CliRuntimeProviderOptions): HappyElvesRuntime;
+export declare function createCliRuntimeProvider(options: CliRuntimeProviderOptions): HappyElvesRuntime & {
+    initialize(): Promise<void>;
+};
 //# sourceMappingURL=index.d.ts.map

package/packages/runtime-cli/dist/index.js

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from "node:fs";
 import os from "node:os";
 import { readClaudeHistoricalEvents, readClaudeHistoricalSessionPage } from "./claude-history.js";
 import { renameClaudeSession } from "./claude-rename.js";
+import { discoverCodexRuntimeOptions } from "./codex-app-server.js";
 import { forkAndTruncateClaudeSession, forkClaudeSession } from "./claude-session-store.js";
 import { startClaudeTurn } from "./claude-turn.js";
 import { readCodexCanonicalHistoricalSessionPage, readCodexHistoricalEvents } from "./codex-history.js";
@@ -13,6 +14,7 @@ export { HistoryCursorStaleError, isHistoryCursorStaleError, mergeHistoricalSess
 export function createCliRuntimeProvider(options) {
     const codexCommand = options.codexCommand ?? process.env.HAPPY_ELVES_CODEX_COMMAND ?? "codex";
     const claudeCommand = options.claudeCommand ?? process.env.HAPPY_ELVES_CLAUDE_COMMAND ?? "claude";
+    let codexOptions = codexAgentModels();
     const sessions = new CliSessionStore({ cwd: options.cwd, codexCommand });
     const historySnapshotDir = path.join(options.stateDir, "history-snapshots");
     async function listHistoricalSessionPage(input) {
@@ -66,6 +68,24 @@ export function createCliRuntimeProvider(options) {
         }), loadedByBackendId);
     }
     return {
+        async initialize() {
+            const configured = agentModelsFromEnv("HAPPY_ELVES_CODEX");
+            if (configured.models && configured.models.length > 0) {
+                codexOptions = configured;
+                return;
+            }
+            const discovered = await discoverCodexRuntimeOptions({
+                command: codexCommand,
+                cwd: options.cwd,
+                timeoutMs: options.codexDiscoveryTimeoutMs,
+            }).catch(() => undefined);
+            codexOptions = discovered?.models && discovered.models.length > 0
+                ? {
+                    ...(configured.defaultModel ? { defaultModel: configured.defaultModel } : discovered.defaultModel ? { defaultModel: discovered.defaultModel } : {}),
+                    models: discovered.models,
+                }
+                : codexAgentModels();
+        },
         getCapabilities() {
             return {
                 provider: "cli",
@@ -75,7 +95,7 @@ export function createCliRuntimeProvider(options) {
         },
         listAgents() {
             return [
-                { id: "codex", label: "Codex", ...codexAgentModels() },
+                { id: "codex", label: "Codex", ...codexOptions },
                 { id: "claude", label: "Claude Code", ...agentModelsFromEnv("HAPPY_ELVES_CLAUDE") },
             ];
         },
@@ -360,8 +380,8 @@ function modelOptionsFromEnv(value) {
     });
 }
 function modelOptionsFromCodexCache(codexHome) {
-    const cachePath = path.join(codexHome?.trim() || path.join(os.homedir(), ".codex"), "models_cache.json");
-    if (!existsSync(cachePath))
+    const cachePath = codexModelCachePaths(codexHome).find((candidate) => existsSync(candidate));
+    if (!cachePath)
         return [];
     try {
         const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
@@ -388,6 +408,26 @@ function modelOptionsFromCodexCache(codexHome) {
         return [];
     }
 }
+function codexModelCachePaths(codexHome) {
+    const candidates = [
+        process.env.HAPPY_ELVES_CODEX_MODELS_CACHE,
+        codexHome?.trim() ? path.join(codexHome.trim(), "models_cache.json") : undefined,
+        process.env.APPDATA ? path.join(process.env.APPDATA, "Codex", "models_cache.json") : undefined,
+        process.env.APPDATA ? path.join(process.env.APPDATA, "codex", "models_cache.json") : undefined,
+        process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, "Codex", "models_cache.json") : undefined,
+        process.env.LOCALAPPDATA ? path.join(process.env.LOCALAPPDATA, "codex", "models_cache.json") : undefined,
+        path.join(os.homedir(), ".codex", "models_cache.json"),
+        process.env.USERPROFILE ? path.join(process.env.USERPROFILE, ".codex", "models_cache.json") : undefined,
+    ];
+    const seen = new Set();
+    return candidates.flatMap((candidate) => {
+        const normalized = candidate?.trim();
+        if (!normalized || seen.has(normalized))
+            return [];
+        seen.add(normalized);
+        return [normalized];
+    });
+}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }