palmier 0.5.0 → 0.5.2

package/src/rpc-handler.ts

@@ -151,10 +151,17 @@ const activeFollowups = new Map<string, ChildProcess>();
 export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
   function flattenTask(task: ParsedTask) {
     const taskDir = getTaskDir(config.projectRoot, task.frontmatter.id);
+    const status = readTaskStatus(taskDir);
+    const pending = getPending(task.frontmatter.id);
     return {
       ...task.frontmatter,
       body: task.body,
-      status: readTaskStatus(taskDir),
+      status: status ? {
+        ...status,
+        ...(pending?.type === "confirmation" ? { pending_confirmation: true } : {}),
+        ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
+        ...(pending?.type === "input" ? { pending_input: pending.params } : {}),
+      } : undefined,
     };
   }
 
@@ -181,6 +188,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           triggers?: Array<{ type: "cron" | "once"; value: string }>;
           triggers_enabled?: boolean;
           requires_confirmation?: boolean;
+          yolo_mode?: boolean;
           command?: string;
         };
 
@@ -211,6 +219,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             triggers: params.triggers ?? [],
             triggers_enabled: params.triggers_enabled ?? true,
             requires_confirmation: params.requires_confirmation ?? true,
+            ...(params.yolo_mode ? { yolo_mode: true } : {}),
             ...(params.command ? { command: params.command } : {}),
           },
           body,
@@ -231,6 +240,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           triggers?: Array<{ type: "cron" | "once"; value: string }>;
           triggers_enabled?: boolean;
           requires_confirmation?: boolean;
+          yolo_mode?: boolean;
           command?: string;
         };
 
@@ -249,6 +259,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         if (params.triggers_enabled !== undefined) existing.frontmatter.triggers_enabled = params.triggers_enabled;
         if (params.requires_confirmation !== undefined)
           existing.frontmatter.requires_confirmation = params.requires_confirmation;
+        if (params.yolo_mode !== undefined) existing.frontmatter.yolo_mode = params.yolo_mode || undefined;
         if (params.command !== undefined) {
           if (params.command) {
             existing.frontmatter.command = params.command;
@@ -295,6 +306,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
           user_prompt: string;
           agent: string;
           requires_confirmation?: boolean;
+          yolo_mode?: boolean;
           command?: string;
         };
 
@@ -310,6 +322,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
             triggers: [],
             triggers_enabled: false,
             requires_confirmation: params.requires_confirmation ?? false,
+            ...(params.yolo_mode ? { yolo_mode: true } : {}),
             ...(params.command ? { command: params.command } : {}),
           },
           body: "",
@@ -383,7 +396,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         // Fire-and-forget: invoke agent inline as a child of the serve process
         const followupAgent = getAgent(followupTask.frontmatter.agent);
         const { command: cmd, args: cmdArgs, stdin } = followupAgent.getTaskRunCommandLine(
-          followupTask, params.message, followupTask.frontmatter.permissions,
+          followupTask, params.message, followupTask.frontmatter.yolo_mode ? "yolo" : followupTask.frontmatter.permissions,
         );
 
         // Spawn directly via crossSpawn so we can track and kill the child
@@ -557,8 +570,8 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const reports: Array<{ file: string; content?: string; error?: string }> = [];
         const runDir = path.join(config.projectRoot, "tasks", params.id, params.run_id);
         for (const file of params.report_files) {
-          if (!file.endsWith(".md")) {
-            reports.push({ file, error: "must end with .md" });
+          if (!file.endsWith(".md") && !file.endsWith(".txt")) {
+            reports.push({ file, error: "must end with .md or .txt" });
             continue;
           }
           const basename = path.basename(file);

package/src/task.ts

@@ -202,31 +202,66 @@ export function beginStreamingMessage(
   const filePath = path.join(taskDir, runId, "TASKRUN.md");
   const delimiter = `<!-- palmier:message role="assistant" time="${time}" -->`;
   fs.appendFileSync(filePath, `${delimiter}\n\n`, "utf-8");
-  return new StreamingMessageWriter(filePath, delimiter);
+  return new StreamingMessageWriter(filePath);
 }
 
 export class StreamingMessageWriter {
-  private delimiter: string;
-  constructor(private filePath: string, delimiter: string) {
-    this.delimiter = delimiter;
-  }
+  constructor(private filePath: string) {}
 
   /** Append a chunk of content to the current message. */
   write(chunk: string): void {
     fs.appendFileSync(this.filePath, chunk, "utf-8");
   }
 
-  /** Finalize the message. If attachments are provided, rewrites the delimiter to include them. */
+  /** Finalize the message. If attachments are provided, rewrites the last assistant delimiter to include them. */
   end(attachments?: string[]): void {
     fs.appendFileSync(this.filePath, "\n\n", "utf-8");
     if (attachments?.length) {
       const raw = fs.readFileSync(this.filePath, "utf-8");
-      const updated = raw.replace(this.delimiter, `${this.delimiter.slice(0, -4)} attachments="${attachments.join(",")}" -->`);
-      fs.writeFileSync(this.filePath, updated, "utf-8");
+      // Find the last assistant delimiter (may differ from the original if spliceUserMessage created a new one)
+      const pattern = /<!-- palmier:message role="assistant" time="\d+" -->/g;
+      let lastMatch: RegExpExecArray | null = null;
+      let m;
+      while ((m = pattern.exec(raw)) !== null) lastMatch = m;
+      if (lastMatch) {
+        const before = raw.slice(0, lastMatch.index);
+        const after = raw.slice(lastMatch.index + lastMatch[0].length);
+        const updated = before + `${lastMatch[0].slice(0, -4)} attachments="${attachments.join(",")}" -->` + after;
+        fs.writeFileSync(this.filePath, updated, "utf-8");
+      }
     }
   }
 }
 
+/**
+ * Splice a user message into a running assistant stream.
+ * Ends the current assistant block, writes the user message,
+ * then opens a new assistant block — all as direct file appends.
+ * The existing StreamingMessageWriter keeps working because its
+ * write() is just appendFileSync, so subsequent chunks land in
+ * the new assistant block.
+ */
+export function spliceUserMessage(
+  taskDir: string,
+  runId: string,
+  userMsg: ConversationMessage,
+  /** Optional text to append to the current assistant block before ending it. */
+  assistantAppend?: string,
+): void {
+  const filePath = path.join(taskDir, runId, "TASKRUN.md");
+  // 1. Optionally append to the current assistant block (e.g. the input questions)
+  if (assistantAppend) {
+    fs.appendFileSync(filePath, assistantAppend, "utf-8");
+  }
+  // 2. End the current assistant block
+  fs.appendFileSync(filePath, "\n\n", "utf-8");
+  // 3. Write the user message
+  appendRunMessage(taskDir, runId, userMsg);
+  // 4. Open a new assistant block for subsequent agent output
+  const delimiter = `<!-- palmier:message role="assistant" time="${Date.now()}" -->`;
+  fs.appendFileSync(filePath, `${delimiter}\n\n`, "utf-8");
+}
+
 /**
  * Read conversation messages from a run's TASKRUN.md file.
  */

package/src/transports/http-transport.ts

@@ -3,7 +3,8 @@ import * as os from "os";
 import { StringCodec, type NatsConnection } from "nats";
 import { validateSession, addSession } from "../session-store.js";
 import { registerPending } from "../pending-requests.js";
-import { getTaskDir, parseTaskFile, appendRunMessage } from "../task.js";
+import * as fs from "node:fs";
+import { getTaskDir, parseTaskFile, spliceUserMessage } from "../task.js";
 import type { HostConfig, RpcMessage, RequiredPermission } from "../types.js";
 
 const PWA_ORIGIN = "https://app.palmier.me";
@@ -99,6 +100,18 @@ export function detectLanIp(): string {
   return "127.0.0.1";
 }
 
+/** Find the latest (highest-numbered) run directory for a task. */
+function findLatestRunId(taskDir: string): string | null {
+  try {
+    const dirs = fs.readdirSync(taskDir)
+      .filter((f) => /^\d+$/.test(f) && fs.statSync(`${taskDir}/${f}`).isDirectory())
+      .sort();
+    return dirs.length > 0 ? dirs[dirs.length - 1] : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Start the HTTP transport: server with RPC, SSE, PWA proxy, pairing, and
  * localhost-only agent endpoints (notify, request-input, confirmation, permission).
@@ -262,6 +275,11 @@ export async function startHttpTransport(
         const taskDir = getTaskDir(config.projectRoot, taskId);
         const task = parseTaskFile(taskDir);
 
+        // Resolve runId: use provided value, otherwise find the latest run directory
+        const effectiveRunId = runId ?? findLatestRunId(taskDir);
+
+        const pendingPromise = registerPending(taskId, "input", descriptions);
+
         await publishEvent(taskId, {
           event_type: "input-request",
           host_id: config.hostId,
@@ -269,19 +287,22 @@ export async function startHttpTransport(
           name: task.frontmatter.name,
         });
 
-        const response = await registerPending(taskId, "input", descriptions);
+        const response = await pendingPromise;
+
+        const questionsBlock = "\n\n" + descriptions.map((d) => `**${d}**`).join("\n");
 
         if (response.length === 1 && response[0] === "aborted") {
           await publishEvent(taskId, { event_type: "input-resolved", host_id: config.hostId, status: "aborted" });
-          if (runId) {
-            appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: "Input request aborted.", type: "input" });
+          if (effectiveRunId) {
+            spliceUserMessage(taskDir, effectiveRunId, { role: "user", time: Date.now(), content: "Aborted", type: "input" }, questionsBlock);
+            await publishEvent(taskId, { event_type: "result-updated", run_id: effectiveRunId });
           }
           sendJson(res, 200, { aborted: true });
         } else {
           await publishEvent(taskId, { event_type: "input-resolved", host_id: config.hostId, status: "provided" });
-          if (runId) {
-            const lines = descriptions.map((desc, i) => `**${desc}** ${response[i]}`);
-            appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: lines.join("\n"), type: "input" });
+          if (effectiveRunId) {
+            spliceUserMessage(taskDir, effectiveRunId, { role: "user", time: Date.now(), content: response.join("\n"), type: "input" }, questionsBlock);
+            await publishEvent(taskId, { event_type: "result-updated", run_id: effectiveRunId });
           }
           sendJson(res, 200, { values: response });
         }
@@ -300,12 +321,14 @@ export async function startHttpTransport(
         const { taskId } = JSON.parse(body) as { taskId: string };
         if (!taskId) { sendJson(res, 400, { error: "taskId is required" }); return; }
 
+        const pendingPromise = registerPending(taskId, "confirmation");
+
         await publishEvent(taskId, {
           event_type: "confirm-request",
           host_id: config.hostId,
         });
 
-        const response = await registerPending(taskId, "confirmation");
+        const response = await pendingPromise;
         const confirmed = response[0] === "confirmed";
 
         await publishEvent(taskId, {
@@ -335,6 +358,8 @@ export async function startHttpTransport(
           return;
         }
 
+        const pendingPromise = registerPending(taskId, "permission", permissions);
+
         await publishEvent(taskId, {
           event_type: "permission-request",
           host_id: config.hostId,
@@ -342,7 +367,7 @@ export async function startHttpTransport(
           name: taskName,
         });
 
-        const response = await registerPending(taskId, "permission", permissions);
+        const response = await pendingPromise;
         const status = response[0] as "granted" | "granted_all" | "aborted";
 
         await publishEvent(taskId, {

package/src/types.ts

@@ -23,6 +23,7 @@ export interface TaskFrontmatter {
   triggers: Trigger[];
   triggers_enabled: boolean;
   requires_confirmation: boolean;
+  yolo_mode?: boolean;
   permissions?: RequiredPermission[];
   command?: string;
 }

package/test/agent-instructions.test.ts

@@ -0,0 +1,31 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { getAgentInstructions } from "../src/agents/shared-prompt.js";
+
+describe("getAgentInstructions", () => {
+  it("includes Permissions section by default", () => {
+    const result = getAgentInstructions("test-task-id");
+    assert.match(result, /## Permissions/);
+    assert.match(result, /PALMIER_PERMISSION/);
+  });
+
+  it("strips Permissions section when skipPermissions is true", () => {
+    const result = getAgentInstructions("test-task-id", true);
+    assert.doesNotMatch(result, /## Permissions/);
+    assert.doesNotMatch(result, /PALMIER_PERMISSION/);
+  });
+
+  it("preserves other sections when Permissions is stripped", () => {
+    const result = getAgentInstructions("test-task-id", true);
+    assert.match(result, /## Reporting Output/);
+    assert.match(result, /## Completion/);
+    assert.match(result, /## HTTP Endpoints/);
+  });
+
+  it("replaces template variables", () => {
+    const result = getAgentInstructions("my-task-123");
+    assert.match(result, /my-task-123/);
+    assert.doesNotMatch(result, /\{\{TASK_ID\}\}/);
+    assert.doesNotMatch(result, /\{\{PORT\}\}/);
+  });
+});