@pushpalsdev/cli 1.0.76 → 1.0.78

package/dist/pushpals-cli.js

@@ -2273,6 +2273,26 @@ function writeTextFileIfMissing(pathValue, text) {
   mkdirSync(dirname(pathValue), { recursive: true });
   writeFileSync(pathValue, text, "utf8");
 }
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function migrateEmbeddedRuntimeTomlSection(text, sectionName, transform) {
+  const sectionPattern = new RegExp(`(^\\[${escapeRegExp(sectionName)}\\]\\r?\\n)([\\s\\S]*?)(?=\\r?\\n\\[|(?![\\s\\S]))`, "m");
+  return text.replace(sectionPattern, (_match, header, body) => {
+    return `${header}${transform(body)}`;
+  });
+}
+function migrateLegacyOpenAICodexDefaults(sectionBody, opts) {
+  const backendIsOpenAICodex = /^\s*backend\s*=\s*"openai_codex"\s*$/m.test(sectionBody);
+  if (!backendIsOpenAICodex && opts.includeModel)
+    return sectionBody;
+  let updated = sectionBody;
+  if (opts.includeModel) {
+    updated = updated.replace(/^(\s*model\s*=\s*)"gpt-5\.4"\s*$/m, '$1"gpt-5.5"');
+  }
+  updated = updated.replace(/^(\s*reasoning_effort\s*=\s*)"high"\s*$/m, '$1"xhigh"');
+  return updated;
+}
 function migrateEmbeddedRuntimeLocalToml(localTomlPath) {
   if (!existsSync5(localTomlPath))
     return;
@@ -2284,8 +2304,13 @@ function migrateEmbeddedRuntimeLocalToml(localTomlPath) {
   }
   const updated = original.replace(/^(\[remotebuddy\.autonomy\]\r?\n)(enabled\s*=\s*false\s*\r?\n)/m, `$1enabled = true
 `);
-  if (updated !== original) {
-    writeFileSync(localTomlPath, updated, "utf8");
+  let migrated = updated;
+  for (const sectionName of ["localbuddy.llm", "remotebuddy.llm", "workerpals.llm"]) {
+    migrated = migrateEmbeddedRuntimeTomlSection(migrated, sectionName, (sectionBody) => migrateLegacyOpenAICodexDefaults(sectionBody, { includeModel: true }));
+  }
+  migrated = migrateEmbeddedRuntimeTomlSection(migrated, "workerpals.openai_codex", (sectionBody) => migrateLegacyOpenAICodexDefaults(sectionBody, { includeModel: false }));
+  if (migrated !== original) {
+    writeFileSync(localTomlPath, migrated, "utf8");
   }
 }
 function copyRuntimeAssetBundle(source, runtimeRoot, force) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushpalsdev/cli",
-  "version": "1.0.76",
+  "version": "1.0.78",
   "description": "PushPals terminal CLI for LocalBuddy -> RemoteBuddy orchestration",
   "license": "MIT",
   "repository": {

package/runtime/sandbox/.pushpals-remotebuddy-fallback.js

@@ -1736,6 +1736,7 @@ var DEFAULT_OLLAMA_ENDPOINT = "http://127.0.0.1:11434/api/chat";
 var DEFAULT_OPENAI_ENDPOINT = "https://api.openai.com/v1/chat/completions";
 var DEFAULT_MODEL = "local-model";
 var DEFAULT_CODEX_MODEL = "gpt-5.5";
+var LEGACY_CODEX_MODEL_FALLBACK = "gpt-5.4";
 var DEFAULT_CODEX_REASONING_EFFORT = "xhigh";
 var DEFAULT_CODEX_TIMEOUT_MS = 120000;
 var DEFAULT_LMSTUDIO_CONTEXT_WINDOW = 4096;
@@ -1860,6 +1861,55 @@ function codexReasoningEffort(configured, model) {
   }
   return defaultEffort;
 }
+function isDefaultCodexLauncher(command) {
+  const normalized = command.map((part) => part.trim().toLowerCase()).filter(Boolean);
+  return normalized.length === 0 || normalized.join("\x00") === ["bun", "x", "--yes", "@openai/codex"].join("\x00") || normalized.join("\x00") === ["bunx", "--yes", "@openai/codex"].join("\x00");
+}
+function parseCodexCliVersion(text) {
+  const match = text.match(/(?:codex(?:-cli)?|openai\s+codex)?\s*v?(\d+)\.(\d+)\.(\d+)(?:-([0-9a-z.-]+))?/i);
+  if (!match)
+    return null;
+  return {
+    major: Number.parseInt(match[1], 10),
+    minor: Number.parseInt(match[2], 10),
+    patch: Number.parseInt(match[3], 10),
+    prerelease: match[4] ?? ""
+  };
+}
+function compareCodexVersions(a, b) {
+  if (a && !b)
+    return 1;
+  if (!a && b)
+    return -1;
+  if (!a || !b)
+    return 0;
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] !== b[key])
+      return a[key] > b[key] ? 1 : -1;
+  }
+  if (a.prerelease === b.prerelease)
+    return 0;
+  if (!a.prerelease)
+    return 1;
+  if (!b.prerelease)
+    return -1;
+  return a.prerelease.localeCompare(b.prerelease);
+}
+function chooseCodexCommandProbe(probes, opts) {
+  if (probes.length === 0)
+    return null;
+  if (!opts.preferNewestCompatible)
+    return probes[0];
+  return probes.reduce((best, probe) => compareCodexVersions(probe.version, best.version) > 0 ? probe : best);
+}
+function requiresNewerCodexForModel(stdout, stderr) {
+  const combined = `${stdout}
+${stderr}`.toLowerCase();
+  return combined.includes("requires a newer version of codex") || combined.includes("requires newer") && combined.includes("codex");
+}
+function isDefaultCodexModel(model) {
+  return model.trim().toLowerCase() === DEFAULT_CODEX_MODEL.toLowerCase();
+}
 function normalizeCodexModel(rawModel) {
   const model = rawModel.trim();
   if (!model)
@@ -1888,6 +1938,63 @@ function normalizeOpenAiBaseFromEndpoint(rawEndpoint) {
   return trimmed;
 }
 async function runProcess(command, opts) {
+  const bunRuntime = globalThis.Bun;
+  if (typeof bunRuntime?.spawn === "function") {
+    return runProcessWithBun(command, opts);
+  }
+  return runProcessWithNode(command, opts);
+}
+async function runProcessWithBun(command, opts) {
+  const bunRuntime = globalThis.Bun;
+  const timeoutMs = opts.timeoutMs ?? 0;
+  let timedOut = false;
+  let timeout = null;
+  let killTimeout = null;
+  const proc = bunRuntime.spawn(command, {
+    cwd: opts.cwd,
+    env: opts.env,
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const stdoutPromise = new Response(proc.stdout).text();
+  const stderrPromise = new Response(proc.stderr).text();
+  if (timeoutMs > 0) {
+    timeout = setTimeout(() => {
+      timedOut = true;
+      try {
+        proc.kill("SIGTERM");
+      } catch {}
+      killTimeout = setTimeout(() => {
+        try {
+          proc.kill("SIGKILL");
+        } catch {}
+      }, 1000);
+      killTimeout.unref?.();
+    }, timeoutMs);
+  }
+  try {
+    if (typeof opts.stdin === "string") {
+      proc.stdin?.write(opts.stdin);
+    }
+    proc.stdin?.end();
+    const code = await proc.exited;
+    const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+    return {
+      code,
+      signal: null,
+      stdout,
+      stderr,
+      timedOut
+    };
+  } finally {
+    if (timeout)
+      clearTimeout(timeout);
+    if (killTimeout)
+      clearTimeout(killTimeout);
+  }
+}
+async function runProcessWithNode(command, opts) {
   const timeoutMs = opts.timeoutMs ?? 0;
   return new Promise((resolve4, reject) => {
     const child = spawn(command[0], command.slice(1), {
@@ -1953,6 +2060,7 @@ async function resolveCodexCommandPrefix(configuredCommand) {
   if (cached)
     return cached;
   const preferred = override.length > 0 ? override : ["bun", "x", "--yes", "@openai/codex"];
+  const preferNewestCompatible = isDefaultCodexLauncher(preferred);
   const candidates = [];
   const pushCandidate = (cmd) => {
     if (cmd.length === 0)
@@ -1976,6 +2084,7 @@ async function resolveCodexCommandPrefix(configuredCommand) {
   const cwd = process.cwd();
   const env = process.env;
   const attemptErrors = [];
+  const successfulProbes = [];
   for (const candidate of candidates) {
     if (candidate.length === 0)
       continue;
@@ -1987,8 +2096,15 @@ async function resolveCodexCommandPrefix(configuredCommand) {
         timeoutMs: 15000
       });
       if (probe.code === 0) {
-        cachedCodexCommandPrefix.set(cacheKey, candidate);
-        return candidate;
+        const versionText = (probe.stdout || probe.stderr || "").trim().split(/\r?\n/, 1)[0] ?? "";
+        successfulProbes.push({
+          command: candidate,
+          version: parseCodexCliVersion(versionText),
+          versionText
+        });
+        if (!preferNewestCompatible)
+          break;
+        continue;
       }
       const detail = (probe.stderr || probe.stdout || "").trim();
       attemptErrors.push(`${rendered} -> exit ${probe.code ?? "unknown"}${detail ? ` (${detail.split(/\r?\n/, 1)[0]})` : ""}`);
@@ -1996,6 +2112,12 @@ async function resolveCodexCommandPrefix(configuredCommand) {
       attemptErrors.push(`${rendered} -> ${String(err)}`);
     }
   }
+  const selected = chooseCodexCommandProbe(successfulProbes, { preferNewestCompatible });
+  if (selected) {
+    cachedCodexCommandPrefix.set(cacheKey, selected.command);
+    console.log(`[LLM] Resolved Codex CLI command: ${selected.command.join(" ")}${selected.versionText ? ` (${selected.versionText})` : ""}.`);
+    return selected.command;
+  }
   const details = attemptErrors.length > 0 ? ` Tried: ${attemptErrors.join("; ")}` : "";
   throw new Error("OpenAI Codex CLI is unavailable. Install/use Codex CLI (`bun x --yes @openai/codex` or `codex`) and retry." + details);
 }
@@ -2742,7 +2864,7 @@ class OpenAiCodexCliClient {
         service: this.service,
         sessionId: this.sessionTag || undefined,
         backend: "openai_codex",
-        modelId: this.model,
+        modelId: usage.modelId ?? this.model,
         promptTokens: usage.promptTokens,
         completionTokens: usage.completionTokens,
         totalTokens: usage.promptTokens + usage.completionTokens,
@@ -2788,6 +2910,13 @@ class OpenAiCodexCliClient {
     }
   }
   async runCodexExec(prompt) {
+    return this.runCodexExecAttempt(prompt, {
+      model: this.model,
+      modelCompatibilityRecoveryAttempt: 0
+    });
+  }
+  async runCodexExecAttempt(prompt, opts) {
+    const model = normalizeCodexModel(opts.model);
     const commandPrefix = await resolveCodexCommandPrefix(this.codexBin);
     const env = { ...process.env };
     env.PYTHONIOENCODING = "utf-8";
@@ -2821,7 +2950,7 @@ class OpenAiCodexCliClient {
       const command = [
         ...commandPrefix,
         "-c",
-        `model_reasoning_effort="${codexReasoningEffort(this.reasoningEffort, this.model)}"`,
+        `model_reasoning_effort="${codexReasoningEffort(this.reasoningEffort, model)}"`,
         "-a",
         "never",
         "-s",
@@ -2832,8 +2961,8 @@ class OpenAiCodexCliClient {
         "--output-last-message",
         lastMessagePath
       ];
-      if (this.model) {
-        command.push("-m", this.model);
+      if (model) {
+        command.push("-m", model);
       }
       command.push("-");
       const result = await runProcess(command, {
@@ -2850,13 +2979,20 @@ class OpenAiCodexCliClient {
       const lastMessage = existsSync3(lastMessagePath) ? readFileSync4(lastMessagePath, "utf8").trim() : "";
       if (result.code !== 0) {
         const detail = stderr || stdout || "codex exec exited with non-zero status";
+        if (opts.modelCompatibilityRecoveryAttempt < 1 && isDefaultCodexModel(model) && LEGACY_CODEX_MODEL_FALLBACK.trim().toLowerCase() !== DEFAULT_CODEX_MODEL.toLowerCase() && requiresNewerCodexForModel(stdout, stderr)) {
+          console.warn(`[LLM] Codex CLI rejected default model ${DEFAULT_CODEX_MODEL}; retrying once with ${LEGACY_CODEX_MODEL_FALLBACK}. Upgrade Codex CLI to use ${DEFAULT_CODEX_MODEL}.`);
+          return this.runCodexExecAttempt(prompt, {
+            model: LEGACY_CODEX_MODEL_FALLBACK,
+            modelCompatibilityRecoveryAttempt: opts.modelCompatibilityRecoveryAttempt + 1
+          });
+        }
         throw new Error(`Codex CLI request failed (exit ${result.code ?? "unknown"}): ${detail}`);
       }
       const text = lastMessage || stdout;
       if (!text) {
         throw new Error("Codex CLI completed without producing a response.");
       }
-      return { text, stderr };
+      return { text, stderr, model };
     } finally {
       rmSync(tmp, { recursive: true, force: true });
     }
@@ -2874,7 +3010,7 @@ class OpenAiCodexCliClient {
       promptTokens: estimateTokensFromText(prompt),
       completionTokens: estimateTokensFromText(result.text)
     });
-    await this.maybeReportUsage(usage);
+    await this.maybeReportUsage({ ...usage, modelId: result.model });
     return {
       text: result.text,
       usage: {