palmier 1.1.23 → 1.1.25

package/dist/commands/run.js

@@ -2,157 +2,116 @@ import * as fs from "fs";
 import * as path from "path";
 import { spawnCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
-import { parseTaskFile, taskDisplayName, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, claimPendingRun, appendRunMessage, getRunDir, beginStreamingMessage, formatAgentModelComment } from "../task.js";
+import { parseTaskFile, taskDisplayName, getTaskDir, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, claimPendingRun, appendRunMessage, getRunDir, beginStreamingMessage, formatAgentModelComment, takeUserReply } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
-import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_PERMISSION_PREFIX, AGENT_MODEL_PREFIX } from "../agents/shared-prompt.js";
+import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_NEED_INPUT_MARKER, AGENT_MODEL_PREFIX, getResumePrompt } from "../agents/shared-prompt.js";
 import { extractFileLinks, resolveTaskFile } from "../task-files.js";
 import { publishHostEvent } from "../events.js";
 /**
- * Invoke the agent CLI in a continuation loop to handle permission requests.
  * `invokeTask` is the ParsedTask whose prompt is passed to the agent (for
  * triggered tasks this is the per-trigger augmented task).
  */
-async function invokeAgentWithRetries(ctx, invokeTask) {
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        let writer;
-        let activeStream;
-        const lineBufs = { stdout: "", stderr: "" };
-        let suppressedStderr = "";
-        let notifyPending = false;
-        let notifyTimer;
-        let agentModel;
-        let agentModelWritten = false;
-        const captureCliModel = createCliModelCapture(ctx.agent);
-        function throttledNotify() {
-            if (notifyPending)
-                return;
-            notifyPending = true;
-            notifyTimer = setTimeout(() => {
-                notifyPending = false;
-                publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
-            }, 500);
-        }
-        function ensureWriter(stream) {
-            if (writer && activeStream === stream)
-                return writer;
-            if (writer)
-                writer.end();
-            writer = beginStreamingMessage(ctx.taskDir, ctx.runId, Date.now(), stream);
-            activeStream = stream;
+async function invokeAgent(ctx, invokeTask, followupPrompt) {
+    let writer;
+    let activeStream;
+    const lineBufs = { stdout: "", stderr: "" };
+    let suppressedStderr = "";
+    let notifyPending = false;
+    let notifyTimer;
+    let agentModel;
+    let agentModelWritten = false;
+    const captureCliModel = createCliModelCapture(ctx.agent);
+    function throttledNotify() {
+        if (notifyPending)
+            return;
+        notifyPending = true;
+        notifyTimer = setTimeout(() => {
+            notifyPending = false;
+            publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+        }, 500);
+    }
+    function ensureWriter(stream) {
+        if (writer && activeStream === stream)
             return writer;
+        if (writer)
+            writer.end();
+        writer = beginStreamingMessage(ctx.taskDir, ctx.runId, Date.now(), stream);
+        activeStream = stream;
+        return writer;
+    }
+    function flushAgentModel() {
+        if (!agentModel || agentModelWritten || !writer)
+            return;
+        writer.write(formatAgentModelComment(agentModel));
+        agentModelWritten = true;
+        throttledNotify();
+    }
+    function onStderr(chunk) {
+        if (ctx.agent.suppressStdErr)
+            suppressedStderr += chunk;
+        else
+            emit("stderr", chunk);
+        const cliModel = captureCliModel(chunk);
+        if (cliModel && !agentModelWritten)
+            agentModel = cliModel;
+        flushAgentModel();
+    }
+    function emit(stream, chunk) {
+        lineBufs[stream] += chunk;
+        const lines = lineBufs[stream].split("\n");
+        lineBufs[stream] = lines.pop() ?? "";
+        if (stream === "stdout" && !agentModel) {
+            agentModel = parseAgentModel(lines.join("\n"));
         }
-        function flushAgentModel() {
-            if (!agentModel || agentModelWritten || !writer)
-                return;
-            writer.write(formatAgentModelComment(agentModel));
-            agentModelWritten = true;
+        const filtered = lines.filter((l) => !l.startsWith("[PALMIER"));
+        if (filtered.length > 0) {
+            ensureWriter(stream).write(filtered.join("\n") + "\n");
             throttledNotify();
         }
-        function onStderr(chunk) {
-            if (ctx.agent.suppressStdErr)
-                suppressedStderr += chunk;
-            else
-                emit("stderr", chunk);
-            const cliModel = captureCliModel(chunk);
-            if (cliModel && !agentModelWritten)
-                agentModel = cliModel;
-            flushAgentModel();
-        }
-        function emit(stream, chunk) {
-            lineBufs[stream] += chunk;
-            const lines = lineBufs[stream].split("\n");
-            lineBufs[stream] = lines.pop() ?? "";
-            if (stream === "stdout" && !agentModel) {
-                agentModel = parseAgentModel(lines.join("\n"));
-            }
-            const filtered = lines.filter((l) => !l.startsWith("[PALMIER"));
-            if (filtered.length > 0) {
-                ensureWriter(stream).write(filtered.join("\n") + "\n");
-                throttledNotify();
-            }
-            flushAgentModel();
-        }
-        function flushTrailingLine(stream) {
-            const trailing = lineBufs[stream];
-            if (trailing && !trailing.startsWith("[PALMIER")) {
-                ensureWriter(stream).write(trailing);
-            }
-        }
-        const { args, stdin, env: agentEnv, files } = ctx.agent.getTaskRunCommandLine(invokeTask);
-        const command = ctx.agent.command;
-        const runDir = getRunDir(ctx.taskDir, ctx.runId);
-        if (files) {
-            for (const f of files)
-                fs.writeFileSync(path.join(runDir, f.path), f.content, "utf-8");
+        flushAgentModel();
+    }
+    function flushTrailingLine(stream) {
+        const trailing = lineBufs[stream];
+        if (trailing && !trailing.startsWith("[PALMIER")) {
+            ensureWriter(stream).write(trailing);
         }
-        const result = await spawnCommand(command, args, {
-            cwd: runDir,
-            env: { ...ctx.guiEnv, ...agentEnv, PALMIER_RUN_DIR: runDir, PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7256) },
-            echoStdout: true,
-            resolveOnFailure: true,
-            stdin,
-            onStdout: (chunk) => emit("stdout", chunk),
-            onStderr,
+    }
+    const { args, stdin, env: agentEnv, files } = ctx.agent.getTaskRunCommandLine(invokeTask, followupPrompt);
+    const command = ctx.agent.command;
+    const runDir = getRunDir(ctx.taskDir, ctx.runId);
+    if (files) {
+        for (const f of files)
+            fs.writeFileSync(path.join(runDir, f.path), f.content, "utf-8");
+    }
+    const result = await spawnCommand(command, args, {
+        cwd: runDir,
+        env: { ...ctx.guiEnv, ...agentEnv, PALMIER_RUN_DIR: runDir, PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7256) },
+        echoStdout: true,
+        resolveOnFailure: true,
+        stdin,
+        onStdout: (chunk) => emit("stdout", chunk),
+        onStderr,
+    });
+    const outcome = result.exitCode !== 0 ? "failed" : parseTaskOutcome(result.output);
+    const linkedFiles = listLinkedTaskFiles(ctx.taskDir, ctx.runId, result.output);
+    flushTrailingLine("stdout");
+    if (outcome === "failed")
+        emit("stderr", suppressedStderr);
+    flushTrailingLine("stderr");
+    if (notifyTimer)
+        clearTimeout(notifyTimer);
+    writer?.end();
+    await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+    if (linkedFiles.length > 0) {
+        await publishHostEvent(ctx.taskId, {
+            event_type: "report-generated",
+            run_id: ctx.runId,
+            name: taskDisplayName(ctx.task.frontmatter),
+            report_files: linkedFiles,
         });
-        const outcome = result.exitCode !== 0 ? "failed" : parseTaskOutcome(result.output);
-        const linkedFiles = listLinkedTaskFiles(ctx.taskDir, ctx.runId, result.output);
-        const requiredPermissions = parsePermissions(result.output);
-        flushTrailingLine("stdout");
-        if (outcome === "failed")
-            emit("stderr", suppressedStderr);
-        flushTrailingLine("stderr");
-        if (requiredPermissions.length > 0) {
-            const permLines = requiredPermissions.map((p) => `- **${p.name}** ${p.description}`).join("\n");
-            ensureWriter("stdout").write(`\n\n**Permissions requested:**\n${permLines}\n`);
-        }
-        if (notifyTimer)
-            clearTimeout(notifyTimer);
-        writer?.end();
-        await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
-        if (linkedFiles.length > 0) {
-            await publishHostEvent(ctx.taskId, {
-                event_type: "report-generated",
-                run_id: ctx.runId,
-                name: taskDisplayName(ctx.task.frontmatter),
-                report_files: linkedFiles,
-            });
-        }
-        if (requiredPermissions.length > 0) {
-            const response = await requestPermission(ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
-            if (response === "aborted") {
-                await appendAndNotify(ctx, {
-                    role: "user",
-                    time: Date.now(),
-                    content: "Deny & Abort Task",
-                    type: "permission",
-                });
-                return { outcome: "failed" };
-            }
-            const newPerms = requiredPermissions.filter((rp) => !ctx.task.frontmatter.permissions?.some((ep) => ep.name === rp.name)
-                && !ctx.transientPermissions.some((ep) => ep.name === rp.name));
-            await appendAndNotify(ctx, {
-                role: "user",
-                time: Date.now(),
-                content: response === "granted_all" ? "Allow Always" : "Allow Once",
-                type: "permission",
-            });
-            if (response === "granted_all") {
-                ctx.task.frontmatter.permissions = [...(ctx.task.frontmatter.permissions ?? []), ...newPerms];
-                invokeTask.frontmatter.permissions = ctx.task.frontmatter.permissions;
-                writeTaskFile(ctx.taskDir, ctx.task);
-            }
-            else {
-                ctx.transientPermissions = [...ctx.transientPermissions, ...newPerms];
-            }
-            // Retry with the new permissions if the agent failed.
-            if (outcome === "failed") {
-                continue;
-            }
-        }
-        return { outcome };
     }
+    return { outcome };
 }
 export function stripPalmierMarkers(output) {
     return output.split("\n").filter((l) => !l.startsWith("[PALMIER")).join("\n").trim();
@@ -171,6 +130,47 @@ function resolveOutcome(taskDir, outcome) {
         return "aborted";
     return outcome;
 }
+const USER_REPLY_POLL_MS = 500;
+// A recurring task can't fire again while this run is waiting, so an unanswered question can't hold it forever.
+const USER_REPLY_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+async function waitForUserReply(runDir) {
+    const deadline = Date.now() + USER_REPLY_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const reply = takeUserReply(runDir);
+        if (reply)
+            return reply;
+        await new Promise((resolve) => setTimeout(resolve, USER_REPLY_POLL_MS));
+    }
+    return undefined;
+}
+/**
+ * Only the agent CLI exits while the user answers. This process stays alive because
+ * the OS scheduler would otherwise clean up what the agent left running, like its browser.
+ */
+async function invokeAgentUntilDone(ctx, invokeTask) {
+    const taskName = taskDisplayName(ctx.task.frontmatter);
+    const runDir = getRunDir(ctx.taskDir, ctx.runId);
+    let result = await invokeAgent(ctx, invokeTask);
+    while (resolveOutcome(ctx.taskDir, result.outcome) === "needs_input") {
+        appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "needs_input" });
+        await publishTaskEvent(ctx.taskDir, ctx.taskId, "needs_input", taskName, ctx.runId);
+        const reply = await waitForUserReply(runDir);
+        if (!reply) {
+            await appendAndNotify(ctx, {
+                role: "assistant",
+                time: Date.now(),
+                content: "The task stopped because no reply arrived within 24 hours.",
+            });
+            return { outcome: "failed" };
+        }
+        appendRunMessage(ctx.taskDir, ctx.runId, { role: "user", time: Date.now(), content: reply, type: "input" });
+        appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "started" });
+        await publishTaskEvent(ctx.taskDir, ctx.taskId, "started", taskName, ctx.runId);
+        await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+        result = await invokeAgent(ctx, invokeTask, getResumePrompt(reply));
+    }
+    return result;
+}
 export async function runCommand(taskId) {
     const config = loadConfig();
     const taskDir = getTaskDir(config.projectRoot, taskId);
@@ -217,7 +217,6 @@ export async function runCommand(taskId) {
         const agent = getAgent(task.frontmatter.agent);
         const ctx = {
             agent, task, taskDir, runId, guiEnv, config, taskId,
-            transientPermissions: [],
         };
         // Command-output and on_new_* tasks share the same trigger machinery: the
         // daemon owns the trigger source (the shell command's stdout / a NATS
@@ -238,7 +237,7 @@ export async function runCommand(taskId) {
                 time: Date.now(),
                 content: task.frontmatter.user_prompt,
             });
-            const result = await invokeAgentWithRetries(ctx, task);
+            const result = await invokeAgentUntilDone(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
             await publishTaskEvent(taskDir, taskId, outcome, taskName, runId);
@@ -299,7 +298,7 @@ async function runEventTriggeredMode(ctx) {
             const perEventTask = {
                 frontmatter: { ...ctx.task.frontmatter, user_prompt: perEventPrompt },
             };
-            const result = await invokeAgentWithRetries(ctx, perEventTask);
+            const result = await invokeAgentUntilDone(ctx, perEventTask);
             lastOutcome = result.outcome;
         }
     }
@@ -315,7 +314,8 @@ async function publishTaskEvent(taskDir, taskId, eventType, taskName, runId) {
     writeTaskStatus(taskDir, {
         running_state: eventType,
         time_stamp: Date.now(),
-        ...(eventType === "started" ? { pid: process.pid } : {}),
+        ...(eventType === "started" || eventType === "needs_input" ? { pid: process.pid } : {}),
+        ...(eventType === "needs_input" ? { run_id: runId } : {}),
     });
     const payload = { event_type: "running-state", running_state: eventType };
     if (taskName)
@@ -324,28 +324,6 @@ async function publishTaskEvent(taskDir, taskId, eventType, taskName, runId) {
         payload.run_id = runId;
     await publishHostEvent(taskId, payload);
 }
-async function requestPermission(config, task, taskDir, requiredPermissions) {
-    const port = config.httpPort ?? 7256;
-    const res = await fetch(`http://localhost:${port}/request-permission`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            taskId: task.frontmatter.id,
-            taskName: taskDisplayName(task.frontmatter),
-            permissions: requiredPermissions,
-        }),
-    });
-    const body = await res.json();
-    const response = body.response;
-    if (!response || !["granted", "granted_all", "aborted"].includes(response)) {
-        throw new Error(`Permission request failed: ${body.error ?? `unexpected response: ${JSON.stringify(body)}`}`);
-    }
-    writeTaskStatus(taskDir, {
-        running_state: response === "aborted" ? "aborted" : "started",
-        time_stamp: Date.now(),
-    });
-    return response;
-}
 async function requestConfirmation(config, task, taskDir) {
     const port = config.httpPort ?? 7256;
     const res = await fetch(`http://localhost:${port}/request-confirmation?taskId=${encodeURIComponent(task.frontmatter.id)}`, {
@@ -376,25 +354,6 @@ export function listLinkedTaskFiles(taskDir, runId, output) {
         }
     });
 }
-export 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();
-        // Skip placeholder examples echoed from the prompt (e.g. "<tool_name> | <description>").
-        if (raw.startsWith("<"))
-            continue;
-        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;
-}
 export function parseAgentModel(output) {
     const regex = new RegExp(`^\\${AGENT_MODEL_PREFIX}[ \\t]+(.+)$`, "gm");
     let match;
@@ -427,10 +386,10 @@ function sanitizeAgentModel(raw) {
         return undefined;
     return model;
 }
-/** Falls back to "finished" if no success/failure marker is found. */
+/** Falls back to "finished" if no outcome marker is found. */
 export function parseTaskOutcome(output) {
     const lastChunk = output.slice(-500);
-    const regex = new RegExp(`^\\${TASK_FAILURE_MARKER}$|^\\${TASK_SUCCESS_MARKER}$`, "gm");
+    const regex = new RegExp(`^\\${TASK_FAILURE_MARKER}$|^\\${TASK_SUCCESS_MARKER}$|^\\${TASK_NEED_INPUT_MARKER}$`, "gm");
     let last = null;
     let match;
     while ((match = regex.exec(lastChunk)) !== null) {
@@ -438,6 +397,8 @@ export function parseTaskOutcome(output) {
     }
     if (last === TASK_FAILURE_MARKER)
         return "failed";
+    if (last === TASK_NEED_INPUT_MARKER)
+        return "needs_input";
     if (last === TASK_SUCCESS_MARKER)
         return "finished";
     return "finished";

package/dist/commands/serve.js

@@ -42,7 +42,9 @@ async function checkStaleTasks(config) {
         catch {
             continue;
         }
-        if (status.running_state === "started" && !platform.isTaskRunning(taskId)) {
+        // Follow-up turns also end in needs_input, but no process is held open for them.
+        const isWaitingRun = status.running_state === "needs_input" && status.pid !== undefined;
+        if ((status.running_state === "started" || isWaitingRun) && !platform.isTaskRunning(taskId)) {
             console.log(`[monitor] Task ${taskId} process exited unexpectedly, marking as failed.`);
             const endTime = Date.now();
             writeTaskStatus(taskDir, { running_state: "failed", time_stamp: endTime });
@@ -64,7 +66,7 @@ async function checkStaleTasks(config) {
                 name: taskDisplayName(task.frontmatter) || taskId,
             });
         }
-        if (task.frontmatter.one_off && status.running_state !== "started") {
+        if (task.frontmatter.one_off && status.running_state !== "started" && !isWaitingRun) {
             try {
                 platform.removeTaskTimer(taskId);
             }

package/dist/pending-requests.d.ts

@@ -1,8 +1,6 @@
-import type { RequiredPermission } from "./types.js";
 export interface PendingRequestMeta {
     /** The task the request belongs to. */
     session_id?: string;
-    /** Task name, set for permission requests. */
     session_name?: string;
     description?: string;
     input_questions?: string[];
@@ -10,10 +8,10 @@ export interface PendingRequestMeta {
     secret?: boolean;
 }
 export interface PendingRequest {
-    type: "confirmation" | "permission" | "input" | "choice";
+    type: "confirmation" | "input" | "choice";
     resolve: (value: string[]) => void;
-    /** Permission list (for 'permission'), input descriptions (for 'input'), or option labels (for 'choice'). */
-    params?: RequiredPermission[] | string[];
+    /** Input descriptions (for 'input') or option labels (for 'choice'). */
+    params?: string[];
     /** Display context for PWAs that connect while this request is already open. */
     meta?: PendingRequestMeta;
 }