palmier 0.2.5 → 0.2.7

package/dist/platform/windows.js

@@ -1,22 +1,18 @@
 import * as fs from "fs";
 import * as path from "path";
-import { execSync, exec, spawn as nodeSpawn } from "child_process";
-import { promisify } from "util";
-import { getTaskDir } from "../task.js";
-import { loadConfig } from "../config.js";
-const execAsync = promisify(exec);
-const TASK_PREFIX = "PalmierTask-";
+import { execFileSync } from "child_process";
+import { spawn as nodeSpawn } from "child_process";
+import { CONFIG_DIR } from "../config.js";
+const TASK_PREFIX = "\\Palmier\\PalmierTask-";
 const DAEMON_TASK_NAME = "PalmierDaemon";
-const SHELL = "cmd.exe";
+const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 /**
- * Resolve the full command to invoke palmier, accounting for the fact that
- * on Windows, globally-installed npm packages are .cmd shims.
+ * Build the /tr value for schtasks: a single string with quoted paths
+ * so Task Scheduler can invoke node with the palmier script + subcommand.
  */
-function getPalmierCommand() {
-    // process.argv[1] is the script path; wrap with node so it works as
-    // a Task Scheduler command without relying on file associations.
+function schtasksTr(...subcommand) {
     const script = process.argv[1] || "palmier";
-    return `"${process.execPath}" "${script}"`;
+    return `"${process.execPath}" "${script}" ${subcommand.join(" ")}`;
 }
 /**
  * Convert one of the 4 supported cron patterns to schtasks flags.
@@ -65,56 +61,81 @@ function schtasksTaskName(taskId) {
 }
 export class WindowsPlatform {
     installDaemon(config) {
-        const cmd = getPalmierCommand();
-        // Try ONSTART first (requires elevation), fall back to ONLOGON
-        const baseArgs = [
-            "/create", "/tn", DAEMON_TASK_NAME,
-            "/tr", `${cmd} serve`,
-            "/rl", "HIGHEST",
-            "/f", // force overwrite if exists
-        ];
+        const script = process.argv[1] || "palmier";
+        const regValue = `"${process.execPath}" "${script}" serve`;
         try {
-            execSync(`schtasks ${[...baseArgs, "/sc", "ONSTART"].join(" ")}`, { encoding: "utf-8", shell: SHELL });
-            console.log(`Task Scheduler: "${DAEMON_TASK_NAME}" installed (runs at startup).`);
+            execFileSync("reg", [
+                "add", "HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run",
+                "/v", DAEMON_TASK_NAME, "/t", "REG_SZ", "/d", regValue, "/f",
+            ], { encoding: "utf-8", stdio: "pipe" });
+            console.log(`Registry Run key "${DAEMON_TASK_NAME}" installed (runs at logon).`);
         }
-        catch {
-            // ONSTART requires admin — fall back to ONLOGON which does not
+        catch (err) {
+            console.error(`Warning: failed to install registry run entry: ${err}`);
+            console.error("You may need to start palmier serve manually.");
+        }
+        // Start the daemon now
+        this.spawnDaemon(script);
+        console.log("\nHost initialization complete!");
+    }
+    async restartDaemon() {
+        // Kill the old daemon if we have its PID
+        if (fs.existsSync(DAEMON_PID_FILE)) {
+            const oldPid = fs.readFileSync(DAEMON_PID_FILE, "utf-8").trim();
             try {
-                execSync(`schtasks ${[...baseArgs, "/sc", "ONLOGON"].join(" ")}`, { encoding: "utf-8", shell: SHELL });
-                console.log(`Task Scheduler: "${DAEMON_TASK_NAME}" installed (runs at logon).`);
-                console.log("  Tip: run as Administrator to use ONSTART instead.");
+                execFileSync("taskkill", ["/pid", oldPid, "/t", "/f"], { windowsHide: true });
             }
-            catch (err) {
-                console.error(`Warning: failed to create scheduled task: ${err}`);
-                console.error("You may need to start palmier serve manually.");
+            catch {
+                // Process may have already exited
             }
         }
-        // Start the daemon now
-        try {
-            execSync(`schtasks /run /tn ${DAEMON_TASK_NAME}`, { encoding: "utf-8", shell: SHELL });
-            console.log("Palmier daemon started.");
-        }
-        catch {
-            console.log("Note: could not start daemon immediately. It will start at next login/boot.");
+        const script = process.argv[1] || "palmier";
+        this.spawnDaemon(script);
+    }
+    spawnDaemon(script) {
+        const child = nodeSpawn(process.execPath, [script, "serve"], {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        if (child.pid) {
+            fs.writeFileSync(DAEMON_PID_FILE, String(child.pid), "utf-8");
         }
-        console.log("\nHost initialization complete!");
+        child.unref();
+        console.log("Palmier daemon started.");
     }
     installTaskTimer(config, task) {
         const taskId = task.frontmatter.id;
         const tn = schtasksTaskName(taskId);
-        const cmd = getPalmierCommand();
+        const tr = schtasksTr("run", taskId);
+        // Always create the scheduled task with a dummy trigger first.
+        // This ensures startTask (/run) works even when no triggers are configured.
+        try {
+            execFileSync("schtasks", [
+                "/create", "/tn", tn,
+                "/tr", tr,
+                "/sc", "ONCE", "/sd", "01/01/2000", "/st", "00:00",
+                "/f",
+            ], { encoding: "utf-8", windowsHide: true });
+        }
+        catch (err) {
+            const e = err;
+            console.error(`Failed to create scheduled task ${tn}: ${e.stderr || err}`);
+        }
+        // Overlay with real schedule triggers if enabled
+        if (!task.frontmatter.triggers_enabled)
+            return;
         const triggers = task.frontmatter.triggers || [];
         for (const trigger of triggers) {
             if (trigger.type === "cron") {
                 const schedArgs = cronToSchtasksArgs(trigger.value);
-                const args = [
-                    "/create", "/tn", tn,
-                    "/tr", `${cmd} run ${taskId}`,
-                    ...schedArgs,
-                    "/f",
-                ];
                 try {
-                    execSync(`schtasks ${args.join(" ")}`, { encoding: "utf-8", shell: SHELL });
+                    execFileSync("schtasks", [
+                        "/create", "/tn", tn,
+                        "/tr", tr,
+                        ...schedArgs,
+                        "/f",
+                    ], { encoding: "utf-8", windowsHide: true });
                 }
                 catch (err) {
                     const e = err;
@@ -132,14 +153,13 @@ export class WindowsPlatform {
                 const [year, month, day] = datePart.split("-");
                 const sd = `${month}/${day}/${year}`;
                 const st = timePart.slice(0, 5);
-                const args = [
-                    "/create", "/tn", tn,
-                    "/tr", `${cmd} run ${taskId}`,
-                    "/sc", "ONCE", "/sd", sd, "/st", st,
-                    "/f",
-                ];
                 try {
-                    execSync(`schtasks ${args.join(" ")}`, { encoding: "utf-8", shell: SHELL });
+                    execFileSync("schtasks", [
+                        "/create", "/tn", tn,
+                        "/tr", tr,
+                        "/sc", "ONCE", "/sd", sd, "/st", st,
+                        "/f",
+                    ], { encoding: "utf-8", windowsHide: true });
                 }
                 catch (err) {
                     const e = err;
@@ -151,46 +171,43 @@ export class WindowsPlatform {
     removeTaskTimer(taskId) {
         const tn = schtasksTaskName(taskId);
         try {
-            execSync(`schtasks /delete /tn ${tn} /f`, { encoding: "utf-8", shell: SHELL });
+            execFileSync("schtasks", ["/delete", "/tn", tn, "/f"], { encoding: "utf-8", windowsHide: true });
         }
         catch {
             // Task might not exist — that's fine
         }
     }
     async startTask(taskId) {
-        const config = loadConfig();
-        const taskDir = getTaskDir(config.projectRoot, taskId);
-        const script = process.argv[1] || "palmier";
-        // Spawn a detached child process and record its PID for later abort
-        const child = nodeSpawn(process.execPath, [script, "run", taskId], {
-            detached: true,
-            stdio: "ignore",
-            cwd: config.projectRoot,
-        });
-        if (child.pid) {
-            fs.mkdirSync(taskDir, { recursive: true });
-            fs.writeFileSync(path.join(taskDir, "pid"), String(child.pid), "utf-8");
+        const tn = schtasksTaskName(taskId);
+        try {
+            execFileSync("schtasks", ["/run", "/tn", tn], { encoding: "utf-8", windowsHide: true });
+        }
+        catch (err) {
+            const e = err;
+            throw new Error(`Failed to start task via schtasks: ${e.stderr || e.message}`);
         }
-        child.unref();
     }
     async stopTask(taskId) {
-        const config = loadConfig();
-        const taskDir = getTaskDir(config.projectRoot, taskId);
-        const pidPath = path.join(taskDir, "pid");
-        if (!fs.existsSync(pidPath)) {
-            throw new Error(`No PID file found for task ${taskId}`);
+        const tn = schtasksTaskName(taskId);
+        try {
+            execFileSync("schtasks", ["/end", "/tn", tn], { encoding: "utf-8", windowsHide: true });
         }
-        const pid = fs.readFileSync(pidPath, "utf-8").trim();
+        catch (err) {
+            const e = err;
+            throw new Error(`Failed to stop task via schtasks: ${e.stderr || e.message}`);
+        }
+    }
+    isTaskRunning(taskId) {
+        const tn = schtasksTaskName(taskId);
         try {
-            // /t kills the entire process tree, /f forces termination
-            await execAsync(`taskkill /pid ${pid} /t /f`);
+            const out = execFileSync("schtasks", ["/query", "/tn", tn, "/fo", "CSV", "/nh"], {
+                encoding: "utf-8",
+                windowsHide: true,
+            });
+            return out.includes('"Running"');
         }
-        finally {
-            // Clean up PID file regardless of whether taskkill succeeded
-            try {
-                fs.unlinkSync(pidPath);
-            }
-            catch { /* ignore */ }
+        catch {
+            return false;
         }
     }
     getGuiEnv() {

package/dist/rpc-handler.d.ts

@@ -1,6 +1,7 @@
+import { type NatsConnection } from "nats";
 import type { HostConfig, RpcMessage } from "./types.js";
 /**
  * Create a transport-agnostic RPC handler bound to the given config.
  */
-export declare function createRpcHandler(config: HostConfig): (request: RpcMessage) => Promise<unknown>;
+export declare function createRpcHandler(config: HostConfig, nc?: NatsConnection): (request: RpcMessage) => Promise<unknown>;
 //# sourceMappingURL=rpc-handler.d.ts.map

package/dist/rpc-handler.js

@@ -1,5 +1,4 @@
 import { randomUUID } from "crypto";
-import * as os from "os";
 import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
@@ -9,19 +8,9 @@ import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import { getAgent } from "./agents/agent.js";
 import { validateSession } from "./session-store.js";
+import { publishHostEvent } from "./events.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PLAN_GENERATION_PROMPT = fs.readFileSync(path.join(__dirname, "commands", "plan-generation.md"), "utf-8");
-function detectLanIp() {
-    const interfaces = os.networkInterfaces();
-    for (const name of Object.keys(interfaces)) {
-        for (const iface of interfaces[name] ?? []) {
-            if (iface.family === "IPv4" && !iface.internal) {
-                return iface.address;
-            }
-        }
-    }
-    return "127.0.0.1";
-}
 /**
  * Parse RESULT frontmatter into a metadata object.
  */
@@ -71,11 +60,12 @@ function parseResultFrontmatter(raw) {
 async function generatePlan(projectRoot, userPrompt, agentName) {
     const fullPrompt = PLAN_GENERATION_PROMPT + userPrompt;
     const planAgent = getAgent(agentName);
-    const { command, args } = planAgent.getPlanGenerationCommandLine(fullPrompt);
+    const { command, args, stdin } = planAgent.getPlanGenerationCommandLine(fullPrompt);
     console.log(`[generatePlan] Running: ${command} ${args.join(" ")}`);
     const { output } = await spawnCommand(command, args, {
         cwd: projectRoot,
         timeout: 120_000,
+        stdin,
     });
     let name = "";
     const trimmed = output.trim();
@@ -96,7 +86,7 @@ async function generatePlan(projectRoot, userPrompt, agentName) {
 /**
  * Create a transport-agnostic RPC handler bound to the given config.
  */
-export function createRpcHandler(config) {
+export function createRpcHandler(config, nc) {
     function flattenTask(task) {
         const taskDir = getTaskDir(config.projectRoot, task.frontmatter.id);
         return {
@@ -121,10 +111,10 @@ export function createRpcHandler(config) {
             }
             case "task.create": {
                 const params = request.params;
-                // Short descriptions skip plan generation and use the description as-is
+                // Only generate a plan for longer prompts that benefit from it
                 let name = "";
                 let body = "";
-                if (params.user_prompt.length < 50) {
+                if (params.user_prompt.length <= 50) {
                     name = params.user_prompt;
                 }
                 else {
@@ -149,15 +139,13 @@ export function createRpcHandler(config) {
                         triggers: params.triggers ?? [],
                         triggers_enabled: params.triggers_enabled ?? true,
                         requires_confirmation: params.requires_confirmation ?? true,
+                        ...(params.command ? { command: params.command } : {}),
                     },
                     body,
                 };
                 writeTaskFile(taskDir, task);
                 appendTaskList(config.projectRoot, id);
-                const platform = getPlatform();
-                if (task.frontmatter.triggers_enabled) {
-                    platform.installTaskTimer(config, task);
-                }
+                getPlatform().installTaskTimer(config, task);
                 return flattenTask(task);
             }
             case "task.update": {
@@ -179,31 +167,34 @@ export function createRpcHandler(config) {
                     existing.frontmatter.triggers_enabled = params.triggers_enabled;
                 if (params.requires_confirmation !== undefined)
                     existing.frontmatter.requires_confirmation = params.requires_confirmation;
-                // Regenerate plan if needed
-                if (needsRegeneration) {
-                    if (existing.frontmatter.user_prompt.length < 50) {
-                        existing.frontmatter.name = existing.frontmatter.user_prompt;
-                        existing.body = "";
+                if (params.command !== undefined) {
+                    if (params.command) {
+                        existing.frontmatter.command = params.command;
                     }
                     else {
-                        try {
-                            const plan = await generatePlan(config.projectRoot, existing.frontmatter.user_prompt, existing.frontmatter.agent);
-                            existing.frontmatter.name = plan.name;
-                            existing.body = plan.body;
-                        }
-                        catch (err) {
-                            const error = err;
-                            return { error: "plan generation failed", stdout: error.stdout, stderr: error.stderr };
-                        }
+                        delete existing.frontmatter.command;
                     }
                 }
-                writeTaskFile(taskDir, existing);
-                // Reinstall or remove timers based on triggers_enabled
-                const platform = getPlatform();
-                platform.removeTaskTimer(params.id);
-                if (existing.frontmatter.triggers_enabled) {
-                    platform.installTaskTimer(config, existing);
+                // Regenerate plan if needed (only for longer prompts)
+                if (existing.frontmatter.user_prompt.length <= 50) {
+                    existing.frontmatter.name = existing.frontmatter.user_prompt;
+                    existing.body = "";
                 }
+                else if (needsRegeneration) {
+                    try {
+                        const plan = await generatePlan(config.projectRoot, existing.frontmatter.user_prompt, existing.frontmatter.agent);
+                        existing.frontmatter.name = plan.name;
+                        existing.body = plan.body;
+                    }
+                    catch (err) {
+                        const error = err;
+                        return { error: "plan generation failed", stdout: error.stdout, stderr: error.stderr };
+                    }
+                }
+                writeTaskFile(taskDir, existing);
+                // Update timers — installTaskTimer overwrites in-place (schtasks /f,
+                // systemd unit rewrite) without killing a running task process.
+                getPlatform().installTaskTimer(config, existing);
                 return flattenTask(existing);
             }
             case "task.delete": {
@@ -226,15 +217,25 @@ export function createRpcHandler(config) {
             }
             case "task.abort": {
                 const params = request.params;
+                // Write abort status BEFORE killing so the dying process's signal
+                // handler can detect this was RPC-initiated and skip publishing.
+                const abortTaskDir = getTaskDir(config.projectRoot, params.id);
+                writeTaskStatus(abortTaskDir, {
+                    running_state: "aborted",
+                    time_stamp: Date.now(),
+                });
                 try {
                     await getPlatform().stopTask(params.id);
-                    return { ok: true, task_id: params.id };
                 }
                 catch (err) {
                     const e = err;
                     console.error(`task.abort failed for ${params.id}: ${e.stderr || e.message}`);
                     return { error: `Failed to abort task: ${e.stderr || e.message}` };
                 }
+                // Notify connected clients (NATS + HTTP SSE if LAN server is running)
+                const abortPayload = { event_type: "running-state", running_state: "aborted" };
+                await publishHostEvent(nc, config.hostId, params.id, abortPayload);
+                return { ok: true, task_id: params.id };
             }
             case "task.status": {
                 const params = request.params;
@@ -291,7 +292,7 @@ export function createRpcHandler(config) {
                 const params = request.params;
                 const taskDir = getTaskDir(config.projectRoot, params.id);
                 const currentStatus = readTaskStatus(taskDir);
-                if (!currentStatus?.pending_confirmation && !currentStatus?.pending_permission?.length) {
+                if (!currentStatus?.pending_confirmation && !currentStatus?.pending_permission?.length && !currentStatus?.pending_input?.length) {
                     return { ok: false, error: "not pending" };
                 }
                 writeTaskStatus(taskDir, { ...currentStatus, user_input: params.value });
@@ -331,16 +332,6 @@ export function createRpcHandler(config) {
                 }
                 return { ok: true, task_id: params.task_id, result_file: params.result_file };
             }
-            case "host.directInfo": {
-                if (config.mode === "lan" || config.mode === "auto") {
-                    const ip = detectLanIp();
-                    return {
-                        directUrl: `http://${ip}:${config.directPort ?? 7400}`,
-                        directToken: config.directToken,
-                    };
-                }
-                return { directUrl: null, directToken: null };
-            }
             default:
                 return { error: `Unknown method: ${request.method}` };
         }

package/dist/spawn-command.d.ts

@@ -1,25 +1,48 @@
+import type { ChildProcess } from "child_process";
+export interface SpawnStreamingOptions {
+    cwd: string;
+    env?: Record<string, string>;
+}
+/**
+ * Spawn a command with shell interpretation, returning the ChildProcess
+ * with stdout piped for line-by-line reading.
+ *
+ * Unlike spawnCommand(), this does NOT collect output into a buffer —
+ * the caller reads from child.stdout directly (e.g. via readline).
+ *
+ * shell: true is required so users can write piped commands like
+ * "tail -f log | grep ERROR".
+ *
+ * stdin is "pipe" (kept open, never written to) rather than "ignore"
+ * (/dev/null). Some long-running commands exit when stdin is closed/EOF.
+ * This differs from spawnCommand() which uses "ignore" because agent
+ * CLIs like `claude -p` hang on an open stdin pipe.
+ */
+export declare function spawnStreamingCommand(command: string, opts: SpawnStreamingOptions): ChildProcess;
 export interface SpawnCommandOptions {
     cwd: string;
     env?: Record<string, string>;
     timeout?: number;
     /** Echo stdout to process.stdout (useful for journald logging). */
     echoStdout?: boolean;
-    /** Forward SIGINT/SIGTERM to the child and resolve on stop. */
-    forwardSignals?: boolean;
     /** Resolve with output even on non-zero exit (instead of rejecting). */
     resolveOnFailure?: boolean;
+    /** If provided, write this string to the process's stdin and then close the pipe. */
+    stdin?: string;
 }
 /**
  * Spawn a command with additional arguments.
  *
- * On Windows, `shell: true` is used so that npm-installed .cmd shims
- * (e.g. claude.cmd, gemini.cmd) are resolved correctly.
+ * Uses cross-spawn to correctly resolve .cmd shims and escape arguments
+ * on Windows without shell: true (which mishandles special characters).
  *
  * On other platforms the command is executed directly (no shell), so no
  * escaping is needed.
  *
- * stdin is set to "ignore" (equivalent to < /dev/null) because tools like
- * `claude -p` hang indefinitely on an open stdin pipe.
+ * stdin is set to "ignore" by default (equivalent to < /dev/null) because
+ * tools like `claude -p` hang indefinitely on an open stdin pipe.
+ * When opts.stdin is provided, stdin is set to "pipe" and the string is
+ * written to the process before closing the pipe.
  */
 export interface SpawnCommandResult {
     output: string;

package/dist/spawn-command.js

@@ -1,13 +1,45 @@
-import { spawn } from "child_process";
+import crossSpawn from "cross-spawn";
+/**
+ * Spawn a command with shell interpretation, returning the ChildProcess
+ * with stdout piped for line-by-line reading.
+ *
+ * Unlike spawnCommand(), this does NOT collect output into a buffer —
+ * the caller reads from child.stdout directly (e.g. via readline).
+ *
+ * shell: true is required so users can write piped commands like
+ * "tail -f log | grep ERROR".
+ *
+ * stdin is "pipe" (kept open, never written to) rather than "ignore"
+ * (/dev/null). Some long-running commands exit when stdin is closed/EOF.
+ * This differs from spawnCommand() which uses "ignore" because agent
+ * CLIs like `claude -p` hang on an open stdin pipe.
+ */
+export function spawnStreamingCommand(command, opts) {
+    return crossSpawn(command, [], {
+        cwd: opts.cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true,
+        env: opts.env ? { ...process.env, ...opts.env } : undefined,
+        windowsHide: true,
+    });
+}
 export function spawnCommand(command, args, opts) {
     return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
+        // Collapse newlines to spaces — cmd.exe can't handle literal newlines
+        // in arguments, and CLI prompts don't need them.
+        const finalArgs = process.platform === "win32"
+            ? args.map((a) => a.replace(/[\r\n]+/g, " "))
+            : args;
+        // console.log(`[spawn] ${command} ${finalArgs.join(" ")}`);
+        const child = crossSpawn(command, finalArgs, {
             cwd: opts.cwd,
-            stdio: ["ignore", "pipe", "pipe"],
+            stdio: [opts.stdin != null ? "pipe" : "ignore", "pipe", "pipe"],
             env: opts.env ? { ...process.env, ...opts.env } : undefined,
-            // On Windows, spawn through shell so .cmd shims resolve correctly
-            shell: process.platform === "win32",
+            windowsHide: true,
         });
+        if (opts.stdin != null) {
+            child.stdin.end(opts.stdin);
+        }
         const chunks = [];
         child.stdout.on("data", (d) => {
             chunks.push(d);
@@ -15,15 +47,6 @@ export function spawnCommand(command, args, opts) {
                 process.stdout.write(d);
         });
         child.stderr.on("data", (d) => process.stderr.write(d));
-        let stopping = false;
-        if (opts.forwardSignals) {
-            const killChild = () => {
-                stopping = true;
-                child.kill("SIGTERM");
-            };
-            process.on("SIGINT", killChild);
-            process.on("SIGTERM", killChild);
-        }
         let timer;
         if (opts.timeout) {
             timer = setTimeout(() => {
@@ -35,7 +58,7 @@ export function spawnCommand(command, args, opts) {
             if (timer)
                 clearTimeout(timer);
             const output = Buffer.concat(chunks).toString("utf-8");
-            if (code === 0 || stopping || opts.resolveOnFailure)
+            if (code === 0 || opts.resolveOnFailure)
                 resolve({ output, exitCode: code });
             else
                 reject(new Error(`process exited with code ${code}`));

package/dist/transports/http-transport.d.ts

@@ -3,5 +3,5 @@ export declare function detectLanIp(): string;
 /**
  * Start the HTTP transport: Express-like server with RPC, SSE, and health endpoints.
  */
-export declare function startHttpTransport(config: HostConfig, handleRpc: (req: RpcMessage) => Promise<unknown>): Promise<void>;
+export declare function startHttpTransport(config: HostConfig, handleRpc: (req: RpcMessage) => Promise<unknown>, port: number, pairingCode?: string, onReady?: () => void): Promise<void>;
 //# sourceMappingURL=http-transport.d.ts.map