palmier 0.9.27 → 0.9.29

package/dist/command-runners.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Daemon-owned supervisors for command-triggered tasks. A command task's shell
+ * command is a long-running trigger source — the daemon spawns it while the task
+ * is enabled, reads its stdout, and feeds each line into the shared per-task
+ * event queue (the same one the NATS notification/SMS subscriptions populate).
+ * The idle→active edge launches a short-lived `palmier run` that drains the
+ * queue, so command tasks share the exact lifecycle as on_new_* event tasks:
+ * one run per burst, "running" only while the agent is actually invoked.
+ *
+ * Lifecycle parity:
+ *   - Enabled command task → command process running (= being monitored).
+ *   - Disable / delete → command process killed; no further triggers.
+ *   - Abort → kills only the in-flight run; the command process is untouched.
+ */
+import type { HostConfig, ParsedTask } from "./types.js";
+/** Start, stop, or restart a task's command process to match its current state. */
+export declare function reconcileCommandRunner(config: HostConfig, task: ParsedTask): void;
+export declare function stopCommandRunner(taskId: string): void;
+/** Recover command runners for all enabled command tasks (daemon startup). */
+export declare function startEnabledCommandRunners(config: HostConfig): void;

package/dist/command-runners.js

@@ -0,0 +1,114 @@
+/**
+ * Daemon-owned supervisors for command-triggered tasks. A command task's shell
+ * command is a long-running trigger source — the daemon spawns it while the task
+ * is enabled, reads its stdout, and feeds each line into the shared per-task
+ * event queue (the same one the NATS notification/SMS subscriptions populate).
+ * The idle→active edge launches a short-lived `palmier run` that drains the
+ * queue, so command tasks share the exact lifecycle as on_new_* event tasks:
+ * one run per burst, "running" only while the agent is actually invoked.
+ *
+ * Lifecycle parity:
+ *   - Enabled command task → command process running (= being monitored).
+ *   - Disable / delete → command process killed; no further triggers.
+ *   - Abort → kills only the in-flight run; the command process is untouched.
+ */
+import * as readline from "readline";
+import { execFileSync } from "child_process";
+import { spawnStreamingCommand } from "./spawn-command.js";
+import { getTaskDir, listTasks, parseTaskFile } from "./task.js";
+import { dispatchTrigger } from "./trigger-dispatch.js";
+import { getPlatform } from "./platform/index.js";
+const runners = new Map();
+const stopping = new Set();
+function shouldRun(task) {
+    return !!task.frontmatter.command
+        && !!task.frontmatter.schedule_enabled
+        && !task.frontmatter.one_off;
+}
+function killChild(child) {
+    if (process.platform === "win32" && child.pid) {
+        try {
+            execFileSync("taskkill", ["/pid", String(child.pid), "/f", "/t"], { windowsHide: true, stdio: "pipe" });
+            return;
+        }
+        catch { /* may have already exited */ }
+    }
+    child.kill();
+}
+function spawnRunner(config, taskId, command) {
+    stopping.delete(taskId);
+    const taskDir = getTaskDir(config.projectRoot, taskId);
+    const platform = getPlatform();
+    const child = spawnStreamingCommand(command, {
+        cwd: taskDir,
+        env: { ...platform.getGuiEnv(), PALMIER_HTTP_PORT: String(config.httpPort ?? 7256) },
+    });
+    runners.set(taskId, { child, command });
+    console.log(`[command-runner] ${taskId} spawned: ${command}`);
+    const rl = readline.createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+        if (!line.trim())
+            return;
+        dispatchTrigger(taskId, line);
+    });
+    child.stderr?.on("data", (d) => process.stderr.write(d));
+    const handleExit = () => {
+        rl.close();
+        if (runners.get(taskId)?.child === child)
+            runners.delete(taskId);
+        if (stopping.has(taskId)) {
+            stopping.delete(taskId);
+            return;
+        }
+        // Exited on its own while still enabled — relaunch so monitoring stays live.
+        console.log(`[command-runner] ${taskId} command exited; relaunching in 1s`);
+        setTimeout(() => {
+            if (stopping.has(taskId) || runners.has(taskId))
+                return;
+            let task;
+            try {
+                task = parseTaskFile(taskDir);
+            }
+            catch {
+                return;
+            }
+            if (shouldRun(task))
+                spawnRunner(config, taskId, task.frontmatter.command);
+        }, 1000);
+    };
+    child.on("close", handleExit);
+    child.on("error", (err) => {
+        console.error(`[command-runner] ${taskId} error:`, err);
+        handleExit();
+    });
+}
+/** Start, stop, or restart a task's command process to match its current state. */
+export function reconcileCommandRunner(config, task) {
+    const taskId = task.frontmatter.id;
+    if (!shouldRun(task)) {
+        stopCommandRunner(taskId);
+        return;
+    }
+    const existing = runners.get(taskId);
+    if (existing) {
+        if (existing.command === task.frontmatter.command)
+            return;
+        stopCommandRunner(taskId);
+    }
+    spawnRunner(config, taskId, task.frontmatter.command);
+}
+export function stopCommandRunner(taskId) {
+    const existing = runners.get(taskId);
+    if (!existing)
+        return;
+    stopping.add(taskId);
+    runners.delete(taskId);
+    killChild(existing.child);
+}
+/** Recover command runners for all enabled command tasks (daemon startup). */
+export function startEnabledCommandRunners(config) {
+    for (const task of listTasks(config.projectRoot)) {
+        if (shouldRun(task))
+            reconcileCommandRunner(config, task);
+    }
+}

package/dist/commands/run.js

@@ -1,8 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import * as readline from "readline";
-import { StringCodec } from "nats";
-import { spawnCommand, spawnStreamingCommand } from "../spawn-command.js";
+import { spawnCommand } from "../spawn-command.js";
 import { loadConfig } from "../config.js";
 import { connectNats } from "../nats-client.js";
 import { parseTaskFile, getTaskDir, writeTaskFile, writeTaskStatus, readTaskStatus, appendHistory, createRunDir, appendRunMessage, readRunMessages, getRunDir, beginStreamingMessage } from "../task.js";
@@ -10,22 +8,10 @@ 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";
-async function sendPushNotification(nc, hostId, title, body) {
-    if (!nc)
-        return;
-    try {
-        const sc = StringCodec();
-        const subject = `host.${hostId}.push.send`;
-        await nc.request(subject, sc.encode(JSON.stringify({ hostId, title, body })), { timeout: 15_000 });
-    }
-    catch (err) {
-        console.warn(`[push] failed to send notification:`, err);
-    }
-}
 /**
  * Invoke the agent CLI in a continuation loop to handle permission requests.
- * `invokeTask` is the ParsedTask whose prompt is passed to the agent (in
- * command-triggered mode this is the per-line augmented task).
+ * `invokeTask` is the ParsedTask whose prompt is passed to the agent (for
+ * triggered tasks this is the per-trigger augmented task).
  */
 async function invokeAgentWithRetries(ctx, invokeTask) {
     // eslint-disable-next-line no-constant-condition
@@ -226,33 +212,18 @@ export async function runCommand(taskId) {
             agent, task, taskDir, runId, guiEnv, nc, config, taskId,
             transientPermissions: [],
         };
-        if (task.frontmatter.command) {
-            let outcome;
-            // Command-triggered tasks auto-restart when the underlying command exits
-            // on its own — only a user abort breaks the loop.
-            while (true) {
-                const result = await runCommandTriggeredMode(ctx);
-                outcome = resolveOutcome(taskDir, result.outcome);
-                if (outcome === "aborted")
-                    break;
-                console.log(`Task ${taskId} command exited (${outcome}); auto-restarting.`);
-                await new Promise((r) => setTimeout(r, 1000));
-                if (resolveOutcome(taskDir, "finished") === "aborted") {
-                    outcome = "aborted";
-                    break;
-                }
-            }
-            appendRunMessage(taskDir, runId, { role: "status", time: Date.now(), content: "", type: outcome });
-            await publishTaskEvent(nc, config, taskDir, taskId, outcome, taskName, runId);
-            console.log(`Task ${taskId} completed (command-triggered).`);
-        }
-        else if (task.frontmatter.schedule_type === "on_new_notification"
+        // Command-triggered and on_new_* tasks share the same trigger machinery: the
+        // daemon owns the trigger source (the shell command's stdout / a NATS
+        // subscription) and feeds the shared per-task queue, while this run drains
+        // that queue one invocation at a time.
+        if (task.frontmatter.command
+            || task.frontmatter.schedule_type === "on_new_notification"
             || task.frontmatter.schedule_type === "on_new_sms") {
             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);
-            console.log(`Task ${taskId} completed (event-triggered).`);
+            console.log(`Task ${taskId} completed (triggered).`);
         }
         else {
             await appendAndNotify(ctx, {
@@ -284,155 +255,21 @@ export async function runCommand(taskId) {
         await cleanup();
     }
 }
-const MAX_QUEUE_SIZE = 100;
-const MAX_LOG_ENTRIES = 1000;
-/** Max input line length (chars). Long emails can take up to 200k chars. */
-const MAX_LINE_LENGTH = 200_000;
-/**
- * Spawn a long-running shell command and invoke the agent CLI once per stdout
- * line, with the user's prompt augmented by that line. Sequential with a
- * bounded queue.
- */
-async function runCommandTriggeredMode(ctx) {
-    const commandStr = ctx.task.frontmatter.command;
-    console.log(`[command-triggered] Spawning: ${commandStr}`);
-    appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
-    await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
-    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 ?? 7256) },
-    });
-    let linesProcessed = 0;
-    let invocationsSucceeded = 0;
-    let invocationsFailed = 0;
-    const lineQueue = [];
-    let processing = false;
-    let commandExited = false;
-    let resolveWhenDone;
-    const logPath = path.join(getRunDir(ctx.taskDir, ctx.runId), "command-output.log");
-    function appendLog(line, agentOutput, outcome) {
-        const entry = `[${new Date().toISOString()}] (${outcome}) input: ${line}\n${agentOutput}\n---\n`;
-        fs.appendFileSync(logPath, entry, "utf-8");
-        try {
-            const content = fs.readFileSync(logPath, "utf-8");
-            const entries = content.split("\n---\n").filter(Boolean);
-            if (entries.length > MAX_LOG_ENTRIES) {
-                const trimmed = entries.slice(-MAX_LOG_ENTRIES).join("\n---\n") + "\n---\n";
-                fs.writeFileSync(logPath, trimmed, "utf-8");
-            }
-        }
-        catch { /* ignore trim errors */ }
-    }
-    async function processLine(line) {
-        linesProcessed++;
-        if (line.length > MAX_LINE_LENGTH) {
-            console.warn(`[command-triggered] Skipping line #${linesProcessed}: ${line.length} chars exceeds limit`);
-            invocationsFailed++;
-            appendLog(line.slice(0, 200) + "...(truncated)", "", "skipped");
-            return;
-        }
-        console.log(`[command-triggered] Processing line #${linesProcessed}: ${line}`);
-        const perLinePrompt = `${ctx.task.frontmatter.user_prompt}\n\nProcess this input:\n${line}`;
-        const perLineTask = {
-            frontmatter: { ...ctx.task.frontmatter, user_prompt: perLinePrompt },
-        };
-        const result = await invokeAgentWithRetries(ctx, perLineTask);
-        if (result.outcome === "finished") {
-            invocationsSucceeded++;
-        }
-        else {
-            invocationsFailed++;
-            const taskLabel = ctx.task.frontmatter.name || ctx.task.frontmatter.user_prompt;
-            await sendPushNotification(ctx.nc, ctx.config.hostId, `Task "${taskLabel}" invocation failed`, line.length > 200 ? line.slice(0, 200) + "…" : line);
-        }
-        appendLog(line, "", result.outcome);
-        // Signal "waiting for more input" in the UI.
-        appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
-        await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
-    }
-    async function drainQueue() {
-        if (processing)
-            return;
-        processing = true;
-        try {
-            while (lineQueue.length > 0) {
-                const line = lineQueue.shift();
-                await processLine(line);
-            }
-        }
-        finally {
-            processing = false;
-            if (commandExited && lineQueue.length === 0 && resolveWhenDone) {
-                resolveWhenDone();
-            }
-        }
-    }
-    const rl = readline.createInterface({ input: child.stdout });
-    rl.on("line", (line) => {
-        if (!line.trim())
-            return;
-        if (lineQueue.length >= MAX_QUEUE_SIZE) {
-            console.warn(`[command-triggered] Queue full, dropping oldest line.`);
-            lineQueue.shift();
-        }
-        lineQueue.push(line);
-        drainQueue().catch((err) => {
-            console.error(`[command-triggered] Error processing line:`, err);
-            invocationsFailed++;
-        });
-    });
-    let stderrBuf = "";
-    child.stderr?.on("data", (d) => {
-        const chunk = d.toString();
-        stderrBuf += chunk;
-        process.stderr.write(d);
-    });
-    const exitCode = await new Promise((resolve) => {
-        child.on("close", (code) => {
-            commandExited = true;
-            rl.close();
-            resolve(code);
-        });
-        child.on("error", (err) => {
-            console.error(`[command-triggered] Command error:`, err);
-            stderrBuf += err.message;
-            commandExited = true;
-            rl.close();
-            resolve(1);
-        });
-    });
-    if (lineQueue.length > 0 || processing) {
-        await new Promise((resolve) => {
-            resolveWhenDone = resolve;
-            drainQueue();
-        });
-    }
-    const endTime = Date.now();
-    if (exitCode !== 0) {
-        const errorDetail = stderrBuf.trim() || `Command exited with code ${exitCode}`;
-        appendRunMessage(ctx.taskDir, ctx.runId, {
-            role: "status",
-            time: endTime,
-            content: errorDetail,
-            type: "error",
-        });
-        await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
-        return { outcome: "failed", endTime };
-    }
-    return { outcome: "finished", endTime };
-}
 /**
- * Drain the daemon-owned per-task event queue via /task-event/pop, invoking
- * the agent once per event. The run process holds no NATS subscription — the
- * daemon owns that and atomically clears the active flag on empty pop so it
- * can fire a fresh run on the next incoming event.
+ * Drain the daemon-owned per-task event queue via /task-event/pop, invoking the
+ * agent once per queued trigger. The run process holds no subscription of its
+ * own — the daemon owns the trigger source (a NATS subscription for on_new_*
+ * tasks, the command's stdout for command tasks) and atomically clears the
+ * active flag on empty pop so it can fire a fresh run on the next trigger.
  */
 async function runEventTriggeredMode(ctx) {
-    const scheduleType = ctx.task.frontmatter.schedule_type;
-    const label = scheduleType === "on_new_notification" ? "notification" : "SMS";
+    const isCommand = !!ctx.task.frontmatter.command;
+    const label = isCommand
+        ? "input"
+        : ctx.task.frontmatter.schedule_type === "on_new_notification" ? "notification" : "SMS";
     const port = ctx.config.httpPort ?? 7256;
     const popUrl = `http://localhost:${port}/task-event/pop?taskId=${encodeURIComponent(ctx.taskId)}`;
-    console.log(`[event-triggered] Draining ${label} queue`);
+    console.log(`[triggered] Draining ${label} queue`);
     appendRunMessage(ctx.taskDir, ctx.runId, { role: "status", time: Date.now(), content: "", type: "monitoring" });
     await publishHostEvent(ctx.nc, ctx.config.hostId, ctx.taskId, { event_type: "result-updated", run_id: ctx.runId });
     let eventsProcessed = 0;
@@ -447,8 +284,10 @@ async function runEventTriggeredMode(ctx) {
             if (body.empty || !body.event)
                 break;
             eventsProcessed++;
-            console.log(`[event-triggered] Processing ${label} #${eventsProcessed}`);
-            const perEventPrompt = `${ctx.task.frontmatter.user_prompt}\n\nProcess this new ${label}:\n${body.event}`;
+            console.log(`[triggered] Processing ${label} #${eventsProcessed}`);
+            const perEventPrompt = isCommand
+                ? `${ctx.task.frontmatter.user_prompt}\n\nProcess this input:\n${body.event}`
+                : `${ctx.task.frontmatter.user_prompt}\n\nProcess this new ${label}:\n${body.event}`;
             const perEventTask = {
                 frontmatter: { ...ctx.task.frontmatter, user_prompt: perEventPrompt },
             };

package/dist/commands/serve.js

@@ -14,7 +14,8 @@ import { CONFIG_DIR } from "../config.js";
 import { StringCodec } from "nats";
 import { addNotification } from "../notification-store.js";
 import { addSmsMessage } from "../sms-store.js";
-import { enqueueEvent } from "../event-queues.js";
+import { dispatchTrigger } from "../trigger-dispatch.js";
+import { startEnabledCommandRunners } from "../command-runners.js";
 const POLL_INTERVAL_MS = 30_000;
 const DAEMON_PID_FILE = path.join(CONFIG_DIR, "daemon.pid");
 /**
@@ -122,6 +123,9 @@ export async function serveCommand() {
             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);
@@ -153,12 +157,7 @@ export async function serveCommand() {
                     if (!normalizedSender || !task.frontmatter.schedule_values.some((s) => normalizeSender(s) === normalizedSender))
                         continue;
                 }
-                const { shouldStart } = enqueueEvent(task.frontmatter.id, payload);
-                if (shouldStart) {
-                    platform.startTask(task.frontmatter.id).catch((err) => {
-                        console.error(`[event-trigger] Failed to start ${task.frontmatter.id}:`, err);
-                    });
-                }
+                dispatchTrigger(task.frontmatter.id, payload);
             }
         }
         const notifSub = nc.subscribe(`host.${config.hostId}.device.notifications`);

package/dist/event-queues.d.ts

@@ -4,8 +4,11 @@
  * `palmier run` process drains via /task-event/pop.
  *
  * Invariants:
- *   - popEvent clears activeRuns atomically when the queue empties, so a
- *     fresh startTask cannot race the tearing-down run.
+ *   - popEvent clears activeRuns when the queue empties. This races the run's
+ *     own teardown (the process/unit is still alive briefly after the empty
+ *     pop), so a trigger arriving in that window can set activeRuns yet fail to
+ *     launch a run (a oneshot `systemctl start` no-ops on an active unit). The
+ *     dispatch watchdog in trigger-dispatch.ts reconciles that stranded state.
  *   - enqueueEvent returns shouldStart=true only on the idle→active edge.
  */
 export declare function enqueueEvent(taskId: string, payload: string): {
@@ -16,5 +19,10 @@ export declare function popEvent(taskId: string): {
 } | {
     empty: true;
 };
+export declare function hasPendingEvents(taskId: string): boolean;
+/** Drop a stranded active flag so a fresh run can be launched (watchdog only). */
+export declare function resetActiveRun(taskId: string): void;
+/** Re-acquire the active flag without enqueuing (watchdog relaunch only). */
+export declare function markActiveRun(taskId: string): void;
 /** Remove any state for a task (called from task.delete). */
 export declare function clearTaskQueue(taskId: string): void;

package/dist/event-queues.js

@@ -4,8 +4,11 @@
  * `palmier run` process drains via /task-event/pop.
  *
  * Invariants:
- *   - popEvent clears activeRuns atomically when the queue empties, so a
- *     fresh startTask cannot race the tearing-down run.
+ *   - popEvent clears activeRuns when the queue empties. This races the run's
+ *     own teardown (the process/unit is still alive briefly after the empty
+ *     pop), so a trigger arriving in that window can set activeRuns yet fail to
+ *     launch a run (a oneshot `systemctl start` no-ops on an active unit). The
+ *     dispatch watchdog in trigger-dispatch.ts reconciles that stranded state.
  *   - enqueueEvent returns shouldStart=true only on the idle→active edge.
  */
 const MAX_QUEUE_SIZE = 100;
@@ -30,6 +33,18 @@ export function popEvent(taskId) {
     activeRuns.delete(taskId);
     return { empty: true };
 }
+export function hasPendingEvents(taskId) {
+    const queue = queues.get(taskId);
+    return !!queue && queue.length > 0;
+}
+/** Drop a stranded active flag so a fresh run can be launched (watchdog only). */
+export function resetActiveRun(taskId) {
+    activeRuns.delete(taskId);
+}
+/** Re-acquire the active flag without enqueuing (watchdog relaunch only). */
+export function markActiveRun(taskId) {
+    activeRuns.add(taskId);
+}
 /** Remove any state for a task (called from task.delete). */
 export function clearTaskQueue(taskId) {
     queues.delete(taskId);