palmier 0.1.8 → 0.2.0

package/src/commands/run.ts

@@ -1,197 +1,205 @@
-import { v4 as uuidv4 } from "uuid";
-import { loadConfig } from "../config.js";
-import { connectNats } from "../nats-client.js";
-import { parseTaskFile, getTaskDir } from "../task.js";
-import type { AgentConfig, ParsedTask, HookPayload } from "../types.js";
-import type { NatsConnection, KV } from "nats";
-import { StringCodec } from "nats";
-
-/**
- * Execute a task by ID.
- */
-export async function runCommand(taskId: string): Promise<void> {
-  const config = loadConfig();
-  const taskDir = getTaskDir(config.projectRoot, taskId);
-  const task = parseTaskFile(taskDir);
-
-  console.log(`Running task: ${task.frontmatter.name || taskId}`);
-
-  let nc: NatsConnection | undefined;
-  let kv: KV | undefined;
-
-  // Track KV keys we create so we can clean them up
-  const kvKeysToClean: string[] = [];
-
-  const cleanup = async () => {
-    if (kv) {
-      for (const key of kvKeysToClean) {
-        try {
-          await kv.delete(key);
-        } catch {
-          // Ignore cleanup errors
-        }
-      }
-    }
-    if (nc && !nc.isClosed()) {
-      await nc.drain();
-    }
-  };
-
-  // Handle signals
-  const onSignal = async () => {
-    console.log("Received signal, cleaning up...");
-    await cleanup();
-    process.exit(1);
-  };
-  process.on("SIGINT", onSignal);
-  process.on("SIGTERM", onSignal);
-
-  try {
-    // If requires_confirmation, ask user via NATS KV
-    if (task.frontmatter.requires_confirmation) {
-      nc = await connectNats(config);
-      const js = nc.jetstream();
-      kv = await js.views.kv("pending-hooks");
-
-      const confirmed = await requestConfirmation(config, task, kv, nc, kvKeysToClean);
-      if (!confirmed) {
-        console.log("Task aborted by user.");
-        await cleanup();
-        return;
-      }
-      console.log("Task confirmed by user.");
-    }
-
-    // Spawn Claude CLI via node-pty
-    await spawnClaude(config, task, taskId);
-
-    console.log(`Task ${taskId} completed.`);
-  } catch (err) {
-    console.error(`Task ${taskId} failed:`, err);
-    process.exitCode = 1;
-  } finally {
-    await cleanup();
-  }
-}
-
-async function requestConfirmation(
-  config: AgentConfig,
-  task: ParsedTask,
-  kv: KV,
-  nc: NatsConnection,
-  kvKeysToClean: string[]
-): Promise<boolean> {
-  const sc = StringCodec();
-  const hookId = uuidv4();
-  const kvKey = `${config.agentId}.${task.frontmatter.id}.${hookId}`;
-  kvKeysToClean.push(kvKey);
-
-  // Start watching BEFORE writing, to avoid race condition
-  const watch = await kv.watch({ key: kvKey });
-
-  // Write hook payload to KV
-  const payload: HookPayload = {
-    type: "confirm",
-    task_id: task.frontmatter.id,
-    hook_id: hookId,
-    agent_id: config.agentId,
-    user_id: config.userId,
-    details: {
-      task_name: task.frontmatter.name,
-      prompt: task.frontmatter.user_prompt,
-    },
-    status: "pending",
-  };
-
-  await kv.put(kvKey, sc.encode(JSON.stringify(payload)));
-
-  // Publish push notification
-  nc.publish(
-    `user.${config.userId}.push.request.confirm`,
-    sc.encode(JSON.stringify({
-      type: "confirm",
-      task_id: task.frontmatter.id,
-      hook_id: hookId,
-      agent_id: config.agentId,
-      task_name: task.frontmatter.name,
-    }))
-  );
-
-  // Wait for status change
-  for await (const entry of watch) {
-    if (entry.operation === "DEL" || entry.operation === "PURGE") {
-      // Key was deleted, treat as aborted
-      return false;
-    }
-
-    try {
-      const updated = JSON.parse(sc.decode(entry.value)) as HookPayload;
-      if (updated.status === "confirmed") {
-        await kv.delete(kvKey);
-        kvKeysToClean.pop();
-        return true;
-      } else if (updated.status === "aborted") {
-        await kv.delete(kvKey);
-        kvKeysToClean.pop();
-        return false;
-      }
-      // Still pending, keep watching
-    } catch {
-      // Couldn't parse, keep watching
-    }
-  }
-
-  return false;
-}
-
-async function spawnClaude(
-  config: AgentConfig,
-  task: ParsedTask,
-  taskId: string
-): Promise<void> {
-  // Dynamic import of node-pty (native module)
-  const { spawn } = await import("node-pty");
-
-  return new Promise<void>((resolve, reject) => {
-    const args = ["-p", task.frontmatter.user_prompt];
-
-    if (task.frontmatter.suppress_permissions) {
-      args.push("--dangerously-skip-permissions");
-    }
-
-    // If the task has a body (system prompt / additional instructions), pass via --system-prompt
-    if (task.body) {
-      args.push("--system-prompt", task.body);
-    }
-
-    const ptyProcess = spawn("claude", args, {
-      name: "xterm-256color",
-      cols: 120,
-      rows: 40,
-      cwd: config.projectRoot,
-      env: {
-        ...process.env,
-        PALMIER_TASK_ID: taskId,
-      } as Record<string, string>,
-    });
-
-    ptyProcess.onData((data: string) => {
-      process.stdout.write(data);
-    });
-
-    ptyProcess.onExit(({ exitCode }: { exitCode: number }) => {
-      if (exitCode === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Claude exited with code ${exitCode}`));
-      }
-    });
-
-    // Forward signals to pty child
-    const killChild = () => {
-      ptyProcess.kill();
-    };
-    process.on("SIGINT", killChild);
-    process.on("SIGTERM", killChild);
-  });
-}
+import * as fs from "fs";
+import * as path from "path";
+import { spawn } from "child_process";
+import { loadConfig } from "../config.js";
+import { connectNats } from "../nats-client.js";
+import { parseTaskFile, getTaskDir } from "../task.js";
+import type { AgentConfig, ParsedTask, ConfirmPayload } from "../types.js";
+import type { NatsConnection, KV } from "nats";
+import { StringCodec } from "nats";
+
+export type TaskEventType = "start" | "finish" | "abort" | "fail";
+
+/**
+ * Execute a task by ID.
+ */
+export async function runCommand(taskId: string): Promise<void> {
+  const config = loadConfig();
+  const taskDir = getTaskDir(config.projectRoot, taskId);
+  const task = parseTaskFile(taskDir);
+
+  console.log(`Running task: ${taskId}`);
+
+  let nc: NatsConnection | undefined;
+  let confirmKv: KV | undefined;
+  const confirmKey = `${config.agentId}.${taskId}`;
+
+  const cleanup = async () => {
+    if (confirmKv) {
+      try { await confirmKv.delete(confirmKey); } catch { /* may not exist */ }
+    }
+    if (nc && !nc.isClosed()) {
+      await nc.drain();
+    }
+  };
+
+  // Handle signals
+  const onSignal = async () => {
+    console.log("Received signal, cleaning up...");
+    if (eventKv) {
+      await writeTaskEvent(eventKv, `${config.agentId}.${taskId}`, "abort").catch(() => {});
+    }
+    await cleanup();
+    process.exit(1);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+
+  let eventKv: KV | undefined;
+
+  try {
+    nc = await connectNats(config);
+    const js = nc.jetstream();
+
+    // Set up task-event KV and mark as started immediately
+    eventKv = await js.views.kv("task-event", { history: 1 });
+    const eventKey = `${config.agentId}.${taskId}`;
+    await writeTaskEvent(eventKv, eventKey, "start");
+
+    // If requires_confirmation, ask user via NATS KV
+    if (task.frontmatter.requires_confirmation) {
+      confirmKv = await js.views.kv("pending-confirmation");
+
+      const confirmed = await requestConfirmation(config, task, confirmKv);
+      if (!confirmed) {
+        console.log("Task aborted by user.");
+        await writeTaskEvent(eventKv, eventKey, "abort");
+        await cleanup();
+        return;
+      }
+      console.log("Task confirmed by user.");
+    }
+
+    // Spawn task process
+    const startTime = Date.now();
+    const output = await spawnTask(config, task);
+    const endTime = Date.now();
+
+    // Save result with frontmatter to task directory
+    const resultPath = path.join(taskDir, "RESULT.md");
+    const resultContent = `---\nstart_time: ${startTime}\nend_time: ${endTime}\n---\n${output}`;
+    fs.writeFileSync(resultPath, resultContent, "utf-8");
+
+    // Set event to finish on completion
+    await writeTaskEvent(eventKv, eventKey, "finish");
+
+    console.log(`Task ${taskId} completed.`);
+  } catch (err) {
+    console.error(`Task ${taskId} failed:`, err);
+    if (eventKv) {
+      await writeTaskEvent(eventKv, `${config.agentId}.${taskId}`, "fail").catch(() => {});
+    }
+    process.exitCode = 1;
+  } finally {
+    await cleanup();
+  }
+}
+
+const sc = StringCodec();
+
+async function writeTaskEvent(kv: KV, key: string, eventType: TaskEventType): Promise<void> {
+  const event = { event_type: eventType, time_stamp: Date.now() };
+  console.log(`[task-event] ${key} → ${eventType}`);
+  await kv.put(key, sc.encode(JSON.stringify(event)));
+}
+
+async function requestConfirmation(
+  config: AgentConfig,
+  task: ParsedTask,
+  kv: KV,
+): Promise<boolean> {
+  const kvKey = `${config.agentId}.${task.frontmatter.id}`;
+
+  // Write confirmation payload to KV — the server watches this bucket and sends push notifications
+  const payload: ConfirmPayload = {
+    type: "confirm",
+    task_id: task.frontmatter.id,
+    agent_id: config.agentId,
+    user_id: config.userId,
+    details: {
+      prompt: task.frontmatter.user_prompt,
+    },
+    status: "pending",
+  };
+
+  await kv.put(kvKey, sc.encode(JSON.stringify(payload)));
+
+  // Watch AFTER writing — the initial history replay delivers the "pending" entry (skipped),
+  // then the iterator stays open for live updates (confirmed/aborted).
+  const watch = await kv.watch({ key: kvKey });
+
+  for await (const entry of watch) {
+    if (entry.operation === "DEL" || entry.operation === "PURGE") {
+      return false;
+    }
+
+    try {
+      const updated = JSON.parse(sc.decode(entry.value)) as ConfirmPayload;
+      if (updated.status === "confirmed") return true;
+      if (updated.status === "aborted") return false;
+      // Still pending, keep watching
+    } catch {
+      // Couldn't parse, keep watching
+    }
+  }
+
+  return false;
+}
+
+function shellEscape(arg: string): string {
+  return "'" + arg.replace(/'/g, "'\\''") + "'";
+}
+
+async function spawnTask(
+  config: AgentConfig,
+  task: ParsedTask,
+): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    const prompt = task.body
+      ? `${task.body}\n\n${task.frontmatter.user_prompt}`
+      : task.frontmatter.user_prompt;
+
+    const command = `${task.frontmatter.command_line} ${shellEscape(prompt)}`;
+
+    const child = spawn(command, {
+      cwd: config.projectRoot,
+      shell: true,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        PALMIER_TASK_ID: task.frontmatter.id,
+      },
+    });
+
+    const stdoutChunks: Buffer[] = [];
+
+    child.stdout?.on("data", (data: Buffer) => {
+      stdoutChunks.push(data);
+      process.stdout.write(data);
+    });
+
+    child.stderr?.on("data", (data: Buffer) => {
+      process.stderr.write(data);
+    });
+
+    let stopping = false;
+    const killChild = () => {
+      stopping = true;
+      child.kill("SIGTERM");
+    };
+    process.on("SIGINT", killChild);
+    process.on("SIGTERM", killChild);
+
+    child.on("close", (exitCode) => {
+      if (exitCode === 0 || stopping) {
+        resolve(Buffer.concat(stdoutChunks).toString("utf-8"));
+      } else {
+        reject(new Error(`Task process exited with code ${exitCode}`));
+      }
+    });
+
+    child.on("error", (err) => {
+      reject(err);
+    });
+  });
+}