maqcli 0.6.2 → 0.6.3

package/dist/core/launcher.js

@@ -353,7 +353,7 @@ async function connectMobile(rl) {
 async function launchUi(authKey) {
     // Reuse the daemon; open its landing page. Import lazily to avoid a cycle.
     const { createDaemon } = await import("../server/daemon.js");
-    const daemon = createDaemon({ token: authKey, version: "0.6.2" });
+    const daemon = createDaemon({ token: authKey, version: "0.6.3" });
     try {
         const { host, port } = await daemon.listen();
         const url = `http://${host}:${port}/`;

package/dist/core/update.d.ts

@@ -24,6 +24,21 @@
  * instead of waiting on it. By the time npm actually touches the shim files,
  * the process that used to hold them has already terminated. This is the same
  * pattern self-updating CLIs (rustup, deno, bun) use on Windows.
+ *
+ * THE SEPARATE "CAN'T EVEN LAUNCH NPM" PROBLEM AND ITS FIX
+ * ------------------------------------------------------------
+ * `child_process.spawn(cmd, args, {shell:false})` — which execSafe always
+ * uses, deliberately, to avoid shell-injection — cannot execute `npm`
+ * directly on Windows AT ALL, regardless of which name you pass. The `npm` on
+ * PATH there is `npm.cmd`, a batch-file shim, and Windows can only run batch
+ * files through a command interpreter; spawning it as a bare child process
+ * throws ENOENT (name not found as-is) or EINVAL (found but not directly
+ * executable), never succeeds. The fix is `runNpm()` below: on Windows it
+ * routes through `cmd.exe /c "npm ..."` (still shell:false at the
+ * child_process level — cmd.exe is the fixed, trusted executable being
+ * spawned; the args passed to IT are our own literal strings, never
+ * unsanitized input, so this does not reopen the shell-injection risk
+ * execSafe exists to close).
  */
 import { spawn } from "node:child_process";
 export interface VersionInfo {
@@ -38,21 +53,23 @@ export declare function isNewer(current: string, latest: string): boolean;
 export declare function fetchLatestVersion(registryUrl?: string, timeoutMs?: number): Promise<string>;
 /** Compare the running version against the registry; never throws. */
 export declare function checkForUpdate(currentVersion: string): Promise<VersionInfo>;
-export interface UpdateOutcome {
-    ok: boolean;
-    message: string;
-    version?: VersionInfo;
-    /** Set when the update was launched detached; the caller should exit(0) promptly instead of doing more work. */
-    detachedPid?: number;
-    /** Path a --wait caller can poll to see the detached install's result. */
-    logPath?: string;
-}
+/**
+ * Run an npm subcommand safely and portably. See the module doc's second
+ * section for why this can't just be `execSafe("npm", args)` on Windows.
+ */
+export declare function runNpm(args: string[], opts?: {
+    timeoutMs?: number;
+}): Promise<{
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}>;
 /**
  * Build the OS-appropriate command to run `npm install -g maqcli@<version>`
  * fully detached from the current process (see module doc for why). On
- * Windows this wraps npm in a new cmd.exe so the child truly detaches from
- * the parent's console/job object; on POSIX, npm itself is spawned directly
- * with `detached: true`.
+ * Windows this wraps npm in a new cmd.exe (which is also how the shim gets
+ * resolved at all — see runNpm above); on POSIX, a `sh -c` one-liner gives us
+ * the same redirection-to-a-log-file behavior.
  */
 export declare function detachedInstallCommand(version: string, logPath: string, platform?: NodeJS.Platform): {
     cmd: string;
@@ -69,7 +86,7 @@ export interface UpdateOutcome {
     ok: boolean;
     message: string;
     version?: VersionInfo;
-    /** Set when the update was launched detached; the caller should exit(0) promptly instead of doing more work. */
+    /** Set when the update was launched detached (the default path). */
     detachedPid?: number;
     /** Path a caller can inspect afterward to see the detached install's own npm output. */
     logPath?: string;
@@ -86,8 +103,8 @@ export interface UpdateOutcome {
  * alive, still holding the lock, for the whole duration).
  *
  * `opts.wait: true` (used by tests, and by --wait for a CI/non-interactive
- * caller that can tolerate the lock risk) runs synchronously via `runner`
- * instead, so the outcome is available in the same process.
+ * caller that can tolerate the lock risk) runs synchronously instead, so the
+ * outcome is available in the same process.
  */
 export declare function performUpdate(currentVersion: string, opts?: {
     checkOnly?: boolean;

package/dist/core/update.js

@@ -24,6 +24,21 @@
  * instead of waiting on it. By the time npm actually touches the shim files,
  * the process that used to hold them has already terminated. This is the same
  * pattern self-updating CLIs (rustup, deno, bun) use on Windows.
+ *
+ * THE SEPARATE "CAN'T EVEN LAUNCH NPM" PROBLEM AND ITS FIX
+ * ------------------------------------------------------------
+ * `child_process.spawn(cmd, args, {shell:false})` — which execSafe always
+ * uses, deliberately, to avoid shell-injection — cannot execute `npm`
+ * directly on Windows AT ALL, regardless of which name you pass. The `npm` on
+ * PATH there is `npm.cmd`, a batch-file shim, and Windows can only run batch
+ * files through a command interpreter; spawning it as a bare child process
+ * throws ENOENT (name not found as-is) or EINVAL (found but not directly
+ * executable), never succeeds. The fix is `runNpm()` below: on Windows it
+ * routes through `cmd.exe /c "npm ..."` (still shell:false at the
+ * child_process level — cmd.exe is the fixed, trusted executable being
+ * spawned; the args passed to IT are our own literal strings, never
+ * unsanitized input, so this does not reopen the shell-injection risk
+ * execSafe exists to close).
  */
 import { spawn } from "node:child_process";
 import { tmpdir } from "node:os";
@@ -66,17 +81,30 @@ export async function checkForUpdate(currentVersion) {
         return { current: currentVersion, latest: null, upToDate: true, error: e.message };
     }
 }
+/**
+ * Run an npm subcommand safely and portably. See the module doc's second
+ * section for why this can't just be `execSafe("npm", args)` on Windows.
+ */
+export async function runNpm(args, opts = {}) {
+    if (process.platform === "win32") {
+        // Every element here is our own literal string (package name, flags) —
+        // never unsanitized user input — so building one cmd.exe command line is
+        // safe. Defensively quote anything with whitespace anyway.
+        const cmdLine = ["npm", ...args].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(" ");
+        return execSafe("cmd.exe", ["/c", cmdLine], opts);
+    }
+    return execSafe("npm", args, opts);
+}
 /**
  * Build the OS-appropriate command to run `npm install -g maqcli@<version>`
  * fully detached from the current process (see module doc for why). On
- * Windows this wraps npm in a new cmd.exe so the child truly detaches from
- * the parent's console/job object; on POSIX, npm itself is spawned directly
- * with `detached: true`.
+ * Windows this wraps npm in a new cmd.exe (which is also how the shim gets
+ * resolved at all — see runNpm above); on POSIX, a `sh -c` one-liner gives us
+ * the same redirection-to-a-log-file behavior.
  */
 export function detachedInstallCommand(version, logPath, platform = process.platform) {
     const pkg = `maqcli@${version}`;
     if (platform === "win32") {
-        // /c runs and closes; redirection captures npm's own output for later inspection.
         return { cmd: "cmd.exe", args: ["/c", `npm install -g ${pkg} > "${logPath}" 2>&1`] };
     }
     return { cmd: "sh", args: ["-c", `npm install -g ${pkg} > '${logPath}' 2>&1`] };
@@ -108,8 +136,8 @@ export function launchDetachedUpdate(version, logPath, spawner = spawn) {
  * alive, still holding the lock, for the whole duration).
  *
  * `opts.wait: true` (used by tests, and by --wait for a CI/non-interactive
- * caller that can tolerate the lock risk) runs synchronously via `runner`
- * instead, so the outcome is available in the same process.
+ * caller that can tolerate the lock risk) runs synchronously instead, so the
+ * outcome is available in the same process.
  */
 export async function performUpdate(currentVersion, opts = {}) {
     const version = await checkForUpdate(currentVersion);
@@ -134,11 +162,12 @@ export async function performUpdate(currentVersion, opts = {}) {
             logPath,
         };
     }
-    // --wait / test path: run synchronously in this process. On Windows this
-    // can hit the file-lock failure mode described above if `maq` itself is
-    // the thing being replaced; it's kept for CI and for tests with a stubbed
-    // runner, not as the default interactive experience.
-    const runner = opts.runner ?? (async (cmd, args) => execSafe(cmd, args, { timeoutMs: 120000 }));
+    // --wait / test path: run synchronously in this process via runNpm (or an
+    // injected runner). On Windows this can still hit the file-lock failure
+    // mode described above if `maq` itself is the thing being replaced; it's
+    // kept for CI and for tests with a stubbed runner, not as the default
+    // interactive experience.
+    const runner = opts.runner ?? ((_cmd, args) => runNpm(args, { timeoutMs: 120000 }));
     const outcome = await runner("npm", ["install", "-g", `maqcli@${latest}`]);
     if (outcome.code !== 0) {
         return {
@@ -171,7 +200,7 @@ export async function readUpdateLog(logPath) {
  * "what did we ask for") — this is what confirms a detached update landed,
  * independent of which process/terminal you're asking from.
  */
-export async function installedGlobalVersion(runner = (cmd, args) => execSafe(cmd, args, { timeoutMs: 15000 })) {
+export async function installedGlobalVersion(runner = (_cmd, args) => runNpm(args, { timeoutMs: 15000 })) {
     const outcome = await runner("npm", ["list", "-g", "maqcli", "--depth=0", "--json"]);
     if (outcome.code !== 0)
         return null;

package/dist/index.js

@@ -46,7 +46,7 @@ import { runOrchestration } from "./core/orchestrator.js";
 import { performUpdate, installedGlobalVersion } from "./core/update.js";
 import { checkProtectedPath, scanForInjection, securityLog, securityRules, } from "./core/security.js";
 import { readFileSync, statSync } from "node:fs";
-const VERSION = "0.6.2";
+const VERSION = "0.6.3";
 async function main(argv) {
     const [command, ...rest] = argv;
     switch (command) {

package/dist/server/daemon.js

@@ -52,7 +52,7 @@ export function createDaemon(opts = {}) {
     const host = opts.host ?? process.env.MAQ_HOST ?? "127.0.0.1";
     const port = opts.port ?? Number(process.env.MAQ_PORT ?? 7717);
     const token = opts.token ?? process.env.MAQ_TOKEN ?? generateToken();
-    const version = opts.version ?? "0.6.2";
+    const version = opts.version ?? "0.6.3";
     const corsOrigin = opts.corsOrigin ?? process.env.MAQ_CORS_ORIGIN;
     const registry = opts.registry ?? new SessionRegistry();
     const interactive = new InteractiveRegistry();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maqcli",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "MAQ master orchestrator — a token-efficient, agent-agnostic supervisor CLI that sits on top of any worker CLI (AI or not) via a Scout -> Plan -> Execute -> Verify pipeline.",
   "type": "module",
   "bin": {