@trevonistrevon/pi-loop 0.1.0

package/src/loop-parse.ts

@@ -0,0 +1,163 @@
+const UNIT_TO_CRON: Record<string, number> = {
+  s: 1,
+  m: 60,
+  h: 3600,
+  d: 86400,
+};
+
+const COMMON_INTERVALS: Record<number, string> = {
+  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: number): { cron: string; description: string } {
+  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: string;
+  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: string): boolean {
+  const parts = expr.trim().split(/\s+/);
+  return parts.length === 5;
+}
+
+export function parseInterval(input: string): { cron: string; description: string } {
+  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: string, fromDate: Date = new Date()): 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: string, value: number): boolean {
+  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: number;
+      let rangeMax: number;
+
+      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: string, recurring: boolean, scheduleMinutes: number): number {
+  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/src/monitor-manager.ts

@@ -0,0 +1,148 @@
+
+import { spawn } from "node:child_process";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { MonitorEntry, MonitorProcess } from "./types.js";
+
+export class MonitorManager {
+  private processes = new Map<string, MonitorProcess>();
+  private nextId = 1;
+
+  constructor(private pi: ExtensionAPI) {}
+
+  create(command: string, description?: string, timeout = 300000): MonitorEntry {
+    const id = String(this.nextId++);
+    const entry: MonitorEntry = {
+      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: MonitorProcess = {
+      entry,
+      pid: child.pid!,
+      proc: child,
+      abortController,
+      waiters: [],
+    };
+
+    child.stdout?.on("data", (data: Buffer) => {
+      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: Buffer) => {
+      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: number | null, status: "completed" | "error") => {
+      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: string): MonitorEntry | undefined {
+    const bp = this.processes.get(id);
+    return bp?.entry;
+  }
+
+  list(): MonitorEntry[] {
+    return Array.from(this.processes.values())
+      .map(bp => bp.entry)
+      .sort((a, b) => Number(a.id) - Number(b.id));
+  }
+
+  async stop(id: string): Promise<boolean> {
+    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<void>((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: string): MonitorProcess | undefined {
+    return this.processes.get(id);
+  }
+}

package/src/scheduler.ts

@@ -0,0 +1,104 @@
+import { computeJitter, cronToNextFire } from "./loop-parse.js";
+import type { LoopStore } from "./store.js";
+import type { LoopEntry } from "./types.js";
+
+const _MAX_EXPIRY_DAYS = 7;
+
+function computeNextFire(entry: LoopEntry): Date {
+  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 {
+  private timers = new Map<string, NodeJS.Timeout>();
+  private fireTimes = new Map<string, number>();
+
+  constructor(
+    private store: LoopStore,
+    private onFire: (entry: LoopEntry) => void,
+  ) {}
+
+  start(): void {
+    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(): void {
+    for (const [id, timer] of this.timers) {
+      clearTimeout(timer);
+      this.timers.delete(id);
+      this.fireTimes.delete(id);
+    }
+  }
+
+  add(entry: LoopEntry): void {
+    if (entry.trigger.type === "cron" || entry.trigger.type === "hybrid") {
+      this.armTimer(entry);
+    }
+  }
+
+  remove(id: string): void {
+    const timer = this.timers.get(id);
+    if (timer) clearTimeout(timer);
+    this.timers.delete(id);
+    this.fireTimes.delete(id);
+  }
+
+  nextFire(id: string): number | undefined {
+    return this.fireTimes.get(id);
+  }
+
+  private armTimer(entry: LoopEntry): void {
+    const _scheduleExpr = entry.trigger.type === "hybrid" ? entry.trigger.cron : (entry.trigger as { schedule: string }).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/src/store.ts

@@ -0,0 +1,189 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import type { LoopEntry, LoopStatus, LoopStoreData, Trigger } from "./types.js";
+
+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: string): void {
+  for (let i = 0; i < LOCK_MAX_RETRIES; i++) {
+    try {
+      writeFileSync(lockPath, `${process.pid}`, { flag: "wx" });
+      return;
+    } catch (e: any) {
+      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: string): void {
+  try { unlinkSync(lockPath); } catch { /* ignore */ }
+}
+
+function isProcessRunning(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch { return false; }
+}
+
+export class LoopStore {
+  private filePath: string | undefined;
+  private lockPath: string | undefined;
+
+  private nextId = 1;
+  private loops = new Map<string, LoopEntry>();
+
+  constructor(listIdOrPath?: string) {
+    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();
+  }
+
+  private load(): void {
+    if (!this.filePath) return;
+    if (!existsSync(this.filePath)) return;
+    try {
+      const data: LoopStoreData = 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 */ }
+  }
+
+  private save(): void {
+    if (!this.filePath) return;
+    const data: LoopStoreData = {
+      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);
+  }
+
+  private withLock<T>(fn: () => T): T {
+    if (!this.lockPath) return fn();
+    acquireLock(this.lockPath);
+    try {
+      this.load();
+      const result = fn();
+      this.save();
+      return result;
+    } finally {
+      releaseLock(this.lockPath);
+    }
+  }
+
+  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; selfPaced?: boolean }): LoopEntry {
+    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: LoopEntry = {
+        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: string): LoopEntry | undefined {
+    if (this.filePath) this.load();
+    return this.loops.get(id);
+  }
+
+  list(): LoopEntry[] {
+    if (this.filePath) this.load();
+    return Array.from(this.loops.values()).sort((a, b) => Number(a.id) - Number(b.id));
+  }
+
+  update(id: string, fields: { status?: LoopStatus; trigger?: Trigger; prompt?: string }): { entry: LoopEntry | undefined; changedFields: string[] } {
+    return this.withLock(() => {
+      const entry = this.loops.get(id);
+      if (!entry) return { entry: undefined, changedFields: [] };
+
+      const changedFields: string[] = [];
+      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: string): boolean {
+    return this.withLock(() => {
+      if (!this.loops.has(id)) return false;
+      this.loops.delete(id);
+      return true;
+    });
+  }
+
+  clearExpired(): number {
+    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(): number {
+    return this.withLock(() => {
+      const count = this.loops.size;
+      this.loops.clear();
+      return count;
+    });
+  }
+
+  deleteFileIfEmpty(): boolean {
+    if (!this.filePath || this.loops.size > 0) return false;
+    try { unlinkSync(this.filePath); } catch { /* ignore */ }
+    return true;
+  }
+}