palmier 0.4.4 → 0.4.6

package/dist/commands/run.js

@@ -9,22 +9,21 @@ import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
 import { TASK_SUCCESS_MARKER, TASK_FAILURE_MARKER, TASK_REPORT_PREFIX, TASK_PERMISSION_PREFIX } from "../agents/shared-prompt.js";
 import { publishHostEvent } from "../events.js";
-import { waitForUserInput } from "../user-input.js";
 /**
- * Invoke the agent CLI with a retry loop for permissions and user input.
+ * Invoke the agent CLI with a continuation loop for permissions and user input.
  *
  * Both standard and command-triggered execution use this.
  * The `invokeTask` is the ParsedTask whose prompt is passed to the agent
  * (for command-triggered mode this is the per-line augmented task).
  */
-async function invokeAgentWithRetry(ctx, invokeTask) {
-    let retryPrompt;
+async function invokeAgentWithContinuation(ctx, invokeTask) {
+    let followupPrompt;
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, retryPrompt, ctx.transientPermissions);
+        const { command, args, stdin } = ctx.agent.getTaskRunCommandLine(invokeTask, followupPrompt, ctx.transientPermissions);
         const result = await spawnCommand(command, args, {
             cwd: getRunDir(ctx.taskDir, ctx.runId),
-            env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
+            env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7400) },
             echoStdout: true,
             resolveOnFailure: true,
             stdin,
@@ -39,10 +38,9 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
             content: stripPalmierMarkers(result.output),
             attachments: reportFiles.length > 0 ? reportFiles : undefined,
         });
-        // Permission retry
-        if (outcome === "failed" && requiredPermissions.length > 0) {
-            const response = await requestPermission(ctx.nc, ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
-            await publishPermissionResolved(ctx.nc, ctx.config, ctx.taskId, response);
+        // Permission handling — agent requested permissions
+        if (requiredPermissions.length > 0) {
+            const response = await requestPermission(ctx.config, ctx.task, ctx.taskDir, requiredPermissions);
             if (response === "aborted") {
                 await appendAndNotify(ctx, {
                     role: "user",
@@ -69,10 +67,13 @@ async function invokeAgentWithRetry(ctx, invokeTask) {
             else {
                 ctx.transientPermissions = [...ctx.transientPermissions, ...newPerms];
             }
-            retryPrompt = "Permissions granted, please continue.";
-            continue;
+            // If the agent actually failed, retry with the new permissions
+            if (outcome === "failed") {
+                followupPrompt = "Permissions granted, please continue.";
+                continue;
+            }
         }
-        // Normal completion (success or non-retryable failure)
+        // Normal completion (success or terminal failure)
         return { outcome };
     }
 }
@@ -141,9 +142,7 @@ export async function runCommand(taskId) {
         await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
         // If requires_confirmation, notify clients and wait
         if (task.frontmatter.requires_confirmation) {
-            const confirmed = await requestConfirmation(nc, config, task, taskDir);
-            const resolvedStatus = confirmed ? "confirmed" : "aborted";
-            await publishConfirmResolved(nc, config, taskId, resolvedStatus);
+            const confirmed = await requestConfirmation(config, task, taskDir);
             if (!confirmed) {
                 console.log("Task aborted by user.");
                 appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "aborted" });
@@ -177,7 +176,7 @@ export async function runCommand(taskId) {
                 time: Date.now(),
                 content: task.body || task.frontmatter.user_prompt,
             });
-            const result = await invokeAgentWithRetry(ctx, task);
+            const result = await invokeAgentWithContinuation(ctx, task);
             const outcome = resolveOutcome(taskDir, result.outcome);
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
             await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
@@ -217,7 +216,7 @@ async function runCommandTriggeredMode(ctx) {
     console.log(`[command-triggered] Spawning: ${commandStr}`);
     const child = spawnStreamingCommand(commandStr, {
         cwd: getRunDir(ctx.taskDir, ctx.runId),
-        env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId) },
+        env: { ...ctx.guiEnv, PALMIER_TASK_ID: ctx.task.frontmatter.id, PALMIER_RUN_DIR: getRunDir(ctx.taskDir, ctx.runId), PALMIER_HTTP_PORT: String(ctx.config.httpPort ?? 7400) },
     });
     let linesProcessed = 0;
     let invocationsSucceeded = 0;
@@ -255,7 +254,7 @@ async function runCommandTriggeredMode(ctx) {
             frontmatter: { ...ctx.task.frontmatter, user_prompt: perLinePrompt },
             body: "",
         };
-        const result = await invokeAgentWithRetry(ctx, perLineTask);
+        const result = await invokeAgentWithContinuation(ctx, perLineTask);
         if (result.outcome === "finished") {
             invocationsSucceeded++;
         }
@@ -333,49 +332,29 @@ async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName
         payload.run_id = runId;
     await publishHostEvent(nc, config.hostId, taskId, payload);
 }
-/**
- * Notify clients that a confirmation request has been resolved.
- */
-async function publishConfirmResolved(nc, config, taskId, status) {
-    await publishHostEvent(nc, config.hostId, taskId, {
-        event_type: "confirm-resolved",
-        host_id: config.hostId,
-        status,
+async function requestPermission(config, task, taskDir, requiredPermissions) {
+    const port = config.httpPort ?? 7400;
+    const params = new URLSearchParams({
+        taskId: task.frontmatter.id,
+        taskName: task.frontmatter.name,
+        permissions: JSON.stringify(requiredPermissions),
     });
-}
-async function requestPermission(nc, config, task, taskDir, requiredPermissions) {
-    const currentStatus = readTaskStatus(taskDir);
-    writeTaskStatus(taskDir, { ...currentStatus, pending_permission: requiredPermissions });
-    await publishHostEvent(nc, config.hostId, task.frontmatter.id, {
-        event_type: "permission-request",
-        host_id: config.hostId,
-        required_permissions: requiredPermissions,
-        name: task.frontmatter.name,
-    });
-    const userInput = await waitForUserInput(taskDir);
-    const response = userInput[0];
+    const res = await fetch(`http://localhost:${port}/request-permission?${params}`);
+    const { response } = await res.json();
     writeTaskStatus(taskDir, {
         running_state: response === "aborted" ? "aborted" : "started",
         time_stamp: Date.now(),
     });
     return response;
 }
-async function publishPermissionResolved(nc, config, taskId, status) {
-    await publishHostEvent(nc, config.hostId, taskId, {
-        event_type: "permission-resolved",
-        host_id: config.hostId,
-        status,
-    });
-}
-async function requestConfirmation(nc, config, task, taskDir) {
-    const currentStatus = readTaskStatus(taskDir);
-    writeTaskStatus(taskDir, { ...currentStatus, pending_confirmation: true });
-    await publishHostEvent(nc, config.hostId, task.frontmatter.id, {
-        event_type: "confirm-request",
-        host_id: config.hostId,
+async function requestConfirmation(config, task, taskDir) {
+    const port = config.httpPort ?? 7400;
+    const params = new URLSearchParams({
+        taskId: task.frontmatter.id,
+        taskName: task.frontmatter.name,
     });
-    const userInput = await waitForUserInput(taskDir);
-    const confirmed = userInput[0] === "confirmed";
+    const res = await fetch(`http://localhost:${port}/request-confirmation?${params}`);
+    const { confirmed } = await res.json();
     writeTaskStatus(taskDir, {
         running_state: confirmed ? "started" : "aborted",
         time_stamp: Date.now(),

package/dist/commands/serve.d.ts

@@ -1,5 +1,5 @@
 /**
- * Start the persistent RPC handler (NATS only).
+ * Start the persistent RPC handler (NATS + HTTP).
  */
 export declare function serveCommand(): Promise<void>;
 //# sourceMappingURL=serve.d.ts.map

package/dist/commands/serve.js

@@ -4,6 +4,7 @@ import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { createRpcHandler } from "../rpc-handler.js";
 import { startNatsTransport } from "../transports/nats-transport.js";
+import { startHttpTransport } from "../transports/http-transport.js";
 import { getTaskDir, readTaskStatus, writeTaskStatus, parseTaskFile, appendRunMessage } from "../task.js";
 import { publishHostEvent } from "../events.js";
 import { getPlatform } from "../platform/index.js";
@@ -69,7 +70,7 @@ async function checkStaleTasks(config, nc) {
     }
 }
 /**
- * Start the persistent RPC handler (NATS only).
+ * Start the persistent RPC handler (NATS + HTTP).
  */
 export async function serveCommand() {
     const config = loadConfig();
@@ -91,6 +92,12 @@ export async function serveCommand() {
         });
     }, POLL_INTERVAL_MS);
     const handleRpc = createRpcHandler(config, nc);
-    await startNatsTransport(config, handleRpc, nc);
+    const httpPort = config.httpPort ?? 7400;
+    // Start NATS transport (loops forever, fire-and-forget)
+    if (nc) {
+        startNatsTransport(config, handleRpc, nc);
+    }
+    // Start HTTP transport (loops forever)
+    await startHttpTransport(config, handleRpc, httpPort, nc);
 }
 //# sourceMappingURL=serve.js.map

package/dist/events.d.ts

@@ -1,9 +1,9 @@
 import { type NatsConnection } from "nats";
 /**
- * Broadcast an event to connected clients via NATS and HTTP SSE (if LAN server is running).
+ * Broadcast an event to connected clients via NATS and HTTP SSE.
  *
  * - NATS: publishes to `host-event.{hostId}.{taskId}`
- * - HTTP: POSTs to the LAN server's `/internal/event` endpoint (auto-detected via lockfile)
+ * - HTTP: POSTs to the serve daemon's `/event` endpoint
  */
 export declare function publishHostEvent(nc: NatsConnection | undefined, hostId: string, taskId: string, payload: Record<string, unknown>): Promise<void>;
 //# sourceMappingURL=events.d.ts.map

package/dist/events.js

@@ -1,11 +1,11 @@
 import { StringCodec } from "nats";
-import { getLanPort } from "./lan-lock.js";
+import { loadConfig } from "./config.js";
 const sc = StringCodec();
 /**
- * Broadcast an event to connected clients via NATS and HTTP SSE (if LAN server is running).
+ * Broadcast an event to connected clients via NATS and HTTP SSE.
  *
  * - NATS: publishes to `host-event.{hostId}.{taskId}`
- * - HTTP: POSTs to the LAN server's `/internal/event` endpoint (auto-detected via lockfile)
+ * - HTTP: POSTs to the serve daemon's `/event` endpoint
  */
 export async function publishHostEvent(nc, hostId, taskId, payload) {
     const subject = `host-event.${hostId}.${taskId}`;
@@ -13,19 +13,18 @@ export async function publishHostEvent(nc, hostId, taskId, payload) {
         nc.publish(subject, sc.encode(JSON.stringify(payload)));
         console.log(`[nats] ${subject} →`, payload);
     }
-    const lanPort = getLanPort();
-    if (lanPort) {
-        try {
-            await fetch(`http://localhost:${lanPort}/internal/event`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ task_id: taskId, ...payload }),
-            });
-            console.log(`[http] host-event: ${taskId} →`, payload);
-        }
-        catch {
-            // LAN server may have shut down — ignore
-        }
+    const config = loadConfig();
+    const port = config.httpPort ?? 7400;
+    try {
+        await fetch(`http://localhost:${port}/event`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ task_id: taskId, ...payload }),
+        });
+        console.log(`[http] host-event: ${taskId} →`, payload);
+    }
+    catch {
+        // Serve HTTP may not be ready yet — ignore
     }
 }
 //# sourceMappingURL=events.js.map

package/dist/index.js

@@ -8,10 +8,7 @@ import { initCommand } from "./commands/init.js";
 import { infoCommand } from "./commands/info.js";
 import { runCommand } from "./commands/run.js";
 import { serveCommand } from "./commands/serve.js";
-import { notifyCommand } from "./commands/notify.js";
-import { requestInputCommand } from "./commands/request-input.js";
 import { pairCommand } from "./commands/pair.js";
-import { lanCommand } from "./commands/lan.js";
 import { restartCommand } from "./commands/restart.js";
 import { sessionsListCommand, sessionsRevokeCommand, sessionsRevokeAllCommand } from "./commands/sessions.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -51,34 +48,12 @@ program
     .action(async () => {
     await restartCommand();
 });
-program
-    .command("notify")
-    .description("Send a push notification to the user")
-    .requiredOption("--title <title>", "Notification title")
-    .requiredOption("--body <body>", "Notification body text")
-    .action(async (opts) => {
-    await notifyCommand(opts);
-});
-program
-    .command("request-input")
-    .description("Request input from the user (requires PALMIER_TASK_ID env var)")
-    .requiredOption("--description <desc...>", "Input descriptions to show the user")
-    .action(async (opts) => {
-    await requestInputCommand(opts);
-});
 program
     .command("pair")
     .description("Generate a pairing code for connecting a PWA client")
     .action(async () => {
     await pairCommand();
 });
-program
-    .command("lan")
-    .description("Start an on-demand LAN server for direct HTTP connections")
-    .option("-p, --port <port>", "Port to listen on", "7400")
-    .action(async (opts) => {
-    await lanCommand({ port: parseInt(opts.port, 10) });
-});
 const sessionsCmd = program
     .command("sessions")
     .description("Manage paired client sessions");

package/dist/pending-requests.d.ts

@@ -0,0 +1,27 @@
+import type { RequiredPermission } from "./types.js";
+export interface PendingRequest {
+    type: "confirmation" | "permission" | "input";
+    resolve: (value: string[]) => void;
+    /** Permission list (for 'permission') or input descriptions (for 'input'). */
+    params?: RequiredPermission[] | string[];
+}
+/**
+ * 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.
+ */
+export declare function registerPending(taskId: string, type: PendingRequest["type"], params?: PendingRequest["params"]): Promise<string[]>;
+/**
+ * Resolve a pending request with the user's response.
+ * Returns true if a pending request was found and resolved.
+ */
+export declare function resolvePending(taskId: string, value: string[]): boolean;
+/**
+ * Get the current pending request for a task (if any).
+ */
+export declare function getPending(taskId: string): PendingRequest | undefined;
+/**
+ * Remove a pending request without resolving it.
+ */
+export declare function removePending(taskId: string): void;
+//# sourceMappingURL=pending-requests.d.ts.map

package/dist/pending-requests.js

@@ -0,0 +1,39 @@
+const pending = new Map();
+/**
+ * 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.
+ */
+export function registerPending(taskId, type, params) {
+    if (pending.has(taskId)) {
+        return Promise.reject(new Error(`Task ${taskId} already has a pending request`));
+    }
+    return new Promise((resolve) => {
+        pending.set(taskId, { type, resolve, params });
+    });
+}
+/**
+ * Resolve a pending request with the user's response.
+ * Returns true if a pending request was found and resolved.
+ */
+export function resolvePending(taskId, value) {
+    const entry = pending.get(taskId);
+    if (!entry)
+        return false;
+    pending.delete(taskId);
+    entry.resolve(value);
+    return true;
+}
+/**
+ * Get the current pending request for a task (if any).
+ */
+export function getPending(taskId) {
+    return pending.get(taskId);
+}
+/**
+ * Remove a pending request without resolving it.
+ */
+export function removePending(taskId) {
+    pending.delete(taskId);
+}
+//# sourceMappingURL=pending-requests.js.map

package/dist/rpc-handler.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from "url";
 import { spawn } from "child_process";
 import { parse as parseYaml } from "yaml";
 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 { getPlatform } from "./platform/index.js";
 import { spawnCommand } from "./spawn-command.js";
 import crossSpawn from "cross-spawn";
@@ -131,8 +132,8 @@ export function createRpcHandler(config, nc) {
         };
     }
     async function handleRpc(request) {
-        // Session token validation: always require a valid session token
-        if (!request.sessionToken || !validateSession(request.sessionToken)) {
+        // Session token validation: skip for trusted localhost requests
+        if (!request.localhost && (!request.sessionToken || !validateSession(request.sessionToken))) {
             return { error: "Unauthorized" };
         }
         switch (request.method) {
@@ -447,7 +448,14 @@ export function createRpcHandler(config, nc) {
                 if (!status) {
                     return { task_id: params.id, error: "No status found" };
                 }
-                return { task_id: params.id, ...status };
+                const pending = getPending(params.id);
+                return {
+                    task_id: params.id,
+                    ...status,
+                    ...(pending?.type === "confirmation" ? { pending_confirmation: true } : {}),
+                    ...(pending?.type === "permission" ? { pending_permission: pending.params } : {}),
+                    ...(pending?.type === "input" ? { pending_input: pending.params } : {}),
+                };
             }
             case "task.result": {
                 const params = request.params;
@@ -494,14 +502,13 @@ export function createRpcHandler(config, nc) {
             }
             case "task.user_input": {
                 const params = request.params;
-                const taskDir = getTaskDir(config.projectRoot, params.id);
-                const currentStatus = readTaskStatus(taskDir);
-                if (!currentStatus?.pending_confirmation && !currentStatus?.pending_permission?.length && !currentStatus?.pending_input?.length) {
+                const pending = getPending(params.id);
+                if (!pending) {
                     return { ok: false, error: "not pending" };
                 }
-                writeTaskStatus(taskDir, { ...currentStatus, user_input: params.value });
+                const resolved = resolvePending(params.id, params.value);
                 console.log(`[task.user_input] ${params.id} → ${params.value}`);
-                return { ok: true };
+                return { ok: resolved };
             }
             case "taskrun.list": {
                 const params = request.params;

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

@@ -1,7 +1,9 @@
+import { type NatsConnection } from "nats";
 import type { HostConfig, RpcMessage } from "../types.js";
 export declare function detectLanIp(): string;
 /**
- * Start the HTTP transport: Express-like server with RPC, SSE, and health endpoints.
+ * Start the HTTP transport: server with RPC, SSE, PWA proxy, pairing, and
+ * localhost-only agent endpoints (notify, request-input, confirmation, permission).
  */
-export declare function startHttpTransport(config: HostConfig, handleRpc: (req: RpcMessage) => Promise<unknown>, port: number, pairingCode?: string, onReady?: () => void): Promise<void>;
+export declare function startHttpTransport(config: HostConfig, handleRpc: (req: RpcMessage) => Promise<unknown>, port: number, nc: NatsConnection | undefined, pairingCode?: string, onReady?: () => void): Promise<void>;
 //# sourceMappingURL=http-transport.d.ts.map