loop-task 2.1.3 → 2.1.5

package/dist/daemon/http/openapi.js

@@ -0,0 +1,92 @@
+import { HTTP_API_HOST, HTTP_API_PORT } from "../../shared/config/constants.js";
+export function buildOpenApiSpec() {
+    return {
+        openapi: "3.0.3",
+        info: {
+            title: "loop-task HTTP API",
+            version: "1.0.0",
+            description: "REST + SSE API for managing loops, tasks, projects, and logs. All endpoints are localhost-only (127.0.0.1).",
+        },
+        servers: [
+            { url: `http://${HTTP_API_HOST}:${HTTP_API_PORT}`, description: "Local daemon" },
+        ],
+        paths: {
+            "/api/loops": {
+                get: { summary: "List all loops", tags: ["Loops"], responses: { "200": { description: "Array of loops", content: { "application/json": { schema: { type: "array" } } } } } },
+                post: { summary: "Create a new loop", tags: ["Loops"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { command: { type: "string" }, commandArgs: { type: "array", items: { type: "string" } }, intervalHuman: { type: "string", example: "5m" }, cwd: { type: "string" }, description: { type: "string" }, taskId: { type: "string" }, now: { type: "boolean" }, maxRuns: { type: "integer" }, verbose: { type: "boolean" }, projectId: { type: "string" }, offset: { type: "integer" } } } } } }, responses: { "201": { description: "Loop created", content: { "application/json": { schema: { type: "object", properties: { id: { type: "string" } } } } } }, "400": { description: "Validation error" } } },
+            },
+            "/api/loops/{id}": {
+                get: { summary: "Get loop status", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Loop details" }, "404": { description: "Not found" } } },
+                patch: { summary: "Update a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { type: "object" } } } }, responses: { "200": { description: "Updated" }, "400": { description: "Validation error" }, "404": { description: "Not found" } } },
+                delete: { summary: "Delete a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Deleted" }, "404": { description: "Not found" } } },
+            },
+            "/api/loops/{id}/pause": { post: { summary: "Pause a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Paused" }, "404": { description: "Not found" } } } },
+            "/api/loops/{id}/resume": { post: { summary: "Resume a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Resumed" }, "404": { description: "Not found" } } } },
+            "/api/loops/{id}/trigger": { post: { summary: "Trigger a loop now", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Triggered" }, "404": { description: "Not found" }, "400": { description: "Max runs reached" }, "409": { description: "Already running" } } } },
+            "/api/loops/{id}/stop": { post: { summary: "Stop a loop", tags: ["Loops"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Stopped" }, "404": { description: "Not found" } } } },
+            "/api/loops/stop-all": { post: { summary: "Stop all loops", tags: ["Loops"], responses: { "200": { description: "All stopped", content: { "application/json": { schema: { type: "object", properties: { count: { type: "integer" } } } } } } } } },
+            "/api/loops/{id}/logs": { get: { summary: "Fetch loop logs", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "tail", in: "query", schema: { type: "integer", default: 50 } }], responses: { "200": { description: "Log content" }, "404": { description: "Not found" } } } },
+            "/api/loops/{id}/logs/stream": { get: { summary: "Stream logs via SSE", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "tail", in: "query", schema: { type: "integer" } }], responses: { "200": { description: "SSE stream" }, "404": { description: "Not found" } } } },
+            "/api/loops/{id}/runs/{num}": { get: { summary: "Get run-specific log", tags: ["Logs"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }, { name: "num", in: "path", required: true, schema: { type: "integer" } }], responses: { "200": { description: "Run log content" } } } },
+            "/api/tasks": {
+                get: { summary: "List all tasks", tags: ["Tasks"], responses: { "200": { description: "Array of tasks" } } },
+                post: { summary: "Create a task", tags: ["Tasks"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { id: { type: "string" }, name: { type: "string" }, command: { type: "string" }, commandArgs: { type: "array", items: { type: "string" } }, onSuccessTaskId: { type: "string" }, onFailureTaskId: { type: "string" } } } } } }, responses: { "201": { description: "Task created" }, "400": { description: "Validation error" } } },
+            },
+            "/api/tasks/{id}": {
+                get: { summary: "Get a task", tags: ["Tasks"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Task details" }, "404": { description: "Not found" } } },
+                patch: { summary: "Update a task", tags: ["Tasks"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { type: "object" } } } }, responses: { "200": { description: "Updated" }, "404": { description: "Not found" } } },
+                delete: { summary: "Delete a task", tags: ["Tasks"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Deleted" }, "404": { description: "Not found" } } },
+            },
+            "/api/projects": {
+                get: { summary: "List all projects", tags: ["Projects"], responses: { "200": { description: "Array of projects" } } },
+                post: { summary: "Create a project", tags: ["Projects"], requestBody: { content: { "application/json": { schema: { type: "object", properties: { name: { type: "string" }, color: { type: "string" } } } } } }, responses: { "201": { description: "Project created" }, "400": { description: "Validation error" } } },
+            },
+            "/api/projects/{id}": {
+                patch: { summary: "Update a project", tags: ["Projects"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { type: "object", properties: { name: { type: "string" }, color: { type: "string" } } } } } }, responses: { "200": { description: "Updated" }, "404": { description: "Not found" }, "400": { description: "Validation error" } } },
+                delete: { summary: "Delete a project", tags: ["Projects"], parameters: [{ name: "id", in: "path", required: true, schema: { type: "string" } }], responses: { "200": { description: "Deleted" }, "400": { description: "Cannot delete system project" } } },
+            },
+            "/api/events": { get: { summary: "Subscribe to daemon events via SSE", tags: ["Events"], responses: { "200": { description: "SSE event stream" } } } },
+            "/api/openapi.json": { get: { summary: "OpenAPI 3.0 spec", tags: ["Docs"], responses: { "200": { description: "OpenAPI JSON spec" } } } },
+            "/api/docs": { get: { summary: "Swagger UI", tags: ["Docs"], responses: { "200": { description: "HTML page" } } } },
+        },
+    };
+}
+export function buildSwaggerHtml() {
+    const specUrl = "/api/openapi.json";
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>loop-task API</title>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css">
+  <style>
+    body { margin: 0; }
+    .swagger-ui { max-width: 1200px; margin: 0 auto; }
+    .header { background: #0d1117; color: #58a6ff; padding: 12px 24px; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; font-size: 14px; }
+    .header a { color: #58a6ff; text-decoration: none; }
+    .header a:hover { text-decoration: underline; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <strong>loop-task HTTP API</strong> &mdash;
+    <a href="/api/openapi.json">OpenAPI JSON</a> &mdash;
+    <a href="/api/docs">Swagger UI</a>
+  </div>
+  <div id="swagger-ui"></div>
+  <script src="https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+  <script>
+    window.onload = function() {
+      window.ui = SwaggerUIBundle({
+        url: "${specUrl}",
+        dom_id: "#swagger-ui",
+        deepLinking: true,
+        presets: [SwaggerUIBundle.presets.apis],
+        layout: "BaseLayout",
+      });
+    };
+  </script>
+</body>
+</html>`;
+}

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

@@ -0,0 +1,218 @@
+import fs from "node:fs";
+import { LOG_TAIL_DEFAULT } from "../../shared/config/constants.js";
+import { tail } from "../../shared/tail.js";
+import { buildLoopOptions } from "../../loop-config.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);
+            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,
+            });
+            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);
+            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,
+            });
+            const ok = await manager.update(params.id, options, intervalHuman);
+            if (!ok) {
+                sendNotFound(res, params.id);
+                return;
+            }
+            sendOk(res, { id: params.id });
+        }
+        catch (err) {
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+    r("DELETE", "/api/loops/:id", async (_req, res, params) => {
+        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/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 });
+    });
+    // --- Logs ---
+    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 content = fs.readFileSync(logPath, "utf-8");
+        sendOk(res, tail(content, tailCount).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);
+        if (fs.existsSync(logPath)) {
+            const content = fs.readFileSync(logPath, "utf-8");
+            for (const line of tail(content, tailCount)) {
+                if (line) {
+                    res.write(`data: ${line}\n\n`);
+                }
+            }
+        }
+        let fileSize = fs.existsSync(logPath) ? fs.statSync(logPath).size : 0;
+        const watcher = fs.watch(logPath, (eventType) => {
+            if (eventType === "rename" && !fs.existsSync(logPath)) {
+                watcher.close();
+                res.write("event: end\ndata: {}\n\n");
+                res.end();
+                return;
+            }
+            if (eventType === "change") {
+                try {
+                    const stat = fs.statSync(logPath);
+                    if (stat.size > fileSize) {
+                        const fd = fs.openSync(logPath, "r");
+                        const buf = Buffer.alloc(stat.size - fileSize);
+                        fs.readSync(fd, buf, 0, buf.length, fileSize);
+                        fs.closeSync(fd);
+                        fileSize = stat.size;
+                        for (const line of buf.toString().split("\n")) {
+                            if (line) {
+                                res.write(`data: ${line}\n\n`);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    watcher.close();
+                    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 buffer = fs.readFileSync(logPath);
+        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 : buffer.length;
+            return buffer.toString("utf-8", start, end);
+        });
+        sendOk(res, parts.join(""));
+    });
+}

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

@@ -0,0 +1,36 @@
+import { initSseResponse } from "./sse.js";
+import { buildOpenApiSpec, buildSwaggerHtml } from "./openapi.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);
+        });
+    });
+}

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");
+            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);
+            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,53 @@
+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;
+            }
+            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);
+            const updated = taskManager.update(params.id, body);
+            if (!updated) {
+                sendNotFound(res, params.id);
+                return;
+            }
+            sendOk(res, updated);
+        }
+        catch (err) {
+            sendError(res, 400, err instanceof Error ? err.message : String(err));
+        }
+    });
+    r("DELETE", "/api/tasks/:id", (_req, res, params) => {
+        if (!taskManager.delete(params.id)) {
+            sendNotFound(res, params.id);
+            return;
+        }
+        sendOk(res);
+    });
+}

package/dist/daemon/http/routes.js

@@ -0,0 +1,17 @@
+import { registerLoopRoutes } from "./route-loops.js";
+import { registerTaskRoutes } from "./route-tasks.js";
+import { registerProjectRoutes } from "./route-projects.js";
+import { registerMiscRoutes } from "./route-misc.js";
+export function registerRoutes(deps) {
+    const { manager, taskManager, projectManager, sseClients } = 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);
+    return routes;
+}

package/dist/daemon/http/server.js

@@ -0,0 +1,64 @@
+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) {
+        this.manager = manager;
+        this.taskManager = taskManager;
+        this.projectManager = projectManager;
+        this.routes = [];
+        this.sseClients = new SseClientSet();
+        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,
+        });
+    }
+    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, () => {
+                daemonLog(`HTTP API server listening on ${host}:${port}`);
+                resolve();
+            });
+        });
+    }
+    async close() {
+        this.sseClients.destroyAll();
+        return new Promise((resolve) => {
+            this.server.close(() => resolve());
+        });
+    }
+    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));
+            }
+        }
+    }
+}

package/dist/daemon/http/sse.js

@@ -0,0 +1,36 @@
+export class SseClientSet {
+    constructor() {
+        this.clients = new Set();
+    }
+    add(res) {
+        this.clients.add(res);
+    }
+    delete(res) {
+        this.clients.delete(res);
+    }
+    destroyAll() {
+        for (const client of this.clients) {
+            client.destroy();
+        }
+        this.clients.clear();
+    }
+    broadcast(event, data) {
+        const payload = `event: ${event}\ndata: ${JSON.stringify(data ?? {})}\n\n`;
+        for (const client of this.clients) {
+            try {
+                client.write(payload);
+            }
+            catch {
+                this.clients.delete(client);
+            }
+        }
+    }
+}
+export function initSseResponse(res) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        "Connection": "keep-alive",
+    });
+    res.write(": connected\n\n");
+}

package/dist/daemon/index.js

@@ -1,10 +1,10 @@
-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 { LoopManager } from "./managers/loop-manager.js";
+import { TaskManager } from "./managers/task-manager.js";
+import { IpcServer } from "./server/index.js";
+import { HttpApiServer } from "./http/server.js";
+import { FileWatcher } from "./watcher/index.js";
+import { writeDaemonPid, removeDaemonPid, writeDaemonSignature, removeDaemonSignature, computeCodeSignature, migrateTasksToJson, migrateLoopsToJson, } from "./state/index.js";
+import { t } from "../shared/i18n/index.js";
 import { daemonLog } from "./daemon-log.js";
 async function main() {
     const taskManager = new TaskManager();
@@ -39,8 +39,6 @@ async function main() {
     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;

package/dist/{ipc/handlers → daemon/ipc}/logs-stream.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { send } from "../send.js";
+import { send } from "./send.js";
 import { tail } from "../../shared/tail.js";
 const TAIL_WINDOW_BYTES = 64 * 1024;
 function readInitialTail(logPath, tailCount) {

package/dist/daemon/managers/loop-entry.js

@@ -0,0 +1,24 @@
+import { LoopController } from "../../core/loop/loop-controller.js";
+import { getLogPath } from "../state/index.js";
+import { buildLoopOptions } from "./loop-options.js";
+export function createLoopEntry(meta, taskResolver, getProjectDirectory, state) {
+    const options = buildLoopOptions(meta);
+    const logPath = getLogPath(meta.id);
+    const projectDir = getProjectDirectory(options.projectId ?? "default");
+    const controller = new LoopController(meta.id, options, logPath, taskResolver, state, projectDir);
+    return { controller, options, intervalHuman: meta.intervalHuman };
+}
+export function metaToState(meta) {
+    return {
+        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,
+    };
+}