palmier 0.9.28 → 0.9.30

package/dist/command-runners.js

@@ -16,7 +16,7 @@ import * as readline from "readline";
 import { execFileSync } from "child_process";
 import { spawnStreamingCommand } from "./spawn-command.js";
 import { getTaskDir, listTasks, parseTaskFile } from "./task.js";
-import { enqueueEvent } from "./event-queues.js";
+import { dispatchTrigger } from "./trigger-dispatch.js";
 import { getPlatform } from "./platform/index.js";
 const runners = new Map();
 const stopping = new Set();
@@ -49,12 +49,8 @@ function spawnRunner(config, taskId, command) {
     rl.on("line", (line) => {
         if (!line.trim())
             return;
-        const { shouldStart } = enqueueEvent(taskId, line);
-        if (shouldStart) {
-            platform.startTask(taskId).catch((err) => {
-                console.error(`[command-runner] failed to start run for ${taskId}:`, err);
-            });
-        }
+        console.log(`[command-runner] ${taskId} stdout line (${line.length} chars): ${line.slice(0, 100)}`);
+        dispatchTrigger(taskId, line);
     });
     child.stderr?.on("data", (d) => process.stderr.write(d));
     const handleExit = () => {

package/dist/commands/serve.js

@@ -14,7 +14,7 @@ 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");
@@ -157,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,11 @@ export declare function popEvent(taskId: string): {
 } | {
     empty: true;
 };
+export declare function hasPendingEvents(taskId: string): boolean;
+export declare function pendingCount(taskId: string): number;
+/** 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,21 @@ export function popEvent(taskId) {
     activeRuns.delete(taskId);
     return { empty: true };
 }
+export function hasPendingEvents(taskId) {
+    const queue = queues.get(taskId);
+    return !!queue && queue.length > 0;
+}
+export function pendingCount(taskId) {
+    return queues.get(taskId)?.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);