palmier 0.2.0 → 0.2.2

package/src/commands/run.ts

@@ -1,14 +1,37 @@
 import * as fs from "fs";
 import * as path from "path";
-import { spawn } from "child_process";
+import { spawnCommand } from "../spawn-command.js";
 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 { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory } from "../task.js";
+import { getAgent } from "../agents/agent.js";
+import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX } from "../agents/shared-prompt.js";
+import type { HostConfig, ParsedTask, TaskRunningState, RequiredPermission } from "../types.js";
+import type { NatsConnection } from "nats";
 import { StringCodec } from "nats";
 
-export type TaskEventType = "start" | "finish" | "abort" | "fail";
+/**
+ * Write a time-stamped RESULT file with frontmatter.
+ * Always generated, even for abort/fail.
+ */
+function writeResult(
+  taskDir: string,
+  taskName: string,
+  taskSnapshotName: string,
+  runningState: string,
+  startTime: number,
+  endTime: number,
+  output: string,
+  reportFiles: string[],
+  requiredPermissions: RequiredPermission[],
+): string {
+  const resultFileName = `RESULT-${endTime}.md`;
+  const reportLine = reportFiles.length > 0 ? `\nreport_files: ${reportFiles.join(", ")}` : "";
+  const permLines = requiredPermissions.map((p) => `\nrequired_permission: ${p.name} | ${p.description}`).join("");
+  const content = `---\ntask_name: ${taskName}\nrunning_state: ${runningState}\nstart_time: ${startTime}\nend_time: ${endTime}\ntask_file: ${taskSnapshotName}${reportLine}${permLines}\n---\n${output}`;
+  fs.writeFileSync(path.join(taskDir, resultFileName), content, "utf-8");
+  return resultFileName;
+}
 
 /**
  * Execute a task by ID.
@@ -17,17 +40,21 @@ export async function runCommand(taskId: string): Promise<void> {
   const config = loadConfig();
   const taskDir = getTaskDir(config.projectRoot, taskId);
   const task = parseTaskFile(taskDir);
+  const mode = config.mode ?? "nats";
+  const useNats = mode === "nats" || mode === "auto";
+  const useHttp = mode === "lan" || mode === "auto";
 
-  console.log(`Running task: ${taskId}`);
+  console.log(`Running task: ${taskId} (mode: ${mode})`);
 
   let nc: NatsConnection | undefined;
-  let confirmKv: KV | undefined;
-  const confirmKey = `${config.agentId}.${taskId}`;
+  const startTime = Date.now();
+  const taskName = task.frontmatter.name;
+
+  // Snapshot the task file at run time
+  const taskSnapshotName = `TASK-${startTime}.md`;
+  fs.copyFileSync(path.join(taskDir, "TASK.md"), path.join(taskDir, taskSnapshotName));
 
   const cleanup = async () => {
-    if (confirmKv) {
-      try { await confirmKv.delete(confirmKey); } catch { /* may not exist */ }
-    }
     if (nc && !nc.isClosed()) {
       await nc.drain();
     }
@@ -36,59 +63,118 @@ export async function runCommand(taskId: string): Promise<void> {
   // Handle signals
   const onSignal = async () => {
     console.log("Received signal, cleaning up...");
-    if (eventKv) {
-      await writeTaskEvent(eventKv, `${config.agentId}.${taskId}`, "abort").catch(() => {});
-    }
+    const endTime = Date.now();
+    const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "abort", startTime, endTime, "", [], []);
+    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+    await publishTaskEvent(nc, config, taskDir, taskId, "abort", useHttp, taskName);
     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();
+    if (useNats) {
+      nc = await connectNats(config);
+    }
 
-    // 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");
+    // Mark as started immediately
+    await publishTaskEvent(nc, config, taskDir, taskId, "start", useHttp, taskName);
 
-    // If requires_confirmation, ask user via NATS KV
+    // If requires_confirmation, notify clients and wait
     if (task.frontmatter.requires_confirmation) {
-      confirmKv = await js.views.kv("pending-confirmation");
-
-      const confirmed = await requestConfirmation(config, task, confirmKv);
+      const confirmed = await requestConfirmation(nc, config, task, taskDir, useHttp);
+      const resolvedStatus = confirmed ? "confirmed" : "aborted";
+      await publishConfirmResolved(nc, config, taskId, resolvedStatus, useHttp);
       if (!confirmed) {
         console.log("Task aborted by user.");
-        await writeTaskEvent(eventKv, eventKey, "abort");
+        const endTime = Date.now();
+        const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "abort", startTime, endTime, "", [], []);
+        appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+        await publishTaskEvent(nc, config, taskDir, taskId, "abort", useHttp, taskName);
         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");
+    // Execution loop: retry on permission failure if user grants
+    const guiEnv = getGuiEnv();
+    const agent = getAgent(task.frontmatter.agent);
+
+    let lastOutput = "";
+    let lastOutcome: TaskRunningState = "fail";
+    let lastReportFiles: string[] = [];
+    let lastRequiredPermissions: RequiredPermission[] = [];
+    let lastEndTime = Date.now();
+
+    let retryPrompt: string | undefined;
+    let transientPermissions: RequiredPermission[] = [];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const { command, args } = agent.getTaskRunCommandLine(task, retryPrompt, transientPermissions);
+      const result = await spawnCommand(command, args, {
+        cwd: taskDir,
+        env: {
+          ...guiEnv,
+          PALMIER_TASK_ID: task.frontmatter.id,
+        },
+        echoStdout: true,
+        forwardSignals: true,
+        resolveOnFailure: true,
+      });
+      lastOutput = result.output;
+      lastEndTime = Date.now();
+
+      lastOutcome = result.exitCode !== 0 ? "fail" : parseTaskOutcome(lastOutput);
+      lastReportFiles = parseReportFiles(lastOutput);
+      lastRequiredPermissions = parsePermissions(lastOutput);
+
+      // If failed with permission requirements, ask user to grant
+      if (lastOutcome === "fail" && lastRequiredPermissions.length > 0) {
+        const response = await requestPermission(nc, config, task, taskDir, lastRequiredPermissions, useHttp);
+        await publishPermissionResolved(nc, config, taskId, response, useHttp);
+
+        if (response === "aborted") {
+          console.log("Permission request aborted by user.");
+          break;
+        }
+
+        const newPerms = lastRequiredPermissions.filter(
+          (rp) => !task.frontmatter.permissions?.some((ep) => ep.name === rp.name)
+            && !transientPermissions.some((ep) => ep.name === rp.name),
+        );
+
+        if (response === "granted_all") {
+          // Persist permissions to task frontmatter for all future runs
+          task.frontmatter.permissions = [...(task.frontmatter.permissions ?? []), ...newPerms];
+          writeTaskFile(taskDir, task);
+        } else {
+          // "granted" — allow for this run only
+          transientPermissions = [...transientPermissions, ...newPerms];
+        }
+
+        console.log(`Permissions granted, retrying task ${taskId}...`);
+        retryPrompt = "Permissions granted, please continue.";
+        continue;
+      }
 
-    // Set event to finish on completion
-    await writeTaskEvent(eventKv, eventKey, "finish");
+      // Normal completion (success or non-permission failure)
+      break;
+    }
 
+    // Write result and history once after the loop
+    const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, lastOutcome, startTime, lastEndTime, lastOutput, lastReportFiles, lastRequiredPermissions);
+    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+    await publishTaskEvent(nc, config, taskDir, taskId, lastOutcome, useHttp, taskName);
     console.log(`Task ${taskId} completed.`);
   } catch (err) {
     console.error(`Task ${taskId} failed:`, err);
-    if (eventKv) {
-      await writeTaskEvent(eventKv, `${config.agentId}.${taskId}`, "fail").catch(() => {});
-    }
+    const endTime = Date.now();
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    const resultFileName = writeResult(taskDir, taskName, taskSnapshotName, "fail", startTime, endTime, errorMsg, [], []);
+    appendHistory(config.projectRoot, { task_id: taskId, result_file: resultFileName });
+    await publishTaskEvent(nc, config, taskDir, taskId, "fail", useHttp, taskName);
     process.exitCode = 1;
   } finally {
     await cleanup();
@@ -97,109 +183,217 @@ export async function runCommand(taskId: string): Promise<void> {
 
 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;
-    }
+/**
+ * Write status.json and notify connected clients via NATS and/or HTTP SSE.
+ */
+async function publishHostEvent(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
+  taskId: string,
+  payload: Record<string, unknown>,
+  useHttp: boolean,
+): Promise<void> {
+  const subject = `host-event.${config.hostId}.${taskId}`;
+
+  if (nc) {
+    nc.publish(subject, sc.encode(JSON.stringify(payload)));
+    console.log(`[nats] ${subject} →`, payload);
+  }
 
+  if (useHttp && config.directPort) {
     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
+      await fetch(`http://localhost:${config.directPort}/internal/event`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ task_id: taskId, ...payload }),
+      });
+      console.log(`[http] host-event: ${taskId} →`, payload);
+    } catch (err) {
+      console.error(`[http] Failed to push event:`, err);
     }
   }
+}
+
+async function publishTaskEvent(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
+  taskDir: string,
+  taskId: string,
+  eventType: TaskRunningState,
+  useHttp: boolean,
+  taskName?: string,
+): Promise<void> {
+  writeTaskStatus(taskDir, {
+    running_state: eventType,
+    time_stamp: Date.now(),
+  });
 
-  return false;
+  const payload: Record<string, unknown> = { event_type: "running-state", running_state: eventType };
+  if (taskName) payload.name = taskName;
+  await publishHostEvent(nc, config, taskId, payload, useHttp);
 }
 
-function shellEscape(arg: string): string {
-  return "'" + arg.replace(/'/g, "'\\''") + "'";
+/**
+ * Notify clients that a confirmation request has been resolved.
+ */
+async function publishConfirmResolved(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
+  taskId: string,
+  status: "confirmed" | "aborted",
+  useHttp: boolean,
+): Promise<void> {
+  await publishHostEvent(nc, config, taskId, {
+    event_type: "confirm-resolved",
+    host_id: config.hostId,
+    status,
+  }, useHttp);
 }
 
-async function spawnTask(
-  config: AgentConfig,
+async function requestPermission(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
   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,
-      },
+  taskDir: string,
+  requiredPermissions: RequiredPermission[],
+  useHttp: boolean,
+): Promise<"granted" | "granted_all" | "aborted"> {
+  const taskId = task.frontmatter.id;
+  const statusPath = path.join(taskDir, "status.json");
+
+  const currentStatus = readTaskStatus(taskDir)!;
+  writeTaskStatus(taskDir, { ...currentStatus, pending_permission: requiredPermissions });
+
+  await publishHostEvent(nc, config, taskId, {
+    event_type: "permission-request",
+    host_id: config.hostId,
+    required_permissions: requiredPermissions,
+    name: task.frontmatter.name,
+  }, useHttp);
+
+  return new Promise<"granted" | "granted_all" | "aborted">((resolve) => {
+    const watcher = fs.watch(statusPath, () => {
+      const status = readTaskStatus(taskDir);
+      if (!status || status.user_input === undefined) return;
+      watcher.close();
+      const response = status.user_input as "granted" | "granted_all" | "aborted";
+      writeTaskStatus(taskDir, {
+        running_state: response === "aborted" ? "abort" : "start",
+        time_stamp: Date.now(),
+      });
+      resolve(response);
     });
+  });
+}
 
-    const stdoutChunks: Buffer[] = [];
+async function publishPermissionResolved(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
+  taskId: string,
+  status: "granted" | "granted_all" | "aborted",
+  useHttp: boolean,
+): Promise<void> {
+  await publishHostEvent(nc, config, taskId, {
+    event_type: "permission-resolved",
+    host_id: config.hostId,
+    status,
+  }, useHttp);
+}
 
-    child.stdout?.on("data", (data: Buffer) => {
-      stdoutChunks.push(data);
-      process.stdout.write(data);
+async function requestConfirmation(
+  nc: NatsConnection | undefined,
+  config: HostConfig,
+  task: ParsedTask,
+  taskDir: string,
+  useHttp: boolean,
+): Promise<boolean> {
+  const taskId = task.frontmatter.id;
+  const statusPath = path.join(taskDir, "status.json");
+
+  // Flag that we're awaiting user confirmation
+  const currentStatus = readTaskStatus(taskDir)!;
+  writeTaskStatus(taskDir, { ...currentStatus, pending_confirmation: true });
+
+  // Publish confirmation request via NATS and/or HTTP SSE
+  await publishHostEvent(nc, config, taskId, {
+    event_type: "confirm-request",
+    host_id: config.hostId,
+  }, useHttp);
+
+  // Wait for task.user_input RPC to set user_input in status.json
+  return new Promise<boolean>((resolve) => {
+    const watcher = fs.watch(statusPath, () => {
+      const status = readTaskStatus(taskDir);
+      if (!status || status.user_input === undefined) return; // still pending
+      watcher.close();
+      const confirmed = status.user_input === "confirmed";
+      // Clear pending_confirmation/user_input and update running_state
+      writeTaskStatus(taskDir, {
+        running_state: confirmed ? "start" : "abort",
+        time_stamp: Date.now(),
+      });
+      resolve(confirmed);
     });
+  });
+}
 
-    child.stderr?.on("data", (data: Buffer) => {
-      process.stderr.write(data);
-    });
+/**
+ * Extract report file names from agent output.
+ * Looks for lines matching: [PALMIER_REPORT] <filename>
+ */
+function parseReportFiles(output: string): string[] {
+  const regex = new RegExp(`^\\${TASK_REPORT_PREFIX}\\s+(.+)$`, "gm");
+  const files: string[] = [];
+  let match;
+  while ((match = regex.exec(output)) !== null) {
+    const name = match[1].trim();
+    if (name) files.push(name);
+  }
+  return files;
+}
 
-    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}`));
-      }
-    });
+/**
+ * Extract required permissions from agent output.
+ * Looks for lines matching: [PALMIER_PERMISSION] <tool> | <description>
+ */
+function parsePermissions(output: string): RequiredPermission[] {
+  const regex = new RegExp(`^\\${TASK_PERMISSION_PREFIX}\\s+(.+)$`, "gm");
+  const perms: RequiredPermission[] = [];
+  let match;
+  while ((match = regex.exec(output)) !== null) {
+    const raw = match[1].trim();
+    const sep = raw.indexOf("|");
+    if (sep !== -1) {
+      perms.push({ name: raw.slice(0, sep).trim(), description: raw.slice(sep + 1).trim() });
+    } else {
+      perms.push({ name: raw, description: "" });
+    }
+  }
+  return perms;
+}
 
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
+/**
+ * Parse the agent's output for success/failure markers.
+ * Falls back to "finish" if no marker is found.
+ */
+function parseTaskOutcome(output: string): TaskRunningState {
+  const lastChunk = output.slice(-500);
+  if (lastChunk.includes(TASK_FAILURE_MARKER)) return "fail";
+  if (lastChunk.includes(TASK_SUCCESS_MARKER)) return "finish";
+  return "finish";
+}
+
+/**
+ * Return env vars for the default physical GUI session (:0).
+ */
+function getGuiEnv(): Record<string, string> {
+  const uid = process.getuid?.();
+  const runtimeDir =
+    process.env.XDG_RUNTIME_DIR ||
+    (uid !== undefined ? `/run/user/${uid}` : "");
+
+  return {
+    DISPLAY: ":0",
+    ...(runtimeDir ? { XDG_RUNTIME_DIR: runtimeDir } : {}),
+  };
 }