@plainconceptsplatform/loop-task 2.6.0

package/dist/daemon/mcp/tools.js

@@ -0,0 +1,382 @@
+import { z } from "zod";
+import { buildLoopOptions } from "../../loop-config.js";
+import { validateContext } from "../../core/context/validate-context.js";
+import { LOG_TAIL_DEFAULT } from "../../shared/config/constants.js";
+import { tail } from "../../shared/tail.js";
+import fs from "node:fs";
+function ok(data) {
+    return { content: [{ type: "text", text: JSON.stringify({ ok: true, data }) }] };
+}
+function err(message) {
+    return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: { message } }) }], isError: true };
+}
+export function registerMcpTools(server, deps) {
+    const { manager, taskManager, projectManager } = deps;
+    server.registerTool("list_loops", { description: "List all loops" }, async () => {
+        return ok(manager.list());
+    });
+    server.registerTool("get_loop", { description: "Get loop status by ID", inputSchema: { id: z.string().describe("Loop ID") } }, async (args) => {
+        const meta = manager.status(args.id);
+        if (!meta)
+            return err(`Loop not found: ${args.id}`);
+        return ok(meta);
+    });
+    server.registerTool("create_loop", {
+        description: "Create a new loop",
+        inputSchema: {
+            command: z.string().optional().describe("Command to run"),
+            commandArgs: z.array(z.string()).optional().describe("Command arguments"),
+            intervalHuman: z.string().default("5m").describe("Interval like 30s, 5m, 1h, or 'manual' for trigger-only loops"),
+            cwd: z.string().optional().describe("Working directory"),
+            description: z.string().optional().describe("Loop description"),
+            taskId: z.string().nullable().optional().describe("Task ID to use instead of command"),
+            now: z.boolean().optional().describe("Run immediately on start"),
+            maxRuns: z.number().nullable().optional().describe("Maximum number of runs"),
+            verbose: z.boolean().optional().describe("Verbose output"),
+            projectId: z.string().optional().describe("Project ID"),
+            offset: z.number().nullable().optional().describe("Offset in ms from interval boundary"),
+            context: z.record(z.string(), z.unknown()).optional().describe("Initial context for chain interpolation"),
+        },
+    }, async (args) => {
+        try {
+            let context;
+            if (args.context !== undefined) {
+                const result = validateContext(args.context);
+                if (!result.valid)
+                    return err(result.error);
+                context = result.context;
+            }
+            const intervalHuman = args.intervalHuman ?? "5m";
+            const { options } = buildLoopOptions(intervalHuman, {
+                command: args.command,
+                commandArgs: args.commandArgs,
+                taskId: args.taskId,
+                cwd: args.cwd,
+                now: args.now,
+                maxRuns: args.maxRuns,
+                verbose: args.verbose,
+                description: args.description,
+                projectId: args.projectId,
+                offset: args.offset,
+                context,
+            });
+            const id = manager.start(options, intervalHuman);
+            return ok({ id });
+        }
+        catch (e) {
+            return err(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("update_loop", {
+        description: "Update an existing loop",
+        inputSchema: {
+            id: z.string().describe("Loop ID"),
+            command: z.string().optional().describe("Command to run"),
+            commandArgs: z.array(z.string()).optional().describe("Command arguments"),
+            intervalHuman: z.string().default("5m").describe("Interval like 30s, 5m, 1h, or 'manual'"),
+            cwd: z.string().optional().describe("Working directory"),
+            description: z.string().optional().describe("Loop description"),
+            taskId: z.string().nullable().optional().describe("Task ID"),
+            now: z.boolean().optional().describe("Run immediately"),
+            maxRuns: z.number().nullable().optional().describe("Maximum runs"),
+            verbose: z.boolean().optional().describe("Verbose output"),
+            projectId: z.string().optional().describe("Project ID"),
+            offset: z.number().nullable().optional().describe("Offset in ms"),
+            context: z.record(z.string(), z.unknown()).optional().describe("Context for chain interpolation"),
+        },
+    }, async (args) => {
+        try {
+            const id = args.id;
+            let context;
+            if (args.context !== undefined) {
+                const result = validateContext(args.context);
+                if (!result.valid)
+                    return err(result.error);
+                context = result.context;
+            }
+            const intervalHuman = args.intervalHuman ?? "5m";
+            const { options } = buildLoopOptions(intervalHuman, {
+                command: args.command,
+                commandArgs: args.commandArgs,
+                taskId: args.taskId,
+                cwd: args.cwd,
+                now: args.now,
+                maxRuns: args.maxRuns,
+                verbose: args.verbose,
+                description: args.description,
+                projectId: args.projectId,
+                offset: args.offset,
+                context,
+            });
+            const updated = await manager.update(id, options, intervalHuman);
+            if (!updated)
+                return err(`Loop not found: ${id}`);
+            return ok({ id });
+        }
+        catch (e) {
+            return err(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("delete_loop", { description: "Delete a loop by ID", inputSchema: { id: z.string().describe("Loop ID") } }, async (args) => {
+        try {
+            const deleted = await manager.delete(args.id);
+            if (!deleted)
+                return err(`Loop not found: ${args.id}`);
+            return ok();
+        }
+        catch (e) {
+            return err(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("pause_loop", { description: "Pause a loop", inputSchema: { id: z.string().describe("Loop ID") } }, async (args) => {
+        if (!manager.pause(args.id))
+            return err(`Loop not found or cannot pause: ${args.id}`);
+        return ok();
+    });
+    server.registerTool("resume_loop", { description: "Resume a paused loop", inputSchema: { id: z.string().describe("Loop ID") } }, async (args) => {
+        if (!manager.resume(args.id))
+            return err(`Loop not found or cannot resume: ${args.id}`);
+        return ok();
+    });
+    server.registerTool("trigger_loop", { description: "Trigger a loop to run immediately", inputSchema: { id: z.string().describe("Loop ID") } }, async (args) => {
+        const id = args.id;
+        if (manager.isMaxRunsBlocked(id))
+            return err("Max runs reached");
+        if (manager.isRunning(id))
+            return err("Loop is already running");
+        if (!manager.trigger(id))
+            return err(`Loop not found: ${id}`);
+        return ok();
+    });
+    server.registerTool("stop_loop", { description: "Stop a running loop", inputSchema: { id: z.string().describe("Loop ID") } }, async (args) => {
+        if (!manager.stopLoop(args.id))
+            return err(`Loop not found or cannot stop: ${args.id}`);
+        return ok();
+    });
+    server.registerTool("stop_all_loops", { description: "Stop all running loops" }, async () => {
+        const count = manager.stopAllLoops();
+        return ok({ count });
+    });
+    server.registerTool("list_tasks", { description: "List all tasks" }, async () => {
+        return ok(taskManager.list());
+    });
+    server.registerTool("get_task", { description: "Get a task by ID", inputSchema: { id: z.string().describe("Task ID") } }, async (args) => {
+        const task = taskManager.get(args.id);
+        if (!task)
+            return err(`Task not found: ${args.id}`);
+        return ok(task);
+    });
+    server.registerTool("create_task", {
+        description: "Create a new task",
+        inputSchema: {
+            id: z.string().optional().describe("Task ID (auto-generated if omitted)"),
+            name: z.string().describe("Task name"),
+            command: z.string().describe("Command to run"),
+            commandArgs: z.array(z.string()).optional().describe("Command arguments"),
+            commandRaw: z.string().optional().describe("Raw command string"),
+            steps: z.array(z.object({ commands: z.array(z.object({ command: z.string(), commandArgs: z.array(z.string()) })) })).optional().describe("Task steps"),
+            onSuccessTaskId: z.string().nullable().optional().describe("Task to run on success"),
+            onFailureTaskId: z.string().nullable().optional().describe("Task to run on failure"),
+            maxRuns: z.number().optional().describe("Maximum number of runs"),
+            silentChain: z.boolean().optional().describe("Suppress chain output"),
+            context: z.record(z.string(), z.unknown()).optional().describe("Context for chain interpolation"),
+        },
+    }, async (args) => {
+        try {
+            const name = args.name;
+            const command = args.command;
+            if (!name?.trim())
+                return err("Task name is required");
+            if (!command?.trim())
+                return err("Task command is required");
+            const input = {
+                id: args.id ?? "",
+                name,
+                command,
+                commandArgs: args.commandArgs ?? [],
+                commandRaw: args.commandRaw,
+                steps: args.steps,
+                onSuccessTaskId: args.onSuccessTaskId ?? null,
+                onFailureTaskId: args.onFailureTaskId ?? null,
+                maxRuns: args.maxRuns,
+                silentChain: args.silentChain,
+                context: args.context,
+            };
+            if (input.context !== undefined) {
+                const result = validateContext(input.context);
+                if (!result.valid)
+                    return err(result.error);
+                input.context = result.context;
+            }
+            const task = taskManager.create(input);
+            return ok(task);
+        }
+        catch (e) {
+            return err(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("update_task", {
+        description: "Update an existing task",
+        inputSchema: {
+            id: z.string().describe("Task ID"),
+            name: z.string().describe("Task name"),
+            command: z.string().describe("Command to run"),
+            commandArgs: z.array(z.string()).optional().describe("Command arguments"),
+            commandRaw: z.string().optional().describe("Raw command string"),
+            steps: z.array(z.object({ commands: z.array(z.object({ command: z.string(), commandArgs: z.array(z.string()) })) })).optional().describe("Task steps"),
+            onSuccessTaskId: z.string().nullable().optional().describe("Task to run on success"),
+            onFailureTaskId: z.string().nullable().optional().describe("Task to run on failure"),
+            maxRuns: z.number().optional().describe("Maximum number of runs"),
+            silentChain: z.boolean().optional().describe("Suppress chain output"),
+            context: z.record(z.string(), z.unknown()).optional().describe("Context for chain interpolation"),
+        },
+    }, async (args) => {
+        try {
+            const id = args.id;
+            const name = args.name;
+            const command = args.command;
+            if (!name?.trim())
+                return err("Task name is required");
+            if (!command?.trim())
+                return err("Task command is required");
+            const input = {
+                name,
+                command,
+                commandArgs: args.commandArgs ?? [],
+                commandRaw: args.commandRaw,
+                steps: args.steps,
+                onSuccessTaskId: args.onSuccessTaskId ?? null,
+                onFailureTaskId: args.onFailureTaskId ?? null,
+                maxRuns: args.maxRuns,
+                silentChain: args.silentChain,
+                context: args.context,
+            };
+            if (input.context !== undefined) {
+                const result = validateContext(input.context);
+                if (!result.valid)
+                    return err(result.error);
+                input.context = result.context;
+            }
+            const updated = taskManager.update(id, input);
+            if (!updated)
+                return err(`Task not found: ${id}`);
+            return ok(updated);
+        }
+        catch (e) {
+            return err(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("delete_task", { description: "Delete a task by ID", inputSchema: { id: z.string().describe("Task ID") } }, async (args) => {
+        try {
+            if (!taskManager.delete(args.id))
+                return err(`Task not found: ${args.id}`);
+            return ok();
+        }
+        catch (e) {
+            return err(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("list_projects", { description: "List all projects" }, async () => {
+        return ok(projectManager.getAll());
+    });
+    server.registerTool("get_project", { description: "Get a project by ID", inputSchema: { id: z.string().describe("Project ID") } }, async (args) => {
+        const project = projectManager.get(args.id);
+        if (!project)
+            return err(`Project not found: ${args.id}`);
+        return ok(project);
+    });
+    server.registerTool("create_project", {
+        description: "Create a new project",
+        inputSchema: {
+            name: z.string().describe("Project name"),
+            color: z.string().default("#ffffff").describe("Project color (hex)"),
+            directory: z.string().optional().describe("Local working directory for loops"),
+            githubSource: z.string().optional().describe("GitHub repository in owner/repo format"),
+        },
+    }, async (args) => {
+        try {
+            const name = args.name;
+            if (!name?.trim())
+                return err("Project name is required");
+            const project = projectManager.create(name.trim(), args.color ?? "#ffffff", args.directory, args.githubSource);
+            return ok(project);
+        }
+        catch (e) {
+            return err(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("update_project", {
+        description: "Update an existing project",
+        inputSchema: {
+            id: z.string().describe("Project ID"),
+            name: z.string().describe("Project name"),
+            color: z.string().optional().describe("Project color (hex)"),
+            directory: z.string().optional().describe("Local working directory"),
+            githubSource: z.string().optional().describe("GitHub repository in owner/repo format"),
+        },
+    }, async (args) => {
+        try {
+            const name = args.name;
+            if (!name?.trim())
+                return err("Project name is required");
+            projectManager.update(args.id, name.trim(), args.color, args.directory, args.githubSource);
+            return ok();
+        }
+        catch (e) {
+            return err(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("delete_project", { description: "Delete a project by ID", inputSchema: { id: z.string().describe("Project ID") } }, async (args) => {
+        try {
+            projectManager.delete(args.id);
+            return ok();
+        }
+        catch (e) {
+            return err(e instanceof Error ? e.message : String(e));
+        }
+    });
+    server.registerTool("get_loop_logs", {
+        description: "Fetch loop log snapshot (last N lines)",
+        inputSchema: {
+            id: z.string().describe("Loop ID"),
+            tail: z.number().default(LOG_TAIL_DEFAULT).describe("Number of lines from the end"),
+        },
+    }, async (args) => {
+        const id = args.id;
+        const logPath = manager.getLogPath(id);
+        if (!logPath)
+            return err(`Loop not found: ${id}`);
+        if (!fs.existsSync(logPath))
+            return ok("");
+        const content = fs.readFileSync(logPath, "utf-8");
+        return ok(tail(content, args.tail ?? LOG_TAIL_DEFAULT).join("\n"));
+    });
+    server.registerTool("get_run_log", {
+        description: "Get run-specific log for a loop",
+        inputSchema: {
+            id: z.string().describe("Loop ID"),
+            runNumber: z.number().describe("Run number"),
+        },
+    }, async (args) => {
+        const id = args.id;
+        const runNumber = args.runNumber;
+        const logPath = manager.getLogPath(id);
+        if (!logPath || !fs.existsSync(logPath))
+            return ok("");
+        const meta = manager.status(id);
+        if (!meta)
+            return err(`Loop not found: ${id}`);
+        const records = meta.runHistory.filter((r) => r.runNumber === runNumber).sort((a, b) => a.logOffset - b.logOffset);
+        if (records.length === 0)
+            return ok("");
+        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);
+        });
+        return ok(parts.join(""));
+    });
+}

package/dist/daemon/recipe/deferred-reload.js

@@ -0,0 +1,32 @@
+import { daemonLog } from "../daemon-log.js";
+export class DeferredReloadManager {
+    constructor(scanner) {
+        this.pendingReloads = new Map();
+        this.scanner = scanner;
+    }
+    requestReload(recipeId, filePath, controller) {
+        if (controller.status === "running") {
+            this.pendingReloads.set(recipeId, filePath);
+            const handler = () => {
+                this.pendingReloads.delete(recipeId);
+                controller.removeListener("stopped", handler);
+                daemonLog(`deferred reload triggered for recipe ${recipeId}`);
+                this.scanner.reloadRecipe(recipeId);
+            };
+            controller.once("stopped", handler);
+            daemonLog(`deferred reload queued for recipe ${recipeId} (loop running)`);
+        }
+        else {
+            this.scanner.reloadRecipe(recipeId);
+        }
+    }
+    cancelReload(recipeId) {
+        this.pendingReloads.delete(recipeId);
+    }
+    hasPending(recipeId) {
+        return this.pendingReloads.has(recipeId);
+    }
+    clear() {
+        this.pendingReloads.clear();
+    }
+}

package/dist/daemon/recipe/diagram-reader.js

@@ -0,0 +1,26 @@
+import fs from "node:fs";
+import * as yaml from "js-yaml";
+/**
+ * Read the `diagram` field from a recipe YAML file.
+ * Returns the diagram text if present, or null if the file has no diagram.
+ * Throws if the file cannot be read or parsed.
+ */
+export function readRecipeDiagram(filePath) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Recipe file not found: ${filePath}`);
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const data = yaml.load(raw);
+    if (!data || typeof data !== "object") {
+        throw new Error(`Recipe file is not a valid YAML mapping: ${filePath}`);
+    }
+    const diagram = data.diagram;
+    if (diagram === undefined || diagram === null) {
+        return null;
+    }
+    if (typeof diagram !== "string") {
+        return null;
+    }
+    // Trim trailing newline that YAML block scalars often add
+    return diagram.replace(/\n$/, "");
+}

package/dist/daemon/recipe/file-writer.js

@@ -0,0 +1,52 @@
+import fs from "node:fs";
+import { parseDocument, isMap, isSeq } from "yaml";
+import { writeFileAtomic } from "../../shared/fs-utils.js";
+let selfWriteNotifier = null;
+export function setRecipeSelfWriteNotifier(notifier) {
+    selfWriteNotifier = notifier;
+}
+/**
+ * Writes recipe override fields back to the YAML file.
+ *
+ * Uses the `yaml` package's Document API for AST-preserving round-trips:
+ * only the touched leaf fields (loops[0].intervalHuman, maxRuns, context)
+ * are mutated in place. Every other node, including a diagram block scalar
+ * holding ASCII art, survives byte-for-byte.
+ */
+export function writeRecipeOverrides(filePath, overrides) {
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`Recipe file not found: ${filePath}`);
+    }
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const doc = parseDocument(raw);
+    if (doc.errors.length > 0) {
+        throw new Error(`Recipe file is not valid YAML: ${filePath}: ${doc.errors[0].message}`);
+    }
+    const root = doc.contents;
+    if (!root || !isMap(root)) {
+        throw new Error(`Recipe file has no root mapping: ${filePath}`);
+    }
+    const loopsNode = root.get("loops");
+    if (!loopsNode || !isSeq(loopsNode) || loopsNode.items.length === 0) {
+        throw new Error(`Recipe file has no loops: ${filePath}`);
+    }
+    const loop = loopsNode.items[0];
+    if (!loop || !isMap(loop)) {
+        throw new Error(`Recipe loops[0] is not a mapping: ${filePath}`);
+    }
+    const loopMap = loop;
+    if (overrides.intervalHuman !== undefined) {
+        loopMap.set("intervalHuman", doc.createNode(overrides.intervalHuman));
+    }
+    if (overrides.maxRuns !== undefined) {
+        loopMap.set("maxRuns", doc.createNode(overrides.maxRuns));
+    }
+    if (overrides.context !== undefined) {
+        loopMap.set("context", doc.createNode(overrides.context));
+    }
+    const content = String(doc);
+    writeFileAtomic(filePath, content);
+    if (selfWriteNotifier) {
+        selfWriteNotifier(filePath, content);
+    }
+}

package/dist/daemon/recipe/id-remapper.js

@@ -0,0 +1,46 @@
+import crypto from "node:crypto";
+import { DEFAULT_TASK_MAX_RUNS } from "../../types.js";
+export function remapRecipeIds(recipe, projectId) {
+    const remapTable = new Map();
+    for (const task of recipe.tasks) {
+        const newId = crypto.randomBytes(4).toString("hex");
+        remapTable.set(task.id, newId);
+    }
+    const tasks = recipe.tasks.map((task) => {
+        const remappedTask = {
+            id: remapTable.get(task.id),
+            name: task.name ?? task.id,
+            command: task.command ?? "",
+            commandArgs: task.commandArgs ?? [],
+            onSuccessTaskId: task.onSuccessTaskId ? remapTable.get(task.onSuccessTaskId) ?? null : null,
+            onFailureTaskId: task.onFailureTaskId ? remapTable.get(task.onFailureTaskId) ?? null : null,
+            maxRuns: DEFAULT_TASK_MAX_RUNS,
+            createdAt: new Date().toISOString(),
+            isRecipeTask: true,
+            projectId,
+        };
+        if (task.silentChain !== undefined) {
+            remappedTask.silentChain = task.silentChain;
+        }
+        if (task.context !== undefined) {
+            remappedTask.context = task.context;
+        }
+        if (task.steps) {
+            remappedTask.steps = task.steps.map((step) => ({
+                commands: step.commands.map((cmd) => ({
+                    command: cmd.command,
+                    commandArgs: cmd.commandArgs,
+                })),
+            }));
+        }
+        if (task.commandRaw !== undefined) {
+            remappedTask.commandRaw = task.commandRaw;
+        }
+        return remappedTask;
+    });
+    const loop = { ...recipe.loops[0] };
+    if (loop.taskId) {
+        loop.taskId = remapTable.get(loop.taskId) ?? loop.taskId;
+    }
+    return { loop, tasks, remapTable };
+}

package/dist/daemon/recipe/runtime-state.js

@@ -0,0 +1,23 @@
+import fs from "node:fs";
+import { writeFileAtomic } from "../../shared/fs-utils.js";
+import { getDataDir, recipeRuntimeJson } from "../../shared/config/paths.js";
+function loadAll() {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(recipeRuntimeJson(), "utf-8"));
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function loadRecipeRuntimeState(id) {
+    return loadAll()[id];
+}
+export function saveRecipeRuntimeState(id, state) {
+    fs.mkdirSync(getDataDir(), { recursive: true });
+    const states = loadAll();
+    states[id] = state;
+    writeFileAtomic(recipeRuntimeJson(), JSON.stringify(states, null, 2));
+}