@proagentstore/cli 0.4.159 → 0.4.161

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

@@ -1,9 +1,10 @@
 import { stripAnsi } from "./transcript-lines.js";
+import { createGrokEngineAdapter, grokOutputFormat } from "./grok-adapter.js";
 export function engineInvocationModeFromAdapter(mode) {
     return mode === "stream-json" ? "structured" : "raw";
 }
 export function structuredCapableEngine(clientType) {
-    return clientType === "claude" || clientType === "codex";
+    return clientType === "claude" || clientType === "codex" || clientType === "grok";
 }
 export function engineInvocationWarning(clientType, mode) {
     if (mode !== "raw" || !structuredCapableEngine(clientType))
@@ -234,5 +235,8 @@ export function engineAdapterFor(clientType, userArgs = []) {
         return claudeEngineAdapter;
     if (clientType === "codex" && userArgs[0] === "exec" && !["resume", "fork", "review", "help"].includes(userArgs[1] ?? ""))
         return codexEngineAdapter;
+    // Grok's NDJSON stream (#1187) — unless the preset chose another output format on purpose, which stays raw.
+    if (clientType === "grok" && [null, "streaming-json"].includes(grokOutputFormat(userArgs)))
+        return createGrokEngineAdapter();
     return genericRawEngineAdapter;
 }

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

@@ -123,3 +123,43 @@ export function checkEngine(input, deps = {}) {
         ...(engine === "grok" && binaryPath ? { vendor: grokVendor(versionText, (deps.realpath ?? safeRealpath)(binaryPath)) } : {}),
     };
 }
+/** `grok models` → its ids and default; null when the output has no model list in it. */
+export function parseGrokModels(text) {
+    const lines = text.split(/\r?\n/);
+    const start = lines.findIndex((l) => /^\s*Available models:\s*$/i.test(l));
+    if (start < 0)
+        return null;
+    const models = [];
+    for (const line of lines.slice(start + 1)) {
+        const m = /^\s*[*-]\s+(\S+)/.exec(line);
+        if (m)
+            models.push(m[1]);
+        else if (line.trim())
+            break;
+    }
+    if (!models.length)
+        return null;
+    const named = /^\s*Default model:\s*(\S+)/im.exec(text)?.[1] ?? null;
+    const starred = lines.slice(start + 1).find((l) => /^\s*\*\s+/.test(l))?.trim().split(/\s+/)[1] ?? null;
+    return { models, defaultModel: named ?? starred };
+}
+export function listEngineModels(input, deps = {}) {
+    const engine = (["claude", "gemini", "codex", "grok", "generic"].includes(input.clientType ?? "") ? input.clientType : "claude");
+    if (engine !== "grok")
+        return { clientType: engine, models: null, defaultModel: null, reason: `the ${engine} CLI publishes no model list` };
+    const command = parseCommand(input.command);
+    const bin = unwrapLauncher(command.bin, command.args).bin || "grok";
+    const launch = resolveEngineSpawn(bin, ["models"], deps);
+    if (!launch.binaryPath)
+        return { clientType: engine, models: null, defaultModel: null, reason: "grok is not installed on this machine" };
+    const text = (deps.listText ?? defaultListText)(launch, deps.env ?? process.env);
+    const parsed = text ? parseGrokModels(text) : null;
+    if (!parsed)
+        return { clientType: engine, models: null, defaultModel: null, reason: "`grok models` gave no model list (is the CLI signed in?)" };
+    return { clientType: engine, ...parsed };
+}
+function defaultListText(launch, env) {
+    const command = launch.via === "direct" && launch.binaryPath ? launch.binaryPath : launch.command;
+    const r = spawnSync(command, launch.args, { encoding: "utf8", env, timeout: 20_000, windowsHide: true, windowsVerbatimArguments: launch.windowsVerbatimArguments });
+    return r.error || r.status !== 0 ? null : `${r.stdout ?? ""}${r.stderr ?? ""}`;
+}

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

@@ -0,0 +1,110 @@
+function record(v) {
+    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function hasFlag(args, flag) {
+    return args.some((a) => a === flag || a.startsWith(`${flag}=`));
+}
+/** The value a preset gave `--output-format`, or null. */
+export function grokOutputFormat(args) {
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--output-format")
+            return args[i + 1] ?? null;
+        if (args[i].startsWith("--output-format="))
+            return args[i].slice("--output-format=".length);
+    }
+    return null;
+}
+/** The preset's argv with the structured-output flags in front — any order parses, and the trailing `-p` stays last. */
+export function grokStructuredArgs(userArgs) {
+    const add = [];
+    if (!grokOutputFormat(userArgs))
+        add.push("--output-format", "streaming-json");
+    if (!hasFlag(userArgs, "--no-auto-update"))
+        add.push("--no-auto-update");
+    return [...add, ...userArgs];
+}
+/** The text a terminal call produced: its content blocks, else `output_for_prompt` without its `exit: N` header. */
+function toolOutput(ev, raw) {
+    const texts = (Array.isArray(ev.content) ? ev.content : []).flatMap((c) => {
+        const inner = record(record(c)?.content);
+        return typeof inner?.text === "string" ? [inner.text] : [];
+    });
+    if (texts.some((t) => t.trim()))
+        return texts.join("");
+    const prompt = typeof raw?.output_for_prompt === "string" ? raw.output_for_prompt : "";
+    return prompt.replace(/^exit: -?\d+\n/, "");
+}
+/** A Grok call as the tool the rest of the runner knows: its terminal tool IS a Bash call. */
+function asTool(ev) {
+    const rawInput = record(ev.rawInput) ?? {};
+    if (ev.kind === "execute" && typeof rawInput.command === "string")
+        return { name: "Bash", input: { command: rawInput.command } };
+    return { name: typeof ev.toolName === "string" && ev.toolName ? ev.toolName : String(ev.title ?? "tool"), input: rawInput };
+}
+/** One session's adapter: it holds the reply being streamed in deltas until something else happens. */
+export function createGrokEngineAdapter() {
+    let text = "";
+    const flush = () => {
+        const t = text.trim();
+        text = "";
+        return t ? [{ kind: "assistant_text", text: t }] : [];
+    };
+    function parseLine(line) {
+        let ev;
+        try {
+            ev = record(JSON.parse(line));
+        }
+        catch {
+            return [];
+        }
+        if (!ev)
+            return [];
+        switch (ev.type) {
+            case "text":
+                if (typeof ev.data === "string")
+                    text += ev.data;
+                return [{ kind: "meta" }];
+            case "thought":
+            case "usage":
+            case "available_commands":
+                return [{ kind: "meta" }];
+            case "tool_call": {
+                const id = typeof ev.toolCallId === "string" ? ev.toolCallId : "";
+                const { name, input } = asTool(ev);
+                return [...flush(), { kind: "tool_use", block: { type: "tool_use", id, name, input }, id, name, input }];
+            }
+            case "tool_call_update": {
+                // Pending and in-progress updates are the same call filling in; only its END settles it.
+                if (ev.status !== "completed" && ev.status !== "failed")
+                    return [{ kind: "meta" }];
+                const id = typeof ev.toolCallId === "string" ? ev.toolCallId : "";
+                const raw = record(ev.rawOutput);
+                const exitCode = typeof raw?.exit_code === "number" ? raw.exit_code : null;
+                const content = toolOutput(ev, raw);
+                const block = { type: "tool_result", tool_use_id: id, is_error: ev.status === "failed" || (exitCode !== null && exitCode !== 0), content };
+                return [{ kind: "tool_result", block, toolUseId: id, content }];
+            }
+            case "end": {
+                const stop = typeof ev.stopReason === "string" ? ev.stopReason : "";
+                const isError = stop !== "end_turn";
+                return [...flush(), { kind: "turn_end", raw: ev, isError, result: isError ? `stopped: ${stop || "unknown"}` : "" }];
+            }
+            case "error": {
+                const message = typeof ev.message === "string" ? ev.message : typeof record(ev.error)?.message === "string" ? record(ev.error)?.message : "";
+                return message.trim() ? [{ kind: "engine_error", text: message.trim() }] : [{ kind: "meta" }];
+            }
+            default:
+                return [];
+        }
+    }
+    return {
+        mode: "stream-json",
+        persistent: false,
+        prepareArgs: grokStructuredArgs,
+        buildLaunchArgs: (userArgs) => [...userArgs],
+        buildTurnArgs: (userArgs, turnText) => [...userArgs, turnText],
+        parseLine,
+        // An older Grok CLI that does not know a flag refuses before it runs the prompt, so one retry raw is safe.
+        rejectsStructuredOutput: (line) => /(?:--output-format|--no-auto-update|streaming-json)/.test(line) && /(?:unexpected argument|unknown (?:argument|option)|unrecognized|invalid value|isn't a valid value)/i.test(line),
+    };
+}

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

@@ -15,7 +15,7 @@ const HANDLERS = {
     claude: { clientType: "claude", cliCommand: "claude --dangerously-skip-permissions", envVar: "ANTHROPIC_API_KEY" },
     gemini: { clientType: "gemini", cliCommand: "gemini --approval-mode yolo --skip-trust --prompt", envVar: "GEMINI_API_KEY" },
     codex: { clientType: "codex", cliCommand: "codex exec --json --sandbox danger-full-access", envVar: "OPENAI_API_KEY" },
-    grok: { clientType: "grok", cliCommand: "grok --permission-mode bypassPermissions -p", envVar: "XAI_API_KEY" },
+    grok: { clientType: "grok", cliCommand: "grok --permission-mode bypassPermissions --no-auto-update --output-format streaming-json -p", envVar: "XAI_API_KEY" },
     generic: { clientType: "generic", cliCommand: "bash", envVar: "" },
 };
 export function handlerFor(clientType) {

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

@@ -601,11 +601,12 @@ export class HeadlessSession {
         if (this.config.clientType === "grok" && this.grokContinuity && !this.grokConversation)
             this.grokConversation = newGrokConversation();
         const grokConversation = this.config.clientType === "grok" && this.grokContinuity ? this.grokConversation : null;
+        const presetArgs = this.adapter.prepareArgs?.(this.cmdArgs) ?? this.cmdArgs; // #1187: Grok's structured flags; gone with the adapter if refused
         const turnArgs = resumedCodexThreadId
             ? buildCodexResumeArgs(this.cmdArgs, resumedCodexThreadId, text)
             : grokConversation
-                ? grokTurnArgs(this.cmdArgs, text, grokConversation)
-                : this.adapter.buildTurnArgs(this.cmdArgs, text);
+                ? grokTurnArgs(presetArgs, text, grokConversation)
+                : this.adapter.buildTurnArgs(presetArgs, text);
         const env = this.spawnEnv;
         const target = spawnTarget(this.cmdPrefix, this.cmdBin, turnArgs);
         const launch = resolveEngineSpawn(target.command, target.args, { env });

package/dist/browser-runner/server.js

@@ -5,7 +5,7 @@ import { URL } from "node:url";
 import { recordRequestFailure } from "./request-failure.js";
 import { LocalRunner, RunnerInputError } from "./runner.js";
 import { probeGitSshIdentity } from "./coding/repo.js";
-import { checkEngine } from "./coding/engine-check.js";
+import { checkEngine, listEngineModels } from "./coding/engine-check.js";
 import { listGithubOrgs, listGithubRepos, searchGithubRepos, getGithubRepoDetail, getGithubCredentialScope } from "./coding/github-browse.js";
 import { routeLocalApplyHandoff } from "./local-apply/handoff-routes.js";
 import { runNativePreflight } from "./native/preflight.js";
@@ -552,10 +552,10 @@ async function route(runner, req, res) {
     // Can this machine run an engine — its binary on PATH, its subscription login stored (#879)? Asked
     // BEFORE a session is launched, so a missing engine is a named refusal rather than a dead pane.
     // An older runner 404s this, and the cloud reads that as "unverified", never as "missing".
-    if (req.method === "POST" && path === "/coding/engine-check") {
+    if (req.method === "POST" && (path === "/coding/engine-check" || path === "/coding/engine-models")) {
         const b = await readJson(req);
         try {
-            return json(res, 200, checkEngine(b));
+            return json(res, 200, path === "/coding/engine-models" ? listEngineModels(b) : checkEngine(b)); // #1199: the CLI's live model list
         }
         catch (e) {
             return json(res, 400, { error: e instanceof Error ? e.message : String(e) });

package/package.json

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