loop-task 1.1.0 → 1.4.0

package/dist/core/loop-controller.js

@@ -0,0 +1,429 @@
+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";
+import { rotateLogIfNeeded } from "./log-rotator.js";
+export class LoopController extends EventEmitter {
+    abortController;
+    runAbortController = null;
+    _paused = false;
+    _forceRun = false;
+    _savedRemainingMs = null;
+    _resetSchedule = false;
+    _stopAfterRun = false;
+    _maxRunsReached = false;
+    _status = "running";
+    resumeResolve = null;
+    runCount = 0;
+    lastRunAt = null;
+    lastExitCode = null;
+    lastDuration = null;
+    nextRunAt = null;
+    createdAt;
+    id;
+    options;
+    logPath;
+    taskResolver;
+    remainingDelayMs = null;
+    logStream = null;
+    loopPromise = null;
+    sessionStartedAt = null;
+    runHistory = [];
+    currentRunStartOffset = 0;
+    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" || 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") {
+            this._paused = true;
+            this._status = "paused";
+            if (interruptCurrentRun && this._status === "paused") {
+                this.runAbortController?.abort();
+            }
+            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._status === "paused" && this._paused && this.resumeResolve) {
+            this._paused = false;
+            if (this.remainingDelayMs !== null) {
+                this._status = "waiting";
+                this.nextRunAt = new Date(Date.now() + this.remainingDelayMs).toISOString();
+            }
+            this.resumeResolve();
+            this.resumeResolve = null;
+            this.emit("resumed");
+        }
+    }
+    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;
+        if (needsStart) {
+            this._stopAfterRun = true;
+            this._paused = false;
+            this._status = "running";
+            this.start();
+        }
+        else {
+            if (this._paused)
+                this.resume();
+        }
+        this.emit("triggered");
+        return true;
+    }
+    async stop() {
+        this.abortController.abort();
+        if (this._paused)
+            this.resume();
+        if (this.loopPromise) {
+            await this.loopPromise;
+        }
+        this.logStream?.end();
+        this.logStream = null;
+    }
+    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,
+            lastDuration: this.lastDuration,
+            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() {
+        const savedStatus = this._status;
+        this._status = savedStatus === "idle" ? "idle" : "paused";
+        return new Promise((resolve) => {
+            this.resumeResolve = resolve;
+        });
+    }
+    async waitForDelay(ms, signal) {
+        let remaining = ms;
+        this.remainingDelayMs = remaining;
+        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) {
+                if (this._status !== "idle") {
+                    this._status = "paused";
+                }
+                this.emit("paused");
+                await this.waitForResume();
+                announced = false;
+                if (signal.aborted) {
+                    this.remainingDelayMs = null;
+                    return false;
+                }
+                if (this._resetSchedule) {
+                    this._resetSchedule = false;
+                    remaining = ms;
+                    this.remainingDelayMs = remaining;
+                }
+            }
+            if (!announced) {
+                this._status = "waiting";
+                this.nextRunAt = new Date(Date.now() + remaining).toISOString();
+                this.emit("waiting");
+                announced = true;
+            }
+            const chunk = Math.min(remaining, SLEEP_CHUNK_MS);
+            const startedAt = Date.now();
+            try {
+                await sleep(chunk, signal);
+            }
+            catch {
+                this.remainingDelayMs = null;
+                return false;
+            }
+            remaining = Math.max(0, remaining - (Date.now() - startedAt));
+            this.remainingDelayMs = remaining;
+        }
+        this.remainingDelayMs = null;
+        this.nextRunAt = null;
+        return true;
+    }
+    async run() {
+        const signal = this.abortController.signal;
+        let isFirstRun = true;
+        try {
+            while (!signal.aborted) {
+                if (this.options.maxRuns !== null && this.runCount >= this.options.maxRuns) {
+                    this._maxRunsReached = true;
+                    this._paused = true;
+                    this._status = "paused";
+                    this.emit("paused");
+                    return;
+                }
+                if (isFirstRun && this._paused) {
+                    await this.waitForResume();
+                    if (signal.aborted)
+                        break;
+                }
+                if (isFirstRun && this.nextRunAt) {
+                    const delay = Math.max(0, new Date(this.nextRunAt).getTime() - Date.now());
+                    if (delay > 0) {
+                        const completed = await this.waitForDelay(delay, signal);
+                        if (!completed) {
+                            break;
+                        }
+                    }
+                }
+                else if (isFirstRun && !this.options.immediate) {
+                    const completed = await this.waitForDelay(this.options.interval, signal);
+                    if (!completed) {
+                        break;
+                    }
+                }
+                isFirstRun = false;
+                if (this._paused) {
+                    await this.waitForResume();
+                    if (signal.aborted)
+                        break;
+                }
+                this._status = "running";
+                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 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 = task?.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;
+                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,
+                    });
+                }
+                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, chainTask.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.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._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 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" && this._status !== "idle" && this._status !== "paused" && !this._maxRunsReached) {
+                this._status = "stopped";
+            }
+        }
+    }
+}

package/dist/daemon/daemon-log.js

@@ -0,0 +1,11 @@
+import fs from "node:fs";
+import { getDataDir, getDaemonLogFile } from "../config/paths.js";
+export function daemonLog(message) {
+    try {
+        fs.mkdirSync(getDataDir(), { recursive: true });
+        fs.appendFileSync(getDaemonLogFile(), `${new Date().toISOString()} ${message}\n`);
+    }
+    catch {
+        // operational logging is best effort
+    }
+}

package/dist/daemon/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/daemon/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/daemon/index.ts"],"names":[],"mappings":""}

package/dist/daemon/index.js

@@ -0,0 +1,43 @@
+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 taskManager = new TaskManager();
+    taskManager.init();
+    const manager = new LoopManager(taskManager);
+    const server = new IpcServer(manager, taskManager);
+    try {
+        await server.listen();
+    }
+    catch (err) {
+        daemonLog(`listen failed (another daemon already holds the socket): ${String(err)}`);
+        process.exit(0);
+    }
+    manager.init();
+    writeDaemonPid(process.pid);
+    writeDaemonSignature(computeCodeSignature());
+    daemonLog(`started pid=${process.pid}`);
+    const cleanup = async () => {
+        daemonLog(`shutting down pid=${process.pid}`);
+        removeDaemonPid();
+        removeDaemonSignature();
+        await manager.shutdown();
+        await server.close();
+        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();
+    });
+}
+main().catch((err) => {
+    daemonLog(`failed to start: ${String(err)}`);
+    console.error(t("errors.daemonFailed"), err);
+    process.exit(1);
+});

package/dist/daemon/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/daemon/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7D,KAAK,UAAU,IAAI;IACjB,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;IAClC,OAAO,CAAC,IAAI,EAAE,CAAC;IAEf,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,OAAO,CAAC,CAAC;IACtC,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC;IAEtB,cAAc,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAE5B,MAAM,OAAO,GAAG,KAAK,IAAI,EAAE;QACzB,eAAe,EAAE,CAAC;QAClB,MAAM,OAAO,CAAC,QAAQ,EAAE,CAAC;QACzB,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACrB,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC,CAAC;IAEF,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC9B,OAAO,CAAC,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,CAAC,mBAAmB,EAAE,CAAC,GAAG,EAAE,EAAE;QACtC,OAAO,CAAC,KAAK,CAAC,4BAA4B,EAAE,GAAG,CAAC,CAAC;QACjD,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC,CAAC;AACL,CAAC;AAED,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE;IACnB,OAAO,CAAC,KAAK,CAAC,yBAAyB,EAAE,GAAG,CAAC,CAAC;IAC9C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/dist/daemon/manager.d.ts

@@ -0,0 +1,17 @@
+import type { LoopOptions, LoopMeta } from "../types.js";
+export declare class LoopManager {
+    private loops;
+    init(): void;
+    start(options: LoopOptions, intervalHuman: string): string;
+    list(): LoopMeta[];
+    status(id: string): LoopMeta | null;
+    pause(id: string): boolean;
+    resume(id: string): boolean;
+    delete(id: string): Promise<boolean>;
+    getLogPath(id: string): string | null;
+    shutdown(): Promise<void>;
+    private wireEvents;
+    private persist;
+    private buildMeta;
+}
+//# sourceMappingURL=manager.d.ts.map

package/dist/daemon/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../../src/daemon/manager.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAczD,qBAAa,WAAW;IACtB,OAAO,CAAC,KAAK,CAAiC;IAE9C,IAAI,IAAI,IAAI;IAiCZ,KAAK,CAAC,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAW1D,IAAI,IAAI,QAAQ,EAAE;IAQlB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;IAMnC,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAQ1B,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAQrB,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAS1C,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAK/B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAS/B,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,OAAO;IAsBf,OAAO,CAAC,SAAS;CAelB"}