palmier 0.6.1 → 0.6.2

package/DISCLAIMER.md

@@ -4,7 +4,7 @@
 
 ## AI Agent Execution
 
-Palmier spawns third-party AI agent CLIs (such as Claude Code, Gemini CLI, and Codex CLI) that can:
+Palmier spawns third-party AI agent CLIs (such as Claude Code, Gemini CLI, Codex CLI, GitHub Copilot, and others) that can:
 
 - **Read, create, modify, and delete files** on your machine
 - **Execute arbitrary shell commands** with your user permissions
@@ -23,7 +23,7 @@ Tasks can be configured to run on schedules (cron) or in response to events with
 
 ## Third-Party Services
 
-Task prompts and execution data may be transmitted to third-party AI service providers (Anthropic, Google, OpenAI, etc.) according to their respective terms and privacy policies. Palmier does not control how these services process your data.
+Task prompts and execution data may be transmitted to third-party AI service providers (Anthropic, Google, OpenAI, etc.) according to their respective terms and privacy policies. Palmier does not install and has no control over how these services process your data.
 
 When using server mode, communication between your device and the host is relayed through the Palmier server. See the [Privacy Policy](https://www.palmier.me/privacy) for details on what data is collected.
 

package/dist/agents/agent-instructions.md

@@ -28,7 +28,7 @@ The request blocks until the user responds. Response: `{"values":["answer1","ans
 
 **Sending push notifications** — To notify the user, POST to `/notify` with:
 ```json
-{"title":"...","body":"..."}
+{"taskId":"{{TASK_ID}}","title":"...","body":"..."}
 ```
 
 ---

package/dist/agents/agent.d.ts

@@ -4,6 +4,8 @@ export interface CommandLine {
     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>;
 }
 /**
  * Interface that each agent tool must implement.

package/dist/agents/agent.js

@@ -1,10 +1,17 @@
 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";
 const agentRegistry = {
     claude: new ClaudeAgent(),
     gemini: new GeminiAgent(),
@@ -13,15 +20,29 @@ const agentRegistry = {
     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 = {
     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 async function detectAgents() {
     const detected = [];

package/dist/agents/aider.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class Aider implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=aider.d.ts.map

package/dist/agents/aider.js

@@ -0,0 +1,32 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class Aider {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "aider",
+            args: ["--message", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        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() {
+        try {
+            execSync("aider --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=aider.js.map

package/dist/agents/cursor.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class Cursor implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=cursor.d.ts.map

package/dist/agents/cursor.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class Cursor {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "cursor",
+            args: ["-p", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        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() {
+        try {
+            execSync("cursor --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=cursor.js.map

package/dist/agents/deepagents.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class DeepAgents implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=deepagents.d.ts.map

package/dist/agents/deepagents.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class DeepAgents {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "deepagents",
+            args: ["--non-interactive", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        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() {
+        try {
+            execSync("deepagents --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=deepagents.js.map

package/dist/agents/droid.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class DroidAgent implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=droid.d.ts.map

package/dist/agents/droid.js

@@ -0,0 +1,32 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class DroidAgent {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "droid",
+            args: ["exec", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        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() {
+        try {
+            execSync("droid --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=droid.js.map

package/dist/agents/goose.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class GooseAgent implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=goose.d.ts.map

package/dist/agents/goose.js

@@ -0,0 +1,32 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class GooseAgent {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "goose",
+            args: ["run", "--text", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        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() {
+        try {
+            execSync("goose --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=goose.js.map

package/dist/agents/opencode.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class OpenCodeAgent implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=opencode.d.ts.map

package/dist/agents/opencode.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class OpenCodeAgent {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "opencode",
+            args: ["run", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        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() {
+        try {
+            execSync("opencode --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=opencode.js.map

package/dist/agents/openhands.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import type { AgentTool, CommandLine } from "./agent.js";
+export declare class OpenHands implements AgentTool {
+    supportsPermissions: boolean;
+    getPlanGenerationCommandLine(prompt: string): CommandLine;
+    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
+    init(): Promise<boolean>;
+}
+//# sourceMappingURL=openhands.d.ts.map

package/dist/agents/openhands.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class OpenHands {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "openhands",
+            args: ["--headless", "-t", prompt],
+        };
+    }
+    getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
+        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() {
+        try {
+            execSync("openhands --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=openhands.js.map

package/dist/commands/run.js

@@ -33,13 +33,13 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
                 publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
             }, 500);
         }
-        const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, undefined, ctx.task.frontmatter.yolo_mode ? "yolo" : ctx.transientPermissions);
+        const { command, args, stdin, env: agentEnv } = ctx.agent.getTaskRunCommandLine(invokeTask, undefined, ctx.task.frontmatter.yolo_mode ? "yolo" : ctx.transientPermissions);
         const truncate = (s, max = 100) => s.length > max ? s.slice(0, max) + "…" : s;
         const displayArgs = args.map((a) => truncate(a));
         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,