omniagent 0.1.16 → 0.1.17

package/dist/cli.js

@@ -1484,7 +1484,7 @@ const codexTarget = {
       timeoutMs: 6e4
     },
     extract: async (context) => {
-      const { extractCodexUsage } = await import("./codex-DhlBosXm.js");
+      const { extractCodexUsage } = await import("./codex-B4oMrP6y.js");
       return extractCodexUsage(context);
     }
   }

package/dist/{codex-DhlBosXm.js → codex-B4oMrP6y.js}

@@ -35,8 +35,18 @@ async function extractCodexUsageFromTui(context) {
     signal: context.signal,
     debug: context.debug,
     steps: [
-      { waitFor: isCodexPromptReadyOrTrustPrompt, waitForTimeoutMs: 1e4 },
+      { waitFor: isCodexPromptReadyOrStartupPrompt, waitForTimeoutMs: 1e4 },
+      // Numeric migration choices submit immediately, so do not append Enter.
+      { write: dismissCodexModelMigrationPrompt, skipIf: isCodexPromptReady },
+      { waitFor: isCodexPromptReadyOrTrustPrompt, waitForTimeoutMs: 1e4, optional: true },
       { write: enterKey(), skipIf: isCodexPromptReady },
+      // Trust onboarding can precede the model-migration dialog.
+      {
+        waitFor: isCodexPromptReadyOrMigrationPrompt,
+        waitForTimeoutMs: 1e4,
+        optional: true
+      },
+      { write: dismissCodexModelMigrationPrompt, skipIf: isCodexPromptReady },
       { waitFor: isCodexPromptReady, waitForTimeoutMs: 1e4 },
       ...typeTextSteps("/status", 20),
       { write: enterKey() },
@@ -98,15 +108,14 @@ function buildCodexApiUsageResult(payload, context) {
       targetId: context.targetId,
       scope: "main",
       rateLimit: usage.rate_limit,
-      now: context.now,
-      requireBothWindows: true
+      now: context.now
     }),
     ...buildCodexApiAdditionalUsageLimits(usage.additional_rate_limits, context)
   ];
-  const hasMainHourly = limits.some((limit) => limit.scope === "main" && limit.window === "hourly");
-  const hasMainWeekly = limits.some((limit) => limit.scope === "main" && limit.window === "weekly");
-  if (!hasMainHourly || !hasMainWeekly) {
-    throw new Error("Codex usage API response did not include complete main rate-limit windows.");
+  if (!limits.some((limit) => limit.scope === "main")) {
+    throw new Error(
+      "Codex usage API response did not include any recognized main rate-limit windows."
+    );
   }
   return {
     targetId: context.targetId,
@@ -203,8 +212,7 @@ function buildCodexApiAdditionalUsageLimits(additionalRateLimits, context) {
       scope,
       rateLimit: entry.rate_limit,
       now: context.now,
-      labelPrefix: scope === "spark" ? void 0 : limitName || meteredFeature || scope,
-      requireBothWindows: false
+      labelPrefix: scope === "spark" ? void 0 : limitName || meteredFeature || scope
     });
   });
 }
@@ -212,25 +220,17 @@ function buildCodexApiRateLimitUsageLimits(options) {
   if (!isRecord(options.rateLimit)) {
     return [];
   }
-  const windows = [
-    ["primary", options.rateLimit.primary_window],
-    ["secondary", options.rateLimit.secondary_window]
-  ];
-  const limits = windows.flatMap(([kind, window]) => {
+  const windows = [options.rateLimit.primary_window, options.rateLimit.secondary_window];
+  return windows.flatMap((window) => {
     const limit = makeCodexApiUsageLimit({
       targetId: options.targetId,
       scope: options.scope,
-      windowKind: kind,
       window,
       now: options.now,
       labelPrefix: options.labelPrefix
     });
     return limit == null ? [] : [limit];
   });
-  if (options.requireBothWindows && limits.length !== 2) {
-    return [];
-  }
-  return limits;
 }
 function makeCodexApiUsageLimit(options) {
   if (!isRecord(options.window)) {
@@ -240,8 +240,11 @@ function makeCodexApiUsageLimit(options) {
   if (percentUsed == null) {
     return null;
   }
+  const window = codexApiWindowName(options.window);
+  if (window == null) {
+    return null;
+  }
   const resetAt = parseApiEpochSeconds(options.window.reset_at);
-  const window = codexApiWindowName(options.window, options.windowKind);
   const percentUsedClamped = clampPercent(percentUsed);
   const percentRemaining = 100 - percentUsedClamped;
   const resetText = resetAt == null ? null : `resets ${resetAt}`;
@@ -271,7 +274,7 @@ function codexAdditionalLimitScope(limitName, meteredFeature) {
   const normalized = source.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
   return normalized || "additional";
 }
-function codexApiWindowName(window, kind) {
+function codexApiWindowName(window) {
   const seconds = parseApiNumber(window.limit_window_seconds);
   if (seconds === 18e3) {
     return "5h";
@@ -279,7 +282,7 @@ function codexApiWindowName(window, kind) {
   if (seconds === 604800) {
     return "weekly";
   }
-  return kind === "primary" ? "5h" : "weekly";
+  return null;
 }
 function formatWindowLabel(window) {
   return window === "weekly" ? "Weekly" : window === "5h" ? "5h" : window;
@@ -320,10 +323,10 @@ function selectCodexStatus(result) {
     if (snapshot == null) {
       continue;
     }
-    for (const content of [`${snapshot.screen}
-${snapshot.raw}`, snapshot.screen, snapshot.raw]) {
+    for (const content of [snapshot.screen, `${snapshot.screen}
+${snapshot.raw}`, snapshot.raw]) {
       const parsed = parseCodexStatus(cleanControlOutput(content));
-      if (parsed.main5hLimit || parsed.mainWeeklyLimit) {
+      if (isCompleteCodexStatus(parsed)) {
         return parsed;
       }
     }
@@ -340,16 +343,32 @@ ${snapshot.raw}`);
 function isCodexPromptReadyOrTrustPrompt(snapshot) {
   return isCodexPromptReady(snapshot) || isCodexTrustPrompt(snapshot);
 }
+function isCodexPromptReadyOrStartupPrompt(snapshot) {
+  return isCodexPromptReadyOrTrustPrompt(snapshot) || isCodexModelMigrationPrompt(snapshot);
+}
 function isCodexTrustPrompt(snapshot) {
   const cleanedOutput = cleanControlOutput(`${snapshot.screen}
 ${snapshot.raw}`);
   return /do you trust the contents of this directory/i.test(cleanedOutput);
 }
+function isCodexModelMigrationPrompt(snapshot) {
+  return codexKeepModelSelection(snapshot) != null;
+}
+function isCodexPromptReadyOrMigrationPrompt(snapshot) {
+  return isCodexPromptReady(snapshot) || isCodexModelMigrationPrompt(snapshot);
+}
+function codexKeepModelSelection(snapshot) {
+  const cleanedScreen = cleanControlOutput(snapshot.screen);
+  const match = /(\d+)\.\s*Use existing model/i.exec(cleanedScreen);
+  return match?.[1] ?? null;
+}
+function dismissCodexModelMigrationPrompt(snapshot) {
+  return codexKeepModelSelection(snapshot) ?? void 0;
+}
 function hasCodexStatusLimits(snapshot) {
   const cleanedOutput = cleanControlOutput(`${snapshot.screen}
 ${snapshot.raw}`);
-  const parsed = parseCodexStatus(cleanedOutput);
-  return Boolean(parsed.main5hLimit && parsed.mainWeeklyLimit);
+  return isCompleteCodexStatus(parseCodexStatus(cleanedOutput));
 }
 function hasCodexStatusResponse(snapshot) {
   const cleanedOutput = cleanControlOutput(`${snapshot.screen}
@@ -358,14 +377,12 @@ ${snapshot.raw}`);
   return Boolean(parsed.main5hLimit || parsed.mainWeeklyLimit) || /refresh requested/i.test(cleanedOutput);
 }
 function buildCodexUsageResult(parsed, context) {
-  assertAnyRequiredCodexLimit(parsed);
-  const errors = buildCodexUsageErrors(parsed, context);
+  assertCompleteCodexStatus(parsed);
   return {
     targetId: context.targetId,
     displayName: context.displayName,
     command: context.command,
-    limits: buildCodexUsageLimits(parsed, context),
-    errors: errors.length > 0 ? errors : void 0
+    limits: buildCodexUsageLimits(parsed, context)
   };
 }
 function buildCodexUsageLimits(parsed, context) {
@@ -375,12 +392,15 @@ function buildCodexUsageLimits(parsed, context) {
       return [];
     }
     const percentRemaining = parsePercentRemaining(raw);
+    if (percentRemaining == null) {
+      return [];
+    }
     return [
       makeUsageLimit({
         targetId: context.targetId,
         scope,
         window,
-        percentUsed: percentRemaining == null ? null : 100 - percentRemaining,
+        percentUsed: 100 - percentRemaining,
         percentRemaining,
         resetText: parseResetText(raw),
         raw,
@@ -424,13 +444,19 @@ function parseCodexStatus(cleanedOutput) {
       const label = labelMatch[1].trim();
       const inlineValue = labelMatch[2].trim();
       if (isCodexSparkLimitLabel(label)) {
-        section = "spark";
-        key = "";
+        const sparkKey = sparkLimitKey(label);
+        if (sparkKey) {
+          key = sparkKey;
+          setCodexLabeledValue(values, key, label, inlineValue);
+        } else {
+          section = "spark";
+          key = "";
+        }
         continue;
       }
       key = labelToCodexKey(label, section);
-      if (key && inlineValue) {
-        setValue(values, key, inlineValue);
+      if (key) {
+        setCodexLabeledValue(values, key, label, inlineValue);
       }
       continue;
     }
@@ -452,35 +478,36 @@ function parseCodexStatus(cleanedOutput) {
     sparkWeeklyLimit: values.sparkWeeklyLimit ?? ""
   };
 }
-function assertAnyRequiredCodexLimit(parsed) {
-  if (parsed.main5hLimit || parsed.mainWeeklyLimit) {
-    return;
-  }
-  throw new Error("Codex usage output did not include the required 5h and weekly limit rows.");
-}
-function buildCodexUsageErrors(parsed, context) {
-  const missing = [];
-  if (!parsed.main5hLimit) {
-    missing.push("5h");
+function assertCompleteCodexStatus(parsed) {
+  if (!hasParseableCodexMainLimit(parsed)) {
+    throw new Error("Codex usage output did not include any parseable main rate-limit rows.");
   }
-  if (!parsed.mainWeeklyLimit) {
-    missing.push("weekly");
-  }
-  if (missing.length === 0) {
-    return [];
+  if (!hasOnlyParseableCodexLimits(parsed)) {
+    throw new Error("Codex usage output included an incomplete rate-limit row.");
   }
-  return [
-    {
-      targetId: context.targetId,
-      displayName: context.displayName,
-      code: "partial_parse",
-      message: `Codex usage output did not include the ${missing.join(" and ")} limit row.`
-    }
-  ];
+}
+function isCompleteCodexStatus(parsed) {
+  return hasParseableCodexMainLimit(parsed) && hasOnlyParseableCodexLimits(parsed);
+}
+function hasParseableCodexMainLimit(parsed) {
+  return parsePercentRemaining(parsed.main5hLimit) != null || parsePercentRemaining(parsed.mainWeeklyLimit) != null;
+}
+function hasOnlyParseableCodexLimits(parsed) {
+  const limits = CODEX_WINDOWS.map(([, , key]) => parsed[key].trim()).filter(Boolean);
+  return limits.every((limit) => parsePercentRemaining(limit) != null);
 }
 function isCodexSparkLimitLabel(label) {
   return /\bspark\b/i.test(label) && /\blimit\b/i.test(label);
 }
+function sparkLimitKey(label) {
+  if (/\b5h limit$/i.test(label)) {
+    return "spark5hLimit";
+  }
+  if (/\bweekly limit$/i.test(label)) {
+    return "sparkWeeklyLimit";
+  }
+  return "";
+}
 function labelToCodexKey(label, section) {
   if (label === "Model") return "model";
   if (label === "Directory") return "directory";
@@ -495,6 +522,13 @@ function labelToCodexKey(label, section) {
   }
   return "";
 }
+function setCodexLabeledValue(values, key, label, inlineValue) {
+  if (inlineValue) {
+    setValue(values, key, inlineValue);
+  } else if (CODEX_WINDOWS.some(([, , limitKey]) => limitKey === key)) {
+    setValue(values, key, `${label}:`);
+  }
+}
 function setValue(values, key, value) {
   const sanitized = sanitizeCodexValue(value);
   if (!sanitized) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omniagent",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "description": "Unified agent configuration CLI that compiles canonical agent configs to multiple runtimes.",
   "type": "module",
   "bin": {