loop-task 2.1.12 → 2.1.14

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

@@ -67,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,67 @@ 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;
+    let currentHttpHost = settingsManager.get().httpApiHost;
+    if (settingsManager.get().httpApiEnabled) {
+        try {
+            await httpServer.listen(resolvedHttpPort, currentHttpHost);
+        }
+        catch (err) {
+            daemonLog(`HTTP API server failed to start: ${String(err)}`);
+        }
     }
-    catch (err) {
-        daemonLog(`HTTP API server failed to start: ${String(err)}`);
+    mcpServer.setHost(currentHttpHost);
+    if (mcpEnabled) {
+        try {
+            await mcpServer.start();
+        }
+        catch (err) {
+            daemonLog(`MCP server failed to start: ${String(err)}`);
+        }
     }
+    settingsManager.onChange((settings) => {
+        const newHost = settings.httpApiHost;
+        const hostChanged = newHost !== currentHttpHost;
+        // HTTP API (8845)
+        if (settings.httpApiEnabled && !httpServer["isListening"]) {
+            httpServer.listen(resolvedHttpPort, newHost).catch((err) => {
+                daemonLog(`HTTP API server failed to restart: ${String(err)}`);
+            });
+        }
+        else if (settings.httpApiEnabled && httpServer["isListening"] && hostChanged) {
+            httpServer.restart(resolvedHttpPort, newHost).catch((err) => {
+                daemonLog(`HTTP API server failed to rebind to ${newHost}: ${String(err)}`);
+            });
+        }
+        else if (!settings.httpApiEnabled && httpServer["isListening"]) {
+            httpServer.close().catch((err) => {
+                daemonLog(`HTTP API server failed to stop: ${String(err)}`);
+            });
+        }
+        // MCP SSE (8846) — shares the same bind host as the HTTP API.
+        mcpServer.setHost(newHost);
+        if (settings.mcpApiEnabled && !mcpServer.isListening) {
+            mcpServer.start().catch((err) => {
+                daemonLog(`MCP server failed to restart: ${String(err)}`);
+            });
+        }
+        else if (settings.mcpApiEnabled && mcpServer.isListening && hostChanged) {
+            mcpServer
+                .close()
+                .then(() => mcpServer.start())
+                .catch((err) => {
+                daemonLog(`MCP server failed to rebind to ${newHost}: ${String(err)}`);
+            });
+        }
+        else if (!settings.mcpApiEnabled && mcpServer.isListening) {
+            mcpServer.close().catch((err) => {
+                daemonLog(`MCP server failed to stop: ${String(err)}`);
+            });
+        }
+        currentHttpHost = newHost;
+    });
     manager.init();
     writeDaemonPid(process.pid);
     writeDaemonSignature(computeCodeSignature());
@@ -53,6 +114,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/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;
+}

package/dist/daemon/mcp/server.js

@@ -0,0 +1,167 @@
+import http from "node:http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { daemonLog } from "../daemon-log.js";
+import { registerMcpTools } from "./tools.js";
+const MCP_DEFAULT_PORT = 8846;
+export class McpApiServer {
+    constructor(manager, taskManager, projectManager, transport) {
+        this.manager = manager;
+        this.taskManager = taskManager;
+        this.projectManager = projectManager;
+        this.mcpServer = null;
+        this.activeTransport = null;
+        this.httpServer = null;
+        this._isListening = false;
+        this.host = "127.0.0.1";
+        this.transportType = transport ?? "sse";
+    }
+    /** Set the bind host for the SSE transport (takes effect on next start). */
+    setHost(host) {
+        this.host = host;
+    }
+    createServer() {
+        const server = new McpServer({ name: "loop-task", version: "1.0.0" }, { capabilities: { tools: {} } });
+        registerMcpTools(server, { manager: this.manager, taskManager: this.taskManager, projectManager: this.projectManager });
+        return server;
+    }
+    get isListening() {
+        return this._isListening;
+    }
+    async start() {
+        if (this._isListening)
+            return;
+        try {
+            if (this.transportType === "stdio") {
+                await this.startStdio();
+            }
+            else {
+                await this.startSse();
+            }
+        }
+        catch (err) {
+            daemonLog(`MCP server failed to start: ${String(err)}`);
+        }
+    }
+    async close() {
+        if (!this._isListening)
+            return;
+        this._isListening = false;
+        if (this.mcpServer) {
+            try {
+                await this.mcpServer.close();
+            }
+            catch {
+                // ignore close errors
+            }
+            this.mcpServer = null;
+        }
+        if (this.httpServer) {
+            await new Promise((resolve) => {
+                this.httpServer.close(() => resolve());
+                this.httpServer.closeAllConnections?.();
+            });
+            this.httpServer = null;
+        }
+        this.activeTransport = null;
+        daemonLog("MCP server stopped");
+    }
+    async startStdio() {
+        if (!process.stdin || !process.stdout) {
+            daemonLog("MCP stdio transport: stdin/stdout not available, skipping");
+            return;
+        }
+        const server = this.createServer();
+        const transport = new StdioServerTransport();
+        this.mcpServer = server;
+        this.activeTransport = transport;
+        await server.connect(transport);
+        this._isListening = true;
+        daemonLog("MCP server listening on stdio");
+        transport.onclose = () => {
+            this._isListening = false;
+            daemonLog("MCP stdio transport closed");
+        };
+    }
+    async startSse() {
+        const port = parseInt(process.env.LOOP_CLI_MCP_PORT ?? "", 10) || MCP_DEFAULT_PORT;
+        // Map session ID → transport for POST routing
+        const sessions = new Map();
+        this.httpServer = http.createServer(async (req, res) => {
+            try {
+                const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+                if (req.method === "GET" && url.pathname === "/sse") {
+                    // Create a fresh McpServer per SSE connection — the SDK only allows
+                    // one transport per McpServer instance, so reusing one would cause
+                    // "Already connected to a transport" errors on reconnect.
+                    const server = this.createServer();
+                    const transport = new SSEServerTransport("/message", res);
+                    sessions.set(transport.sessionId, transport);
+                    await server.connect(transport);
+                    if (!this.mcpServer)
+                        this.mcpServer = server;
+                    this._isListening = true;
+                    daemonLog(`MCP SSE client connected (session: ${transport.sessionId})`);
+                    transport.onclose = () => {
+                        sessions.delete(transport.sessionId);
+                        daemonLog(`MCP SSE client disconnected (session: ${transport.sessionId})`);
+                    };
+                }
+                else if (req.method === "POST" && url.pathname === "/message") {
+                    const body = await this.readBody(req);
+                    // Route the POST to the correct transport by session ID
+                    const sessionId = url.searchParams.get("sessionId");
+                    const transport = sessionId ? sessions.get(sessionId) : sessions.values().next().value;
+                    if (transport) {
+                        await transport.handlePostMessage(req, res, body);
+                    }
+                    else {
+                        res.writeHead(400).end("No active SSE connection");
+                    }
+                }
+                else {
+                    res.writeHead(404).end("Not found");
+                }
+            }
+            catch (err) {
+                daemonLog(`MCP SSE request error: ${String(err)}`);
+                if (!res.headersSent) {
+                    res.writeHead(500).end("Internal error");
+                }
+            }
+        });
+        return new Promise((resolve) => {
+            this.httpServer.on("error", (err) => {
+                if (err.code === "EADDRINUSE") {
+                    daemonLog(`MCP SSE server: port ${port} already in use, skipping SSE transport`);
+                }
+                else {
+                    daemonLog(`MCP SSE server error: ${String(err)}`);
+                }
+                resolve();
+            });
+            this.httpServer.listen(port, this.host, () => {
+                daemonLog(`MCP SSE server listening on ${this.host}:${port}`);
+                this._isListening = true;
+                resolve();
+            });
+        });
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on("data", (chunk) => chunks.push(chunk));
+            req.on("end", () => {
+                try {
+                    const raw = Buffer.concat(chunks).toString("utf-8");
+                    resolve(raw ? JSON.parse(raw) : {});
+                }
+                catch {
+                    resolve({});
+                }
+            });
+            req.on("error", reject);
+        });
+    }
+}