@plainconceptsplatform/loop-task 2.6.0

package/dist/daemon/recipe/scanner.js

@@ -0,0 +1,165 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import * as yaml from "js-yaml";
+import { LoopController } from "../../core/loop/loop-controller.js";
+import { validateRecipeFile } from "./validator.js";
+import { remapRecipeIds } from "./id-remapper.js";
+import { getLogPath } from "../state/index.js";
+import { daemonLog } from "../daemon-log.js";
+import { parseDuration } from "../../duration.js";
+import { loadRecipeRuntimeState, saveRecipeRuntimeState } from "./runtime-state.js";
+const RECIPE_EXTENSIONS = [".yaml", ".yml"];
+const RECIPE_DIR = ".loops/recipes";
+export function recipeLoopId(projectId, filePath) {
+    return `recipe-${crypto.createHash("sha1").update(`${projectId}:${path.resolve(filePath)}`).digest("hex").slice(0, 16)}`;
+}
+export class RecipeScanner {
+    constructor(recipeTaskStore) {
+        this.loopManager = null;
+        this.projectManager = null;
+        this.recipes = new Map();
+        this.recipeTaskStore = recipeTaskStore;
+    }
+    setManagers(loopManager, projectManager) {
+        this.loopManager = loopManager;
+        this.projectManager = projectManager;
+    }
+    getRecipeTaskStore() {
+        return this.recipeTaskStore;
+    }
+    getRecipe(recipeId) {
+        return this.recipes.get(recipeId);
+    }
+    listRecipes() {
+        return [...this.recipes.values()];
+    }
+    scanAllProjects() {
+        if (!this.projectManager)
+            return;
+        const projects = this.projectManager.getAll();
+        for (const project of projects) {
+            if (project.directory) {
+                this.scanDirectory(project.id, project.directory);
+            }
+        }
+    }
+    scanDirectory(projectId, projectDir) {
+        const recipesDir = path.join(projectDir, RECIPE_DIR);
+        if (!fs.existsSync(recipesDir))
+            return;
+        try {
+            const files = fs.readdirSync(recipesDir).filter((f) => RECIPE_EXTENSIONS.some((ext) => f.endsWith(ext)));
+            for (const file of files) {
+                const filePath = path.join(recipesDir, file);
+                this.loadRecipe(projectId, filePath, file);
+            }
+        }
+        catch (err) {
+            daemonLog(`error scanning recipes directory ${recipesDir}: ${String(err)}`);
+        }
+    }
+    loadRecipe(projectId, filePath, fileName) {
+        if (!this.loopManager)
+            return null;
+        const existing = this.findRecipeByPath(filePath);
+        if (existing) {
+            return existing.id;
+        }
+        let raw;
+        try {
+            raw = yaml.load(fs.readFileSync(filePath, "utf-8"));
+        }
+        catch (err) {
+            daemonLog(`error reading recipe file ${filePath}: ${String(err)}`);
+            return null;
+        }
+        const validation = validateRecipeFile(raw);
+        if (!validation.valid) {
+            daemonLog(`invalid recipe file ${filePath}: ${validation.error}`);
+            return null;
+        }
+        const recipe = validation.data;
+        const { loop: recipeLoop, tasks } = remapRecipeIds(recipe, projectId);
+        const id = recipeLoopId(projectId, filePath);
+        const taskIds = tasks.map((t) => t.id);
+        this.recipeTaskStore.setMany(tasks);
+        const projectDir = this.projectManager?.get(projectId)?.directory ?? "";
+        const intervalHuman = recipeLoop.intervalHuman ?? "0";
+        const interval = intervalHuman === "0" || intervalHuman === "manual" ? 0 : parseDuration(intervalHuman);
+        const options = {
+            interval,
+            taskId: recipeLoop.taskId ?? null,
+            command: recipeLoop.command ?? "",
+            commandArgs: recipeLoop.commandArgs ?? [],
+            cwd: projectDir,
+            immediate: recipeLoop.immediate ?? false,
+            maxRuns: recipeLoop.maxRuns ?? null,
+            verbose: recipeLoop.verbose ?? false,
+            description: recipeLoop.description ?? "",
+            projectId,
+            offset: recipeLoop.offset ?? null,
+            context: recipeLoop.context,
+        };
+        const taskResolver = (taskId) => this.recipeTaskStore.get(taskId) ?? null;
+        const logPath = getLogPath(id);
+        const controller = new LoopController(id, options, logPath, taskResolver, loadRecipeRuntimeState(id), projectDir);
+        const entry = { controller, options, intervalHuman };
+        this.loopManager.addRecipeLoop(id, entry, fileName, filePath, () => {
+            saveRecipeRuntimeState(id, controller.getMeta());
+        });
+        this.recipes.set(id, {
+            id,
+            projectId,
+            recipeFile: fileName,
+            filePath,
+            taskIds,
+        });
+        controller.start();
+        daemonLog(`loaded recipe loop ${id} from ${fileName} (project: ${projectId})`);
+        return id;
+    }
+    unloadRecipe(recipeId) {
+        if (!this.loopManager)
+            return;
+        const entry = this.recipes.get(recipeId);
+        if (!entry)
+            return;
+        this.loopManager.removeRecipeLoop(recipeId);
+        this.recipeTaskStore.deleteMany(entry.taskIds);
+        this.recipes.delete(recipeId);
+        daemonLog(`unloaded recipe loop ${recipeId} from ${entry.recipeFile}`);
+    }
+    reloadRecipe(recipeId) {
+        const entry = this.recipes.get(recipeId);
+        if (!entry)
+            return;
+        this.unloadRecipe(recipeId);
+        this.loadRecipe(entry.projectId, entry.filePath, entry.recipeFile);
+    }
+    unloadRecipesForProject(projectId) {
+        const toRemove = [];
+        for (const [id, entry] of this.recipes) {
+            if (entry.projectId === projectId) {
+                toRemove.push(id);
+            }
+        }
+        for (const id of toRemove) {
+            this.unloadRecipe(id);
+        }
+    }
+    findRecipeByPath(filePath) {
+        for (const entry of this.recipes.values()) {
+            if (entry.filePath === filePath)
+                return entry;
+        }
+        return undefined;
+    }
+    findRecipeByFileName(projectId, fileName) {
+        for (const entry of this.recipes.values()) {
+            if (entry.projectId === projectId && entry.recipeFile === fileName)
+                return entry;
+        }
+        return undefined;
+    }
+}

package/dist/daemon/recipe/task-store.js

@@ -0,0 +1,33 @@
+export class RecipeTaskStore {
+    constructor() {
+        this.tasks = new Map();
+    }
+    get(id) {
+        return this.tasks.get(id) ?? null;
+    }
+    list() {
+        return [...this.tasks.values()];
+    }
+    set(task) {
+        this.tasks.set(task.id, task);
+    }
+    setMany(tasks) {
+        for (const task of tasks) {
+            this.tasks.set(task.id, task);
+        }
+    }
+    delete(id) {
+        return this.tasks.delete(id);
+    }
+    deleteMany(ids) {
+        for (const id of ids) {
+            this.tasks.delete(id);
+        }
+    }
+    clear() {
+        this.tasks.clear();
+    }
+    has(id) {
+        return this.tasks.has(id);
+    }
+}

package/dist/daemon/recipe/validator.js

@@ -0,0 +1,35 @@
+export function validateRecipeFile(raw) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return { valid: false, error: "Recipe file must be a mapping (root object)" };
+    }
+    const data = raw;
+    if (!("version" in data)) {
+        return { valid: false, error: "Missing export version. Expected: 2" };
+    }
+    if (data.version !== 2) {
+        return { valid: false, error: `Unsupported export version: ${data.version}. Expected: 2` };
+    }
+    if (!("loops" in data) || !Array.isArray(data.loops)) {
+        return { valid: false, error: "Missing or invalid 'loops' array" };
+    }
+    if (data.loops.length === 0) {
+        return { valid: false, error: "Recipe file must have exactly one loop in 'loops' array" };
+    }
+    if (data.loops.length > 1) {
+        return { valid: false, error: "Recipe file must have exactly one loop, found " + data.loops.length };
+    }
+    if (!("tasks" in data) || !Array.isArray(data.tasks)) {
+        return { valid: false, error: "Missing or invalid 'tasks' array" };
+    }
+    for (let i = 0; i < data.tasks.length; i++) {
+        const task = data.tasks[i];
+        if (typeof task !== "object" || task === null) {
+            return { valid: false, error: `tasks[${i}]: must be an object` };
+        }
+        const record = task;
+        if (!record.id || typeof record.id !== "string") {
+            return { valid: false, error: `tasks[${i}]: missing or invalid 'id' field` };
+        }
+    }
+    return { valid: true, data: data };
+}

package/dist/daemon/server/handlers/diagnostics-handlers.js

@@ -0,0 +1,7 @@
+import { send } from "../../ipc/send.js";
+import { collectDiagnostics, isDiagnosticsEnabled } from "../../diagnostics.js";
+export function handleDiagnostics(_request, socket, ctx) {
+    const extended = isDiagnosticsEnabled();
+    const diag = collectDiagnostics(ctx.manager, extended);
+    send(socket, { type: "ok", data: diag });
+}

package/dist/daemon/server/handlers/index.js

@@ -0,0 +1,101 @@
+import { handleStart, handleUpdate, handleList, handleStatus, handlePause, handleResume, handleStopLoop, handleStopAll, handlePlayLoop, handleTrigger, handleDelete, } from "./loop-handlers.js";
+import { handleRunLog, handleRunLogStream, handleLogs, } from "./log-handlers.js";
+import { handleTaskCreate, handleTaskUpdate, handleTaskList, handleTaskGet, handleTaskDelete, } from "./task-handlers.js";
+import { handleProjectList, handleProjectCreate, handleProjectUpdate, handleProjectDelete, } from "./project-handlers.js";
+import { handleSettingsGet, handleSettingsSet, } from "./settings-handlers.js";
+import { handleDiagnostics } from "./diagnostics-handlers.js";
+import { handleTelemetryTest } from "./telemetry-handlers.js";
+export { handleStart, handleUpdate, handleList, handleStatus, handlePause, handleResume, handleStopLoop, handleStopAll, handlePlayLoop, handleTrigger, handleDelete, handleRunLog, handleRunLogStream, handleLogs, handleTaskCreate, handleTaskUpdate, handleTaskList, handleTaskGet, handleTaskDelete, handleProjectList, handleProjectCreate, handleProjectUpdate, handleProjectDelete, handleSettingsGet, handleSettingsSet, handleDiagnostics, handleTelemetryTest, };
+/**
+ * Dispatch an incoming IPC request to the appropriate handler.
+ * Returns true if the request was handled, false otherwise.
+ */
+export async function dispatch(request, socket, ctx) {
+    switch (request.type) {
+        case "start":
+            handleStart(request, socket, ctx);
+            break;
+        case "update":
+            await handleUpdate(request, socket, ctx);
+            break;
+        case "list":
+            handleList(request, socket, ctx);
+            break;
+        case "status":
+            handleStatus(request, socket, ctx);
+            break;
+        case "pause":
+            handlePause(request, socket, ctx);
+            break;
+        case "resume":
+            handleResume(request, socket, ctx);
+            break;
+        case "stop-loop":
+            await handleStopLoop(request, socket, ctx);
+            break;
+        case "stop-all":
+            await handleStopAll(request, socket, ctx);
+            break;
+        case "play-loop":
+            handlePlayLoop(request, socket, ctx);
+            break;
+        case "trigger":
+            handleTrigger(request, socket, ctx);
+            break;
+        case "delete":
+            await handleDelete(request, socket, ctx);
+            break;
+        case "run-log":
+            handleRunLog(request, socket, ctx);
+            break;
+        case "run-log-stream":
+            handleRunLogStream(request, socket, ctx);
+            break;
+        case "attach":
+        case "logs":
+            handleLogs(request, socket, ctx);
+            break;
+        case "task-create":
+            handleTaskCreate(request, socket, ctx);
+            break;
+        case "task-update":
+            handleTaskUpdate(request, socket, ctx);
+            break;
+        case "task-list":
+            handleTaskList(request, socket, ctx);
+            break;
+        case "task-get":
+            handleTaskGet(request, socket, ctx);
+            break;
+        case "task-delete":
+            handleTaskDelete(request, socket, ctx);
+            break;
+        case "project-list":
+            handleProjectList(request, socket, ctx);
+            break;
+        case "project-create":
+            handleProjectCreate(request, socket, ctx);
+            break;
+        case "project-update":
+            handleProjectUpdate(request, socket, ctx);
+            break;
+        case "project-delete":
+            handleProjectDelete(request, socket, ctx);
+            break;
+        case "settings-get":
+            await handleSettingsGet(request, socket, ctx.settingsManager);
+            break;
+        case "settings-set":
+            await handleSettingsSet(request, socket, ctx.settingsManager);
+            break;
+        case "diagnostics":
+            handleDiagnostics(request, socket, ctx);
+            break;
+        case "telemetry-test":
+            handleTelemetryTest(request, socket, ctx.telemetryManager);
+            break;
+        default:
+            return false;
+    }
+    return true;
+}

package/dist/daemon/server/handlers/log-handlers.js

@@ -0,0 +1,129 @@
+import fs from "node:fs";
+import { send } from "../../ipc/send.js";
+import { t } from "../../../shared/i18n/index.js";
+import { LOG_TAIL_DEFAULT, MAX_STREAM_INITIAL_BYTES } from "../../../shared/config/constants.js";
+import { tailFileBounded, readByteRange } from "../../../core/logging/bounded-log-reader.js";
+import { followLogFile } from "../../../core/logging/log-follower.js";
+function ipcLine(line) {
+    return JSON.stringify({ type: "data", line }) + "\n";
+}
+export function handleRunLog(request, socket, ctx) {
+    const { id, runNumber } = request.payload;
+    const logPath = ctx.manager.getLogPath(id);
+    if (!logPath || !fs.existsSync(logPath)) {
+        send(socket, { type: "ok", data: "" });
+        return;
+    }
+    const meta = ctx.manager.status(id);
+    if (!meta) {
+        send(socket, { type: "ok", data: "" });
+        return;
+    }
+    const records = meta.runHistory
+        .filter((r) => r.runNumber === runNumber)
+        .sort((a, b) => a.logOffset - b.logOffset);
+    if (records.length === 0) {
+        send(socket, { type: "ok", data: "" });
+        return;
+    }
+    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 : undefined;
+        return readByteRange(logPath, start, end);
+    });
+    send(socket, { type: "ok", data: parts.join("") });
+}
+export function handleRunLogStream(request, socket, ctx) {
+    const { id, runNumber } = request.payload;
+    const meta = ctx.manager.status(id);
+    if (!meta) {
+        send(socket, { type: "error", message: t("errors.loopNotFound", { id }) });
+        return;
+    }
+    const records = meta.runHistory
+        .filter((r) => r.runNumber === runNumber)
+        .sort((a, b) => a.logOffset - b.logOffset);
+    if (records.length === 0) {
+        send(socket, { type: "ok", data: "" });
+        return;
+    }
+    const logPath = ctx.manager.getLogPath(id);
+    if (!logPath || !fs.existsSync(logPath)) {
+        send(socket, { type: "ok", data: "" });
+        return;
+    }
+    const firstOffset = records[0].logOffset;
+    const stat = fs.statSync(logPath);
+    if (stat.size > firstOffset) {
+        const data = readByteRange(logPath, firstOffset, Math.min(stat.size, firstOffset + MAX_STREAM_INITIAL_BYTES));
+        for (const line of data.split("\n")) {
+            if (line) {
+                send(socket, { type: "data", line });
+            }
+        }
+    }
+    const allCompleted = records.every((r) => r.status === "completed");
+    if (allCompleted) {
+        send(socket, { type: "end" });
+        return;
+    }
+    const watcher = followLogFile({
+        logPath,
+        initialOffset: stat.size,
+        dest: socket,
+        formatLine: ipcLine,
+        onEnd: () => send(socket, { type: "end" }),
+        onError: () => send(socket, { type: "end" }),
+    });
+    socket.on("close", () => watcher.close());
+    socket.on("error", () => watcher.close());
+}
+export function handleLogs(request, socket, ctx) {
+    const id = request.payload.id;
+    const logPath = ctx.manager.getLogPath(id);
+    if (!logPath) {
+        send(socket, { type: "error", message: t("errors.loopNotFound", { id }) });
+        return;
+    }
+    if (!fs.existsSync(logPath)) {
+        if (request.type === "logs") {
+            send(socket, { type: "ok", data: "" });
+        }
+        else {
+            send(socket, { type: "error", message: t("errors.noLogsYet") });
+        }
+        return;
+    }
+    const follow = request.type === "attach" || (request.type === "logs" && request.payload.follow);
+    const tailCount = request.type === "logs" ? (request.payload.tail ?? LOG_TAIL_DEFAULT) : 0;
+    if (follow) {
+        streamLogFollowBounded(logPath, socket, tailCount);
+    }
+    else {
+        const lines = tailFileBounded(logPath, tailCount);
+        send(socket, { type: "ok", data: lines.join("\n") });
+    }
+}
+function streamLogFollowBounded(logPath, socket, tailCount) {
+    if (fs.existsSync(logPath)) {
+        const lines = tailFileBounded(logPath, tailCount);
+        for (const line of lines) {
+            if (line) {
+                send(socket, { type: "data", line });
+            }
+        }
+    }
+    const initialOffset = fs.existsSync(logPath) ? fs.statSync(logPath).size : 0;
+    const watcher = followLogFile({
+        logPath,
+        initialOffset,
+        dest: socket,
+        formatLine: ipcLine,
+        onEnd: () => send(socket, { type: "end" }),
+        onError: () => send(socket, { type: "end" }),
+    });
+    socket.on("close", () => watcher.close());
+    socket.on("error", () => watcher.close());
+}

package/dist/daemon/server/handlers/loop-handlers.js

@@ -0,0 +1,64 @@
+import { send } from "../../ipc/send.js";
+import { t } from "../../../shared/i18n/index.js";
+export function handleStart(request, socket, ctx) {
+    const { intervalHuman, ...options } = request.payload;
+    const id = ctx.manager.start(options, intervalHuman);
+    send(socket, { type: "ok", data: { id } });
+}
+export async function handleUpdate(request, socket, ctx) {
+    const { id, intervalHuman, ...options } = request.payload;
+    try {
+        const ok = await ctx.manager.update(id, options, intervalHuman);
+        ctx.respondOk(socket, ok, id, ok ? { id } : undefined);
+    }
+    catch (err) {
+        send(socket, { type: "error", message: err instanceof Error ? err.message : String(err) });
+    }
+}
+export function handleList(_request, socket, ctx) {
+    send(socket, { type: "ok", data: ctx.manager.list() });
+}
+export function handleStatus(request, socket, ctx) {
+    const meta = ctx.manager.status(request.payload.id);
+    ctx.respondOk(socket, meta !== null, request.payload.id, meta ?? undefined);
+}
+export function handlePause(request, socket, ctx) {
+    ctx.respondOk(socket, ctx.manager.pause(request.payload.id), request.payload.id);
+}
+export function handleResume(request, socket, ctx) {
+    ctx.respondOk(socket, ctx.manager.resume(request.payload.id), request.payload.id);
+}
+export async function handleStopLoop(request, socket, ctx) {
+    ctx.respondOk(socket, await ctx.manager.stopLoop(request.payload.id), request.payload.id);
+}
+export async function handleStopAll(_request, socket, ctx) {
+    const count = await ctx.manager.stopAllLoops();
+    send(socket, { type: "ok", data: count });
+}
+export function handlePlayLoop(request, socket, ctx) {
+    if (ctx.manager.isMaxRunsBlocked(request.payload.id)) {
+        send(socket, { type: "error", message: t("errors.maxRunsReached") });
+        return;
+    }
+    ctx.respondOk(socket, ctx.manager.playLoop(request.payload.id), request.payload.id);
+}
+export function handleTrigger(request, socket, ctx) {
+    if (ctx.manager.isMaxRunsBlocked(request.payload.id)) {
+        send(socket, { type: "error", message: t("errors.maxRunsReached") });
+        return;
+    }
+    if (ctx.manager.isRunning(request.payload.id)) {
+        send(socket, { type: "error", message: t("errors.triggerWhileRunning") });
+        return;
+    }
+    ctx.respondOk(socket, ctx.manager.trigger(request.payload.id), request.payload.id);
+}
+export async function handleDelete(request, socket, ctx) {
+    try {
+        const ok = await ctx.manager.delete(request.payload.id);
+        ctx.respondOk(socket, ok, request.payload.id);
+    }
+    catch (err) {
+        send(socket, { type: "error", message: err instanceof Error ? err.message : String(err) });
+    }
+}

package/dist/daemon/server/handlers/project-handlers.js

@@ -0,0 +1,42 @@
+import { send } from "../../ipc/send.js";
+import { t } from "../../../shared/i18n/index.js";
+export function handleProjectList(_request, socket, ctx) {
+    send(socket, { type: "ok", data: ctx.manager.listProjects() });
+}
+export function handleProjectCreate(request, socket, ctx) {
+    const { name, color, directory, githubSource } = request.payload;
+    if (!name || !name.trim()) {
+        send(socket, { type: "error", message: t("project.error.nameRequired") });
+        return;
+    }
+    try {
+        const project = ctx.manager.createProject(name.trim(), color, directory, githubSource);
+        send(socket, { type: "ok", data: project });
+    }
+    catch (err) {
+        send(socket, { type: "error", message: err instanceof Error ? err.message : String(err) });
+    }
+}
+export function handleProjectUpdate(request, socket, ctx) {
+    const { id, name, color, directory, githubSource } = request.payload;
+    if (!name || !name.trim()) {
+        send(socket, { type: "error", message: t("project.error.nameEmpty") });
+        return;
+    }
+    try {
+        ctx.manager.updateProject(id, name.trim(), color, directory, githubSource);
+        send(socket, { type: "ok" });
+    }
+    catch (err) {
+        send(socket, { type: "error", message: err instanceof Error ? err.message : String(err) });
+    }
+}
+export function handleProjectDelete(request, socket, ctx) {
+    try {
+        ctx.manager.deleteProject(request.payload.id);
+        send(socket, { type: "ok" });
+    }
+    catch (err) {
+        send(socket, { type: "error", message: err instanceof Error ? err.message : String(err) });
+    }
+}

package/dist/daemon/server/handlers/settings-handlers.js

@@ -0,0 +1,8 @@
+import { send } from "../../ipc/send.js";
+export async function handleSettingsGet(_request, socket, settingsManager) {
+    send(socket, { type: "ok", data: settingsManager.get() });
+}
+export async function handleSettingsSet(request, socket, settingsManager) {
+    const updated = settingsManager.set(request.settings);
+    send(socket, { type: "ok", data: updated });
+}

package/dist/daemon/server/handlers/task-handlers.js

@@ -0,0 +1,20 @@
+import { send } from "../../ipc/send.js";
+export function handleTaskCreate(request, socket, ctx) {
+    const task = ctx.taskManager.create(request.payload);
+    send(socket, { type: "ok", data: task });
+}
+export function handleTaskUpdate(request, socket, ctx) {
+    const updated = ctx.taskManager.update(request.payload.id, request.payload);
+    ctx.respondOk(socket, updated !== null, request.payload.id, updated ?? undefined);
+}
+export function handleTaskList(_request, socket, ctx) {
+    send(socket, { type: "ok", data: ctx.taskManager.list() });
+}
+export function handleTaskGet(request, socket, ctx) {
+    const task = ctx.taskManager.get(request.payload.id);
+    ctx.respondOk(socket, task !== null, request.payload.id, task ?? undefined);
+}
+export function handleTaskDelete(request, socket, ctx) {
+    const ok = ctx.taskManager.delete(request.payload.id);
+    ctx.respondOk(socket, ok, request.payload.id);
+}

package/dist/daemon/server/handlers/telemetry-handlers.js

@@ -0,0 +1,5 @@
+import { send } from "../../ipc/send.js";
+export async function handleTelemetryTest(_request, socket, telemetryManager) {
+    const result = await telemetryManager.testConnection();
+    send(socket, { type: "ok", data: result });
+}