palmier 0.7.6 → 0.7.8

package/src/agents/goose.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class GooseAgent implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "goose", args: ["run", "--text", prompt] };
   }

package/src/agents/hermes.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class Hermes implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "hermes", args: ["chat", "-q", prompt] };
   }

package/src/agents/kimi.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class KimiAgent implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "kimi", args: ["-p", prompt] };
   }

package/src/agents/kiro.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class Kiro implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "kiro-cli", args: ["--no-interactive", prompt] };
   }

package/src/agents/openclaw.ts

@@ -5,13 +5,13 @@ import { getAgentInstructions } from "./shared-prompt.js";
 
 export class OpenClawAgent implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = false;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "openclaw", args: ["agent", "--local", "--agent", "main", "--message", prompt] };
   }
 
   getTaskRunCommandLine(task: ParsedTask, followupPrompt?: string, extraPermissions?: RequiredPermission[] | "yolo"): CommandLine {
-    const yolo = extraPermissions === "yolo";
-    const prompt = followupPrompt ?? getAgentInstructions(task, yolo || !this.supportsPermissions);
+    const prompt = followupPrompt ?? getAgentInstructions(task, true);
     // OpenClaw does not support stdin as prompt.
     const args = ["agent", "--local", "--session-id", task.frontmatter.id, "--message", prompt];
 

package/src/agents/opencode.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class OpenCodeAgent implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "opencode", args: ["run", prompt] };
   }

package/src/agents/qoder.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class Qoder implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "qodercli", args: ["-p", prompt] };
   }

package/src/agents/qwen.ts

@@ -6,6 +6,7 @@ import { SHELL } from "../platform/index.js";
 
 export class QwenAgent implements AgentTool {
   supportsPermissions = false;
+  supportsYolo = true;
   getPromptCommandLine(prompt: string): CommandLine {
     return { command: "qwen", args: ["-p", prompt] };
   }

package/src/agents/shared-prompt.ts

@@ -16,7 +16,7 @@ const AGENT_INSTRUCTIONS_TEMPLATE = fs.readFileSync(
  * Build the full agent prompt: instructions + endpoint docs + task description.
  */
 export function getAgentInstructions(task: ParsedTask, skipPermissions?: boolean): string {
-  const port = loadConfig().httpPort ?? 9966;
+  const port = loadConfig().httpPort ?? 7256;
   const taskDescription = task.frontmatter.user_prompt;
   let instructions = AGENT_INSTRUCTIONS_TEMPLATE
     .replace(/\{\{ENDPOINT_DOCS\}\}/g, generateEndpointDocs(port, task.frontmatter.id))

package/src/commands/init.ts

@@ -45,7 +45,7 @@ export async function initCommand(): Promise<void> {
     const lanAnswer = await ask("Enable LAN access (direct HTTP from local network)? (y/N): ");
     const lanEnabled = lanAnswer.trim().toLowerCase() === "y";
 
-    let httpPort = 9966;
+    let httpPort = 7256;
     const portLabel = lanEnabled ? "HTTP port for local and LAN access" : "HTTP port for local access";
     const portAnswer = await ask(`${portLabel} (default ${httpPort}): `);
     const parsed = parseInt(portAnswer.trim(), 10);
@@ -86,7 +86,7 @@ export async function initCommand(): Promise<void> {
     try { existingHostId = loadConfig().hostId; } catch { /* first init */ }
 
     const serverUrl = "https://app.palmier.me";
-    let registerResponse: { hostId: string; natsUrl: string; natsWsUrl: string; natsToken: string };
+    let registerResponse: { hostId: string; natsUrl: string; natsWsUrl: string; natsJwt: string; natsNkeySeed: string };
 
     while (true) {
       console.log(`\nRegistering host...`);
@@ -111,7 +111,8 @@ export async function initCommand(): Promise<void> {
       projectRoot: process.cwd(),
       natsUrl: registerResponse.natsUrl,
       natsWsUrl: registerResponse.natsWsUrl,
-      natsToken: registerResponse.natsToken,
+      natsJwt: registerResponse.natsJwt,
+      natsNkeySeed: registerResponse.natsNkeySeed,
       agents,
       httpPort,
       lanEnabled,
@@ -138,7 +139,7 @@ export async function initCommand(): Promise<void> {
 async function registerHost(
   serverUrl: string,
   existingHostId?: string,
-): Promise<{ hostId: string; natsUrl: string; natsWsUrl: string; natsToken: string }> {
+): Promise<{ hostId: string; natsUrl: string; natsWsUrl: string; natsJwt: string; natsNkeySeed: string }> {
   try {
     const res = await fetch(`${serverUrl}/api/hosts/register`, {
       method: "POST",
@@ -155,7 +156,8 @@ async function registerHost(
       hostId: string;
       natsUrl: string;
       natsWsUrl: string;
-      natsToken: string;
+      natsJwt: string;
+      natsNkeySeed: string;
     };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);

package/src/commands/pair.ts

@@ -8,7 +8,7 @@ import type { HostConfig } from "../types.js";
 const CODE_CHARS = "ABCDEFGHJKMNPQRSTUVWXYZ23456789"; // no O/0/I/1/L
 const CODE_LENGTH = 6;
 
-export const PAIRING_EXPIRY_MS = 5 * 60 * 1000; // 5 minutes
+export const PAIRING_EXPIRY_MS = 60 * 1000; // 1 minute
 
 export function generatePairingCode(): string {
   const bytes = new Uint8Array(CODE_LENGTH);
@@ -67,7 +67,7 @@ function httpPairRegister(port: number, code: string): Promise<boolean> {
 export async function pairCommand(): Promise<void> {
   const config = loadConfig();
   const code = generatePairingCode();
-  const httpPort = config.httpPort ?? 9966;
+  const httpPort = config.httpPort ?? 7256;
 
   let paired = false;
 
@@ -84,7 +84,7 @@ export async function pairCommand(): Promise<void> {
   console.log("");
   console.log(`  ${code}`);
   console.log("");
-  console.log("Code expires in 5 minutes.");
+  console.log("Code expires in 1 minute.");
 
   // NATS pairing (server mode)
   const nc = await connectNats(config);

package/src/commands/run.ts

@@ -67,7 +67,7 @@ async function invokeAgentWithRetries(
     );
     const result = await spawnCommand(command, args, {
       cwd: getRunDir(ctx.taskDir, ctx.runId),
-      env: { ...ctx.guiEnv, ...agentEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
+      env: { ...ctx.guiEnv, ...agentEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7256) },
       echoStdout: true,
       resolveOnFailure: true,
       stdin,
@@ -321,7 +321,7 @@ async function runCommandTriggeredMode(
 
   const child = spawnStreamingCommand(commandStr, {
     cwd: getRunDir(ctx.taskDir, ctx.runId),
-    env: { ...ctx.guiEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 9966) },
+    env: { ...ctx.guiEnv, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7256) },
   });
 
   let linesProcessed = 0;
@@ -483,7 +483,7 @@ async function requestPermission(
   taskDir: string,
   requiredPermissions: RequiredPermission[],
 ): Promise<"granted" | "granted_all" | "aborted"> {
-  const port = config.httpPort ?? 9966;
+  const port = config.httpPort ?? 7256;
   const res = await fetch(`http://localhost:${port}/request-permission`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -511,7 +511,7 @@ async function requestConfirmation(
   task: ParsedTask,
   taskDir: string,
 ): Promise<boolean> {
-  const port = config.httpPort ?? 9966;
+  const port = config.httpPort ?? 7256;
   const res = await fetch(`http://localhost:${port}/request-confirmation?taskId=${encodeURIComponent(task.frontmatter.id)}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },

package/src/commands/serve.ts

@@ -127,7 +127,7 @@ export async function serveCommand(): Promise<void> {
   }, POLL_INTERVAL_MS);
 
   const handleRpc = createRpcHandler(config, nc);
-  const httpPort = config.httpPort ?? 9966;
+  const httpPort = config.httpPort ?? 7256;
 
   // Start NATS transport (loops forever, fire-and-forget)
   if (nc) {

package/src/config.ts

@@ -25,8 +25,8 @@ export function loadConfig(): HostConfig {
     throw new Error("Invalid host config: missing hostId");
   }
 
-  if (!config.natsUrl || !config.natsToken) {
-    throw new Error("Invalid host config: missing natsUrl or natsToken");
+  if (!config.natsUrl || !config.natsJwt || !config.natsNkeySeed) {
+    throw new Error("Invalid host config: missing NATS JWT credentials. Re-run palmier init.");
   }
 
   return config;

package/src/device-capabilities.ts

@@ -17,6 +17,7 @@ export type DeviceCapability =
   | "calendar"
   | "alert"
   | "battery"
+  | "email"
   | "dnd";
 
 type CapabilityMap = Partial<Record<DeviceCapability, RegisteredDevice>>;

package/src/events.ts

@@ -23,7 +23,7 @@ export async function publishHostEvent(
   }
 
   const config = loadConfig();
-  const port = config.httpPort ?? 9966;
+  const port = config.httpPort ?? 7256;
   try {
     await fetch(`http://localhost:${port}/event`, {
       method: "POST",

package/src/mcp-tools.ts

@@ -65,7 +65,7 @@ const requestInputTool: ToolDefinition = {
     "Request input from the user.",
     "The request blocks until the user responds.",
     'Response: `{"values": ["answer1", "answer2"]}` on success, or `{"aborted": true}` if the user declines.',
-    "When you need information from the user (credentials, answers to questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout, even in a non-interactive environment — use this endpoint instead.",
+    "When you need information from the user (credentials, answers to questions, preferences, clarifications, etc.), do not guess, fail, or prompt via stdout, even in a non-interactive environment — use this instead.",
   ],
   inputSchema: {
     type: "object",
@@ -84,13 +84,18 @@ const requestInputTool: ToolDefinition = {
     const { description, questions } = args as { description?: string; questions: string[] };
     if (!questions?.length) throw new ToolError("questions is required", 400);
 
-    const pendingPromise = registerPending(ctx.sessionId, "input", questions);
+    const pendingPromise = registerPending(ctx.sessionId, "input", questions, {
+      session_id: ctx.sessionId,
+      session_name: ctx.agentName,
+      description,
+      input_questions: questions,
+    });
 
     await ctx.publishEvent("_input", {
       event_type: "input-request",
       host_id: ctx.config.hostId,
       session_id: ctx.sessionId,
-      agent_name: ctx.agentName,
+      session_name: ctx.agentName,
       description,
       input_questions: questions,
     });
@@ -131,13 +136,17 @@ const requestConfirmationTool: ToolDefinition = {
     const { description } = args as { description: string };
     if (!description) throw new ToolError("description is required", 400);
 
-    const pendingPromise = registerPending(ctx.sessionId, "confirmation");
+    const pendingPromise = registerPending(ctx.sessionId, "confirmation", undefined, {
+      session_id: ctx.sessionId,
+      session_name: ctx.agentName,
+      description,
+    });
 
     await ctx.publishEvent("_confirm", {
       event_type: "confirm-request",
       host_id: ctx.config.hostId,
       session_id: ctx.sessionId,
-      agent_name: ctx.agentName,
+      session_name: ctx.agentName,
       description,
     });
 
@@ -159,7 +168,7 @@ const deviceGeolocationTool: ToolDefinition = {
   name: "device-geolocation",
   description: [
     "Get the GPS location of the user's mobile device.",
-    "When you need the user's real-time location, use this endpoint.",
+    "When you need the user's real-time location, use this.",
     "Blocks until the device responds (up to 30 seconds).",
     'Response: `{"latitude": ..., "longitude": ..., "accuracy": ..., "timestamp": ...}` on success, or `{"error": "..."}` on failure.',
   ],
@@ -657,7 +666,74 @@ const setRingerModeTool: ToolDefinition = {
   },
 };
 
-export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendAlertTool, readBatteryTool, setRingerModeTool];
+const sendEmailTool: ToolDefinition = {
+  name: "send-email",
+  description: [
+    "Send an email from the user's mobile device.",
+    "When you need to send an email, use this. The email app opens on the device with the draft pre-filled for the user to review and send.",
+    'Response: `{"ok": true}` on success, or `{"error": "..."}` on failure.',
+  ],
+  inputSchema: {
+    type: "object",
+    properties: {
+      to: { type: "string", description: "Recipient email address" },
+      subject: { type: "string", description: "Email subject" },
+      body: { type: "string", description: "Email body text" },
+      cc: { type: "string", description: "CC recipient(s)" },
+      bcc: { type: "string", description: "BCC recipient(s)" },
+    },
+    required: ["to"],
+  },
+  async handler(args, ctx) {
+    if (!ctx.nc) throw new ToolError("Not connected to server (NATS unavailable)", 503);
+
+    const device = getCapabilityDevice("email");
+    if (!device) throw new ToolError("No device has email access enabled", 400);
+
+    const { to, subject, body, cc, bcc } = args as { to: string; subject?: string; body?: string; cc?: string; bcc?: string };
+    if (!to) throw new ToolError("to is required", 400);
+
+    const sc = StringCodec();
+
+    const payload: Record<string, string> = {
+      hostId: ctx.config.hostId, requestId: ctx.sessionId, fcmToken: device.fcmToken,
+      to,
+    };
+    if (subject) payload.subject = subject;
+    if (body) payload.body = body;
+    if (cc) payload.cc = cc;
+    if (bcc) payload.bcc = bcc;
+
+    const ackReply = await ctx.nc.request(
+      `host.${ctx.config.hostId}.fcm.email`,
+      sc.encode(JSON.stringify(payload)),
+      { timeout: 5_000 },
+    );
+    const ack = JSON.parse(sc.decode(ackReply.data)) as { ok?: boolean; error?: string };
+    if (ack.error) throw new ToolError(ack.error, 502);
+
+    const responsePromise = new Promise<string>((resolve, reject) => {
+      const sub = ctx.nc!.subscribe(`host.${ctx.config.hostId}.email.${ctx.sessionId}`, { max: 1 });
+      const timer = setTimeout(() => {
+        sub.unsubscribe();
+        reject(new ToolError("Device did not respond within 30 seconds", 504));
+      }, 30_000);
+
+      (async () => {
+        for await (const msg of sub) {
+          clearTimeout(timer);
+          resolve(sc.decode(msg.data));
+        }
+      })();
+    });
+
+    const result = JSON.parse(await responsePromise);
+    if (result.error) return { error: result.error };
+    return result;
+  },
+};
+
+export const agentTools: ToolDefinition[] = [notifyTool, requestInputTool, requestConfirmationTool, deviceGeolocationTool, readContactsTool, createContactTool, readCalendarTool, createCalendarEventTool, sendSmsTool, sendEmailTool, sendAlertTool, readBatteryTool, setRingerModeTool];
 export const agentToolMap = new Map<string, ToolDefinition>(agentTools.map((t) => [t.name, t]));
 
 // ── MCP Resources ─────────────────────────────────────────────────────

package/src/nats-client.ts

@@ -1,13 +1,20 @@
-import { connect, type NatsConnection } from "nats";
+import { connect, jwtAuthenticator, type NatsConnection } from "nats";
 import type { HostConfig } from "./types.js";
 
 /**
- * Connect to NATS using the host config's TCP URL and token auth.
+ * Connect to NATS using the host config's JWT credentials.
  */
 export async function connectNats(config: HostConfig): Promise<NatsConnection> {
+  if (!config.natsJwt || !config.natsNkeySeed) {
+    throw new Error("NATS JWT credentials not configured. Re-run palmier init.");
+  }
+
   const nc = await connect({
     servers: config.natsUrl,
-    token: config.natsToken,
+    authenticator: jwtAuthenticator(
+      config.natsJwt,
+      new TextEncoder().encode(config.natsNkeySeed),
+    ),
   });
 
   // Do not log anything as that will pollute stdout for mcp server.

package/src/pending-requests.ts

@@ -1,30 +1,44 @@
 import type { RequiredPermission } from "./types.js";
 
+export interface PendingRequestMeta {
+  /** Doubles as task_id for permission-type entries (the key the task uses). */
+  session_id?: string;
+  /** Human-readable label for whoever opened the prompt — agent name for
+   *  confirm/input, task name for permission. */
+  session_name?: string;
+  description?: string;
+  input_questions?: string[];
+}
+
 export interface PendingRequest {
   type: "confirmation" | "permission" | "input";
   resolve: (value: string[]) => void;
   /** Permission list (for 'permission') or input descriptions (for 'input'). */
   params?: RequiredPermission[] | string[];
+  /** Display context for PWAs that connect while this request is already open. */
+  meta?: PendingRequestMeta;
 }
 
 const pending = new Map<string, PendingRequest>();
 
 /**
- * Register a pending request for a task. Returns a Promise that resolves
- * when `resolvePending` is called with the user's response.
- * Only one pending request per task at a time.
+ * Register a pending request keyed by either a sessionId (confirmation / input)
+ * or a taskId (permission). The `meta` is surfaced to PWAs that connect after
+ * the request was opened, so their modals can render without replaying events.
+ * Only one pending request per key at a time.
  */
 export function registerPending(
-  taskId: string,
+  key: string,
   type: PendingRequest["type"],
   params?: PendingRequest["params"],
+  meta?: PendingRequestMeta,
 ): Promise<string[]> {
-  if (pending.has(taskId)) {
-    return Promise.reject(new Error(`Task ${taskId} already has a pending request`));
+  if (pending.has(key)) {
+    return Promise.reject(new Error(`Key ${key} already has a pending request`));
   }
 
   return new Promise<string[]>((resolve) => {
-    pending.set(taskId, { type, resolve, params });
+    pending.set(key, { type, resolve, params, meta });
   });
 }
 
@@ -32,24 +46,42 @@ export function registerPending(
  * Resolve a pending request with the user's response.
  * Returns true if a pending request was found and resolved.
  */
-export function resolvePending(taskId: string, value: string[]): boolean {
-  const entry = pending.get(taskId);
+export function resolvePending(key: string, value: string[]): boolean {
+  const entry = pending.get(key);
   if (!entry) return false;
-  pending.delete(taskId);
+  pending.delete(key);
   entry.resolve(value);
   return true;
 }
 
 /**
- * Get the current pending request for a task (if any).
+ * Get the current pending request for a key (if any).
  */
-export function getPending(taskId: string): PendingRequest | undefined {
-  return pending.get(taskId);
+export function getPending(key: string): PendingRequest | undefined {
+  return pending.get(key);
 }
 
 /**
  * Remove a pending request without resolving it.
  */
-export function removePending(taskId: string): void {
-  pending.delete(taskId);
+export function removePending(key: string): void {
+  pending.delete(key);
+}
+
+/**
+ * List all currently-pending requests, stripped of the unserializable `resolve`
+ * callback. Used by `host.info` so the PWA can seed its modal state on connect.
+ */
+export function listPending(): Array<{
+  key: string;
+  type: PendingRequest["type"];
+  params?: PendingRequest["params"];
+  meta?: PendingRequestMeta;
+}> {
+  return [...pending.entries()].map(([key, entry]) => ({
+    key,
+    type: entry.type,
+    params: entry.params,
+    meta: entry.meta,
+  }));
 }

package/src/rpc-handler.ts

@@ -4,7 +4,7 @@ import * as path from "path";
 import { spawn, type ChildProcess } from "child_process";
 import { type NatsConnection } from "nats";
 import { listTasks, parseTaskFile, writeTaskFile, getTaskDir, readTaskStatus, writeTaskStatus, readHistory, deleteHistoryEntry, appendTaskList, removeFromTaskList, appendHistory, createRunDir, appendRunMessage, getRunDir } from "./task.js";
-import { resolvePending, getPending } from "./pending-requests.js";
+import { resolvePending, getPending, listPending } from "./pending-requests.js";
 import { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import crossSpawn from "cross-spawn";
@@ -142,13 +142,9 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
   function flattenTask(task: ParsedTask) {
     const taskDir = getTaskDir(config.projectRoot, task.frontmatter.id);
     const status = readTaskStatus(taskDir);
-    const pending = getPending(task.frontmatter.id);
     return {
       ...task.frontmatter,
-      status: status ? {
-        ...status,
-        ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
-      } : undefined,
+      status: status ?? undefined,
     };
   }
 
@@ -161,22 +157,28 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
     }
 
     switch (request.method) {
-      case "task.list": {
-        const tasks = listTasks(config.projectRoot);
+      case "host.info": {
+        // Bootstrap metadata the PWA needs on connect, independent of which tab
+        // is active. Includes any prompts already waiting so a reconnecting
+        // PWA can render their modals without replaying events.
         const capabilities: Record<string, string | null> = {};
         for (const cap of ["location", "notifications", "sms", "contacts", "calendar", "alert", "battery", "dnd"] as const) {
           capabilities[cap] = getCapabilityDevice(cap)?.clientToken ?? null;
         }
         return {
-          tasks: tasks.map((task) => flattenTask(task)),
           agents: config.agents ?? [],
           version: currentVersion,
           host_platform: process.platform,
-          location_client_token: capabilities.location,
           capability_tokens: capabilities,
+          pending_prompts: listPending(),
         };
       }
 
+      case "task.list": {
+        const tasks = listTasks(config.projectRoot);
+        return { tasks: tasks.map((task) => flattenTask(task)) };
+      }
+
       case "task.get": {
         const params = request.params as { id: string };
         const taskDir = getTaskDir(config.projectRoot, params.id);
@@ -537,12 +539,7 @@ export function createRpcHandler(config: HostConfig, nc?: NatsConnection) {
         if (!status) {
           return { task_id: params.id, error: "No status found" };
         }
-        const pending = getPending(params.id);
-        return {
-          task_id: params.id,
-          ...status,
-          ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
-        };
+        return { task_id: params.id, ...status };
       }
 
       case "task.result": {

package/src/transports/http-transport.ts

@@ -306,7 +306,7 @@ export async function startHttpTransport(
           const timer = setTimeout(() => {
             pendingPairs.delete(code);
             resolve({ paired: false });
-          }, expiryMs ?? 5 * 60 * 1000);
+          }, expiryMs ?? 60 * 1000);
 
           pendingPairs.set(code, { resolve, timer });
           req.on("close", () => {
@@ -336,13 +336,16 @@ export async function startHttpTransport(
           return;
         }
 
-        const pendingPromise = registerPending(taskId, "permission", permissions);
+        const pendingPromise = registerPending(taskId, "permission", permissions, {
+          session_id: taskId,
+          session_name: taskName,
+        });
 
         await publishEvent(taskId, {
           event_type: "permission-request",
           host_id: config.hostId,
           required_permissions: permissions,
-          name: taskName,
+          session_name: taskName,
         });
 
         const response = await pendingPromise;

package/src/types.ts

@@ -4,12 +4,13 @@ export interface HostConfig {
 
   natsUrl?: string;
   natsWsUrl?: string;
-  natsToken?: string;
+  natsJwt?: string;
+  natsNkeySeed?: string;
 
   // Detected agent CLIs
-  agents?: Array<{ key: string; label: string }>;
+  agents?: Array<{ key: string; label: string; supportsPermissions: boolean; supportsYolo: boolean }>;
 
-  // HTTP server port (default 9966)
+  // HTTP server port (default 7256)
   httpPort?: number;
   // Whether to accept non-localhost HTTP connections
   lanEnabled?: boolean;