@cydm/happy-elves 0.1.0-beta.251 → 0.1.0-beta.258

package/apps/cli/package.json

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

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.251",
+  "version": "0.1.0-beta.258",
   "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/apps/relay/dist/relay-context.js

@@ -195,10 +195,54 @@ export function createRelayContext(options) {
         };
     }
     function activeSessionClaim(accountId, sessionId) {
-        return options.db
+        const claim = options.db
             .prepare(`SELECT * FROM relay_session_claims
          WHERE account_id = ? AND session_id = ? AND state = 'active'`)
             .get(accountId, sessionId);
+        if (!claim)
+            return undefined;
+        if (isStaleSessionClaim(claim)) {
+            options.db
+                .prepare("DELETE FROM relay_session_claims WHERE account_id = ? AND session_id = ? AND request_id = ?")
+                .run(claim.account_id, claim.session_id, claim.request_id);
+            return undefined;
+        }
+        return claim;
+    }
+    function isStaleSessionClaim(claim) {
+        const admission = options.db
+            .prepare(`SELECT dispatch, finished_at, terminal_status
+         FROM relay_admissions
+         WHERE account_id = ? AND request_id = ?`)
+            .get(claim.account_id, claim.request_id);
+        if (admission && (admission.finished_at !== null || admission.terminal_status !== null))
+            return true;
+        const session = options.db
+            .prepare(`SELECT status, current_head, last_turn_id, updated_at
+         FROM sessions
+         WHERE account_id = ? AND id = ?`)
+            .get(claim.account_id, claim.session_id);
+        if (admission?.dispatch === "delivered" &&
+            session &&
+            !["new", "running", "offline"].includes(session.status) &&
+            session.updated_at > claim.created_at &&
+            session.current_head !== claim.turn_id &&
+            session.last_turn_id !== claim.turn_id) {
+            return true;
+        }
+        const newerTerminal = options.db
+            .prepare(`SELECT 1
+         FROM relay_admissions
+         WHERE account_id = ?
+           AND session_id = ?
+           AND kind = 'prompt'
+           AND request_id <> ?
+           AND finished_at IS NOT NULL
+           AND terminal_status IS NOT NULL
+           AND created_at > ?
+         LIMIT 1`)
+            .get(claim.account_id, claim.session_id, claim.request_id, claim.created_at);
+        return Boolean(newerTerminal);
     }
     function claimSessionTurn(params) {
         const existing = activeSessionClaim(params.accountId, params.sessionId);

package/package.json

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

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

@@ -1,4 +1,6 @@
 import path from "node:path";
+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 { forkAndTruncateClaudeSession, forkClaudeSession } from "./claude-session-store.js";
@@ -73,7 +75,7 @@ export function createCliRuntimeProvider(options) {
         },
         listAgents() {
             return [
-                { id: "codex", label: "Codex", ...agentModelsFromEnv("HAPPY_ELVES_CODEX") },
+                { id: "codex", label: "Codex", ...codexAgentModels() },
                 { id: "claude", label: "Claude Code", ...agentModelsFromEnv("HAPPY_ELVES_CLAUDE") },
             ];
         },
@@ -331,6 +333,16 @@ function agentModelsFromEnv(prefix) {
         ...(models.length > 0 ? { models } : {}),
     };
 }
+function codexAgentModels() {
+    const configured = agentModelsFromEnv("HAPPY_ELVES_CODEX");
+    if (configured.models && configured.models.length > 0)
+        return configured;
+    const cachedModels = modelOptionsFromCodexCache(process.env.CODEX_HOME);
+    return {
+        ...(configured.defaultModel ? { defaultModel: configured.defaultModel } : {}),
+        ...(cachedModels.length > 0 ? { models: cachedModels } : {}),
+    };
+}
 function modelOptionsFromEnv(value) {
     const seen = new Set();
     return (value ?? "")
@@ -347,4 +359,60 @@ function modelOptionsFromEnv(value) {
         return [{ id, ...(label ? { label } : {}) }];
     });
 }
+function modelOptionsFromCodexCache(codexHome) {
+    const cachePath = codexModelCachePaths(codexHome).find((candidate) => existsSync(candidate));
+    if (!cachePath)
+        return [];
+    try {
+        const parsed = JSON.parse(readFileSync(cachePath, "utf8"));
+        const models = Array.isArray(parsed)
+            ? parsed
+            : isRecord(parsed) && Array.isArray(parsed.models)
+                ? parsed.models
+                : [];
+        const seen = new Set();
+        return models.flatMap((item) => {
+            if (!isRecord(item))
+                return [];
+            if (typeof item.visibility === "string" && item.visibility !== "list")
+                return [];
+            const id = stringField(item, "slug") || stringField(item, "id") || stringField(item, "model") || stringField(item, "name");
+            if (!id || seen.has(id))
+                return [];
+            seen.add(id);
+            const label = stringField(item, "display_name") || stringField(item, "displayName") || stringField(item, "label");
+            return [{ id, ...(label ? { label } : {}) }];
+        });
+    }
+    catch {
+        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);
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
 //# sourceMappingURL=index.js.map