palmier 1.1.5 → 1.1.7

package/dist/rpc-handler.js

@@ -4,7 +4,7 @@ import * as path from "path";
 import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, isTaskInList, appendHistory, createRunDir, appendRunMessage, getRunDir, writeFollowupStatus, readFollowupStatus, deleteFollowupStatus, isRunStarred, setRunStarred } from "./task.js";
 import { resolvePending, getPending, listPending } from "./pending-requests.js";
 import { getPlatform } from "./platform/index.js";
-import { spawnCommand } from "./spawn-command.js";
+import { onChildDone, resolveCommand, spawnCommand } from "./spawn-command.js";
 import crossSpawn from "cross-spawn";
 import { getAgent, getPromptCommandLine, getNpmInstalledVersion } from "./agents/agent.js";
 import { validateClient, revokeClient } from "./client-store.js";
@@ -404,7 +404,8 @@ export function createRpcHandler(config, nc) {
                     for (const f of followupFiles)
                         fs.writeFileSync(path.join(followupRunDir, f.path), f.content, "utf-8");
                 }
-                const child = crossSpawn(cmd, cmdArgs, {
+                const resolved = resolveCommand(cmd, cmdArgs);
+                const child = crossSpawn(resolved.command, resolved.args, {
                     cwd: followupRunDir,
                     stdio: [stdin != null ? "pipe" : "ignore", "pipe", "pipe"],
                     env: { ...process.env, ...followupAgentEnv },
@@ -418,7 +419,7 @@ export function createRpcHandler(config, nc) {
                 const chunks = [];
                 child.stdout?.on("data", (d) => chunks.push(d));
                 child.stderr?.on("data", (d) => process.stderr.write(d));
-                child.on("close", async (code) => {
+                onChildDone(child, async (code) => {
                     activeFollowups.delete(followupKey);
                     deleteFollowupStatus(followupRunDir);
                     // stop_followup already wrote the stopped status.

package/dist/spawn-command.d.ts

@@ -1,4 +1,19 @@
 import { type ChildProcess } from "child_process";
+/**
+ * cross-spawn runs Windows .cmd shims through cmd.exe, which caps the command
+ * line at 8191 chars and can't carry newlines. For npm-installed CLIs, run the
+ * shim's node script directly so long multi-line prompts survive intact.
+ */
+export declare function resolveCommand(command: string, args: string[]): {
+    command: string;
+    args: string[];
+};
+/**
+ * Like the "close" event, but doesn't wait for grandchildren: a background process
+ * the child started (e.g. a browser daemon) can inherit its stdio pipes on Windows
+ * and hold them open long after the child itself exits.
+ */
+export declare function onChildDone(child: ChildProcess, callback: (code: number | null) => void): void;
 export interface SpawnStreamingOptions {
     cwd: string;
     env?: Record<string, string>;

package/dist/spawn-command.js

@@ -1,5 +1,44 @@
 import crossSpawn from "cross-spawn";
 import { execFileSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+const NPM_NODE_SHIM_TARGET = /"%_prog%"\s+"%dp0%\\([^"]+)"\s+%\*\s*$/;
+/**
+ * cross-spawn runs Windows .cmd shims through cmd.exe, which caps the command
+ * line at 8191 chars and can't carry newlines. For npm-installed CLIs, run the
+ * shim's node script directly so long multi-line prompts survive intact.
+ */
+export function resolveCommand(command, args) {
+    if (process.platform !== "win32")
+        return { command, args };
+    const shim = findNpmNodeShim(command);
+    if (shim)
+        return { command: shim.node, args: [shim.script, ...args] };
+    return { command, args: args.map((a) => a.replace(/[\r\n]+/g, " ")) };
+}
+function findNpmNodeShim(command) {
+    if (path.basename(command) !== command || path.extname(command))
+        return null;
+    const exts = (process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+    for (const dir of (process.env.PATH ?? "").split(path.delimiter).filter(Boolean)) {
+        for (const ext of exts) {
+            const candidate = path.join(dir, command + ext);
+            if (!fs.existsSync(candidate))
+                continue;
+            if (ext.toLowerCase() !== ".cmd")
+                return null;
+            const match = fs.readFileSync(candidate, "utf-8").match(NPM_NODE_SHIM_TARGET);
+            if (!match)
+                return null;
+            const localNode = path.join(dir, "node.exe");
+            return {
+                node: fs.existsSync(localNode) ? localNode : process.execPath,
+                script: path.join(dir, match[1]),
+            };
+        }
+    }
+    return null;
+}
 /** Kill a child process and its entire tree on Windows; plain kill elsewhere. */
 function treeKill(child) {
     if (process.platform === "win32" && child.pid) {
@@ -11,6 +50,32 @@ function treeKill(child) {
     }
     child.kill();
 }
+const STDIO_DRAIN_GRACE_MS = 1000;
+/**
+ * Like the "close" event, but doesn't wait for grandchildren: a background process
+ * the child started (e.g. a browser daemon) can inherit its stdio pipes on Windows
+ * and hold them open long after the child itself exits.
+ */
+export function onChildDone(child, callback) {
+    let done = false;
+    let grace;
+    const finish = (code) => {
+        if (done)
+            return;
+        done = true;
+        if (grace)
+            clearTimeout(grace);
+        callback(code);
+    };
+    child.on("exit", (code) => {
+        grace = setTimeout(() => {
+            child.stdout?.destroy();
+            child.stderr?.destroy();
+            finish(code);
+        }, STDIO_DRAIN_GRACE_MS);
+    });
+    child.on("close", finish);
+}
 /**
  * Spawn with shell interpretation for piped commands like "tail -f log | grep".
  * Returns the ChildProcess with stdout piped so the caller can read it directly
@@ -30,14 +95,11 @@ export function spawnStreamingCommand(command, opts) {
 }
 export function spawnCommand(command, args, opts) {
     return new Promise((resolve, reject) => {
-        // cmd.exe can't handle literal newlines in arguments.
-        const finalArgs = process.platform === "win32"
-            ? args.map((a) => a.replace(/[\r\n]+/g, " "))
-            : args;
+        const resolved = resolveCommand(command, args);
         const truncate = (s, max = 100) => s.length > max ? s.slice(0, max) + "..." : s;
-        const displayArgs = finalArgs.map((arg) => truncate(arg));
-        console.log(`[spawn] ${command} ${displayArgs.join(" ")}`);
-        const child = crossSpawn(command, finalArgs, {
+        const displayArgs = resolved.args.map((arg) => truncate(arg));
+        console.log(`[spawn] ${resolved.command} ${displayArgs.join(" ")}`);
+        const child = crossSpawn(resolved.command, resolved.args, {
             cwd: opts.cwd,
             stdio: [opts.stdin != null ? "pipe" : "ignore", "pipe", "pipe"],
             env: opts.env ? { ...process.env, ...opts.env } : undefined,
@@ -68,7 +130,7 @@ export function spawnCommand(command, args, opts) {
                 reject(new Error("command timed out"));
             }, opts.timeout);
         }
-        child.on("close", (code) => {
+        onChildDone(child, (code) => {
             if (timer)
                 clearTimeout(timer);
             const output = Buffer.concat(chunks).toString("utf-8");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "palmier",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
   "license": "Apache-2.0",
   "author": "Hongxu Cai",