@proagentstore/cli 0.4.113 → 0.4.115

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

@@ -1,20 +1,10 @@
 import { spawnSync } from "node:child_process";
-import { accessSync, constants, statSync } from "node:fs";
+import { statSync } from "node:fs";
 import { homedir } from "node:os";
-import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { join } from "node:path";
 import { handlerFor } from "./handlers.js";
 import { parseCommand } from "./headless.js";
-function defaultIsExecutable(p) {
-    try {
-        if (!statSync(p).isFile())
-            return false;
-        accessSync(p, constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
+import { resolveEngineSpawn } from "./engine-spawn.js";
 function defaultExists(p) {
     try {
         statSync(p);
@@ -29,28 +19,6 @@ function defaultKeychainItemStatus(service) {
     const r = spawnSync("security", ["find-generic-password", "-s", service], { stdio: "ignore", timeout: 5_000 });
     return r.error ? null : r.status;
 }
-/** The same resolution `spawn(bin)` does: a path is taken as-is, a bare name is searched on PATH. */
-export function resolveBinary(bin, deps = {}) {
-    const isExec = deps.isExecutable ?? defaultIsExecutable;
-    if (!bin)
-        return null;
-    if (bin.includes("/") || isAbsolute(bin)) {
-        const p = resolve(bin);
-        return isExec(p) ? p : null;
-    }
-    const env = deps.env ?? process.env;
-    const exts = (deps.platform ?? process.platform) === "win32" ? (env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
-    for (const dir of (env.PATH || "").split(delimiter)) {
-        if (!dir)
-            continue;
-        for (const ext of exts) {
-            const p = join(dir, bin + ext);
-            if (isExec(p))
-                return p;
-        }
-    }
-    return null;
-}
 /** Does this engine have a stored interactive login on the machine? */
 export function detectEngineLogin(engine, deps = {}) {
     const env = deps.env ?? process.env;
@@ -100,14 +68,14 @@ export function checkEngine(input, deps = {}) {
     const engine = (["claude", "gemini", "codex", "grok", "generic"].includes(input.clientType ?? "") ? input.clientType : "claude");
     const parsed = parseCommand(input.command);
     const bin = parsed.bin || parseCommand(handlerFor(engine).cliCommand).bin || engine;
-    const binaryPath = resolveBinary(bin, deps);
+    const { binaryPath, via } = resolveEngineSpawn(bin, [], deps);
     const login = input.credentialInjected ? { login: "found", where: "platform" } : detectEngineLogin(engine, deps);
     return {
         checked: true,
         engine,
         bin,
         binaryFound: binaryPath !== null,
-        ...(binaryPath ? { binaryPath } : {}),
+        ...(binaryPath ? { binaryPath, binaryVia: via } : {}),
         login: login.login,
         ...(login.where ? { loginWhere: login.where } : {}),
     };

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

@@ -0,0 +1,99 @@
+import { accessSync, constants, readFileSync, statSync } from "node:fs";
+import { posix, win32 } from "node:path";
+function defaultIsExecutable(p) {
+    try {
+        if (!statSync(p).isFile())
+            return false;
+        accessSync(p, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function defaultReadText(p) {
+    try {
+        return readFileSync(p, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/** Windows env names are case-insensitive, but a copied env object is not (`Path`, `ComSpec`). */
+function envVar(env, name, windows) {
+    if (!windows)
+        return env[name];
+    const key = Object.keys(env).find((k) => k.toUpperCase() === name);
+    return key ? env[key] : undefined;
+}
+const isPathLike = (bin, windows) => bin.includes("/") || (windows ? bin.includes("\\") || win32.isAbsolute(bin) : posix.isAbsolute(bin));
+/** The same resolution `spawn(bin)` does: a path is taken as-is, a bare name is searched on PATH (with PATHEXT on Windows). */
+export function resolveBinary(bin, deps = {}) {
+    const isExec = deps.isExecutable ?? defaultIsExecutable;
+    if (!bin)
+        return null;
+    const windows = (deps.platform ?? process.platform) === "win32";
+    const path = windows ? win32 : posix;
+    if (isPathLike(bin, windows)) {
+        const p = path.resolve(bin);
+        return isExec(p) ? p : null;
+    }
+    const env = deps.env ?? process.env;
+    const exts = windows ? (envVar(env, "PATHEXT", true) || ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of (envVar(env, "PATH", windows) || "").split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const p = path.join(dir, bin + ext);
+            if (isExec(p))
+                return p;
+        }
+    }
+    return null;
+}
+/** The first `%dp0%\node_modules\…` target an npm (cmd-shim) `.cmd` launches, absolute. */
+export function shimTarget(shimPath, text) {
+    const m = /"%~?dp0%?\\(node_modules\\[^"]+)"/i.exec(text);
+    return m ? win32.join(win32.dirname(shimPath), m[1]) : null;
+}
+// cmd.exe metacharacters (cross-spawn's set). A caret makes the next one literal for one parse.
+const CMD_META = /([()\][%!^"`<>&|;, *?])/g;
+/**
+ * One argument for `cmd.exe /s /c "<shim> <args>"`: quoted for the CRT's argv parser, then
+ * caret-escaped twice — once for cmd's own parse, once more for the shim's `%*` re-parse.
+ */
+export function quoteCmdArg(arg) {
+    let a = arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1");
+    a = `"${a}"`;
+    return a.replace(CMD_META, "^$1").replace(CMD_META, "^$1");
+}
+export function resolveEngineSpawn(bin, args, deps = {}) {
+    const windows = (deps.platform ?? process.platform) === "win32";
+    if (!windows)
+        return { command: bin, args, binaryPath: resolveBinary(bin, deps), via: "direct" };
+    const env = deps.env ?? process.env;
+    // Real executables first: PATHEXT order would otherwise pick `.CMD` over a later `.EXE` in no order we chose.
+    const exe = resolveBinary(bin, { ...deps, env: { ...env, PATHEXT: ".exe;.com" } });
+    const found = exe ?? resolveBinary(bin, { ...deps, env: { ...env, PATHEXT: ".cmd;.bat" } });
+    if (!found)
+        return { command: bin, args, binaryPath: null, via: "direct" };
+    if (!/\.(cmd|bat)$/i.test(found))
+        return { command: found, args, binaryPath: found, via: "direct" };
+    const isExec = deps.isExecutable ?? defaultIsExecutable;
+    const text = (deps.readText ?? defaultReadText)(found);
+    const target = text ? shimTarget(found, text) : null;
+    if (target && isExec(target)) {
+        if (/\.(exe|com)$/i.test(target))
+            return { command: target, args, binaryPath: target, via: "direct" };
+        if (/\.[cm]?js$/i.test(target))
+            return { command: deps.nodePath ?? process.execPath, args: [target, ...args], binaryPath: target, via: "node" };
+    }
+    const line = [found.replace(CMD_META, "^$1"), ...args.map(quoteCmdArg)].join(" ");
+    return {
+        command: envVar(env, "COMSPEC", true) || "cmd.exe",
+        args: ["/d", "/s", "/c", `"${line}"`],
+        windowsVerbatimArguments: true,
+        binaryPath: found,
+        via: "cmd",
+    };
+}

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

@@ -7,6 +7,7 @@ import { appendTurnTail, turnReportFromExit, turnReportFromResult } from "./engi
 import { renderToolResult, shortInput, stripAnsi } from "./transcript-lines.js";
 import { authoredTurn, authorTag } from "./turn-author.js";
 import { engineSpawnEnv, mergeEnv } from "./engine-env.js";
+import { resolveEngineSpawn } from "./engine-spawn.js";
 import { ghGuardStatus } from "./gh-guard.js";
 import { handlerFor } from "./handlers.js";
 import { resolveEngineAuth } from "./engine-auth.js";
@@ -426,10 +427,13 @@ export class HeadlessSession {
         this.inputs.newEngine();
         this.buf = "";
         const args = this.adapter.buildLaunchArgs(this.cmdArgs, this.claudeSessionId);
-        const proc = spawn(this.cmdBin, args, {
+        const env = this.spawnEnv;
+        const launch = resolveEngineSpawn(this.cmdBin, args, { env });
+        const proc = spawn(launch.command, launch.args, {
             cwd: this.config.workDir,
-            env: this.spawnEnv,
+            env,
             stdio: ["pipe", "pipe", "pipe"],
+            windowsVerbatimArguments: launch.windowsVerbatimArguments,
         });
         this.proc = proc;
         this.run = "idle";
@@ -582,10 +586,13 @@ export class HeadlessSession {
         const turnArgs = resumedCodexThreadId
             ? buildCodexResumeArgs(this.cmdArgs, resumedCodexThreadId, text)
             : this.adapter.buildTurnArgs(this.cmdArgs, text);
-        const proc = spawn(this.cmdBin, turnArgs, {
+        const env = this.spawnEnv;
+        const launch = resolveEngineSpawn(this.cmdBin, turnArgs, { env });
+        const proc = spawn(launch.command, launch.args, {
             cwd: this.config.workDir,
-            env: this.spawnEnv,
+            env,
             stdio: ["ignore", "pipe", "pipe"],
+            windowsVerbatimArguments: launch.windowsVerbatimArguments,
         });
         // A turn already running is aborted before its replacement starts: `input()` accepts a turn
         // at any time — a human typing in the console, a takeover, a Loop that stopped waiting —

package/dist/index.js

@@ -1260,6 +1260,7 @@ import { execFile, spawn as spawn3 } from "child_process";
 import { promisify } from "util";
 var run = promisify(execFile);
 var RUNNER_UPDATE_PATH = "/pags/runner/update";
+var RUNNER_RESTART_PATH = "/pags/runner/restart";
 var RUNNER_RESTART_EXIT_CODE = 75;
 var SUPERVISED_ENV = "PAGS_UP_SUPERVISED";
 var SUPERVISOR_RESTARTS = "2";
@@ -1317,6 +1318,28 @@ function planRunnerUpdate(f) {
   if (f.busy.length > 0) return { action: "wait", current: f.current, latest: f.latest, waitingFor: f.busy };
   return { action: "update", current: f.current, latest: f.latest, restarter: f.restarter };
 }
+function planRunnerRestart(f) {
+  if (!f.restarter) {
+    return {
+      action: "refused",
+      current: f.current,
+      reason: `Nothing would start this runner again after a restart: it was not started by \`pags up\`, and neither ${SERVICE_ENV}=1 nor ${RESTART_COMMAND_ENV} is set. Restart it at the machine.`
+    };
+  }
+  if (!f.force) {
+    if (f.busy === null || f.busy.includes("runner-work-observation-unavailable")) {
+      return {
+        action: "refused",
+        current: f.current,
+        reason: "The local runtime did not answer the work check, so this machine cannot be shown idle \u2014 it may be the part that is wedged. Restart with force to restart anyway; any run in progress on this machine is lost."
+      };
+    }
+    if (f.busy.length > 0) {
+      return { action: "refused", current: f.current, waitingFor: f.busy, reason: `${f.busy.length} piece(s) of work are running here. Restart when they finish, or with force (that work is lost).` };
+    }
+  }
+  return { action: "restart", current: f.current, restarter: f.restarter };
+}
 async function installVersion(version2) {
   if (process.env[BOOTSTRAP_ENV]) {
     await installPayload(version2);
@@ -2222,7 +2245,7 @@ function createInstallBridge(deps) {
 
 // src/commands/runner/relay.ts
 var MEMBERSHIP_SYNC_PATH = "/pags/membership/sync";
-var CLI_CONTROL_PATHS = /* @__PURE__ */ new Set([MEMBERSHIP_SYNC_PATH, RUNNER_UPDATE_PATH]);
+var CLI_CONTROL_PATHS = /* @__PURE__ */ new Set([MEMBERSHIP_SYNC_PATH, RUNNER_UPDATE_PATH, RUNNER_RESTART_PATH]);
 async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force = false, watchInstances = false) {
   const apiBase = pagsApiBase(opts.apiBase).replace(/^http/, "ws");
   const pagsToken = clean(opts.pagsToken) || clean(process.env.PAGS_TOKEN) || clean(loadSession()?.token);
@@ -2279,7 +2302,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     writeLine(formatStatusLine({ registration: state, agents, reason: state === "ok" ? void 0 : lastRegisterError }));
   };
   for (const id of instanceIds) await registerRuntime(id);
-  const updateFacts = async (signal) => {
+  const workLook = async (signal) => {
     const [sessionsResult, healthResult] = await Promise.allSettled([
       requestRunner("GET", "/coding/sessions", {
         url: localUrl,
@@ -2288,7 +2311,10 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       }, void 0, signal),
       requestRunner("GET", "/health", { url: localUrl, token: runnerToken, instanceId: instanceIds[0] }, void 0, signal)
     ]);
-    const { busy, observations } = readWorkLook(sessionsResult, healthResult, Date.now());
+    return readWorkLook(sessionsResult, healthResult, Date.now());
+  };
+  const updateFacts = async (signal) => {
+    const { busy, observations } = await workLook(signal);
     return {
       observations,
       current: CLI_VERSION,
@@ -2389,8 +2415,21 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     setTimeout(() => leaveForRestart(plan.restarter), 25).unref();
     return { status: 200, result: { action: "restarting", current: plan.current, latest: plan.latest, restartedBy: plan.restarter, ...supervisor ? { supervisor } : {} } };
   };
+  const answerRestart = async (body) => {
+    const request = body;
+    const dryRun = request?.dryRun === true;
+    const force2 = request?.force === true;
+    if (bridge.inFlight()) return { status: 409, result: { error: "A runner update is installing or restarting; nothing else restarted." } };
+    const look = force2 ? null : await boundedWork((signal) => workLook(signal));
+    const plan = planRunnerRestart({ current: CLI_VERSION, restarter: restarterFrom(process.env), busy: force2 ? [] : look?.busy ?? null, force: force2 });
+    if (dryRun || plan.action === "refused") return { status: 200, result: { ...plan, dryRun } };
+    setTimeout(() => leaveForRestart(plan.restarter), 25).unref();
+    const supervisor = supervisorNote(plan.restarter);
+    return { status: 200, result: { action: "restarting", current: plan.current, latest: plan.current, restartedBy: plan.restarter, forced: force2, ...supervisor ? { supervisor } : {} } };
+  };
   const answerControl = async (path, body) => {
     if (path === RUNNER_UPDATE_PATH) return answerUpdate(body);
+    if (path === RUNNER_RESTART_PATH) return answerRestart(body);
     if (path !== MEMBERSHIP_SYNC_PATH) return { status: 404, result: { error: `Unknown runner control ${path}` } };
     const request = body;
     const named = typeof request?.attach === "string" ? request.attach : "";

package/package.json

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