palmier 0.6.0 → 0.6.2

package/src/agents/goose.ts

@@ -0,0 +1,35 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+
+export class GooseAgent implements AgentTool {
+  supportsPermissions = false;
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "goose",
+      args: ["run", "--text", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+    const args = ["run"];
+
+    if (followupPrompt) {args.push("--resume");} // continue mode for followups
+    args.push("--text", prompt);
+
+    return { command: "goose", args, ...(yolo ? { env: { GOOSE_MODE: "auto" } } : {}) };
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("goose --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

package/src/agents/opencode.ts

@@ -0,0 +1,38 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+
+export class OpenCodeAgent implements AgentTool {
+  supportsPermissions = false;
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "opencode",
+      args: ["run", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+    const args = ["run"];
+
+    if (yolo) {
+      args.push("--dangerously-skip-permissions");
+    }
+    if (followupPrompt) {args.push("--continue");} // continue mode for followups
+    args.push(prompt);
+
+    return { command: "opencode", args};
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("opencode --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

package/src/agents/openhands.ts

@@ -0,0 +1,38 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+
+export class OpenHands implements AgentTool {
+  supportsPermissions = false;
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "openhands",
+      args: ["--headless", "-t", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
+    const yolo = extraPermissions === "yolo";
+    const prompt = followupPrompt ?? (getAgentInstructions(task.frontmatter.id, yolo || !this.supportsPermissions) + "\n\n" + (task.body || task.frontmatter.user_prompt));
+    const args = ["--headless"];
+
+    if (yolo) {
+      args.push("--always-approve");
+    }
+    if (followupPrompt) {args.push("--resume", "--last");} // continue mode for followups
+    args.push("-t", prompt);
+
+    return { command: "openhands", args};
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("openhands --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

package/src/commands/pair.ts

@@ -61,7 +61,7 @@ function httpPairRegister(port: number, code: string): Promise<boolean> {
 }
 
 /**
- * Generate an OTP code and wait for a PWA client to pair.
+ * Generate a pairing code and wait for a PWA client to pair.
  * Listens on NATS (server mode) and HTTP (via serve daemon) in parallel.
  */
 export async function pairCommand(): Promise<void> {

package/src/commands/run.ts

@@ -62,7 +62,7 @@ async function invokeAgentWithRetries(
       }, 500);
     }
 
-    const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(
+    const { command, args, stdin, env: agentEnv } = ctx.agent.getTaskRunCommandLine(
       invokeTask, undefined, ctx.task.frontmatter.yolo_mode ? "yolo" : ctx.transientPermissions,
     );
     const truncate = (s: string, max = 100) => s.length > max ? s.slice(0, max) + "…" : s;
@@ -70,7 +70,7 @@ async function invokeAgentWithRetries(
     console.log(`[invoke] ${command} ${displayArgs.join(" ")}${stdin ? ` (stdin: ${truncate(stdin, 100)})` : ""}`);
     const result = await spawnCommand(command, args, {
       cwd: getRunDir(ctx.taskDir, ctx.runId),
-      env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
+      env: { ...ctx.guiEnv, ...agentEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
       echoStdout: true,
       resolveOnFailure: true,
       stdin,

package/src/rpc-handler.ts

@@ -27,7 +27,7 @@ const PLAN_GENERATION_PROMPT = fs.readFileSync(
 /**
  * Parse RESULT frontmatter and conversation messages.
  */
-function parseResultFrontmatter(raw: string): Record<string, unknown> {
+export function parseResultFrontmatter(raw: string): Record<string, unknown> {
   const fmMatch = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!fmMatch) return { messages: [] };
 
@@ -124,13 +124,14 @@ async function generatePlan(
 ): Promise<{ name: string; body: string }> {
   const fullPrompt = PLAN_GENERATION_PROMPT + userPrompt;
   const planAgent = getAgent(agentName);
-  const { command, args, stdin } = planAgent.getPlanGenerationCommandLine(fullPrompt);
+  const { command, args, stdin, env: agentEnv } = planAgent.getPlanGenerationCommandLine(fullPrompt);
   console.log(`[generatePlan] Running: ${command} ${args.join(" ")}`);
 
   const { output } = await spawnCommand(command, args, {
     cwd: projectRoot,
     timeout: 120_000,
     stdin,
+    ...(agentEnv ? { env: agentEnv } : {}),
   });
 
   let name = "";
@@ -423,7 +424,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(
+        const { command: cmd, args: cmdArgs, stdin, env: followupAgentEnv } = followupAgent.getTaskRunCommandLine(
           followupTask, params.message, followupTask.frontmatter.yolo_mode ? "yolo" : followupTask.frontmatter.permissions,
         );
 
@@ -431,7 +432,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         const child = crossSpawn(cmd, cmdArgs, {
           cwd: followupRunDir,
           stdio: [stdin != null ? "pipe" : "ignore", "pipe", "pipe"],
-          env: { ...process.env, PALMIER_TASK_ID: params.id },
+          env: { ...process.env, ...followupAgentEnv, PALMIER_TASK_ID: params.id },
           windowsHide: true,
         });
         if (stdin != null) child.stdin!.end(stdin);

package/src/transports/http-transport.ts

@@ -1,5 +1,6 @@
 import * as http from "node:http";
 import * as os from "os";
+import * as path from "node:path";
 import { StringCodec, type NatsConnection } from "nats";
 import { validateClient, addClient } from "../client-store.js";
 import { registerPending } from "../pending-requests.js";
@@ -7,9 +8,7 @@ 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";
-
-// ── On-the-fly PWA asset cache ──────────────────────────────────────────
+// ── Bundled PWA asset serving ───────────────────────────────────────────
 
 interface CachedAsset {
   data: Buffer;
@@ -17,8 +16,8 @@ interface CachedAsset {
 }
 
 const assetCache = new Map<string, CachedAsset>();
-/** Paths currently being fetched (dedup concurrent requests). */
-const assetInflight = new Map<string, Promise<CachedAsset | null>>();
+
+const PWA_DIR = path.join(import.meta.dirname, "..", "pwa");
 
 const CONTENT_TYPES: Record<string, string> = {
   ".html": "text/html; charset=utf-8",
@@ -30,6 +29,7 @@ const CONTENT_TYPES: Record<string, string> = {
   ".woff2": "font/woff2",
   ".woff": "font/woff",
   ".svg": "image/svg+xml",
+  ".webmanifest": "application/manifest+json",
 };
 
 function guessContentType(urlPath: string): string {
@@ -38,45 +38,32 @@ function guessContentType(urlPath: string): string {
   return CONTENT_TYPES[ext] ?? "application/octet-stream";
 }
 
-async function fetchBuffer(url: string): Promise<Buffer> {
-  const res = await fetch(url);
-  if (!res.ok) throw new Error(`${res.status} ${res.statusText} for ${url}`);
-  return Buffer.from(await res.arrayBuffer());
-}
-
 /**
- * Fetch a PWA asset on-the-fly, caching in memory.
- * Returns null if the asset cannot be fetched.
+ * Read a PWA asset from the bundled pwa/ directory, caching in memory.
+ * Returns null if the file does not exist.
  */
-async function getAsset(urlPath: string): Promise<CachedAsset | null> {
+function getAsset(urlPath: string): CachedAsset | null {
   const cached = assetCache.get(urlPath);
   if (cached) return cached;
 
-  // Dedup concurrent requests for the same path
-  const inflight = assetInflight.get(urlPath);
-  if (inflight) return inflight;
-
-  const promise = (async () => {
-    try {
-      let data = await fetchBuffer(`${PWA_ORIGIN}${urlPath}`);
-      // Inject LAN mode marker into index HTML so the PWA can detect it's served by palmier
-      if (urlPath === "/") {
-        const html = data.toString("utf-8").replace("</head>", "<script>window.__PALMIER_SERVE__=true</script></head>");
-        data = Buffer.from(html, "utf-8");
-      }
-      const asset: CachedAsset = { data, contentType: guessContentType(urlPath) };
-      assetCache.set(urlPath, asset);
-      return asset;
-    } catch (err) {
-      console.warn(`[pwa] Failed to fetch ${urlPath}: ${err}`);
-      return null;
-    } finally {
-      assetInflight.delete(urlPath);
-    }
-  })();
+  const filePath = path.join(PWA_DIR, urlPath === "/" ? "index.html" : urlPath);
 
-  assetInflight.set(urlPath, promise);
-  return promise;
+  // Prevent path traversal
+  if (!filePath.startsWith(PWA_DIR)) return null;
+
+  try {
+    let data = fs.readFileSync(filePath);
+    // Inject marker into index HTML so the PWA can detect it's served by palmier
+    if (urlPath === "/") {
+      const html = data.toString("utf-8").replace("</head>", "<script>window.__PALMIER_SERVE__=true</script></head>");
+      data = Buffer.from(html, "utf-8");
+    }
+    const asset: CachedAsset = { data, contentType: guessContentType(urlPath) };
+    assetCache.set(urlPath, asset);
+    return asset;
+  } catch {
+    return null;
+  }
 }
 
 type SseClient = http.ServerResponse;
@@ -238,11 +225,12 @@ export async function startHttpTransport(
 
       try {
         const body = await readBody(req);
-        const { title, body: notifBody } = JSON.parse(body) as { title: string; body: string };
+        const { taskId: notifTaskId, title, body: notifBody } = JSON.parse(body) as { taskId?: string; title: string; body: string };
         if (!title || !notifBody) { sendJson(res, 400, { error: "title and body are required" }); return; }
 
         const sc = StringCodec();
-        const payload = { hostId: config.hostId, title, body: notifBody };
+        const payload: Record<string, string> = { hostId: config.hostId, title, body: notifBody };
+        if (notifTaskId) payload.task_id = notifTaskId;
         const subject = `host.${config.hostId}.push.send`;
         const reply = await nc.request(subject, sc.encode(JSON.stringify(payload)), { timeout: 15_000 });
         const result = JSON.parse(sc.decode(reply.data)) as { ok?: boolean; error?: string };
@@ -383,7 +371,7 @@ export async function startHttpTransport(
       return;
     }
 
-    // ── Public pair endpoint — no auth, PWA posts OTP code here ────────
+    // ── Public pair endpoint — no auth, PWA posts pairing code here ────────
 
     if (req.method === "POST" && pathname === "/pair") {
       try {
@@ -421,9 +409,9 @@ export async function startHttpTransport(
       if (SKIP.has(pathname)) { sendJson(res, 404, { error: "Not found" }); return; }
 
       // Try exact path, then fall back to index.html (SPA routing)
-      let asset = await getAsset(pathname);
+      let asset = getAsset(pathname);
       if (!asset && pathname !== "/") {
-        asset = await getAsset("/");
+        asset = getAsset("/");
       }
 
       if (asset) {

package/test/result-state.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  createRunDir,
+  appendRunMessage,
+  beginStreamingMessage,
+} from "../src/task.js";
+import { parseResultFrontmatter } from "../src/rpc-handler.js";
+
+let taskDir: string;
+let runId: string;
+
+function setup() {
+  taskDir = fs.mkdtempSync(path.join(os.tmpdir(), "palmier-test-"));
+  runId = createRunDir(taskDir, "Test Task", 1000, "claude");
+}
+
+function readRaw(): string {
+  return fs.readFileSync(path.join(taskDir, runId, "TASKRUN.md"), "utf-8");
+}
+
+describe("parseResultFrontmatter — monitoring state", () => {
+  beforeEach(setup);
+
+  it("returns 'monitoring' when monitoring is the last message", () => {
+    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
+    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "monitoring" });
+
+    const result = parseResultFrontmatter(readRaw());
+    assert.equal(result.running_state, "monitoring");
+  });
+
+  it("returns 'started' when an assistant message follows monitoring", () => {
+    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
+    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "monitoring" });
+    const writer = beginStreamingMessage(taskDir, runId, 1002);
+    writer.write("Working on it...");
+    writer.end();
+
+    const result = parseResultFrontmatter(readRaw());
+    assert.equal(result.running_state, "started");
+  });
+
+  it("returns 'monitoring' after agent finishes and monitoring resumes", () => {
+    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
+    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "monitoring" });
+    // Agent processes a line
+    const writer = beginStreamingMessage(taskDir, runId, 1002);
+    writer.write("Done processing line.");
+    writer.end();
+    // Back to monitoring
+    appendRunMessage(taskDir, runId, { role: "status", time: 1003, content: "", type: "monitoring" });
+
+    const result = parseResultFrontmatter(readRaw());
+    assert.equal(result.running_state, "monitoring");
+  });
+
+  it("returns 'started' when a user message follows monitoring", () => {
+    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
+    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "monitoring" });
+    appendRunMessage(taskDir, runId, { role: "user", time: 1002, content: "some input" });
+
+    const result = parseResultFrontmatter(readRaw());
+    assert.equal(result.running_state, "started");
+  });
+});
+
+describe("parseResultFrontmatter — standard states", () => {
+  beforeEach(setup);
+
+  it("returns 'started' for a running task", () => {
+    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
+    appendRunMessage(taskDir, runId, { role: "user", time: 1001, content: "Do something" });
+
+    const result = parseResultFrontmatter(readRaw());
+    assert.equal(result.running_state, "started");
+  });
+
+  it("returns 'finished' for a completed task", () => {
+    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
+    appendRunMessage(taskDir, runId, { role: "user", time: 1001, content: "Do something" });
+    const writer = beginStreamingMessage(taskDir, runId, 1002);
+    writer.write("Done.");
+    writer.end();
+    appendRunMessage(taskDir, runId, { role: "status", time: 1003, content: "", type: "finished" });
+
+    const result = parseResultFrontmatter(readRaw());
+    assert.equal(result.running_state, "finished");
+  });
+
+  it("returns 'failed' for a failed task", () => {
+    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
+    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "failed" });
+
+    const result = parseResultFrontmatter(readRaw());
+    assert.equal(result.running_state, "failed");
+  });
+
+  it("returns 'followup' when started again after terminal state", () => {
+    appendRunMessage(taskDir, runId, { role: "status", time: 1000, content: "", type: "started" });
+    appendRunMessage(taskDir, runId, { role: "status", time: 1001, content: "", type: "finished" });
+    appendRunMessage(taskDir, runId, { role: "status", time: 1002, content: "", type: "started" });
+
+    const result = parseResultFrontmatter(readRaw());
+    assert.equal(result.running_state, "followup");
+  });
+});