@proagentstore/cli 0.4.153 → 0.4.154

package/dist/browser-runner/coding/engine-check.js

@@ -1,11 +1,38 @@
 import { spawnSync } from "node:child_process";
 import { unwrapLauncher } from "./launcher-wrapper.js";
-import { statSync } from "node:fs";
+import { realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { handlerFor } from "./handlers.js";
 import { parseCommand } from "./headless.js";
 import { resolveEngineSpawn } from "./engine-spawn.js";
+function safeRealpath(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}
+function defaultVersionText(launch, env) {
+    // The file the check FOUND, not the bare name: off Windows `command` is the name as given, which spawnSync would
+    // resolve against this process's PATH rather than the one being checked — and report another binary's version.
+    const command = launch.via === "direct" && launch.binaryPath ? launch.binaryPath : launch.command;
+    const r = spawnSync(command, launch.args, { encoding: "utf8", env, timeout: 5_000, windowsHide: true, windowsVerbatimArguments: launch.windowsVerbatimArguments });
+    return r.error || r.status !== 0 ? null : `${r.stdout ?? ""}${r.stderr ?? ""}`;
+}
+/** `codex-cli 0.146.0`, `2.1.3 (Claude Code)`, `grok 1.0.62 (1474f9cbdd91)` → the version. Null when there is none. */
+export function parseEngineVersion(text) {
+    return text?.match(/\b\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0] ?? null;
+}
+/** Whose `grok` answered: xAI's names itself; the community npm one prints a bare version from a node_modules script. */
+export function grokVendor(text, binaryPath) {
+    if (text && /^\s*grok \d+\.\d+/m.test(text))
+        return "xai";
+    if (/[\\/]node_modules[\\/]|@vibe-kit/.test(binaryPath ?? ""))
+        return "community";
+    return "unknown";
+}
 function defaultExists(p) {
     try {
         statSync(p);
@@ -52,6 +79,14 @@ export function detectEngineLogin(engine, deps = {}) {
         }
         return { login: "missing", where: file };
     }
+    if (engine === "grok") {
+        // xAI's Grok CLI keeps its subscription login (grok.com / accounts.x.ai) in auth.json under GROK_HOME, default
+        // ~/.grok. An external auth provider or OIDC setup signs in another way, so absence is not proof there.
+        if (env.GROK_AUTH_PROVIDER_COMMAND?.trim() || env.GROK_OIDC_ISSUER?.trim() || env.GROK_DEPLOYMENT_KEY?.trim())
+            return { login: "unknown" };
+        const file = join(env.GROK_HOME?.trim() || join(home, ".grok"), "auth.json");
+        return { login: exists(file) ? "found" : "missing", where: file };
+    }
     if (engine === "gemini") {
         // Google sign-in lands here; Gemini also accepts other auth (gcloud, Vertex), so absence is
         // not proof of "signed out".
@@ -73,6 +108,9 @@ export function checkEngine(input, deps = {}) {
     const bin = parsed.bin || parseCommand(handlerFor(engine).cliCommand).bin || engine;
     const { binaryPath, via } = resolveEngineSpawn(bin, [], deps);
     const login = input.credentialInjected ? { login: "found", where: "platform" } : detectEngineLogin(engine, deps);
+    // Grok's version is what tells xAI's CLI from a same-named npm package, so it is always read for Grok (a native
+    // binary, milliseconds); the others only when asked (coding_engine_get), because each is a Node startup.
+    const versionText = binaryPath && (engine === "grok" || input.withVersion) ? (deps.versionText ?? defaultVersionText)(resolveEngineSpawn(bin, ["--version"], deps), deps.env ?? process.env) : null;
     return {
         checked: true,
         engine,
@@ -81,5 +119,7 @@ export function checkEngine(input, deps = {}) {
         ...(binaryPath ? { binaryPath, binaryVia: via } : {}),
         login: login.login,
         ...(login.where ? { loginWhere: login.where } : {}),
+        ...(binaryPath && (engine === "grok" || input.withVersion) ? { version: parseEngineVersion(versionText) } : {}),
+        ...(engine === "grok" && binaryPath ? { vendor: grokVendor(versionText, (deps.realpath ?? safeRealpath)(binaryPath)) } : {}),
     };
 }

package/dist/browser-runner/coding/engine-spawn.js

@@ -1,5 +1,23 @@
 import { accessSync, constants, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import { posix, win32 } from "node:path";
+/**
+ * xAI's Grok CLI for a bare `grok`, wherever PATH points (#1156). Its installer (x.ai/cli/install.sh, install.ps1) always
+ * puts it in `~/.grok/bin` (`GROK_BIN_DIR` overrides), and adds that to PATH only in the SHELL's profile — so a
+ * `pags up` started by launchd, systemd, a Scheduled Task or an older terminal does not see it. And an npm package of
+ * the same name, the community `@vibe-kit/grok-cli` (API-key billed, different flags), can sit earlier on PATH: on the
+ * Mac mini it did, in nvm's bin. The preset means xAI's CLI, so its own location wins when it is there. An explicit path
+ * in a preset is the owner's choice and is never rewritten.
+ */
+export function officialEngineBinary(bin, deps = {}) {
+    if (bin !== "grok")
+        return null;
+    const windows = (deps.platform ?? process.platform) === "win32";
+    const env = deps.env ?? process.env;
+    const dir = envVar(env, "GROK_BIN_DIR", windows)?.trim() || (windows ? win32 : posix).join(deps.home ?? homedir(), ".grok", "bin");
+    const file = (windows ? win32 : posix).join(dir, windows ? "grok.exe" : "grok");
+    return (deps.isExecutable ?? defaultIsExecutable)(file) ? file : null;
+}
 function defaultIsExecutable(p) {
     try {
         if (!statSync(p).isFile())
@@ -67,7 +85,8 @@ export function quoteCmdArg(arg) {
     a = `"${a}"`;
     return a.replace(CMD_META, "^$1").replace(CMD_META, "^$1");
 }
-export function resolveEngineSpawn(bin, args, deps = {}) {
+export function resolveEngineSpawn(requested, args, deps = {}) {
+    const bin = officialEngineBinary(requested, deps) ?? requested;
     const windows = (deps.platform ?? process.platform) === "win32";
     if (!windows)
         return { command: bin, args, binaryPath: resolveBinary(bin, deps), via: "direct" };

package/dist/browser-runner/coding/grok-continuity.js

@@ -0,0 +1,53 @@
+/**
+ * Grok keeps ITS OWN conversation across one-shot turns (#1156) — by an id the runner chooses.
+ *
+ * Every Grok turn is a new `grok … -p "<turn>"` process, so without this each turn started with no memory of the last
+ * one but the platform's replay. `-c/--continue` was the CLI's only offer when the preset was written, and it picks the
+ * MOST RECENT session in the directory — another `grok` run in the same checkout (the owner's own) would answer instead
+ * (`coding-engines.ts`, "NO PRESET RESUMES"). xAI's Grok CLI now takes an explicit id, so continuity is exact:
+ *
+ *   first turn    `-s <uuid>`   a NEW conversation under an id the runner made up (1.x: must be a UUID, must not exist);
+ *   later turns   `-r <uuid>`   resume exactly that one (errors if it does not exist — never "the most recent").
+ *
+ * Checked against `grok --help` of xAI's Grok CLI 1.0.62 (2026-10-18). 0.2.x also accepts both: there `-s` creates-or-
+ * resumes and `-r` errors on an unknown id. NOT yet exercised end to end — the CLI refuses every turn until it is signed
+ * in, and it was not on the machine this was written on — so the runner treats it as unproven: a turn whose flags are
+ * rejected is retried once without them and the session runs without continuity, and the platform's replay is still
+ * sent with every turn (`holdsConversationThisTurn` stays false for Grok) until a signed-in run proves it.
+ */
+import { randomUUID } from "node:crypto";
+const UUID_RE = /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i;
+/** Only a UUID ever reaches argv — anything else read back from the state file is discarded. */
+export function isGrokConversationId(value) {
+    return typeof value === "string" && UUID_RE.test(value);
+}
+export function newGrokConversation(makeId = randomUUID) {
+    return { id: makeId(), started: false };
+}
+/** The turn's argv: the continuity flag first (any order parses), then the preset, then the turn as `-p`'s value. */
+export function grokTurnArgs(userArgs, turnText, conversation) {
+    if (!conversation)
+        return [...userArgs, turnText];
+    return [conversation.started ? "-r" : "-s", conversation.id, ...userArgs, turnText];
+}
+/**
+ * The CLI refused the continuity flags themselves — an argument error, printed before it signs in or runs anything (the
+ * argument parser runs first). Narrow on purpose: retrying any other failure could run a real instruction twice.
+ */
+// Only a line that BEGINS with the CLI's own `error:` (clap's argument errors), and only about these flags or the id —
+// a tool's output in a failed turn that merely mentions a session must never cause a same-turn retry.
+const REJECTED_RE = /^\s*error:\s(?:.*unexpected argument '?-(?:s|r)\b|.*(?:--session-id|--resume)\b|.*must be a valid uuid|.*session\b.*\b(?:not found|already exists|does not exist))/i;
+export function grokRejectedContinuity(lines) {
+    return lines.some((l) => REJECTED_RE.test(l));
+}
+/** What a finished turn means for the conversation. Pure. */
+export function afterGrokTurn(conversation, outcome) {
+    // The flags themselves were refused before anything ran: run without continuity from now on.
+    if (outcome.code && outcome.rejected)
+        return { next: null, persist: null, disable: true };
+    // Done: the CLI holds the conversation now. Remember it, so the next turn — and the next runner start — resume it.
+    if (outcome.code === 0)
+        return { next: { ...conversation, started: true }, persist: conversation.id, disable: false };
+    // Any other failure: the conversation may be half-made or unknown. Forget it, so the next turn starts a clean one.
+    return { next: null, persist: null, disable: false };
+}

package/dist/browser-runner/coding/headless-state.js

@@ -5,7 +5,7 @@ export function isCodexThreadId(value) {
     return typeof value === "string" && /^[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test(value);
 }
 function stateKey(id, engine) {
-    return engine === "codex" ? `codex:${id}` : id;
+    return engine === "claude" ? id : `${engine}:${id}`;
 }
 function loadFile(path) {
     if (!path || !existsSync(path))

package/dist/browser-runner/coding/headless.js

@@ -14,6 +14,7 @@ import { handlerFor } from "./handlers.js";
 import { resolveEngineAuth } from "./engine-auth.js";
 import { buildCodexResumeArgs, engineAdapterFor, engineInvocationModeFromAdapter, engineInvocationWarning, genericRawEngineAdapter } from "./engine-adapter.js";
 import { isCodexThreadId, readCodexState, readState, writeState } from "./headless-state.js";
+import { afterGrokTurn, grokRejectedContinuity, grokTurnArgs, isGrokConversationId, newGrokConversation } from "./grok-continuity.js";
 export { buildClaudeArgs } from "./engine-adapter.js";
 export { defaultStatePath } from "./headless-state.js";
 /**
@@ -70,6 +71,10 @@ export class HeadlessSession {
     claudeSessionId = null;
     /** Codex's thread id from `thread.started` — used only by the explicit-ID resume path (#848). */
     codexThreadId = null;
+    /** Grok's own conversation across one-shot turns (#1156, grok-continuity.ts); null = the next turn starts one. */
+    grokConversation = null;
+    /** Off once this machine's CLI refused the continuity flags: the session then runs as before, turn by turn. */
+    grokContinuity = true;
     /**
      * The cloud's context brief, until the first turn spends it (ADR 0005, #693). Null once
      * delivered, and null from the start when the engine resumed its own conversation.
@@ -270,6 +275,8 @@ export class HeadlessSession {
             config.clientType === "codex" && this.mode === "stream-json" && !config.fresh
                 ? readCodexState(config.statePath, config.id) ?? (config.resumeFrom ? readCodexState(config.statePath, config.resumeFrom) : null)
                 : null;
+        const storedGrok = config.clientType === "grok" && !config.fresh ? (readState(config.statePath, config.id, "grok") ?? (config.resumeFrom ? readState(config.statePath, config.resumeFrom, "grok") : null)) : null;
+        this.grokConversation = isGrokConversationId(storedGrok) ? { id: storedGrok, started: true } : null;
         // AFTER both lines above, because `resumedConversation` reads them: the brief is the fallback,
         // so an engine that found its own conversation drops it unread rather than being handed a
         // summary of the conversation it is already in.
@@ -590,9 +597,15 @@ export class HeadlessSession {
         this.structuredOutputRejected = false;
         const resumedCodexThreadId = this.codexResumeThreadId;
         const inputId = this.turnInputId;
+        // #1156: Grok carries its conversation by an id this runner chose — `-s` to make it, `-r` to resume it.
+        if (this.config.clientType === "grok" && this.grokContinuity && !this.grokConversation)
+            this.grokConversation = newGrokConversation();
+        const grokConversation = this.config.clientType === "grok" && this.grokContinuity ? this.grokConversation : null;
         const turnArgs = resumedCodexThreadId
             ? buildCodexResumeArgs(this.cmdArgs, resumedCodexThreadId, text)
-            : this.adapter.buildTurnArgs(this.cmdArgs, text);
+            : grokConversation
+                ? grokTurnArgs(this.cmdArgs, text, grokConversation)
+                : this.adapter.buildTurnArgs(this.cmdArgs, text);
         const env = this.spawnEnv;
         const target = spawnTarget(this.cmdPrefix, this.cmdBin, turnArgs);
         const launch = resolveEngineSpawn(target.command, target.args, { env });
@@ -687,6 +700,19 @@ export class HeadlessSession {
                 this.runOneShot(text);
                 return;
             }
+            if (grokConversation) {
+                const after = afterGrokTurn(grokConversation, { code, rejected: grokRejectedContinuity(this.turnTail) });
+                this.grokConversation = after.next;
+                writeState(this.config.statePath, this.config.id, after.persist, "grok");
+                // The flags were refused before anything ran (an argument error): the same turn again, without them.
+                if (after.disable) {
+                    this.grokContinuity = false;
+                    this.proc = null;
+                    this.push("[grok CLI rejected its session flags; retrying this turn without conversation continuity]");
+                    this.runOneShot(text);
+                    return;
+                }
+            }
             // A rejected/expired explicit ID is not retried as the same turn: the CLI may have started
             // work before failing. Drop only that known-bad local key so the NEXT turn is safely fresh.
             if (code && resumedCodexThreadId && this.codexThreadId === resumedCodexThreadId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-  "version": "0.4.153",
+  "version": "0.4.154",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",