@trevonistrevon/pi-loop 0.1.0

package/dist/loop-parse.js

@@ -0,0 +1,150 @@
+const UNIT_TO_CRON = {
+    s: 1,
+    m: 60,
+    h: 3600,
+    d: 86400,
+};
+const COMMON_INTERVALS = {
+    60: "*/1 * * * *",
+    120: "*/2 * * * *",
+    300: "*/5 * * * *",
+    600: "*/10 * * * *",
+    900: "*/15 * * * *",
+    1800: "*/30 * * * *",
+    3600: "0 * * * *",
+    7200: "0 */2 * * *",
+    10800: "0 */3 * * *",
+    14400: "0 */4 * * *",
+    21600: "0 */6 * * *",
+    28800: "0 */8 * * *",
+    43200: "0 */12 * * *",
+    86400: "0 0 * * *",
+};
+function roundToNearestCommon(seconds) {
+    const keys = Object.keys(COMMON_INTERVALS).map(Number).sort((a, b) => a - b);
+    let best = keys[0];
+    for (const k of keys) {
+        if (Math.abs(k - seconds) < Math.abs(best - seconds))
+            best = k;
+    }
+    const mins = best / 60;
+    let description;
+    if (mins < 60) {
+        description = `${mins} minute${mins !== 1 ? "s" : ""}`;
+    }
+    else {
+        const hrs = mins / 60;
+        if (hrs % 24 === 0) {
+            const days = hrs / 24;
+            description = `${days} day${days !== 1 ? "s" : ""}`;
+        }
+        else {
+            description = `${hrs} hour${hrs !== 1 ? "s" : ""}`;
+        }
+    }
+    return { cron: COMMON_INTERVALS[best], description };
+}
+function isFullCron(expr) {
+    const parts = expr.trim().split(/\s+/);
+    return parts.length === 5;
+}
+export function parseInterval(input) {
+    const trimmed = input.trim();
+    if (isFullCron(trimmed)) {
+        return { cron: trimmed, description: `cron: ${trimmed}` };
+    }
+    const match = trimmed.match(/^(\d+)\s*(s|m|h|d)$/i);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const unit = match[2].toLowerCase();
+        const totalSec = value * (UNIT_TO_CRON[unit] ?? 60);
+        if (totalSec < 60) {
+            return { cron: `*/1 * * * *`, description: `${totalSec} seconds (rounded to 1 minute)` };
+        }
+        return roundToNearestCommon(totalSec);
+    }
+    throw new Error(`Cannot parse interval "${input}". Use formats like "5m", "2h", "1d", or a full cron expression.`);
+}
+export function cronToNextFire(cronExpr, fromDate = new Date()) {
+    const parts = cronExpr.trim().split(/\s+/);
+    if (parts.length !== 5)
+        throw new Error(`Invalid cron expression: ${cronExpr}`);
+    const [minF, hourF, dayF, monthF, dowF] = parts;
+    const now = new Date(fromDate);
+    now.setSeconds(0, 0);
+    for (let minutesAdvanced = 1; minutesAdvanced < 525600; minutesAdvanced++) {
+        now.setMinutes(now.getMinutes() + 1);
+        if (!cronFieldMatches(minF, now.getMinutes()))
+            continue;
+        if (!cronFieldMatches(hourF, now.getHours()))
+            continue;
+        if (!cronFieldMatches(dayF, now.getDate()))
+            continue;
+        if (!cronFieldMatches(monthF, now.getMonth() + 1))
+            continue;
+        if (!cronFieldMatches(dowF, now.getDay()))
+            continue;
+        return new Date(now);
+    }
+    throw new Error(`No matching time found for cron expression: ${cronExpr}`);
+}
+function cronFieldMatches(field, value) {
+    if (field === "*")
+        return true;
+    const parts = field.split(",");
+    for (const part of parts) {
+        if (part === "*")
+            return true;
+        if (part.includes("/")) {
+            const [range, stepStr] = part.split("/");
+            const step = parseInt(stepStr, 10);
+            let rangeMin;
+            let rangeMax;
+            if (range === "*") {
+                rangeMin = 0;
+                rangeMax = 59;
+            }
+            else if (range.includes("-")) {
+                const [minS, maxS] = range.split("-");
+                rangeMin = parseInt(minS, 10);
+                rangeMax = parseInt(maxS, 10);
+            }
+            else {
+                continue;
+            }
+            let v = rangeMin;
+            while (v <= rangeMax) {
+                if (v === value)
+                    return true;
+                v += step;
+            }
+            continue;
+        }
+        if (part.includes("-")) {
+            const [minS, maxS] = part.split("-");
+            const min = parseInt(minS, 10);
+            const max = parseInt(maxS, 10);
+            if (value >= min && value <= max)
+                return true;
+            continue;
+        }
+        if (parseInt(part, 10) === value)
+            return true;
+    }
+    return false;
+}
+export function computeJitter(taskId, recurring, scheduleMinutes) {
+    let hash = 0;
+    for (let i = 0; i < taskId.length; i++) {
+        hash = ((hash << 5) - hash) + taskId.charCodeAt(i);
+        hash |= 0;
+    }
+    const normalized = Math.abs(hash % 10000) / 10000;
+    if (recurring && scheduleMinutes <= 30) {
+        return Math.floor(normalized * (scheduleMinutes / 2) * 60 * 1000);
+    }
+    if (recurring) {
+        return Math.floor(normalized * 30 * 60 * 1000);
+    }
+    return Math.floor(normalized * 90 * 1000);
+}

package/dist/monitor-manager.d.ts

@@ -0,0 +1,13 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { MonitorEntry, MonitorProcess } from "./types.js";
+export declare class MonitorManager {
+    private pi;
+    private processes;
+    private nextId;
+    constructor(pi: ExtensionAPI);
+    create(command: string, description?: string, timeout?: number): MonitorEntry;
+    get(id: string): MonitorEntry | undefined;
+    list(): MonitorEntry[];
+    stop(id: string): Promise<boolean>;
+    getProcess(id: string): MonitorProcess | undefined;
+}

package/dist/monitor-manager.js

@@ -0,0 +1,137 @@
+import { spawn } from "node:child_process";
+export class MonitorManager {
+    pi;
+    processes = new Map();
+    nextId = 1;
+    constructor(pi) {
+        this.pi = pi;
+    }
+    create(command, description, timeout = 300000) {
+        const id = String(this.nextId++);
+        const entry = {
+            id,
+            command,
+            description,
+            timeout,
+            status: "running",
+            startedAt: Date.now(),
+            outputLines: 0,
+        };
+        const abortController = new AbortController();
+        const child = spawn("sh", ["-c", command], {
+            stdio: ["ignore", "pipe", "pipe"],
+            signal: abortController.signal,
+            env: { ...process.env },
+        });
+        const bp = {
+            entry,
+            pid: child.pid,
+            proc: child,
+            abortController,
+            waiters: [],
+        };
+        child.stdout?.on("data", (data) => {
+            const lines = data.toString().split("\n");
+            for (const line of lines) {
+                if (line.length === 0)
+                    continue;
+                entry.outputLines++;
+                this.pi.events.emit("monitor:output", {
+                    monitorId: id,
+                    line,
+                    timestamp: Date.now(),
+                });
+            }
+        });
+        child.stderr?.on("data", (data) => {
+            const lines = data.toString().split("\n");
+            for (const line of lines) {
+                if (line.length === 0)
+                    continue;
+                entry.outputLines++;
+                this.pi.events.emit("monitor:output", {
+                    monitorId: id,
+                    line,
+                    timestamp: Date.now(),
+                });
+            }
+        });
+        const finish = (code, status) => {
+            entry.status = status;
+            entry.exitCode = code ?? undefined;
+            entry.completedAt = Date.now();
+            this.pi.events.emit(status === "completed" ? "monitor:done" : "monitor:error", {
+                monitorId: id,
+                exitCode: code,
+                outputLines: entry.outputLines,
+            });
+            for (const resolve of bp.waiters)
+                resolve();
+            bp.waiters = [];
+        };
+        child.on("close", (code) => {
+            if (entry.status === "running") {
+                finish(code, code === 0 ? "completed" : "error");
+            }
+        });
+        child.on("error", (err) => {
+            if (entry.status === "running") {
+                entry.status = "error";
+                entry.completedAt = Date.now();
+                this.pi.events.emit("monitor:error", {
+                    monitorId: id,
+                    error: err.message,
+                });
+                for (const resolve of bp.waiters)
+                    resolve();
+                bp.waiters = [];
+            }
+        });
+        if (timeout > 0) {
+            setTimeout(() => {
+                if (entry.status === "running") {
+                    this.stop(id);
+                }
+            }, timeout);
+        }
+        this.processes.set(id, bp);
+        return entry;
+    }
+    get(id) {
+        const bp = this.processes.get(id);
+        return bp?.entry;
+    }
+    list() {
+        return Array.from(this.processes.values())
+            .map(bp => bp.entry)
+            .sort((a, b) => Number(a.id) - Number(b.id));
+    }
+    async stop(id) {
+        const bp = this.processes.get(id);
+        if (!bp || bp.entry.status !== "running")
+            return false;
+        bp.entry.status = "stopped";
+        bp.proc.kill("SIGTERM");
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                try {
+                    bp.proc.kill("SIGKILL");
+                }
+                catch { /* already dead */ }
+                resolve();
+            }, 5000);
+            bp.proc.on("close", () => {
+                clearTimeout(timer);
+                resolve();
+            });
+        });
+        bp.entry.completedAt = Date.now();
+        for (const resolve of bp.waiters)
+            resolve();
+        bp.waiters = [];
+        return true;
+    }
+    getProcess(id) {
+        return this.processes.get(id);
+    }
+}

package/dist/scheduler.d.ts

@@ -0,0 +1,15 @@
+import type { LoopStore } from "./store.js";
+import type { LoopEntry } from "./types.js";
+export declare class CronScheduler {
+    private store;
+    private onFire;
+    private timers;
+    private fireTimes;
+    constructor(store: LoopStore, onFire: (entry: LoopEntry) => void);
+    start(): void;
+    stop(): void;
+    add(entry: LoopEntry): void;
+    remove(id: string): void;
+    nextFire(id: string): number | undefined;
+    private armTimer;
+}

package/dist/scheduler.js

@@ -0,0 +1,89 @@
+import { computeJitter, cronToNextFire } from "./loop-parse.js";
+const _MAX_EXPIRY_DAYS = 7;
+function computeNextFire(entry) {
+    if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+        return cronToNextFire(entry.trigger.type === "hybrid" ? entry.trigger.cron : entry.trigger.schedule);
+    }
+    return new Date(Date.now() + 60000);
+}
+export class CronScheduler {
+    store;
+    onFire;
+    timers = new Map();
+    fireTimes = new Map();
+    constructor(store, onFire) {
+        this.store = store;
+        this.onFire = onFire;
+    }
+    start() {
+        for (const entry of this.store.list()) {
+            if (entry.status !== "active")
+                continue;
+            if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+                this.armTimer(entry);
+            }
+        }
+    }
+    stop() {
+        for (const [id, timer] of this.timers) {
+            clearTimeout(timer);
+            this.timers.delete(id);
+            this.fireTimes.delete(id);
+        }
+    }
+    add(entry) {
+        if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+            this.armTimer(entry);
+        }
+    }
+    remove(id) {
+        const timer = this.timers.get(id);
+        if (timer)
+            clearTimeout(timer);
+        this.timers.delete(id);
+        this.fireTimes.delete(id);
+    }
+    nextFire(id) {
+        return this.fireTimes.get(id);
+    }
+    armTimer(entry) {
+        const _scheduleExpr = entry.trigger.type === "hybrid" ? entry.trigger.cron : entry.trigger.schedule;
+        const nextFire = computeNextFire(entry);
+        const jitter = computeJitter(entry.id, entry.recurring, 30);
+        const fireTime = nextFire.getTime() + jitter;
+        const now = Date.now();
+        if (fireTime > entry.expiresAt) {
+            this.store.update(entry.id, { status: "expired" });
+            return;
+        }
+        const delay = Math.max(0, fireTime - now);
+        this.fireTimes.set(entry.id, fireTime);
+        const existing = this.timers.get(entry.id);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            const current = this.store.get(entry.id);
+            if (!current || current.status !== "active") {
+                this.timers.delete(entry.id);
+                this.fireTimes.delete(entry.id);
+                return;
+            }
+            const now2 = Date.now();
+            if (now2 >= current.expiresAt) {
+                this.store.update(entry.id, { status: "expired" });
+                this.timers.delete(entry.id);
+                this.fireTimes.delete(entry.id);
+                return;
+            }
+            this.onFire(current);
+            if (current.recurring) {
+                this.armTimer(current);
+            }
+            else {
+                this.timers.delete(entry.id);
+                this.fireTimes.delete(entry.id);
+            }
+        }, delay);
+        this.timers.set(entry.id, timer);
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,30 @@
+import type { LoopEntry, LoopStatus, Trigger } from "./types.js";
+export declare class LoopStore {
+    private filePath;
+    private lockPath;
+    private nextId;
+    private loops;
+    constructor(listIdOrPath?: string);
+    private load;
+    private save;
+    private withLock;
+    create(trigger: Trigger, prompt: string, opts: {
+        recurring: boolean;
+        autoTask?: boolean;
+        selfPaced?: boolean;
+    }): LoopEntry;
+    get(id: string): LoopEntry | undefined;
+    list(): LoopEntry[];
+    update(id: string, fields: {
+        status?: LoopStatus;
+        trigger?: Trigger;
+        prompt?: string;
+    }): {
+        entry: LoopEntry | undefined;
+        changedFields: string[];
+    };
+    delete(id: string): boolean;
+    clearExpired(): number;
+    clearAll(): number;
+    deleteFileIfEmpty(): boolean;
+}

package/dist/store.js

@@ -0,0 +1,195 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+const LOOPS_DIR = join(homedir(), ".pi", "loops");
+const LOCK_RETRY_MS = 50;
+const LOCK_MAX_RETRIES = 100;
+const MAX_LOOPS = 25;
+const MAX_EXPIRY_DAYS = 7;
+function acquireLock(lockPath) {
+    for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+        try {
+            writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+            return;
+        }
+        catch (e) {
+            if (e.code === "EEXIST") {
+                try {
+                    const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
+                    if (pid && !isProcessRunning(pid)) {
+                        unlinkSync(lockPath);
+                        continue;
+                    }
+                }
+                catch { /* ignore read errors */ }
+                const start = Date.now();
+                while (Date.now() - start < LOCK_RETRY_MS) { /* busy wait */ }
+                continue;
+            }
+            throw e;
+        }
+    }
+    throw new Error(`Failed to acquire lock: ${lockPath}`);
+}
+function releaseLock(lockPath) {
+    try {
+        unlinkSync(lockPath);
+    }
+    catch { /* ignore */ }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export class LoopStore {
+    filePath;
+    lockPath;
+    nextId = 1;
+    loops = new Map();
+    constructor(listIdOrPath) {
+        if (!listIdOrPath)
+            return;
+        const isAbsPath = isAbsolute(listIdOrPath);
+        const filePath = isAbsPath ? listIdOrPath : join(LOOPS_DIR, `${listIdOrPath}.json`);
+        mkdirSync(dirname(filePath), { recursive: true });
+        this.filePath = filePath;
+        this.lockPath = filePath + ".lock";
+        this.load();
+    }
+    load() {
+        if (!this.filePath)
+            return;
+        if (!existsSync(this.filePath))
+            return;
+        try {
+            const data = JSON.parse(readFileSync(this.filePath, "utf-8"));
+            this.nextId = data.nextId;
+            this.loops.clear();
+            for (const loop of data.loops) {
+                this.loops.set(loop.id, loop);
+            }
+        }
+        catch { /* corrupt file — start fresh */ }
+    }
+    save() {
+        if (!this.filePath)
+            return;
+        const data = {
+            nextId: this.nextId,
+            loops: Array.from(this.loops.values()),
+        };
+        const tmpPath = this.filePath + ".tmp";
+        writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+        renameSync(tmpPath, this.filePath);
+    }
+    withLock(fn) {
+        if (!this.lockPath)
+            return fn();
+        acquireLock(this.lockPath);
+        try {
+            this.load();
+            const result = fn();
+            this.save();
+            return result;
+        }
+        finally {
+            releaseLock(this.lockPath);
+        }
+    }
+    create(trigger, prompt, opts) {
+        return this.withLock(() => {
+            if (this.loops.size >= MAX_LOOPS) {
+                throw new Error(`Maximum of ${MAX_LOOPS} loops reached. Delete some before creating new ones.`);
+            }
+            const now = Date.now();
+            const entry = {
+                id: String(this.nextId++),
+                prompt,
+                trigger,
+                status: "active",
+                recurring: opts.recurring,
+                autoTask: opts.autoTask,
+                selfPaced: opts.selfPaced,
+                createdAt: now,
+                updatedAt: now,
+                expiresAt: now + MAX_EXPIRY_DAYS * 24 * 60 * 60 * 1000,
+            };
+            this.loops.set(entry.id, entry);
+            return entry;
+        });
+    }
+    get(id) {
+        if (this.filePath)
+            this.load();
+        return this.loops.get(id);
+    }
+    list() {
+        if (this.filePath)
+            this.load();
+        return Array.from(this.loops.values()).sort((a, b) => Number(a.id) - Number(b.id));
+    }
+    update(id, fields) {
+        return this.withLock(() => {
+            const entry = this.loops.get(id);
+            if (!entry)
+                return { entry: undefined, changedFields: [] };
+            const changedFields = [];
+            if (fields.status !== undefined) {
+                entry.status = fields.status;
+                changedFields.push("status");
+            }
+            if (fields.trigger !== undefined) {
+                entry.trigger = fields.trigger;
+                changedFields.push("trigger");
+            }
+            if (fields.prompt !== undefined) {
+                entry.prompt = fields.prompt;
+                changedFields.push("prompt");
+            }
+            entry.updatedAt = Date.now();
+            return { entry, changedFields };
+        });
+    }
+    delete(id) {
+        return this.withLock(() => {
+            if (!this.loops.has(id))
+                return false;
+            this.loops.delete(id);
+            return true;
+        });
+    }
+    clearExpired() {
+        return this.withLock(() => {
+            const now = Date.now();
+            let count = 0;
+            for (const [id, entry] of this.loops) {
+                if (now >= entry.expiresAt) {
+                    this.loops.delete(id);
+                    count++;
+                }
+            }
+            return count;
+        });
+    }
+    clearAll() {
+        return this.withLock(() => {
+            const count = this.loops.size;
+            this.loops.clear();
+            return count;
+        });
+    }
+    deleteFileIfEmpty() {
+        if (!this.filePath || this.loops.size > 0)
+            return false;
+        try {
+            unlinkSync(this.filePath);
+        }
+        catch { /* ignore */ }
+        return true;
+    }
+}

package/dist/trigger-system.d.ts

@@ -0,0 +1,19 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { CronScheduler } from "./scheduler.js";
+import type { LoopEntry } from "./types.js";
+export declare class TriggerSystem {
+    private pi;
+    private scheduler;
+    private eventSubscriptions;
+    private hybridTimers;
+    private lastFireTime;
+    constructor(pi: ExtensionAPI, scheduler: CronScheduler);
+    start(): void;
+    stop(): void;
+    add(entry: LoopEntry): void;
+    remove(id: string): void;
+    private subscribeEvent;
+    private handleHybridFire;
+    private fireLoop;
+    private matchesFilter;
+}