palmier 0.6.1 → 0.6.2

package/src/agents/agent.ts

@@ -2,16 +2,25 @@ import type { ParsedTask, RequiredPermission } from "../types.js";
 import { ClaudeAgent } from "./claude.js";
 import { GeminiAgent } from "./gemini.js";
 import { CodexAgent } from "./codex.js";
+import { DroidAgent } from "./droid.js";
 import { OpenClawAgent } from "./openclaw.js";
 import { CopilotAgent } from "./copilot.js";
 import { QwenAgent } from "./qwen.js";
 import { KimiAgent } from "./kimi.js";
+import { GooseAgent } from "./goose.js";
+import { OpenCodeAgent } from "./opencode.js";
+import { DeepAgents } from "./deepagents.js";
+import { Aider } from "./aider.js";
+import { OpenHands } from "./openhands.js";
+import { Cursor } from "./cursor.js";
 
 export interface CommandLine {
   command: string;
   args: string[];
   /** If provided, the string is written to the process's stdin and then the pipe is closed. */
   stdin?: string;
+  /** Additional environment variables to set for the spawned process. */
+  env?: Record<string, string>;
 }
 
 /**
@@ -45,16 +54,30 @@ const agentRegistry: Record<string, AgentTool> = {
   copilot: new CopilotAgent(),
   qwen: new QwenAgent(),
   kimi: new KimiAgent(),
+  droid: new DroidAgent(),
+  goose: new GooseAgent(),
+  opencode: new OpenCodeAgent(),
+  deepagents: new DeepAgents(),
+  aider: new Aider(),
+  openhands: new OpenHands(),
+  cursor: new Cursor(),
 };
 
 const agentLabels: Record<string, string> = {
   claude: "Claude Code",
   gemini: "Gemini CLI",
   codex: "Codex CLI",
+  droid: "Droid CLI",
   openclaw: "OpenClaw",
   copilot: "Copilot CLI",
   qwen: "Qwen Code",
   kimi: "Kimi Code",
+  goose: "Goose CLI",
+  opencode: "OpenCode",
+  deepagents: "Deep Agents CLI",
+  aider: "Aider",
+  openhands: "OpenHands",
+  cursor: "Cursor CLI",
 };
 
 export interface DetectedAgent {

package/src/agents/aider.ts

@@ -0,0 +1,37 @@
+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 Aider implements AgentTool {
+  supportsPermissions = false;
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "aider",
+      args: ["--message", 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 = [];
+
+    if (yolo) {
+      args.push("--yes-always");
+    }
+    args.push("--message", prompt);
+
+    return { command: "aider", args};
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("aider --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

package/src/agents/cursor.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 Cursor implements AgentTool {
+  supportsPermissions = false;
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "cursor",
+      args: ["-p", 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 = [];
+
+    if (yolo) {
+      args.push("--force");
+    }
+    if (followupPrompt) {args.push("--continue");} // continue mode for followups
+    args.push("-p", prompt);
+
+    return { command: "cursor", args};
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("cursor --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

package/src/agents/deepagents.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 DeepAgents implements AgentTool {
+  supportsPermissions = false;
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "deepagents",
+      args: ["--non-interactive", 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 = [];
+
+    if (yolo) {
+      args.push("--auto-approve");
+    }
+    if (followupPrompt) {args.push("--resume");} // continue mode for followups
+    args.push("--non-interactive", prompt);
+
+    return { command: "deepagents", args};
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("deepagents --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

package/src/agents/droid.ts

@@ -0,0 +1,37 @@
+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 DroidAgent implements AgentTool {
+  supportsPermissions = false;
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "droid",
+      args: ["exec", 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 = ["exec", "--session-id", task.frontmatter.id];
+
+    if (yolo) {
+      args.push("--skip-permissions-unsafe");
+    }
+    args.push(prompt);
+
+    return { command: "droid", args};
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("droid --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    return true;
+  }
+}

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/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

@@ -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

@@ -225,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 };