loop-task 2.1.4 → 2.1.5

package/dist/daemon/server/index.js

@@ -0,0 +1,113 @@
+import net from "node:net";
+import { getSocketPath, removeSocketFile } from "../state/index.js";
+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) {
+        this.clients = new Set();
+        this.subscribers = new Set();
+        this.manager = manager;
+        this.taskManager = taskManager;
+        this.socketPath = getSocketPath();
+        this.server = net.createServer((socket) => this.handleConnection(socket));
+    }
+    async listen() {
+        removeSocketFile();
+        return new Promise((resolve, reject) => {
+            this.server.on("error", reject);
+            this.server.listen(this.socketPath, () => {
+                this.server.removeListener("error", reject);
+                resolve();
+            });
+        });
+    }
+    async close() {
+        for (const client of this.clients) {
+            client.destroy();
+        }
+        this.clients.clear();
+        this.subscribers.clear();
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                removeSocketFile();
+                resolve();
+            });
+        });
+    }
+    pushEvent(event, data) {
+        for (const socket of this.subscribers) {
+            try {
+                send(socket, { type: "event", event, data });
+            }
+            catch {
+                this.subscribers.delete(socket);
+            }
+        }
+    }
+    handleConnection(socket) {
+        this.clients.add(socket);
+        socket.on("close", () => {
+            this.clients.delete(socket);
+            this.subscribers.delete(socket);
+        });
+        let buffer = "";
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        const request = JSON.parse(line);
+                        this.handleRequest(request, socket);
+                    }
+                    catch {
+                        send(socket, { type: "error", message: t("errors.invalidJson") });
+                    }
+                }
+            }
+        });
+        socket.on("close", () => {
+            this.clients.delete(socket);
+        });
+        socket.on("error", () => {
+            this.clients.delete(socket);
+        });
+    }
+    respondOk(socket, ok, id, data) {
+        if (!ok) {
+            send(socket, { type: "error", message: t("errors.loopNotFound", { id }) });
+        }
+        else if (data !== undefined) {
+            send(socket, { type: "ok", data });
+        }
+        else {
+            send(socket, { type: "ok" });
+        }
+    }
+    async handleRequest(request, socket) {
+        // Dispatch to extracted handlers
+        const handled = await dispatch(request, socket, {
+            manager: this.manager,
+            taskManager: this.taskManager,
+            respondOk: (s, ok, id, data) => this.respondOk(s, ok, id, data),
+        });
+        if (!handled) {
+            // Handle non-dispatchable cases inline
+            switch (request.type) {
+                case "subscribe": {
+                    this.subscribers.add(socket);
+                    send(socket, { type: "ok" });
+                    break;
+                }
+                case "shutdown": {
+                    send(socket, { type: "ok" });
+                    await this.manager.shutdown();
+                    await this.close();
+                    process.exit(0);
+                }
+            }
+        }
+    }
+}

package/dist/daemon/{spawner.js → spawner/index.js}

@@ -1,9 +1,9 @@
 import { spawn } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { readDaemonPid, isDaemonAlive, removeDaemonPid, removeDaemonSignature, readDaemonSignature, computeCodeSignature, getSocketPath, } from "./state.js";
-import { t } from "../i18n/index.js";
-import { DAEMON_POLL_MS, DAEMON_SPAWN_TIMEOUT_MS } from "../config/constants.js";
+import { readDaemonPid, isDaemonAlive, removeDaemonPid, removeDaemonSignature, readDaemonSignature, computeCodeSignature, getSocketPath, } from "../state/index.js";
+import { t } from "../../shared/i18n/index.js";
+import { DAEMON_POLL_MS, DAEMON_SPAWN_TIMEOUT_MS } from "../../shared/config/constants.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 let cachedSignature = null;
@@ -54,7 +54,7 @@ export function ensureDaemon() {
         removeDaemonPid();
         removeDaemonSignature();
     }
-    const daemonScript = path.resolve(__dirname, __filename.endsWith(".ts") ? "index.ts" : "index.js");
+    const daemonScript = path.resolve(__dirname, __filename.endsWith(".ts") ? "../index.ts" : "../index.js");
     const args = __filename.endsWith(".ts")
         ? process.execPath.includes("bun")
             ? [daemonScript]

package/dist/daemon/{state.js → state/index.js}

@@ -2,9 +2,9 @@ import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
 import { fileURLToPath } from "node:url";
-import { removeIfExists, writeFileAtomic } from "../shared/fs-utils.js";
-import { getLoopsDir, getTasksDir, getLogsDir, logFile, getPidFile, getSignatureFile, getSocketPath, loopsJson, tasksJson, getDataDir, } from "../config/paths.js";
-export { getDataDir, getPidFile, getSocketPath } from "../config/paths.js";
+import { removeIfExists, writeFileAtomic } from "../../shared/fs-utils.js";
+import { getLoopsDir, getTasksDir, getLogsDir, logFile, getPidFile, getSignatureFile, getSocketPath, loopsJson, tasksJson, getDataDir, } from "../../shared/config/paths.js";
+export { getDataDir, getPidFile, getSocketPath } from "../../shared/config/paths.js";
 function ensureDirs() {
     fs.mkdirSync(getDataDir(), { recursive: true });
     fs.mkdirSync(getLogsDir(), { recursive: true });
@@ -127,7 +127,7 @@ export function getLogPath(id) {
     return logFile(id);
 }
 export function computeCodeSignature() {
-    const srcDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+    const srcDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
     let maxMtimeMs = 0;
     let totalSize = 0;
     let count = 0;

package/dist/daemon/{file-watcher.js → watcher/index.js}

@@ -1,15 +1,17 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createHash } from "node:crypto";
-import { loopsJson, tasksJson, projectsJson } from "../config/paths.js";
+import { loopsJson, tasksJson, projectsJson } from "../../shared/config/paths.js";
 const DEBOUNCE_MS = 300;
 const MTIME_POLL_MS = 2000;
 export class FileWatcher {
-    watchers = new Map();
-    mtimeTimers = new Map();
-    loopManager = null;
-    taskManager = null;
-    projectManager = null;
+    constructor() {
+        this.watchers = new Map();
+        this.mtimeTimers = new Map();
+        this.loopManager = null;
+        this.taskManager = null;
+        this.projectManager = null;
+    }
     setManagers(loopManager, taskManager, projectManager) {
         this.loopManager = loopManager;
         this.taskManager = taskManager;

package/dist/duration.js

@@ -1,5 +1,5 @@
 import ms from "ms";
-import { t } from "./i18n/index.js";
+import { t } from "./shared/i18n/index.js";
 export function parseDuration(input) {
     const trimmed = input.trim();
     if (!trimmed) {

package/dist/{tui/state.js → entities/loops/filters.js}

@@ -97,79 +97,3 @@ const STATUS_CYCLE = {
 export function cycleStatusFilter(status) {
     return STATUS_CYCLE[status];
 }
-export const defaultProjectFilters = {
-    query: "",
-    hasLoops: "all",
-    isSystem: "all",
-    sort: "name",
-};
-export function applyProjectFilters(projects, loops, filters) {
-    const filtered = projects.filter((project) => {
-        if (filters.hasLoops === "with-loops") {
-            const count = loops.filter((l) => (l.projectId ?? "default") === project.id).length;
-            if (count === 0)
-                return false;
-        }
-        if (filters.hasLoops === "empty") {
-            const count = loops.filter((l) => (l.projectId ?? "default") === project.id).length;
-            if (count > 0)
-                return false;
-        }
-        if (filters.isSystem === "system" && !project.isSystem)
-            return false;
-        if (filters.isSystem === "user" && project.isSystem)
-            return false;
-        const query = filters.query.trim().toLowerCase();
-        if (query && !project.name.toLowerCase().includes(query))
-            return false;
-        return true;
-    });
-    return filtered.sort((a, b) => {
-        if (filters.sort === "name") {
-            return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
-        }
-        if (filters.sort === "loop-count") {
-            const ca = loops.filter((l) => (l.projectId ?? "default") === a.id).length;
-            const cb = loops.filter((l) => (l.projectId ?? "default") === b.id).length;
-            if (cb !== ca)
-                return cb - ca;
-            return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
-        }
-        const da = a.createdAt;
-        const db = b.createdAt;
-        if (da !== db)
-            return db.localeCompare(da);
-        return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
-    });
-}
-const PROJECT_SORT_CYCLE = {
-    name: "loop-count",
-    "loop-count": "created-date",
-    "created-date": "name",
-};
-export function cycleProjectSortMode(mode) {
-    return PROJECT_SORT_CYCLE[mode];
-}
-const PROJECT_HAS_LOOPS_CYCLE = {
-    all: "with-loops",
-    "with-loops": "empty",
-    empty: "all",
-};
-export function cycleProjectHasLoopsFilter(filter) {
-    return PROJECT_HAS_LOOPS_CYCLE[filter];
-}
-const PROJECT_IS_SYSTEM_CYCLE = {
-    all: "system",
-    system: "user",
-    user: "all",
-};
-export function cycleProjectIsSystemFilter(filter) {
-    return PROJECT_IS_SYSTEM_CYCLE[filter];
-}
-export function resolveInputOwner(state) {
-    if (state.modalOpen)
-        return "modal";
-    if (state.commandBarHasText || state.commandBarDropdownOpen)
-        return "commandBar";
-    return "panel";
-}

package/dist/entities/loops/index.js

@@ -0,0 +1 @@
+export { defaultFilters, applyLoopFilters, cycleSortMode, cycleStatusFilter, } from "./filters.js";

package/dist/entities/projects/filters.js

@@ -0,0 +1,69 @@
+export const defaultProjectFilters = {
+    query: "",
+    hasLoops: "all",
+    isSystem: "all",
+    sort: "name",
+};
+export function applyProjectFilters(projects, loops, filters) {
+    const filtered = projects.filter((project) => {
+        if (filters.hasLoops === "with-loops") {
+            const count = loops.filter((l) => (l.projectId ?? "default") === project.id).length;
+            if (count === 0)
+                return false;
+        }
+        if (filters.hasLoops === "empty") {
+            const count = loops.filter((l) => (l.projectId ?? "default") === project.id).length;
+            if (count > 0)
+                return false;
+        }
+        if (filters.isSystem === "system" && !project.isSystem)
+            return false;
+        if (filters.isSystem === "user" && project.isSystem)
+            return false;
+        const query = filters.query.trim().toLowerCase();
+        if (query && !project.name.toLowerCase().includes(query))
+            return false;
+        return true;
+    });
+    return filtered.sort((a, b) => {
+        if (filters.sort === "name") {
+            return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
+        }
+        if (filters.sort === "loop-count") {
+            const ca = loops.filter((l) => (l.projectId ?? "default") === a.id).length;
+            const cb = loops.filter((l) => (l.projectId ?? "default") === b.id).length;
+            if (cb !== ca)
+                return cb - ca;
+            return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
+        }
+        const da = a.createdAt;
+        const db = b.createdAt;
+        if (da !== db)
+            return db.localeCompare(da);
+        return a.name.localeCompare(b.name, undefined, { sensitivity: "base" });
+    });
+}
+const PROJECT_SORT_CYCLE = {
+    name: "loop-count",
+    "loop-count": "created-date",
+    "created-date": "name",
+};
+export function cycleProjectSortMode(mode) {
+    return PROJECT_SORT_CYCLE[mode];
+}
+const PROJECT_HAS_LOOPS_CYCLE = {
+    all: "with-loops",
+    "with-loops": "empty",
+    empty: "all",
+};
+export function cycleProjectHasLoopsFilter(filter) {
+    return PROJECT_HAS_LOOPS_CYCLE[filter];
+}
+const PROJECT_IS_SYSTEM_CYCLE = {
+    all: "system",
+    system: "user",
+    user: "all",
+};
+export function cycleProjectIsSystemFilter(filter) {
+    return PROJECT_IS_SYSTEM_CYCLE[filter];
+}

package/dist/entities/projects/index.js

@@ -0,0 +1 @@
+export { defaultProjectFilters, applyProjectFilters, cycleProjectSortMode, cycleProjectHasLoopsFilter, cycleProjectIsSystemFilter, } from "./filters.js";

package/dist/entities/tasks/filters.js

@@ -0,0 +1,41 @@
+export const defaultTaskFilters = {
+    query: "",
+    sort: "name",
+};
+function taskSearchableText(task) {
+    return `${task.id} ${task.name} ${task.command} ${task.commandArgs.join(" ")}`.toLowerCase();
+}
+function matches(task, filters) {
+    const query = filters.query.trim().toLowerCase();
+    if (!query)
+        return true;
+    return taskSearchableText(task).includes(query);
+}
+function compare(left, right, sort) {
+    if (sort === "name") {
+        return left.name.localeCompare(right.name, undefined, { sensitivity: "base" });
+    }
+    if (sort === "command") {
+        const leftCmd = left.commandRaw ?? [left.command, ...left.commandArgs].join(" ");
+        const rightCmd = right.commandRaw ?? [right.command, ...right.commandArgs].join(" ");
+        const byCmd = leftCmd.localeCompare(rightCmd, undefined, { sensitivity: "base" });
+        if (byCmd !== 0)
+            return byCmd;
+        return left.name.localeCompare(right.name, undefined, { sensitivity: "base" });
+    }
+    // "created" — newest first
+    return right.createdAt.localeCompare(left.createdAt);
+}
+export function applyTaskFilters(tasks, filters) {
+    return tasks
+        .filter((task) => matches(task, filters))
+        .sort((left, right) => compare(left, right, filters.sort));
+}
+const TASK_SORT_CYCLE = {
+    name: "command",
+    command: "created",
+    created: "name",
+};
+export function cycleTaskSortMode(mode) {
+    return TASK_SORT_CYCLE[mode];
+}

package/dist/entities/tasks/index.js

@@ -0,0 +1 @@
+export { defaultTaskFilters, applyTaskFilters, cycleTaskSortMode, } from "./filters.js";

package/dist/{tui/components → features/chain-editor}/ChainEditor.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useState, useMemo, useEffect } from "react";
 import { Box, Text, useInput } from "ink";
-import { darkTheme as theme } from "../theme.js";
-import { listTasks } from "../daemon.js";
-import { commandLine } from "../format.js";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { useInject } from "../../shared/hooks/useInject.js";
+import { TYPES } from "../../shared/services/types.js";
+import { commandLine } from "../../shared/ui/format.js";
 function buildChains(tasks) {
     const taskMap = new Map();
     for (const task of tasks) {
@@ -58,9 +59,10 @@ function flattenTree(node, result = [], prefix = "") {
 export function ChainEditor(props) {
     const [tasks, setTasks] = useState([]);
     const [selectedIndex, setSelectedIndex] = useState(0);
+    const taskService = useInject(TYPES.TaskService);
     useEffect(() => {
-        listTasks().then(setTasks).catch(() => setTasks([]));
-    }, []);
+        taskService.list().then(setTasks).catch(() => setTasks([]));
+    }, [taskService]);
     const trees = useMemo(() => buildChains(tasks), [tasks]);
     const flatNodes = useMemo(() => {
         const all = [];

package/dist/features/code-editor/CodeEditorModal.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useState, useCallback, useMemo } from "react";
+import { Box, Text } from "ink";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { t } from "../../shared/i18n/index.js";
+import { useUndoRedo } from "../../shared/hooks/useUndoRedo.js";
+import { highlightSegments } from "../../shared/utils/syntax.js";
+import { joinCommandLines } from "../../loop-config.js";
+import { CODE_EDITOR_UNDO_LIMIT, CODE_EDITOR_SYNTAX_COLORS } from "../../shared/config/constants.js";
+import { useModalDimensions } from "./useModalDimensions.js";
+import { useEditorKeyboard } from "./useEditorKeyboard.js";
+export function CodeEditorModal(props) {
+    const { initialValue, onSave, onCancel } = props;
+    const { modalWidth, modalHeight, editorVisibleLines: EDITOR_VISIBLE_LINES } = useModalDimensions();
+    const { value, setValue, undo, redo } = useUndoRedo(initialValue, CODE_EDITOR_UNDO_LIMIT);
+    const [cursorRow, setCursorRow] = useState(() => {
+        const lines = initialValue.split("\n");
+        return Math.max(0, lines.length - 1);
+    });
+    const [cursorCol, setCursorCol] = useState(() => {
+        const lines = initialValue.split("\n");
+        return (lines[lines.length - 1] ?? "").length;
+    });
+    const [flashMsg, setFlashMsg] = useState(null);
+    const lines = useMemo(() => (value ? value.split("\n") : [""]), [value]);
+    const lineCount = lines.length;
+    const lineNumWidth = String(lineCount).length;
+    React.useEffect(() => {
+        if (flashMsg) {
+            const timer = setTimeout(() => setFlashMsg(null), 1500);
+            return () => clearTimeout(timer);
+        }
+    }, [flashMsg]);
+    const scrollStart = useMemo(() => {
+        if (cursorRow < EDITOR_VISIBLE_LINES)
+            return 0;
+        return cursorRow - EDITOR_VISIBLE_LINES + 1;
+    }, [cursorRow]);
+    const visibleLines = useMemo(() => lines.slice(scrollStart, scrollStart + EDITOR_VISIBLE_LINES), [lines, scrollStart]);
+    const applyMutation = useCallback((nextLines, newCursorRow, newCursorCol) => {
+        setValue(nextLines.join("\n"));
+        setCursorRow(newCursorRow);
+        setCursorCol(newCursorCol);
+    }, [setValue]);
+    useEditorKeyboard({
+        lines,
+        cursorRow,
+        cursorCol,
+        value,
+        setValue,
+        setCursorRow,
+        setCursorCol,
+        undo,
+        redo,
+        onSave,
+        onCancel,
+        setFlashMsg,
+        applyMutation,
+    });
+    const joined = joinCommandLines(value);
+    const innerWidth = modalWidth - 2;
+    const truncatedPreview = joined.length > innerWidth
+        ? joined.slice(0, innerWidth - 1) + t("codeEditor.previewTruncated")
+        : joined;
+    const accent = theme.accent.brand;
+    return (_jsx(Box, { position: "absolute", top: 0, left: 0, width: "100%", height: "100%", justifyContent: "center", alignItems: "center", children: _jsxs(Box, { width: modalWidth, height: modalHeight, flexDirection: "column", backgroundColor: theme.bg.elevated, borderStyle: "round", borderColor: accent, paddingX: 1, children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { color: accent, bold: true, children: t("codeEditor.title") }), _jsxs(Text, { color: theme.text.muted, children: [lineCount, " ", t("cmdEditor.lines")] })] }), _jsx(Box, { flexDirection: "column", flexGrow: 1, overflow: "hidden", children: visibleLines.map((line, visIdx) => {
+                        const rowIdx = scrollStart + visIdx;
+                        const isCursor = rowIdx === cursorRow;
+                        const lineNum = String(rowIdx + 1).padStart(lineNumWidth, " ");
+                        if (isCursor) {
+                            const before = line.slice(0, cursorCol);
+                            const cur = cursorCol < line.length ? line[cursorCol] : " ";
+                            const after = cursorCol < line.length ? line.slice(cursorCol + 1) : "";
+                            // Cursor line: render with cursor (no syntax highlight on cursor line)
+                            return (_jsxs(Box, { children: [_jsxs(Text, { color: theme.text.muted, children: [lineNum, " "] }), _jsx(Text, { color: theme.text.primary, children: before }), _jsx(Text, { inverse: true, children: cur }), _jsx(Text, { color: theme.text.primary, children: after })] }, rowIdx));
+                        }
+                        // Non-cursor line: syntax highlighted (whitespace preserved)
+                        const segments = highlightSegments(line, CODE_EDITOR_SYNTAX_COLORS, theme.text.muted);
+                        if (segments.length === 0) {
+                            return (_jsxs(Box, { children: [_jsxs(Text, { color: theme.text.muted, children: [lineNum, " "] }), _jsx(Text, { children: " " })] }, rowIdx));
+                        }
+                        return (_jsxs(Box, { children: [_jsxs(Text, { color: theme.text.muted, children: [lineNum, " "] }), segments.map((seg, ti) => (_jsx(Text, { color: seg.color, children: seg.value }, ti)))] }, rowIdx));
+                    }) }), _jsxs(Box, { children: [_jsxs(Text, { color: theme.text.muted, children: [t("codeEditor.previewLabel"), " "] }), _jsx(Text, { color: theme.text.secondary, children: truncatedPreview || t("codeEditor.emptyPlaceholder") })] }), _jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { color: theme.accent.brand, children: t("codeEditor.buttonCopy") }), _jsx(Text, { color: theme.text.muted, children: "ctrl+x" }), _jsx(Text, { color: theme.accent.brand, children: t("codeEditor.buttonPaste") }), _jsx(Text, { color: theme.text.muted, children: "ctrl+v" }), _jsx(Text, { color: theme.accent.brand, children: t("codeEditor.buttonClear") }), _jsx(Text, { color: theme.text.muted, children: "ctrl+l" })] }), flashMsg ? (_jsx(Text, { color: theme.semantic.success, children: flashMsg })) : null] }), _jsx(Box, { children: _jsx(Text, { color: theme.text.muted, children: t("codeEditor.hint") }) })] }) }));
+}

package/dist/{tui/components → features/code-editor}/CodeEditorPreview.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-import { darkTheme as theme } from "../theme.js";
-import { t } from "../../i18n/index.js";
-import { CODE_EDITOR_MAX_VISIBLE } from "../../config/constants.js";
+import { darkTheme as theme } from "../../shared/ui/theme.js";
+import { t } from "../../shared/i18n/index.js";
+import { CODE_EDITOR_MAX_VISIBLE } from "../../shared/config/constants.js";
 export function CodeEditorPreview(props) {
     const { value, hint, isActive, onActivate } = props;
     const lines = value ? value.split("\n") : [];

package/dist/features/code-editor/useEditorKeyboard.js

@@ -0,0 +1,147 @@
+import { useInput } from "ink";
+import { t } from "../../shared/i18n/index.js";
+import { copyToClipboard, readFromClipboard } from "../../shared/clipboard.js";
+import { sanitizeMultilinePaste, wrapCommand } from "../../shared/utils/paste.js";
+export function useEditorKeyboard(params) {
+    const { lines, cursorRow, cursorCol, value, setValue, setCursorRow, setCursorCol, undo, redo, onSave, onCancel, setFlashMsg, applyMutation, } = params;
+    useInput((input, key) => {
+        if (input.includes("\x1b[200~")) {
+            const pasted = wrapCommand(sanitizeMultilinePaste(input));
+            if (pasted) {
+                const next = [...lines];
+                const line = next[cursorRow] ?? "";
+                next[cursorRow] =
+                    line.slice(0, cursorCol) + pasted + line.slice(cursorCol);
+                applyMutation(next, cursorRow, cursorCol + pasted.length);
+            }
+            return;
+        }
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if ((key.ctrl && input === "s") || input === "\x13") {
+            onSave(value);
+            return;
+        }
+        if ((key.ctrl && !key.shift && input === "z") || input === "\x1a") {
+            undo();
+            return;
+        }
+        if (key.ctrl && key.shift && input === "z") {
+            redo();
+            return;
+        }
+        if ((key.ctrl && input === "x") || input === "\x18") {
+            copyToClipboard(value);
+            setValue("");
+            setCursorRow(0);
+            setCursorCol(0);
+            setFlashMsg(t("codeEditor.copied"));
+            return;
+        }
+        if ((key.ctrl && input === "v") || input === "\x16") {
+            const clip = readFromClipboard();
+            if (clip) {
+                const pasted = sanitizeMultilinePaste(clip);
+                if (pasted) {
+                    const next = [...lines];
+                    const line = next[cursorRow] ?? "";
+                    next[cursorRow] =
+                        line.slice(0, cursorCol) + pasted + line.slice(cursorCol);
+                    applyMutation(next, cursorRow, cursorCol + pasted.length);
+                }
+            }
+            else {
+                setFlashMsg(t("codeEditor.clipboardEmpty"));
+            }
+            return;
+        }
+        if ((key.ctrl && input === "l") || input === "\x0c") {
+            setValue("");
+            setCursorRow(0);
+            setCursorCol(0);
+            setFlashMsg(t("codeEditor.cleared"));
+            return;
+        }
+        if (key.return) {
+            const next = [...lines];
+            const line = next[cursorRow] ?? "";
+            next.splice(cursorRow, 1, line.slice(0, cursorCol), line.slice(cursorCol));
+            applyMutation(next, cursorRow + 1, 0);
+            return;
+        }
+        if (key.upArrow) {
+            if (cursorRow > 0) {
+                const newRow = cursorRow - 1;
+                setCursorRow(newRow);
+                setCursorCol((c) => Math.min(c, (lines[newRow] ?? "").length));
+            }
+            return;
+        }
+        if (key.downArrow) {
+            if (cursorRow < lines.length - 1) {
+                const newRow = cursorRow + 1;
+                setCursorRow(newRow);
+                setCursorCol((c) => Math.min(c, (lines[newRow] ?? "").length));
+            }
+            return;
+        }
+        if (key.leftArrow) {
+            if (cursorCol > 0) {
+                setCursorCol((c) => c - 1);
+            }
+            else if (cursorRow > 0) {
+                setCursorRow((r) => r - 1);
+                setCursorCol((lines[cursorRow - 1] ?? "").length);
+            }
+            return;
+        }
+        if (key.rightArrow) {
+            const curLen = (lines[cursorRow] ?? "").length;
+            if (cursorCol < curLen) {
+                setCursorCol((c) => c + 1);
+            }
+            else if (cursorRow < lines.length - 1) {
+                setCursorRow((r) => r + 1);
+                setCursorCol(0);
+            }
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (cursorCol > 0) {
+                const next = [...lines];
+                const line = next[cursorRow] ?? "";
+                next[cursorRow] =
+                    line.slice(0, cursorCol - 1) + line.slice(cursorCol);
+                applyMutation(next, cursorRow, cursorCol - 1);
+            }
+            else if (cursorRow > 0) {
+                const next = [...lines];
+                const prev = next[cursorRow - 1] ?? "";
+                const cur = next[cursorRow] ?? "";
+                next.splice(cursorRow - 1, 2, prev + cur);
+                applyMutation(next, cursorRow - 1, prev.length);
+            }
+            return;
+        }
+        if (input.length > 1 && !key.meta) {
+            const pasted = wrapCommand(sanitizeMultilinePaste(input));
+            if (pasted) {
+                const next = [...lines];
+                const line = next[cursorRow] ?? "";
+                next[cursorRow] =
+                    line.slice(0, cursorCol) + pasted + line.slice(cursorCol);
+                applyMutation(next, cursorRow, cursorCol + pasted.length);
+            }
+            return;
+        }
+        if (input.length === 1 && input >= " " && input <= "~") {
+            const next = [...lines];
+            const line = next[cursorRow] ?? "";
+            next[cursorRow] =
+                line.slice(0, cursorCol) + input + line.slice(cursorCol);
+            applyMutation(next, cursorRow, cursorCol + 1);
+        }
+    }, { isActive: true });
+}