loop-task 2.0.15 → 2.0.16

package/dist/cli/import-validator.js

@@ -38,7 +38,7 @@ const LOOP_FIELDS = [
     { name: "remainingDelayMs", type: "number", nullable: true },
     { name: "pid", type: "number", nullable: false },
     { name: "maxRunsReached", type: "boolean", nullable: false },
-    { name: "runHistory", type: "array", nullable: false },
+    { name: "runHistory", type: "array", nullable: true },
     { name: "skippedCount", type: "number", nullable: false },
     { name: "projectId", type: "string", nullable: false },
     { name: "offset", type: "number", nullable: true },

package/dist/cli/import-writer.js

@@ -9,8 +9,12 @@ function backupFilePath(filePath) {
 export function atomicImportWrite(loops, tasks, projects) {
     const dataDir = getDataDir();
     fs.mkdirSync(dataDir, { recursive: true });
+    const normalizedLoops = loops.map((loop) => ({
+        ...loop,
+        runHistory: Array.isArray(loop.runHistory) ? loop.runHistory : [],
+    }));
     const contents = {
-        "loops.json": JSON.stringify(loops, null, 2),
+        "loops.json": JSON.stringify(normalizedLoops, null, 2),
         "tasks.json": JSON.stringify(tasks, null, 2),
         "projects.json": JSON.stringify(projects, null, 2),
     };

package/dist/cli.js

@@ -206,10 +206,11 @@ program
         sendRequest({ type: "task-list" }),
         sendRequest({ type: "project-list" }),
     ]);
+    const loops = loopsRes.type === "ok" ? loopsRes.data : [];
     const exportData = {
         version: 2,
         exportedAt: new Date().toISOString(),
-        loops: loopsRes.type === "ok" ? loopsRes.data : [],
+        loops: loops.map(({ runHistory: _ignored, ...rest }) => rest),
         tasks: tasksRes.type === "ok" ? tasksRes.data : [],
         projects: projectsRes.type === "ok" ? projectsRes.data : [],
     };

package/dist/i18n/en.json

@@ -290,6 +290,7 @@
     "codeEditor.fieldHint": "press enter to open editor",
     "codeEditor.copied": "Copied!",
     "codeEditor.cleared": "Cleared",
+    "codeEditor.clipboardEmpty": "Clipboard empty — right-click to paste",
     "board.exampleInterval": "30m",
     "board.exampleCommand": "opencode run \"search missing translations and translate them, 3 maximum\" --model \"opencode/big-pickle\"",
     "board.exampleDescription": "translate missing strings",

package/dist/shared/clipboard.js

@@ -1,39 +1,109 @@
 import { execFileSync } from "node:child_process";
 import { platform } from "node:os";
+/**
+ * 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) →
+ * tmux load-buffer (when $TMUX is set) → OSC 52 (works over SSH because
+ * the local terminal owns the clipboard).
+ */
 export function copyToClipboard(text) {
     const os = platform();
     if (os === "win32") {
-        execFileSync("clip", { input: text });
+        try {
+            execFileSync("clip", { input: text });
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    else if (os === "darwin") {
-        execFileSync("pbcopy", { input: text });
+    if (os === "darwin") {
+        try {
+            execFileSync("pbcopy", { input: text });
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
-    else {
+    // 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 = [
+        () => execFileSync("xclip", ["-selection", "clipboard"], { input: text }),
+        () => execFileSync("xsel", ["--clipboard", "--input"], { input: text }),
+        () => execFileSync("wl-copy", [], { input: text }),
+    ];
+    for (const tryFn of tries) {
         try {
-            execFileSync("xclip", ["-selection", "clipboard"], { input: text });
+            tryFn();
+            return true;
         }
         catch {
-            execFileSync("xsel", ["--clipboard", "--input"], { input: text });
+            // try next tool
         }
     }
+    if (process.env.TMUX) {
+        try {
+            execFileSync("tmux", ["load-buffer", "-"], { input: text });
+            return true;
+        }
+        catch {
+            // fall through to OSC 52
+        }
+    }
+    // OSC 52: ask the connected terminal to copy. Works over SSH because the
+    // local terminal owns the clipboard. Most modern terminals support it
+    // (iTerm2, WezTerm, Windows Terminal, Kitty, Alacritty).
+    try {
+        process.stdout.write(`\x1b]52;c;${Buffer.from(text, "utf-8").toString("base64")}\x07`);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
+/**
+ * Read text from the system clipboard. Returns "" if unavailable.
+ *
+ * Linux toolchain: xclip → xsel → wl-paste → tmux save-buffer -. OSC 52
+ * reply is not solicited synchronously (timings are unreliable across
+ * terminals); callers fall back to bracketed-paste detection for input.
+ */
 export function readFromClipboard() {
     const os = platform();
     try {
         if (os === "win32") {
             return execFileSync("powershell", ["-NoProfile", "-Command", "Get-Clipboard"], { encoding: "utf-8" }).replace(/\r?\n$/, "");
         }
-        else if (os === "darwin") {
+        if (os === "darwin") {
             return execFileSync("pbpaste", { encoding: "utf-8" });
         }
-        else {
+        // Linux / BSD
+        const tries = [
+            () => execFileSync("xclip", ["-selection", "clipboard", "-o"], { encoding: "utf-8" }),
+            () => execFileSync("xsel", ["--clipboard", "--output"], { encoding: "utf-8" }),
+            () => execFileSync("wl-paste", [], { encoding: "utf-8" }),
+        ];
+        for (const tryFn of tries) {
             try {
-                return execFileSync("xclip", ["-selection", "clipboard", "-o"], { encoding: "utf-8" });
+                return tryFn();
             }
             catch {
-                return execFileSync("xsel", ["--clipboard", "--output"], { encoding: "utf-8" });
+                // try next tool
             }
         }
+        if (process.env.TMUX) {
+            try {
+                return execFileSync("tmux", ["save-buffer", "-"], { encoding: "utf-8" });
+            }
+            catch {
+                // ignore
+            }
+        }
+        return "";
     }
     catch {
         return "";

package/dist/tui/components/CodeEditorModal.js

@@ -49,18 +49,32 @@ export function CodeEditorModal(props) {
     }, [setValue]);
     // ---- Keyboard handling ----
     useInput((input, key) => {
+        // Bracketed paste: content wrapped in ESC[200~ ... ESC[201~
+        // Must be detected BEFORE the escape check — the leading ESC trips
+        // key.escape and would close the modal before paste is handled.
+        if (input.includes("\x1b[200~")) {
+            const pasted = sanitizePaste(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;
+        }
         // Esc → cancel
         if (key.escape) {
             onCancel();
             return;
         }
-        // Ctrl+S → save
-        if (key.ctrl && input === "s") {
+        // Ctrl+S → save (also accept raw \x13 fallback)
+        if ((key.ctrl && input === "s") || input === "\x13") {
             onSave(value);
             return;
         }
-        // Ctrl+Z → undo
-        if (key.ctrl && !key.shift && input === "z") {
+        // Ctrl+Z → undo (also accept raw \x1a fallback)
+        if ((key.ctrl && !key.shift && input === "z") || input === "\x1a") {
             undo();
             return;
         }
@@ -69,8 +83,8 @@ export function CodeEditorModal(props) {
             redo();
             return;
         }
-        // Ctrl+X → cut (copy all to clipboard, then clear)
-        if (key.ctrl && input === "x") {
+        // Ctrl+X → cut (copy all to clipboard, then clear; also accept \x18)
+        if ((key.ctrl && input === "x") || input === "\x18") {
             copyToClipboard(value);
             setValue("");
             setCursorRow(0);
@@ -78,8 +92,9 @@ export function CodeEditorModal(props) {
             setFlashMsg(t("codeEditor.copied"));
             return;
         }
-        // Ctrl+V → paste from clipboard
-        if (key.ctrl && input === "v") {
+        // Ctrl+V → paste from clipboard (also accept raw \x16 fallback for
+        // terminals that don't set key.ctrl on the SYN control byte)
+        if ((key.ctrl && input === "v") || input === "\x16") {
             const clip = readFromClipboard();
             if (clip) {
                 const pasted = sanitizePaste(clip);
@@ -91,10 +106,15 @@ export function CodeEditorModal(props) {
                     applyMutation(next, cursorRow, cursorCol + pasted.length);
                 }
             }
+            else {
+                // No clipboard tool available (common over SSH). Bracketed paste
+                // (right-click in the terminal) still works — point the user at it.
+                setFlashMsg(t("codeEditor.clipboardEmpty"));
+            }
             return;
         }
         // Ctrl+L → clear all
-        if (key.ctrl && input === "l") {
+        if ((key.ctrl && input === "l") || input === "\x0c") {
             setValue("");
             setCursorRow(0);
             setCursorCol(0);
@@ -165,18 +185,6 @@ export function CodeEditorModal(props) {
             }
             return;
         }
-        // Bracketed paste: content wrapped in ESC[200~ ... ESC[201~
-        if (input.includes("\x1b[200~")) {
-            const pasted = sanitizePaste(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;
-        }
         // Multi-char containing CR/LF with no bracketed markers — ignore
         if (input.length > 1 && (input.includes("\r") || input.includes("\n")))
             return;

package/dist/tui/components/ExportModal.js

@@ -14,6 +14,12 @@ export function ExportModal(props) {
     const maxScroll = Math.max(0, displayLines.length - VISIBLE_LINES);
     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
+        // close the modal on a right-click paste.
+        if (input.includes("\x1b[200~")) {
+            return;
+        }
         if (key.escape) {
             props.onClose();
             return;

package/dist/tui/components/LogModal.js

@@ -54,6 +54,13 @@ export function LogModal(props) {
     const endIdx = startIdx + MAX_VISIBLE_LINES;
     const visible = filtered.slice(startIdx, endIdx);
     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
+        // close the modal before the paste is acknowledged. LogModal doesn't
+        // insert pastes, so just swallow the sequence.
+        if (input.includes("\x1b[200~")) {
+            return;
+        }
         if (searchMode) {
             if (key.escape || key.return) {
                 setSearchMode(false);

package/dist/tui/daemon.js

@@ -123,7 +123,7 @@ export async function exportConfig() {
     const exportData = {
         version: 2,
         exportedAt: new Date().toISOString(),
-        loops,
+        loops: loops.map(({ runHistory: _ignored, ...rest }) => rest),
         tasks,
         projects,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loop-task",
-  "version": "2.0.15",
+  "version": "2.0.16",
   "description": "Loop engineering toolkit. Run any command on a cadence, in the background, managed from a terminal board. Schedule tests, builds, syncs, or agent prompts.",
   "type": "module",
   "bin": {