codedeck 0.7.0 → 0.7.1

package/dist/plugin/hooks/pane-ticker.ts

@@ -0,0 +1,102 @@
+import type { PaneSnapshot } from "../mods/agents/types.js";
+
+const TICK_INTERVAL_MS = 1000;
+const REFRESH_INTERVAL_MS = 5000;
+const LIVE_STATUSES = new Set(["working", "starting", "needs_input"]);
+
+export interface PaneTickerOptions {
+  now: () => number;
+  setInterval: (callback: () => void, milliseconds: number) => unknown;
+  clearInterval: (handle: unknown) => void;
+  invalidate: () => unknown;
+  refresh: () => unknown;
+}
+
+export interface PaneTicker {
+  update(paneOpen: boolean, snapshot: PaneSnapshot | undefined): void;
+  refreshed(): void;
+}
+
+/** Schedules pane redraws and refresh requests while any worker card is live. */
+export function createPaneTicker(options: PaneTickerOptions): PaneTicker {
+  let running = false;
+  let handle: unknown;
+  let lastRefreshAt = 0;
+
+  const invoke = (action: () => unknown) => {
+    try {
+      void Promise.resolve(action()).catch(() => {});
+    } catch {
+      // Hook failures drop the drawing, so timer work must stay contained.
+    }
+  };
+
+  const tick = () => {
+    if (!running) return;
+    try {
+      invoke(options.invalidate);
+      const now = options.now();
+      if (!Number.isFinite(now) || now - lastRefreshAt < REFRESH_INTERVAL_MS) return;
+      lastRefreshAt = now;
+      invoke(options.refresh);
+    } catch {
+      // A failed timer callback must not escape into the hooks runtime.
+    }
+  };
+
+  const stop = () => {
+    if (!running) return;
+    running = false;
+    const currentHandle = handle;
+    handle = undefined;
+    try {
+      options.clearInterval(currentHandle);
+    } catch {
+      // Keep the module alive even if the timer host refuses a clear.
+    }
+  };
+
+  const start = () => {
+    if (running) return;
+    try {
+      const now = options.now();
+      if (!Number.isFinite(now)) return;
+      lastRefreshAt = now;
+      running = true;
+      handle = options.setInterval(tick, TICK_INTERVAL_MS);
+    } catch {
+      running = false;
+      handle = undefined;
+    }
+  };
+
+  const hasLiveRow = (snapshot: PaneSnapshot | undefined): boolean => {
+    try {
+      return (
+        snapshot !== undefined &&
+        Array.isArray(snapshot.rows) &&
+        snapshot.rows.some((row) => row != null && LIVE_STATUSES.has(row.status))
+      );
+    } catch {
+      return false;
+    }
+  };
+
+  return {
+    update(paneOpen, snapshot) {
+      if (paneOpen && hasLiveRow(snapshot)) {
+        start();
+        return;
+      }
+      stop();
+    },
+    refreshed() {
+      try {
+        const now = options.now();
+        if (Number.isFinite(now)) lastRefreshAt = now;
+      } catch {
+        // Keep the prior cadence if the injected clock fails.
+      }
+    },
+  };
+}

package/dist/plugin/hooks/register.tsx

@@ -7,6 +7,7 @@ import type { Register } from "claude-code";
 import { formatPane, paneButtonLabel, selectPane } from "../mods/agents/pane.js";
 import { parseRows } from "../mods/agents/parse.js";
 import type { PaneSnapshot } from "../mods/agents/types.js";
+import { createPaneTicker, type PaneTicker } from "./pane-ticker.js";
 import { togglePane } from "./pane-toggle.js";
 
 // Stable pane id: 1 to 64 letters, digits, "_" or "-". open carries it into
@@ -51,14 +52,17 @@ const toggleAgentsPane = async ($: Engine$, isOpen: boolean): Promise<boolean> =
 
 // Passing $ into a helper is allowed, verified. What the engine refuses is
 // pulling a namespace off it: `const P = $.process` fails to load the module.
-// So refresh takes $ as a parameter and the state register owns travels beside
-// it in this object. paneOpen never leaves register, so it stays a bare let.
+// refresh takes $ as a parameter; its state and paneOpen stay in this register.
 type PaneState = {
   // Last good snapshot; undefined until one refresh has fully succeeded, which
   // is how the pane draws nothing rather than a guess.
   snapshot: PaneSnapshot | undefined;
   inFlight: boolean;
   lastRefreshEndedAt: number;
+  ticker: PaneTicker | undefined;
+  paneOpen: boolean;
+  tickInvalidate: () => unknown;
+  tickRefresh: () => unknown;
   // True once session.start saw a CODEDECK_RUN_ID. Cached because ui.render
   // fires on every drawing pass and must not await an env read to decide
   // whether to draw one button.
@@ -67,6 +71,13 @@ type PaneState = {
 
 const TOOL_REFRESH_GAP_MS = 1500;
 
+function syncTicker($: Engine$, state: PaneState, refreshCompleted = false): void {
+  state.tickInvalidate = () => $.ui.invalidate("ui.render");
+  state.tickRefresh = () => refresh($, state);
+  if (refreshCompleted) state.ticker?.refreshed();
+  state.ticker?.update(state.paneOpen, state.snapshot);
+}
+
 const refresh = async ($: Engine$, state: PaneState): Promise<void> => {
   // Claim the slot before the first await. Guard and set must not straddle a
   // yield point: with the `$.env.get` read in between, two tool.call firings
@@ -103,6 +114,7 @@ const refresh = async ($: Engine$, state: PaneState): Promise<void> => {
   } finally {
     state.inFlight = false;
     state.lastRefreshEndedAt = Date.now();
+    syncTicker($, state, true);
   }
 };
 
@@ -112,10 +124,21 @@ export const register: Register = (on) => {
     inFlight: false,
     lastRefreshEndedAt: 0,
     hasRun: false,
+    ticker: undefined,
+    paneOpen: false,
+    tickInvalidate: () => undefined,
+    tickRefresh: () => undefined,
   };
-  let paneOpen = false;
+  state.ticker = createPaneTicker({
+    now: () => Date.now(),
+    setInterval: (callback, milliseconds) => setInterval(callback, milliseconds),
+    clearInterval: (handle) => clearInterval(handle as ReturnType<typeof setInterval>),
+    invalidate: () => state.tickInvalidate(),
+    refresh: () => state.tickRefresh(),
+  });
 
   on("session.start", async ($, e, next) => {
+    syncTicker($, state);
     // Not "agents": the engine refuses it with `$.command.register: "/agents"
     // refused: it is the built-in /agents`. "band", "deck" and
     // "codedeck-agents" were each verified free. The description is load
@@ -145,10 +168,11 @@ export const register: Register = (on) => {
     // is the one call here not yet verified in a PTY session, paneOpen stays
     // true and the next /band retries the close, instead of the flag and the
     // pane desyncing for the rest of the session.
-    paneOpen = await toggleAgentsPane($, paneOpen);
+    state.paneOpen = await toggleAgentsPane($, state.paneOpen);
+    syncTicker($, state);
     await $.ui.invalidate("ui.render");
-    if (paneOpen) void refresh($, state);
-    return { text: paneOpen ? "agents pane open" : "agents pane closed" };
+    if (state.paneOpen) void refresh($, state);
+    return { text: state.paneOpen ? "agents pane open" : "agents pane closed" };
   });
 
   on("turn.complete", async ($, e, next) => {
@@ -172,9 +196,10 @@ export const register: Register = (on) => {
     // A $ captured from a past render does work, verified, but it outlives the
     // event it came from and nothing promises how long.
     if ((e as { element?: string }).element === BUTTON_KEY) {
-      paneOpen = await toggleAgentsPane($, paneOpen);
+      state.paneOpen = await toggleAgentsPane($, state.paneOpen);
+      syncTicker($, state);
       await $.ui.invalidate("ui.render");
-      if (paneOpen) void refresh($, state);
+      if (state.paneOpen) void refresh($, state);
     }
     return await next(e);
   });