@hank-warren/pi-auto-permissions 0.16.2 → 0.18.0

package/jsonl-sidecar.ts

@@ -0,0 +1,22 @@
+import { appendFileSync, chmodSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { dirname } from "node:path";
+
+/** Rotate once a sidecar grows past this size; one previous generation is kept. */
+export const SIDECAR_ROTATE_BYTES = 16 * 1024 * 1024;
+
+function rotateIfLarge(path: string, rotateBytes: number): void {
+  try {
+    if (statSync(path).size < rotateBytes) return;
+    renameSync(path, `${path}.1`);
+  } catch {
+    // A missing or unrotatable sidecar simply keeps appending.
+  }
+}
+
+/** Append one JSON line to an owner-only sidecar, rotating first when `rotateBytes` is set. */
+export function appendJsonlRecord(path: string, record: unknown, rotateBytes?: number): void {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  if (rotateBytes !== undefined) rotateIfLarge(path, rotateBytes);
+  appendFileSync(path, `${JSON.stringify(record)}\n`, { encoding: "utf8", mode: 0o600 });
+  chmodSync(path, 0o600);
+}

package/override-evidence.ts

@@ -6,6 +6,8 @@ import type { ReviewEvidenceRecord } from "./review.js";
  * evidence stream as user-source records so the guardian can treat them as
  * authorization (allows) or standing constraints (blocks).
  */
+export const PERMISSION_OVERRIDE_CHOICES = ["allow", "allow_unnecessary", "allow_appropriate", "block"] as const;
+
 export interface PermissionOverride {
   seq: number;
   /**
@@ -18,13 +20,7 @@ export interface PermissionOverride {
   gateLabel: string;
   command: string;
   reviewerReason: string;
-  choice: "allow" | "allow_unnecessary" | "allow_appropriate" | "block";
-  /** Present only for a user-scoped ledger approval loaded at session start. */
-  standing?: {
-    grantedAt: string;
-    project: string;
-    gateGroup: string;
-  };
+  choice: (typeof PERMISSION_OVERRIDE_CHOICES)[number];
 }
 
 /** Anchor value meaning "before every collected record". */
@@ -43,16 +39,6 @@ export function overrideEvidenceRecord(override: PermissionOverride): ReviewEvid
   const command = JSON.stringify(commandPreview(override.command));
   const gate = JSON.stringify(override.gateLabel);
   const concern = JSON.stringify(commandPreview(override.reviewerReason));
-  if (override.standing) {
-    const granted = override.standing.grantedAt.slice(0, 10);
-    const project = JSON.stringify(commandPreview(override.standing.project));
-    const group = JSON.stringify(override.standing.gateGroup);
-    return {
-      key: `override:${override.seq}`,
-      source: "user",
-      text: `USER (standing permission override, granted ${granted} in ${project}): allowed gated command ${command} (gate ${gate}, group ${group}) despite reviewer concern ${concern}. Treat comparable actions in any project as authorized unless a later user statement or block contradicts this. This never authorizes an action of a materially higher risk class.`,
-    };
-  }
   let text: string;
   switch (override.choice) {
     case "allow_unnecessary":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-auto-permissions",
-  "version": "0.16.2",
+  "version": "0.18.0",
   "description": "Fork of @ogulcancelik/pi-auto-permissions with dialog-answer user evidence: context-aware Bash permissions for Pi with automated guardian review.",
   "type": "module",
   "keywords": [
@@ -43,24 +43,20 @@
     "NOTICE.md",
     "auto-permissions-setup",
     "index.ts",
-    "approval-pulse.ts",
     "config.ts",
     "config-writer.ts",
     "default-rules.ts",
     "denial-log.ts",
     "settings-menu.ts",
     "guardian-transport.ts",
-    "openai-codex-transport.ts",
     "subagent-context.ts",
-    "loop-context.ts",
-    "loop-revise-budget.ts",
     "evaluation-log.ts",
     "gates.ts",
+    "jsonl-sidecar.ts",
     "override-evidence.ts",
     "review.ts",
     "review-queue.ts",
     "session-environment.ts",
-    "standing-overrides.ts",
     "usage-log.ts",
     "widget-status.ts",
     "classify.ts",
@@ -80,7 +76,6 @@
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
-    "@earendil-works/pi-tui": "*",
-    "typebox": "*"
+    "@earendil-works/pi-tui": "*"
   }
 }

package/prompt-select.ts

@@ -1,6 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { OptionSelector } from "@hank-warren/pi-permission-selector/selector.ts";
-import { PulsingApprovalIndicator } from "./approval-pulse.js";
 
 /**
  * Tell Herdr this pane is waiting on a human, so a supervising agent can see
@@ -33,23 +32,20 @@ export function promptSelect(
   title: string,
   values: string[],
   signal: AbortSignal,
-  opts: { allowComment: boolean },
 ): Promise<string | undefined> {
-  let indicator: PulsingApprovalIndicator | undefined;
   return ctx.ui.custom<string | undefined>((tui, theme, _keybindings, done) => {
     let finished = false;
     const onAbort = () => finish(undefined);
     const finish = (result: string | undefined) => {
       if (finished) return;
       finished = true;
-      indicator?.stop();
       signal.removeEventListener("abort", onAbort);
       done(result);
     };
     const selector = new OptionSelector({
-      title,
+      title: `${theme.fg("warning", theme.bold("●"))} ${title}`,
       options: values.map((value) => ({ value, label: value })),
-      allowComment: opts.allowComment,
+      allowComment: true,
       theme,
       onSelect: (option, comment) => {
         if (comment) {
@@ -64,17 +60,10 @@ export function promptSelect(
       onCancel: () => finish(undefined),
       requestRender: () => tui.requestRender(),
     });
-    indicator = new PulsingApprovalIndicator(
-      title.split("\n", 1)[0] ?? "Auto Permissions needs approval",
-      selector,
-      theme,
-      () => tui.requestRender(),
-    );
     signal.addEventListener("abort", onAbort, { once: true });
     // `done` before the factory resolves is safe: pi marks the dialog closed
     // and never mounts the component.
     if (signal.aborted) onAbort();
-    else indicator.start();
-    return indicator;
-  }).finally(() => indicator?.stop());
+    return selector;
+  });
 }

package/review-display.ts

@@ -1,267 +1,181 @@
-import * as PiCodingAgent from "@earendil-works/pi-coding-agent";
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import type { Gate } from "./gates.js";
-import type { ReviewScope, ReviewTarget } from "./review-scope.js";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { ReviewScope } from "./review-scope.js";
 import {
+  isActiveReviewState,
   reviewFrameIntervalMs,
-  reviewStatusFrame,
   reviewStatusLines,
+  reviewSummaryLines,
+  WAITING_FRAME_INTERVAL_MS,
   type ReviewDisplayState,
   type ReviewLinePalette,
+  type ReviewSummaryCounts,
 } from "./widget-status.js";
 
-/** The subset of Pi's tool-render theme the review status line uses. */
-interface RowTheme {
-  fg(role: string, text: string): string;
-}
-
 const WIDGET_KEY = "auto-permissions";
-const PROJECT_CONFIG_DIR_NAME = (PiCodingAgent as { CONFIG_DIR_NAME?: string }).CONFIG_DIR_NAME ?? ".pi";
-
-type ReviewRow = {
-  gate: Gate;
-  state: ReviewDisplayState;
-  reviewer: string;
-  detail?: string;
-};
-
-/**
- * The status line for one review row.
- *
- * The tool row words the states that describe *this* call in its own terms
- * ("guardian running" where the widget says "waiting for <model>"), because
- * the row already sits under the command it belongs to. `queued` is the one
- * state that describes the queue rather than the call, so it reuses the
- * widget's frame verbatim rather than restating it — two placements
- * disagreeing about what "queued" says is exactly what sharing this prevents.
- */
-function rowStatus(review: ReviewRow, theme: RowTheme): string {
-  if (review.state === "queued") {
-    const frame = reviewStatusFrame(review.state, review.reviewer, 0);
-    return theme.fg(frame.tone, `${frame.glyph} ${frame.label}`);
-  }
-  return review.state === "waiting"
-    ? theme.fg("warning", "◌ guardian running")
-    : review.state === "approved"
-      ? theme.fg("success", "✓ approved")
-      : review.state === "revise"
-        ? theme.fg("warning", "↻ revision requested")
-        : review.state === "ask_user"
-          ? theme.fg("accent", "? approval required")
-          : theme.fg("error", "✗ blocked");
-}
 
 export interface ReviewDisplay {
-  /**
-   * Take over the `bash` tool so review status renders inside its call row
-   * instead of above the editor. Only for `ui.placement: "toolRow"`.
-   */
-  registerGuardedBash(ctx: ExtensionContext): void;
   show(scope: ReviewScope, state: ReviewDisplayState, detail?: string, autoClear?: boolean): void;
   clear(scope: ReviewScope): void;
   shutdown(ctx: ExtensionContext): void;
 }
 
-function loadNativeBashOptions(cwd: string, projectTrusted: boolean): { commandPrefix?: string; shellPath?: string } {
-  const readSettings = (path: string): Record<string, unknown> => {
-    try {
-      const value = JSON.parse(readFileSync(path, "utf8"));
-      return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
-    } catch {
-      return {};
-    }
-  };
-  const getAgentDir = (PiCodingAgent as { getAgentDir?: () => string }).getAgentDir;
-  const global = getAgentDir ? readSettings(join(getAgentDir(), "settings.json")) : {};
-  const project = projectTrusted ? readSettings(join(cwd, PROJECT_CONFIG_DIR_NAME, "settings.json")) : {};
-  const setting = (name: string): string | undefined => {
-    const value = project[name] ?? global[name];
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-  };
-  return { commandPrefix: setting("shellCommandPrefix"), shellPath: setting("shellPath") };
+interface Row {
+  scope: ReviewScope;
+  state: ReviewDisplayState;
+  detail?: string;
+}
+
+function rowKey(scope: ReviewScope): string {
+  return scope.target.toolCallId ?? `command:${scope.command}`;
+}
+
+function reviewerLabel(scope: ReviewScope): string {
+  const { ctx, config } = scope;
+  return config.reviewer
+    ? `${config.reviewer.provider}/${config.reviewer.model}`
+    : ctx.model
+      ? `${ctx.model.provider}/${ctx.model.id}`
+      : "active model";
 }
 
 /**
- * Where a review announces itself: the bash tool row when this extension owns
- * the renderer, and the above-editor widget otherwise.
+ * Where reviews announce themselves: the above-editor widget.
  *
- * Owns the rows, their invalidators, and both widget timers, because every one
- * of them is only meaningful next to the others — a row without its
- * invalidator never repaints, and a widget timer outliving its widget animates
- * something nobody can see.
+ * Several guarded commands can be under review at once, so the display keeps
+ * one row per unsettled command. One row renders exactly as a lone review
+ * always has; several collapse into a single summary line. A settled result
+ * is shown only once nothing is left unsettled, and a new review replaces it.
+ *
+ * Owns both widget timers — the animation interval and the auto-clear
+ * timeout — because a timer outliving its widget animates or clears something
+ * nobody can see.
  */
-export function createReviewDisplay(
-  pi: ExtensionAPI,
-  deps: { isSessionActive: () => boolean },
-): ReviewDisplay {
-  const reviewRows = new Map<string, ReviewRow>();
-  const reviewRowInvalidators = new Map<string, () => void>();
-  let bashRendererRegistered = false;
-  let bashRendererSourcePath: string | undefined;
+export function createReviewDisplay(deps: { isSessionActive: () => boolean }): ReviewDisplay {
+  const active = new Map<string, Row>();
+  let settled: Row | undefined;
   let clearWidgetTimer: ReturnType<typeof setTimeout> | undefined;
   let widgetAnimTimer: ReturnType<typeof setInterval> | undefined;
 
-  function ownsBashRenderer(): boolean {
-    if (!bashRendererRegistered) return false;
-    const current = pi.getAllTools().find((tool) => tool.name === "bash");
-    return bashRendererSourcePath === undefined || current?.sourceInfo.path === bashRendererSourcePath;
+  function stopAnimation(): void {
+    if (widgetAnimTimer) clearInterval(widgetAnimTimer);
+    widgetAnimTimer = undefined;
   }
 
-  function clearReviewWidget(ctx: ExtensionContext): void {
+  function stopClearTimer(): void {
     if (clearWidgetTimer) clearTimeout(clearWidgetTimer);
     clearWidgetTimer = undefined;
-    if (widgetAnimTimer) clearInterval(widgetAnimTimer);
-    widgetAnimTimer = undefined;
-    if (ctx.mode === "tui") ctx.ui.setWidget(WIDGET_KEY, undefined);
   }
 
-  function rowTarget(target: ReviewTarget): string | undefined {
-    return target.toolName === "bash" && target.toolCallId && ownsBashRenderer()
-      ? target.toolCallId
-      : undefined;
+  function visible(scope: ReviewScope): boolean {
+    return deps.isSessionActive() && scope.ctx.mode === "tui" && scope.config.ui.enabled;
   }
 
-  pi.on("tool_execution_end", async (event) => {
-    if (event.toolName !== "bash") return;
-    if (!reviewRows.has(event.toolCallId)) reviewRowInvalidators.delete(event.toolCallId);
-  });
-
-  return {
-    registerGuardedBash(ctx: ExtensionContext): void {
-      if (bashRendererRegistered) return;
-      const existing = pi.getAllTools().find((tool) => tool.name === "bash");
-      if (existing && existing.sourceInfo.source !== "builtin") {
-        ctx.ui.notify("Auto Permissions kept the existing non-native bash backend; review status will use the editor widget.", "warning");
-        return;
+  function render(ctx: ExtensionContext): void {
+    stopAnimation();
+    if (ctx.mode !== "tui") return;
+    const rows = [...active.values()];
+    const shown = rows.length === 1 ? rows[0] : rows.length === 0 ? settled : undefined;
+    if (rows.length === 0 && !settled) {
+      ctx.ui.setWidget(WIDGET_KEY, undefined);
+      return;
+    }
+    const latest = rows.at(-1) ?? settled!;
+    const reviewer = reviewerLabel(latest.scope);
+    const counts: ReviewSummaryCounts = { waiting: 0, queued: 0, askUser: 0 };
+    for (const row of rows) {
+      if (row.state === "waiting") counts.waiting += 1;
+      else if (row.state === "queued") counts.queued += 1;
+      else if (row.state === "ask_user") counts.askUser += 1;
+    }
+    const intervalMs = shown
+      ? reviewFrameIntervalMs(shown.state)
+      : counts.waiting > 0 ? WAITING_FRAME_INTERVAL_MS : undefined;
+
+    ctx.ui.setWidget(WIDGET_KEY, (tui, theme) => {
+      const palette: ReviewLinePalette = {
+        header: (text) => theme.fg("accent", theme.bold(text)),
+        muted: (text) => theme.fg("muted", text),
+        warning: (text) => theme.fg("warning", text),
+        success: (text) => theme.fg("success", text),
+        accent: (text) => theme.fg("accent", text),
+        error: (text) => theme.fg("error", text),
+      };
+      let frameIndex = 0;
+      let timer: ReturnType<typeof setInterval> | undefined;
+      const stopTimer = () => {
+        if (timer) clearInterval(timer);
+        if (widgetAnimTimer === timer) widgetAnimTimer = undefined;
+        timer = undefined;
+      };
+      if (intervalMs !== undefined) {
+        timer = setInterval(() => {
+          frameIndex++;
+          tui.requestRender();
+        }, intervalMs);
+        timer.unref?.();
+        widgetAnimTimer = timer;
       }
-
-      const createBashToolDefinition = (PiCodingAgent as {
-        createBashToolDefinition?: (cwd: string, options?: { commandPrefix?: string; shellPath?: string }) => any;
-      }).createBashToolDefinition;
-      if (!createBashToolDefinition) return;
-      const native = createBashToolDefinition(
-        ctx.cwd,
-        loadNativeBashOptions(ctx.cwd, ctx.isProjectTrusted()),
-      );
-      const nativeRenderCall = native.renderCall;
-      const { renderResult: _nativeResultRenderer, ...nativeWithoutResultRenderer } = native;
-
-      pi.registerTool({
-        ...nativeWithoutResultRenderer,
-        renderCall(args: unknown, theme: any, context: any) {
-          const state = context.state as Record<string, unknown>;
-          const base = nativeRenderCall(args, theme, {
-            ...context,
-            lastComponent: state.autoPermissionsBaseCallComponent,
-          });
-          state.autoPermissionsBaseCallComponent = base;
-          reviewRowInvalidators.set(context.toolCallId, context.invalidate);
-
-          const container = new Container();
-          container.addChild(base);
-          const review = reviewRows.get(context.toolCallId);
-          if (review) {
-            const status = rowStatus(review, theme);
-            const suffix = review.state === "waiting"
-              ? ` · ${review.gate.label} · ${review.reviewer}`
-              : ` · ${review.gate.label}`;
-            let text = `\n  ${status}${theme.fg("muted", suffix)}`;
-            if (review.detail) text += `\n  ${theme.fg("muted", review.detail)}`;
-            container.addChild(new Text(text, 0, 0));
-          }
-          return container;
+      return {
+        render(width: number): string[] {
+          const lines = shown
+            ? reviewStatusLines(shown.state, shown.scope.gate.label, reviewer, frameIndex, shown.detail, palette)
+            : reviewSummaryLines(counts, reviewer, frameIndex, palette);
+          return lines.map((line) => truncateToWidth(line, Math.max(1, width)));
         },
-      });
-      bashRendererRegistered = true;
-      bashRendererSourcePath = pi.getAllTools().find((tool) => tool.name === "bash")?.sourceInfo.path;
-    },
-
-    show(scope: ReviewScope, state: ReviewDisplayState, detail?: string, autoClear = false): void {
-      const { ctx, config, gate, target } = scope;
-      if (!deps.isSessionActive() || ctx.mode !== "tui" || !config.ui.enabled) return;
-      const reviewer = config.reviewer
-        ? `${config.reviewer.provider}/${config.reviewer.model}`
-        : ctx.model
-          ? `${ctx.model.provider}/${ctx.model.id}`
-          : "active model";
+        invalidate() {},
+        dispose() {
+          stopTimer();
+        },
+      };
+    }, { placement: "aboveEditor" });
+  }
 
-      const rowId = rowTarget(target);
-      if (rowId) {
-        reviewRows.set(rowId, { gate, state, reviewer, detail });
-        reviewRowInvalidators.get(rowId)?.();
-        return;
-      }
+  function reset(ctx: ExtensionContext): void {
+    active.clear();
+    settled = undefined;
+    stopClearTimer();
+    stopAnimation();
+    if (ctx.mode === "tui") ctx.ui.setWidget(WIDGET_KEY, undefined);
+  }
 
-      if (clearWidgetTimer) clearTimeout(clearWidgetTimer);
-      clearWidgetTimer = undefined;
-      if (widgetAnimTimer) clearInterval(widgetAnimTimer);
-      widgetAnimTimer = undefined;
-      ctx.ui.setWidget(WIDGET_KEY, (tui, theme) => {
-        const palette: ReviewLinePalette = {
-          header: (text) => theme.fg("accent", theme.bold(text)),
-          muted: (text) => theme.fg("muted", text),
-          warning: (text) => theme.fg("warning", text),
-          success: (text) => theme.fg("success", text),
-          accent: (text) => theme.fg("accent", text),
-          error: (text) => theme.fg("error", text),
-        };
-        let frameIndex = 0;
-        let timer: ReturnType<typeof setInterval> | undefined;
-        const stopTimer = () => {
-          if (timer) clearInterval(timer);
-          if (widgetAnimTimer === timer) widgetAnimTimer = undefined;
-          timer = undefined;
-        };
-        const intervalMs = reviewFrameIntervalMs(state);
-        if (intervalMs !== undefined) {
-          timer = setInterval(() => {
-            frameIndex++;
-            if (reviewStatusFrame(state, reviewer, frameIndex).done) stopTimer();
-            tui.requestRender();
-          }, intervalMs);
-          timer.unref?.();
-          widgetAnimTimer = timer;
+  return {
+    show(scope: ReviewScope, state: ReviewDisplayState, detail?: string, autoClear = false): void {
+      if (!visible(scope)) return;
+      const key = rowKey(scope);
+      stopClearTimer();
+      if (isActiveReviewState(state)) {
+        active.set(key, { scope, state, detail });
+        settled = undefined;
+      } else {
+        active.delete(key);
+        const row: Row = { scope, state, detail };
+        settled = row;
+        if (autoClear) {
+          clearWidgetTimer = setTimeout(() => {
+            clearWidgetTimer = undefined;
+            if (!deps.isSessionActive() || settled !== row) return;
+            settled = undefined;
+            render(scope.ctx);
+          }, scope.config.ui.resultDisplayMs);
+          clearWidgetTimer.unref?.();
         }
-        return {
-          render(width: number): string[] {
-            return reviewStatusLines(state, gate.label, reviewer, frameIndex, detail, palette)
-              .map((line) => truncateToWidth(line, Math.max(1, width)));
-          },
-          invalidate() {},
-          dispose() {
-            stopTimer();
-          },
-        };
-      }, { placement: "aboveEditor" });
-
-      if (autoClear) {
-        clearWidgetTimer = setTimeout(() => {
-          if (deps.isSessionActive()) clearReviewWidget(ctx);
-        }, config.ui.resultDisplayMs);
-        clearWidgetTimer.unref?.();
       }
+      render(scope.ctx);
     },
 
     clear(scope: ReviewScope): void {
-      const rowId = rowTarget(scope.target);
-      if (rowId) {
-        reviewRows.delete(rowId);
-        const invalidate = reviewRowInvalidators.get(rowId);
-        invalidate?.();
-        reviewRowInvalidators.delete(rowId);
-        return;
+      const key = rowKey(scope);
+      const wasShown = active.delete(key) || (settled !== undefined && rowKey(settled.scope) === key);
+      if (settled && rowKey(settled.scope) === key) {
+        settled = undefined;
+        stopClearTimer();
       }
-      clearReviewWidget(scope.ctx);
+      if (wasShown || (active.size === 0 && !settled)) render(scope.ctx);
     },
 
     shutdown(ctx: ExtensionContext): void {
-      reviewRows.clear();
-      for (const invalidate of reviewRowInvalidators.values()) invalidate();
-      reviewRowInvalidators.clear();
-      clearReviewWidget(ctx);
+      reset(ctx);
     },
   };
 }