loop-task 1.3.0 → 1.4.1

package/dist/daemon/projects.js

@@ -0,0 +1,104 @@
+import fs from "node:fs";
+import { writeFileAtomic } from "../shared/fs-utils.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { daemonLog } from "./daemon-log.js";
+import crypto from "node:crypto";
+export class ProjectManager {
+    projects = new Map();
+    projectsDir;
+    constructor(loopCliHome) {
+        const baseDir = loopCliHome || join(homedir(), ".loop-cli");
+        this.projectsDir = join(baseDir, "projects");
+    }
+    init() {
+        if (!fs.existsSync(this.projectsDir)) {
+            fs.mkdirSync(this.projectsDir, { recursive: true });
+        }
+        this.loadProjects();
+        if (!this.projects.has("default")) {
+            this.createDefaultProject();
+        }
+    }
+    loadProjects() {
+        this.projects.clear();
+        if (!fs.existsSync(this.projectsDir))
+            return;
+        try {
+            const files = fs.readdirSync(this.projectsDir);
+            for (const file of files) {
+                if (!file.endsWith(".json"))
+                    continue;
+                try {
+                    const raw = fs.readFileSync(join(this.projectsDir, file), "utf-8");
+                    const content = JSON.parse(raw);
+                    if (content.id)
+                        this.projects.set(content.id, content);
+                }
+                catch (err) {
+                    daemonLog(`Failed to load project ${file}: ${err}`);
+                }
+            }
+        }
+        catch (err) {
+            daemonLog(`Failed to load projects directory: ${err}`);
+        }
+    }
+    saveProject(project) {
+        const filePath = join(this.projectsDir, `${project.id}.json`);
+        writeFileAtomic(filePath, JSON.stringify(project, null, 2));
+        this.projects.set(project.id, project);
+    }
+    createDefaultProject() {
+        const defaultProject = {
+            id: "default",
+            name: "Default",
+            color: "#ffffff",
+            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) {
+        const id = crypto.randomBytes(4).toString("hex");
+        const project = {
+            id,
+            name,
+            color,
+            createdAt: new Date().toISOString(),
+            isSystem: false,
+            isDefault: false,
+        };
+        this.saveProject(project);
+        return project;
+    }
+    update(id, name, color) {
+        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");
+        project.name = name;
+        if (color)
+            project.color = color;
+        this.saveProject(project);
+    }
+    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");
+        const filePath = join(this.projectsDir, `${id}.json`);
+        if (fs.existsSync(filePath))
+            fs.rmSync(filePath);
+        this.projects.delete(id);
+    }
+}

package/dist/daemon/server.js

@@ -6,14 +6,15 @@ import { LOG_TAIL_DEFAULT } from "../config/constants.js";
 import { send } from "../ipc/send.js";
 import { tail } from "../shared/tail.js";
 import { streamLogFollow } from "../ipc/handlers/logs-stream.js";
-import { splitLogByRuns } from "../core/log-parser.js";
 export class IpcServer {
     server;
     manager;
+    taskManager;
     socketPath;
     clients = new Set();
-    constructor(manager) {
+    constructor(manager, taskManager) {
         this.manager = manager;
+        this.taskManager = taskManager;
         this.socketPath = getSocketPath();
         this.server = net.createServer((socket) => this.handleConnection(socket));
     }
@@ -107,7 +108,27 @@ export class IpcServer {
                 this.respondOk(socket, this.manager.resume(request.payload.id), request.payload.id);
                 break;
             }
+            case "stop-loop": {
+                this.respondOk(socket, this.manager.stopLoop(request.payload.id), request.payload.id);
+                break;
+            }
+            case "play-loop": {
+                if (this.manager.isMaxRunsBlocked(request.payload.id)) {
+                    send(socket, { type: "error", message: t("errors.maxRunsReached") });
+                    break;
+                }
+                this.respondOk(socket, this.manager.playLoop(request.payload.id), request.payload.id);
+                break;
+            }
             case "trigger": {
+                if (this.manager.isMaxRunsBlocked(request.payload.id)) {
+                    send(socket, { type: "error", message: t("errors.maxRunsReached") });
+                    break;
+                }
+                if (this.manager.isRunning(request.payload.id)) {
+                    send(socket, { type: "error", message: t("errors.triggerWhileRunning") });
+                    break;
+                }
                 this.respondOk(socket, this.manager.trigger(request.payload.id), request.payload.id);
                 break;
             }
@@ -120,11 +141,78 @@ export class IpcServer {
                 this.handleRunLog(request, socket);
                 break;
             }
+            case "run-log-stream": {
+                this.handleRunLogStream(request, socket);
+                break;
+            }
             case "attach":
             case "logs": {
                 this.handleLogs(request, socket);
                 break;
             }
+            case "task-create": {
+                const task = this.taskManager.create(request.payload);
+                send(socket, { type: "ok", data: task });
+                break;
+            }
+            case "task-update": {
+                const updated = this.taskManager.update(request.payload.id, request.payload);
+                this.respondOk(socket, updated !== null, request.payload.id, updated ?? undefined);
+                break;
+            }
+            case "task-list": {
+                send(socket, { type: "ok", data: this.taskManager.list() });
+                break;
+            }
+            case "task-get": {
+                const task = this.taskManager.get(request.payload.id);
+                this.respondOk(socket, task !== null, request.payload.id, task ?? undefined);
+                break;
+            }
+            case "task-delete": {
+                const ok = this.taskManager.delete(request.payload.id);
+                this.respondOk(socket, ok, request.payload.id);
+                break;
+            }
+            case "project-list": {
+                send(socket, { type: "ok", data: this.manager.listProjects() });
+                break;
+            }
+            case "project-create": {
+                const { name, color } = request.payload;
+                if (!name || !name.trim()) {
+                    send(socket, { type: "error", message: t("project.error.nameRequired") });
+                    break;
+                }
+                const project = this.manager.createProject(name.trim(), color);
+                send(socket, { type: "ok", data: project });
+                break;
+            }
+            case "project-update": {
+                const { id, name, color } = request.payload;
+                if (!name || !name.trim()) {
+                    send(socket, { type: "error", message: t("project.error.nameEmpty") });
+                    break;
+                }
+                try {
+                    this.manager.updateProject(id, name.trim(), color);
+                    send(socket, { type: "ok" });
+                }
+                catch (err) {
+                    send(socket, { type: "error", message: err instanceof Error ? err.message : String(err) });
+                }
+                break;
+            }
+            case "project-delete": {
+                try {
+                    this.manager.deleteProject(request.payload.id);
+                    send(socket, { type: "ok" });
+                }
+                catch (err) {
+                    send(socket, { type: "error", message: err instanceof Error ? err.message : String(err) });
+                }
+                break;
+            }
             case "shutdown": {
                 send(socket, { type: "ok" });
                 await this.manager.shutdown();
@@ -140,10 +228,93 @@ export class IpcServer {
             send(socket, { type: "ok", data: "" });
             return;
         }
-        const content = fs.readFileSync(logPath, "utf-8");
-        const runs = splitLogByRuns(content);
-        const run = runs.find((r) => r.runNumber === runNumber);
-        send(socket, { type: "ok", data: run ? run.lines.join("\n") : "" });
+        const meta = this.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 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);
+        });
+        send(socket, { type: "ok", data: parts.join("") });
+    }
+    handleRunLogStream(request, socket) {
+        const { id, runNumber } = request.payload;
+        const meta = this.manager.status(id);
+        if (!meta) {
+            send(socket, { type: "error", message: t("errors.loopNotFound", { id }) });
+            return;
+        }
+        const record = meta.runHistory.find((r) => r.runNumber === runNumber);
+        if (!record) {
+            send(socket, { type: "ok", data: "" });
+            return;
+        }
+        const logPath = this.manager.getLogPath(id);
+        if (!logPath || !fs.existsSync(logPath)) {
+            send(socket, { type: "ok", data: "" });
+            return;
+        }
+        const offset = record.logOffset;
+        const stat = fs.statSync(logPath);
+        if (stat.size > offset) {
+            const fd = fs.openSync(logPath, "r");
+            const buf = Buffer.alloc(stat.size - offset);
+            fs.readSync(fd, buf, 0, buf.length, offset);
+            fs.closeSync(fd);
+            for (const line of buf.toString().split("\n")) {
+                if (line) {
+                    send(socket, { type: "data", line });
+                }
+            }
+        }
+        if (record.status === "completed") {
+            send(socket, { type: "end" });
+            return;
+        }
+        let fileSize = stat.size;
+        const watcher = fs.watch(logPath, (eventType) => {
+            if (eventType === "rename" && !fs.existsSync(logPath)) {
+                watcher.close();
+                send(socket, { type: "end" });
+                return;
+            }
+            if (eventType === "change") {
+                try {
+                    const s = fs.statSync(logPath);
+                    if (s.size > fileSize) {
+                        const fd = fs.openSync(logPath, "r");
+                        const buf = Buffer.alloc(s.size - fileSize);
+                        fs.readSync(fd, buf, 0, buf.length, fileSize);
+                        fs.closeSync(fd);
+                        fileSize = s.size;
+                        for (const line of buf.toString().split("\n")) {
+                            if (line) {
+                                send(socket, { type: "data", line });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    watcher.close();
+                    send(socket, { type: "end" });
+                }
+            }
+        });
+        socket.on("close", () => watcher.close());
+        socket.on("error", () => watcher.close());
     }
     handleLogs(request, socket) {
         const id = request.payload.id;

package/dist/daemon/state.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import crypto from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { removeIfExists, writeFileAtomic } from "../shared/fs-utils.js";
-import { getLoopsDir, getLogsDir, loopFile, logFile, getPidFile, getSignatureFile, getSocketPath, } from "../config/paths.js";
+import { getLoopsDir, getTasksDir, getLogsDir, loopFile, taskFile, logFile, getPidFile, getSignatureFile, getSocketPath, } from "../config/paths.js";
 export { getDataDir, getPidFile, getSocketPath } from "../config/paths.js";
 function ensureDirs() {
     fs.mkdirSync(getLoopsDir(), { recursive: true });
@@ -40,6 +40,37 @@ export function deleteLoop(id) {
     removeIfExists(loopFile(id));
     removeIfExists(logFile(id));
 }
+export function saveTask(task) {
+    const dir = getTasksDir();
+    fs.mkdirSync(dir, { recursive: true });
+    writeFileAtomic(taskFile(task.id), JSON.stringify(task, null, 2));
+}
+export function loadTask(id) {
+    const file = taskFile(id);
+    if (!fs.existsSync(file))
+        return null;
+    const raw = fs.readFileSync(file, "utf-8");
+    return JSON.parse(raw);
+}
+export function loadAllTasks() {
+    const dir = getTasksDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const files = fs.readdirSync(dir).filter((f) => f.endsWith(".json"));
+    const tasks = [];
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), "utf-8");
+            tasks.push(JSON.parse(raw));
+        }
+        catch {
+            // skip corrupted files
+        }
+    }
+    return tasks.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+export function deleteTask(id) {
+    removeIfExists(taskFile(id));
+}
 export function getLogPath(id) {
     ensureDirs();
     return logFile(id);

package/dist/daemon/task-manager.js

@@ -0,0 +1,58 @@
+import crypto from "node:crypto";
+import { saveTask, loadAllTasks, deleteTask as deleteTaskState } from "./state.js";
+import { daemonLog } from "./daemon-log.js";
+export class TaskManager {
+    tasks = new Map();
+    init() {
+        const saved = loadAllTasks();
+        for (const task of saved) {
+            this.tasks.set(task.id, task);
+        }
+        if (saved.length > 0) {
+            daemonLog(`loaded ${saved.length} task(s) from persisted state`);
+        }
+    }
+    create(input) {
+        const task = {
+            ...input,
+            createdAt: new Date().toISOString(),
+        };
+        this.tasks.set(task.id, task);
+        saveTask(task);
+        return task;
+    }
+    get(id) {
+        return this.tasks.get(id) ?? null;
+    }
+    list() {
+        return [...this.tasks.values()];
+    }
+    update(id, input) {
+        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.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,
+        });
+    }
+}