loop-task 2.1.12 → 2.1.13

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);
+    }
+}

package/dist/entities/tasks/filters.js

@@ -23,7 +23,7 @@ function compare(left, right, sort) {
             return byCmd;
         return left.name.localeCompare(right.name, undefined, { sensitivity: "base" });
     }
-    // "created" — newest first
+    // "created"  newest first
     return right.createdAt.localeCompare(left.createdAt);
 }
 export function applyTaskFilters(tasks, filters) {

package/dist/features/commands/commands.js

@@ -4,7 +4,10 @@ function globalCommands() {
     return [
         { label: t('cmd.help'), value: 'help', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+p' },
         { label: t('cmd.debug'), value: 'debug', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+b' },
-        { label: t('cmd.api'), value: 'api', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+g' },
+        { label: t('cmd.api'), value: 'api', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.toggleApi'), value: 'toggle-api', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.mcp'), value: 'mcp', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
+        { label: t('cmd.toggleMcp'), value: 'toggle-mcp', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL },
         { label: t('cmd.export'), value: 'export', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+x' },
         { label: t('cmd.import'), value: 'import', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+i' },
         { label: t('cmd.status'), value: 'status', hint: '', tier: COMMAND_TIER_GLOBAL, category: COMMAND_CATEGORY_GLOBAL, shortcut: 'ctrl+y' },

package/dist/features/commands/useCommandHandlers.js

@@ -2,6 +2,8 @@ import { t } from "../../shared/i18n/index.js";
 import { cycleSortMode, cycleStatusFilter } from "../../entities/loops/filters.js";
 import { cycleProjectSortMode, cycleProjectHasLoopsFilter, cycleProjectIsSystemFilter } from "../../entities/projects/filters.js";
 import { groupRunsByCycle } from "../../widgets/right-panel/RunHistory.js";
+import { container } from "../../shared/container/index.js";
+import { TYPES } from "../../shared/services/types.js";
 export function useCommandHandlers(context) {
     const { activeTab, selected, selectedRunIndex, selectedTask, selectedProjectEntity, tasks, projects, currentProjectId, setCloneMode, setEditTarget, setPendingTaskSelection, setEditTask, setEditProject, setActiveTab, setConfirmState, setCommandsBrowserOpen, setSearchValue, setSearchState, setFilters, setSort, setCurrentProjectId, setProjectFilters, setProjectSelectedIndex, setDebugMode, setExportModal, push, pop, refresh, refreshTasks, refreshProjects, pushToast, loopService, taskService, projectService, exportService, runAction, handleOpenRunLog, } = context;
     const commandHandlers = {
@@ -128,6 +130,36 @@ export function useCommandHandlers(context) {
             const baseUrl = `http://127.0.0.1:${port}`;
             pushToast("info", `API: ${baseUrl} | Swagger: ${baseUrl}/api/docs | OpenAPI: ${baseUrl}/api/openapi.json`);
         },
+        "toggle-api": async () => {
+            try {
+                const settingsService = container.get(TYPES.SettingsService);
+                const current = await settingsService.getHttpApiEnabled();
+                await settingsService.setHttpApiEnabled(!current);
+                pushToast("success", t(!current ? "board.toastApiEnabled" : "board.toastApiDisabled"));
+            }
+            catch (e) {
+                pushToast("error", t("board.toastApiToggleError", { message: e.message }));
+            }
+        },
+        mcp: () => {
+            const transport = process.env.LOOP_CLI_MCP_TRANSPORT ?? "sse";
+            const port = process.env.LOOP_CLI_MCP_PORT ?? "8846";
+            const info = transport === "stdio"
+                ? `MCP server on stdio. To use SSE (default), restart without LOOP_CLI_MCP_TRANSPORT=stdio`
+                : `MCP: connect your client to http://127.0.0.1:${port}/sse`;
+            pushToast("info", info);
+        },
+        "toggle-mcp": async () => {
+            try {
+                const settingsService = container.get(TYPES.SettingsService);
+                const current = await settingsService.getMcpApiEnabled();
+                await settingsService.setMcpApiEnabled(!current);
+                pushToast("success", t(!current ? "board.toastMcpEnabled" : "board.toastMcpDisabled"));
+            }
+            catch (e) {
+                pushToast("error", t("board.toastMcpToggleError", { message: e.message }));
+            }
+        },
         status: () => { pushToast("info", `Command "status" coming soon`); },
         export: () => {
             exportService.exportConfig()

package/dist/features/commands/useGlobalShortcuts.js

@@ -46,7 +46,6 @@ export function useGlobalShortcuts(context) {
             const globalShortcuts = {
                 p: () => { setCommandsBrowserOpen(true); },
                 b: () => handleCommand("debug"),
-                g: () => handleCommand("api"),
                 x: () => handleCommand("export"),
                 i: () => handleCommand("import"),
                 y: () => handleCommand("status"),

package/dist/features/overlays/ExportModal.js

@@ -15,7 +15,7 @@ export function ExportModal(props) {
     const [scrollOffset, setScrollOffset] = useState(0);
     useInput((input, key) => {
         // Bracketed paste: content wrapped in ESC[200~ ... ESC[201~. Must come
-        // before the escape check — the leading ESC trips key.escape and would
+        // before the escape check  the leading ESC trips key.escape and would
         // close the modal on a right-click paste.
         if (input.includes("\x1b[200~")) {
             return;

package/dist/loop-config.js

@@ -96,7 +96,7 @@ export function joinCommandLines(text) {
     // - Segment ending with \: backslash consumed, joins to next with NO added space
     // - Segment NOT ending with \: joins to next with a single space
     // Leading whitespace on each line is trimmed (indentation); trailing whitespace
-    // before \ is preserved (it's part of the content — e.g. separates tokens).
+    // before \ is preserved (it's part of the content  e.g. separates tokens).
     let result = "";
     let prevContinued = false; // true if previous segment ended with \
     for (const seg of segments) {

package/dist/shared/clipboard.js

@@ -1,7 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { platform } from "node:os";
 /**
- * Write text to the system clipboard. Never throws — returns false if no
+ * Write text to the system clipboard. Never throws  returns false if no
  * clipboard tool is available (e.g. a headless SSH box without xclip/xsel).
  *
  * Linux toolchain tried in order: xclip → xsel → wl-copy (Wayland) →
@@ -28,7 +28,7 @@ export function copyToClipboard(text) {
             return false;
         }
     }
-    // Linux / BSD: try each clipboard tool in order. All calls are guarded —
+    // Linux / BSD: try each clipboard tool in order. All calls are guarded 
     // a missing binary must never throw, since callers invoke this from
     // synchronous keypress handlers (an uncaught throw here kills the app).
     const tries = [

package/dist/shared/config/paths.js

@@ -30,6 +30,9 @@ export function tasksJson() {
 export function projectsJson() {
     return path.join(getDataDir(), "projects.json");
 }
+export function settingsJson() {
+    return path.join(getDataDir(), "settings.json");
+}
 export function logFile(id) {
     return path.join(getLogsDir(), `${id}.log`);
 }

package/dist/shared/container/index.js

@@ -5,12 +5,14 @@ import { IpcTaskService } from "../services/task-service.js";
 import { IpcProjectService } from "../services/project-service.js";
 import { IpcLogService } from "../services/log-service.js";
 import { IpcExportService } from "../services/export-service.js";
+import { IpcSettingsService } from "../services/settings-service.js";
 export function createContainer() {
     const container = new Container();
     container.bind(TYPES.LoopService).to(IpcLoopService);
     container.bind(TYPES.TaskService).to(IpcTaskService);
     container.bind(TYPES.ProjectService).to(IpcProjectService);
     container.bind(TYPES.LogService).to(IpcLogService);
+    container.bind(TYPES.SettingsService).to(IpcSettingsService);
     container.bind(TYPES.ExportService).toDynamicValue(() => {
         const loopService = container.get(TYPES.LoopService);
         const taskService = container.get(TYPES.TaskService);