palmier 1.1.19 → 1.1.20

package/dist/commands/run.js

@@ -2,7 +2,6 @@ import * as fs from "fs";
 import * as path from "path";
 import { spawnCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
-import { connectNats } from "../nats-client.js";
 import { parseTaskFile, taskDisplayName, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, appendRunMessage, readRunMessages, getRunDir, beginStreamingMessage, formatAgentModelComment } from "../task.js";
 import { getAgent } from "../agents/agent.js";
 import { getPlatform } from "../platform/index.js";
@@ -31,7 +30,7 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
             notifyPending = true;
             notifyTimer = setTimeout(() => {
                 notifyPending = false;
-                publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+                publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
             }, 500);
         }
         function ensureWriter(stream) {
@@ -104,9 +103,9 @@ async function invokeAgentWithRetries(ctx, invokeTask) {
             ensureWriter("stdout").write(`\n\n**Permissions requested:**\n${permLines}\n`);
         }
         writer?.end();
-        await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+        await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
         if (linkedFiles.length > 0) {
-            await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, {
+            await publishHostEvent(ctx.taskId, {
                 event_type: "report-generated",
                 run_id: ctx.runId,
                 name: taskDisplayName(ctx.task.frontmatter),
@@ -153,7 +152,7 @@ export function stripPalmierMarkers(output) {
 }
 async function appendAndNotify(ctx, msg) {
     appendRunMessage(ctx.taskDir, ctx.runId, msg);
-    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+    await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
 }
 /** The latest run dir with no status messages yet — freshly created by the RPC handler. */
 function findLatestPendingRunId(taskDir) {
@@ -182,7 +181,6 @@ export async function runCommand(taskId) {
     const taskDir = getTaskDir(config.projectRoot, taskId);
     const task = parseTaskFile(taskDir);
     console.log(`Running task: ${taskId}`);
-    let nc;
     const taskName = taskDisplayName(task.frontmatter);
     const existingRunId = findLatestPendingRunId(taskDir);
     const agentVersion = config.agents?.find((a) => a.key === task.frontmatter.agent)?.version;
@@ -191,9 +189,6 @@ export async function runCommand(taskId) {
         appendHistory(config.projectRoot, { task_id: taskId, run_id: runId });
     }
     const cleanup = async () => {
-        if (nc && !nc.isClosed()) {
-            await nc.drain();
-        }
         if (task.frontmatter.one_off) {
             try {
                 getPlatform().removeTaskTimer(taskId);
@@ -202,32 +197,31 @@ export async function runCommand(taskId) {
         }
     };
     try {
-        nc = await connectNats(config);
-        await publishTaskEvent(nc, config, taskDir, taskId, "started", taskName, runId);
+        await publishTaskEvent(taskDir, taskId, "started", taskName, runId);
         appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "started" });
-        await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
+        await publishHostEvent(taskId, { event_type: "result-updated", run_id: runId });
         if (task.frontmatter.requires_confirmation) {
             const confirmed = await requestConfirmation(config, task, taskDir);
             const confirmPrompt = `**Task Confirmation**\n\nRun task "${taskName || task.frontmatter.user_prompt}"?`;
             appendRunMessage(taskDir, runId, { role: "assistant", time: Date.now(), content: confirmPrompt, type: "confirmation" });
-            await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
+            await publishHostEvent(taskId, { event_type: "result-updated", run_id: runId });
             if (!confirmed) {
                 console.log("Task aborted by user.");
                 appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: "Aborted", type: "confirmation" });
                 appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "aborted" });
-                await publishTaskEvent(nc, config, taskDir, taskId, "aborted", taskName, runId);
+                await publishTaskEvent(taskDir, taskId, "aborted", taskName, runId);
                 await cleanup();
                 return;
             }
             console.log("Task confirmed by user.");
             appendRunMessage(taskDir, runId, { role: "user", time: Date.now(), content: "Confirmed", type: "confirmation" });
             appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: "confirmation" });
-            await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
+            await publishHostEvent(taskId, { event_type: "result-updated", run_id: runId });
         }
         const guiEnv = getPlatform().getGuiEnv();
         const agent = getAgent(task.frontmatter.agent);
         const ctx = {
-            agent, task, taskDir, runId, guiEnv, nc, config, taskId,
+            agent, task, taskDir, runId, guiEnv, config, taskId,
             transientPermissions: [],
         };
         // Command-output and on_new_* tasks share the same trigger machinery: the
@@ -240,7 +234,7 @@ export async function runCommand(taskId) {
             const result = await runEventTriggeredMode(ctx);
             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);
+            await publishTaskEvent(taskDir, taskId, outcome, taskName, runId);
             console.log(`Task ${taskId} completed (triggered).`);
         }
         else {
@@ -252,7 +246,7 @@ export async function runCommand(taskId) {
             const result = await invokeAgentWithRetries(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);
+            await publishTaskEvent(taskDir, taskId, outcome, taskName, runId);
             console.log(`Task ${taskId} completed.`);
         }
     }
@@ -266,7 +260,7 @@ export async function runCommand(taskId) {
             content: errorMsg,
         });
         appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
-        await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
+        await publishTaskEvent(taskDir, taskId, outcome, taskName, runId);
         process.exitCode = 1;
     }
     finally {
@@ -317,12 +311,12 @@ async function runEventTriggeredMode(ctx) {
     catch (err) {
         const errorMsg = err instanceof Error ? err.message : String(err);
         appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: errorMsg, type: "error" });
-        await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
+        await publishHostEvent(ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
         return { outcome: "failed", endTime: Date.now() };
     }
     return { outcome: lastOutcome, endTime: Date.now() };
 }
-async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName, runId) {
+async function publishTaskEvent(taskDir, taskId, eventType, taskName, runId) {
     writeTaskStatus(taskDir, {
         running_state: eventType,
         time_stamp: Date.now(),
@@ -333,7 +327,7 @@ async function publishTaskEvent(nc, config, taskDir, taskId, eventType, taskName
         payload.name = taskName;
     if (runId)
         payload.run_id = runId;
-    await publishHostEvent(nc, config.hostId, taskId, payload);
+    await publishHostEvent(taskId, payload);
 }
 async function requestPermission(config, task, taskDir, requiredPermissions) {
     const port = config.httpPort ?? 7256;

package/dist/commands/serve.js

@@ -25,7 +25,7 @@ const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
  * clean up OS scheduler units for one-off tasks that have already terminated.
  * The system scheduler (Task Scheduler / systemd) is the authoritative source.
  */
-async function checkStaleTasks(config, nc) {
+async function checkStaleTasks(config) {
     const tasksRoot = path.join(config.projectRoot, "tasks");
     if (!fs.existsSync(tasksRoot))
         return;
@@ -59,7 +59,7 @@ async function checkStaleTasks(config, nc) {
                     type: "failed",
                 });
             }
-            await publishHostEvent(nc, config.hostId, taskId, {
+            await publishHostEvent(taskId, {
                 event_type: "running-state",
                 running_state: "failed",
                 name: taskDisplayName(task.frontmatter) || taskId,
@@ -91,7 +91,7 @@ async function checkStaleTasks(config, nc) {
                     content: "",
                     type: "failed",
                 });
-                await publishHostEvent(nc, config.hostId, taskId, { event_type: "result-updated", run_id: runId });
+                await publishHostEvent(taskId, { event_type: "result-updated", run_id: runId });
             }
         }
     }
@@ -112,37 +112,18 @@ export async function serveCommand() {
     saveConfig(config);
     console.log(`Detected agents: ${agents.map((a) => a.key).join(", ") || "none"}`);
     let nc;
-    try {
-        nc = await connectNats(config);
+    const handleRpc = createRpcHandler(config);
+    function attachNats(conn) {
+        nc = conn;
         console.log("[nats] Connected");
-    }
-    catch (err) {
-        console.warn(`[nats] Connection failed (server mode unavailable): ${err}`);
-    }
-    await checkStaleTasks(config, nc);
-    // Reinstall scheduler entries for all tasks (recovery after init/reinstall)
-    const platform = getPlatform();
-    const allTasks = listTasks(config.projectRoot);
-    for (const task of allTasks) {
-        try {
-            platform.installTaskTimer(config, task);
-        }
-        catch (err) {
-            console.error(`Warning: failed to install timer for task ${task.frontmatter.id}: ${err}`);
-        }
-    }
-    // Spawn the long-running command process for every enabled command task —
-    // the daemon owns these the same way it owns the device-event subscriptions.
-    startEnabledCommandRunners(config);
-    setInterval(() => {
-        checkStaleTasks(config, nc).catch((err) => {
-            console.error("[monitor] Error checking stale tasks:", err);
-        });
-    }, POLL_INTERVAL_MS);
-    const handleRpc = createRpcHandler(config, nc);
-    const httpPort = config.httpPort ?? 7256;
-    if (nc) {
-        startNatsTransport(config, handleRpc, nc);
+        (async () => {
+            for await (const s of conn.status()) {
+                if (s.type === "pingTimer")
+                    continue;
+                console.log(`[nats] Status: ${s.type}${typeof s.data === "string" ? ` (${s.data})` : ""}`);
+            }
+        })();
+        startNatsTransport(config, handleRpc, conn);
         const sc = StringCodec();
         // Match phone numbers regardless of formatting; letters preserved for shortcodes.
         function normalizeSender(raw) {
@@ -168,7 +149,7 @@ export async function serveCommand() {
                 dispatchTrigger(task.frontmatter.id, payload);
             }
         }
-        const notifSub = nc.subscribe(`host.${config.hostId}.device.notifications`);
+        const notifSub = conn.subscribe(`host.${config.hostId}.device.notifications`);
         (async () => {
             for await (const msg of notifSub) {
                 const raw = sc.decode(msg.data);
@@ -183,7 +164,7 @@ export async function serveCommand() {
                 dispatchDeviceEvent("on_new_notification", raw, parsed);
             }
         })();
-        const smsSub = nc.subscribe(`host.${config.hostId}.device.sms`);
+        const smsSub = conn.subscribe(`host.${config.hostId}.device.sms`);
         (async () => {
             for await (const msg of smsSub) {
                 const raw = sc.decode(msg.data);
@@ -199,5 +180,42 @@ export async function serveCommand() {
             }
         })();
     }
-    await startHttpTransport(config, handleRpc, httpPort, nc);
+    // The client's own reconnect only covers a connection that was once up, so a
+    // daemon started while offline (e.g. at logon before Wi-Fi) must keep dialing.
+    async function connectWithRetry() {
+        for (let delayMs = 5_000;; delayMs = Math.min(delayMs * 2, 60_000)) {
+            try {
+                attachNats(await connectNats(config));
+                return;
+            }
+            catch (err) {
+                console.warn(`[nats] Connection failed, retrying in ${delayMs / 1000}s: ${err}`);
+            }
+            await new Promise((r) => setTimeout(r, delayMs));
+        }
+    }
+    // Don't block startup on the relay: local mode must work offline.
+    connectWithRetry();
+    await checkStaleTasks(config);
+    // Reinstall scheduler entries for all tasks (recovery after init/reinstall)
+    const platform = getPlatform();
+    const allTasks = listTasks(config.projectRoot);
+    for (const task of allTasks) {
+        try {
+            platform.installTaskTimer(config, task);
+        }
+        catch (err) {
+            console.error(`Warning: failed to install timer for task ${task.frontmatter.id}: ${err}`);
+        }
+    }
+    // Spawn the long-running command process for every enabled command task —
+    // the daemon owns these the same way it owns the device-event subscriptions.
+    startEnabledCommandRunners(config);
+    setInterval(() => {
+        checkStaleTasks(config).catch((err) => {
+            console.error("[monitor] Error checking stale tasks:", err);
+        });
+    }, POLL_INTERVAL_MS);
+    const httpPort = config.httpPort ?? 7256;
+    await startHttpTransport(config, handleRpc, httpPort, () => nc);
 }

package/dist/events.d.ts

@@ -1,2 +1,2 @@
-import { type NatsConnection } from "nats";
-export declare function publishHostEvent(nc: NatsConnection | undefined, hostId: string, taskId: string, payload: Record<string, unknown>): Promise<void>;
+/** Hands the event to the daemon, which forwards it to the relay and local SSE clients. */
+export declare function publishHostEvent(taskId: string, payload: Record<string, unknown>): Promise<void>;

package/dist/events.js

@@ -1,12 +1,6 @@
-import { StringCodec } from "nats";
 import { loadConfig } from "./config.js";
-const sc = StringCodec();
-export async function publishHostEvent(nc, hostId, taskId, payload) {
-    const subject = `host-event.${hostId}.${taskId}`;
-    if (nc) {
-        nc.publish(subject, sc.encode(JSON.stringify(payload)));
-        console.log(`[nats] ${subject} →`, payload);
-    }
+/** Hands the event to the daemon, which forwards it to the relay and local SSE clients. */
+export async function publishHostEvent(taskId, payload) {
     const config = loadConfig();
     const port = config.httpPort ?? 7256;
     try {

package/dist/nats-client.js

@@ -6,6 +6,12 @@ export async function connectNats(config) {
     const nc = await connect({
         servers: config.natsUrl,
         authenticator: jwtAuthenticator(config.natsJwt, new TextEncoder().encode(config.natsNkeySeed)),
+        // Sleep or a network switch kills the socket silently; the 2-min default
+        // ping leaves the host unreachable for minutes, and the default 10
+        // reconnect attempts close the connection for good after a short outage.
+        maxReconnectAttempts: -1,
+        pingInterval: 20_000,
+        maxPingOut: 2,
     });
     return nc;
 }

package/dist/platform/windows.d.ts

@@ -12,7 +12,10 @@ import type { HostConfig, ParsedTask } from "../types.js";
  *   monthly: "MM HH D * *"
  */
 export declare function scheduleValueToXml(scheduleType: "crons" | "specific_times", value: string): string;
-export declare function buildTaskXml(tr: string, triggers: string[], foreground?: boolean): string;
+export declare function buildTaskXml(tr: string, triggers: string[], opts?: {
+    foreground?: boolean;
+    persistent?: boolean;
+}): string;
 export declare class WindowsPlatform implements PlatformService {
     installDaemon(config: HostConfig): void;
     uninstallDaemon(): void;

package/dist/platform/windows.js

@@ -40,7 +40,7 @@ export function scheduleValueToXml(scheduleType, value) {
     }
     return `<CalendarTrigger><StartBoundary>${base}</StartBoundary><ScheduleByDay><DaysInterval>1</DaysInterval></ScheduleByDay></CalendarTrigger>`;
 }
-export function buildTaskXml(tr, triggers, foreground) {
+export function buildTaskXml(tr, triggers, opts = {}) {
     const [command, ...argParts] = tr.match(/"[^"]*"|[^\s]+/g) ?? [];
     const commandStr = command?.replace(/"/g, "") ?? "";
     const argsStr = argParts.map((a) => a.replace(/"/g, "")).join(" ");
@@ -49,7 +49,7 @@ export function buildTaskXml(tr, triggers, foreground) {
         `<Task version="1.3" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">`,
         `  <Principals>`,
         `    <Principal>`,
-        `      <LogonType>${foreground ? "InteractiveToken" : "S4U"}</LogonType>`,
+        `      <LogonType>${opts.foreground ? "InteractiveToken" : "S4U"}</LogonType>`,
         `      <RunLevel>LeastPrivilege</RunLevel>`,
         `    </Principal>`,
         `  </Principals>`,
@@ -58,6 +58,12 @@ export function buildTaskXml(tr, triggers, foreground) {
         `    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>`,
         `    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>`,
         `    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>`,
+        // Omitting ExecutionTimeLimit means Task Scheduler's 72h default, which
+        // kills a long-running process; PT0S disables the limit.
+        ...(opts.persistent ? [
+            `    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>`,
+            `    <RestartOnFailure><Interval>PT1M</Interval><Count>999</Count></RestartOnFailure>`,
+        ] : []),
         `  </Settings>`,
         `  <Triggers>${triggers.join("")}</Triggers>`,
         `  <Actions>`,
@@ -171,7 +177,7 @@ export class WindowsPlatform {
     ensureDaemonTask(script) {
         const tn = `\\Palmier\\${DAEMON_TASK_NAME}`;
         const tr = `"${process.execPath}" "${script}" serve`;
-        const xml = buildTaskXml(tr, [`<BootTrigger><Enabled>true</Enabled></BootTrigger>`]);
+        const xml = buildTaskXml(tr, [`<BootTrigger><Enabled>true</Enabled></BootTrigger>`], { persistent: true });
         const xmlPath = path.join(CONFIG_DIR, "daemon-task.xml");
         try {
             const bom = Buffer.from([0xFF, 0xFE]);
@@ -234,7 +240,7 @@ export class WindowsPlatform {
         // MultipleInstancesPolicy. S4U keeps the console hidden unless
         // foreground_mode is set. Works unelevated because the caller (daemon)
         // runs elevated.
-        const xml = buildTaskXml(tr, triggerElements, task.frontmatter.foreground_mode);
+        const xml = buildTaskXml(tr, triggerElements, { foreground: task.frontmatter.foreground_mode });
         const xmlPath = path.join(CONFIG_DIR, `task-${taskId}.xml`);
         try {
             // schtasks /xml requires UTF-16LE with BOM.