palmier 0.9.19 → 0.9.21

package/README.md

@@ -67,7 +67,7 @@ Palmier runs as a background daemon (systemd on Linux, launchd on macOS, Task Sc
 
 ### MCP Server
 
-Palmier exposes an [MCP](https://modelcontextprotocol.io) server at `http://localhost:7256/mcp` (streamable HTTP transport). MCP-capable agents can register it to get tool and resource definitions automatically. The same tools and resources are also available as REST endpoints for curl-based agents.
+Palmier exposes an [MCP](https://modelcontextprotocol.io) server at `http://localhost:7256/mcp` (streamable HTTP transport). MCP-capable agents can register it to get tool and resource definitions automatically. The same tools and resources are also readily available if running agent tasks directly from Palmier app, without installing the MCP server.
 
 **MCP server URL:** `http://localhost:7256/mcp`
 
@@ -174,19 +174,33 @@ Revoking the linked device also clears the host's linked-device record; device c
 ### The `init` Command
 
 The wizard:
-- Detects installed agent CLIs and caches the result
+- Detects installed agent CLIs and caches the result; agents previously installed by Palmier have their installed version re-probed so the recorded version stays in sync with manual upgrades
+- Offers to install missing supported agents from npm (one at a time, arrow-key menu). After each install the agent's version is stamped (becoming "Palmier-managed"), the wizard kicks off authentication, and waits for you to press Enter before offering the next install. On re-init, the agents list is saved after every install so an interrupted wizard is resumable.
 - Asks for the HTTP port
 - Detects the default network interface (used for auto-LAN)
 - Shows a summary (including any existing scheduled tasks to recover) and asks for confirmation
 - Registers with the Palmier server, saves configuration to `~/.config/palmier/host.json`
-- Installs a background daemon (systemd user service on Linux, LaunchAgent on macOS, Task Scheduler on Windows)
+- Installs a background daemon (systemd user service on Linux, LaunchAgent on macOS, Task Scheduler on Windows). On re-init, also restarts the daemon so the running process picks up the new agents/versions for `host.info`.
 - Auto-enters pair mode to connect your first device
 
 The daemon automatically recovers existing tasks by reinstalling their system timers on startup.
 
 > **macOS note:** Palmier installs as a user-level LaunchAgent, so it runs without `sudo`. LaunchAgents only run while the user is logged into the GUI session — after a reboot, scheduled tasks stay dormant until you log in at least once. Enable auto-login in System Settings → Users & Groups if you need unattended operation across reboots.
 
-Agents are re-detected on every daemon start. Run `palmier restart` after installing or removing a CLI.
+Agents are re-detected on every daemon start; managed-agent versions are re-probed live so upgrades performed outside the wizard show up automatically.
+
+### Palmier-managed Agents
+
+An agent is considered **Palmier-managed** if it was installed via `palmier init`, `palmier agents`, or its update is initiated via the PWA. Palmier-managed agents have a known installed version stamped at install/update time; that version is what the PWA uses to drive the agent soft-update dialog and what's recorded into each session's run metadata so a session always shows the agent version it actually ran with — even after the live agent is upgraded.
+
+Agents installed by the user outside the wizard (e.g., `npm install -g <pkg>` directly) are detected and usable but are **not** considered Palmier-managed. The PWA shows them under a separate "Version not managed by Palmier" section and does not offer auto-update for them.
+
+Run `palmier agents` to manage agent CLIs after setup: it lists installed agents and offers an interactive picker to install or uninstall one. `palmier init` only prompts for an agent install when none are detected; once any agent is installed, init just lists them and continues with host registration.
+
+### Updates
+
+- **Palmier itself** — when a newer version of `palmier` is published to npm, the PWA shows a dismissible "Update Available" dialog. Clicking "Update Now" runs `npm update -g palmier` on the host and restarts the daemon. Clicking "Dismiss" suppresses the dialog for that exact version (per host, per device); a future release re-arms it.
+- **Palmier-managed agents** — same flow per agent: when npm publishes a newer version, the PWA shows an "Agent Update Available" dialog. Clicking "Update Now" runs `npm update -g <pkg>` on the host (no daemon restart needed). Dismissals are per host, per agent, per version.
 
 ### Re-detecting the LAN Network
 
@@ -197,6 +211,7 @@ The default network interface is detected once during `palmier init` and saved t
 | Command | Description |
 |---|---|
 | `palmier init` | Interactive setup wizard |
+| `palmier agents` | List, install, and uninstall agent CLIs |
 | `palmier pair` | Generate a pairing code to pair a new device |
 | `palmier clients list` | List active client tokens |
 | `palmier clients revoke <token>` | Revoke a specific client token |

package/dist/agents/agent.d.ts

@@ -12,12 +12,19 @@ export interface CommandLine {
     }>;
 }
 export interface AgentTool {
+    /** Human-readable name shown in the PWA and CLI (e.g. "Claude Code"). */
+    label: string;
     /** 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[];
+    promptArgs: string[];
     /** Single arg passed to `command` to probe whether the CLI is installed. Usually `"--version"`. */
-    versionCommandLineArg: string;
+    probeArg: string;
+    /** Optional args to launch the agent's auth flow after a successful install. When set,
+     *  `palmier init` runs `<command> <args...>` interactively (stdio: "inherit") so the user
+     *  can sign in before configuration continues. Leave undefined for agents that auth on
+     *  first run with no separate command. */
+    authArgs?: string[];
     /** Whether this agent supports permission overrides (e.g. --allowedTools).
      *  When falsy, the permissions section is omitted from agent instructions. */
     supportsPermissions?: boolean;
@@ -59,5 +66,12 @@ export interface InstallableAgent {
     freeUsage?: string;
 }
 export declare function listInstallableAgents(): InstallableAgent[];
-export declare function detectAgents(previous?: DetectedAgent[]): Promise<DetectedAgent[]>;
+/** Detect agents present on PATH and resolve their version when they are
+ *  Palmier-managed. An agent is treated as managed if either:
+ *  - it had a `version` in the `previous` list (preserved across daemon restarts), or
+ *  - its key is in `newlyInstalled` (e.g. just installed by the wizard this session).
+ *
+ *  Every managed agent has its version probed live via `npm ls -g`, so manual
+ *  upgrades outside Palmier are picked up on the next detection. */
+export declare function detectAgents(previous?: DetectedAgent[], newlyInstalled?: Set<string>): Promise<DetectedAgent[]>;
 export declare function getAgent(name: string): AgentTool;

package/dist/agents/agent.js

@@ -18,10 +18,10 @@ 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] };
+    return { args: [...agent.promptArgs, prompt] };
 }
 export async function probeAgent(agent) {
-    const probe = `${agent.command} ${agent.versionCommandLineArg}`;
+    const probe = `${agent.command} ${agent.probeArg}`;
     try {
         execSync(probe, { stdio: "ignore", shell: SHELL });
     }
@@ -73,25 +73,6 @@ const agentRegistry = {
     qoder: qoderAgent,
     hermes: hermesAgent,
 };
-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 CLI",
-    cline: "Cline CLI",
-    qoder: "Qoder CLI",
-    hermes: "Hermes Agent",
-};
 export function listInstallableAgents() {
     const out = [];
     for (const [key, agent] of Object.entries(agentRegistry)) {
@@ -99,7 +80,7 @@ export function listInstallableAgents() {
             continue;
         out.push({
             key,
-            label: agentLabels[key] ?? key,
+            label: agent.label,
             npmPackage: agent.npmPackage,
             command: agent.command,
             ...(agent.freeUsage ? { freeUsage: agent.freeUsage } : {}),
@@ -107,22 +88,31 @@ export function listInstallableAgents() {
     }
     return out;
 }
-export async function detectAgents(previous) {
+/** Detect agents present on PATH and resolve their version when they are
+ *  Palmier-managed. An agent is treated as managed if either:
+ *  - it had a `version` in the `previous` list (preserved across daemon restarts), or
+ *  - its key is in `newlyInstalled` (e.g. just installed by the wizard this session).
+ *
+ *  Every managed agent has its version probed live via `npm ls -g`, so manual
+ *  upgrades outside Palmier are picked up on the next detection. */
+export async function detectAgents(previous, newlyInstalled) {
     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 probeAgent(agent);
         if (!ok)
             continue;
-        const prevVersion = previousByKey.get(key)?.version;
+        const wasManaged = !!previousByKey.get(key)?.version || (newlyInstalled?.has(key) ?? false);
+        const version = wasManaged && agent.npmPackage
+            ? getNpmInstalledVersion(agent.npmPackage) ?? undefined
+            : undefined;
         detected.push({
             key,
-            label,
+            label: agent.label,
             supportsPermissions: agent.supportsPermissions,
             supportsYolo: agent.supportsYolo,
             ...(agent.npmPackage ? { npmPackage: agent.npmPackage } : {}),
-            ...(prevVersion ? { version: prevVersion } : {}),
+            ...(version ? { version } : {}),
         });
     }
     return detected;

package/dist/agents/aider.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const aiderAgent = {
+    label: "Aider",
     command: "aider",
-    promptCommandLineArgs: ["--message"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["--message"],
+    probeArg: "--version",
     supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";

package/dist/agents/claude.js

@@ -1,8 +1,10 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const claudeAgent = {
+    label: "Claude Code",
     command: "claude",
-    promptCommandLineArgs: ["-p"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["-p"],
+    probeArg: "--version",
+    authArgs: ["auth", "login"],
     supportsPermissions: true,
     supportsYolo: true,
     npmPackage: "@anthropic-ai/claude-code",

package/dist/agents/cline.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const clineAgent = {
+    label: "Cline CLI",
     command: "cline",
-    promptCommandLineArgs: ["--yolo", "-p"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["--yolo", "-p"],
+    probeArg: "--version",
     supportsYolo: true,
     npmPackage: "cline",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {

package/dist/agents/codex.js

@@ -1,8 +1,10 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const codexAgent = {
+    label: "Codex CLI",
     command: "codex",
-    promptCommandLineArgs: ["exec", "--skip-git-repo-check"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["exec", "--skip-git-repo-check"],
+    probeArg: "--version",
+    authArgs: ["login"],
     supportsYolo: true,
     suppressStdErr: true,
     npmPackage: "@openai/codex",

package/dist/agents/copilot.js

@@ -1,8 +1,10 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const copilotAgent = {
+    label: "Copilot CLI",
     command: "copilot",
-    promptCommandLineArgs: ["-p"],
-    versionCommandLineArg: "-v",
+    promptArgs: ["-p"],
+    probeArg: "-v",
+    authArgs: ["login"],
     supportsYolo: true,
     suppressStdErr: true,
     npmPackage: "@github/copilot",

package/dist/agents/cursor.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const cursorAgent = {
+    label: "Cursor CLI",
     command: "cursor",
-    promptCommandLineArgs: ["-p"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["-p"],
+    probeArg: "--version",
     supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";

package/dist/agents/deepagents.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const deepAgentsAgent = {
+    label: "Deep Agents CLI",
     command: "deepagents",
-    promptCommandLineArgs: ["--non-interactive"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["--non-interactive"],
+    probeArg: "--version",
     supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";

package/dist/agents/droid.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const droidAgent = {
+    label: "Droid CLI",
     command: "droid",
-    promptCommandLineArgs: ["exec"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["exec"],
+    probeArg: "--version",
     supportsYolo: true,
     npmPackage: "@factory/cli",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {

package/dist/agents/gemini.js

@@ -16,9 +16,10 @@ export function renderPolicyToml(allowedTools) {
     ].join("\n");
 }
 export const geminiAgent = {
+    label: "Gemini CLI",
     command: "gemini",
-    promptCommandLineArgs: ["--prompt"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["--prompt"],
+    probeArg: "--version",
     supportsPermissions: true,
     supportsYolo: true,
     npmPackage: "@google/gemini-cli",

package/dist/agents/goose.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const gooseAgent = {
+    label: "Goose CLI",
     command: "goose",
-    promptCommandLineArgs: ["run", "--text"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["run", "--text"],
+    probeArg: "--version",
     supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";

package/dist/agents/hermes.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const hermesAgent = {
+    label: "Hermes Agent",
     command: "hermes",
-    promptCommandLineArgs: ["chat", "-q"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["chat", "-q"],
+    probeArg: "--version",
     supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";

package/dist/agents/kimi.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const kimiAgent = {
+    label: "Kimi Code",
     command: "kimi",
-    promptCommandLineArgs: ["-p"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["-p"],
+    probeArg: "--version",
     supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";

package/dist/agents/kiro.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const kiroAgent = {
+    label: "Kiro CLI",
     command: "kiro-cli",
-    promptCommandLineArgs: ["--no-interactive"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["--no-interactive"],
+    probeArg: "--version",
     supportsYolo: true,
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const yolo = extraPermissions === "yolo";

package/dist/agents/openclaw.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const openClawAgent = {
+    label: "OpenClaw",
     command: "openclaw",
-    promptCommandLineArgs: ["agent", "--local", "--agent", "main", "--message"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["agent", "--local", "--agent", "main", "--message"],
+    probeArg: "--version",
     npmPackage: "openclaw",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {
         const prompt = followupPrompt ?? getAgentInstructions(task);

package/dist/agents/opencode.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const openCodeAgent = {
+    label: "OpenCode",
     command: "opencode",
-    promptCommandLineArgs: ["run"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["run"],
+    probeArg: "--version",
     supportsYolo: true,
     npmPackage: "opencode-ai",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {

package/dist/agents/qoder.js

@@ -1,8 +1,9 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const qoderAgent = {
+    label: "Qoder CLI",
     command: "qodercli",
-    promptCommandLineArgs: ["-p"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["-p"],
+    probeArg: "--version",
     supportsYolo: true,
     npmPackage: "@qoder-ai/qodercli",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {

package/dist/agents/qwen.js

@@ -1,8 +1,10 @@
 import { getAgentInstructions } from "./shared-prompt.js";
 export const qwenAgent = {
+    label: "Qwen Code",
     command: "qwen",
-    promptCommandLineArgs: ["-p"],
-    versionCommandLineArg: "--version",
+    promptArgs: ["-p"],
+    probeArg: "--version",
+    authArgs: ["auth", "qwen-oauth"],
     supportsYolo: true,
     npmPackage: "@qwen-code/qwen-code",
     getTaskRunCommandLine(task, followupPrompt, extraPermissions) {

package/dist/agents/wizard.d.ts

@@ -0,0 +1,23 @@
+import { type DetectedAgent } from "./agent.js";
+export declare const colors: {
+    bold: (s: string) => string;
+    dim: (s: string) => string;
+    green: (s: string) => string;
+    cyan: (s: string) => string;
+    red: (s: string) => string;
+    yellow: (s: string) => string;
+};
+export declare function printInstalledAgents(agents: DetectedAgent[]): void;
+export interface InstallPickerOptions {
+    /** Show a "Cancel" entry as the first choice. */
+    allowCancel?: boolean;
+    /** Override the picker prompt message. */
+    message?: string;
+}
+/** Show the install picker and run the npm install + auth flow for the chosen
+ *  agent. Returns the new DetectedAgent record on success, or null if the user
+ *  cancelled, no installables remain, or the install failed. */
+export declare function pickAndInstallAgent(current: DetectedAgent[], options?: InstallPickerOptions): Promise<DetectedAgent | null>;
+/** Show the uninstall picker. Runs `npm uninstall -g` for the chosen agent
+ *  and returns the agent key on success, or null on cancel/failure/no candidates. */
+export declare function pickAndUninstallAgent(current: DetectedAgent[]): Promise<string | null>;

package/dist/agents/wizard.js

@@ -0,0 +1,160 @@
+import { spawnSync } from "child_process";
+import * as readline from "readline";
+import { selectFromList } from "../prompts.js";
+import { getAgent, getNpmInstalledVersion, listInstallableAgents, } from "./agent.js";
+export const colors = {
+    bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    dim: (s) => `\x1b[2m${s}\x1b[0m`,
+    green: (s) => `\x1b[32m${s}\x1b[0m`,
+    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+    red: (s) => `\x1b[31m${s}\x1b[0m`,
+    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+};
+const { bold, dim, green, cyan, red } = colors;
+export function printInstalledAgents(agents) {
+    if (agents.length === 0) {
+        console.log(`  ${dim("(none installed)")}`);
+        return;
+    }
+    for (const a of agents) {
+        const version = a.version ? ` ${dim(`v${a.version}`)}` : "";
+        const note = a.version ? "" : ` ${dim("(not managed by Palmier)")}`;
+        console.log(`  ${green("✓")} ${a.label}${version}${note}`);
+    }
+}
+/** Show the install picker and run the npm install + auth flow for the chosen
+ *  agent. Returns the new DetectedAgent record on success, or null if the user
+ *  cancelled, no installables remain, or the install failed. */
+export async function pickAndInstallAgent(current, options = {}) {
+    const detectedKeys = new Set(current.map((a) => a.key));
+    const missing = listInstallableAgents()
+        .filter((a) => !detectedKeys.has(a.key))
+        .sort((a, b) => a.label.localeCompare(b.label));
+    if (missing.length === 0) {
+        console.log(`\n${dim("All supported agents are already installed.")}`);
+        return null;
+    }
+    const installChoices = missing.map((a) => ({
+        label: a.freeUsage ? `${a.label} ${green(`[${a.freeUsage}]`)}` : a.label,
+        hint: a.npmPackage,
+    }));
+    const choices = options.allowCancel
+        ? [{ label: "Cancel", hint: "go back" }, ...installChoices]
+        : installChoices;
+    const message = options.message ?? `\n${bold("Select an agent to install:")}`;
+    const idx = await selectFromList(message, choices);
+    if (idx === null)
+        return null;
+    if (options.allowCancel && idx === 0)
+        return null;
+    const choice = missing[options.allowCancel ? idx - 1 : idx];
+    if (!installAgentPackage(choice))
+        return null;
+    console.log(green(`  ${choice.label} installed.`));
+    const tool = getAgent(choice.key);
+    const version = getNpmInstalledVersion(choice.npmPackage) ?? undefined;
+    const record = {
+        key: choice.key,
+        label: choice.label,
+        ...(tool.supportsPermissions ? { supportsPermissions: true } : {}),
+        ...(tool.supportsYolo ? { supportsYolo: true } : {}),
+        npmPackage: choice.npmPackage,
+        ...(version ? { version } : {}),
+    };
+    if (tool.authArgs && tool.authArgs.length > 0) {
+        runAgentAuthFlow(choice.label, tool.command, tool.authArgs);
+    }
+    else {
+        console.log(`\n${bold("Next: authenticate the CLI.")}`);
+        console.log(`  Run ${cyan(choice.command)} in another terminal and follow the sign-in prompts.`);
+        console.log(`  Palmier will use the CLI on your behalf once it's signed in.`);
+    }
+    await waitForEnter("Press Enter once authentication is complete...");
+    return record;
+}
+/** Show the uninstall picker. Runs `npm uninstall -g` for the chosen agent
+ *  and returns the agent key on success, or null on cancel/failure/no candidates. */
+export async function pickAndUninstallAgent(current) {
+    const uninstallable = current.filter((a) => a.npmPackage);
+    if (uninstallable.length === 0) {
+        console.log(`\n${dim("No agents available to uninstall.")}`);
+        return null;
+    }
+    const choices = [
+        { label: "Cancel", hint: "go back" },
+        ...uninstallable.map((a) => ({
+            label: a.label,
+            hint: a.npmPackage,
+        })),
+    ];
+    const idx = await selectFromList(`\n${bold("Select an agent to uninstall:")}`, choices);
+    if (idx === null || idx === 0)
+        return null;
+    const target = uninstallable[idx - 1];
+    if (!target.npmPackage)
+        return null;
+    if (!uninstallAgentPackage(target.npmPackage))
+        return null;
+    console.log(green(`  ${target.label} uninstalled.`));
+    return target.key;
+}
+function installAgentPackage(agent) {
+    console.log(`\nInstalling ${cyan(agent.npmPackage)}...\n`);
+    const cmd = `npm install -g ${agent.npmPackage}`;
+    const result = spawnSync(cmd, { shell: true, stdio: "inherit" });
+    if (result.error) {
+        console.log(`\n${red(`Failed to run npm: ${result.error.message}`)}`);
+        console.log(`Make sure ${cyan("npm")} is on your PATH, then retry.`);
+        return false;
+    }
+    if (result.status !== 0) {
+        const exitInfo = result.signal ? `signal ${result.signal}` : `exit ${result.status}`;
+        console.log(`\n${red(`${cmd} failed (${exitInfo}).`)}`);
+        if (process.platform === "win32") {
+            console.log(`If this is a permissions error, try opening a terminal as Administrator and re-running.`);
+        }
+        else {
+            console.log(`If this is a permissions error, try running with ${cyan("sudo")} or fix your global npm prefix.`);
+        }
+        return false;
+    }
+    return true;
+}
+function uninstallAgentPackage(npmPackage) {
+    console.log(`\nUninstalling ${cyan(npmPackage)}...\n`);
+    const cmd = `npm uninstall -g ${npmPackage}`;
+    const result = spawnSync(cmd, { shell: true, stdio: "inherit" });
+    if (result.error) {
+        console.log(`\n${red(`Failed to run npm: ${result.error.message}`)}`);
+        return false;
+    }
+    if (result.status !== 0) {
+        const exitInfo = result.signal ? `signal ${result.signal}` : `exit ${result.status}`;
+        console.log(`\n${red(`${cmd} failed (${exitInfo}).`)}`);
+        return false;
+    }
+    return true;
+}
+function runAgentAuthFlow(label, command, args) {
+    const cmd = `${command} ${args.join(" ")}`;
+    console.log(`\n${bold(`Authenticating ${label}...`)} ${dim(`(${cmd})`)}\n`);
+    const result = spawnSync(cmd, { shell: true, stdio: "inherit" });
+    console.log("");
+    if (result.error) {
+        console.log(red(`Auth failed: could not run ${cmd} — ${result.error.message}`));
+        console.log(`Re-run ${cyan(cmd)} manually after this.\n`);
+        return;
+    }
+    if (result.status !== 0) {
+        const exitInfo = result.signal ? `signal ${result.signal}` : `exit ${result.status}`;
+        console.log(red(`Auth failed (${exitInfo}).`));
+        console.log(`Re-run ${cyan(cmd)} manually after this.\n`);
+        return;
+    }
+    console.log(green(`Successfully authenticated ${label}.\n`));
+}
+async function waitForEnter(message) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    await new Promise((resolve) => rl.question(`\n${dim(message)} `, resolve));
+    rl.close();
+}

package/dist/commands/agents.d.ts

@@ -0,0 +1 @@
+export declare function agentsCommand(): Promise<void>;

package/dist/commands/agents.js

@@ -0,0 +1,59 @@
+import { loadConfig, saveConfig } from "../config.js";
+import { detectAgents } from "../agents/agent.js";
+import { colors, pickAndInstallAgent, pickAndUninstallAgent, printInstalledAgents, } from "../agents/wizard.js";
+import { selectFromList } from "../prompts.js";
+import { getPlatform } from "../platform/index.js";
+const { bold, dim, cyan } = colors;
+export async function agentsCommand() {
+    let config = null;
+    try {
+        config = loadConfig();
+    }
+    catch { /* host not yet initialized */ }
+    let agents = await detectAgents(config?.agents);
+    let dirty = false;
+    while (true) {
+        console.log(`\n${bold("=== Installed agents ===")}\n`);
+        printInstalledAgents(agents);
+        const idx = await selectFromList(`\n${bold("What would you like to do?")}`, [
+            { label: "Install an agent", hint: "add a supported CLI" },
+            { label: "Uninstall an agent", hint: "remove a supported CLI" },
+            { label: "Done", hint: "exit" },
+        ]);
+        if (idx === null || idx === 2)
+            break;
+        if (idx === 0) {
+            const installed = await pickAndInstallAgent(agents, { allowCancel: true });
+            if (installed) {
+                agents = [...agents.filter((a) => a.key !== installed.key), installed];
+                dirty = true;
+            }
+        }
+        else if (idx === 1) {
+            const removedKey = await pickAndUninstallAgent(agents);
+            if (removedKey) {
+                agents = agents.filter((a) => a.key !== removedKey);
+                dirty = true;
+            }
+        }
+        agents = await detectAgents(agents);
+    }
+    if (!dirty)
+        return;
+    if (config) {
+        config.agents = agents;
+        saveConfig(config);
+        console.log(`\nConfig saved to ${dim("~/.config/palmier/host.json")}`);
+        try {
+            await getPlatform().restartDaemon();
+            console.log(dim("Daemon restarted."));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.log(dim(`(Daemon restart skipped: ${message})`));
+        }
+    }
+    else {
+        console.log(`\n${dim(`Run ${cyan("palmier init")} to register this host with the new agent set.`)}`);
+    }
+}