loop-task 1.4.5 → 1.4.7

package/README.md

@@ -50,6 +50,8 @@ loop-task                          # open the board (requires Bun)
 loop-task start                    # start the daemon, restore persisted loops
 loop-task new 30m -- npm test      # create a background loop
 loop-task run --now 10s -- echo hi # run a loop in the foreground
+loop-task stop <id>                # stop a frozen loop and kill its child process
+loop-task restart                  # kill daemon + all loops, restart fresh
 ```
 
 Or run it directly:
@@ -137,6 +139,8 @@ Colors can be a name (`white`, `cyan`, `green`, `yellow`, `orange`, `pink`) or a
 | `loop-task new <interval> -- <command>` | Create a background loop (creates an inline task) |
 | `loop-task new <interval> --project <name> -- <command>` | Create a loop assigned to a project |
 | `loop-task run <interval> -- <command>` | Run a loop in the foreground |
+| `loop-task stop <id>` | Stop a loop and interrupt its running child process |
+| `loop-task restart` | Kill the daemon and all running loops, then restart fresh |
 | `loop-task project list` | List all projects |
 | `loop-task project new <name> [--color <color>]` | Create a project |
 | `loop-task project rename <id\|name> <new-name>` | Rename a project |

package/dist/board/App.js

@@ -26,7 +26,7 @@ import { ProjectsPage } from "./components/ProjectsPage.js";
 import { fetchRunLog, deleteLoop, pauseLoop, resumeLoop, stopLoop, playLoop, triggerLoop, listTasks, deleteTask, listProjects } from "./daemon.js";
 import { useBreakpoint } from "./hooks/useBreakpoint.js";
 import { useRouter } from "./router.js";
-const BOARD_REFRESH_DELAY_MS = 150;
+import { POLL_MS } from "../config/constants.js";
 const VIEW_TO_MODE = {
     create: "create",
     "task-create": "task",
@@ -117,14 +117,20 @@ export function App(props) {
         }
         catch { /* ignore */ }
     }
-    useState(() => { void refreshTasks(); });
     async function refreshProjects() {
         try {
             setProjects(await listProjects());
         }
         catch { /* ignore */ }
     }
-    useState(() => { void refreshProjects(); });
+    useEffect(() => { void refreshTasks(); void refreshProjects(); }, []);
+    useEffect(() => {
+        const timer = setInterval(() => {
+            void refreshTasks();
+            void refreshProjects();
+        }, POLL_MS);
+        return () => clearInterval(timer);
+    }, []);
     useEffect(() => {
         try {
             localStorage.setItem("loop-current-project", currentProjectId);
@@ -135,7 +141,7 @@ export function App(props) {
         return async () => {
             try {
                 await action();
-                setTimeout(() => { void refresh(); }, BOARD_REFRESH_DELAY_MS);
+                void refresh();
                 pushToast("success", label);
             }
             catch (error) {
@@ -266,7 +272,7 @@ export function App(props) {
         setPendingTaskSelection(null);
         pop();
         pushToast("success", updated ? t("board.toastUpdated", { desc }) : t("board.toastStarted", { desc }));
-        setTimeout(() => { void refresh(); }, BOARD_REFRESH_DELAY_MS);
+        void refresh();
     };
     const onTaskDone = (updated, id) => {
         setEditTask(null);
@@ -309,7 +315,7 @@ export function App(props) {
         onOpenRunLog: handleOpenRunLog,
         refreshTasks,
         onViewTasks: () => { void refreshTasks(); push("task-list"); },
-        onViewProjects: () => push("projects"),
+        onViewProjects: () => { void refreshProjects(); push("projects"); },
         onViewLoops: () => replace("board"),
         onAddLoop: () => { setEditTarget(null); push("create"); },
         onAddTask: () => { setEditTask(null); push("task-create"); },

package/dist/board/components/Navigator.js

@@ -26,9 +26,9 @@ export function Navigator(props) {
     const bulletW = 2;
     const nonVar = 2 + 1 + statusW + 1 + 1 + 1 + exitW + 1 + 1 + runsW + 1 + skpW;
     const avail = Math.floor(panelWidth) - nonVar - bulletW;
-    const descW = Math.min(22, Math.max(6, Math.round(avail * 0.30)));
-    const sinceW = Math.min(14, Math.max(8, Math.round(avail * 0.35)));
-    const timingW = Math.max(6, avail - descW - sinceW);
+    const descW = Math.min(32, Math.max(10, Math.round(avail * 0.38)));
+    const timingW = Math.min(16, Math.max(6, Math.round(avail * 0.25)));
+    const sinceW = Math.max(8, avail - descW - timingW);
     const header = "  " +
         fit("", bulletW) +
         fit(t("board.headerDescription"), descW) +

package/dist/board/hooks/useInputShortcuts.js

@@ -9,33 +9,52 @@ export function useInputShortcuts(getActiveInput) {
             return;
         const name = key.name;
         if (name === "c") {
-            const text = input.getSelectedText();
-            if (text) {
-                copyToClipboard(text);
+            try {
+                const text = input.getSelectedText();
+                if (text) {
+                    copyToClipboard(text);
+                }
+            }
+            catch (e) {
+                console.error(`[loop-task] copy failed: ${e}`);
             }
             key.preventDefault();
+            key.stopPropagation();
             return;
         }
         if (name === "x") {
-            const text = input.getSelectedText();
-            if (text) {
-                copyToClipboard(text);
-                input.deleteSelection();
+            try {
+                const text = input.getSelectedText();
+                if (text) {
+                    copyToClipboard(text);
+                    input.deleteSelection();
+                }
+            }
+            catch (e) {
+                console.error(`[loop-task] cut failed: ${e}`);
             }
             key.preventDefault();
+            key.stopPropagation();
             return;
         }
         if (name === "v") {
-            const text = readFromClipboard();
-            if (text) {
-                input.insertText(text);
+            try {
+                const text = readFromClipboard();
+                if (text) {
+                    input.insertText(text);
+                }
+            }
+            catch (e) {
+                console.error(`[loop-task] paste failed: ${e}`);
             }
             key.preventDefault();
+            key.stopPropagation();
             return;
         }
         if (name === "a") {
             input.selectAll();
             key.preventDefault();
+            key.stopPropagation();
             return;
         }
     });

package/dist/board/toast.js

@@ -46,7 +46,7 @@ export function ToastStack(props) {
     }
     return (_jsx("box", { style: {
             position: "absolute",
-            bottom: 1,
+            bottom: 3,
             right: 2,
             flexDirection: "column",
             alignItems: "flex-end",

package/dist/cli.js

@@ -4,6 +4,7 @@ import { createRequire } from "node:module";
 import { Logger } from "./logger.js";
 import { runLoop } from "./core/foreground-loop.js";
 import { buildLoopOptions } from "./loop-config.js";
+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";
@@ -22,6 +23,49 @@ program
     ensureDaemon();
     console.log(t("cli.daemonStarted"));
 });
+program
+    .command("stop")
+    .description("Stop a running loop and interrupt its current execution")
+    .argument("<id>", "Loop ID")
+    .action(async (id) => {
+    try {
+        const { sendRequest } = await import("./client/ipc.js");
+        const res = await sendRequest({ type: "stop-loop", payload: { id } });
+        if (res.type === "ok" && res.data) {
+            console.log(`Stopped loop ${id}`);
+        }
+        else if (res.type === "error") {
+            console.error(res.message);
+            process.exit(1);
+        }
+        else {
+            console.error(`Loop ${id} not found`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(t("cli.error", { message }));
+        process.exit(1);
+    }
+});
+program
+    .command("restart")
+    .description("Kill the daemon and all running loops, then restart fresh")
+    .action(async () => {
+    const { stopDaemon, ensureDaemon } = await import("./daemon/spawner.js");
+    const { readDaemonPid, removeDaemonPid, removeDaemonSignature } = await import("./daemon/state.js");
+    const pid = readDaemonPid();
+    if (pid !== null) {
+        console.log("Stopping daemon...");
+        stopDaemon(pid);
+        removeDaemonPid();
+        removeDaemonSignature();
+    }
+    console.log("Starting fresh daemon...");
+    ensureDaemon();
+    console.log("Daemon restarted.");
+});
 program
     .command("new")
     .description(t("cli.newDescription"))
@@ -32,17 +76,20 @@ program
     .option("--verbose", t("cli.optVerbose"), false)
     .option("--cwd <dir>", t("cli.optCwd"))
     .option("--project <name>", t("cli.optProject"))
+    .option("--offset <duration>", "Phase offset (e.g. 5m, 15m)")
     .action(async (intervalStr, cmdArgs, opts) => {
     try {
         const projectId = opts.project
             ? await resolveProjectId(opts.project)
             : undefined;
+        const offsetMs = opts.offset ? parseDuration(opts.offset) : null;
         const built = buildLoopOptions(intervalStr, {
             ...opts,
             command: cmdArgs[0],
             commandArgs: cmdArgs.slice(1),
             cwd: opts.cwd ?? process.cwd(),
             projectId,
+            offset: offsetMs,
         });
         await startLoop(built.options, built.intervalHuman);
     }

package/dist/core/loop-controller.js

@@ -5,6 +5,7 @@ import { sleep } from "../shared/sleep.js";
 import { SLEEP_CHUNK_MS } from "../config/constants.js";
 import { executeCommand } from "./command-runner.js";
 import { rotateLogIfNeeded } from "./log-rotator.js";
+import { computePhase, alignToPhase } from "./scheduling.js";
 import { t } from "../i18n/index.js";
 export class LoopController extends EventEmitter {
     abortController;
@@ -116,7 +117,11 @@ export class LoopController extends EventEmitter {
         this._resetSchedule = true;
         this._paused = false;
         this._status = "waiting";
-        this.nextRunAt = new Date(Date.now() + this.options.interval).toISOString();
+        const phase = this.options.offset !== null
+            ? this.options.offset
+            : computePhase(this.id, this.options.interval);
+        const delay = alignToPhase(Date.now(), this.options.interval, phase);
+        this.nextRunAt = new Date(Date.now() + delay).toISOString();
         if (this.resumeResolve) {
             this.resumeResolve();
             this.resumeResolve = null;
@@ -274,7 +279,14 @@ export class LoopController extends EventEmitter {
                     }
                 }
                 else if (isFirstRun && !this.options.immediate) {
-                    const completed = await this.waitForDelay(this.options.interval, signal);
+                    const phase = this.options.offset !== null
+                        ? this.options.offset
+                        : computePhase(this.id, this.options.interval);
+                    const delay = alignToPhase(Date.now(), this.options.interval, phase);
+                    if (delay > 0) {
+                        this.nextRunAt = new Date(Date.now() + delay).toISOString();
+                    }
+                    const completed = await this.waitForDelay(delay, signal);
                     if (!completed) {
                         break;
                     }

package/dist/core/scheduling.js

@@ -0,0 +1,12 @@
+export function computePhase(loopId, intervalMs) {
+    let hash = 0;
+    for (let i = 0; i < loopId.length; i++) {
+        hash = ((hash << 5) - hash + loopId.charCodeAt(i)) | 0;
+    }
+    return Math.abs(hash) % intervalMs;
+}
+export function alignToPhase(now, intervalMs, phaseMs) {
+    const elapsed = now % intervalMs;
+    const delay = (phaseMs - elapsed + intervalMs) % intervalMs;
+    return delay;
+}

package/dist/daemon/manager.js

@@ -44,6 +44,7 @@ export class LoopManager {
                 verbose: meta.verbose,
                 description: meta.description ?? "",
                 projectId: meta.projectId ?? "default",
+                offset: meta.offset ?? null,
             };
             const logPath = getLogPath(meta.id);
             const controller = new LoopController(meta.id, options, logPath, this.taskResolver, {
@@ -161,10 +162,19 @@ export class LoopManager {
         const entry = this.loops.get(id);
         if (!entry)
             return false;
-        entry.controller.stopLoop();
+        entry.controller.stopLoop(true);
         this.persist(id, entry.controller, entry.options, entry.intervalHuman);
         return true;
     }
+    stopAllLoops() {
+        let count = 0;
+        for (const [id, entry] of this.loops) {
+            entry.controller.stopLoop(true);
+            this.persist(id, entry.controller, entry.options, entry.intervalHuman);
+            count++;
+        }
+        return count;
+    }
     playLoop(id) {
         const entry = this.loops.get(id);
         if (!entry)
@@ -255,6 +265,7 @@ export class LoopManager {
             remainingDelayMs: runtime.remainingDelayMs,
             pid: process.pid,
             projectId: options.projectId ?? "default",
+            offset: options.offset,
         };
     }
 }

package/dist/daemon/server.js

@@ -112,6 +112,11 @@ export class IpcServer {
                 this.respondOk(socket, this.manager.stopLoop(request.payload.id), request.payload.id);
                 break;
             }
+            case "stop-all": {
+                const count = this.manager.stopAllLoops();
+                send(socket, { type: "ok", data: count });
+                break;
+            }
             case "play-loop": {
                 if (this.manager.isMaxRunsBlocked(request.payload.id)) {
                     send(socket, { type: "error", message: t("errors.maxRunsReached") });

package/dist/daemon/spawner.js

@@ -16,7 +16,7 @@ function currentCodeSignature() {
 function blockingWait(ms) {
     Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
-function stopDaemon(pid) {
+export function stopDaemon(pid) {
     try {
         process.kill(pid, "SIGTERM");
     }

package/dist/loop-config.js

@@ -78,6 +78,7 @@ export function buildLoopOptions(intervalHuman, input = {}) {
             verbose: input.verbose ?? false,
             description,
             projectId: input.projectId ?? "default",
+            offset: input.offset ?? null,
         },
     };
 }

package/package.json

@@ -1,75 +1,74 @@
-{
-  "name": "loop-task",
-  "version": "1.4.5",
-  "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": {
-    "loop-task": "dist/entry.js"
-  },
-  "main": "dist/entry.js",
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json && node -e \"require('fs').copyFileSync('src/entry.js','dist/entry.js'); require('fs').copyFileSync('src/esm-loader.js','dist/esm-loader.js')\"",
-    "prepublishOnly": "npm run build",
-    "start": "node dist/entry.js",
-    "dev": "bun src/cli.ts",
-    "dev:watch": "bun --watch src/cli.ts",
-    "board": "node dist/entry.js",
-    "test": "vitest run --exclude '**/background-cli.test.ts'",
-    "test:all": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage --exclude '**/background-cli.test.ts'",
-    "lint": "eslint src/ tests/",
-    "typecheck": "tsc --noEmit",
-    "release:dry": "npm publish --dry-run",
-    "release": "npm publish"
-  },
-  "keywords": [
-    "cli",
-    "loop",
-    "loop-engineering",
-    "repeat",
-    "interval",
-    "schedule",
-    "timer",
-    "cron",
-    "automation",
-    "automations",
-    "devops",
-    "agent",
-    "ai-agent",
-    "coding-agent",
-    "agent-automation",
-    "claude-code",
-    "codex",
-    "opencode",
-    "background-tasks",
-    "scheduler"
-  ],
-  "author": "Quique Fdez Guerra",
-  "license": "MIT",
-  "engines": {
-    "node": ">=20.0.0"
-  },
-  "dependencies": {
-    "@opentui/core": "^0.4.1",
-    "@opentui/react": "^0.4.1",
-    "commander": "^13.1.0",
-    "execa": "^9.6.0",
-    "ms": "^2.1.3",
-    "react": "^19.2.7"
-  },
-  "devDependencies": {
-    "@types/ms": "^2.1.0",
-    "@types/node": "^22.15.0",
-    "@types/react": "^19.2.17",
-    "@vitest/coverage-v8": "^3.1.0",
-    "eslint": "^9.25.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.8.0",
-    "typescript-eslint": "^8.30.0",
-    "vitest": "^3.1.0"
-  }
+{
+  "name": "loop-task",
+  "version": "1.4.7",
+  "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": {
+    "loop-task": "dist/entry.js"
+  },
+  "main": "dist/entry.js",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "cli",
+    "loop",
+    "loop-engineering",
+    "repeat",
+    "interval",
+    "schedule",
+    "timer",
+    "cron",
+    "automation",
+    "automations",
+    "devops",
+    "agent",
+    "ai-agent",
+    "coding-agent",
+    "agent-automation",
+    "claude-code",
+    "codex",
+    "opencode",
+    "background-tasks",
+    "scheduler"
+  ],
+  "author": "Quique Fdez Guerra",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@opentui/core": "^0.4.1",
+    "@opentui/react": "^0.4.1",
+    "commander": "^13.1.0",
+    "execa": "^9.6.0",
+    "ms": "^2.1.3",
+    "react": "^19.2.7"
+  },
+  "devDependencies": {
+    "@types/ms": "^2.1.0",
+    "@types/node": "^22.15.0",
+    "@types/react": "^19.2.17",
+    "@vitest/coverage-v8": "^3.1.0",
+    "eslint": "^9.25.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.30.0",
+    "vitest": "^3.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node -e \"require('fs').copyFileSync('src/entry.js','dist/entry.js'); require('fs').copyFileSync('src/esm-loader.js','dist/esm-loader.js')\"",
+    "start": "node dist/entry.js",
+    "dev": "bun src/cli.ts",
+    "dev:watch": "bun --watch src/cli.ts",
+    "board": "node dist/entry.js",
+    "test": "vitest run --exclude '**/background-cli.test.ts'",
+    "test:all": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage --exclude '**/background-cli.test.ts'",
+    "lint": "eslint src/ tests/",
+    "typecheck": "tsc --noEmit",
+    "release:dry": "npm publish --dry-run",
+    "release": "npm publish"
+  }
 }