loop-task 2.1.11 → 2.1.13

package/dist/daemon/mcp/server.js

@@ -0,0 +1,162 @@
+import http from "node:http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { daemonLog } from "../daemon-log.js";
+import { registerMcpTools } from "./tools.js";
+const MCP_DEFAULT_PORT = 8846;
+export class McpApiServer {
+    constructor(manager, taskManager, projectManager, transport) {
+        this.manager = manager;
+        this.taskManager = taskManager;
+        this.projectManager = projectManager;
+        this.mcpServer = null;
+        this.activeTransport = null;
+        this.httpServer = null;
+        this._isListening = false;
+        this.transportType = transport ?? "sse";
+    }
+    createServer() {
+        const server = new McpServer({ name: "loop-task", version: "1.0.0" }, { capabilities: { tools: {} } });
+        registerMcpTools(server, { manager: this.manager, taskManager: this.taskManager, projectManager: this.projectManager });
+        return server;
+    }
+    get isListening() {
+        return this._isListening;
+    }
+    async start() {
+        if (this._isListening)
+            return;
+        try {
+            if (this.transportType === "stdio") {
+                await this.startStdio();
+            }
+            else {
+                await this.startSse();
+            }
+        }
+        catch (err) {
+            daemonLog(`MCP server failed to start: ${String(err)}`);
+        }
+    }
+    async close() {
+        if (!this._isListening)
+            return;
+        this._isListening = false;
+        if (this.mcpServer) {
+            try {
+                await this.mcpServer.close();
+            }
+            catch {
+                // ignore close errors
+            }
+            this.mcpServer = null;
+        }
+        if (this.httpServer) {
+            await new Promise((resolve) => {
+                this.httpServer.close(() => resolve());
+                this.httpServer.closeAllConnections?.();
+            });
+            this.httpServer = null;
+        }
+        this.activeTransport = null;
+        daemonLog("MCP server stopped");
+    }
+    async startStdio() {
+        if (!process.stdin || !process.stdout) {
+            daemonLog("MCP stdio transport: stdin/stdout not available, skipping");
+            return;
+        }
+        const server = this.createServer();
+        const transport = new StdioServerTransport();
+        this.mcpServer = server;
+        this.activeTransport = transport;
+        await server.connect(transport);
+        this._isListening = true;
+        daemonLog("MCP server listening on stdio");
+        transport.onclose = () => {
+            this._isListening = false;
+            daemonLog("MCP stdio transport closed");
+        };
+    }
+    async startSse() {
+        const port = parseInt(process.env.LOOP_CLI_MCP_PORT ?? "", 10) || MCP_DEFAULT_PORT;
+        // Map session ID → transport for POST routing
+        const sessions = new Map();
+        this.httpServer = http.createServer(async (req, res) => {
+            try {
+                const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+                if (req.method === "GET" && url.pathname === "/sse") {
+                    // Create a fresh McpServer per SSE connection — the SDK only allows
+                    // one transport per McpServer instance, so reusing one would cause
+                    // "Already connected to a transport" errors on reconnect.
+                    const server = this.createServer();
+                    const transport = new SSEServerTransport("/message", res);
+                    sessions.set(transport.sessionId, transport);
+                    await server.connect(transport);
+                    if (!this.mcpServer)
+                        this.mcpServer = server;
+                    this._isListening = true;
+                    daemonLog(`MCP SSE client connected (session: ${transport.sessionId})`);
+                    transport.onclose = () => {
+                        sessions.delete(transport.sessionId);
+                        daemonLog(`MCP SSE client disconnected (session: ${transport.sessionId})`);
+                    };
+                }
+                else if (req.method === "POST" && url.pathname === "/message") {
+                    const body = await this.readBody(req);
+                    // Route the POST to the correct transport by session ID
+                    const sessionId = url.searchParams.get("sessionId");
+                    const transport = sessionId ? sessions.get(sessionId) : sessions.values().next().value;
+                    if (transport) {
+                        await transport.handlePostMessage(req, res, body);
+                    }
+                    else {
+                        res.writeHead(400).end("No active SSE connection");
+                    }
+                }
+                else {
+                    res.writeHead(404).end("Not found");
+                }
+            }
+            catch (err) {
+                daemonLog(`MCP SSE request error: ${String(err)}`);
+                if (!res.headersSent) {
+                    res.writeHead(500).end("Internal error");
+                }
+            }
+        });
+        return new Promise((resolve) => {
+            this.httpServer.on("error", (err) => {
+                if (err.code === "EADDRINUSE") {
+                    daemonLog(`MCP SSE server: port ${port} already in use, skipping SSE transport`);
+                }
+                else {
+                    daemonLog(`MCP SSE server error: ${String(err)}`);
+                }
+                resolve();
+            });
+            this.httpServer.listen(port, "127.0.0.1", () => {
+                daemonLog(`MCP SSE server listening on 127.0.0.1:${port}`);
+                this._isListening = true;
+                resolve();
+            });
+        });
+    }
+    readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on("data", (chunk) => chunks.push(chunk));
+            req.on("end", () => {
+                try {
+                    const raw = Buffer.concat(chunks).toString("utf-8");
+                    resolve(raw ? JSON.parse(raw) : {});
+                }
+                catch {
+                    resolve({});
+                }
+            });
+            req.on("error", reject);
+        });
+    }
+}

package/dist/daemon/mcp/tools.js

@@ -0,0 +1,368 @@
+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) => {
+        const deleted = await manager.delete(args.id);
+        if (!deleted)
+            return err(`Loop not found: ${args.id}`);
+        return ok();
+    });
+    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"),
+            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,
+                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"),
+            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,
+                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) => {
+        if (!taskManager.delete(args.id))
+            return err(`Task not found: ${args.id}`);
+        return ok();
+    });
+    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/server/handlers/index.js

@@ -2,7 +2,8 @@ import { handleStart, handleUpdate, handleList, handleStatus, handlePause, handl
 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, };
+import { handleSettingsGet, handleSettingsSet, } from "./settings-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, };
 /**
  * Dispatch an incoming IPC request to the appropriate handler.
  * Returns true if the request was handled, false otherwise.
@@ -79,6 +80,12 @@ export async function dispatch(request, socket, ctx) {
         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;
         default:
             return false;
     }

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

@@ -4,22 +4,27 @@ 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;
+    const { name, color, directory, githubSource } = 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 });
+    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 } = request.payload;
+    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);
+        ctx.manager.updateProject(id, name.trim(), color, directory, githubSource);
         send(socket, { type: "ok" });
     }
     catch (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/index.js

@@ -4,11 +4,12 @@ import { t } from "../../shared/i18n/index.js";
 import { send } from "../ipc/send.js";
 import { dispatch } from "./handlers/index.js";
 export class IpcServer {
-    constructor(manager, taskManager) {
+    constructor(manager, taskManager, settingsManager) {
         this.clients = new Set();
         this.subscribers = new Set();
         this.manager = manager;
         this.taskManager = taskManager;
+        this.settingsManager = settingsManager;
         this.socketPath = getSocketPath();
         this.server = net.createServer((socket) => this.handleConnection(socket));
     }
@@ -91,6 +92,7 @@ export class IpcServer {
         const handled = await dispatch(request, socket, {
             manager: this.manager,
             taskManager: this.taskManager,
+            settingsManager: this.settingsManager,
             respondOk: (s, ok, id, data) => this.respondOk(s, ok, id, data),
         });
         if (!handled) {

package/dist/daemon/settings-manager.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import { settingsJson } from "../shared/config/paths.js";
+import { daemonLog } from "./daemon-log.js";
+const DEFAULTS = { httpApiEnabled: true, mcpApiEnabled: true };
+export class SettingsManager {
+    constructor() {
+        this.settings = { ...DEFAULTS };
+        this.listeners = [];
+    }
+    load() {
+        try {
+            const raw = fs.readFileSync(settingsJson(), "utf-8");
+            const parsed = JSON.parse(raw);
+            if (typeof parsed === "object" && parsed !== null) {
+                this.settings = { ...DEFAULTS, ...parsed };
+            }
+        }
+        catch {
+            this.settings = { ...DEFAULTS };
+        }
+    }
+    save() {
+        const tmp = settingsJson() + ".tmp";
+        fs.writeFileSync(tmp, JSON.stringify(this.settings, null, 2));
+        fs.renameSync(tmp, settingsJson());
+    }
+    get() {
+        return { ...this.settings };
+    }
+    set(partial) {
+        this.settings = { ...this.settings, ...partial };
+        this.save();
+        for (const cb of this.listeners) {
+            try {
+                cb(this.get());
+            }
+            catch (err) {
+                daemonLog(`settings onChange error: ${String(err)}`);
+            }
+        }
+        return this.get();
+    }
+    onChange(callback) {
+        this.listeners.push(callback);
+    }
+}