loop-task 1.5.5 → 2.0.1

package/dist/daemon/index.js

@@ -1,6 +1,8 @@
 import { LoopManager } from "./manager.js";
 import { TaskManager } from "./task-manager.js";
 import { IpcServer } from "./server.js";
+import { HttpApiServer } from "./http-server.js";
+import { FileWatcher } from "./file-watcher.js";
 import { writeDaemonPid, removeDaemonPid, writeDaemonSignature, removeDaemonSignature, computeCodeSignature, migrateTasksToJson, migrateLoopsToJson, } from "./state.js";
 import { t } from "../i18n/index.js";
 import { daemonLog } from "./daemon-log.js";
@@ -11,6 +13,8 @@ async function main() {
     taskManager.init();
     const manager = new LoopManager(taskManager);
     const server = new IpcServer(manager, taskManager);
+    const projectManager = manager.projectManager;
+    const httpServer = new HttpApiServer(manager, taskManager, projectManager);
     try {
         await server.listen();
     }
@@ -18,24 +22,50 @@ async function main() {
         daemonLog(`listen failed (another daemon already holds the socket): ${String(err)}`);
         process.exit(0);
     }
+    try {
+        const httpPort = parseInt(process.env.LOOP_CLI_HTTP_PORT ?? "", 10);
+        await httpServer.listen(Number.isNaN(httpPort) ? undefined : httpPort);
+    }
+    catch (err) {
+        daemonLog(`HTTP API server failed to start: ${String(err)}`);
+    }
     manager.init();
     writeDaemonPid(process.pid);
     writeDaemonSignature(computeCodeSignature());
     daemonLog(`started pid=${process.pid}`);
+    const fileWatcher = new FileWatcher();
+    fileWatcher.setManagers(manager, taskManager, manager["projectManager"]);
+    fileWatcher.start();
+    daemonLog(`file watcher started for hot-reloading JSON configs`);
+    let shuttingDown = false;
     const cleanup = async () => {
+        // Re-entry guard: a persist failure during shutdown must not re-trigger
+        // cleanup via uncaughtException, or the daemon crash-loops forever.
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
         daemonLog(`shutting down pid=${process.pid}`);
-        removeDaemonPid();
-        removeDaemonSignature();
-        await manager.shutdown();
-        await server.close();
-        process.exit(0);
+        try {
+            fileWatcher.stop();
+            removeDaemonPid();
+            removeDaemonSignature();
+            await manager.shutdown();
+            await server.close();
+            await httpServer.close();
+        }
+        catch (err) {
+            daemonLog(`error during shutdown: ${String(err)}`);
+        }
+        finally {
+            process.exit(0);
+        }
     };
     process.on("SIGINT", cleanup);
     process.on("SIGTERM", cleanup);
     process.on("uncaughtException", (err) => {
         daemonLog(`uncaught exception: ${String(err)}`);
         console.error(t("errors.daemonUncaught"), err);
-        cleanup();
+        void cleanup();
     });
 }
 main().catch((err) => {

package/dist/daemon/manager.js

@@ -18,26 +18,18 @@ export class LoopManager {
         this.projectManager.init();
         const saved = loadAllLoops();
         let restarted = 0;
-        let migrated = 0;
         const shouldAutoStart = (s) => s !== "stopped" && s !== "idle";
         for (const meta of saved) {
             if (!meta.projectId) {
                 meta.projectId = "default";
                 saveLoop(meta);
             }
-            let taskId = meta.taskId;
-            if (!taskId && meta.command) {
-                const task = this.taskManager.createInline(meta.command, meta.commandArgs);
-                taskId = task.id;
-                meta.taskId = taskId;
-                saveLoop(meta);
-                migrated += 1;
-            }
             const options = {
                 interval: meta.interval,
-                taskId: taskId ?? null,
+                taskId: meta.taskId,
                 command: meta.command,
                 commandArgs: meta.commandArgs,
+                commandRaw: meta.commandRaw,
                 cwd: meta.cwd ?? "",
                 immediate: false,
                 maxRuns: meta.maxRuns,
@@ -70,9 +62,6 @@ export class LoopManager {
                 restarted += 1;
             }
         }
-        if (migrated > 0) {
-            daemonLog(`migrated ${migrated} loop(s) to task model`);
-        }
         if (restarted > 0) {
             daemonLog(`restarted ${restarted} loop(s) from persisted state`);
         }
@@ -93,6 +82,8 @@ export class LoopManager {
             return false;
         const executionChanged = entry.options.interval !== options.interval ||
             entry.options.taskId !== options.taskId ||
+            entry.options.command !== options.command ||
+            entry.options.commandArgs.join(" ") !== options.commandArgs.join(" ") ||
             entry.options.immediate !== options.immediate ||
             entry.options.maxRuns !== options.maxRuns ||
             entry.options.verbose !== options.verbose;
@@ -226,6 +217,95 @@ export class LoopManager {
         await Promise.all(stops);
         this.loops.clear();
     }
+    reconcile(newLoops) {
+        const newIds = new Set(newLoops.map((l) => l.id));
+        const shouldAutoStart = (s) => s !== "stopped" && s !== "idle";
+        for (const [existingId, entry] of this.loops) {
+            if (!newIds.has(existingId)) {
+                void entry.controller.stop().then(() => {
+                    this.loops.delete(existingId);
+                    this.lastSerialized.delete(existingId);
+                    deleteLoopState(existingId);
+                });
+            }
+        }
+        for (const meta of newLoops) {
+            const existing = this.loops.get(meta.id);
+            if (existing) {
+                const configChanged = existing.options.interval !== meta.interval ||
+                    existing.options.command !== meta.command ||
+                    existing.options.cwd !== (meta.cwd ?? "");
+                if (configChanged) {
+                    void existing.controller.stop().then(() => {
+                        const options = {
+                            interval: meta.interval,
+                            taskId: meta.taskId ?? null,
+                            command: meta.command,
+                            commandArgs: meta.commandArgs,
+                            cwd: meta.cwd ?? "",
+                            immediate: false,
+                            maxRuns: meta.maxRuns,
+                            verbose: meta.verbose,
+                            description: meta.description ?? "",
+                            projectId: meta.projectId ?? "default",
+                            offset: meta.offset ?? null,
+                        };
+                        const logPath = getLogPath(meta.id);
+                        const controller = new LoopController(meta.id, options, logPath, this.taskResolver, {
+                            status: meta.status,
+                            createdAt: meta.createdAt,
+                            runCount: meta.runCount,
+                            sessionStartedAt: meta.sessionStartedAt,
+                            lastRunAt: meta.lastRunAt,
+                            lastExitCode: meta.lastExitCode,
+                            lastDuration: meta.lastDuration,
+                            nextRunAt: meta.nextRunAt,
+                            remainingDelayMs: meta.remainingDelayMs,
+                            runHistory: meta.runHistory,
+                        });
+                        this.loops.set(meta.id, { controller, options, intervalHuman: meta.intervalHuman });
+                        this.wireEvents(meta.id, controller, options, meta.intervalHuman);
+                        if (shouldAutoStart(meta.status)) {
+                            controller.start();
+                        }
+                    });
+                }
+            }
+            else {
+                const options = {
+                    interval: meta.interval,
+                    taskId: meta.taskId ?? null,
+                    command: meta.command,
+                    commandArgs: meta.commandArgs,
+                    cwd: meta.cwd ?? "",
+                    immediate: false,
+                    maxRuns: meta.maxRuns,
+                    verbose: meta.verbose,
+                    description: meta.description ?? "",
+                    projectId: meta.projectId ?? "default",
+                    offset: meta.offset ?? null,
+                };
+                const logPath = getLogPath(meta.id);
+                const controller = new LoopController(meta.id, options, logPath, this.taskResolver, {
+                    status: meta.status,
+                    createdAt: meta.createdAt,
+                    runCount: meta.runCount,
+                    sessionStartedAt: meta.sessionStartedAt,
+                    lastRunAt: meta.lastRunAt,
+                    lastExitCode: meta.lastExitCode,
+                    lastDuration: meta.lastDuration,
+                    nextRunAt: meta.nextRunAt,
+                    remainingDelayMs: meta.remainingDelayMs,
+                    runHistory: meta.runHistory,
+                });
+                this.loops.set(meta.id, { controller, options, intervalHuman: meta.intervalHuman });
+                this.wireEvents(meta.id, controller, options, meta.intervalHuman);
+                if (shouldAutoStart(meta.status)) {
+                    controller.start();
+                }
+            }
+        }
+    }
     wireEvents(id, controller, options, intervalHuman) {
         const persist = () => this.persist(id, controller, options, intervalHuman);
         controller.on("run:start", persist);
@@ -255,6 +335,7 @@ export class LoopManager {
             ...runtime,
             command: task?.command ?? options.command,
             commandArgs: task?.commandArgs ?? options.commandArgs,
+            commandRaw: options.commandRaw,
             cwd: options.cwd || "",
             interval: options.interval,
             intervalHuman,

package/dist/daemon/projects.js

@@ -122,4 +122,14 @@ export class ProjectManager {
         this.projects.delete(id);
         this.saveAllProjects();
     }
+    reload(newProjects) {
+        this.projects.clear();
+        for (const project of newProjects) {
+            this.projects.set(project.id, project);
+        }
+        if (!this.projects.has("default")) {
+            this.createDefaultProject();
+        }
+        daemonLog(`reloaded ${newProjects.length} project(s) from external change`);
+    }
 }

package/dist/daemon/server.js

@@ -12,6 +12,7 @@ export class IpcServer {
     taskManager;
     socketPath;
     clients = new Set();
+    subscribers = new Set();
     constructor(manager, taskManager) {
         this.manager = manager;
         this.taskManager = taskManager;
@@ -33,6 +34,7 @@ export class IpcServer {
             client.destroy();
         }
         this.clients.clear();
+        this.subscribers.clear();
         return new Promise((resolve) => {
             this.server.close(() => {
                 removeSocketFile();
@@ -40,8 +42,22 @@ export class IpcServer {
             });
         });
     }
+    pushEvent(event, data) {
+        for (const socket of this.subscribers) {
+            try {
+                send(socket, { type: "event", event, data });
+            }
+            catch {
+                this.subscribers.delete(socket);
+            }
+        }
+    }
     handleConnection(socket) {
         this.clients.add(socket);
+        socket.on("close", () => {
+            this.clients.delete(socket);
+            this.subscribers.delete(socket);
+        });
         let buffer = "";
         socket.on("data", (chunk) => {
             buffer += chunk.toString();
@@ -218,6 +234,11 @@ export class IpcServer {
                 }
                 break;
             }
+            case "subscribe": {
+                this.subscribers.add(socket);
+                send(socket, { type: "ok" });
+                break;
+            }
             case "shutdown": {
                 send(socket, { type: "ok" });
                 await this.manager.shutdown();

package/dist/daemon/task-manager.js

@@ -55,4 +55,11 @@ export class TaskManager {
             onFailureTaskId: null,
         });
     }
+    reload(newTasks) {
+        this.tasks.clear();
+        for (const task of newTasks) {
+            this.tasks.set(task.id, task);
+        }
+        daemonLog(`reloaded ${newTasks.length} task(s) from external change`);
+    }
 }

package/dist/esm-loader.js

@@ -14,7 +14,10 @@ export function resolve(specifier, context, nextResolve) {
     }
   }
 
-  if (specifier.includes("react-reconciler/constants") || specifier.includes("react-reconciler/reflection")) {
+  if (
+    (specifier.includes("react-reconciler/constants") || specifier.includes("react-reconciler/reflection")) &&
+    !specifier.endsWith(".js")
+  ) {
     return nextResolve(specifier + ".js", context);
   }
 

package/dist/hooks/useLoopFormValidation.js

@@ -0,0 +1,140 @@
+import fs from "node:fs";
+import { parseDuration } from "../duration.js";
+import { parseMaxRuns } from "../loop-config.js";
+import { t } from "../i18n/index.js";
+// ── Types ───────────────────────────────────────────────────────────
+export const createFields = [
+    "interval",
+    "taskMode",
+    "command",
+    "cwd",
+    "taskId",
+    "description",
+    "runNow",
+    "maxRuns",
+    "project",
+];
+// ── Validation ──────────────────────────────────────────────────────
+/**
+ * Validates a single loop form field and returns an error string, or
+ * `null` if the value is valid.
+ *
+ * Mirrors the validation logic used in the board's CreateForm submit()
+ * and the TUI's validation utility, but in a single shared hook that
+ * both surfaces can consume.
+ *
+ * @param key   - The field to validate.
+ * @param values - All form values (needed for cross-field rules like
+ *                 "command is required only when taskMode is inline").
+ */
+function validateField(key, values) {
+    const value = values[key] ?? "";
+    switch (key) {
+        // ── interval ──────────────────────────────────────────────────
+        // Always required; delegates to parseDuration() which throws on
+        // empty, invalid syntax, or non-positive values.
+        case "interval": {
+            if (!value.trim()) {
+                return t("errors.durationEmpty");
+            }
+            try {
+                parseDuration(value);
+                return null;
+            }
+            catch (err) {
+                return err instanceof Error ? err.message : String(err);
+            }
+        }
+        // ── command ───────────────────────────────────────────────────
+        // Required only when the user chose inline mode.
+        case "command": {
+            if (values.taskMode === "existing")
+                return null;
+            if (!value.trim()) {
+                return t("errors.commandEmpty");
+            }
+            return null;
+        }
+        // ── cwd ───────────────────────────────────────────────────────
+        // Optional; if provided the directory must exist on disk.
+        case "cwd": {
+            if (!value.trim())
+                return null;
+            if (!fs.existsSync(value)) {
+                return t("board.cwdMissing", { cwd: value });
+            }
+            return null;
+        }
+        // ── description ───────────────────────────────────────────────
+        // Always required.
+        case "description": {
+            if (!value.trim()) {
+                return t("errors.descriptionEmpty");
+            }
+            return null;
+        }
+        // ── maxRuns ───────────────────────────────────────────────────
+        // Optional; if provided it must be a positive integer.
+        case "maxRuns": {
+            if (!value.trim())
+                return null;
+            try {
+                parseMaxRuns(value);
+                return null;
+            }
+            catch (err) {
+                return err instanceof Error ? err.message : String(err);
+            }
+        }
+        // ── no validation needed ──────────────────────────────────────
+        case "taskMode":
+        case "runNow":
+        case "project":
+        case "taskId":
+            return null;
+    }
+}
+/**
+ * Validates every relevant field and returns a map of field-key → error
+ * message. Only fields that fail validation appear in the map (omitted
+ * fields are valid).
+ */
+function validateAll(values) {
+    const errors = {};
+    const fieldsToValidate = [
+        "interval",
+        "command",
+        "cwd",
+        "description",
+        "maxRuns",
+    ];
+    for (const field of fieldsToValidate) {
+        const error = validateField(field, values);
+        if (error !== null) {
+            errors[field] = error;
+        }
+    }
+    return errors;
+}
+// ── Hook ────────────────────────────────────────────────────────────
+/**
+ * Shared form-validation hook for loop creation / edit forms.
+ *
+ * Returns stable references to `validateField` and `validateAll` so it
+ * can be called from any React component without triggering re-renders.
+ *
+ * @example
+ * ```ts
+ * const { validateField, validateAll } = useLoopFormValidation();
+ *
+ * // On-blur per-field check:
+ * const err = validateField("interval", values);
+ *
+ * // On-submit full check:
+ * const errors = validateAll(values);
+ * if (Object.keys(errors).length === 0) { submit(); }
+ * ```
+ */
+export function useLoopFormValidation() {
+    return { validateField, validateAll };
+}