palmier 0.2.5 → 0.2.6

package/src/rpc-handler.ts

@@ -4,11 +4,13 @@ import * as fs from "fs";
 import * as path from "path";
 import { fileURLToPath } from "url";
 import { parse as parseYaml } from "yaml";
+import { type NatsConnection } from "nats";
 import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, getTaskCreatedAt, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList } from "./task.js";
 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";
 import type { HostConfig, ParsedTask, RpcMessage } from "./types.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -82,12 +84,13 @@ async function generatePlan(
 ): Promise<{ name: string; body: string }> {
   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 = "";
@@ -109,7 +112,7 @@ async function generatePlan(
 /**
  * Create a transport-agnostic RPC handler bound to the given config.
  */
-export function createRpcHandler(config: HostConfig) {
+export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
   function flattenTask(task: ParsedTask) {
     const taskDir = getTaskDir(config.projectRoot, task.frontmatter.id);
     return {
@@ -142,12 +145,13 @@ export function createRpcHandler(config: HostConfig) {
           triggers?: Array<{ type: "cron" | "once"; value: string }>;
           triggers_enabled?: boolean;
           requires_confirmation?: boolean;
+          command?: string;
         };
 
-        // 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 {
           try {
@@ -171,16 +175,14 @@ export function createRpcHandler(config: HostConfig) {
             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);
       }
@@ -193,6 +195,7 @@ export function createRpcHandler(config: HostConfig) {
           triggers?: Array<{ type: "cron" | "once"; value: string }>;
           triggers_enabled?: boolean;
           requires_confirmation?: boolean;
+          command?: string;
         };
 
         const taskDir = getTaskDir(config.projectRoot, params.id);
@@ -210,32 +213,35 @@ export function createRpcHandler(config: HostConfig) {
         if (params.triggers_enabled !== undefined) 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: unknown) {
-              const error = err as { stdout?: string; stderr?: string };
-              return { error: "plan generation failed", stdout: error.stdout, stderr: error.stderr };
-            }
+            delete existing.frontmatter.command;
+          }
+        }
+
+        // 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: unknown) {
+            const error = err as { stdout?: string; stderr?: string };
+            return { error: "plan generation failed", stdout: error.stdout, stderr: error.stderr };
           }
         }
 
         writeTaskFile(taskDir, existing);
 
-        // Reinstall or remove timers based on triggers_enabled
+        // Reinstall service and timers
         const platform = getPlatform();
         platform.removeTaskTimer(params.id);
-        if (existing.frontmatter.triggers_enabled) {
-          platform.installTaskTimer(config, existing);
-        }
+        platform.installTaskTimer(config, existing);
 
         return flattenTask(existing);
       }
@@ -263,14 +269,25 @@ export function createRpcHandler(config: HostConfig) {
 
       case "task.abort": {
         const params = request.params as { id: string };
+        // 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: unknown) {
           const e = err as { stderr?: string; message?: string };
           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)
+        const abortPayload: Record<string, unknown> = { event_type: "running-state", running_state: "aborted" };
+        const useHttp = (config.mode ?? "nats") === "lan" || (config.mode ?? "nats") === "auto";
+        await publishHostEvent(nc, config, params.id, abortPayload, useHttp);
+        return { ok: true, task_id: params.id };
       }
 
       case "task.status": {
@@ -327,11 +344,11 @@ export function createRpcHandler(config: HostConfig) {
       }
 
       case "task.user_input": {
-        const params = request.params as { id: string; value: string };
+        const params = request.params as { id: string; value: string[] };
         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" };
         }
 

package/src/spawn-command.ts

@@ -1,83 +1,120 @@
-import { spawn } from "child_process";
-
-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;
-}
-
-/**
- * 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.
- *
- * 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.
- */
-export interface SpawnCommandResult {
-  output: string;
-  exitCode: number | null;
-}
-
-export function spawnCommand(
-  command: string,
-  args: string[],
-  opts: SpawnCommandOptions,
-): Promise<SpawnCommandResult> {
-  return new Promise<SpawnCommandResult>((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd: opts.cwd,
-      stdio: ["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",
-    });
-
-    const chunks: Buffer[] = [];
-    child.stdout.on("data", (d: Buffer) => {
-      chunks.push(d);
-      if (opts.echoStdout) process.stdout.write(d);
-    });
-    child.stderr.on("data", (d: Buffer) => 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: ReturnType<typeof setTimeout> | undefined;
-    if (opts.timeout) {
-      timer = setTimeout(() => {
-        child.kill();
-        reject(new Error("command timed out"));
-      }, opts.timeout);
-    }
-
-    child.on("close", (code) => {
-      if (timer) clearTimeout(timer);
-      const output = Buffer.concat(chunks).toString("utf-8");
-      if (code === 0 || stopping || opts.resolveOnFailure) resolve({ output, exitCode: code });
-      else reject(new Error(`process exited with code ${code}`));
-    });
-
-    child.on("error", (err) => {
-      if (timer) clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
+import crossSpawn from "cross-spawn";
+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 function spawnStreamingCommand(
+  command: string,
+  opts: SpawnStreamingOptions,
+): ChildProcess {
+  return crossSpawn(command, [], {
+    cwd: opts.cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: true,
+    env: opts.env ? { ...process.env, ...opts.env } : undefined,
+    windowsHide: true,
+  });
+}
+
+export interface SpawnCommandOptions {
+  cwd: string;
+  env?: Record<string, string>;
+  timeout?: number;
+  /** Echo stdout to process.stdout (useful for journald logging). */
+  echoStdout?: 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.
+ *
+ * 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" 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;
+  exitCode: number | null;
+}
+
+export function spawnCommand(
+  command: string,
+  args: string[],
+  opts: SpawnCommandOptions,
+): Promise<SpawnCommandResult> {
+  return new Promise<SpawnCommandResult>((resolve, reject) => {
+    // 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: [opts.stdin != null ? "pipe" : "ignore", "pipe", "pipe"],
+      env: opts.env ? { ...process.env, ...opts.env } : undefined,
+      windowsHide: true,
+    });
+
+    if (opts.stdin != null) {
+      child.stdin!.end(opts.stdin);
+    }
+
+    const chunks: Buffer[] = [];
+    child.stdout!.on("data", (d: Buffer) => {
+      chunks.push(d);
+      if (opts.echoStdout) process.stdout.write(d);
+    });
+    child.stderr!.on("data", (d: Buffer) => process.stderr.write(d));
+
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    if (opts.timeout) {
+      timer = setTimeout(() => {
+        child.kill();
+        reject(new Error("command timed out"));
+      }, opts.timeout);
+    }
+
+    child.on("close", (code: number | null) => {
+      if (timer) clearTimeout(timer);
+      const output = Buffer.concat(chunks).toString("utf-8");
+      if (code === 0 || opts.resolveOnFailure) resolve({ output, exitCode: code });
+      else reject(new Error(`process exited with code ${code}`));
+    });
+
+    child.on("error", (err: Error) => {
+      if (timer) clearTimeout(timer);
+      reject(err);
+    });
+  });
+}

package/src/transports/nats-transport.ts

@@ -1,15 +1,15 @@
-import { StringCodec, type Msg, type Subscription } from "nats";
-import { connectNats } from "../nats-client.js";
+import { StringCodec, type NatsConnection, type Msg, type Subscription } from "nats";
 import type { HostConfig, RpcMessage } from "../types.js";
 
 /**
- * Start the NATS transport: connect, subscribe to RPC subjects, dispatch to handler.
+ * Start the NATS transport using an existing connection.
+ * Subscribe to RPC subjects and dispatch to handler.
  */
 export async function startNatsTransport(
   config: HostConfig,
   handleRpc: (req: RpcMessage) => Promise<unknown>,
+  nc: NatsConnection,
 ): Promise<void> {
-  const nc = await connectNats(config);
   const sc = StringCodec();
 
   const subject = `host.${config.hostId}.rpc.>`;

package/src/types.ts

@@ -25,6 +25,7 @@ export interface TaskFrontmatter {
   triggers_enabled: boolean;
   requires_confirmation: boolean;
   permissions?: RequiredPermission[];
+  command?: string;
 }
 
 export interface Trigger {
@@ -37,14 +38,15 @@ export interface ParsedTask {
   body: string;
 }
 
-export type TaskRunningState = "start" | "finish" | "abort" | "fail";
+export type TaskRunningState = "started" | "finished" | "aborted" | "failed";
 
 export interface TaskStatus {
   running_state: TaskRunningState;
   time_stamp: number;
   pending_confirmation?: boolean;
   pending_permission?: RequiredPermission[];
-  user_input?: string;
+  pending_input?: string[];
+  user_input?: string[];
 }
 
 export interface HistoryEntry {