@plainconceptsplatform/loop-task 2.6.0

package/dist/loop-config.js

@@ -0,0 +1,152 @@
+import { parseDuration } from "./duration.js";
+import { t } from "./shared/i18n/index.js";
+export function parseMaxRuns(value) {
+    if (value === null || value === undefined || value === "") {
+        return null;
+    }
+    const parsed = typeof value === "number" ? value : parseInt(value, 10);
+    if (Number.isNaN(parsed) || parsed < 1) {
+        throw new Error(t("errors.maxRunsInvalid"));
+    }
+    return parsed;
+}
+export function parseCommandLine(input) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let hasToken = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const char = input[i];
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else if (char === "\\" && quote === '"') {
+                if (i + 1 < input.length) {
+                    i += 1;
+                    current += input[i];
+                }
+                else {
+                    current += char;
+                }
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            hasToken = true;
+            continue;
+        }
+        if (char === " " || char === "\t") {
+            if (hasToken) {
+                tokens.push(current);
+                current = "";
+                hasToken = false;
+            }
+            continue;
+        }
+        current += char;
+        hasToken = true;
+    }
+    if (quote) {
+        throw new Error(t("errors.unbalancedQuote"));
+    }
+    if (hasToken) {
+        tokens.push(current);
+    }
+    return tokens;
+}
+export function joinCommandLines(text) {
+    // Quote-aware split: don't split on newlines inside quoted strings
+    const segments = [];
+    let current = "";
+    let quote = null;
+    for (let i = 0; i < text.length; i += 1) {
+        const char = text[i];
+        if (quote) {
+            if (char === quote) {
+                quote = null;
+            }
+            else if (char === "\\" && quote === '"' && i + 1 < text.length) {
+                current += char + text[i + 1];
+                i += 1;
+                continue;
+            }
+            current += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (char === "\n") {
+            segments.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    segments.push(current);
+    // Join segments according to backslash-continuation rules:
+    // - Empty/whitespace-only segments are dropped
+    // - 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).
+    let result = "";
+    let prevContinued = false; // true if previous segment ended with \
+    for (const seg of segments) {
+        const trimmed = seg.trim();
+        if (trimmed === "")
+            continue;
+        const endsBackslash = trimmed.endsWith("\\");
+        const content = endsBackslash ? trimmed.slice(0, -1) : trimmed;
+        if (result === "") {
+            result = content;
+        }
+        else if (prevContinued) {
+            result += content;
+        }
+        else {
+            result += " " + content;
+        }
+        prevContinued = endsBackslash;
+    }
+    return result;
+}
+export function buildLoopOptions(intervalHuman, input = {}) {
+    const command = input.command ?? "";
+    const commandArgs = input.commandArgs ?? [];
+    const taskId = input.taskId ?? null;
+    if (!taskId && !command.trim()) {
+        throw new Error(t("errors.commandEmpty"));
+    }
+    const description = input.description?.trim() ?? "";
+    if (!description) {
+        throw new Error(t("errors.descriptionEmpty"));
+    }
+    const parsedInterval = parseDuration(intervalHuman);
+    const isManual = parsedInterval === 0;
+    const normalizedIntervalHuman = isManual ? "manual" : intervalHuman;
+    return {
+        intervalHuman: normalizedIntervalHuman,
+        options: {
+            interval: parsedInterval,
+            taskId,
+            command,
+            commandArgs,
+            cwd: input.cwd ?? "",
+            immediate: isManual ? false : (input.now ?? false),
+            maxRuns: parseMaxRuns(input.maxRuns),
+            verbose: input.verbose ?? false,
+            description,
+            projectId: input.projectId ?? "default",
+            offset: input.offset ?? null,
+            context: input.context,
+        },
+    };
+}

package/dist/shared/clipboard.js

@@ -0,0 +1,111 @@
+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") {
+        try {
+            execFileSync("clip", { input: text });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    if (os === "darwin") {
+        try {
+            execFileSync("pbcopy", { input: text });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // 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 {
+            tryFn();
+            return true;
+        }
+        catch {
+            // 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$/, "");
+        }
+        if (os === "darwin") {
+            return execFileSync("pbpaste", { encoding: "utf-8" });
+        }
+        // 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 tryFn();
+            }
+            catch {
+                // try next tool
+            }
+        }
+        if (process.env.TMUX) {
+            try {
+                return execFileSync("tmux", ["save-buffer", "-"], { encoding: "utf-8" });
+            }
+            catch {
+                // ignore
+            }
+        }
+        return "";
+    }
+    catch {
+        return "";
+    }
+}

package/dist/shared/config/constants.js

@@ -0,0 +1,104 @@
+export const POLL_MS = 1000;
+export const TOAST_TIMEOUT_MS = 3500;
+export const TOAST_MAX = 4;
+export const LOG_LINES_MAX = 500;
+export const MAX_LOG_BYTES = 1024 * 1024;
+export const MAX_CONTEXT_STDOUT_BYTES = 1024 * 1024;
+/** Max bytes for stdout attached to a span attribute (16KB) */
+export const MAX_SPAN_OUTPUT_BYTES = 16 * 1024;
+export const MAX_LOG_GENERATIONS = 3;
+export const MAX_INMEMORY_RUN_HISTORY = 100;
+export const MAX_STREAM_INITIAL_BYTES = 256 * 1024;
+export const USER_TIMING_SWEEP_MS = 10_000;
+export const LOG_MODAL_LINES_MAX = 5000;
+export const LOG_LINE_CHARS_MAX = 10_000;
+export const FOLLOW_REATTACH_DELAY_MS = 100;
+export const FOLLOW_REATTACH_MAX_ATTEMPTS = 20;
+export const FOLLOW_READ_BATCH_BYTES = 1024 * 1024;
+export const SLEEP_CHUNK_MS = 200;
+export const DAEMON_SPAWN_TIMEOUT_MS = 5000;
+export const DAEMON_POLL_MS = 100;
+export const IPC_TIMEOUT_MS = 10000;
+export const LOG_TAIL_DEFAULT = 50;
+/** Terminal width >= this shows the wide (side-by-side) two-panel layout. */
+export const BOARD_BREAKPOINT_WIDE = 110;
+/** Terminal width >= this and < WIDE shows the compact (stacked) single-panel layout. */
+export const BOARD_BREAKPOINT_COMPACT = 70;
+/** Legacy alias kept for backward compat with any external consumers. */
+export const BOARD_BREAKPOINT_WIDTH = BOARD_BREAKPOINT_WIDE;
+export const HEADER_COMPACT_WIDTH = 60;
+export const SEARCH_SELECT_HEIGHT = 6;
+// DECSET 2004: terminal wraps pasted text in ESC[200~ ... ESC[201~ so the
+// app can insert it wholesale instead of processing each char as a keypress.
+export const BRACKETED_PASTE_ENABLE = "\x1b[?2004h";
+export const BRACKETED_PASTE_DISABLE = "\x1b[?2004l";
+export const PASTE_MAX_CHARS = 4096;
+// DECSET 1000: enable mouse button event tracking (scroll wheel + clicks).
+// DECSET 1006: enable SGR extended mouse mode (structured escape sequences
+// that are unambiguous and easy to parse, e.g. [<64;col;rowM for scroll up).
+export const MOUSE_TRACKING_ENABLE = "\x1b[?1000h\x1b[?1006h";
+export const MOUSE_TRACKING_DISABLE = "\x1b[?1006l\x1b[?1000l";
+export const HOVER_BG = "#1e3a5f";
+export const PROJECT_COLORS = {
+    white: "#ffffff",
+    cyan: "#06b6d4",
+    green: "#4ade80",
+    yellow: "#facc15",
+    orange: "#fb923c",
+    pink: "#f472b6",
+};
+export const PROJECT_COLOR_KEYS = Object.keys(PROJECT_COLORS);
+// Entity theme colors - used for header action buttons and view accents
+export const ENTITY_COLORS = {
+    loop: "#38bdf8", // cyan/blue
+    task: "#a78bfa", // purple
+    project: "#34d399", // green
+};
+export const WIZARD_LOOP_REQUIRED_STEPS = 3;
+export const WIZARD_LOOP_TOTAL_STEPS = 7;
+export const WIZARD_TASK_REQUIRED_STEPS = 2;
+export const WIZARD_TASK_TOTAL_STEPS = 4;
+export const WIZARD_PROJECT_REQUIRED_STEPS = 1;
+export const WIZARD_PROJECT_TOTAL_STEPS = 2;
+export const COMMAND_TIER_ACTION = "action";
+export const COMMAND_TIER_CONFIRM = "confirm";
+export const COMMAND_TIER_GLOBAL = "global";
+export const COMMAND_CATEGORY_GLOBAL = "global";
+export const COMMAND_CATEGORY_FILTERS = "filters";
+export const COMMAND_CATEGORY_LOOP = "loop";
+export const COMMAND_CATEGORY_TASK = "task";
+export const COMMAND_CATEGORY_PROJECT = "project";
+export const CONFIRM_YES = "yes";
+export const CONFIRM_CANCEL = "cancel";
+export const PANEL_LEFT = "left";
+export const PANEL_RIGHT = "right";
+export const COMMAND_TEMPLATES = [
+    { label: "npm run", command: "npm", args: "run" },
+    { label: "npm test", command: "npm", args: "test" },
+    { label: "pnpm build", command: "pnpm", args: "build" },
+    { label: "pnpm test", command: "pnpm", args: "test" },
+    { label: "yarn build", command: "yarn", args: "build" },
+    { label: "dotnet build", command: "dotnet", args: "build" },
+    { label: "dotnet test", command: "dotnet", args: "test" },
+    { label: "docker compose up", command: "docker", args: "compose up" },
+    { label: "make", command: "make", args: "" },
+    { label: "shell script", command: "bash", args: "./script.sh" },
+];
+export const COMMAND_INPUT_HEIGHT = 6;
+export const COMMAND_INPUT_DROPDOWN_MAX_VISIBLE = 6;
+export const HTTP_API_PORT = 8845;
+export const HTTP_API_HOST = "127.0.0.1";
+export const EXPORT_MAX_PREVIEW_LINES = 200;
+export const CTRL_SHORTCUT_EDIT = "Ctrl+E";
+export const CTRL_SHORTCUT_DELETE = "Ctrl+D";
+export const CODE_EDITOR_MAX_VISIBLE = 2;
+export const CODE_EDITOR_MODAL_HEIGHT = 40;
+export const CODE_EDITOR_MODAL_WIDTH = 120;
+export const CODE_EDITOR_WRAP_LENGTH = 80;
+export const CODE_EDITOR_UNDO_LIMIT = 50;
+export const CODE_EDITOR_SYNTAX_COLORS = {
+    flag: "#38bdf8",
+    string: "#4ade80",
+    operator: "#facc15",
+    word: "#e5e7eb",
+};

package/dist/shared/config/paths.js

@@ -0,0 +1,67 @@
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+export function getDataDir() {
+    const override = process.env.LOOP_CLI_HOME;
+    const base = override && override.trim() ? override : os.homedir();
+    return path.join(base, ".loop-cli");
+}
+export function getLoopsDir() {
+    return path.join(getDataDir(), "loops");
+}
+export function getTasksDir() {
+    return path.join(getDataDir(), "tasks");
+}
+export function getLogsDir() {
+    return path.join(getDataDir(), "logs");
+}
+export function loopFile(id) {
+    return path.join(getLoopsDir(), `${id}.json`);
+}
+export function taskFile(id) {
+    return path.join(getTasksDir(), `${id}.json`);
+}
+export function loopsJson() {
+    return path.join(getDataDir(), "loops.json");
+}
+export function tasksJson() {
+    return path.join(getDataDir(), "tasks.json");
+}
+export function recipeRuntimeJson() {
+    return path.join(getDataDir(), "recipe-runtime.json");
+}
+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`);
+}
+export function getPidFile() {
+    return path.join(getDataDir(), "daemon.pid");
+}
+export function getSignatureFile() {
+    return path.join(getDataDir(), "daemon.sig");
+}
+export function getDaemonStartLockFile() {
+    return path.join(getDataDir(), "daemon.start.lock");
+}
+export function getDaemonLogFile() {
+    return path.join(getDataDir(), "daemon.log");
+}
+export function getBoardLogFile() {
+    return path.join(getDataDir(), "board.log");
+}
+export function getSocketPath() {
+    const suffix = crypto
+        .createHash("sha1")
+        .update(getDataDir())
+        .digest("hex")
+        .slice(0, 12);
+    if (process.platform === "win32") {
+        return `\\\\.\\pipe\\loop-cli-${os.userInfo().username}-${suffix}`;
+    }
+    return path.join(getDataDir(), `daemon-${suffix}.sock`);
+}

package/dist/shared/container/index.js

@@ -0,0 +1,24 @@
+import { Container } from "inversify";
+import { TYPES } from "../services/types.js";
+import { IpcLoopService } from "../services/loop-service.js";
+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);
+        const projectService = container.get(TYPES.ProjectService);
+        return new IpcExportService(loopService, taskService, projectService);
+    });
+    return container;
+}
+export const container = createContainer();

package/dist/shared/fs-utils.js

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+// On Windows, renaming over a file that another handle has open (e.g. the
+// daemon's own fs.watch on loops.json) can transiently fail with EPERM/EBUSY.
+// Retry the rename a few times before falling back to a direct (non-atomic)
+// write so a momentary lock can't take the daemon down.
+const RENAME_RETRIES = 5;
+const RENAME_BACKOFF_MS = 15;
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+export function removeIfExists(filePath) {
+    if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+    }
+}
+export function writeFileAtomic(filePath, data) {
+    const tmp = `${filePath}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, data);
+    let lastErr;
+    for (let attempt = 0; attempt < RENAME_RETRIES; attempt++) {
+        try {
+            fs.renameSync(tmp, filePath);
+            return;
+        }
+        catch (err) {
+            lastErr = err;
+            const code = err.code;
+            if (code !== "EPERM" && code !== "EBUSY" && code !== "EACCES")
+                break;
+            sleepSync(RENAME_BACKOFF_MS * (attempt + 1));
+        }
+    }
+    // Fallback: the destination stayed locked. Write in place (non-atomic) so
+    // state is still persisted; a partial write is recoverable since corrupt
+    // JSON is skipped on load, whereas a crash-looping daemon is not.
+    try {
+        fs.writeFileSync(filePath, data);
+        fs.rmSync(tmp, { force: true });
+    }
+    catch {
+        fs.rmSync(tmp, { force: true });
+        throw lastErr;
+    }
+}

package/dist/shared/hooks/useBreakpoint.js

@@ -0,0 +1,11 @@
+import { useStdout } from "ink";
+import { BOARD_BREAKPOINT_COMPACT, BOARD_BREAKPOINT_WIDE } from "../config/constants.js";
+export function useBreakpoint() {
+    const { stdout } = useStdout();
+    const width = stdout?.columns ?? 80;
+    if (width >= BOARD_BREAKPOINT_WIDE)
+        return "wide";
+    if (width >= BOARD_BREAKPOINT_COMPACT)
+        return "compact";
+    return "minimal";
+}

package/dist/shared/hooks/useDaemonSettings.js

@@ -0,0 +1,41 @@
+import { useEffect, useState } from "react";
+import { useInject } from "./useInject.js";
+import { TYPES } from "../services/types.js";
+import { POLL_MS } from "../config/constants.js";
+export function useDaemonSettings() {
+    const settingsService = useInject(TYPES.SettingsService);
+    const [state, setState] = useState({
+        httpApiEnabled: false,
+        mcpApiEnabled: false,
+        telemetryEnabled: false,
+        reachable: false,
+    });
+    useEffect(() => {
+        let cancelled = false;
+        const poll = async () => {
+            try {
+                const settings = await settingsService.getSettings();
+                if (!cancelled) {
+                    setState({
+                        httpApiEnabled: settings.httpApiEnabled,
+                        mcpApiEnabled: settings.mcpApiEnabled,
+                        telemetryEnabled: settings.telemetryEnabled,
+                        reachable: true,
+                    });
+                }
+            }
+            catch {
+                if (!cancelled) {
+                    setState((prev) => ({ ...prev, reachable: false }));
+                }
+            }
+        };
+        void poll();
+        const timer = setInterval(() => void poll(), POLL_MS);
+        return () => {
+            cancelled = true;
+            clearInterval(timer);
+        };
+    }, [settingsService]);
+    return state;
+}

package/dist/shared/hooks/useInject.js

@@ -0,0 +1,6 @@
+import { useContext } from "react";
+import { InversifyContext } from "../providers/InversifyProvider.js";
+export function useInject(identifier) {
+    const { container } = useContext(InversifyContext);
+    return container.get(identifier);
+}

package/dist/shared/hooks/useLogStream.js

@@ -0,0 +1,37 @@
+import { useEffect, useRef, useState } from "react";
+import { useInject } from "./useInject.js";
+import { TYPES } from "../services/types.js";
+import { t } from "../i18n/index.js";
+import { LOG_LINES_MAX } from "../config/constants.js";
+import { appendClamped } from "../utils/log-lines.js";
+export function useLogStream(selectedId, view, onError) {
+    const injectedLogService = useInject(TYPES.LogService);
+    const logServiceRef = useRef(injectedLogService);
+    const logService = logServiceRef.current;
+    const [logLines, setLogLines] = useState([]);
+    const logSocket = useRef(null);
+    useEffect(() => {
+        logSocket.current?.destroy();
+        logSocket.current = null;
+        setLogLines([]);
+        if (!selectedId || view !== "board") {
+            return;
+        }
+        setLogLines([t("board.logWaiting")]);
+        const socket = logService.streamLogs(selectedId, (line) => setLogLines((prev) => {
+            const next = prev[0] === t("board.logWaiting") ? [] : prev;
+            return appendClamped(next, line, LOG_LINES_MAX);
+        }), onError);
+        logSocket.current = socket;
+        return () => {
+            socket.destroy();
+            if (logSocket.current === socket) {
+                logSocket.current = null;
+            }
+        };
+    }, [selectedId, view, logService]);
+    return {
+        logLines,
+        destroy: () => logSocket.current?.destroy(),
+    };
+}