@plainconceptsplatform/loop-task 2.6.0

package/dist/daemon/http/route-loops.js

@@ -0,0 +1,311 @@
+import fs from "node:fs";
+import { LOG_TAIL_DEFAULT } from "../../shared/config/constants.js";
+import { tailFileBounded, readByteRange } from "../../core/logging/bounded-log-reader.js";
+import { followLogFile } from "../../core/logging/log-follower.js";
+import { buildLoopOptions } from "../../loop-config.js";
+import { validateContext } from "../../core/context/validate-context.js";
+import { sendOk, sendError, sendNotFound, parseQuery, readBody } from "./helpers.js";
+export function registerLoopRoutes(manager, routes, r) {
+    r("GET", "/api/loops", (_req, res) => {
+        sendOk(res, manager.list());
+    });
+    r("GET", "/api/loops/:id", (_req, res, params) => {
+        const meta = manager.status(params.id);
+        if (!meta) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        sendOk(res, meta);
+    });
+    r("POST", "/api/loops", async (req, res) => {
+        try {
+            const body = await readBody(req);
+            let context;
+            if (body.context !== undefined) {
+                const result = validateContext(body.context);
+                if (!result.valid) {
+                    sendError(res, 400, result.error);
+                    return;
+                }
+                context = result.context;
+            }
+            const intervalHuman = body.intervalHuman ?? "5m";
+            const { options } = buildLoopOptions(intervalHuman, {
+                command: body.command,
+                commandArgs: body.commandArgs,
+                taskId: body.taskId,
+                cwd: body.cwd,
+                now: body.now,
+                maxRuns: body.maxRuns,
+                verbose: body.verbose,
+                description: body.description,
+                projectId: body.projectId,
+                offset: body.offset,
+                context,
+            });
+            const id = manager.start(options, intervalHuman);
+            sendOk(res, { id }, 201);
+        }
+        catch (err) {
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+    r("PATCH", "/api/loops/:id", async (req, res, params) => {
+        try {
+            const body = await readBody(req);
+            let context;
+            if (body.context !== undefined) {
+                const result = validateContext(body.context);
+                if (!result.valid) {
+                    sendError(res, 400, result.error);
+                    return;
+                }
+                context = result.context;
+            }
+            const intervalHuman = body.intervalHuman ?? "5m";
+            const { options } = buildLoopOptions(intervalHuman, {
+                command: body.command,
+                commandArgs: body.commandArgs,
+                taskId: body.taskId,
+                cwd: body.cwd,
+                now: body.now,
+                maxRuns: body.maxRuns,
+                verbose: body.verbose,
+                description: body.description,
+                projectId: body.projectId,
+                offset: body.offset,
+                context,
+            });
+            const ok = await manager.update(params.id, options, intervalHuman);
+            if (!ok) {
+                sendNotFound(res, params.id);
+                return;
+            }
+            sendOk(res, { id: params.id });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            const isRecipeRestriction = message.includes("Recipe loops");
+            sendError(res, isRecipeRestriction ? 403 : 400, message);
+        }
+    });
+    r("DELETE", "/api/loops/:id", async (_req, res, params) => {
+        if (manager.isRecipeLoop(params.id)) {
+            sendError(res, 403, "Recipe loops cannot be deleted; remove the recipe file instead");
+            return;
+        }
+        const ok = await manager.delete(params.id);
+        if (!ok) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        sendOk(res);
+    });
+    r("POST", "/api/loops/:id/pause", (_req, res, params) => {
+        if (!manager.pause(params.id)) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        sendOk(res);
+    });
+    r("POST", "/api/loops/:id/resume", (_req, res, params) => {
+        if (!manager.resume(params.id)) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        sendOk(res);
+    });
+    r("POST", "/api/loops/:id/play", (_req, res, params) => {
+        if (manager.isMaxRunsBlocked(params.id)) {
+            sendError(res, 409, "Max runs reached");
+            return;
+        }
+        if (manager.isRunning(params.id)) {
+            sendError(res, 409, "Loop is already running");
+            return;
+        }
+        if (!manager.playLoop(params.id)) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        const meta = manager.status(params.id);
+        sendOk(res, meta);
+    });
+    r("POST", "/api/loops/:id/trigger", (_req, res, params) => {
+        if (manager.isMaxRunsBlocked(params.id)) {
+            sendError(res, 400, "Max runs reached");
+            return;
+        }
+        if (manager.isRunning(params.id)) {
+            sendError(res, 409, "Loop is already running");
+            return;
+        }
+        if (!manager.trigger(params.id)) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        sendOk(res);
+    });
+    r("POST", "/api/loops/:id/stop", (_req, res, params) => {
+        if (!manager.stopLoop(params.id)) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        sendOk(res);
+    });
+    r("POST", "/api/loops/stop-all", (_req, res) => {
+        const count = manager.stopAllLoops();
+        sendOk(res, { count });
+    });
+    r("GET", "/api/loops/:id/runs", (_req, res, params) => {
+        const meta = manager.status(params.id);
+        if (!meta) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        const query = parseQuery(_req.url);
+        const fromStr = query.get("from");
+        const toStr = query.get("to");
+        let runs = meta.runHistory;
+        if (fromStr) {
+            const fromMs = new Date(fromStr).getTime();
+            if (!Number.isNaN(fromMs)) {
+                runs = runs.filter((r) => new Date(r.startedAt).getTime() >= fromMs);
+            }
+        }
+        if (toStr) {
+            const toMs = new Date(toStr).getTime();
+            if (!Number.isNaN(toMs)) {
+                runs = runs.filter((r) => new Date(r.startedAt).getTime() <= toMs);
+            }
+        }
+        sendOk(res, runs);
+    });
+    r("GET", "/api/loops/:id/logs/date", (_req, res, params) => {
+        const meta = manager.status(params.id);
+        if (!meta) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        const query = parseQuery(_req.url);
+        const fromStr = query.get("from");
+        const toStr = query.get("to");
+        if (!fromStr || !toStr) {
+            sendError(res, 400, "Both 'from' and 'to' query parameters are required (ISO 8601)");
+            return;
+        }
+        const fromMs = new Date(fromStr).getTime();
+        const toMs = new Date(toStr).getTime();
+        if (Number.isNaN(fromMs) || Number.isNaN(toMs)) {
+            sendError(res, 400, "Invalid date format for 'from' or 'to' (use ISO 8601)");
+            return;
+        }
+        const logPath = manager.getLogPath(params.id);
+        if (!logPath || !fs.existsSync(logPath)) {
+            sendOk(res, "");
+            return;
+        }
+        const matching = meta.runHistory.filter((r) => {
+            const t = new Date(r.startedAt).getTime();
+            return t >= fromMs && t <= toMs;
+        });
+        if (matching.length === 0) {
+            sendOk(res, "");
+            return;
+        }
+        matching.sort((a, b) => a.logOffset - b.logOffset);
+        const allSorted = meta.runHistory.slice().sort((a, b) => a.logOffset - b.logOffset);
+        const parts = matching.map((record) => {
+            const start = record.logOffset;
+            const idx = allSorted.indexOf(record);
+            const end = idx < allSorted.length - 1 ? allSorted[idx + 1].logOffset : undefined;
+            return readByteRange(logPath, start, end);
+        });
+        sendOk(res, parts.join(""));
+    });
+    r("GET", "/api/loops/:id/logs", (_req, res, params) => {
+        const logPath = manager.getLogPath(params.id);
+        if (!logPath) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        const query = parseQuery(_req.url);
+        const tailCount = parseInt(query.get("tail") ?? String(LOG_TAIL_DEFAULT), 10);
+        if (!fs.existsSync(logPath)) {
+            sendOk(res, "");
+            return;
+        }
+        const lines = tailFileBounded(logPath, tailCount);
+        sendOk(res, lines.join("\n"));
+    });
+    r("GET", "/api/loops/:id/logs/stream", (_req, res, params) => {
+        const logPath = manager.getLogPath(params.id);
+        if (!logPath) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        res.writeHead(200, {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            "Connection": "keep-alive",
+        });
+        const query = parseQuery(_req.url);
+        const tailCount = parseInt(query.get("tail") ?? "0", 10);
+        let initialOffset = 0;
+        if (fs.existsSync(logPath)) {
+            const lines = tailFileBounded(logPath, tailCount);
+            for (const line of lines) {
+                if (line) {
+                    res.write(`data: ${line}\n\n`);
+                }
+            }
+            initialOffset = fs.statSync(logPath).size;
+        }
+        const watcher = followLogFile({
+            logPath,
+            initialOffset,
+            dest: res,
+            formatLine: (line) => `data: ${line}\n\n`,
+            onEnd: () => {
+                res.write("event: end\ndata: {}\n\n");
+                res.end();
+            },
+            onError: () => {
+                res.end();
+            },
+        });
+        _req.on("close", () => {
+            watcher.close();
+            res.end();
+        });
+    });
+    r("GET", "/api/loops/:id/runs/:num", (_req, res, params) => {
+        const { id, num } = params;
+        const logPath = manager.getLogPath(id);
+        if (!logPath || !fs.existsSync(logPath)) {
+            sendOk(res, "");
+            return;
+        }
+        const meta = manager.status(id);
+        if (!meta) {
+            sendNotFound(res, id);
+            return;
+        }
+        const runNumber = parseInt(num, 10);
+        const records = meta.runHistory
+            .filter((r) => r.runNumber === runNumber)
+            .sort((a, b) => a.logOffset - b.logOffset);
+        if (records.length === 0) {
+            sendOk(res, "");
+            return;
+        }
+        const allSorted = meta.runHistory.slice().sort((a, b) => a.logOffset - b.logOffset);
+        const parts = records.map((record) => {
+            const start = record.logOffset;
+            const idx = allSorted.indexOf(record);
+            const end = idx < allSorted.length - 1 ? allSorted[idx + 1].logOffset : undefined;
+            return readByteRange(logPath, start, end);
+        });
+        sendOk(res, parts.join(""));
+    });
+}

package/dist/daemon/http/route-misc.js

@@ -0,0 +1,60 @@
+import { initSseResponse } from "./sse.js";
+import { buildOpenApiSpec, buildSwaggerHtml } from "./openapi.js";
+import { sendOk, sendError, readBody } from "./helpers.js";
+import { collectDiagnostics, isDiagnosticsEnabled } from "../diagnostics.js";
+export function registerMiscRoutes(sseClients, r) {
+    r("GET", "/api/openapi.json", (_req, res) => {
+        const spec = buildOpenApiSpec();
+        const body = JSON.stringify(spec, null, 2);
+        res.writeHead(200, {
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(body),
+        });
+        res.end(body);
+    });
+    r("GET", "/api/docs", (_req, res) => {
+        const html = buildSwaggerHtml();
+        res.writeHead(200, {
+            "Content-Type": "text/html",
+            "Content-Length": Buffer.byteLength(html),
+        });
+        res.end(html);
+    });
+    r("GET", "/", (_req, res) => {
+        const html = buildSwaggerHtml();
+        res.writeHead(200, {
+            "Content-Type": "text/html",
+            "Content-Length": Buffer.byteLength(html),
+        });
+        res.end(html);
+    });
+    r("GET", "/api/events", (_req, res) => {
+        initSseResponse(res);
+        sseClients.add(res);
+        _req.on("close", () => {
+            sseClients.delete(res);
+        });
+    });
+}
+export function registerSettingsRoutes(settingsManager, r) {
+    r("GET", "/api/settings", (_req, res) => {
+        sendOk(res, settingsManager.get());
+    });
+    r("PATCH", "/api/settings", async (req, res) => {
+        try {
+            const body = await readBody(req);
+            const updated = settingsManager.set(body);
+            sendOk(res, updated);
+        }
+        catch (err) {
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+}
+export function registerDiagnosticsRoutes(loopManager, r) {
+    r("GET", "/api/diagnostics", (_req, res) => {
+        const extended = isDiagnosticsEnabled();
+        const diag = collectDiagnostics(loopManager, extended);
+        sendOk(res, diag);
+    });
+}

package/dist/daemon/http/route-projects.js

@@ -0,0 +1,55 @@
+import { sendOk, sendError, sendNotFound, readBody } from "./helpers.js";
+export function registerProjectRoutes(projectManager, r) {
+    r("GET", "/api/projects", (_req, res) => {
+        sendOk(res, projectManager.getAll());
+    });
+    r("POST", "/api/projects", async (req, res) => {
+        try {
+            const body = await readBody(req);
+            if (!body.name?.trim()) {
+                sendError(res, 400, "Project name is required");
+                return;
+            }
+            const project = projectManager.create(body.name.trim(), body.color ?? "#ffffff", body.directory, body.githubSource);
+            sendOk(res, project, 201);
+        }
+        catch (err) {
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+    r("PATCH", "/api/projects/:id", async (req, res, params) => {
+        try {
+            const body = await readBody(req);
+            if (!body.name?.trim()) {
+                sendError(res, 400, "Project name is required");
+                return;
+            }
+            projectManager.update(params.id, body.name.trim(), body.color, body.directory, body.githubSource);
+            sendOk(res);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("not found")) {
+                sendNotFound(res, params.id);
+            }
+            else {
+                sendError(res, 400, msg);
+            }
+        }
+    });
+    r("DELETE", "/api/projects/:id", (_req, res, params) => {
+        try {
+            projectManager.delete(params.id);
+            sendOk(res);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes("not found") || msg.includes("system")) {
+                sendError(res, 400, msg);
+            }
+            else {
+                sendError(res, 500, msg);
+            }
+        }
+    });
+}

package/dist/daemon/http/route-tasks.js

@@ -0,0 +1,141 @@
+import { validateContext } from "../../core/context/validate-context.js";
+import { sendOk, sendError, sendNotFound, readBody } from "./helpers.js";
+export function registerTaskRoutes(taskManager, r) {
+    r("GET", "/api/tasks", (_req, res) => {
+        sendOk(res, taskManager.list());
+    });
+    r("GET", "/api/tasks/:id", (_req, res, params) => {
+        const task = taskManager.get(params.id);
+        if (!task) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        sendOk(res, task);
+    });
+    r("POST", "/api/tasks", async (req, res) => {
+        try {
+            const body = await readBody(req);
+            if (!body.name?.trim()) {
+                sendError(res, 400, "Task name is required");
+                return;
+            }
+            if (!body.command?.trim()) {
+                sendError(res, 400, "Task command is required");
+                return;
+            }
+            if (body.context !== undefined) {
+                const result = validateContext(body.context);
+                if (!result.valid) {
+                    sendError(res, 400, result.error);
+                    return;
+                }
+                body.context = result.context;
+            }
+            const task = taskManager.create(body);
+            sendOk(res, task, 201);
+        }
+        catch (err) {
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+    r("PATCH", "/api/tasks/:id", async (req, res, params) => {
+        try {
+            const body = await readBody(req);
+            if (body.context !== undefined) {
+                const result = validateContext(body.context);
+                if (!result.valid) {
+                    sendError(res, 400, result.error);
+                    return;
+                }
+                body.context = result.context;
+            }
+            const updated = taskManager.update(params.id, body);
+            if (!updated) {
+                sendNotFound(res, params.id);
+                return;
+            }
+            sendOk(res, updated);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("immutable")) {
+                sendError(res, 403, err.message);
+                return;
+            }
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+    r("DELETE", "/api/tasks/:id", (_req, res, params) => {
+        try {
+            if (!taskManager.delete(params.id)) {
+                sendNotFound(res, params.id);
+                return;
+            }
+            sendOk(res);
+        }
+        catch (err) {
+            if (err instanceof Error && err.message.includes("immutable")) {
+                sendError(res, 403, err.message);
+                return;
+            }
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+    r("POST", "/api/task-chains", async (req, res) => {
+        try {
+            const body = await readBody(req);
+            if (!body.tasks || !Array.isArray(body.tasks) || body.tasks.length === 0) {
+                sendError(res, 400, "tasks array must not be empty");
+                return;
+            }
+            if (body.chain && body.chain !== "sequential-success" && body.chain !== "sequential-failure" && body.chain !== "none") {
+                sendError(res, 400, `Invalid chain mode: "${body.chain}". Must be "sequential-success", "sequential-failure", or "none"`);
+                return;
+            }
+            for (const task of body.tasks) {
+                if (!task.name?.trim()) {
+                    sendError(res, 400, "Each task must have a name");
+                    return;
+                }
+                if (!task.command?.trim()) {
+                    sendError(res, 400, "Each task must have a command");
+                    return;
+                }
+            }
+            const created = [];
+            try {
+                for (const taskInput of body.tasks) {
+                    const task = taskManager.create(taskInput);
+                    created.push(task);
+                }
+                const chainMode = body.chain ?? "none";
+                if (chainMode === "sequential-success") {
+                    for (let i = 0; i < created.length - 1; i++) {
+                        taskManager.update(created[i].id, {
+                            ...created[i],
+                            onSuccessTaskId: created[i + 1].id,
+                        });
+                    }
+                }
+                else if (chainMode === "sequential-failure") {
+                    for (let i = 0; i < created.length - 1; i++) {
+                        taskManager.update(created[i].id, {
+                            ...created[i],
+                            onFailureTaskId: created[i + 1].id,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                for (const task of created) {
+                    taskManager.delete(task.id);
+                }
+                sendError(res, 400, err instanceof Error ? err.message : String(err));
+                return;
+            }
+            sendOk(res, { taskIds: created.map((t) => t.id) }, 201);
+        }
+        catch (err) {
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+}

package/dist/daemon/http/routes.js

@@ -0,0 +1,19 @@
+import { registerLoopRoutes } from "./route-loops.js";
+import { registerTaskRoutes } from "./route-tasks.js";
+import { registerProjectRoutes } from "./route-projects.js";
+import { registerMiscRoutes, registerSettingsRoutes, registerDiagnosticsRoutes } from "./route-misc.js";
+export function registerRoutes(deps) {
+    const { manager, taskManager, projectManager, sseClients, settingsManager } = deps;
+    const routes = [];
+    const r = (method, path, handler) => {
+        const segments = path.split("/").filter((s) => s.length > 0);
+        routes.push({ method, segments, handler });
+    };
+    registerLoopRoutes(manager, routes, r);
+    registerTaskRoutes(taskManager, r);
+    registerProjectRoutes(projectManager, r);
+    registerMiscRoutes(sseClients, r);
+    registerSettingsRoutes(settingsManager, r);
+    registerDiagnosticsRoutes(manager, r);
+    return routes;
+}

package/dist/daemon/http/server.js

@@ -0,0 +1,82 @@
+import http from "node:http";
+import { HTTP_API_PORT, HTTP_API_HOST } from "../../shared/config/constants.js";
+import { daemonLog } from "../daemon-log.js";
+import { sendError, matchRoute, parsePath } from "./helpers.js";
+import { SseClientSet } from "./sse.js";
+import { registerRoutes } from "./routes.js";
+export class HttpApiServer {
+    constructor(manager, taskManager, projectManager, settingsManager) {
+        this.manager = manager;
+        this.taskManager = taskManager;
+        this.projectManager = projectManager;
+        this.settingsManager = settingsManager;
+        this.routes = [];
+        this.sseClients = new SseClientSet();
+        this.isListening = false;
+        this.server = http.createServer((req, res) => this.handleRequest(req, res));
+        this.routes = registerRoutes({
+            manager: this.manager,
+            taskManager: this.taskManager,
+            projectManager: this.projectManager,
+            sseClients: this.sseClients,
+            settingsManager: this.settingsManager,
+        });
+    }
+    async listen(port = HTTP_API_PORT, host = HTTP_API_HOST) {
+        return new Promise((resolve, reject) => {
+            this.server.on("error", (err) => {
+                if (err.code === "EADDRINUSE") {
+                    daemonLog(`HTTP API server: port ${port} already in use, skipping HTTP transport`);
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+            this.server.listen(port, host, () => {
+                this.isListening = true;
+                daemonLog(`HTTP API server listening on ${host}:${port}`);
+                resolve();
+            });
+        });
+    }
+    async close() {
+        if (!this.isListening)
+            return;
+        this.isListening = false;
+        this.sseClients.destroyAll();
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                resolve();
+            });
+            // Node's server.close() stops accepting new connections but leaves
+            // existing keep-alive sockets open, so a browser tab (e.g. Swagger UI)
+            // keeps being served on its persistent connection. Force them closed so
+            // the port is actually released when the API is toggled off.
+            this.server.closeAllConnections?.();
+        });
+    }
+    async restart(port = HTTP_API_PORT, host = HTTP_API_HOST) {
+        await this.close();
+        await this.listen(port, host);
+    }
+    broadcastEvent(event, data) {
+        this.sseClients.broadcast(event, data);
+    }
+    async handleRequest(req, res) {
+        try {
+            const pathSegments = parsePath(req.url);
+            const match = matchRoute(this.routes, req.method ?? "GET", pathSegments);
+            if (!match) {
+                sendError(res, 404, `Not found: ${req.method} ${req.url}`);
+                return;
+            }
+            await match.handler(req, res, match.params);
+        }
+        catch (err) {
+            if (!res.headersSent) {
+                sendError(res, 500, err instanceof Error ? err.message : String(err));
+            }
+        }
+    }
+}