@trevonistrevon/pi-loop 0.2.5 → 0.2.7

package/dist/index.js

@@ -120,6 +120,7 @@ export default function (pi) {
             prompt: entry.prompt,
             trigger: entry.trigger,
             timestamp: Date.now(),
+            readOnly: entry.readOnly,
         });
     }
     // ── Session lifecycle ──
@@ -178,7 +179,12 @@ export default function (pi) {
         showPersistedLoops(isResume);
     });
     // ── Loop fire handler — sends a user message to re-wake the agent ──
-    pi.events.on("loop:fire", (data) => {
+    pi.events.on("loop:fire", (event) => {
+        const data = event;
+        if (_latestCtx?.hasPendingMessages()) {
+            debug(`loop:fire #${data.loopId} — agent has pending messages, skipping`);
+            return;
+        }
         const triggerInfo = typeof data.trigger === "string"
             ? data.trigger
             : data.trigger?.type === "cron"
@@ -186,13 +192,13 @@ export default function (pi) {
                 : data.trigger?.type === "event"
                     ? `event: ${data.trigger.source}`
                     : `hybrid`;
+        const loopId = data.loopId || "?";
         const prompt = data.prompt || "loop fired";
+        const constraint = data.readOnly ? "\n\nREAD-ONLY MODE — use only read tools (Read, TaskList, LoopList, MonitorList, LoopCreate, etc.). No file writes, shell execution, or destructive changes." : "";
         const message = [
-            `[pi-loop] Loop #${data.loopId || "?"} fired (${triggerInfo}).`,
+            `[pi-loop] Loop #${loopId} fired (${triggerInfo}).${constraint}`,
             prompt,
         ].join("\n");
-        // deliverAs: "followUp" queues the message when the agent is busy;
-        // it delivers after the current turn finishes.
         pi.sendUserMessage(message, { deliverAs: "followUp" });
     });
     // ──────────────────────────────────────────────────
@@ -230,7 +236,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
 - **prompt**: what to do when the loop fires (e.g., "check if the build passed")
 - **recurring**: repeat or fire once (default: true)
 - **autoTask**: if pi-tasks is loaded, auto-create a task on each fire
-- **triggerType**: "cron", "event", or "hybrid" (inferred if omitted)`,
+- **readOnly**: restrict the agent to read-only tools when this loop fires (default: false)`,
         promptGuidelines: [
             "When the user asks for a loop, repeating task, periodic check, or scheduled reminder, use LoopCreate — not raw Bash for/sleep/while.",
             "Use LoopCreate for any 'every X seconds/minutes/hours' requests.",
@@ -244,9 +250,10 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
             autoTask: Type.Optional(Type.Boolean({ description: "Auto-create pi-tasks task on fire", default: false })),
             triggerType: Type.Optional(Type.String({ description: "cron, event, or hybrid (inferred from trigger string if omitted)", enum: ["cron", "event", "hybrid"] })),
             debounceMs: Type.Optional(Type.Number({ description: "Debounce for hybrid triggers (default: 30000)", default: 30000 })),
+            readOnly: Type.Optional(Type.Boolean({ description: "Restrict the agent to read-only tools when this loop fires (default: false)", default: false })),
         }),
         execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            const { trigger: triggerInput, prompt, recurring, autoTask, triggerType, debounceMs } = params;
+            const { trigger: triggerInput, prompt, recurring, autoTask, triggerType, debounceMs, readOnly } = params;
             let trigger;
             const inferred = triggerType ?? inferTriggerType(triggerInput);
             if (inferred === "cron") {
@@ -267,10 +274,14 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
                     debounceMs: debounceMs ?? 30000,
                 };
             }
+            const validationError = validateTrigger(trigger);
+            if (validationError)
+                return Promise.resolve(textResult(validationError));
             const entry = store.create(trigger, prompt, {
                 recurring: recurring ?? (inferred !== "event"),
                 autoTask,
                 selfPaced: triggerInput === "self-paced" || prompt.toLowerCase().includes("self-paced"),
+                readOnly,
             });
             triggerSystem.add(entry);
             widget.update();
@@ -287,6 +298,29 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
                 `ID: ${entry.id} (use LoopDelete to cancel)`));
         },
     });
+    function validateTrigger(trigger) {
+        if (trigger.type === "cron") {
+            const parts = trigger.schedule.trim().split(/\s+/);
+            if (parts.length !== 5) {
+                return `Invalid cron trigger. Expected 5 fields, got ${parts.length}: "${trigger.schedule}". Use formats like "5m", "1h", "0 9 * * 1-5", or set triggerType to "event" for event sources.`;
+            }
+        }
+        else if (trigger.type === "event") {
+            if (!trigger.source || trigger.source.trim().length === 0) {
+                return `Invalid event trigger. Event source must be non-empty (e.g., "tool_execution_start").`;
+            }
+        }
+        else if (trigger.type === "hybrid") {
+            const cronParts = trigger.cron.trim().split(/\s+/);
+            if (cronParts.length !== 5) {
+                return `Invalid hybrid trigger. Cron part must have 5 fields, got ${cronParts.length}: "${trigger.cron}".`;
+            }
+            if (!trigger.event.source || trigger.event.source.trim().length === 0) {
+                return `Invalid hybrid trigger. Event source must be non-empty (e.g., "tool_execution_start").`;
+            }
+        }
+        return null;
+    }
     function inferTriggerType(input) {
         if (input.includes("hybrid") || (input.includes("cron") && input.includes("event")))
             return "hybrid";

package/dist/store.d.ts

@@ -12,6 +12,7 @@ export declare class LoopStore {
         recurring: boolean;
         autoTask?: boolean;
         selfPaced?: boolean;
+        readOnly?: boolean;
     }): LoopEntry;
     get(id: string): LoopEntry | undefined;
     list(): LoopEntry[];

package/dist/store.js

@@ -16,8 +16,11 @@ function acquireLock(lockPath) {
             if (e.code === "EEXIST") {
                 try {
                     const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
-                    if (pid && !isProcessRunning(pid)) {
-                        unlinkSync(lockPath);
+                    if (!pid || !isProcessRunning(pid)) {
+                        try {
+                            unlinkSync(lockPath);
+                        }
+                        catch { /* ignore */ }
                         continue;
                     }
                 }
@@ -115,6 +118,7 @@ export class LoopStore {
                 recurring: opts.recurring,
                 autoTask: opts.autoTask,
                 selfPaced: opts.selfPaced,
+                readOnly: opts.readOnly,
                 createdAt: now,
                 updatedAt: now,
                 expiresAt: now + MAX_EXPIRY_DAYS * 24 * 60 * 60 * 1000,

package/dist/types.d.ts

@@ -29,6 +29,7 @@ export interface LoopEntry {
     expiresAt: number;
     autoTask?: boolean;
     selfPaced?: boolean;
+    readOnly?: boolean;
 }
 export interface LoopStoreData {
     nextId: number;

package/dist/ui/widget.d.ts

@@ -1,15 +1,7 @@
+import type { ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import type { MonitorManager } from "../monitor-manager.js";
 import type { CronScheduler } from "../scheduler.js";
 import type { LoopStore } from "../store.js";
-export type UICtx = {
-    setStatus(key: string, text: string | undefined): void;
-    setWidget(key: string, content: undefined | ((tui: any, theme: any) => {
-        render(): string[];
-        invalidate(): void;
-    }), options?: {
-        placement?: "aboveEditor" | "belowEditor";
-    }): void;
-};
 export declare class LoopWidget {
     private store;
     private scheduler;
@@ -19,7 +11,7 @@ export declare class LoopWidget {
     private widgetRegistered;
     private interval;
     constructor(store: LoopStore, scheduler: CronScheduler | undefined, monitorManager: MonitorManager);
-    setUICtx(ctx: UICtx): void;
+    setUICtx(ctx: ExtensionUIContext): void;
     setStore(store: LoopStore): void;
     setScheduler(scheduler: CronScheduler): void;
     update(): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trevonistrevon/pi-loop",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "A pi extension for cron/event-based agent re-wake loops and background process monitoring.",
   "author": "trevonistrevon",
   "license": "MIT",

package/src/index.ts

@@ -16,7 +16,7 @@
 
 import { randomUUID } from "node:crypto";
 import { join, resolve } from "node:path";
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, ExtensionUIContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { parseInterval } from "./loop-parse.js";
 import { MonitorManager } from "./monitor-manager.js";
@@ -24,7 +24,7 @@ import { CronScheduler } from "./scheduler.js";
 import { LoopStore } from "./store.js";
 import { TriggerSystem } from "./trigger-system.js";
 import type { LoopEntry, Trigger } from "./types.js";
-import { LoopWidget, type UICtx } from "./ui/widget.js";
+import { LoopWidget } from "./ui/widget.js";
 
 const DEBUG = !!process.env.PI_LOOP_DEBUG;
 function debug(...args: unknown[]) {
@@ -35,6 +35,18 @@ function textResult(msg: string) {
   return { content: [{ type: "text" as const, text: msg }], details: undefined as any };
 }
 
+interface LoopFireEvent {
+  loopId: string;
+  prompt: string;
+  trigger: Trigger | string;
+  timestamp: number;
+  readOnly?: boolean;
+}
+
+interface SessionSwitchEvent {
+  reason?: string;
+}
+
 
 export default function (pi: ExtensionAPI) {
   const piLoopEnv = process.env.PI_LOOP;
@@ -123,6 +135,7 @@ export default function (pi: ExtensionAPI) {
       prompt: entry.prompt,
       trigger: entry.trigger,
       timestamp: Date.now(),
+      readOnly: entry.readOnly,
     });
   }
 
@@ -161,20 +174,20 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("turn_start", async (_event, ctx) => {
     _latestCtx = ctx;
-    widget.setUICtx(ctx.ui as UICtx);
+    widget.setUICtx(ctx.ui);
     upgradeStoreIfNeeded(ctx);
   });
 
   pi.on("before_agent_start", async (_event, ctx) => {
     _latestCtx = ctx;
-    widget.setUICtx(ctx.ui as UICtx);
+    widget.setUICtx(ctx.ui);
     upgradeStoreIfNeeded(ctx);
     showPersistedLoops();
   });
 
-  pi.on("session_switch" as any, async (event: any, ctx: ExtensionContext) => {
+  pi.on("session_switch" as any, async (event: SessionSwitchEvent, ctx: ExtensionContext) => {
     _latestCtx = ctx;
-    widget.setUICtx(ctx.ui as UICtx);
+    widget.setUICtx(ctx.ui);
     triggerSystem.stop();
 
     const isResume = event?.reason === "resume";
@@ -191,7 +204,14 @@ export default function (pi: ExtensionAPI) {
 
   // ── Loop fire handler — sends a user message to re-wake the agent ──
 
-  pi.events.on("loop:fire", (data: any) => {
+  pi.events.on("loop:fire", (event: unknown) => {
+    const data = event as LoopFireEvent;
+
+    if (_latestCtx?.hasPendingMessages()) {
+      debug(`loop:fire #${data.loopId} — agent has pending messages, skipping`);
+      return;
+    }
+
     const triggerInfo = typeof data.trigger === "string"
       ? data.trigger
       : data.trigger?.type === "cron"
@@ -200,14 +220,14 @@ export default function (pi: ExtensionAPI) {
           ? `event: ${data.trigger.source}`
           : `hybrid`;
 
+    const loopId = data.loopId || "?";
     const prompt = data.prompt || "loop fired";
+    const constraint = data.readOnly ? "\n\nREAD-ONLY MODE — use only read tools (Read, TaskList, LoopList, MonitorList, LoopCreate, etc.). No file writes, shell execution, or destructive changes." : "";
     const message = [
-      `[pi-loop] Loop #${data.loopId || "?"} fired (${triggerInfo}).`,
+      `[pi-loop] Loop #${loopId} fired (${triggerInfo}).${constraint}`,
       prompt,
     ].join("\n");
 
-    // deliverAs: "followUp" queues the message when the agent is busy;
-    // it delivers after the current turn finishes.
     pi.sendUserMessage(message, { deliverAs: "followUp" });
   });
 
@@ -247,7 +267,7 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
 - **prompt**: what to do when the loop fires (e.g., "check if the build passed")
 - **recurring**: repeat or fire once (default: true)
 - **autoTask**: if pi-tasks is loaded, auto-create a task on each fire
-- **triggerType**: "cron", "event", or "hybrid" (inferred if omitted)`,
+- **readOnly**: restrict the agent to read-only tools when this loop fires (default: false)`,
     promptGuidelines: [
       "When the user asks for a loop, repeating task, periodic check, or scheduled reminder, use LoopCreate — not raw Bash for/sleep/while.",
       "Use LoopCreate for any 'every X seconds/minutes/hours' requests.",
@@ -261,10 +281,11 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
       autoTask: Type.Optional(Type.Boolean({ description: "Auto-create pi-tasks task on fire", default: false })),
       triggerType: Type.Optional(Type.String({ description: "cron, event, or hybrid (inferred from trigger string if omitted)", enum: ["cron", "event", "hybrid"] })),
       debounceMs: Type.Optional(Type.Number({ description: "Debounce for hybrid triggers (default: 30000)", default: 30000 })),
+      readOnly: Type.Optional(Type.Boolean({ description: "Restrict the agent to read-only tools when this loop fires (default: false)", default: false })),
     }),
 
     execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const { trigger: triggerInput, prompt, recurring, autoTask, triggerType, debounceMs } = params;
+      const { trigger: triggerInput, prompt, recurring, autoTask, triggerType, debounceMs, readOnly } = params;
 
       let trigger: Trigger;
       const inferred = triggerType ?? inferTriggerType(triggerInput);
@@ -286,10 +307,14 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
         };
       }
 
+      const validationError = validateTrigger(trigger);
+      if (validationError) return Promise.resolve(textResult(validationError));
+
       const entry = store.create(trigger, prompt, {
         recurring: recurring ?? (inferred !== "event"),
         autoTask,
         selfPaced: triggerInput === "self-paced" || prompt.toLowerCase().includes("self-paced"),
+        readOnly,
       });
 
       triggerSystem.add(entry);
@@ -312,6 +337,28 @@ Skip this tool when the task is a one-off check (just do it directly) or when th
     },
   });
 
+  function validateTrigger(trigger: Trigger): string | null {
+    if (trigger.type === "cron") {
+      const parts = trigger.schedule.trim().split(/\s+/);
+      if (parts.length !== 5) {
+        return `Invalid cron trigger. Expected 5 fields, got ${parts.length}: "${trigger.schedule}". Use formats like "5m", "1h", "0 9 * * 1-5", or set triggerType to "event" for event sources.`;
+      }
+    } else if (trigger.type === "event") {
+      if (!trigger.source || trigger.source.trim().length === 0) {
+        return `Invalid event trigger. Event source must be non-empty (e.g., "tool_execution_start").`;
+      }
+    } else if (trigger.type === "hybrid") {
+      const cronParts = trigger.cron.trim().split(/\s+/);
+      if (cronParts.length !== 5) {
+        return `Invalid hybrid trigger. Cron part must have 5 fields, got ${cronParts.length}: "${trigger.cron}".`;
+      }
+      if (!trigger.event.source || trigger.event.source.trim().length === 0) {
+        return `Invalid hybrid trigger. Event source must be non-empty (e.g., "tool_execution_start").`;
+      }
+    }
+    return null;
+  }
+
   function inferTriggerType(input: string): "cron" | "event" | "hybrid" {
     if (input.includes("hybrid") || (input.includes("cron") && input.includes("event"))) return "hybrid";
     if (/^\d+\s*[smhd]$/i.test(input.trim())) return "cron";
@@ -554,8 +601,8 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
           triggerSystem.add(entry);
           widget.update();
           ui.notify(`Loop #${entry.id} created: every ${parsed.description} — ${prompt.slice(0, 50)}`, "info");
-        } catch (err: any) {
-          ui.notify(err.message, "error");
+        } catch (err: unknown) {
+          ui.notify((err as Error).message, "error");
         }
         return;
       }
@@ -572,7 +619,7 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
     },
   });
 
-  async function scheduleLoop(ui: any, prompt?: string) {
+  async function scheduleLoop(ui: ExtensionUIContext, prompt?: string) {
     const p = prompt || await ui.input("Prompt (what should the agent check?)");
     if (!p) return;
 
@@ -586,12 +633,12 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
       triggerSystem.add(entry);
       widget.update();
       ui.notify(`Loop #${entry.id} created: every ${parsed.description}`, "info");
-    } catch (err: any) {
-      ui.notify(err.message, "error");
+    } catch (err: unknown) {
+      ui.notify((err as Error).message, "error");
     }
   }
 
-  async function eventLoop(ui: any, prompt?: string) {
+  async function eventLoop(ui: ExtensionUIContext, prompt?: string) {
     const p = prompt || await ui.input("Prompt");
     if (!p) return;
 
@@ -605,7 +652,7 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
     ui.notify(`Event loop #${entry.id} created: fires on "${source}"`, "info");
   }
 
-  async function viewLoops(ui: any) {
+  async function viewLoops(ui: ExtensionUIContext) {
     const loops = store.list();
     if (loops.length === 0) {
       await ui.select("No active loops", ["← Back"]);
@@ -658,7 +705,7 @@ Use MonitorList to find the monitor ID, then stop it with this tool.`,
     return viewLoops(ui);
   }
 
-  async function settings(ui: any) {
+  async function settings(ui: ExtensionUIContext) {
     const loops = store.list();
     const active = loops.filter(l => l.status === "active").length;
     ui.notify(`${active}/${loops.length} active loops (max 25)`, "info");

package/src/store.ts

@@ -18,8 +18,8 @@ function acquireLock(lockPath: string): void {
       if (e.code === "EEXIST") {
         try {
           const pid = parseInt(readFileSync(lockPath, "utf-8"), 10);
-          if (pid && !isProcessRunning(pid)) {
-            unlinkSync(lockPath);
+          if (!pid || !isProcessRunning(pid)) {
+            try { unlinkSync(lockPath); } catch { /* ignore */ }
             continue;
           }
         } catch { /* ignore read errors */ }
@@ -95,7 +95,7 @@ export class LoopStore {
     }
   }
 
-  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; selfPaced?: boolean }): LoopEntry {
+  create(trigger: Trigger, prompt: string, opts: { recurring: boolean; autoTask?: boolean; selfPaced?: boolean; readOnly?: 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.`);
@@ -109,6 +109,7 @@ export class LoopStore {
         recurring: opts.recurring,
         autoTask: opts.autoTask,
         selfPaced: opts.selfPaced,
+        readOnly: opts.readOnly,
         createdAt: now,
         updatedAt: now,
         expiresAt: now + MAX_EXPIRY_DAYS * 24 * 60 * 60 * 1000,

package/src/types.ts

@@ -31,6 +31,7 @@ export interface LoopEntry {
   expiresAt: number;
   autoTask?: boolean;
   selfPaced?: boolean;
+  readOnly?: boolean;
 }
 
 export interface LoopStoreData {

package/src/ui/widget.ts

@@ -1,3 +1,5 @@
+import type { ExtensionUIContext, Theme } from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import type { MonitorManager } from "../monitor-manager.js";
 import type { CronScheduler } from "../scheduler.js";
@@ -5,18 +7,9 @@ import type { LoopStore } from "../store.js";
 
 const MAX_VISIBLE = 6;
 
-export type UICtx = {
-  setStatus(key: string, text: string | undefined): void;
-  setWidget(
-    key: string,
-    content: undefined | ((tui: any, theme: any) => { render(): string[]; invalidate(): void }),
-    options?: { placement?: "aboveEditor" | "belowEditor" },
-  ): void;
-};
-
 export class LoopWidget {
-  private uiCtx: UICtx | undefined;
-  private tui: any | undefined;
+  private uiCtx: ExtensionUIContext | undefined;
+  private tui: TUI | undefined;
   private widgetRegistered = false;
   private interval: ReturnType<typeof setInterval> | undefined;
 
@@ -26,7 +19,7 @@ export class LoopWidget {
     private monitorManager: MonitorManager,
   ) {}
 
-  setUICtx(ctx: UICtx) {
+  setUICtx(ctx: ExtensionUIContext) {
     this.uiCtx = ctx;
   }
 
@@ -61,17 +54,17 @@ export class LoopWidget {
     }
 
     if (!this.widgetRegistered) {
-      this.uiCtx.setWidget("loops", (tui, theme) => {
+      this.uiCtx.setWidget("loops", (tui: TUI, theme: Theme) => {
         this.tui = tui;
-        return { render: () => this.renderWidget(tui, theme), invalidate: () => {} };
+        return { render: () => this.renderWidget(tui, theme), invalidate: () => {} } as Component & { dispose?(): void };
       }, { placement: "aboveEditor" });
       this.widgetRegistered = true;
     } else if (this.tui) {
-      this.tui.requestRender();
+      (this.tui as any).requestRender();
     }
   }
 
-  private renderWidget(tui: any, _theme: any): string[] {
+  private renderWidget(tui: TUI, _theme: Theme): string[] {
     const loops = this.store.list().filter(l => l.status === "active");
     const monitors = this.monitorManager.list().filter(m => m.status === "running");
     const w = tui.terminal.columns;