loop-task 1.5.5 → 2.0.1

package/dist/cli/import-validator.js

@@ -0,0 +1,151 @@
+const PROJECT_FIELDS = [
+    { name: "id", type: "string", nullable: false },
+    { name: "name", type: "string", nullable: false },
+    { name: "color", type: "string", nullable: false },
+    { name: "createdAt", type: "string", nullable: false },
+    { name: "isSystem", type: "boolean", nullable: false },
+    { name: "isDefault", type: "boolean", nullable: false },
+];
+const TASK_FIELDS = [
+    { name: "id", type: "string", nullable: false },
+    { name: "name", type: "string", nullable: false },
+    { name: "command", type: "string", nullable: false },
+    { name: "commandArgs", type: "array", nullable: false },
+    { name: "onSuccessTaskId", type: "string", nullable: true },
+    { name: "onFailureTaskId", type: "string", nullable: true },
+    { name: "createdAt", type: "string", nullable: false },
+];
+const LOOP_FIELDS = [
+    { name: "id", type: "string", nullable: false },
+    { name: "taskId", type: "string", nullable: true },
+    { name: "command", type: "string", nullable: false },
+    { name: "commandArgs", type: "array", nullable: false },
+    { name: "interval", type: "number", nullable: false },
+    { name: "intervalHuman", type: "string", nullable: false },
+    { name: "immediate", type: "boolean", nullable: false },
+    { name: "maxRuns", type: "number", nullable: true },
+    { name: "verbose", type: "boolean", nullable: false },
+    { name: "cwd", type: "string", nullable: false },
+    { name: "description", type: "string", nullable: false },
+    { name: "status", type: "string", nullable: false },
+    { name: "createdAt", type: "string", nullable: false },
+    { name: "sessionStartedAt", type: "string", nullable: true },
+    { name: "runCount", type: "number", nullable: false },
+    { name: "lastRunAt", type: "string", nullable: true },
+    { name: "lastExitCode", type: "number", nullable: true },
+    { name: "lastDuration", type: "number", nullable: true },
+    { name: "nextRunAt", type: "string", nullable: true },
+    { 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: "skippedCount", type: "number", nullable: false },
+    { name: "projectId", type: "string", nullable: false },
+    { name: "offset", type: "number", nullable: true },
+];
+const EXPECTED_VERSION = 2;
+const REQUIRED_KEYS = ["loops", "tasks", "projects"];
+function validateItems(items, fields, label) {
+    const errors = [];
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            errors.push({ key: "item", message: `${label}[${i}]: must be an object` });
+            continue;
+        }
+        const record = item;
+        for (const field of fields) {
+            const value = record[field.name];
+            if (value === undefined || value === null) {
+                if (!field.nullable) {
+                    errors.push({ key: "item", message: `${label}[${i}]: missing field '${field.name}'` });
+                }
+                continue;
+            }
+            if (field.nullable && value === null)
+                continue;
+            switch (field.type) {
+                case "string":
+                    if (typeof value !== "string") {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be a string` });
+                    }
+                    break;
+                case "number":
+                    if (typeof value !== "number") {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be a number` });
+                    }
+                    break;
+                case "boolean":
+                    if (typeof value !== "boolean") {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be a boolean` });
+                    }
+                    break;
+                case "array":
+                    if (!Array.isArray(value)) {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be an array` });
+                    }
+                    break;
+                case "object":
+                    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be an object` });
+                    }
+                    break;
+            }
+        }
+    }
+    return errors;
+}
+export function validateExportFile(raw) {
+    const errors = [];
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return { valid: false, errors: [{ key: "version", message: "Invalid export file: expected a JSON object" }] };
+    }
+    const data = raw;
+    if (!("version" in data)) {
+        return { valid: false, errors: [{ key: "version", message: "Missing export version. Expected: 2" }] };
+    }
+    if (data.version !== EXPECTED_VERSION) {
+        return {
+            valid: false,
+            errors: [{ key: "version", message: `Unsupported export version: ${data.version}. Expected: ${EXPECTED_VERSION}` }],
+        };
+    }
+    const missingKeys = [];
+    const nonArrayKeys = [];
+    for (const key of REQUIRED_KEYS) {
+        if (!(key in data)) {
+            missingKeys.push(key);
+        }
+        else if (!Array.isArray(data[key])) {
+            nonArrayKeys.push(key);
+        }
+    }
+    if (missingKeys.length > 0) {
+        errors.push({ key: "missing_keys", message: `Missing required keys: ${missingKeys.join(", ")}` });
+    }
+    if (nonArrayKeys.length > 0) {
+        for (const key of nonArrayKeys) {
+            errors.push({ key: "non_array_keys", message: `field '${key}' must be an array` });
+        }
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    const itemErrors = [
+        ...validateItems(data.loops, LOOP_FIELDS, "loops"),
+        ...validateItems(data.tasks, TASK_FIELDS, "tasks"),
+        ...validateItems(data.projects, PROJECT_FIELDS, "projects"),
+    ];
+    if (itemErrors.length > 0) {
+        return { valid: false, errors: itemErrors };
+    }
+    return {
+        valid: true,
+        errors: [],
+        data: {
+            loops: data.loops,
+            tasks: data.tasks,
+            projects: data.projects,
+        },
+    };
+}

package/dist/cli/import-writer.js

@@ -0,0 +1,77 @@
+import fs from "node:fs";
+import path from "node:path";
+import { writeFileAtomic } from "../shared/fs-utils.js";
+import { getDataDir } from "../config/paths.js";
+const STORE_FILES = ["loops.json", "tasks.json", "projects.json"];
+function backupFilePath(filePath) {
+    return `${filePath}.bak`;
+}
+export function atomicImportWrite(loops, tasks, projects) {
+    const dataDir = getDataDir();
+    fs.mkdirSync(dataDir, { recursive: true });
+    const contents = {
+        "loops.json": JSON.stringify(loops, null, 2),
+        "tasks.json": JSON.stringify(tasks, null, 2),
+        "projects.json": JSON.stringify(projects, null, 2),
+    };
+    const backups = new Map();
+    for (const store of STORE_FILES) {
+        const storePath = path.join(dataDir, store);
+        if (fs.existsSync(storePath) && fs.statSync(storePath).isFile()) {
+            backups.set(store, fs.readFileSync(storePath, "utf-8"));
+        }
+        else {
+            backups.set(store, null);
+        }
+    }
+    const writtenStores = [];
+    try {
+        for (const store of STORE_FILES) {
+            const storePath = path.join(dataDir, store);
+            writeFileAtomic(storePath, contents[store]);
+            writtenStores.push(store);
+        }
+    }
+    catch (err) {
+        const writeError = err;
+        for (const store of STORE_FILES) {
+            const storePath = path.join(dataDir, store);
+            const backup = backups.get(store) ?? null;
+            if (backup !== null) {
+                try {
+                    writeFileAtomic(storePath, backup);
+                }
+                catch {
+                    // best-effort restore
+                }
+            }
+            else {
+                try {
+                    if (fs.existsSync(storePath) && fs.statSync(storePath).isFile()) {
+                        fs.unlinkSync(storePath);
+                    }
+                }
+                catch {
+                    // best-effort cleanup
+                }
+            }
+        }
+        return {
+            success: false,
+            error: writeError.message,
+            writtenStores,
+        };
+    }
+    for (const store of STORE_FILES) {
+        const bakPath = backupFilePath(path.join(dataDir, store));
+        try {
+            if (fs.existsSync(bakPath)) {
+                fs.unlinkSync(bakPath);
+            }
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+    return { success: true, writtenStores: [...STORE_FILES] };
+}

package/dist/cli.js

@@ -8,6 +8,7 @@ import { parseDuration } from "./duration.js";
 import { startLoop } from "./client/commands.js";
 import { listProjectsCli, createProjectCli, renameProjectCli, setProjectColorCli, deleteProjectCli, resolveProjectId, } from "./client/commands.js";
 import { t } from "./i18n/index.js";
+import { HTTP_API_PORT, HTTP_API_HOST } from "./config/constants.js";
 const require = createRequire(import.meta.url);
 const packageJson = require("../package.json");
 const program = new Command();
@@ -77,6 +78,7 @@ program
     .option("--cwd <dir>", t("cli.optCwd"))
     .option("--project <name>", t("cli.optProject"))
     .option("--offset <duration>", "Phase offset (e.g. 5m, 15m)")
+    .option("--description <desc>", "Description of the loop")
     .action(async (intervalStr, cmdArgs, opts) => {
     try {
         const projectId = opts.project
@@ -90,6 +92,7 @@ program
             cwd: opts.cwd ?? process.cwd(),
             projectId,
             offset: offsetMs,
+            description: opts.description ?? cmdArgs.join(" "),
         });
         await startLoop(built.options, built.intervalHuman);
     }
@@ -108,6 +111,7 @@ program
     .option("--max-runs <n>", t("cli.optMaxRuns"))
     .option("--verbose", t("cli.optVerbose"))
     .option("--cwd <dir>", t("cli.optCwd"))
+    .option("--description <desc>", "Description of the loop")
     .action(async (intervalStr, cmdArgs, opts) => {
     if (!intervalStr || !cmdArgs || cmdArgs.length === 0) {
         program.help();
@@ -119,6 +123,7 @@ program
         command: cmdArgs[0],
         commandArgs: cmdArgs.slice(1),
         cwd: opts.cwd ?? process.cwd(),
+        description: opts.description ?? cmdArgs.join(" "),
     });
     const controller = new AbortController();
     process.on("SIGINT", () => controller.abort());
@@ -165,23 +170,112 @@ projectCmd
     await deleteProjectCli(idOrName);
 });
 program.action(async () => {
-    if (!process.execPath.includes("bun")) {
-        const { spawn } = await import("node:child_process");
-        const child = spawn("bun", [process.argv[1]], {
-            stdio: "inherit",
-            env: { ...process.env },
-            shell: true,
-        });
-        child.on("error", () => {
-            console.error("The board requires the Bun runtime for OpenTUI native FFI.\n" +
-                "Install Bun: npm install -g bun\n" +
-                "Then run: loop-task");
-            process.exit(1);
-        });
-        child.on("exit", (code) => process.exit(code ?? 0));
-        return;
-    }
-    const { launchBoard } = await import("./board/index.js");
+    const { launchBoard } = await import("./tui/index.js");
     await launchBoard();
 });
+program
+    .command("status")
+    .description("Show status of all loops")
+    .option("--json", "Output as JSON")
+    .action(async (opts) => {
+    const { sendRequest } = await import("./client/ipc.js");
+    const response = await sendRequest({ type: "list" });
+    if (response.type !== "ok") {
+        console.error("Failed to get status");
+        process.exit(1);
+    }
+    const loops = response.data;
+    if (opts.json) {
+        console.log(JSON.stringify(loops, null, 2));
+    }
+    else {
+        for (const loop of loops) {
+            const { describeLoop, statusLabel } = await import("./board/format.js");
+            console.log(`${loop.id}  ${statusLabel(loop.status)}  ${describeLoop(loop)}`);
+        }
+    }
+});
+program
+    .command("export")
+    .description("Export all configs to a JSON file (or stdout)")
+    .argument("[file]", "Output file (defaults to stdout)")
+    .action(async (file) => {
+    const { sendRequest } = await import("./client/ipc.js");
+    const [loopsRes, tasksRes, projectsRes] = await Promise.all([
+        sendRequest({ type: "list" }),
+        sendRequest({ type: "task-list" }),
+        sendRequest({ type: "project-list" }),
+    ]);
+    const exportData = {
+        version: 2,
+        exportedAt: new Date().toISOString(),
+        loops: loopsRes.type === "ok" ? loopsRes.data : [],
+        tasks: tasksRes.type === "ok" ? tasksRes.data : [],
+        projects: projectsRes.type === "ok" ? projectsRes.data : [],
+    };
+    const json = JSON.stringify(exportData, null, 2);
+    if (file) {
+        const { writeFile } = await import("node:fs/promises");
+        await writeFile(file, json, "utf-8");
+        console.log(`Exported to ${file}`);
+    }
+    else {
+        console.log(json);
+    }
+});
+program
+    .command("import")
+    .description("Restore a previously exported state file (inverse of loop-task export)")
+    .argument("<file>", "Input file")
+    .action(async (file) => {
+    const { readFile } = await import("node:fs/promises");
+    let content;
+    try {
+        content = await readFile(file, "utf-8");
+    }
+    catch (err) {
+        const e = err;
+        console.error(`Failed to read file: ${e.message}`);
+        process.exit(1);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        console.error("Invalid JSON in import file");
+        process.exit(1);
+    }
+    const { validateExportFile } = await import("./cli/import-validator.js");
+    const result = validateExportFile(parsed);
+    if (!result.valid) {
+        for (const error of result.errors) {
+            console.error(error.message);
+        }
+        process.exit(1);
+    }
+    const { atomicImportWrite } = await import("./cli/import-writer.js");
+    const writeResult = atomicImportWrite(result.data.loops, result.data.tasks, result.data.projects);
+    if (!writeResult.success) {
+        console.error(`Failed to write store: ${writeResult.error}`);
+        if (writeResult.writtenStores.length > 0) {
+            console.error("Rolled back previously written stores.");
+        }
+        process.exit(1);
+    }
+    console.log(`Imported ${result.data.loops.length} loops, ${result.data.tasks.length} tasks, ${result.data.projects.length} projects`);
+    console.log("Daemon will hot-reload automatically.");
+});
+program
+    .command("api")
+    .description("Show HTTP API server info (base URL, Swagger UI, OpenAPI spec)")
+    .action(() => {
+    const port = process.env.LOOP_CLI_HTTP_PORT ?? String(HTTP_API_PORT);
+    const baseUrl = `http://${HTTP_API_HOST}:${port}`;
+    console.log(`HTTP API Server`);
+    console.log(`  Base URL:   ${baseUrl}`);
+    console.log(`  Swagger UI: ${baseUrl}/api/docs`);
+    console.log(`  OpenAPI:    ${baseUrl}/api/openapi.json`);
+    console.log(`  Events:     ${baseUrl}/api/events (SSE)`);
+});
 await program.parseAsync(process.argv);

package/dist/config/constants.js

@@ -13,6 +13,12 @@ export const LOG_TAIL_DEFAULT = 50;
 export const BOARD_BREAKPOINT_WIDTH = 80;
 export const HEADER_COMPACT_WIDTH = 60;
 export const SEARCH_SELECT_HEIGHT = 6;
+// ── Clipboard / bracketed paste ─────────────────────────────────────
+// 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;
 export const HOVER_BG = "#1e3a5f";
 export const PROJECT_COLORS = {
     white: "#ffffff",
@@ -29,3 +35,49 @@ export const ENTITY_COLORS = {
     task: "#a78bfa", // purple
     project: "#34d399", // green
 };
+// ── Wizard step counts ──────────────────────────────────────────────
+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;
+// ── Command tiers ───────────────────────────────────────────────────
+export const COMMAND_TIER_ACTION = "action";
+export const COMMAND_TIER_CONFIRM = "confirm";
+export const COMMAND_TIER_GLOBAL = "global";
+// ── Command categories ─────────────────────────────────────────────
+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";
+// ── Confirm keywords ────────────────────────────────────────────────
+export const CONFIRM_YES = "yes";
+export const CONFIRM_CANCEL = "cancel";
+// ── Panel focus types ───────────────────────────────────────────────
+export const PANEL_LEFT = "left";
+export const PANEL_RIGHT = "right";
+// ── Command builder templates ──────────────────────────────────────
+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" },
+];
+// ── Command input constants ─────────────────────────────────────────
+export const COMMAND_INPUT_HEIGHT = 6;
+export const COMMAND_INPUT_DROPDOWN_MAX_VISIBLE = 6;
+// ── HTTP API server ─────────────────────────────────────────────────
+export const HTTP_API_PORT = 8845;
+export const HTTP_API_HOST = "127.0.0.1";
+// ── Ctrl shortcut hints (for display) ───────────────────────────────
+export const EXPORT_MAX_PREVIEW_LINES = 200;
+export const CTRL_SHORTCUT_EDIT = "Ctrl+E";
+export const CTRL_SHORTCUT_DELETE = "Ctrl+D";

package/dist/daemon/file-watcher.js

@@ -0,0 +1,171 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { loopsJson, tasksJson, projectsJson } from "../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;
+    setManagers(loopManager, taskManager, projectManager) {
+        this.loopManager = loopManager;
+        this.taskManager = taskManager;
+        this.projectManager = projectManager;
+    }
+    start() {
+        this.watch(loopsJson(), (content) => this.handleLoopsChange(content));
+        this.watch(tasksJson(), (content) => this.handleTasksChange(content));
+        this.watch(projectsJson(), (content) => this.handleProjectsChange(content));
+    }
+    stop() {
+        for (const [, entry] of this.watchers) {
+            if (entry.debounceTimer)
+                clearTimeout(entry.debounceTimer);
+        }
+        for (const [, timer] of this.mtimeTimers) {
+            clearInterval(timer);
+        }
+        this.watchers.clear();
+        this.mtimeTimers.clear();
+    }
+    registerSelfWrite(filePath, content) {
+        const hash = this.hash(content);
+        const entry = this.watchers.get(filePath);
+        if (entry) {
+            entry.lastHash = hash;
+        }
+    }
+    watch(filePath, onChange) {
+        const dir = path.dirname(filePath);
+        const basename = path.basename(filePath);
+        this.watchers.set(filePath, {
+            lastHash: "",
+            debounceTimer: null,
+            lastMtime: 0,
+        });
+        try {
+            const initialContent = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : "";
+            this.watchers.get(filePath).lastHash = this.hash(initialContent);
+            this.watchers.get(filePath).lastMtime = fs.statSync(filePath).mtimeMs;
+        }
+        catch {
+            // file doesn't exist yet
+        }
+        try {
+            fs.watch(dir, (eventType, filename) => {
+                if (filename !== basename)
+                    return;
+                this.handleFileEvent(filePath, onChange);
+            });
+        }
+        catch {
+            // fs.watch not available, mtime polling will handle it
+        }
+        const mtimeTimer = setInterval(() => {
+            this.checkMtime(filePath, onChange);
+        }, MTIME_POLL_MS);
+        this.mtimeTimers.set(filePath, mtimeTimer);
+    }
+    handleFileEvent(filePath, onChange) {
+        const entry = this.watchers.get(filePath);
+        if (!entry)
+            return;
+        if (entry.debounceTimer) {
+            clearTimeout(entry.debounceTimer);
+        }
+        entry.debounceTimer = setTimeout(() => {
+            this.processChange(filePath, onChange);
+            entry.debounceTimer = null;
+        }, DEBOUNCE_MS);
+    }
+    checkMtime(filePath, onChange) {
+        const entry = this.watchers.get(filePath);
+        if (!entry)
+            return;
+        try {
+            const stat = fs.statSync(filePath);
+            if (stat.mtimeMs > entry.lastMtime) {
+                entry.lastMtime = stat.mtimeMs;
+                this.handleFileEvent(filePath, onChange);
+            }
+        }
+        catch {
+            // file might not exist
+        }
+    }
+    processChange(filePath, onChange) {
+        const entry = this.watchers.get(filePath);
+        if (!entry)
+            return;
+        let content;
+        try {
+            content = fs.readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return;
+        }
+        const fileHash = this.hash(content);
+        if (fileHash === entry.lastHash) {
+            return;
+        }
+        entry.lastHash = fileHash;
+        try {
+            const stat = fs.statSync(filePath);
+            entry.lastMtime = stat.mtimeMs;
+        }
+        catch {
+            // ignore
+        }
+        try {
+            onChange(content);
+        }
+        catch (error) {
+            console.error(`[file-watcher] Error processing change to ${filePath}:`, error);
+        }
+    }
+    hash(content) {
+        return createHash("sha1").update(content).digest("hex").slice(0, 16);
+    }
+    handleLoopsChange(content) {
+        if (!this.loopManager)
+            return;
+        let newLoops;
+        try {
+            newLoops = JSON.parse(content);
+        }
+        catch {
+            console.error("[file-watcher] Malformed loops.json, keeping old state");
+            return;
+        }
+        this.loopManager.reconcile(newLoops);
+    }
+    handleTasksChange(content) {
+        if (!this.taskManager)
+            return;
+        let newTasks;
+        try {
+            newTasks = JSON.parse(content);
+        }
+        catch {
+            console.error("[file-watcher] Malformed tasks.json, keeping old state");
+            return;
+        }
+        this.taskManager.reload(newTasks);
+    }
+    handleProjectsChange(content) {
+        if (!this.projectManager)
+            return;
+        let newProjects;
+        try {
+            newProjects = JSON.parse(content);
+        }
+        catch {
+            console.error("[file-watcher] Malformed projects.json, keeping old state");
+            return;
+        }
+        this.projectManager.reload(newProjects);
+    }
+}