palmier 0.2.5 → 0.2.7

package/dist/transports/http-transport.js

@@ -1,6 +1,79 @@
 import * as http from "node:http";
 import * as os from "os";
 import { validateSession, addSession } from "../session-store.js";
+const PWA_ORIGIN = "https://app.palmier.me";
+const CONTENT_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".ico": "image/x-icon",
+    ".woff2": "font/woff2",
+    ".woff": "font/woff",
+    ".svg": "image/svg+xml",
+};
+function guessContentType(urlPath) {
+    const ext = urlPath.match(/\.[^.]+$/)?.[0] ?? "";
+    return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+async function fetchBuffer(url) {
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`${res.status} ${res.statusText} for ${url}`);
+    return Buffer.from(await res.arrayBuffer());
+}
+/**
+ * Download the PWA from palmier.me into memory.
+ * Parses index.html for asset references, then fetches each one.
+ */
+async function downloadPwaAssets() {
+    const assets = new Map();
+    // 1. Fetch index.html
+    const html = await fetchBuffer(`${PWA_ORIGIN}/`);
+    assets.set("/", { data: html, contentType: "text/html; charset=utf-8" });
+    const htmlStr = html.toString("utf-8");
+    // 2. Extract references from HTML (src="..." and href="...")
+    // Skip service worker and manifest — they require HTTPS which LAN mode doesn't use
+    const SKIP = new Set(["/registerSW.js", "/service-worker.js", "/manifest.webmanifest"]);
+    const refRegex = /(?:src|href)="([^"]+)"/g;
+    const htmlRefs = new Set();
+    let match;
+    while ((match = refRegex.exec(htmlStr)) !== null) {
+        const ref = match[1];
+        if (ref.startsWith("/") && !ref.startsWith("//") && !SKIP.has(ref)) {
+            htmlRefs.add(ref);
+        }
+    }
+    // 3. Fetch all HTML-referenced assets
+    for (const ref of htmlRefs) {
+        try {
+            const data = await fetchBuffer(`${PWA_ORIGIN}${ref}`);
+            assets.set(ref, { data, contentType: guessContentType(ref) });
+            // 4. Parse CSS for font url() references
+            if (ref.endsWith(".css")) {
+                const cssStr = data.toString("utf-8");
+                const urlRegex = /url\(["']?([^"')]+)["']?\)/g;
+                let cssMatch;
+                while ((cssMatch = urlRegex.exec(cssStr)) !== null) {
+                    let fontRef = cssMatch[1];
+                    if (fontRef.startsWith("data:"))
+                        continue;
+                    // Resolve relative URLs against the CSS file's directory
+                    if (!fontRef.startsWith("/")) {
+                        const cssDir = ref.substring(0, ref.lastIndexOf("/") + 1);
+                        fontRef = cssDir + fontRef;
+                    }
+                    htmlRefs.add(fontRef);
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[pwa] Failed to fetch ${ref}: ${err}`);
+        }
+    }
+    return assets;
+}
 const pendingPairs = new Map();
 export function detectLanIp() {
     const interfaces = os.networkInterfaces();
@@ -16,20 +89,27 @@ export function detectLanIp() {
 /**
  * Start the HTTP transport: Express-like server with RPC, SSE, and health endpoints.
  */
-export async function startHttpTransport(config, handleRpc) {
-    const port = config.directPort ?? 7400;
+export async function startHttpTransport(config, handleRpc, port, pairingCode, onReady) {
+    // Download PWA assets into memory before starting the server
+    console.log("[http] Downloading PWA assets...");
+    const pwaAssets = await downloadPwaAssets();
+    console.log(`[http] Cached ${pwaAssets.size} PWA assets in memory.`);
     const sseClients = new Set();
+    // If a pairing code is provided (from `palmier lan`), pre-register it
+    if (pairingCode) {
+        const EXPIRY_MS = 24 * 60 * 60 * 1000; // 24 hours — stays valid while lan server runs
+        const timer = setTimeout(() => { pendingPairs.delete(pairingCode); }, EXPIRY_MS);
+        pendingPairs.set(pairingCode, {
+            resolve: () => { },
+            timer,
+        });
+    }
     function broadcastSseEvent(data) {
         const payload = `data: ${JSON.stringify(data)}\n\n`;
         for (const client of sseClients) {
             client.write(payload);
         }
     }
-    function setCorsHeaders(res) {
-        res.setHeader("Access-Control-Allow-Origin", "*");
-        res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
-        res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
-    }
     function checkAuth(req) {
         const auth = req.headers.authorization;
         if (!auth || !auth.startsWith("Bearer "))
@@ -60,13 +140,6 @@ export async function startHttpTransport(config, handleRpc) {
         return addr === "127.0.0.1" || addr === "::1" || addr === "::ffff:127.0.0.1";
     }
     const server = http.createServer(async (req, res) => {
-        setCorsHeaders(res);
-        // Handle CORS preflight
-        if (req.method === "OPTIONS") {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
         const url = new URL(req.url ?? "/", `http://localhost:${port}`);
         const pathname = url.pathname;
         // Internal event endpoint — localhost only, no auth
@@ -146,7 +219,6 @@ export async function startHttpTransport(config, handleRpc) {
                     hostId: config.hostId,
                     sessionToken: session.token,
                     directUrl: `http://${ip}:${port}`,
-                    directToken: config.directToken,
                 };
                 // Resolve the long-poll and clean up
                 clearTimeout(pending.timer);
@@ -159,7 +231,21 @@ export async function startHttpTransport(config, handleRpc) {
             }
             return;
         }
-        // All other endpoints require auth
+        // Serve cached PWA assets for non-API routes (no auth required)
+        const isApiRoute = pathname === "/events" || pathname.startsWith("/rpc/");
+        if (!isApiRoute) {
+            // SPA fallback: serve index.html for unrecognized paths
+            const asset = pwaAssets.get(pathname) ?? (pathname !== "/" ? pwaAssets.get("/") : undefined);
+            if (asset) {
+                res.writeHead(200, { "Content-Type": asset.contentType });
+                res.end(asset.data);
+            }
+            else {
+                sendJson(res, 404, { error: "Not found" });
+            }
+            return;
+        }
+        // API endpoints require auth
         if (!checkAuth(req)) {
             sendJson(res, 401, { error: "Unauthorized" });
             return;
@@ -170,7 +256,6 @@ export async function startHttpTransport(config, handleRpc) {
                 "Content-Type": "text/event-stream",
                 "Cache-Control": "no-cache",
                 Connection: "keep-alive",
-                "Access-Control-Allow-Origin": "*",
             });
             res.write(":ok\n\n");
             // Send heartbeat every 5 seconds
@@ -220,7 +305,7 @@ export async function startHttpTransport(config, handleRpc) {
     return new Promise((resolve, reject) => {
         server.listen(port, () => {
             console.log(`[http] Listening on port ${port}`);
-            console.log(`[http] SSE clients can connect to /events`);
+            onReady?.();
             // Graceful shutdown
             const shutdown = () => {
                 console.log("[http] Shutting down...");

package/dist/transports/nats-transport.d.ts

@@ -1,6 +1,8 @@
+import { type NatsConnection } from "nats";
 import type { HostConfig, RpcMessage } from "../types.js";
 /**
- * Start the NATS transport: connect, subscribe to RPC subjects, dispatch to handler.
+ * Start the NATS transport using an existing connection.
+ * Subscribe to RPC subjects and dispatch to handler.
  */
-export declare function startNatsTransport(config: HostConfig, handleRpc: (req: RpcMessage) => Promise<unknown>): Promise<void>;
+export declare function startNatsTransport(config: HostConfig, handleRpc: (req: RpcMessage) => Promise<unknown>, nc: NatsConnection): Promise<void>;
 //# sourceMappingURL=nats-transport.d.ts.map

package/dist/transports/nats-transport.js

@@ -1,10 +1,9 @@
 import { StringCodec } from "nats";
-import { connectNats } from "../nats-client.js";
 /**
- * Start the NATS transport: connect, subscribe to RPC subjects, dispatch to handler.
+ * Start the NATS transport using an existing connection.
+ * Subscribe to RPC subjects and dispatch to handler.
  */
-export async function startNatsTransport(config, handleRpc) {
-    const nc = await connectNats(config);
+export async function startNatsTransport(config, handleRpc, nc) {
     const sc = StringCodec();
     const subject = `host.${config.hostId}.rpc.>`;
     console.log(`[nats] Subscribing to: ${subject}`);

package/dist/types.d.ts

@@ -1,12 +1,10 @@
 export interface HostConfig {
     hostId: string;
     projectRoot: string;
-    mode: "nats" | "lan" | "auto";
+    nats?: boolean;
     natsUrl?: string;
     natsWsUrl?: string;
     natsToken?: string;
-    directPort?: number;
-    directToken?: string;
     agents?: Array<{
         key: string;
         label: string;
@@ -21,6 +19,7 @@ export interface TaskFrontmatter {
     triggers_enabled: boolean;
     requires_confirmation: boolean;
     permissions?: RequiredPermission[];
+    command?: string;
 }
 export interface Trigger {
     type: "cron" | "once";
@@ -30,13 +29,14 @@ export interface ParsedTask {
     frontmatter: TaskFrontmatter;
     body: string;
 }
-export type TaskRunningState = "start" | "finish" | "abort" | "fail";
+export type TaskRunningState = "started" | "finished" | "aborted" | "failed";
 export interface TaskStatus {
     running_state: TaskRunningState;
     time_stamp: number;
     pending_confirmation?: boolean;
     pending_permission?: RequiredPermission[];
-    user_input?: string;
+    pending_input?: string[];
+    user_input?: string[];
 }
 export interface HistoryEntry {
     task_id: string;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "palmier",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Palmier host CLI - provisions, executes tasks, and serves NATS RPC",
-  "license": "ISC",
+  "license": "Apache-2.0",
   "author": "Hongxu Cai",
   "type": "module",
   "main": "dist/index.js",
@@ -19,16 +19,18 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
     "commander": "^13.1.0",
+    "cross-spawn": "^7.0.6",
     "dotenv": "^16.4.7",
     "nats": "^2.29.1",
     "yaml": "^2.7.0"
   },
   "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
     "@types/node": "^22.13.0",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0"
   },
   "engines": {
-    "node": ">=20.0.0"
+    "node": ">=24.0.0"
   }
 }

package/src/agents/agent.ts

@@ -2,10 +2,13 @@ import type { ParsedTask, RequiredPermission } from "../types.js";
 import { ClaudeAgent } from "./claude.js";
 import { GeminiAgent } from "./gemini.js";
 import { CodexAgent } from "./codex.js";
+import { OpenClawAgent } from "./openclaw.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;
 }
 
 /**
@@ -16,9 +19,10 @@ export interface AgentTool {
   /** Return the command and args used to generate a plan from a prompt. */
   getPlanGenerationCommandLine(prompt: string): CommandLine;
 
-  /** Return the command and args used to run a task. If prompt is provided, use it instead of the task's prompt.
-   *  extraPermissions are transient permissions granted for this run only (not persisted in frontmatter). */
-  getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
+  /** Return the command and args used to run a task. If retryPrompt 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 are transient
+   *  permissions granted for this run only (not persisted in frontmatter). */
+  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine;
 
   /** Detect whether the agent CLI is available and perform any agent-specific
    *  initialization. Returns true if the agent was detected and initialized successfully. */
@@ -29,6 +33,7 @@ const agentRegistry: Record<string, AgentTool> = {
   claude: new ClaudeAgent(),
   gemini: new GeminiAgent(),
   codex: new CodexAgent(),
+  openclaw: new OpenClawAgent(),
 };
 
 const agentLabels: Record<string, string> = {

package/src/agents/claude.ts

@@ -1,43 +1,44 @@
-import type { ParsedTask, RequiredPermission } from "../types.js";
-import { execSync } from "child_process";
-import type { AgentTool, CommandLine } from "./agent.js";
-import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
-
-// execSync's shell option takes a string (shell path), not boolean.
-// On Windows we need a shell so .cmd shims resolve correctly.
-const SHELL = process.platform === "win32" ? "cmd.exe" : undefined;
-
-export class ClaudeAgent implements AgentTool {
-  getPlanGenerationCommandLine(prompt: string): CommandLine {
-    return {
-      command: "claude",
-      args: ["-p", prompt],
-    };
-  }
-
-  getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    prompt = (prompt ?? (task.body || task.frontmatter.user_prompt)) + TASK_OUTCOME_SUFFIX;
-    const args = ["-c", "--permission-mode", "acceptEdits", "-p", prompt];
-
-    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
-    for (const p of allPerms) {
-      args.push("--allowedTools", p.name);
-    }
-
-    return { command: "claude", args };
-  }
-
-  async init(): Promise<boolean> {
-    try {
-      execSync("claude --version", { shell: SHELL });
-    } catch {
-      return false;
-    }
-    try {
-      execSync("claude mcp add --transport stdio palmier --scope user -- palmier mcpserver", { shell: SHELL });
-    } catch (err) {
-      console.warn("Warning: failed to install MCP for Claude:", err instanceof Error ? err.message : err);
-    }
-    return true;
-  }
-}
+import type { ParsedTask, RequiredPermission } from "../types.js";
+import { execSync } from "child_process";
+import type { AgentTool, CommandLine } from "./agent.js";
+import { AGENT_INSTRUCTIONS } from "./shared-prompt.js";
+
+// execSync's shell option takes a string (shell path), not boolean.
+// On Windows we need a shell so .cmd shims resolve correctly.
+const SHELL = process.platform === "win32" ? "cmd.exe" : undefined;
+
+export class ClaudeAgent implements AgentTool {
+  getPlanGenerationCommandLine(prompt: string): CommandLine {
+    return {
+      command: "claude",
+      args: ["-p", prompt],
+    };
+  }
+
+  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    const prompt = retryPrompt ?? (task.body || task.frontmatter.user_prompt);
+    const args = ["--permission-mode", "acceptEdits", "--append-system-prompt", AGENT_INSTRUCTIONS, "-p"];
+
+    const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
+    for (const p of allPerms) {
+      args.push("--allowedTools", p.name);
+    }
+
+    if (retryPrompt) {args.push("-c");} // continue mode for retries
+    return { command: "claude", args, stdin: prompt };
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      execSync("claude --version", { stdio: "ignore", shell: SHELL });
+    } catch {
+      return false;
+    }
+    try {
+      execSync("claude mcp add --transport stdio palmier --scope user -- palmier mcpserver", { stdio: "ignore", shell: SHELL });
+    } catch {
+      // MCP registration is best-effort; agent still works without it
+    }
+    return true;
+  }
+}

package/src/agents/codex.ts

@@ -1,7 +1,7 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import { execSync } from "child_process";
 import type { AgentTool, CommandLine } from "./agent.js";
-import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+import { AGENT_INSTRUCTIONS } from "./shared-prompt.js";
 
 // On Windows we need a shell so .cmd shims resolve correctly.
 const SHELL = process.platform === "win32" ? "cmd.exe" : undefined;
@@ -11,12 +11,12 @@ export class CodexAgent implements AgentTool {
     // TODO: fill in
     return {
       command: "codex",
-      args: ["exec", "--skip-git-repo-check",prompt],
+      args: ["exec", "--skip-git-repo-check", prompt],
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    prompt = (prompt ?? (task.body || task.frontmatter.user_prompt)) + TASK_OUTCOME_SUFFIX;
+  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
     // TODO: Update sandbox to workspace-write once https://github.com/openai/codex/issues/12572
     // is fixed.
     const args = ["exec", "--full-auto", "--skip-git-repo-check", "--sandbox", "danger-full-access"];
@@ -26,23 +26,22 @@ export class CodexAgent implements AgentTool {
       args.push("--config");
       args.push(`apps.${p.name}.default_tools_approval_mode="approve"`);
     }
+    args.push("-"); // read prompt from stdin
 
-    args.push(prompt);
-    args.push("resume", "--last");
-
-    return { command: "codex", args };
+    if (retryPrompt) {args.push("resume", "--last");} // continue mode for retries
+    return { command: "codex", args, stdin: prompt };
   }
 
   async init(): Promise<boolean> {
     try {
-      execSync("codex --version", { shell: SHELL });
+      execSync("codex --version", { stdio: "ignore", shell: SHELL });
     } catch {
       return false;
     }
     try {
-      execSync("codex mcp add palmier palmier mcpserver", { shell: SHELL });
-    } catch (err) {
-      console.warn("Warning: failed to install MCP for Codex:", err instanceof Error ? err.message : err);
+      execSync("codex mcp add palmier palmier mcpserver", { stdio: "ignore", shell: SHELL });
+    } catch {
+      // MCP registration is best-effort; agent still works without it
     }
     return true;
   }

package/src/agents/gemini.ts

@@ -1,7 +1,7 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import { execSync } from "child_process";
 import type { AgentTool, CommandLine } from "./agent.js";
-import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+import { AGENT_INSTRUCTIONS } from "./shared-prompt.js";
 
 // On Windows we need a shell so .cmd shims resolve correctly.
 const SHELL = process.platform === "win32" ? "cmd.exe" : undefined;
@@ -11,13 +11,14 @@ export class GeminiAgent implements AgentTool {
     // TODO: fill in
     return {
       command: "gemini",
-      args: ["--approval-mode", "auto_edit","--prompt", prompt],
+      args: ["--approval-mode", "auto_edit", "--prompt", prompt],
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    prompt = prompt ?? (task.body || task.frontmatter.user_prompt);
-    const args = ["--resume", "--prompt", prompt + TASK_OUTCOME_SUFFIX];
+  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    const prompt = retryPrompt ?? (task.body || task.frontmatter.user_prompt);
+    const fullPrompt = AGENT_INSTRUCTIONS + "\n\n" + prompt;
+    const args = ["--prompt", "-"];
 
     const allPerms = [...(task.frontmatter.permissions ?? []), ...(extraPermissions ?? [])];
     if (allPerms.length > 0) {
@@ -27,19 +28,20 @@ export class GeminiAgent implements AgentTool {
       }
     }
 
-    return { command: "gemini", args };
+    if (retryPrompt) {args.push("--resume");} // continue mode for retries
+    return { command: "gemini", args, stdin: fullPrompt };
   }
 
   async init(): Promise<boolean> {
     try {
-      execSync("gemini --version", { shell: SHELL });
+      execSync("gemini --version", { stdio: "ignore", shell: SHELL });
     } catch {
       return false;
     }
     try {
-      execSync("gemini mcp add --scope user palmier palmier mcpserver", { shell: SHELL });
-    } catch (err) {
-      console.warn("Warning: failed to install MCP for Gemini:", err instanceof Error ? err.message : err);
+      execSync("gemini mcp add --scope user palmier palmier mcpserver", { stdio: "ignore", shell: SHELL });
+    } catch {
+      // MCP registration is best-effort; agent still works without it
     }
     return true;
   }

package/src/agents/openclaw.ts

@@ -1,26 +1,27 @@
 import type { ParsedTask, RequiredPermission } from "../types.js";
 import { execSync } from "child_process";
 import type { AgentTool, CommandLine } from "./agent.js";
-import { TASK_OUTCOME_SUFFIX } from "./shared-prompt.js";
+import { AGENT_INSTRUCTIONS } from "./shared-prompt.js";
 
-export class ClaudeAgent implements AgentTool {
+export class OpenClawAgent implements AgentTool {
   getPlanGenerationCommandLine(prompt: string): CommandLine {
     return {
       command: "openclaw",
-      args: ["agent", "--message", prompt],
+      args: ["agent", "--local", "--agent", "main", "--message", prompt],
     };
   }
 
-  getTaskRunCommandLine(task: ParsedTask, prompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
-    prompt = (prompt ?? (task.body || task.frontmatter.user_prompt)) + TASK_OUTCOME_SUFFIX;
-    const args = ["agent", "--message", prompt];
+  getTaskRunCommandLine(task: ParsedTask, retryPrompt?: string, extraPermissions?: RequiredPermission[]): CommandLine {
+    const prompt = AGENT_INSTRUCTIONS + "\n\n" + (retryPrompt ?? (task.body || task.frontmatter.user_prompt));
+    // OpenClaw does not support stdin as prompt.
+    const args = ["agent", "--local", "--session-id", task.frontmatter.id, "--message", prompt];
 
     return { command: "openclaw", args };
   }
 
   async init(): Promise<boolean> {
     try {
-      execSync("openclaw --version");
+      execSync("openclaw --version", { stdio: "ignore" });
     } catch {
       return false;
     }

package/src/agents/shared-prompt.ts

@@ -1,12 +1,9 @@
 /**
- * Appended to the end of every task prompt.
- * Instructs the agent to output a clear success/failure marker
- * so that palmier can determine the task outcome.
+ * Instructions prepended or injected as system prompt for every task invocation.
+ * Instructs the agent to output structured markers so palmier can determine
+ * the task outcome, report files, and permission/input requests.
  */
-export const TASK_OUTCOME_SUFFIX = `
-
----
-If you generate report or output files, print each file name on its own line prefixed with [PALMIER_REPORT]: e.g.
+export const AGENT_INSTRUCTIONS = `If you generate report or output files, print each file name on its own line prefixed with [PALMIER_REPORT]: e.g.
 [PALMIER_REPORT] report.md
 [PALMIER_REPORT] summary.md
 
@@ -18,9 +15,14 @@ Do not wrap them in code blocks or add text on the same line.
 If the task fails because a tool was denied or you lack the required permissions, print each required permission on its own line prefixed with [PALMIER_PERMISSION]: e.g.
 [PALMIER_PERMISSION] Read | Read file contents from the repository
 [PALMIER_PERMISSION] Bash(npm test) | Run the test suite via npm
-[PALMIER_PERMISSION] Write | Write generated output files`;
+[PALMIER_PERMISSION] Write | Write generated output files
+
+If the task requires information from the user that you do not have (such as credentials, connection strings, API keys, or configuration values), print each required input on its own line prefixed with [PALMIER_INPUT]: e.g.
+[PALMIER_INPUT] What is the database connection string?
+[PALMIER_INPUT] What is the API key for the external service?`;
 
 export const TASK_SUCCESS_MARKER = "[PALMIER_TASK_SUCCESS]";
 export const TASK_FAILURE_MARKER = "[PALMIER_TASK_FAILURE]";
 export const TASK_REPORT_PREFIX = "[PALMIER_REPORT]";
 export const TASK_PERMISSION_PREFIX = "[PALMIER_PERMISSION]";
+export const TASK_INPUT_PREFIX = "[PALMIER_INPUT]";

package/src/commands/agents.ts

@@ -1,8 +1,10 @@
 import { loadConfig, saveConfig } from "../config.js";
 import { detectAgents } from "../agents/agent.js";
+import { getPlatform } from "../platform/index.js";
 
 export async function agentsCommand(): Promise<void> {
   const config = loadConfig();
+  const oldKeys = (config.agents ?? []).map((a) => a.key).sort().join(",");
 
   console.log("Detecting installed agents...");
   const agents = await detectAgents();
@@ -17,4 +19,13 @@ export async function agentsCommand(): Promise<void> {
       console.log(`  ${a.key} — ${a.label}`);
     }
   }
+
+  // Restart daemon if agent list changed so the UI picks it up immediately
+  const newKeys = agents.map((a) => a.key).sort().join(",");
+  if (newKeys !== oldKeys) {
+    try {
+      console.log("Agent list changed, restarting daemon...");
+      await getPlatform().restartDaemon();
+    } catch { /* daemon may not be running yet */ }
+  }
 }

package/src/commands/info.ts

@@ -1,40 +1,16 @@
-import * as os from "os";
 import { loadConfig } from "../config.js";
 import { loadSessions } from "../session-store.js";
 
-/**
- * Detect the first non-internal IPv4 address.
- */
-function detectLanIp(): string {
-  const interfaces = os.networkInterfaces();
-  for (const name of Object.keys(interfaces)) {
-    for (const iface of interfaces[name] ?? []) {
-      if (iface.family === "IPv4" && !iface.internal) {
-        return iface.address;
-      }
-    }
-  }
-  return "127.0.0.1";
-}
-
 /**
  * Print host connection info for setting up clients.
  */
 export async function infoCommand(): Promise<void> {
   const config = loadConfig();
-  const mode = config.mode ?? "nats";
   const sessions = loadSessions();
 
   console.log(`Host ID:      ${config.hostId}`);
-  console.log(`Mode:         ${mode}`);
   console.log(`Project root: ${config.projectRoot}`);
 
-  if (mode === "lan" || mode === "auto") {
-    const lanIp = detectLanIp();
-    const port = config.directPort ?? 7400;
-    console.log(`LAN address:  ${lanIp}:${port}`);
-  }
-
   // Detected agents
   if (config.agents && config.agents.length > 0) {
     console.log(`Agents:       ${config.agents.map((a) => a.label).join(", ")}`);