palmier 0.9.15 → 0.9.17

package/README.md

@@ -134,7 +134,7 @@ Three ways to reach your host, ordered by setup effort:
 |------|-------|---------|-------|
 | **Local** | `http://localhost:7256` in a browser on the host machine | Not required | Loopback only. No internet needed. |
 | **Remote (web)** | [https://app.palmier.me](https://app.palmier.me) in any browser | Required | Always goes through the cloud relay. |
-| **Remote (app)** | [Android APK](https://github.com/caihongxu/palmier-android/releases/latest) | Required | Push notifications, device capabilities, and **auto-LAN**. |
+| **Remote (app)** | [Android APK](https://github.com/caihongxu/palmier-android/releases/latest/download/palmier.apk) | Required | Push notifications, device capabilities, and **auto-LAN**. |
 
 **Auto-LAN (native app only).** When the Android app is on the same network as the host, it transparently routes RPC over direct LAN HTTP (`http://<host-ip>:7256/rpc/...`) instead of through the relay — lower latency, no protocol change. Browser PWAs can't do this (Private Network Access / mixed-content restrictions) and stay on the relay.
 

package/dist/agents/agent.d.ts

@@ -1,6 +1,5 @@
 import type { ParsedTask, RequiredPermission } from "../types.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;
@@ -13,27 +12,57 @@ export interface CommandLine {
     }>;
 }
 export interface AgentTool {
-    /** Return the command and args for a short, non-interactive prompt (e.g. generating a task name). */
-    getPromptCommandLine(prompt: string): CommandLine;
+    /** The agent's CLI binary name (e.g. "claude", "kiro-cli"). */
+    command: string;
+    /** Static args for a short, non-interactive prompt. The prompt is appended to the end of this list. */
+    promptCommandLineArgs: string[];
+    /** Single arg passed to `command` to probe whether the CLI is installed. Usually `"--version"`. */
+    versionCommandLineArg: string;
+    /** Whether this agent supports permission overrides (e.g. --allowedTools).
+     *  When falsy, the permissions section is omitted from agent instructions. */
+    supportsPermissions?: boolean;
+    /** Whether this agent supports yolo mode (auto-approve all tools). */
+    supportsYolo?: boolean;
+    /** When true, the run loop will not listen to or persist the agent's stderr output. */
+    suppressStdErr?: boolean;
+    /** npm package that provides this agent's CLI, if installable via `npm install -g`.
+     *  Used by `palmier init` to offer one-click installation when no agents are detected. */
+    npmPackage?: string;
+    /** Optional human-readable note about free-usage availability (e.g. "Free Tier").
+     *  Surfaced next to the agent in the installer. */
+    freeUsage?: string;
     /** Return the command and args used to run a task. If followupPrompt is provided, use it instead of the task's prompt,
      *  and treat it as a continuation of the original run (reuse the same session, etc).
      *  extraPermissions: pass an array of RequiredPermission for transient permissions granted for this run only,
      *  or pass `"yolo"` to enable yolo mode (auto-approve all tools, skip permission instructions). */
     getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
-    /** Whether this agent supports permission overrides (e.g. --allowedTools).
-     *  If false, the permissions section is omitted from agent instructions. */
-    supportsPermissions: boolean;
-    /** Whether this agent supports yolo mode (auto-approve all tools). */
-    supportsYolo: boolean;
-    /** Detect whether the agent CLI is available and perform any agent-specific
-     *  initialization. Returns true if the agent was detected and initialized successfully. */
-    init(): Promise<boolean>;
 }
+export declare function getPromptCommandLine(agent: AgentTool, prompt: string): CommandLine;
+export declare function probeAgent(agent: AgentTool): Promise<boolean>;
+/** Look up the installed version of an npm-managed agent via `npm ls -g --json`.
+ *  Returns the version string, or null if the package isn't reported as installed
+ *  globally. Does not gate on exit code — `npm ls` exits non-zero on extraneous
+ *  deps in the global tree but still prints valid JSON to stdout. */
+export declare function getNpmInstalledVersion(npmPackage: string): string | null;
 export interface DetectedAgent {
     key: string;
     label: string;
-    supportsPermissions: boolean;
-    supportsYolo: boolean;
+    supportsPermissions?: boolean;
+    supportsYolo?: boolean;
+    /** npm package name, present iff the agent is installable via npm. */
+    npmPackage?: string;
+    /** Currently-installed version (resolved via `npm ls -g`) for npm-installed agents. */
+    version?: string;
+    /** True when this agent was installed by Palmier (the init wizard). Persists across detections. */
+    palmierManaged?: boolean;
+}
+export interface InstallableAgent {
+    key: string;
+    label: string;
+    npmPackage: string;
+    command: string;
+    freeUsage?: string;
 }
-export declare function detectAgents(): Promise<DetectedAgent[]>;
+export declare function listInstallableAgents(): InstallableAgent[];
+export declare function detectAgents(previous?: DetectedAgent[]): Promise<DetectedAgent[]>;
 export declare function getAgent(name: string): AgentTool;

package/dist/agents/agent.js

@@ -1,38 +1,77 @@
-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";
-import { Hermes } from "./hermes.js";
+import { execSync } from "child_process";
+import { SHELL } from "../platform/index.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 { deepAgentsAgent } from "./deepagents.js";
+import { aiderAgent } from "./aider.js";
+import { cursorAgent } from "./cursor.js";
+import { kiroAgent } from "./kiro.js";
+import { clineAgent } from "./cline.js";
+import { qoderAgent } from "./qoder.js";
+import { hermesAgent } from "./hermes.js";
+export function getPromptCommandLine(agent, prompt) {
+    return { args: [...agent.promptCommandLineArgs, prompt] };
+}
+export async function probeAgent(agent) {
+    const probe = `${agent.command} ${agent.versionCommandLineArg}`;
+    try {
+        execSync(probe, { stdio: "ignore", shell: SHELL });
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/** Look up the installed version of an npm-managed agent via `npm ls -g --json`.
+ *  Returns the version string, or null if the package isn't reported as installed
+ *  globally. Does not gate on exit code — `npm ls` exits non-zero on extraneous
+ *  deps in the global tree but still prints valid JSON to stdout. */
+export function getNpmInstalledVersion(npmPackage) {
+    const cmd = `npm ls -g ${npmPackage} --depth=0 --json`;
+    let stdout;
+    try {
+        stdout = execSync(cmd, { stdio: ["ignore", "pipe", "ignore"], shell: SHELL, encoding: "utf-8" });
+    }
+    catch (err) {
+        const e = err;
+        if (!e.stdout)
+            return null;
+        stdout = e.stdout.toString();
+    }
+    try {
+        const parsed = JSON.parse(stdout);
+        return parsed.dependencies?.[npmPackage]?.version ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 const agentRegistry = {
-    claude: new ClaudeAgent(),
-    gemini: new GeminiAgent(),
-    codex: new CodexAgent(),
-    openclaw: new OpenClawAgent(),
-    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(),
-    hermes: new Hermes(),
+    claude: claudeAgent,
+    gemini: geminiAgent,
+    codex: codexAgent,
+    openclaw: openClawAgent,
+    copilot: copilotAgent,
+    qwen: qwenAgent,
+    kimi: kimiAgent,
+    droid: droidAgent,
+    goose: gooseAgent,
+    opencode: openCodeAgent,
+    deepagents: deepAgentsAgent,
+    aider: aiderAgent,
+    cursor: cursorAgent,
+    kiro: kiroAgent,
+    cline: clineAgent,
+    qoder: qoderAgent,
+    hermes: hermesAgent,
 };
 const agentLabels = {
     claude: "Claude Code",
@@ -53,13 +92,40 @@ const agentLabels = {
     qoder: "Qoder CLI",
     hermes: "Hermes Agent",
 };
-export async function detectAgents() {
+export function listInstallableAgents() {
+    const out = [];
+    for (const [key, agent] of Object.entries(agentRegistry)) {
+        if (!agent.npmPackage)
+            continue;
+        out.push({
+            key,
+            label: agentLabels[key] ?? key,
+            npmPackage: agent.npmPackage,
+            command: agent.command,
+            ...(agent.freeUsage ? { freeUsage: agent.freeUsage } : {}),
+        });
+    }
+    return out;
+}
+export async function detectAgents(previous) {
+    const previousByKey = new Map((previous ?? []).map((a) => [a.key, a]));
     const detected = [];
     for (const [key, agent] of Object.entries(agentRegistry)) {
         const label = agentLabels[key] ?? key;
-        const ok = await agent.init();
-        if (ok)
-            detected.push({ key, label, supportsPermissions: agent.supportsPermissions, supportsYolo: agent.supportsYolo });
+        const ok = await probeAgent(agent);
+        if (!ok)
+            continue;
+        const version = agent.npmPackage ? getNpmInstalledVersion(agent.npmPackage) ?? undefined : undefined;
+        const prevManaged = previousByKey.get(key)?.palmierManaged;
+        detected.push({
+            key,
+            label,
+            supportsPermissions: agent.supportsPermissions,
+            supportsYolo: agent.supportsYolo,
+            ...(agent.npmPackage ? { npmPackage: agent.npmPackage } : {}),
+            ...(version ? { version } : {}),
+            ...(prevManaged ? { palmierManaged: true } : {}),
+        });
     }
     return detected;
 }

package/dist/agents/aider.d.ts

@@ -1,9 +1,2 @@
-import type { ParsedTask, RequiredPermission } from "../types.js";
-import type { AgentTool, CommandLine } from "./agent.js";
-export declare class Aider implements AgentTool {
-    supportsPermissions: boolean;
-    supportsYolo: boolean;
-    getPromptCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
-    init(): Promise<boolean>;
-}
+import type { AgentTool } from "./agent.js";
+export declare const aiderAgent: AgentTool;

package/dist/agents/aider.js

@@ -1,29 +1,17 @@
-import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
-import { SHELL } from "../platform/index.js";
-export class Aider {
-    supportsPermissions = false;
-    supportsYolo = true;
-    getPromptCommandLine(prompt) {
-        return { command: "aider", args: ["--message", prompt] };
-    }
+export const aiderAgent = {
+    command: "aider",
+    promptCommandLineArgs: ["--message"],
+    versionCommandLineArg: "--version",
+    supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";
-        const prompt = followupPrompt ?? getAgentInstructions(task, yolo || !this.supportsPermissions);
+        const prompt = followupPrompt ?? getAgentInstructions(task);
         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;
-    }
-}
+        return { args };
+    },
+};

package/dist/agents/claude.d.ts

@@ -1,9 +1,2 @@
-import type { ParsedTask, RequiredPermission } from "../types.js";
-import type { AgentTool, CommandLine } from "./agent.js";
-export declare class ClaudeAgent implements AgentTool {
-    supportsPermissions: boolean;
-    supportsYolo: boolean;
-    getPromptCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
-    init(): Promise<boolean>;
-}
+import type { AgentTool } from "./agent.js";
+export declare const claudeAgent: AgentTool;

package/dist/agents/claude.js

@@ -1,15 +1,15 @@
-import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
-import { SHELL } from "../platform/index.js";
-export class ClaudeAgent {
-    supportsPermissions = true;
-    supportsYolo = true;
-    getPromptCommandLine(prompt) {
-        return { command: "claude", args: ["-p", prompt] };
-    }
+export const claudeAgent = {
+    command: "claude",
+    promptCommandLineArgs: ["-p"],
+    versionCommandLineArg: "--version",
+    supportsPermissions: true,
+    supportsYolo: true,
+    npmPackage: "@anthropic-ai/claude-code",
+    freeUsage: "Free with Claude Pro",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";
-        const prompt = followupPrompt ?? getAgentInstructions(task, yolo || !this.supportsPermissions);
+        const prompt = followupPrompt ?? getAgentInstructions(task);
         const args = ["--permission-mode", yolo ? "bypassPermissions" : "acceptEdits", "-p"];
         if (!yolo) {
             args.push("--allowedTools", "Bash(curl)", "WebFetch");
@@ -21,15 +21,6 @@ export class ClaudeAgent {
         if (followupPrompt) {
             args.push("-c");
         }
-        return { command: "claude", args, stdin: prompt };
-    }
-    async init() {
-        try {
-            execSync("claude --version", { stdio: "ignore", shell: SHELL });
-        }
-        catch {
-            return false;
-        }
-        return true;
-    }
-}
+        return { args, stdin: prompt };
+    },
+};

package/dist/agents/cline.d.ts

@@ -1,9 +1,2 @@
-import type { ParsedTask, RequiredPermission } from "../types.js";
-import type { AgentTool, CommandLine } from "./agent.js";
-export declare class Cline implements AgentTool {
-    supportsPermissions: boolean;
-    supportsYolo: boolean;
-    getPromptCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
-    init(): Promise<boolean>;
-}
+import type { AgentTool } from "./agent.js";
+export declare const clineAgent: AgentTool;

package/dist/agents/cline.js

@@ -1,29 +1,18 @@
-import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
-import { SHELL } from "../platform/index.js";
-export class Cline {
-    supportsPermissions = false;
-    supportsYolo = true;
-    getPromptCommandLine(prompt) {
-        return { command: "cline ", args: ["--yolo", "-p", prompt] };
-    }
+export const clineAgent = {
+    command: "cline",
+    promptCommandLineArgs: ["--yolo", "-p"],
+    versionCommandLineArg: "--version",
+    supportsYolo: true,
+    npmPackage: "cline",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";
-        const prompt = followupPrompt ?? getAgentInstructions(task, yolo || !this.supportsPermissions);
+        const prompt = followupPrompt ?? getAgentInstructions(task);
         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;
-    }
-}
+        return { args };
+    },
+};

package/dist/agents/codex.d.ts

@@ -1,9 +1,2 @@
-import type { ParsedTask, RequiredPermission } from "../types.js";
-import type { AgentTool, CommandLine } from "./agent.js";
-export declare class CodexAgent implements AgentTool {
-    supportsPermissions: boolean;
-    supportsYolo: boolean;
-    getPromptCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
-    init(): Promise<boolean>;
-}
+import type { AgentTool } from "./agent.js";
+export declare const codexAgent: AgentTool;

package/dist/agents/codex.js

@@ -1,35 +1,20 @@
-import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
-import { SHELL } from "../platform/index.js";
-export class CodexAgent {
-    supportsPermissions = true;
-    supportsYolo = true;
-    getPromptCommandLine(prompt) {
-        return { command: "codex", args: ["exec", "--skip-git-repo-check", prompt] };
-    }
+export const codexAgent = {
+    command: "codex",
+    promptCommandLineArgs: ["exec", "--skip-git-repo-check"],
+    versionCommandLineArg: "--version",
+    supportsYolo: true,
+    suppressStdErr: true,
+    npmPackage: "@openai/codex",
+    freeUsage: "Free Tier",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";
-        const prompt = followupPrompt ?? getAgentInstructions(task, yolo || !this.supportsPermissions);
+        const prompt = followupPrompt ?? getAgentInstructions(task);
         const args = ["exec", "--skip-git-repo-check", "--sandbox", yolo ? "danger-full-access" : "workspace-write"];
-        if (!yolo) {
-            const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
-            for (const p of allPerms) {
-                args.push("--config", `apps.${p.name}.default_tools_approval_mode="approve"`);
-            }
-        }
         if (followupPrompt) {
             args.push("resume", "--last");
         }
         args.push("-");
-        return { command: "codex", args, stdin: prompt };
-    }
-    async init() {
-        try {
-            execSync("codex --version", { stdio: "ignore", shell: SHELL });
-        }
-        catch {
-            return false;
-        }
-        return true;
-    }
-}
+        return { args, stdin: prompt, env: { RUST_LOG: "warn" } };
+    },
+};

package/dist/agents/copilot.d.ts

@@ -1,9 +1,2 @@
-import type { ParsedTask, RequiredPermission } from "../types.js";
-import type { AgentTool, CommandLine } from "./agent.js";
-export declare class CopilotAgent implements AgentTool {
-    supportsPermissions: boolean;
-    supportsYolo: boolean;
-    getPromptCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
-    init(): Promise<boolean>;
-}
+import type { AgentTool } from "./agent.js";
+export declare const copilotAgent: AgentTool;

package/dist/agents/copilot.js

@@ -1,15 +1,15 @@
-import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
-import { SHELL } from "../platform/index.js";
-export class CopilotAgent {
-    supportsPermissions = false;
-    supportsYolo = true;
-    getPromptCommandLine(prompt) {
-        return { command: "copilot", args: ["-p", prompt] };
-    }
+export const copilotAgent = {
+    command: "copilot",
+    promptCommandLineArgs: ["-p"],
+    versionCommandLineArg: "-v",
+    supportsYolo: true,
+    suppressStdErr: true,
+    npmPackage: "@github/copilot",
+    freeUsage: "Free Tier",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";
-        const prompt = followupPrompt ?? getAgentInstructions(task, yolo || !this.supportsPermissions);
+        const prompt = followupPrompt ?? getAgentInstructions(task);
         const args = ["-p", prompt];
         if (yolo) {
             args.push("--yolo");
@@ -21,15 +21,6 @@ export class CopilotAgent {
         if (followupPrompt) {
             args.push("--continue");
         }
-        return { command: "copilot", args };
-    }
-    async init() {
-        try {
-            execSync("copilot -v", { stdio: "ignore", shell: SHELL });
-        }
-        catch {
-            return false;
-        }
-        return true;
-    }
-}
+        return { args };
+    },
+};

package/dist/agents/cursor.d.ts

@@ -1,9 +1,2 @@
-import type { ParsedTask, RequiredPermission } from "../types.js";
-import type { AgentTool, CommandLine } from "./agent.js";
-export declare class Cursor implements AgentTool {
-    supportsPermissions: boolean;
-    supportsYolo: boolean;
-    getPromptCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
-    init(): Promise<boolean>;
-}
+import type { AgentTool } from "./agent.js";
+export declare const cursorAgent: AgentTool;

package/dist/agents/cursor.js

@@ -1,15 +1,12 @@
-import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
-import { SHELL } from "../platform/index.js";
-export class Cursor {
-    supportsPermissions = false;
-    supportsYolo = true;
-    getPromptCommandLine(prompt) {
-        return { command: "cursor", args: ["-p", prompt] };
-    }
+export const cursorAgent = {
+    command: "cursor",
+    promptCommandLineArgs: ["-p"],
+    versionCommandLineArg: "--version",
+    supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";
-        const prompt = followupPrompt ?? getAgentInstructions(task, yolo || !this.supportsPermissions);
+        const prompt = followupPrompt ?? getAgentInstructions(task);
         const args = [];
         if (yolo) {
             args.push("--force");
@@ -18,15 +15,6 @@ export class Cursor {
             args.push("--continue");
         }
         args.push("-p", prompt);
-        return { command: "cursor", args };
-    }
-    async init() {
-        try {
-            execSync("cursor --version", { stdio: "ignore", shell: SHELL });
-        }
-        catch {
-            return false;
-        }
-        return true;
-    }
-}
+        return { args };
+    },
+};

package/dist/agents/deepagents.d.ts

@@ -1,9 +1,2 @@
-import type { ParsedTask, RequiredPermission } from "../types.js";
-import type { AgentTool, CommandLine } from "./agent.js";
-export declare class DeepAgents implements AgentTool {
-    supportsPermissions: boolean;
-    supportsYolo: boolean;
-    getPromptCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
-    init(): Promise<boolean>;
-}
+import type { AgentTool } from "./agent.js";
+export declare const deepAgentsAgent: AgentTool;

package/dist/agents/deepagents.js

@@ -1,15 +1,12 @@
-import { execSync } from "child_process";
 import { getAgentInstructions } from "./shared-prompt.js";
-import { SHELL } from "../platform/index.js";
-export class DeepAgents {
-    supportsPermissions = false;
-    supportsYolo = true;
-    getPromptCommandLine(prompt) {
-        return { command: "deepagents", args: ["--non-interactive", prompt] };
-    }
+export const deepAgentsAgent = {
+    command: "deepagents",
+    promptCommandLineArgs: ["--non-interactive"],
+    versionCommandLineArg: "--version",
+    supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";
-        const prompt = followupPrompt ?? getAgentInstructions(task, yolo || !this.supportsPermissions);
+        const prompt = followupPrompt ?? getAgentInstructions(task);
         const args = [];
         if (yolo) {
             args.push("--auto-approve");
@@ -18,15 +15,6 @@ export class DeepAgents {
             args.push("--resume");
         }
         args.push("--non-interactive", prompt);
-        return { command: "deepagents", args };
-    }
-    async init() {
-        try {
-            execSync("deepagents --version", { stdio: "ignore", shell: SHELL });
-        }
-        catch {
-            return false;
-        }
-        return true;
-    }
-}
+        return { args };
+    },
+};

package/dist/agents/droid.d.ts

@@ -1,9 +1,2 @@
-import type { ParsedTask, RequiredPermission } from "../types.js";
-import type { AgentTool, CommandLine } from "./agent.js";
-export declare class DroidAgent implements AgentTool {
-    supportsPermissions: boolean;
-    supportsYolo: boolean;
-    getPromptCommandLine(prompt: string): CommandLine;
-    getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine;
-    init(): Promise<boolean>;
-}
+import type { AgentTool } from "./agent.js";
+export declare const droidAgent: AgentTool;