@proagentstore/cli 0.4.125 → 0.4.127

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

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { unwrapLauncher } from "./launcher-wrapper.js";
 import { statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -66,7 +67,9 @@ export function detectEngineLogin(engine, deps = {}) {
  */
 export function checkEngine(input, deps = {}) {
     const engine = (["claude", "gemini", "codex", "grok", "generic"].includes(input.clientType ?? "") ? input.clientType : "claude");
-    const parsed = parseCommand(input.command);
+    // The ENGINE is what must be installed — after a `pas mcp-auth exec --` wrapper (#1006), not the wrapper.
+    const command = parseCommand(input.command);
+    const parsed = unwrapLauncher(command.bin, command.args);
     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);

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

@@ -1,4 +1,5 @@
 import { InputLedger } from "./input-ledger.js";
+import { spawnTarget, unwrapLauncher } from "./launcher-wrapper.js";
 import { runObjectiveBlock } from "./run-objective.js";
 import { spawn } from "node:child_process";
 import { classifyCommand, commandFromToolInput, fillTargetFromResult, toolCallOk, toolResultMark } from "./engine-acts.js";
@@ -83,6 +84,8 @@ export class HeadlessSession {
     mode;
     adapter;
     cmdBin;
+    /** A launcher wrapper spawned in front of the engine (`pas mcp-auth exec --`), or empty. */
+    cmdPrefix;
     cmdArgs;
     binName;
     /** Wall-clock of the last stdout/stderr byte — drives the persistent-raw idle heuristic. */
@@ -242,7 +245,10 @@ export class HeadlessSession {
     constructor(config) {
         this.config = config;
         this.engineLabel = `${config.clientType}:${config.id}`;
-        const { bin, args } = parseCommand(config.command);
+        // `pas mcp-auth exec -- codex …` (#1006): spawn the wrapper, but drive the engine after `--`.
+        const parsed = parseCommand(config.command);
+        const { prefix, bin, args } = unwrapLauncher(parsed.bin, parsed.args);
+        this.cmdPrefix = prefix;
         // When no explicit command is configured, fall back to THIS engine's default
         // command (codex/gemini/grok/…) — not a hard-coded "claude", which would drive a
         // non-Claude session with the wrong CLI (and mode is already "raw" for it).
@@ -428,7 +434,8 @@ export class HeadlessSession {
         this.buf = "";
         const args = this.adapter.buildLaunchArgs(this.cmdArgs, this.claudeSessionId);
         const env = this.spawnEnv;
-        const launch = resolveEngineSpawn(this.cmdBin, args, { env });
+        const target = spawnTarget(this.cmdPrefix, this.cmdBin, args);
+        const launch = resolveEngineSpawn(target.command, target.args, { env });
         const proc = spawn(launch.command, launch.args, {
             cwd: this.config.workDir,
             env,
@@ -587,7 +594,8 @@ export class HeadlessSession {
             ? buildCodexResumeArgs(this.cmdArgs, resumedCodexThreadId, text)
             : this.adapter.buildTurnArgs(this.cmdArgs, text);
         const env = this.spawnEnv;
-        const launch = resolveEngineSpawn(this.cmdBin, turnArgs, { env });
+        const target = spawnTarget(this.cmdPrefix, this.cmdBin, turnArgs);
+        const launch = resolveEngineSpawn(target.command, target.args, { env });
         const proc = spawn(launch.command, launch.args, {
             cwd: this.config.workDir,
             env,

package/dist/browser-runner/coding/launcher-wrapper.js

@@ -0,0 +1,25 @@
+/**
+ * `pas mcp-auth exec -- <engine …>` (#1006, PAS #356) on the runner.
+ *
+ * The ProAppStore CLI runs a command with the owner's remote PAS MCP credential in that process's
+ * environment only. So the runner must SPAWN the wrapper (it is what supplies the token) while
+ * everything that understands an engine — the adapter choice (`codex exec` → structured), the turn
+ * and resume argument builders, the engine-installed check — works on the ENGINE command after `--`.
+ *
+ * Matched exactly, as in the API (`workers/api/src/lib/coding-command.ts`) and the SDK
+ * (`packages/sdk/src/engine-posture.ts`): `pas` followed by anything other than `mcp-auth exec --`
+ * is not a wrapper, and stays the binary.
+ */
+export const PAS_MCP_AUTH_WRAPPER = ["mcp-auth", "exec", "--"];
+export function unwrapLauncher(bin, args) {
+    const isPas = (bin.split("/").pop() || "").toLowerCase() === "pas";
+    if (!isPas || !PAS_MCP_AUTH_WRAPPER.every((t, k) => args[k] === t) || args.length <= PAS_MCP_AUTH_WRAPPER.length) {
+        return { prefix: [], bin, args: [...args] };
+    }
+    const rest = args.slice(PAS_MCP_AUTH_WRAPPER.length);
+    return { prefix: [bin, ...PAS_MCP_AUTH_WRAPPER], bin: rest[0], args: rest.slice(1) };
+}
+/** What to actually spawn: the wrapper (if any) carrying the engine and its built args. */
+export function spawnTarget(prefix, bin, args) {
+    return prefix.length ? { command: prefix[0], args: [...prefix.slice(1), bin, ...args] } : { command: bin, args: [...args] };
+}

package/dist/browser-runner/native/contract.js

@@ -0,0 +1,17 @@
+/**
+ * Native desktop / Maestro runtime (`local_native`, #1057) — the wire contract between the API
+ * Worker and the runner.
+ *
+ * This file is copied BYTE-FOR-BYTE between `packages/browser-runner/src/native/contract.ts` and
+ * `workers/api/src/lib/native/contract.ts` (the two packages cannot import each other), and
+ * `workers/api/src/lib/native/contract.test.ts` fails if they differ. It imports nothing.
+ *
+ * Slice 1 is the FOUNDATION only: a read-only preflight that reports what this machine could do,
+ * plus the run/event shapes the later slices will use. Nothing here drives a screen, a mouse, a
+ * keyboard or a Maestro flow yet.
+ */
+/** The runner route the API calls (over the relay) to probe a machine. Read-only. */
+export const NATIVE_PREFLIGHT_PATH = "/native/preflight";
+/** The capability a runner advertises once it can answer {@link NATIVE_PREFLIGHT_PATH}. */
+export const NATIVE_PREFLIGHT_CAPABILITY = "native.preflight";
+export const NATIVE_BACKENDS = ["desktop", "maestro"];

package/dist/browser-runner/native/preflight.js

@@ -0,0 +1,172 @@
+/**
+ * `/native/preflight` (#1057, slice 1): what this machine could do for the `local_native` runtime
+ * — desktop control permissions and Maestro devices — WITHOUT doing any of it.
+ *
+ * Rules this module keeps:
+ *   - READ-ONLY. It runs fixed probe commands and installs nothing. It never prompts for an OS
+ *     permission either: on macOS the two checks are the "preflight" APIs that only report state
+ *     (`CGPreflightScreenCaptureAccess`, `AXIsProcessTrusted`), not the "request" ones that open a
+ *     system dialog. (`screencapture` is NOT used as the probe: without Screen Recording it still
+ *     exits 0 and captures only the wallpaper, so its exit code proves nothing.)
+ *   - NEVER THROWS. A missing tool, a timeout or garbage output becomes a state (`unknown`, not
+ *     installed, no devices) and a stable error code with a sentence the owner can act on.
+ *   - Parsing is pure and exported, so it is tested on recorded outputs — no live device needed.
+ *
+ * `adb devices` starts the adb server if it is not already running; that is adb's own behaviour
+ * when asked to list devices, not something installed or configured here.
+ */
+import { execFile } from "node:child_process";
+import { arch as osArch, platform as osPlatform } from "node:os";
+/** Run one probe command; never rejects. */
+export const execProbe = (cmd, args, timeoutMs = 8000) => new Promise((resolve) => {
+    execFile(cmd, args, { timeout: timeoutMs, windowsHide: true, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+        const e = err;
+        if (e?.code === "ENOENT")
+            return resolve({ found: false, code: null, stdout: "", stderr: "" });
+        resolve({
+            found: true,
+            code: e ? (typeof e.code === "number" ? e.code : 1) : 0,
+            stdout: String(stdout ?? ""),
+            stderr: String(stderr ?? ""),
+            ...(e?.killed ? { timedOut: true } : {}),
+        });
+    });
+});
+// ── Pure parsers ────────────────────────────────────────────────────────────
+/** `osascript -l JavaScript` printing `true`/`false` → a permission state. */
+export function parseBooleanProbe(r) {
+    if (!r.found || r.timedOut || r.code !== 0)
+        return "unknown";
+    const out = r.stdout.trim().toLowerCase();
+    return out === "true" ? "granted" : out === "false" ? "denied" : "unknown";
+}
+/** `maestro --version` → its version, or null when it printed nothing recognisable. */
+export function parseMaestroVersion(r) {
+    if (!r.found || r.code !== 0)
+        return null;
+    const m = r.stdout.match(/\d+\.\d+(?:\.\d+)?/);
+    if (m)
+        return m[0];
+    // No version number: keep a short first line verbatim, and refuse a long one rather than cut it.
+    const first = r.stdout.trim().split("\n")[0] ?? "";
+    return first && first.length <= 40 ? first : null;
+}
+/** `adb devices -l` → attached devices (any state; `device` is the usable one). */
+export function parseAdbDevices(stdout) {
+    const out = [];
+    for (const line of stdout.split("\n")) {
+        const t = line.trim();
+        if (!t || t.startsWith("List of devices") || t.startsWith("*"))
+            continue;
+        const [id, state, ...rest] = t.split(/\s+/);
+        if (!id || !state)
+            continue;
+        const model = rest.find((p) => p.startsWith("model:"))?.slice("model:".length);
+        out.push({ id, kind: "android", name: model ? model.replace(/_/g, " ") : id, state });
+    }
+    return out;
+}
+/** `xcrun simctl list devices booted --json` → booted simulators. */
+export function parseSimctlBooted(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        return [];
+    }
+    const devices = parsed?.devices;
+    if (!devices || typeof devices !== "object")
+        return [];
+    const out = [];
+    for (const list of Object.values(devices)) {
+        if (!Array.isArray(list))
+            continue;
+        for (const d of list) {
+            if (typeof d?.udid !== "string" || d.state !== "Booted")
+                continue;
+            out.push({ id: d.udid, kind: "ios_simulator", name: typeof d.name === "string" ? d.name : d.udid, state: "Booted" });
+        }
+    }
+    return out;
+}
+/** Combine the parts into one result with its error codes. Pure. */
+export function summarizePreflight(input) {
+    const { screenRecording, accessibility } = input;
+    const states = [screenRecording, accessibility];
+    const permissionState = states.includes("unsupported")
+        ? "unsupported"
+        : states.includes("denied")
+            ? "denied"
+            : states.every((s) => s === "granted")
+                ? "granted"
+                : "unknown";
+    const errors = [];
+    const add = (code, message) => errors.push({ code, message });
+    if (permissionState === "unsupported")
+        add("NATIVE_UNSUPPORTED_OS", `Desktop control is not supported on ${input.os} yet (macOS and Windows only).`);
+    if (permissionState === "denied") {
+        const missing = [screenRecording === "denied" ? "Screen Recording" : null, accessibility === "denied" ? "Accessibility" : null].filter(Boolean).join(" and ");
+        add("NATIVE_PERMISSIONS_MISSING", `This machine has not granted ${missing}. Grant it to the app that runs \`pags up\` (e.g. Terminal) in System Settings → Privacy & Security, then restart \`pags up\`.`);
+    }
+    if (!input.maestroInstalled)
+        add("NATIVE_MAESTRO_NOT_INSTALLED", "Maestro is not installed on this machine. The runner never installs it; install it yourself (https://maestro.mobile.dev) if you want phone or emulator automation.");
+    const usable = input.devices.filter((d) => d.state === "device" || d.state === "Booted");
+    if (input.maestroInstalled && usable.length === 0) {
+        add("NATIVE_DEVICE_NOT_FOUND", input.devices.length ? `No usable device: ${input.devices.map((d) => `${d.name} (${d.state})`).join(", ")}. Authorise or boot one.` : "No Android device/emulator or booted iOS simulator is connected.");
+    }
+    return {
+        os: input.os,
+        osVersion: input.osVersion,
+        arch: input.arch,
+        desktop: { screenRecording, accessibility, permissionState },
+        maestro: { installed: input.maestroInstalled, version: input.maestroVersion, adbInstalled: input.adbInstalled, simctlAvailable: input.simctlAvailable, connectedDevices: input.devices },
+        errors,
+        checkedAt: input.checkedAt,
+    };
+}
+// ── The probe ───────────────────────────────────────────────────────────────
+// CGPreflightScreenCaptureAccess is not in JXA's bridge metadata, so it is bound explicitly —
+// without the bind the call is "not a function" and the state would read `unknown`.
+const JXA_SCREEN = 'ObjC.import("CoreGraphics"); ObjC.bindFunction("CGPreflightScreenCaptureAccess", ["bool", []]); $.CGPreflightScreenCaptureAccess()';
+const JXA_AX = 'ObjC.import("ApplicationServices"); $.AXIsProcessTrusted()';
+const PS_UIA = "Add-Type -AssemblyName UIAutomationClient; if ([System.Windows.Automation.AutomationElement]::RootElement) { 'true' } else { 'false' }";
+export async function runNativePreflight(deps = {}) {
+    const exec = deps.exec ?? execProbe;
+    const platform = deps.platform ?? osPlatform();
+    const safe = (p) => p.catch(() => ({ found: false, code: null, stdout: "", stderr: "" }));
+    let osVersion = null;
+    let screenRecording = "unsupported";
+    let accessibility = "unsupported";
+    if (platform === "darwin") {
+        const [ver, screen, ax] = await Promise.all([safe(exec("sw_vers", ["-productVersion"])), safe(exec("osascript", ["-l", "JavaScript", "-e", JXA_SCREEN])), safe(exec("osascript", ["-l", "JavaScript", "-e", JXA_AX]))]);
+        osVersion = ver.code === 0 ? ver.stdout.trim() || null : null;
+        screenRecording = parseBooleanProbe(screen);
+        accessibility = parseBooleanProbe(ax);
+    }
+    else if (platform === "win32") {
+        // Windows has no per-app permission for screen capture or UI Automation: one availability probe.
+        const uia = parseBooleanProbe(await safe(exec("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", PS_UIA], 15000)));
+        screenRecording = uia;
+        accessibility = uia;
+    }
+    const [maestro, adb, simctl] = await Promise.all([
+        safe(exec("maestro", ["--version"], 15000)),
+        safe(exec("adb", ["devices", "-l"])),
+        platform === "darwin" ? safe(exec("xcrun", ["simctl", "list", "devices", "booted", "--json"])) : Promise.resolve({ found: false, code: null, stdout: "", stderr: "" }),
+    ]);
+    const devices = [...(adb.found && adb.code === 0 ? parseAdbDevices(adb.stdout) : []), ...(simctl.found && simctl.code === 0 ? parseSimctlBooted(simctl.stdout) : [])];
+    return summarizePreflight({
+        os: platform,
+        osVersion,
+        arch: deps.arch ?? osArch(),
+        screenRecording,
+        accessibility,
+        maestroVersion: parseMaestroVersion(maestro),
+        maestroInstalled: maestro.found && maestro.code === 0,
+        adbInstalled: adb.found,
+        simctlAvailable: simctl.found && simctl.code === 0,
+        devices,
+        checkedAt: (deps.now ?? Date.now)(),
+    });
+}

package/dist/browser-runner/runner.js

@@ -39,6 +39,7 @@ const CAPABILITIES = [
     "human.approval",
     "human.takeover",
     "tmux.control",
+    "native.preflight",
 ];
 /** How many times a task may attempt an action before handing off to a human. */
 export const MAX_AUTONOMOUS_ATTEMPTS = 3;

package/dist/browser-runner/server.js

@@ -5,6 +5,7 @@ import { probeGitSshIdentity } from "./coding/repo.js";
 import { checkEngine } 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";
 import { routeLocalApplyReconciliation } from "./local-apply/reconciliation-routes.js";
 export function createRunnerServer(runner) {
     return createServer(async (req, res) => {
@@ -105,6 +106,11 @@ async function route(runner, req, res) {
     if ((req.method === "GET" || req.method === "POST") && path === "/capabilities") {
         return json(res, 200, runner.capabilities());
     }
+    // #1057 slice 1: a READ-ONLY probe of what native desktop / Maestro control could do on this
+    // machine. Runs fixed probe commands, installs nothing, prompts for nothing, never throws.
+    if ((req.method === "GET" || req.method === "POST") && path === "/native/preflight") {
+        return json(res, 200, await runNativePreflight());
+    }
     if (req.method === "GET" && path === "/sessions") {
         return json(res, 200, { sessions: runner.store.listSessions() });
     }

package/package.json

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