palmier 0.9.20 → 0.9.22

package/README.md

@@ -6,28 +6,26 @@
 
 **Website:** [palmier.me](https://www.palmier.me) | **Web App:** [app.palmier.me](https://app.palmier.me) | **Android App:** [caihongxu/palmier-android](https://github.com/caihongxu/palmier-android)
 
-You already have AI agents running on your machine. Palmier is an agent-agnostic bridge between those agents and your phone.
+**Free AI agents, right from your phone.**
 
-From your phone, you can start sessions, schedule tasks, approve requests, and review results. From your machine, your agents can use phone-side capabilities like notifications, location, SMS, contacts, and calendar — so they can react to the real world, not just the terminal.
+Palmier runs AI agents on your computer using the AI subscriptions you already have, then lets you start or schedule tasks, check progress, and respond to requests from your phone. It also gives your agents access to phone-side capabilities — calendar, contacts, notifications, location, SMS, alarms — so they can react to the real world, not just the terminal.
 
-It runs on your machine as a background daemon and pairs with a mobile-friendly PWA.
+Palmier is free, open source, and requires no account or API key. It runs as a background daemon on your machine and pairs with a mobile-friendly PWA or the Android app (iOS coming soon).
 
-## What Palmier is
+## What Palmier does
 
-Palmier is an **agent-agnostic phone bridge and mobile control layer** for the agents you already use.
+* **Your phone becomes an agent remote** — start, schedule, monitor, and respond to agent tasks without being at your computer. On the same network, the Android app connects over LAN automatically for lower latency.
+* **Agent access to your phone data** — give agents access to your phone's location, calendar, contacts, notifications, and SMS. They can also send email on your behalf, send you push notifications, and ask for your input when needed. (Phone capabilities require the Android app.)
+* **Free with your existing AI subscriptions** — Palmier installs/detects agent CLIs and invokes them, so Claude Pro, Gemini, ChatGPT Plus, and [more](https://www.palmier.me/agents) just work. No extra account, no extra API key.
+* **Task scheduling** — run tasks on a schedule, on demand, or in response to events (e.g. when a push notification arrives), using native OS schedulers (systemd, launchd, Task Scheduler).
+* **You stay in control** — agents can only access phone capabilities you enable; approve requests from your phone, or enable yolo mode to auto-approve.
+* **Your agents, your machine** — agents run on your hardware, not ours. Your data stays on your machine. No account required.
 
 It is not:
 
 * an agent runtime itself
-* a replacement for Claude Code / Codex CLI / Gemini CLI / OpenClaw / Hermes
 * a system for driving your phone UI like a human tapping through apps
 
-Instead, Palmier focuses on:
-
-* letting agents access phone-side capabilities and context in the background
-* letting you talk to, manage, and schedule your agents from your phone
-* making phone integrations work out of the box without requiring users to wire up separate calendar/email/contact stacks
-
 ## Quick Start
 
 1. Install a supported agent CLI — [Claude Code](https://docs.anthropic.com/en/docs/claude-code), [Gemini CLI](https://github.com/google-gemini/gemini-cli), [Codex CLI](https://github.com/openai/codex), [GitHub Copilot](https://github.com/github/gh-copilot), [OpenClaw](https://openclaw.ai/), or [others](https://www.palmier.me/agents).
@@ -53,7 +51,7 @@ Instead, Palmier focuses on:
    ```
    This detects your agents, configures access, installs the background daemon, and starts pairing.
 4. Open `http://localhost:7256` to access the app locally — no pairing needed.
-5. To access from other devices, enter the pairing code shown after init into the [PWA](https://app.palmier.me).
+5. To access from other devices, enter the pairing code shown after init into the [PWA](https://app.palmier.me) or the [Android app](https://github.com/caihongxu/palmier-android/releases/latest/download/palmier.apk).
 
 ### Prerequisites
 
@@ -132,9 +130,11 @@ Three ways to reach your host, ordered by setup effort:
 
 | Mode | Where | Pairing | Notes |
 |------|-------|---------|-------|
-| **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/download/palmier.apk) | Required | Push notifications, device capabilities, and **auto-LAN**. |
+| **Local (browser)** | `http://localhost:7256` in a browser on the host machine | Not required | Loopback only. No internet or Palmier server connection needed. |
+| **PWA** | [https://app.palmier.me](https://app.palmier.me) in any browser | Required | Installable to your home screen; supports web push notifications. Always goes through the cloud relay. |
+| **Android app** | [Android APK](https://github.com/caihongxu/palmier-android/releases/latest/download/palmier.apk) | Required | Unlocks phone capabilities (GPS, email, calendar, contacts, SMS, alarms), push notifications, and **auto-LAN**. |
+
+iOS app coming soon.
 
 **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.
 
@@ -191,10 +191,12 @@ Agents are re-detected on every daemon start; managed-agent versions are re-prob
 
 ### Palmier-managed Agents
 
-An agent is considered **Palmier-managed** if it was installed via `palmier init` (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.
+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.
@@ -209,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/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,166 @@
+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 othersChoice = { label: "Others", hint: "see all supported agents" };
+    const choices = options.allowCancel
+        ? [{ label: "Cancel", hint: "go back" }, ...installChoices, othersChoice]
+        : [...installChoices, othersChoice];
+    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;
+    if (idx === choices.length - 1) {
+        console.log(`\n${bold("More agents:")} ${cyan("https://www.palmier.me/agents")}`);
+        console.log(`Install one with ${cyan("npm install -g <package>")}, then re-run this command.`);
+        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.`)}`);
+    }
+}

package/dist/commands/init.js

@@ -1,17 +1,12 @@
 import * as readline from "readline";
-import { spawnSync } from "child_process";
 import { loadConfig, saveConfig } from "../config.js";
-import { detectAgents, getAgent, getNpmInstalledVersion, listInstallableAgents } from "../agents/agent.js";
+import { detectAgents } from "../agents/agent.js";
+import { colors, pickAndInstallAgent, printInstalledAgents } from "../agents/wizard.js";
 import { getPlatform } from "../platform/index.js";
 import { pairCommand } from "./pair.js";
 import { detectDefaultInterface, getInterfaceIpv4 } from "../network.js";
 import { listTasks } from "../task.js";
-import { selectFromList } from "../prompts.js";
-const bold = (s) => `\x1b[1m${s}\x1b[0m`;
-const dim = (s) => `\x1b[2m${s}\x1b[0m`;
-const green = (s) => `\x1b[32m${s}\x1b[0m`;
-const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
-const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const { bold, dim, green, cyan, red } = colors;
 export async function initCommand() {
     console.log(`\n${bold("=== Palmier Host Setup ===")}\n`);
     console.log(`By continuing, you agree to the ${cyan("Terms of Service")} (https://www.palmier.me/terms)`);
@@ -23,18 +18,26 @@ export async function initCommand() {
     }
     catch { /* first init */ }
     let agents = await detectAgents(previousConfig?.agents);
-    logDetectedAgents(agents);
-    await offerAgentInstall(agents, () => {
-        if (previousConfig) {
-            previousConfig.agents = agents;
-            saveConfig(previousConfig);
-        }
-    });
     if (agents.length === 0) {
-        console.log(`\n${red("No agent CLIs detected.")} Palmier requires at least one supported agent CLI.\n`);
-        console.log(`See supported agents: https://www.palmier.me/agents\n`);
-        console.log(`Install at least one agent CLI, then run ${cyan("palmier init")} again.`);
-        process.exit(1);
+        console.log(`\n${red("No agent CLIs detected.")} Palmier needs at least one to run.`);
+        const installed = await pickAndInstallAgent(agents);
+        if (installed) {
+            agents = [...agents, installed];
+            if (previousConfig) {
+                previousConfig.agents = agents;
+                saveConfig(previousConfig);
+            }
+        }
+        if (agents.length === 0) {
+            console.log(`\nSee supported agents: https://www.palmier.me/agents\n`);
+            console.log(`Install at least one agent CLI, then run ${cyan("palmier init")} again.`);
+            process.exit(1);
+        }
+    }
+    else {
+        console.log(`\n${bold("Installed agents:")}`);
+        printInstalledAgents(agents);
+        console.log(`\n${dim(`Tip: run ${cyan("palmier agents")} to install more or uninstall.\n`)}`);
     }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     const ask = (q) => new Promise((resolve) => rl.question(q, resolve));
@@ -129,109 +132,6 @@ export async function initCommand() {
         throw err;
     }
 }
-async function offerAgentInstall(agents, onAgentInstalled) {
-    while (true) {
-        const detectedKeys = new Set(agents.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)
-            return;
-        const hasAgents = agents.length > 0;
-        const message = hasAgents
-            ? `\n${bold("Install additional agents?")} The following supported agents can be installed:`
-            : `\n${red("No agent CLIs detected.")} Palmier can install one for you via npm:`;
-        const installChoices = missing.map((a) => ({
-            label: a.freeUsage ? `${a.label} ${green(`[${a.freeUsage}]`)}` : a.label,
-            hint: `${a.npmPackage}`,
-        }));
-        const choices = hasAgents
-            ? [{ label: "No — continue to the next step ", hint: "skip installation" }, ...installChoices]
-            : installChoices;
-        const idx = await selectFromList(message, choices);
-        if (idx === null)
-            return;
-        if (hasAgents && idx === 0)
-            return;
-        const choice = missing[hasAgents ? idx - 1 : idx];
-        if (!installAgentPackage(choice))
-            return;
-        console.log(green(`  ${choice.label} installed.`));
-        // Stamp the agent record with version *before* auth so that an interrupted
-        // wizard (Ctrl+C during sign-in, etc.) still leaves the agent recorded as
-        // Palmier-managed in the persisted config on next run.
-        const tool = getAgent(choice.key);
-        const version = getNpmInstalledVersion(choice.npmPackage) ?? undefined;
-        agents.push({
-            key: choice.key,
-            label: choice.label,
-            ...(tool.supportsPermissions ? { supportsPermissions: true } : {}),
-            ...(tool.supportsYolo ? { supportsYolo: true } : {}),
-            npmPackage: choice.npmPackage,
-            ...(version ? { version } : {}),
-        });
-        onAgentInstalled?.();
-        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...");
-    }
-}
-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();
-}
-function logDetectedAgents(agents) {
-    if (agents.length === 0)
-        return;
-    console.log(`  Found: ${green(agents.map((a) => a.version ? `${a.label} v${a.version}` : a.label).join(", "))}`);
-}
-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 init finishes.\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 init finishes.\n`);
-        return;
-    }
-    console.log(green(`Successfully authenticated ${label}.\n`));
-}
-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 ${cyan("palmier init")}.`);
-        }
-        else {
-            console.log(`If this is a permissions error, try running with ${cyan("sudo")} or fix your global npm prefix.`);
-        }
-        return false;
-    }
-    return true;
-}
 async function registerHost(serverUrl, existingHostId) {
     try {
         const res = await fetch(`${serverUrl}/api/hosts/register`, {

package/dist/commands/run.js

@@ -227,8 +227,21 @@ export async function runCommand(taskId) {
             transientPermissions: [],
         };
         if (task.frontmatter.command) {
-            const result = await runCommandTriggeredMode(ctx);
-            const outcome = resolveOutcome(taskDir, result.outcome);
+            let outcome;
+            // Command-triggered tasks auto-restart when the underlying command exits
+            // on its own — only a user abort breaks the loop.
+            while (true) {
+                const result = await runCommandTriggeredMode(ctx);
+                outcome = resolveOutcome(taskDir, result.outcome);
+                if (outcome === "aborted")
+                    break;
+                console.log(`Task ${taskId} command exited (${outcome}); auto-restarting.`);
+                await new Promise((r) => setTimeout(r, 1000));
+                if (resolveOutcome(taskDir, "finished") === "aborted") {
+                    outcome = "aborted";
+                    break;
+                }
+            }
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
             await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
             console.log(`Task ${taskId} completed (command-triggered).`);

package/dist/index.js

@@ -11,6 +11,7 @@ import { serveCommand } from "./commands/serve.js";
 import { pairCommand } from "./commands/pair.js";
 import { restartCommand } from "./commands/restart.js";
 import { clientsListCommand, clientsRevokeCommand, clientsRevokeAllCommand } from "./commands/clients.js";
+import { agentsCommand } from "./commands/agents.js";
 import { uninstallCommand } from "./commands/uninstall.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "../package.json"), "utf-8"));
@@ -76,6 +77,12 @@ clientsCmd
     .action(async () => {
     await clientsRevokeAllCommand();
 });
+program
+    .command("agents")
+    .description("List, install, and uninstall agent CLIs")
+    .action(async () => {
+    await agentsCommand();
+});
 program
     .command("uninstall")
     .description("Stop the daemon and remove all scheduled tasks")