loop-task 2.1.11 → 2.1.13

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

@@ -2,6 +2,7 @@ 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 { 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) => {
@@ -18,6 +19,15 @@ export function registerLoopRoutes(manager, routes, r) {
     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,
@@ -30,6 +40,7 @@ export function registerLoopRoutes(manager, routes, r) {
                 description: body.description,
                 projectId: body.projectId,
                 offset: body.offset,
+                context,
             });
             const id = manager.start(options, intervalHuman);
             sendOk(res, { id }, 201);
@@ -41,6 +52,15 @@ export function registerLoopRoutes(manager, routes, r) {
     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,
@@ -53,6 +73,7 @@ export function registerLoopRoutes(manager, routes, r) {
                 description: body.description,
                 projectId: body.projectId,
                 offset: body.offset,
+                context,
             });
             const ok = await manager.update(params.id, options, intervalHuman);
             if (!ok) {
@@ -87,6 +108,22 @@ export function registerLoopRoutes(manager, routes, r) {
         }
         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");
@@ -113,6 +150,75 @@ export function registerLoopRoutes(manager, routes, r) {
         const count = manager.stopAllLoops();
         sendOk(res, { count });
     });
+    // --- Run History ---
+    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);
+    });
+    // --- Date-Filtered Logs ---
+    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 buffer = fs.readFileSync(logPath);
+        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 : buffer.length;
+            return buffer.toString("utf-8", start, end);
+        });
+        sendOk(res, parts.join(""));
+    });
     // --- Logs ---
     r("GET", "/api/loops/:id/logs", (_req, res, params) => {
         const logPath = manager.getLogPath(params.id);

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

@@ -1,5 +1,6 @@
 import { initSseResponse } from "./sse.js";
 import { buildOpenApiSpec, buildSwaggerHtml } from "./openapi.js";
+import { sendOk, sendError, readBody } from "./helpers.js";
 export function registerMiscRoutes(sseClients, r) {
     r("GET", "/api/openapi.json", (_req, res) => {
         const spec = buildOpenApiSpec();
@@ -34,3 +35,18 @@ export function registerMiscRoutes(sseClients, r) {
         });
     });
 }
+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));
+        }
+    });
+}

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

@@ -10,7 +10,7 @@ export function registerProjectRoutes(projectManager, r) {
                 sendError(res, 400, "Project name is required");
                 return;
             }
-            const project = projectManager.create(body.name.trim(), body.color ?? "#ffffff");
+            const project = projectManager.create(body.name.trim(), body.color ?? "#ffffff", body.directory, body.githubSource);
             sendOk(res, project, 201);
         }
         catch (err) {
@@ -24,7 +24,7 @@ export function registerProjectRoutes(projectManager, r) {
                 sendError(res, 400, "Project name is required");
                 return;
             }
-            projectManager.update(params.id, body.name.trim(), body.color);
+            projectManager.update(params.id, body.name.trim(), body.color, body.directory, body.githubSource);
             sendOk(res);
         }
         catch (err) {

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

@@ -1,3 +1,4 @@
+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) => {
@@ -22,6 +23,14 @@ export function registerTaskRoutes(taskManager, r) {
                 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);
         }
@@ -32,6 +41,14 @@ export function registerTaskRoutes(taskManager, r) {
     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);
@@ -50,4 +67,62 @@ export function registerTaskRoutes(taskManager, r) {
         }
         sendOk(res);
     });
+    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

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

package/dist/daemon/http/server.js

@@ -5,18 +5,21 @@ import { sendError, matchRoute, parsePath } from "./helpers.js";
 import { SseClientSet } from "./sse.js";
 import { registerRoutes } from "./routes.js";
 export class HttpApiServer {
-    constructor(manager, taskManager, projectManager) {
+    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) {
@@ -31,17 +34,32 @@ export class HttpApiServer {
                 }
             });
             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());
+            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);
     }

package/dist/daemon/index.js

@@ -2,20 +2,27 @@ 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 { McpApiServer } from "./mcp/index.js";
 import { FileWatcher } from "./watcher/index.js";
+import { SettingsManager } from "./settings-manager.js";
 import { writeDaemonPid, removeDaemonPid, writeDaemonSignature, removeDaemonSignature, computeCodeSignature, migrateTasksToJson, migrateLoopsToJson, setSelfWriteNotifier, } from "./state/index.js";
 import { setProjectSelfWriteNotifier } from "./managers/project-manager.js";
 import { t } from "../shared/i18n/index.js";
 import { daemonLog } from "./daemon-log.js";
 async function main() {
+    const mcpEnabled = (process.env.LOOP_CLI_MCP_ENABLED ?? "true") !== "false";
+    const mcpTransport = process.env.LOOP_CLI_MCP_TRANSPORT === "stdio" ? "stdio" : "sse";
     const taskManager = new TaskManager();
     migrateLoopsToJson();
     migrateTasksToJson();
     taskManager.init();
     const manager = new LoopManager(taskManager);
-    const server = new IpcServer(manager, taskManager);
+    const settingsManager = new SettingsManager();
+    settingsManager.load();
+    const server = new IpcServer(manager, taskManager, settingsManager);
     const projectManager = manager.projectManager;
-    const httpServer = new HttpApiServer(manager, taskManager, projectManager);
+    const httpServer = new HttpApiServer(manager, taskManager, projectManager, settingsManager);
+    const mcpServer = new McpApiServer(manager, taskManager, projectManager, mcpTransport);
     try {
         await server.listen();
     }
@@ -23,13 +30,46 @@ async function main() {
         daemonLog(`listen failed (another daemon already holds the socket): ${String(err)}`);
         process.exit(0);
     }
-    try {
-        const httpPort = parseInt(process.env.LOOP_CLI_HTTP_PORT ?? "", 10);
-        await httpServer.listen(Number.isNaN(httpPort) ? undefined : httpPort);
+    const httpPort = parseInt(process.env.LOOP_CLI_HTTP_PORT ?? "", 10);
+    const resolvedHttpPort = Number.isNaN(httpPort) ? undefined : httpPort;
+    if (settingsManager.get().httpApiEnabled) {
+        try {
+            await httpServer.listen(resolvedHttpPort);
+        }
+        catch (err) {
+            daemonLog(`HTTP API server failed to start: ${String(err)}`);
+        }
     }
-    catch (err) {
-        daemonLog(`HTTP API server failed to start: ${String(err)}`);
+    if (mcpEnabled) {
+        try {
+            await mcpServer.start();
+        }
+        catch (err) {
+            daemonLog(`MCP server failed to start: ${String(err)}`);
+        }
     }
+    settingsManager.onChange((settings) => {
+        if (settings.httpApiEnabled && !httpServer["isListening"]) {
+            httpServer.listen(resolvedHttpPort).catch((err) => {
+                daemonLog(`HTTP API server failed to restart: ${String(err)}`);
+            });
+        }
+        else if (!settings.httpApiEnabled && httpServer["isListening"]) {
+            httpServer.close().catch((err) => {
+                daemonLog(`HTTP API server failed to stop: ${String(err)}`);
+            });
+        }
+        if (settings.mcpApiEnabled && !mcpServer.isListening) {
+            mcpServer.start().catch((err) => {
+                daemonLog(`MCP server failed to restart: ${String(err)}`);
+            });
+        }
+        else if (!settings.mcpApiEnabled && mcpServer.isListening) {
+            mcpServer.close().catch((err) => {
+                daemonLog(`MCP server failed to stop: ${String(err)}`);
+            });
+        }
+    });
     manager.init();
     writeDaemonPid(process.pid);
     writeDaemonSignature(computeCodeSignature());
@@ -53,6 +93,7 @@ async function main() {
             await manager.shutdown();
             await server.close();
             await httpServer.close();
+            await mcpServer.close();
         }
         catch (err) {
             daemonLog(`error during shutdown: ${String(err)}`);

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

@@ -20,5 +20,7 @@ export function metaToState(meta) {
         nextRunAt: meta.nextRunAt,
         remainingDelayMs: meta.remainingDelayMs,
         runHistory: meta.runHistory,
+        skippedCount: meta.skippedCount,
+        silentChainCount: meta.silentChainCount,
     };
 }

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

@@ -92,11 +92,11 @@ export class LoopManager {
     listProjects() {
         return this.projectManager.getAll();
     }
-    createProject(name, color, directory) {
-        return this.projectManager.create(name, color, directory);
+    createProject(name, color, directory, githubSource) {
+        return this.projectManager.create(name, color, directory, githubSource);
     }
-    updateProject(id, name, color, directory) {
-        this.projectManager.update(id, name, color, directory);
+    updateProject(id, name, color, directory, githubSource) {
+        this.projectManager.update(id, name, color, directory, githubSource);
     }
     deleteProject(id) {
         for (const [loopId, entry] of this.loops) {

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

@@ -12,5 +12,6 @@ export function buildLoopOptions(meta) {
         description: meta.description ?? "",
         projectId: meta.projectId ?? "default",
         offset: meta.offset ?? null,
+        context: meta.context,
     };
 }

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

@@ -27,6 +27,7 @@ export function toMeta(controller, options, intervalHuman, taskManager) {
         pid: process.pid,
         projectId: options.projectId ?? "default",
         offset: options.offset,
+        context: options.context,
     };
 }
 export function persistLoop(id, controller, options, intervalHuman, taskManager, lastSerialized) {

package/dist/daemon/managers/project-manager.js

@@ -8,6 +8,12 @@ let selfWriteNotifier = null;
 export function setProjectSelfWriteNotifier(notifier) {
     selfWriteNotifier = notifier;
 }
+const GITHUB_SOURCE_REGEX = /^[a-zA-Z0-9_.\-]+\/[a-zA-Z0-9_.\-]+$/;
+function validateGithubSource(githubSource) {
+    if (!GITHUB_SOURCE_REGEX.test(githubSource)) {
+        throw new Error(`Invalid githubSource format: "${githubSource}". Expected owner/repo (e.g. CKGrafico/loop-task)`);
+    }
+}
 export class ProjectManager {
     constructor() {
         this.projects = new Map();
@@ -99,13 +105,16 @@ export class ProjectManager {
     get(id) {
         return this.projects.get(id);
     }
-    create(name, color, directory) {
+    create(name, color, directory, githubSource) {
+        if (githubSource !== undefined && githubSource !== "")
+            validateGithubSource(githubSource);
         const id = crypto.randomBytes(4).toString("hex");
         const project = {
             id,
             name,
             color,
             directory: directory ?? "",
+            githubSource: githubSource || undefined,
             createdAt: new Date().toISOString(),
             isSystem: false,
             isDefault: false,
@@ -113,7 +122,7 @@ export class ProjectManager {
         this.saveProject(project);
         return project;
     }
-    update(id, name, color, directory) {
+    update(id, name, color, directory, githubSource) {
         const project = this.projects.get(id);
         if (!project)
             throw new Error(`Project ${id} not found`);
@@ -124,6 +133,11 @@ export class ProjectManager {
             project.color = color;
         if (directory !== undefined)
             project.directory = directory;
+        if (githubSource !== undefined) {
+            if (githubSource !== "")
+                validateGithubSource(githubSource);
+            project.githubSource = githubSource || undefined;
+        }
         this.saveProject(project);
     }
     delete(id) {

package/dist/daemon/mcp/index.js

@@ -0,0 +1,2 @@
+export { McpApiServer } from "./server.js";
+export { registerMcpTools } from "./tools.js";

package/dist/daemon/mcp/openapi-sync.js

@@ -0,0 +1,50 @@
+import { buildOpenApiSpec } from "../http/openapi.js";
+export function buildMcpToolDefsFromOpenApi() {
+    const spec = buildOpenApiSpec();
+    const defs = [];
+    if (!spec.paths)
+        return defs;
+    for (const [path, methods] of Object.entries(spec.paths)) {
+        for (const [method, operation] of Object.entries(methods)) {
+            if (!operation.summary)
+                continue;
+            const toolName = httpToToolName(method, path);
+            if (!toolName)
+                continue;
+            defs.push({
+                name: toolName,
+                description: operation.summary,
+            });
+        }
+    }
+    return defs;
+}
+function httpToToolName(method, path) {
+    const mappings = {
+        "GET /api/loops": "list_loops",
+        "POST /api/loops": "create_loop",
+        "GET /api/loops/:id": "get_loop",
+        "PATCH /api/loops/:id": "update_loop",
+        "DELETE /api/loops/:id": "delete_loop",
+        "POST /api/loops/:id/pause": "pause_loop",
+        "POST /api/loops/:id/resume": "resume_loop",
+        "POST /api/loops/:id/play": "resume_loop",
+        "POST /api/loops/:id/trigger": "trigger_loop",
+        "POST /api/loops/:id/stop": "stop_loop",
+        "POST /api/loops/stop-all": "stop_all_loops",
+        "GET /api/loops/:id/logs": "get_loop_logs",
+        "GET /api/loops/:id/runs/:num": "get_run_log",
+        "GET /api/tasks": "list_tasks",
+        "POST /api/tasks": "create_task",
+        "GET /api/tasks/:id": "get_task",
+        "PATCH /api/tasks/:id": "update_task",
+        "DELETE /api/tasks/:id": "delete_task",
+        "GET /api/projects": "list_projects",
+        "POST /api/projects": "create_project",
+        "PATCH /api/projects/:id": "update_project",
+        "DELETE /api/projects/:id": "delete_project",
+    };
+    const normalizedPath = path.replace(/\{[^}]+\}/g, (m) => ":" + m.slice(1, -1));
+    const key = `${method.toUpperCase()} ${normalizedPath}`;
+    return mappings[key] ?? null;
+}