loop-task 2.1.4 → 2.1.5

package/dist/daemon/{manager.js → managers/loop-manager.js}

@@ -1,23 +1,28 @@
 import crypto from "node:crypto";
-import { LoopController } from "../core/loop-controller.js";
-import { ProjectManager } from "./projects.js";
-import { saveLoop, loadAllLoops, deleteLoop as deleteLoopState, getLogPath, } from "./state.js";
-import { daemonLog } from "./daemon-log.js";
+import { LoopController } from "../../core/loop/loop-controller.js";
+import { ProjectManager } from "./project-manager.js";
+import { saveLoop, loadAllLoops, deleteLoop as deleteLoopState, getLogPath, } from "../state/index.js";
+import { daemonLog } from "../daemon-log.js";
+import { createLoopEntry, metaToState } from "./loop-entry.js";
+import { wireEvents, persistLoop, buildMeta } from "./loop-serialization.js";
 export class LoopManager {
-    loops = new Map();
-    lastSerialized = new Map();
-    taskManager;
-    projectManager;
     constructor(taskManager, projectManager) {
+        this.loops = new Map();
+        this.lastSerialized = new Map();
+        this.taskResolver = (taskId) => this.taskManager.get(taskId);
         this.taskManager = taskManager;
         this.projectManager = projectManager || new ProjectManager();
     }
-    taskResolver = (taskId) => this.taskManager.get(taskId);
     getProjectDirectory(projectId) {
         return this.projectManager.get(projectId)?.directory;
     }
+    persist(id, controller, options, intervalHuman) {
+        persistLoop(id, controller, options, intervalHuman, this.taskManager, this.lastSerialized);
+    }
+    wireUp(id, entry) {
+        wireEvents(id, entry.controller, entry.options, entry.intervalHuman, () => this.persist(id, entry.controller, entry.options, entry.intervalHuman));
+    }
     init() {
-        // Initialize projects first
         this.projectManager.init();
         const saved = loadAllLoops();
         let restarted = 0;
@@ -27,42 +32,11 @@ export class LoopManager {
                 meta.projectId = "default";
                 saveLoop(meta);
             }
-            const options = {
-                interval: meta.interval,
-                taskId: meta.taskId,
-                command: meta.command,
-                commandArgs: meta.commandArgs,
-                commandRaw: meta.commandRaw,
-                cwd: meta.cwd ?? "",
-                immediate: false,
-                maxRuns: meta.maxRuns,
-                verbose: meta.verbose,
-                description: meta.description ?? "",
-                projectId: meta.projectId ?? "default",
-                offset: meta.offset ?? null,
-            };
-            const logPath = getLogPath(meta.id);
-            const projectDir = this.getProjectDirectory(options.projectId ?? "default");
-            const controller = new LoopController(meta.id, options, logPath, this.taskResolver, {
-                status: meta.status,
-                createdAt: meta.createdAt,
-                runCount: meta.runCount,
-                sessionStartedAt: meta.sessionStartedAt,
-                lastRunAt: meta.lastRunAt,
-                lastExitCode: meta.lastExitCode,
-                lastDuration: meta.lastDuration,
-                nextRunAt: meta.nextRunAt,
-                remainingDelayMs: meta.remainingDelayMs,
-                runHistory: meta.runHistory,
-            }, projectDir);
-            this.loops.set(meta.id, {
-                controller,
-                options,
-                intervalHuman: meta.intervalHuman,
-            });
-            this.wireEvents(meta.id, controller, options, meta.intervalHuman);
+            const entry = createLoopEntry(meta, this.taskResolver, this.getProjectDirectory.bind(this), metaToState(meta));
+            this.loops.set(meta.id, entry);
+            this.wireUp(meta.id, entry);
             if (shouldAutoStart(meta.status)) {
-                controller.start();
+                entry.controller.start();
                 restarted += 1;
             }
         }
@@ -75,9 +49,10 @@ export class LoopManager {
         const logPath = getLogPath(id);
         const projectDir = this.getProjectDirectory(options.projectId ?? "default");
         const controller = new LoopController(id, options, logPath, this.taskResolver, undefined, projectDir);
-        this.loops.set(id, { controller, options, intervalHuman });
+        const entry = { controller, options, intervalHuman };
+        this.loops.set(id, entry);
         controller.start();
-        this.wireEvents(id, controller, options, intervalHuman);
+        this.wireUp(id, entry);
         this.persist(id, controller, options, intervalHuman);
         return id;
     }
@@ -110,7 +85,7 @@ export class LoopManager {
     list() {
         const result = [];
         for (const [id, entry] of this.loops) {
-            result.push(this.buildMeta(id, entry));
+            result.push(buildMeta(id, entry, this.taskManager));
         }
         return result;
     }
@@ -136,7 +111,7 @@ export class LoopManager {
         const entry = this.loops.get(id);
         if (!entry)
             return null;
-        return this.buildMeta(id, entry);
+        return buildMeta(id, entry, this.taskManager);
     }
     pause(id) {
         const entry = this.loops.get(id);
@@ -242,118 +217,23 @@ export class LoopManager {
                     existing.options.cwd !== (meta.cwd ?? "");
                 if (configChanged) {
                     void existing.controller.stop().then(() => {
-                        const options = {
-                            interval: meta.interval,
-                            taskId: meta.taskId ?? null,
-                            command: meta.command,
-                            commandArgs: meta.commandArgs,
-                            cwd: meta.cwd ?? "",
-                            immediate: false,
-                            maxRuns: meta.maxRuns,
-                            verbose: meta.verbose,
-                            description: meta.description ?? "",
-                            projectId: meta.projectId ?? "default",
-                            offset: meta.offset ?? null,
-                        };
-                        const logPath = getLogPath(meta.id);
-                        const projectDir = this.getProjectDirectory(options.projectId ?? "default");
-                        const controller = new LoopController(meta.id, options, logPath, this.taskResolver, {
-                            status: meta.status,
-                            createdAt: meta.createdAt,
-                            runCount: meta.runCount,
-                            sessionStartedAt: meta.sessionStartedAt,
-                            lastRunAt: meta.lastRunAt,
-                            lastExitCode: meta.lastExitCode,
-                            lastDuration: meta.lastDuration,
-                            nextRunAt: meta.nextRunAt,
-                            remainingDelayMs: meta.remainingDelayMs,
-                            runHistory: meta.runHistory,
-                        }, projectDir);
-                        this.loops.set(meta.id, { controller, options, intervalHuman: meta.intervalHuman });
-                        this.wireEvents(meta.id, controller, options, meta.intervalHuman);
+                        const entry = createLoopEntry(meta, this.taskResolver, this.getProjectDirectory.bind(this), metaToState(meta));
+                        this.loops.set(meta.id, entry);
+                        this.wireUp(meta.id, entry);
                         if (shouldAutoStart(meta.status)) {
-                            controller.start();
+                            entry.controller.start();
                         }
                     });
                 }
             }
             else {
-                const options = {
-                    interval: meta.interval,
-                    taskId: meta.taskId ?? null,
-                    command: meta.command,
-                    commandArgs: meta.commandArgs,
-                    cwd: meta.cwd ?? "",
-                    immediate: false,
-                    maxRuns: meta.maxRuns,
-                    verbose: meta.verbose,
-                    description: meta.description ?? "",
-                    projectId: meta.projectId ?? "default",
-                    offset: meta.offset ?? null,
-                };
-                const logPath = getLogPath(meta.id);
-                const projectDir = this.getProjectDirectory(options.projectId ?? "default");
-                const controller = new LoopController(meta.id, options, logPath, this.taskResolver, {
-                    status: meta.status,
-                    createdAt: meta.createdAt,
-                    runCount: meta.runCount,
-                    sessionStartedAt: meta.sessionStartedAt,
-                    lastRunAt: meta.lastRunAt,
-                    lastExitCode: meta.lastExitCode,
-                    lastDuration: meta.lastDuration,
-                    nextRunAt: meta.nextRunAt,
-                    remainingDelayMs: meta.remainingDelayMs,
-                    runHistory: meta.runHistory,
-                }, projectDir);
-                this.loops.set(meta.id, { controller, options, intervalHuman: meta.intervalHuman });
-                this.wireEvents(meta.id, controller, options, meta.intervalHuman);
+                const entry = createLoopEntry(meta, this.taskResolver, this.getProjectDirectory.bind(this), metaToState(meta));
+                this.loops.set(meta.id, entry);
+                this.wireUp(meta.id, entry);
                 if (shouldAutoStart(meta.status)) {
-                    controller.start();
+                    entry.controller.start();
                 }
             }
         }
     }
-    wireEvents(id, controller, options, intervalHuman) {
-        const persist = () => this.persist(id, controller, options, intervalHuman);
-        controller.on("run:start", persist);
-        controller.on("run:end", persist);
-        controller.on("paused", persist);
-        controller.on("resumed", persist);
-        controller.on("triggered", persist);
-        controller.on("waiting", persist);
-        controller.on("stopped", persist);
-    }
-    persist(id, controller, options, intervalHuman) {
-        const meta = this.toMeta(controller, options, intervalHuman);
-        const serialized = JSON.stringify(meta);
-        if (this.lastSerialized.get(id) === serialized) {
-            return;
-        }
-        this.lastSerialized.set(id, serialized);
-        saveLoop(meta);
-    }
-    buildMeta(id, entry) {
-        return this.toMeta(entry.controller, entry.options, entry.intervalHuman);
-    }
-    toMeta(controller, options, intervalHuman) {
-        const runtime = controller.getMeta();
-        const task = options.taskId ? this.taskManager.get(options.taskId) : null;
-        return {
-            ...runtime,
-            command: task?.command ?? options.command,
-            commandArgs: task?.commandArgs ?? options.commandArgs,
-            commandRaw: options.commandRaw,
-            cwd: options.cwd || "",
-            interval: options.interval,
-            intervalHuman,
-            immediate: options.immediate,
-            maxRuns: options.maxRuns,
-            verbose: options.verbose,
-            description: options.description,
-            remainingDelayMs: runtime.remainingDelayMs,
-            pid: process.pid,
-            projectId: options.projectId ?? "default",
-            offset: options.offset,
-        };
-    }
 }

package/dist/daemon/managers/loop-options.js

@@ -0,0 +1,16 @@
+export function buildLoopOptions(meta) {
+    return {
+        interval: meta.interval,
+        taskId: meta.taskId ?? null,
+        command: meta.command,
+        commandArgs: meta.commandArgs,
+        commandRaw: meta.commandRaw,
+        cwd: meta.cwd ?? "",
+        immediate: false,
+        maxRuns: meta.maxRuns,
+        verbose: meta.verbose,
+        description: meta.description ?? "",
+        projectId: meta.projectId ?? "default",
+        offset: meta.offset ?? null,
+    };
+}

package/dist/daemon/managers/loop-serialization.js

@@ -0,0 +1,43 @@
+import { saveLoop } from "../state/index.js";
+export function wireEvents(id, controller, options, intervalHuman, persist) {
+    controller.on("run:start", persist);
+    controller.on("run:end", persist);
+    controller.on("paused", persist);
+    controller.on("resumed", persist);
+    controller.on("triggered", persist);
+    controller.on("waiting", persist);
+    controller.on("stopped", persist);
+}
+export function toMeta(controller, options, intervalHuman, taskManager) {
+    const runtime = controller.getMeta();
+    const task = options.taskId ? taskManager.get(options.taskId) : null;
+    return {
+        ...runtime,
+        command: task?.command ?? options.command,
+        commandArgs: task?.commandArgs ?? options.commandArgs,
+        commandRaw: options.commandRaw,
+        cwd: options.cwd || "",
+        interval: options.interval,
+        intervalHuman,
+        immediate: options.immediate,
+        maxRuns: options.maxRuns,
+        verbose: options.verbose,
+        description: options.description,
+        remainingDelayMs: runtime.remainingDelayMs,
+        pid: process.pid,
+        projectId: options.projectId ?? "default",
+        offset: options.offset,
+    };
+}
+export function persistLoop(id, controller, options, intervalHuman, taskManager, lastSerialized) {
+    const meta = toMeta(controller, options, intervalHuman, taskManager);
+    const serialized = JSON.stringify(meta);
+    if (lastSerialized.get(id) === serialized) {
+        return;
+    }
+    lastSerialized.set(id, serialized);
+    saveLoop(meta);
+}
+export function buildMeta(id, entry, taskManager) {
+    return toMeta(entry.controller, entry.options, entry.intervalHuman, taskManager);
+}

package/dist/daemon/{projects.js → managers/project-manager.js}

@@ -1,11 +1,13 @@
 import fs from "node:fs";
-import { writeFileAtomic } from "../shared/fs-utils.js";
-import { daemonLog } from "./daemon-log.js";
+import { writeFileAtomic } from "../../shared/fs-utils.js";
+import { daemonLog } from "../daemon-log.js";
 import crypto from "node:crypto";
-import { getDataDir, projectsJson } from "../config/paths.js";
+import { getDataDir, projectsJson } from "../../shared/config/paths.js";
 import path from "node:path";
 export class ProjectManager {
-    projects = new Map();
+    constructor() {
+        this.projects = new Map();
+    }
     init() {
         const dataDir = getDataDir();
         fs.mkdirSync(dataDir, { recursive: true });

package/dist/daemon/{task-manager.js → managers/task-manager.js}

@@ -1,8 +1,10 @@
 import crypto from "node:crypto";
-import { saveTask, loadAllTasks, deleteTask as deleteTaskState } from "./state.js";
-import { daemonLog } from "./daemon-log.js";
+import { saveTask, loadAllTasks, deleteTask as deleteTaskState } from "../state/index.js";
+import { daemonLog } from "../daemon-log.js";
 export class TaskManager {
-    tasks = new Map();
+    constructor() {
+        this.tasks = new Map();
+    }
     init() {
         const saved = loadAllTasks();
         for (const task of saved) {

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

@@ -0,0 +1,86 @@
+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";
+export { handleStart, handleUpdate, handleList, handleStatus, handlePause, handleResume, handleStopLoop, handleStopAll, handlePlayLoop, handleTrigger, handleDelete, handleRunLog, handleRunLogStream, handleLogs, handleTaskCreate, handleTaskUpdate, handleTaskList, handleTaskGet, handleTaskDelete, handleProjectList, handleProjectCreate, handleProjectUpdate, handleProjectDelete, };
+/**
+ * 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":
+            handleStopLoop(request, socket, ctx);
+            break;
+        case "stop-all":
+            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;
+        default:
+            return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,130 @@
+import fs from "node:fs";
+import { send } from "../../ipc/send.js";
+import { t } from "../../../shared/i18n/index.js";
+import { LOG_TAIL_DEFAULT } from "../../../shared/config/constants.js";
+import { tail } from "../../../shared/tail.js";
+import { streamLogFollow } from "../../ipc/logs-stream.js";
+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 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("") });
+}
+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 fd = fs.openSync(logPath, "r");
+        const buf = Buffer.alloc(stat.size - firstOffset);
+        fs.readSync(fd, buf, 0, buf.length, firstOffset);
+        fs.closeSync(fd);
+        for (const line of buf.toString().split("\n")) {
+            if (line) {
+                send(socket, { type: "data", line });
+            }
+        }
+    }
+    const allCompleted = records.every((r) => r.status === "completed");
+    if (allCompleted) {
+        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());
+}
+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) {
+        streamLogFollow(logPath, socket, tailCount);
+    }
+    else {
+        const content = fs.readFileSync(logPath, "utf-8");
+        send(socket, { type: "ok", data: tail(content, tailCount).join("\n") });
+    }
+}

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

@@ -0,0 +1,54 @@
+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;
+    const ok = await ctx.manager.update(id, options, intervalHuman);
+    ctx.respondOk(socket, ok, id, ok ? { id } : undefined);
+}
+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 function handleStopLoop(request, socket, ctx) {
+    ctx.respondOk(socket, ctx.manager.stopLoop(request.payload.id), request.payload.id);
+}
+export function handleStopAll(_request, socket, ctx) {
+    const count = 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) {
+    const ok = await ctx.manager.delete(request.payload.id);
+    ctx.respondOk(socket, ok, request.payload.id);
+}

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

@@ -0,0 +1,37 @@
+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 } = request.payload;
+    if (!name || !name.trim()) {
+        send(socket, { type: "error", message: t("project.error.nameRequired") });
+        return;
+    }
+    const project = ctx.manager.createProject(name.trim(), color, directory);
+    send(socket, { type: "ok", data: project });
+}
+export function handleProjectUpdate(request, socket, ctx) {
+    const { id, name, color, directory } = 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);
+        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/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);
+}