loop-task 1.3.0 → 1.4.1

package/dist/core/loop-controller.js

@@ -1,5 +1,6 @@
 import { EventEmitter } from "node:events";
 import fs from "node:fs";
+import crypto from "node:crypto";
 import { sleep } from "../shared/sleep.js";
 import { SLEEP_CHUNK_MS } from "../config/constants.js";
 import { executeCommand } from "./command-runner.js";
@@ -9,7 +10,10 @@ export class LoopController extends EventEmitter {
     runAbortController = null;
     _paused = false;
     _forceRun = false;
-    interruptedForForceRun = false;
+    _savedRemainingMs = null;
+    _resetSchedule = false;
+    _stopAfterRun = false;
+    _maxRunsReached = false;
     _status = "running";
     resumeResolve = null;
     runCount = 0;
@@ -21,34 +25,47 @@ export class LoopController extends EventEmitter {
     id;
     options;
     logPath;
+    taskResolver;
     remainingDelayMs = null;
     logStream = null;
     loopPromise = null;
+    sessionStartedAt = null;
     runHistory = [];
     currentRunStartOffset = 0;
-    constructor(id, options, logPath, state) {
+    skippedCount = 0;
+    constructor(id, options, logPath, taskResolver, state) {
         super();
         this.id = id;
         this.options = options;
         this.logPath = logPath;
+        this.taskResolver = taskResolver;
         this.abortController = new AbortController();
         this.createdAt = state?.createdAt ?? new Date().toISOString();
         this.runCount = state?.runCount ?? 0;
+        this._maxRunsReached = state?.maxRunsReached ?? false;
+        this.sessionStartedAt = state?.sessionStartedAt ?? null;
         this.lastRunAt = state?.lastRunAt ?? null;
         this.lastExitCode = state?.lastExitCode ?? null;
         this.lastDuration = state?.lastDuration ?? null;
         this.nextRunAt = state?.nextRunAt ?? null;
         this.remainingDelayMs = state?.remainingDelayMs ?? null;
         this._status = state?.status ?? "running";
-        this._paused = state?.status === "paused";
-        this.runHistory = state?.runHistory ?? [];
+        this._paused = state?.status === "paused" || state?.status === "idle";
+        this.runHistory = (state?.runHistory ?? []).map((r) => r.status === "running" ? { ...r, status: "completed" } : r).map((r) => ({ ...r, logOffset: r.logOffset ?? 0 }));
+        this.skippedCount = state?.skippedCount ?? 0;
     }
     get status() {
         return this._status;
     }
     start() {
+        this.skippedCount = 0;
+        this.logStream?.end();
+        this.abortController = new AbortController();
         this.logStream = fs.createWriteStream(this.logPath, { flags: "a" });
         this.loopPromise = this.run();
+        if (this.sessionStartedAt === null) {
+            this.sessionStartedAt = new Date().toISOString();
+        }
     }
     pause(interruptCurrentRun = false) {
         if (this._status === "running" || this._status === "waiting") {
@@ -60,8 +77,21 @@ export class LoopController extends EventEmitter {
             this.emit("paused");
         }
     }
+    stopLoop(interruptCurrentRun = false) {
+        if (this._status === "running" || this._status === "waiting" || this._status === "paused") {
+            this._paused = true;
+            this._status = "idle";
+            this.sessionStartedAt = null;
+            this.remainingDelayMs = null;
+            this.nextRunAt = null;
+            if (interruptCurrentRun) {
+                this.runAbortController?.abort();
+            }
+            this.emit("stopped");
+        }
+    }
     resume() {
-        if (this._paused && this.resumeResolve) {
+        if (this._status === "paused" && this._paused && this.resumeResolve) {
             this._paused = false;
             if (this.remainingDelayMs !== null) {
                 this._status = "waiting";
@@ -72,19 +102,45 @@ export class LoopController extends EventEmitter {
             this.emit("resumed");
         }
     }
-    triggerNow(interruptCurrentRun = false) {
-        if (this._status === "stopped") {
+    playLoop() {
+        if (this._status !== "idle" && this._status !== "stopped")
+            return false;
+        if (this._maxRunsReached)
+            return false;
+        if (this.options.maxRuns !== null && this.runCount >= this.options.maxRuns) {
+            this._maxRunsReached = true;
             return false;
         }
+        this.sessionStartedAt = new Date().toISOString();
+        this._resetSchedule = true;
+        this._paused = false;
+        this._status = "waiting";
+        this.nextRunAt = new Date(Date.now() + this.options.interval).toISOString();
+        if (this.resumeResolve) {
+            this.resumeResolve();
+            this.resumeResolve = null;
+        }
+        this.start();
+        this.emit("resumed");
+        return true;
+    }
+    triggerNow() {
+        if (this._status === "running")
+            return false;
+        if (this._maxRunsReached)
+            return false;
+        const needsStart = this._status === "stopped" || this._status === "idle";
+        this._savedRemainingMs = this.remainingDelayMs;
         this._forceRun = true;
-        this.remainingDelayMs = null;
-        this.nextRunAt = null;
-        if (interruptCurrentRun) {
-            this.interruptedForForceRun = true;
-            this.runAbortController?.abort();
+        if (needsStart) {
+            this._stopAfterRun = true;
+            this._paused = false;
+            this._status = "running";
+            this.start();
         }
-        if (this._paused) {
-            this.resume();
+        else {
+            if (this._paused)
+                this.resume();
         }
         this.emit("triggered");
         return true;
@@ -102,8 +158,11 @@ export class LoopController extends EventEmitter {
     getMeta() {
         return {
             id: this.id,
+            taskId: this.options.taskId,
             status: this._status,
             createdAt: this.createdAt,
+            maxRunsReached: this._maxRunsReached,
+            sessionStartedAt: this.sessionStartedAt,
             runCount: this.runCount,
             lastRunAt: this.lastRunAt,
             lastExitCode: this.lastExitCode,
@@ -111,10 +170,22 @@ export class LoopController extends EventEmitter {
             nextRunAt: this.nextRunAt,
             remainingDelayMs: this.remainingDelayMs,
             runHistory: this.runHistory,
+            skippedCount: this.skippedCount,
         };
     }
+    clearMaxRunsReached() {
+        this._maxRunsReached = false;
+        this._paused = false;
+        this._status = "idle";
+        this.remainingDelayMs = null;
+        this.nextRunAt = null;
+    }
+    isMaxRunsReached() {
+        return this._maxRunsReached;
+    }
     async waitForResume() {
-        this._status = "paused";
+        const savedStatus = this._status;
+        this._status = savedStatus === "idle" ? "idle" : "paused";
         return new Promise((resolve) => {
             this.resumeResolve = resolve;
         });
@@ -125,12 +196,21 @@ export class LoopController extends EventEmitter {
         let announced = false;
         while (remaining > 0) {
             if (this._forceRun) {
+                this._savedRemainingMs = remaining;
                 this.remainingDelayMs = null;
                 this.nextRunAt = null;
                 return true;
             }
+            if (this._resetSchedule) {
+                this._resetSchedule = false;
+                remaining = ms;
+                this.remainingDelayMs = remaining;
+                announced = false;
+            }
             if (this._paused) {
-                this._status = "paused";
+                if (this._status !== "idle") {
+                    this._status = "paused";
+                }
                 this.emit("paused");
                 await this.waitForResume();
                 announced = false;
@@ -138,6 +218,11 @@ export class LoopController extends EventEmitter {
                     this.remainingDelayMs = null;
                     return false;
                 }
+                if (this._resetSchedule) {
+                    this._resetSchedule = false;
+                    remaining = ms;
+                    this.remainingDelayMs = remaining;
+                }
             }
             if (!announced) {
                 this._status = "waiting";
@@ -167,8 +252,10 @@ export class LoopController extends EventEmitter {
         try {
             while (!signal.aborted) {
                 if (this.options.maxRuns !== null && this.runCount >= this.options.maxRuns) {
-                    this._status = "stopped";
-                    this.emit("stopped");
+                    this._maxRunsReached = true;
+                    this._paused = true;
+                    this._status = "paused";
+                    this.emit("paused");
                     return;
                 }
                 if (isFirstRun && this._paused) {
@@ -201,49 +288,140 @@ export class LoopController extends EventEmitter {
                 this._forceRun = false;
                 this.runCount++;
                 this.lastRunAt = new Date().toISOString();
+                const runStartedAtMs = Date.now();
+                if (this.sessionStartedAt === null) {
+                    this.sessionStartedAt = this.lastRunAt;
+                }
                 this.nextRunAt = null;
                 this.emit("run:start", this.runCount);
                 this.logStream = rotateLogIfNeeded(this.logPath, this.logStream);
                 this.currentRunStartOffset = fs.existsSync(this.logPath) ? fs.statSync(this.logPath).size : 0;
+                this.runHistory.push({
+                    runNumber: this.runCount,
+                    startedAt: this.lastRunAt,
+                    exitCode: -1,
+                    duration: 0,
+                    logSize: 0,
+                    status: "running",
+                    logOffset: this.currentRunStartOffset,
+                });
                 this.runAbortController = new AbortController();
-                const result = await executeCommand(this.options.command, this.options.commandArgs, this.options.cwd, this.logStream, AbortSignal.any([signal, this.runAbortController.signal]), this.runCount);
+                const task = this.options.taskId ? this.taskResolver(this.options.taskId) : null;
+                const command = task?.command ?? this.options.command;
+                const commandArgs = task?.commandArgs ?? this.options.commandArgs;
+                const cwd = this.options.cwd;
+                const result = await executeCommand(command, commandArgs, cwd, this.logStream, AbortSignal.any([signal, this.runAbortController.signal]), this.runCount);
                 this.runAbortController = null;
                 this.lastExitCode = result.exitCode;
                 this.lastDuration = result.duration;
-                if (!this.interruptedForForceRun) {
-                    const logSize = fs.existsSync(this.logPath) ? fs.statSync(this.logPath).size - this.currentRunStartOffset : 0;
+                const logSize = fs.existsSync(this.logPath) ? fs.statSync(this.logPath).size - this.currentRunStartOffset : 0;
+                const runningRecord = this.runHistory.find((r) => r.runNumber === this.runCount);
+                if (runningRecord) {
+                    runningRecord.exitCode = result.exitCode;
+                    runningRecord.duration = result.duration;
+                    runningRecord.logSize = Math.max(0, logSize);
+                    runningRecord.status = "completed";
+                }
+                else {
                     this.runHistory.push({
                         runNumber: this.runCount,
                         startedAt: this.lastRunAt,
                         exitCode: result.exitCode,
                         duration: result.duration,
                         logSize: Math.max(0, logSize),
+                        status: "completed",
+                        logOffset: this.currentRunStartOffset,
                     });
-                    if (this.runHistory.length > 50) {
-                        this.runHistory = this.runHistory.slice(-50);
+                }
+                const chainTargetId = result.exitCode === 0 ? task?.onSuccessTaskId : task?.onFailureTaskId;
+                if (chainTargetId) {
+                    const chainTask = this.taskResolver(chainTargetId);
+                    if (chainTask) {
+                        const chainGroupId = crypto.randomUUID().slice(0, 8);
+                        const mainRecord = this.runHistory[this.runHistory.length - 1];
+                        if (mainRecord)
+                            mainRecord.chainGroupId = chainGroupId;
+                        const chainStartedAt = new Date().toISOString();
+                        const chainOffset = fs.existsSync(this.logPath) ? fs.statSync(this.logPath).size : 0;
+                        this.runHistory.push({
+                            runNumber: this.runCount,
+                            startedAt: chainStartedAt,
+                            exitCode: -1,
+                            duration: 0,
+                            logSize: 0,
+                            status: "running",
+                            logOffset: chainOffset,
+                            chainGroupId,
+                            chainName: chainTask.name,
+                        });
+                        const chainResult = await executeCommand(chainTask.command, chainTask.commandArgs, this.options.cwd, this.logStream, signal, this.runCount);
+                        const chainLogSize = fs.existsSync(this.logPath) ? fs.statSync(this.logPath).size - chainOffset : 0;
+                        const chainRecord = this.runHistory.find((r) => r.chainGroupId === chainGroupId && r.status === "running");
+                        if (chainRecord) {
+                            chainRecord.exitCode = chainResult.exitCode;
+                            chainRecord.duration = chainResult.duration;
+                            chainRecord.logSize = Math.max(0, chainLogSize);
+                            chainRecord.status = "completed";
+                        }
+                        this.lastExitCode = chainResult.exitCode;
+                        this.lastDuration = (this.lastDuration ?? 0) + chainResult.duration;
                     }
                 }
-                if (this.interruptedForForceRun) {
-                    this.runCount = Math.max(0, this.runCount - 1);
-                    this.interruptedForForceRun = false;
-                    this._forceRun = true;
+                if (this.runHistory.length > 50) {
+                    this.runHistory = this.runHistory.slice(-50);
                 }
                 this.emit("run:end", result);
                 if (signal.aborted)
                     break;
                 if (this.options.maxRuns !== null && this.runCount >= this.options.maxRuns) {
-                    this._status = "stopped";
+                    this._maxRunsReached = true;
+                    this._paused = true;
+                    this._status = "paused";
+                    this.remainingDelayMs = null;
+                    this.nextRunAt = null;
+                    this.emit("paused");
+                    return;
+                }
+                if (this._stopAfterRun) {
+                    this._stopAfterRun = false;
+                    this._paused = true;
+                    this._status = "idle";
+                    this.remainingDelayMs = null;
+                    this.nextRunAt = null;
                     this.emit("stopped");
                     return;
                 }
-                const completed = await this.waitForDelay(this.options.interval, signal);
-                if (!completed) {
-                    break;
+                const saved = this._savedRemainingMs;
+                this._savedRemainingMs = null;
+                if (saved !== null) {
+                    const remaining = Math.max(0, saved - result.duration);
+                    if (remaining > 0) {
+                        const completed = await this.waitForDelay(remaining, signal);
+                        if (!completed)
+                            break;
+                    }
+                }
+                else {
+                    const nextSlotMs = runStartedAtMs + this.options.interval;
+                    const overrunMs = Date.now() - nextSlotMs;
+                    if (overrunMs >= 0) {
+                        const missed = Math.floor(overrunMs / this.options.interval) + 1;
+                        this.skippedCount += missed;
+                        const adjustedDelay = this.options.interval - (overrunMs % this.options.interval);
+                        const completed = await this.waitForDelay(adjustedDelay, signal);
+                        if (!completed)
+                            break;
+                    }
+                    else {
+                        const completed = await this.waitForDelay(this.options.interval, signal);
+                        if (!completed)
+                            break;
+                    }
                 }
             }
         }
         finally {
-            if (this._status !== "stopped") {
+            if (this._status !== "stopped" && this._status !== "idle" && this._status !== "paused" && !this._maxRunsReached) {
                 this._status = "stopped";
             }
         }

package/dist/daemon/index.js

@@ -1,11 +1,14 @@
 import { LoopManager } from "./manager.js";
+import { TaskManager } from "./task-manager.js";
 import { IpcServer } from "./server.js";
 import { writeDaemonPid, removeDaemonPid, writeDaemonSignature, removeDaemonSignature, computeCodeSignature, } from "./state.js";
 import { t } from "../i18n/index.js";
 import { daemonLog } from "./daemon-log.js";
 async function main() {
-    const manager = new LoopManager();
-    const server = new IpcServer(manager);
+    const taskManager = new TaskManager();
+    taskManager.init();
+    const manager = new LoopManager(taskManager);
+    const server = new IpcServer(manager, taskManager);
     try {
         await server.listen();
     }

package/dist/daemon/manager.js

@@ -1,31 +1,56 @@
 import crypto from "node:crypto";
 import { LoopController } from "../core/loop-controller.js";
+import { ProjectManager } from "./projects.js";
 import { saveLoop, loadAllLoops, deleteLoop as deleteLoopState, getLogPath, } from "./state.js";
 import { daemonLog } from "./daemon-log.js";
 export class LoopManager {
     loops = new Map();
     lastSerialized = new Map();
+    taskManager;
+    projectManager;
+    constructor(taskManager, projectManager) {
+        this.taskManager = taskManager;
+        this.projectManager = projectManager || new ProjectManager();
+    }
+    taskResolver = (taskId) => this.taskManager.get(taskId);
     init() {
+        // Initialize projects first
+        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.status === "stopped")
-                continue;
+            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,
                 command: meta.command,
                 commandArgs: meta.commandArgs,
+                cwd: meta.cwd ?? "",
                 immediate: false,
                 maxRuns: meta.maxRuns,
                 verbose: meta.verbose,
-                cwd: meta.cwd ?? "",
                 description: meta.description ?? "",
+                projectId: meta.projectId ?? "default",
             };
             const logPath = getLogPath(meta.id);
-            const controller = new LoopController(meta.id, options, logPath, {
+            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,
@@ -39,8 +64,13 @@ export class LoopManager {
                 intervalHuman: meta.intervalHuman,
             });
             this.wireEvents(meta.id, controller, options, meta.intervalHuman);
-            controller.start();
-            restarted += 1;
+            if (shouldAutoStart(meta.status)) {
+                controller.start();
+                restarted += 1;
+            }
+        }
+        if (migrated > 0) {
+            daemonLog(`migrated ${migrated} loop(s) to task model`);
         }
         if (restarted > 0) {
             daemonLog(`restarted ${restarted} loop(s) from persisted state`);
@@ -49,7 +79,7 @@ export class LoopManager {
     start(options, intervalHuman) {
         const id = crypto.randomUUID().slice(0, 8);
         const logPath = getLogPath(id);
-        const controller = new LoopController(id, options, logPath);
+        const controller = new LoopController(id, options, logPath, this.taskResolver);
         this.loops.set(id, { controller, options, intervalHuman });
         controller.start();
         this.wireEvents(id, controller, options, intervalHuman);
@@ -61,19 +91,20 @@ export class LoopManager {
         if (!entry)
             return false;
         const executionChanged = entry.options.interval !== options.interval ||
-            entry.options.command !== options.command ||
-            entry.options.commandArgs.length !== options.commandArgs.length ||
-            entry.options.commandArgs.some((arg, index) => arg !== options.commandArgs[index]) ||
+            entry.options.taskId !== options.taskId ||
             entry.options.immediate !== options.immediate ||
             entry.options.maxRuns !== options.maxRuns ||
-            entry.options.verbose !== options.verbose ||
-            entry.options.cwd !== options.cwd;
+            entry.options.verbose !== options.verbose;
+        const maxRunsChanged = entry.options.maxRuns !== options.maxRuns;
         Object.assign(entry.options, options);
         entry.intervalHuman = intervalHuman;
+        if (maxRunsChanged) {
+            entry.controller.clearMaxRunsReached();
+        }
         if (entry.controller.status === "running") {
             entry.controller.pause(true);
         }
-        else if (executionChanged && entry.controller.status !== "paused") {
+        else if (executionChanged && entry.controller.status !== "paused" && entry.controller.status !== "idle") {
             entry.controller.pause();
         }
         this.persist(id, entry.controller, entry.options, entry.intervalHuman);
@@ -86,6 +117,24 @@ export class LoopManager {
         }
         return result;
     }
+    listProjects() {
+        return this.projectManager.getAll();
+    }
+    createProject(name, color) {
+        return this.projectManager.create(name, color);
+    }
+    updateProject(id, name, color) {
+        this.projectManager.update(id, name, color);
+    }
+    deleteProject(id) {
+        for (const [loopId, entry] of this.loops) {
+            if (entry.options.projectId === id) {
+                entry.options.projectId = "default";
+                this.persist(loopId, entry.controller, entry.options, entry.intervalHuman);
+            }
+        }
+        this.projectManager.delete(id);
+    }
     status(id) {
         const entry = this.loops.get(id);
         if (!entry)
@@ -108,14 +157,42 @@ export class LoopManager {
         this.persist(id, entry.controller, entry.options, entry.intervalHuman);
         return true;
     }
-    trigger(id) {
+    stopLoop(id) {
         const entry = this.loops.get(id);
         if (!entry)
             return false;
-        entry.controller.triggerNow(true);
+        entry.controller.stopLoop();
         this.persist(id, entry.controller, entry.options, entry.intervalHuman);
         return true;
     }
+    playLoop(id) {
+        const entry = this.loops.get(id);
+        if (!entry)
+            return false;
+        const ok = entry.controller.playLoop();
+        if (ok) {
+            this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+        }
+        return ok;
+    }
+    trigger(id) {
+        const entry = this.loops.get(id);
+        if (!entry)
+            return false;
+        const ok = entry.controller.triggerNow();
+        if (ok) {
+            this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+        }
+        return ok;
+    }
+    isMaxRunsBlocked(id) {
+        const entry = this.loops.get(id);
+        return !!entry?.controller.isMaxRunsReached();
+    }
+    isRunning(id) {
+        const entry = this.loops.get(id);
+        return entry?.controller.status === "running";
+    }
     async delete(id) {
         const entry = this.loops.get(id);
         if (!entry)
@@ -150,7 +227,7 @@ export class LoopManager {
         controller.on("stopped", persist);
     }
     persist(id, controller, options, intervalHuman) {
-        const meta = toMeta(controller, options, intervalHuman);
+        const meta = this.toMeta(controller, options, intervalHuman);
         const serialized = JSON.stringify(meta);
         if (this.lastSerialized.get(id) === serialized) {
             return;
@@ -159,23 +236,25 @@ export class LoopManager {
         saveLoop(meta);
     }
     buildMeta(id, entry) {
-        return toMeta(entry.controller, entry.options, entry.intervalHuman);
+        return this.toMeta(entry.controller, entry.options, entry.intervalHuman);
+    }
+    toMeta(controller, options, intervalHuman) {
+        const runtime = controller.getMeta();
+        const task = options.taskId ? this.taskManager.get(options.taskId) : null;
+        return {
+            ...runtime,
+            command: task?.command ?? options.command,
+            commandArgs: task?.commandArgs ?? options.commandArgs,
+            cwd: options.cwd || "",
+            interval: options.interval,
+            intervalHuman,
+            immediate: options.immediate,
+            maxRuns: options.maxRuns,
+            verbose: options.verbose,
+            description: options.description,
+            remainingDelayMs: runtime.remainingDelayMs,
+            pid: process.pid,
+            projectId: options.projectId ?? "default",
+        };
     }
-}
-function toMeta(controller, options, intervalHuman) {
-    const runtime = controller.getMeta();
-    return {
-        ...runtime,
-        command: options.command,
-        commandArgs: options.commandArgs,
-        interval: options.interval,
-        intervalHuman,
-        immediate: options.immediate,
-        maxRuns: options.maxRuns,
-        verbose: options.verbose,
-        cwd: options.cwd,
-        description: options.description,
-        remainingDelayMs: runtime.remainingDelayMs,
-        pid: process.pid,
-    };
 }