@plainconceptsplatform/loop-task 2.6.0

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

@@ -0,0 +1,170 @@
+import fs from "node:fs";
+import { writeFileAtomic } from "../../shared/fs-utils.js";
+import { daemonLog } from "../daemon-log.js";
+import crypto from "node:crypto";
+import { getDataDir, projectsJson } from "../../shared/config/paths.js";
+import path from "node:path";
+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();
+        this.onDirectoryChange = null;
+    }
+    setOnDirectoryChange(callback) {
+        this.onDirectoryChange = callback;
+    }
+    init() {
+        const dataDir = getDataDir();
+        fs.mkdirSync(dataDir, { recursive: true });
+        this.migrateProjectsToJson();
+        this.loadProjects();
+        if (!this.projects.has("default")) {
+            this.createDefaultProject();
+        }
+    }
+    migrateProjectsToJson() {
+        const jsonFile = projectsJson();
+        if (fs.existsSync(jsonFile))
+            return;
+        const oldDir = path.join(getDataDir(), "projects");
+        if (!fs.existsSync(oldDir))
+            return;
+        try {
+            const files = fs.readdirSync(oldDir).filter((f) => f.endsWith(".json"));
+            if (files.length === 0)
+                return;
+            const projects = [];
+            for (const file of files) {
+                try {
+                    const raw = fs.readFileSync(path.join(oldDir, file), "utf-8");
+                    const content = JSON.parse(raw);
+                    if (content.id)
+                        projects.push(content);
+                }
+                catch {
+                    // skip corrupted files
+                }
+            }
+            writeFileAtomic(jsonFile, JSON.stringify(projects, null, 2));
+            daemonLog(`migrated ${projects.length} project(s) to projects.json`);
+        }
+        catch (err) {
+            daemonLog(`Failed to migrate projects: ${err}`);
+        }
+    }
+    loadProjects() {
+        this.projects.clear();
+        const jsonFile = projectsJson();
+        if (!fs.existsSync(jsonFile))
+            return;
+        try {
+            const raw = fs.readFileSync(jsonFile, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed))
+                return;
+            for (const item of parsed) {
+                if (item && item.id)
+                    this.projects.set(item.id, item);
+            }
+        }
+        catch (err) {
+            daemonLog(`Failed to load projects.json: ${err}`);
+        }
+    }
+    saveAllProjects() {
+        const all = Array.from(this.projects.values());
+        const content = JSON.stringify(all, null, 2);
+        writeFileAtomic(projectsJson(), content);
+        if (selfWriteNotifier)
+            selfWriteNotifier(projectsJson(), content);
+    }
+    saveProject(project) {
+        this.projects.set(project.id, project);
+        this.saveAllProjects();
+    }
+    createDefaultProject() {
+        const defaultProject = {
+            id: "default",
+            name: "Default",
+            color: "#ffffff",
+            directory: "",
+            createdAt: new Date().toISOString(),
+            isSystem: true,
+            isDefault: true,
+        };
+        this.saveProject(defaultProject);
+    }
+    getAll() {
+        return Array.from(this.projects.values());
+    }
+    get(id) {
+        return this.projects.get(id);
+    }
+    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,
+        };
+        this.saveProject(project);
+        return project;
+    }
+    update(id, name, color, directory, githubSource) {
+        const project = this.projects.get(id);
+        if (!project)
+            throw new Error(`Project ${id} not found`);
+        if (project.isSystem)
+            throw new Error("Cannot rename system project");
+        const oldDirectory = project.directory ?? "";
+        project.name = name;
+        if (color)
+            project.color = color;
+        if (directory !== undefined)
+            project.directory = directory;
+        if (githubSource !== undefined) {
+            if (githubSource !== "")
+                validateGithubSource(githubSource);
+            project.githubSource = githubSource || undefined;
+        }
+        this.saveProject(project);
+        if (directory !== undefined && directory !== oldDirectory) {
+            this.onDirectoryChange?.(id, oldDirectory, directory);
+        }
+    }
+    delete(id) {
+        const project = this.projects.get(id);
+        if (!project)
+            throw new Error(`Project ${id} not found`);
+        if (project.isSystem)
+            throw new Error("Cannot delete system project");
+        this.projects.delete(id);
+        this.saveAllProjects();
+    }
+    reload(newProjects) {
+        this.projects.clear();
+        for (const project of newProjects) {
+            this.projects.set(project.id, project);
+        }
+        if (!this.projects.has("default")) {
+            this.createDefaultProject();
+        }
+        daemonLog(`reloaded ${newProjects.length} project(s) from external change`);
+    }
+}

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

@@ -0,0 +1,94 @@
+import crypto from "node:crypto";
+import { DEFAULT_TASK_MAX_RUNS } from "../../types.js";
+import { saveTask, loadAllTasks, deleteTask as deleteTaskState } from "../state/index.js";
+import { daemonLog } from "../daemon-log.js";
+export class TaskManager {
+    constructor() {
+        this.tasks = new Map();
+        this.recipeTaskStore = null;
+    }
+    setRecipeTaskStore(store) {
+        this.recipeTaskStore = store;
+    }
+    init() {
+        const saved = loadAllTasks();
+        for (const task of saved) {
+            this.tasks.set(task.id, {
+                ...task,
+                maxRuns: task.maxRuns ?? DEFAULT_TASK_MAX_RUNS,
+            });
+        }
+        if (saved.length > 0) {
+            daemonLog(`loaded ${saved.length} task(s) from persisted state`);
+        }
+    }
+    create(input) {
+        const task = {
+            ...input,
+            id: input.id ?? crypto.randomUUID().slice(0, 8),
+            maxRuns: input.maxRuns ?? DEFAULT_TASK_MAX_RUNS,
+            createdAt: new Date().toISOString(),
+        };
+        this.tasks.set(task.id, task);
+        saveTask(task);
+        return task;
+    }
+    get(id) {
+        const userTask = this.tasks.get(id) ?? null;
+        if (userTask)
+            return userTask;
+        if (this.recipeTaskStore) {
+            return this.recipeTaskStore.get(id);
+        }
+        return null;
+    }
+    list() {
+        const userTasks = [...this.tasks.values()];
+        if (this.recipeTaskStore) {
+            return [...userTasks, ...this.recipeTaskStore.list()];
+        }
+        return userTasks;
+    }
+    update(id, input) {
+        if (this.recipeTaskStore?.has(id)) {
+            throw new Error("Recipe tasks are immutable and cannot be updated");
+        }
+        const existing = this.tasks.get(id);
+        if (!existing)
+            return null;
+        const updated = { ...existing, ...input };
+        this.tasks.set(id, updated);
+        saveTask(updated);
+        return updated;
+    }
+    delete(id) {
+        if (this.recipeTaskStore?.has(id)) {
+            throw new Error("Recipe tasks are immutable and cannot be deleted");
+        }
+        if (!this.tasks.has(id))
+            return false;
+        this.tasks.delete(id);
+        deleteTaskState(id);
+        return true;
+    }
+    createInline(command, commandArgs) {
+        const id = crypto.randomUUID().slice(0, 8);
+        const name = [command, ...commandArgs].join(" ").slice(0, 40);
+        return this.create({
+            id,
+            name,
+            command,
+            commandArgs,
+            onSuccessTaskId: null,
+            onFailureTaskId: null,
+            maxRuns: DEFAULT_TASK_MAX_RUNS,
+        });
+    }
+    reload(newTasks) {
+        this.tasks.clear();
+        for (const task of newTasks) {
+            this.tasks.set(task.id, task);
+        }
+        daemonLog(`reloaded ${newTasks.length} task(s) from external change`);
+    }
+}

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);
+        });
+    }
+}