@pellux/goodvibes-tui 0.27.0 → 0.29.0

package/src/panels/approval-panel.ts

@@ -1,150 +1,252 @@
 import type { Line } from '../types/grid.ts';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import type { PanelIntegrationContext } from './types.ts';
 import {
+  buildBodyText,
+  buildDetailBlock,
   buildGuidanceLine,
   buildKeyValueLine,
+  buildKeyboardHints,
   buildPanelLine,
+  buildStatusBadge,
   DEFAULT_PANEL_PALETTE,
+  type StatusBadgeKind,
 } from './polish.ts';
-import type { PolicyRuntimeState } from '@/runtime/index.ts';
+import { truncateDisplay } from '../utils/terminal-width.ts';
+import type { PolicyRuntimeState, PermissionAuditEntry } from '@/runtime/index.ts';
 import { buildPermissionRuleSuggestions } from '@/runtime/index.ts';
 
-const C = {
-  ...DEFAULT_PANEL_PALETTE,
-  headerBg: '#111827',
-} as const;
-
-const APPROVAL_ROWS = [
-  ['shell', 'why prompted: side effects, destructive ops, secret exposure, escalation', 'review via /security and /policy preflight'],
-  ['file', 'why prompted: config mutation, notebook edits, secret-bearing paths', 'review via /approval review file'],
-  ['network', 'why prompted: external hosts, fetch scope, egress policy', 'review via /approval review network'],
-  ['delegate', 'why prompted: recursive agents, spawn ceilings, write-set inheritance', 'review via /approval review delegate'],
-  ['mcp', 'why prompted: trust escalation, host scope, path scope, coherence mismatch', 'review via /mcp trust and /security'],
-  ['remote', 'why prompted: runner trust, remote write scope, artifact requirements', 'review via /remote and /sandbox'],
-  ['hook', 'why prompted: deny/mutate authority, blocking behavior, runner provenance', 'review via /hooks and /security'],
-  ['plugin', 'why prompted: install/update lifecycle, provenance, capability grants', 'review via /marketplace and /security'],
-  ['sandbox', 'why prompted: WSL/VM isolation changes alter host risk posture', 'review via /sandbox preset and /sandbox review'],
-] as const;
-
-type ApprovalRow = (typeof APPROVAL_ROWS)[number];
-
-export class ApprovalPanel extends ScrollableListPanel<ApprovalRow> {
+// Splits a computed '/command arg1 arg2' string into the { name, args } shape
+// ctx.executeCommand expects — same leading-slash-stripping approach used by
+// remote-panel.ts / session-browser-panel.ts for their own dispatched commands.
+function parseCommand(command: string): { name: string; args: string[] } | null {
+  const parts = command.replace(/^\//, '').split(/\s+/).filter(Boolean);
+  const [name, ...args] = parts;
+  return name ? { name, args } : null;
+}
+
+// Base chrome only — title band comes straight from DEFAULT_PANEL_PALETTE
+// (WO-002).
+const C = DEFAULT_PANEL_PALETTE;
+
+// Reference catalog of approval lanes and where each one is reviewed. Used to
+// resolve the next-step command for a live request and as a fallback reference
+// when no live requests are present.
+const LANE_REVIEW: Record<string, { command: string; why: string }> = {
+  shell:    { command: '/security', why: 'side effects, destructive ops, secret exposure, escalation' },
+  file:     { command: '/approval review file', why: 'config mutation, notebook edits, secret-bearing paths' },
+  network:  { command: '/approval review network', why: 'external hosts, fetch scope, egress policy' },
+  delegate: { command: '/approval review delegate', why: 'recursive agents, spawn ceilings, write-set inheritance' },
+  mcp:      { command: '/mcp trust', why: 'trust escalation, host scope, path scope, coherence mismatch' },
+  remote:   { command: '/remote', why: 'runner trust, remote write scope, artifact requirements' },
+  hook:     { command: '/hooks', why: 'deny/mutate authority, blocking behavior, runner provenance' },
+  plugin:   { command: '/marketplace', why: 'install/update lifecycle, provenance, capability grants' },
+  sandbox:  { command: '/sandbox review', why: 'WSL/VM isolation changes alter host risk posture' },
+};
+
+function laneOf(entry: PermissionAuditEntry): string {
+  const key = (entry.category || entry.tool || '').toLowerCase();
+  for (const lane of Object.keys(LANE_REVIEW)) {
+    if (key.includes(lane)) return lane;
+  }
+  return key || 'shell';
+}
+
+function reviewFor(entry: PermissionAuditEntry): { command: string; why: string } {
+  return LANE_REVIEW[laneOf(entry)] ?? { command: '/security', why: 'review approval posture' };
+}
+
+function decisionOf(entry: PermissionAuditEntry): 'pending' | 'approved' | 'denied' {
+  return entry.approved === undefined ? 'pending' : entry.approved ? 'approved' : 'denied';
+}
+
+function badgeKind(decision: 'pending' | 'approved' | 'denied'): StatusBadgeKind {
+  return decision === 'pending' ? 'pending' : decision === 'approved' ? 'completed' : 'failed';
+}
+
+function riskColor(risk: string): string {
+  const r = risk.toLowerCase();
+  if (r.includes('critical') || r.includes('high')) return C.bad;
+  if (r.includes('medium') || r.includes('moderate')) return C.warn;
+  return C.good;
+}
+
+function fmtAgo(ts: number): string {
+  const sec = Math.max(0, Math.floor((Date.now() - ts) / 1000));
+  if (sec < 60) return `${sec}s ago`;
+  if (sec < 3600) return `${Math.floor(sec / 60)}m ago`;
+  return `${Math.floor(sec / 3600)}h ago`;
+}
+
+export class ApprovalPanel extends ScrollableListPanel<PermissionAuditEntry> {
   private readonly policyRuntimeState: Pick<PolicyRuntimeState, 'getSnapshot'>;
+  // p / 1-3 = dispatch '/policy simulate' or a rule-suggestion command via the
+  // handleInput -> handlePanelIntegrationAction bridge (handleInput has no
+  // ctx.executeCommand — same pattern as remote-panel.ts / session-browser-panel.ts).
+  private pendingCommand: { name: string; args: string[] } | null = null;
 
   public constructor(policyRuntimeState: Pick<PolicyRuntimeState, 'getSnapshot'>) {
-    super('approval', 'Approval', 'A', 'monitoring');
+    super('approval', 'Approval', 'A', 'security-policy');
     this.showSelectionGutter = true; // I5: non-color selection affordance
     this.policyRuntimeState = policyRuntimeState;
   }
 
-  protected override getPalette() { return C; }
-  protected override getEmptyStateMessage() { return ' No approval lanes defined.'; }
-
-  protected getItems(): readonly ApprovalRow[] {
-    return APPROVAL_ROWS;
-  }
-
-  protected renderItem(row: ApprovalRow, index: number, selected: boolean, width: number): Line {
-    const bg = selected ? C.selectBg : undefined;
-    return buildPanelLine(width, [
-      ['  ', C.label],
-      [row[0].padEnd(10), C.info, bg],
-      [row[1].slice(0, Math.max(0, width - 18)), C.value, bg],
-    ]);
+  private getRuleSuggestions() {
+    const audit = this.policyRuntimeState.getSnapshot().recentPermissionAudit;
+    return buildPermissionRuleSuggestions(audit).slice(0, 3);
   }
 
-  public handleInput(key: string): boolean {
-    if (key === 'home') {
-      this.selectedIndex = 0;
-      this.markDirty();
-      return true;
-    }
-    if (key === 'end') {
-      this.selectedIndex = APPROVAL_ROWS.length - 1;
-      this.markDirty();
+  override handleInput(key: string): boolean {
+    if (key === 'p') {
+      this.pendingCommand = parseCommand('/policy simulate');
       return true;
     }
-    if (key === 'enter' || key === 'return') {
+    if (key === '1' || key === '2' || key === '3') {
+      const suggestion = this.getRuleSuggestions()[Number(key) - 1];
+      if (!suggestion) return false;
+      this.pendingCommand = parseCommand(suggestion.command);
       return true;
     }
     return super.handleInput(key);
   }
 
+  /** Drains `pendingCommand` (set by 'p' or '1'/'2'/'3') via the ctx.executeCommand bridge. */
+  handlePanelIntegrationAction(_key: string, ctx: PanelIntegrationContext): boolean {
+    if (!this.pendingCommand) return false;
+    const { name, args } = this.pendingCommand;
+    this.pendingCommand = null;
+    void ctx.executeCommand?.(name, args);
+    return true;
+  }
+
+  protected override getPalette() { return C; }
+  protected override getEmptyStateMessage() { return ' No approval pressure right now.'; }
+  protected override getEmptyStateActions() {
+    return [
+      { command: '/security', summary: 'inspect trust, tokens, quarantines, and incident pressure' },
+      { command: '/policy simulate', summary: 'preview which requests a rule change would auto-approve' },
+    ];
+  }
+
+  // Pending requests (those still needing a decision) are surfaced first so the
+  // operator sees actionable items at the top, then most-recent decisions.
+  protected getItems(): readonly PermissionAuditEntry[] {
+    const audit = this.policyRuntimeState.getSnapshot().recentPermissionAudit;
+    const pending = audit.filter((e) => e.approved === undefined);
+    const decided = audit.filter((e) => e.approved !== undefined);
+    return [...pending, ...decided];
+  }
+
+  protected renderItem(entry: PermissionAuditEntry, _index: number, selected: boolean, width: number): Line {
+    const bg = selected ? C.selectBg : undefined;
+    const decision = decisionOf(entry);
+    const badge = buildStatusBadge(badgeKind(decision), decision)[0]!;
+    const detailWidth = Math.max(0, width - 40);
+    return buildPanelLine(width, [
+      [' ', C.label, bg],
+      [`${badge.text} `.padEnd(12), badge.fg, bg],
+      [`${truncateDisplay(entry.tool, 12)} `.padEnd(13), C.value, bg],
+      [`${truncateDisplay(entry.riskLevel, 6)} `.padEnd(7), riskColor(entry.riskLevel), bg],
+      [truncateDisplay(entry.summary, detailWidth), C.dim, bg],
+    ]);
+  }
+
+  /** Next-step review command for the currently selected request (if any). */
   public getSelectedCommand(): string | null {
-    const selected = APPROVAL_ROWS[this.selectedIndex] ?? null;
-    return selected ? selected[2].replace('review via ', '').trim() : null;
+    const selected = this.getSelectedItem();
+    return selected ? reviewFor(selected).command : null;
   }
 
   public render(width: number, height: number): Line[] {
     this.clampSelection();
-    const policySnapshot = this.policyRuntimeState.getSnapshot();
-    const approvalCount = policySnapshot.recentPermissionAudit.filter((e) => e.approved === true).length;
-    const denialCount = policySnapshot.recentPermissionAudit.filter((e) => e.approved === false).length;
-    const pendingCount = policySnapshot.recentPermissionAudit.filter((e) => e.approved === undefined).length;
+    const audit = this.policyRuntimeState.getSnapshot().recentPermissionAudit;
+    const approvalCount = audit.filter((e) => e.approved === true).length;
+    const denialCount = audit.filter((e) => e.approved === false).length;
+    const pendingCount = audit.filter((e) => e.approved === undefined).length;
+
+    const selected = this.getSelectedItem() ?? null;
+
+    // ---- Posture summary (severity + counts first) ----
+    const headerLines: Line[] = [
+      buildPanelLine(width, [
+        ['  ', C.label],
+        ...buildStatusBadge('pending', 'pending', { count: pendingCount }),
+        ['   ', C.dim],
+        ...buildStatusBadge('completed', 'approved', { count: approvalCount }),
+        ['   ', C.dim],
+        ...buildStatusBadge('failed', 'denied', { count: denialCount }),
+      ]),
+      pendingCount > 0
+        ? buildPanelLine(width, [[`  ${pendingCount} request${pendingCount !== 1 ? 's' : ''} awaiting a decision — select one to see its review path.`, C.warn]])
+        : buildPanelLine(width, [
+            ['  p ', C.info],
+            ['/policy simulate — preview which requests a scoped rule change would auto-approve', C.dim],
+          ]),
+    ];
 
-    const selected = APPROVAL_ROWS[this.selectedIndex] ?? null;
+    // ---- Detail block for the selected request ----
     const detailLines: Line[] = [];
     if (selected) {
-      detailLines.push(buildPanelLine(width, [['  Selected Lane', C.label]]));
-      detailLines.push(buildKeyValueLine(width, [
-        { label: 'lane', value: selected[0], valueColor: C.info },
-        { label: 'next review', value: selected[2], valueColor: C.dim },
+      const review = reviewFor(selected);
+      const decision = decisionOf(selected);
+      detailLines.push(...buildDetailBlock(width, `Request · ${selected.tool}`, [
+        buildKeyValueLine(width, [
+          { label: 'decision', value: decision, valueColor: decision === 'pending' ? C.info : decision === 'approved' ? C.good : C.bad },
+          { label: 'risk', value: selected.riskLevel, valueColor: riskColor(selected.riskLevel) },
+          { label: 'lane', value: laneOf(selected), valueColor: C.info },
+        ], C),
+        buildKeyValueLine(width, [
+          { label: 'requested', value: fmtAgo(selected.requestedAt), valueColor: C.dim },
+          ...(selected.decidedAt ? [{ label: 'decided', value: fmtAgo(selected.decidedAt), valueColor: C.dim }] : []),
+          ...(selected.target ? [{ label: 'target', value: truncateDisplay(selected.target, 24), valueColor: C.value }] : []),
+        ], C),
+        ...buildBodyText(width, selected.summary, C, C.value),
+        ...(selected.reasons[0]
+          ? buildBodyText(width, `why prompted: ${selected.reasons[0]}`, C, C.dim)
+          : buildBodyText(width, `why prompted: ${review.why}`, C, C.dim)),
+        // WO-160: dropped the printed `review.command` guidance line here —
+        // Enter is already wired by the shell to dispatch that exact command
+        // (see onSelect below and the "Enter: review (<command>)" footer
+        // hint), so restating it as a signpost was a pure action substitute.
       ], C));
-      detailLines.push(buildPanelLine(width, [[` ${selected[1]}`, C.value]]));
-      detailLines.push(buildGuidanceLine(width, selected[2].replace('review via ', ''), `open the ${selected[0]} review path`, C));
-    }
-
-    const recentAuditLines: Line[] = [];
-    for (const entry of policySnapshot.recentPermissionAudit.slice(0, 5)) {
-      const decision = entry.approved === undefined ? 'pending' : entry.approved ? 'approved' : 'denied';
-      const decisionColor = entry.approved === undefined ? C.info : entry.approved ? C.good : C.bad;
-      recentAuditLines.push(buildPanelLine(width, [
-        [`  ${decision.padEnd(8)}`, decisionColor],
-        [`${entry.tool}`.padEnd(14), C.label],
-        [entry.summary.slice(0, Math.max(0, width - 28)), C.value],
-      ]));
-      if (entry.reasons[0]) {
-        recentAuditLines.push(buildPanelLine(width, [[`    ${entry.reasons[0]}`, C.dim]]));
-      }
-    }
-    if (recentAuditLines.length === 0) {
-      recentAuditLines.push(buildPanelLine(width, [[`  No recent approval pressure. Live requests and decisions will appear here.`, C.dim]]));
     }
 
+    // ---- Durable-rule suggestions from repeated denials (dispatchable via 1/2/3) ----
+    const suggestions = this.getRuleSuggestions();
     const ruleSuggestionLines: Line[] = [];
-    for (const suggestion of buildPermissionRuleSuggestions(policySnapshot.recentPermissionAudit).slice(0, 3)) {
-      ruleSuggestionLines.push(buildPanelLine(width, [[`  ${suggestion.summary}`, C.info]]));
+    suggestions.forEach((suggestion, index) => {
+      ruleSuggestionLines.push(buildPanelLine(width, [
+        [`  ${index + 1}) `, C.info],
+        [truncateDisplay(suggestion.summary, Math.max(0, width - 8)), C.info],
+      ]));
       ruleSuggestionLines.push(buildGuidanceLine(width, suggestion.command, suggestion.reason, C));
-    }
-    if (ruleSuggestionLines.length === 0) {
-      ruleSuggestionLines.push(buildPanelLine(width, [[`  No repeated denials currently suggest a durable rule.`, C.dim]]));
+    });
+    if (ruleSuggestionLines.length > 0) {
+      ruleSuggestionLines.unshift(buildPanelLine(width, [['  Suggested durable rules (press 1/2/3 to apply)', C.label]]));
     }
 
-    const headerLines: Line[] = [
-      buildPanelLine(width, [['  Approval posture', C.label]]),
-      buildKeyValueLine(width, [
-        { label: 'why prompted', value: 'risk summary', valueColor: C.value },
-        { label: 'what-if', value: '/policy simulate + preflight', valueColor: C.info },
-        { label: 'operator', value: '/security + /cockpit', valueColor: C.good },
-      ], C),
-      buildPanelLine(width, [
-        ['  \u2713 ', C.good],
-        [`approvals (${approvalCount})  `, C.good],
-        ['\u2715 ', C.bad],
-        [`denials (${denialCount})  `, C.bad],
-        ['\u25cb ', C.info],
-        [`pending (${pendingCount})`, C.info],
-      ]),
-      buildGuidanceLine(width, '/approval review shell', 'inspect the highest-risk approval lane and refine scoped review posture', C),
-      ...detailLines,
-      ...recentAuditLines,
-      ...ruleSuggestionLines,
-    ];
+    // ---- Context-aware footer: only show review key when a request is selected ----
+    const hints = selected
+      ? [
+          { keys: '↑/↓', label: 'select' },
+          { keys: 'Enter', label: `review (${reviewFor(selected).command})` },
+          { keys: 'g/G', label: 'top/bottom' },
+        ]
+      : [
+          { keys: '↑/↓', label: 'select' },
+          { keys: 'g/G', label: 'top/bottom' },
+        ];
+    if (suggestions.length > 0) hints.push({ keys: '1-3', label: 'apply rule suggestion' });
+    if (pendingCount === 0) hints.push({ keys: 'p', label: 'policy simulate' });
 
     return this.renderList(width, height, {
       title: 'Approval Control Room',
       header: headerLines,
-      footer: [buildPanelLine(width, [[`  Up/Down move  Home/End jump  selected lane opens the next command path`, C.dim]])],
+      footer: [...detailLines, ...ruleSuggestionLines, buildKeyboardHints(width, hints, C)],
     });
   }
+
+  protected override onSelect(item: PermissionAuditEntry): void {
+    void item; // Enter is wired by the shell to open getSelectedCommand(); selection model lives here.
+  }
 }