palmier 0.6.1 → 0.6.3

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,19 @@
 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 { Cursor } from "./cursor.js";
+import { Kiro } from "./kiro.js";
+import { Cline } from "./cline.js";
+import { Qoder } from "./qoder.js";
 const agentRegistry = {
     claude: new ClaudeAgent(),
     gemini: new GeminiAgent(),
@@ -13,15 +22,33 @@ 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(),
+    cursor: new Cursor(),
+    kiro: new Kiro(),
+    cline: new Cline(),
+    qoder: new Qoder(),
 };
 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",
+    cursor: "Cursor CLI",
+    kiro: "Kiro",
+    cline: "Cline",
+    qoder: "Qoder",
 };
 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/cline.d.ts

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

package/dist/agents/cline.js

@@ -0,0 +1,32 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class Cline {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "cline ",
+            args: ["--yolo", "-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("--yolo");
+        }
+        args.push(prompt);
+        return { command: "cline ", args };
+    }
+    async init() {
+        try {
+            execSync("cline --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=cline.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/kiro.d.ts

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

package/dist/agents/kiro.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class Kiro {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "kiro-cli",
+            args: ["--no-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("--trust-all-tools");
+        }
+        if (followupPrompt) {
+            args.push("--resume");
+        } // continue mode for followups
+        args.push("--no-interactive", prompt);
+        return { command: "kiro-cli", args };
+    }
+    async init() {
+        try {
+            execSync("kiro-cli --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=kiro.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/qoder.d.ts

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

package/dist/agents/qoder.js

@@ -0,0 +1,35 @@
+import { execSync } from "child_process";
+import { getAgentInstructions } from "./shared-prompt.js";
+import { SHELL } from "../platform/index.js";
+export class Qoder {
+    supportsPermissions = false;
+    getPlanGenerationCommandLine(prompt) {
+        return {
+            command: "qodercli",
+            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("--yolo");
+        }
+        if (followupPrompt) {
+            args.push("-c");
+        } // continue mode for followups
+        args.push("-p", prompt);
+        return { command: "qodercli", args };
+    }
+    async init() {
+        try {
+            execSync("qodercli --version", { stdio: "ignore", shell: SHELL });
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=qoder.js.map

package/dist/commands/plan-generation.md

@@ -15,7 +15,7 @@ task_name: <concise label, 3-6 words>
 - Write a numbered sequence of concrete, actionable steps.
 - If the task produces formatted output (report, email, summary, etc.), specify the structure, sections, and tone.
 - When a step requires user input, simply state what information is needed from the user. Do not specify how to obtain it — the agent has its own tool for requesting user input.
-- Relative times in the task description (e.g., "yesterday", "last week") refer to execution time, not plan generation time.
+- Relative times in the task description (e.g., "today", "yesterday", "last week") refer to execution time, not plan generation time. Keep them as-is in the plan — do not convert them to specific dates.
 
 ## Task Description
 

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,