palmier 0.2.0 → 0.2.2

package/dist/commands/run.js

@@ -1,10 +1,24 @@
 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 { 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 { StringCodec } from "nats";
+/**
+ * Write a time-stamped RESULT file with frontmatter.
+ * Always generated, even for abort/fail.
+ */
+function writeResult(taskDir, taskName, taskSnapshotName, runningState, startTime, endTime, output, reportFiles, requiredPermissions) {
+    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.
  */
@@ -12,17 +26,17 @@ export async function runCommand(taskId) {
     const config = loadConfig();
     const taskDir = getTaskDir(config.projectRoot, taskId);
     const task = parseTaskFile(taskDir);
-    console.log(`Running task: ${taskId}`);
+    const mode = config.mode ?? "nats";
+    const useNats = mode === "nats" || mode === "auto";
+    const useHttp = mode === "lan" || mode === "auto";
+    console.log(`Running task: ${taskId} (mode: ${mode})`);
     let nc;
-    let confirmKv;
-    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();
         }
@@ -30,51 +44,104 @@ export async function runCommand(taskId) {
     // 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;
     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 (useNats) {
+            nc = await connectNats(config);
+        }
+        // Mark as started immediately
+        await publishTaskEvent(nc, config, taskDir, taskId, "start", useHttp, taskName);
+        // 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");
-        // Set event to finish on completion
-        await writeTaskEvent(eventKv, eventKey, "finish");
+        // Execution loop: retry on permission failure if user grants
+        const guiEnv = getGuiEnv();
+        const agent = getAgent(task.frontmatter.agent);
+        let lastOutput = "";
+        let lastOutcome = "fail";
+        let lastReportFiles = [];
+        let lastRequiredPermissions = [];
+        let lastEndTime = Date.now();
+        let retryPrompt;
+        let transientPermissions = [];
+        // 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;
+            }
+            // 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 {
@@ -82,90 +149,167 @@ export async function runCommand(taskId) {
     }
 }
 const sc = StringCodec();
-async function writeTaskEvent(kv, key, eventType) {
-    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, task, kv) {
-    const kvKey = `${config.agentId}.${task.frontmatter.id}`;
-    // Write confirmation payload to KV — the server watches this bucket and sends push notifications
-    const payload = {
-        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, config, taskId, payload, useHttp) {
+    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));
-            if (updated.status === "confirmed")
-                return true;
-            if (updated.status === "aborted")
-                return false;
-            // Still pending, 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 {
-            // Couldn't parse, keep watching
+        catch (err) {
+            console.error(`[http] Failed to push event:`, err);
         }
     }
-    return false;
 }
-function shellEscape(arg) {
-    return "'" + arg.replace(/'/g, "'\\''") + "'";
+async function publishTaskEvent(nc, config, taskDir, taskId, eventType, useHttp, taskName) {
+    writeTaskStatus(taskDir, {
+        running_state: eventType,
+        time_stamp: Date.now(),
+    });
+    const payload = { event_type: "running-state", running_state: eventType };
+    if (taskName)
+        payload.name = taskName;
+    await publishHostEvent(nc, config, taskId, payload, useHttp);
 }
-async function spawnTask(config, task) {
-    return new Promise((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 = [];
-        child.stdout?.on("data", (data) => {
-            stdoutChunks.push(data);
-            process.stdout.write(data);
-        });
-        child.stderr?.on("data", (data) => {
-            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}`));
-            }
+/**
+ * Notify clients that a confirmation request has been resolved.
+ */
+async function publishConfirmResolved(nc, config, taskId, status, useHttp) {
+    await publishHostEvent(nc, config, taskId, {
+        event_type: "confirm-resolved",
+        host_id: config.hostId,
+        status,
+    }, useHttp);
+}
+async function requestPermission(nc, config, task, taskDir, requiredPermissions, useHttp) {
+    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((resolve) => {
+        const watcher = fs.watch(statusPath, () => {
+            const status = readTaskStatus(taskDir);
+            if (!status || status.user_input === undefined)
+                return;
+            watcher.close();
+            const response = status.user_input;
+            writeTaskStatus(taskDir, {
+                running_state: response === "aborted" ? "abort" : "start",
+                time_stamp: Date.now(),
+            });
+            resolve(response);
         });
-        child.on("error", (err) => {
-            reject(err);
+    });
+}
+async function publishPermissionResolved(nc, config, taskId, status, useHttp) {
+    await publishHostEvent(nc, config, taskId, {
+        event_type: "permission-resolved",
+        host_id: config.hostId,
+        status,
+    }, useHttp);
+}
+async function requestConfirmation(nc, config, task, taskDir, useHttp) {
+    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((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);
         });
     });
 }
+/**
+ * Extract report file names from agent output.
+ * Looks for lines matching: [PALMIER_REPORT] <filename>
+ */
+function parseReportFiles(output) {
+    const regex = new RegExp(`^\\${TASK_REPORT_PREFIX}\\s+(.+)$`, "gm");
+    const files = [];
+    let match;
+    while ((match = regex.exec(output)) !== null) {
+        const name = match[1].trim();
+        if (name)
+            files.push(name);
+    }
+    return files;
+}
+/**
+ * Extract required permissions from agent output.
+ * Looks for lines matching: [PALMIER_PERMISSION] <tool> | <description>
+ */
+function parsePermissions(output) {
+    const regex = new RegExp(`^\\${TASK_PERMISSION_PREFIX}\\s+(.+)$`, "gm");
+    const perms = [];
+    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;
+}
+/**
+ * Parse the agent's output for success/failure markers.
+ * Falls back to "finish" if no marker is found.
+ */
+function parseTaskOutcome(output) {
+    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() {
+    const uid = process.getuid?.();
+    const runtimeDir = process.env.XDG_RUNTIME_DIR ||
+        (uid !== undefined ? `/run/user/${uid}` : "");
+    return {
+        DISPLAY: ":0",
+        ...(runtimeDir ? { XDG_RUNTIME_DIR: runtimeDir } : {}),
+    };
+}
 //# sourceMappingURL=run.js.map

package/dist/commands/serve.d.ts

@@ -1,5 +1,5 @@
 /**
- * Start the persistent NATS RPC handler.
+ * Start the persistent RPC handler using the configured transport(s).
  */
 export declare function serveCommand(): Promise<void>;
 //# sourceMappingURL=serve.d.ts.map