@gotgenes/pi-permission-system 20.5.0 → 20.7.0

package/src/authority/permission-prompt-component.ts

@@ -0,0 +1,273 @@
+import type {
+  ExtensionContext,
+  ExtensionUIContext,
+} from "@earendil-works/pi-coding-agent";
+import { type Component, matchesKey } from "@earendil-works/pi-tui";
+import {
+  type PermissionPromptDecision,
+  type RequestPermissionOptions,
+  requestPermissionDecisionFromUi,
+} from "#src/authority/permission-dialog";
+import {
+  initialPromptState,
+  type PromptEvent,
+  type PromptKey,
+  type PromptModelConfig,
+  type PromptViewState,
+  reducePrompt,
+} from "#src/authority/permission-prompt-decision";
+
+/**
+ * Inline `ctx.ui.custom` permission dialog for TUI sessions.
+ *
+ * All interaction logic lives in the pure {@link reducePrompt} model; this
+ * module is the thin adapter that renders the model's state to lines, maps raw
+ * keystrokes to {@link PromptEvent}s, and resolves the `ctx.ui.custom` promise
+ * with the committed {@link PermissionPromptDecision}. The component renders
+ * inline (never as an overlay).
+ */
+
+/** The subset of the session UI surface the inline dialog needs. */
+export type PermissionPromptUi = Pick<
+  ExtensionUIContext,
+  "select" | "input" | "custom"
+>;
+
+/** The resolved presentation context selected once per activation. */
+export interface PermissionPromptView {
+  mode: ExtensionContext["mode"];
+  ui: PermissionPromptUi;
+  doublePressToConfirm: boolean;
+}
+
+/** Live prompt-behavior preferences read at prompt time (see `doublePressToConfirm`). */
+export interface PromptPreferences {
+  doublePressToConfirm: boolean;
+}
+
+/**
+ * Route a permission ask to the inline keybind dialog in TUI mode, or the
+ * `select()`/`input()` flow otherwise (RPC / frontend — the #519 constraint).
+ *
+ * The single entry the `LocalUserAuthorizer` calls; keeps the mode dispatch in
+ * one place so the fallback and the inline component never both render.
+ */
+export function requestPermissionDecision(
+  view: PermissionPromptView,
+  title: string,
+  message: string,
+  options?: RequestPermissionOptions,
+): Promise<PermissionPromptDecision> {
+  if (view.mode === "tui") {
+    return presentInlinePermissionPrompt(view, title, message, options);
+  }
+  return requestPermissionDecisionFromUi(view.ui, title, message, options);
+}
+
+/** Minimal theme surface the dialog uses; satisfied by the real SDK theme. */
+interface PromptTheme {
+  fg(color: string, text: string): string;
+}
+
+const DEFAULT_SESSION_LABEL = "Yes, for this session";
+
+const OPTION_LABELS: Record<PromptKey, string> = {
+  y: "Yes",
+  s: DEFAULT_SESSION_LABEL,
+  n: "No",
+  r: "No, provide reason",
+};
+
+const OPTION_ORDER: readonly PromptKey[] = ["y", "s", "n", "r"];
+
+export function presentInlinePermissionPrompt(
+  view: PermissionPromptView,
+  title: string,
+  message: string,
+  options?: RequestPermissionOptions,
+): Promise<PermissionPromptDecision> {
+  const config: PromptModelConfig = {
+    doublePressToConfirm: view.doublePressToConfirm,
+    sessionLabel: options?.sessionLabel ?? DEFAULT_SESSION_LABEL,
+    sessionScope: options?.sessionScope,
+  };
+  return view.ui.custom<PermissionPromptDecision>(
+    (tui, theme, _keybindings, done) =>
+      new PermissionPromptComponent(
+        theme,
+        config,
+        title,
+        message,
+        () => {
+          tui.requestRender();
+        },
+        done,
+      ),
+    { overlay: false },
+  );
+}
+
+class PermissionPromptComponent implements Component {
+  private state: PromptViewState;
+  private reasonBuffer = "";
+
+  constructor(
+    private readonly theme: PromptTheme,
+    private readonly config: PromptModelConfig,
+    private readonly title: string,
+    private readonly message: string,
+    private readonly requestRender: () => void,
+    private readonly done: (decision: PermissionPromptDecision) => void,
+  ) {
+    this.state = initialPromptState(config);
+  }
+
+  invalidate(): void {
+    // No cached rendering state to clear.
+  }
+
+  render(_width: number): string[] {
+    switch (this.state.step) {
+      case "decision":
+        return this.renderDecision();
+      case "reason":
+        return this.renderReason();
+      case "scope":
+        return this.renderScope();
+    }
+  }
+
+  handleInput(data: string): void {
+    if (this.state.step === "reason") {
+      this.handleReasonInput(data);
+      return;
+    }
+    const event = this.toEvent(data);
+    if (event) {
+      this.apply(event);
+    }
+  }
+
+  private handleReasonInput(data: string): void {
+    if (matchesKey(data, "enter")) {
+      this.apply({ type: "submitReason", draft: this.reasonBuffer });
+      return;
+    }
+    if (matchesKey(data, "escape")) {
+      this.reasonBuffer = "";
+      this.apply({ type: "cancel" });
+      return;
+    }
+    if (matchesKey(data, "backspace")) {
+      this.reasonBuffer = this.reasonBuffer.slice(0, -1);
+      this.requestRender();
+      return;
+    }
+    if (isPrintable(data)) {
+      this.reasonBuffer += data;
+      this.requestRender();
+    }
+  }
+
+  private toEvent(data: string): PromptEvent | undefined {
+    if (matchesKey(data, "up") || matchesKey(data, "k")) {
+      return { type: "nav", direction: "up" };
+    }
+    if (matchesKey(data, "down") || matchesKey(data, "j")) {
+      return { type: "nav", direction: "down" };
+    }
+    if (matchesKey(data, "enter")) {
+      return { type: "confirm" };
+    }
+    if (matchesKey(data, "escape")) {
+      return { type: "cancel" };
+    }
+    if (this.state.step === "decision") {
+      const key = OPTION_ORDER.find((option) => matchesKey(data, option));
+      if (key) {
+        return { type: "hotkey", key };
+      }
+    }
+    return undefined;
+  }
+
+  private apply(event: PromptEvent): void {
+    const outcome = reducePrompt(this.config, this.state, event);
+    if (outcome.kind === "decision") {
+      this.done(outcome.decision);
+      return;
+    }
+    if (outcome.state.step === "reason" && this.state.step !== "reason") {
+      this.reasonBuffer = "";
+    }
+    this.state = outcome.state;
+    this.requestRender();
+  }
+
+  private renderDecision(): string[] {
+    const lines = [this.theme.fg("accent", this.title), this.message, ""];
+    for (const key of OPTION_ORDER) {
+      const label = key === "s" ? this.config.sessionLabel : OPTION_LABELS[key];
+      const selected = this.state.highlightedKey === key;
+      const marker = selected ? "▶" : " ";
+      const row = `${marker} (${key}) ${label}`;
+      lines.push(selected ? this.theme.fg("accent", row) : row);
+    }
+    lines.push("");
+    lines.push(
+      this.state.hint ||
+        this.theme.fg(
+          "muted",
+          "↑/↓ move · enter confirm · esc deny · press a letter, then again to confirm",
+        ),
+    );
+    return lines;
+  }
+
+  private renderReason(): string[] {
+    const lines = [
+      this.theme.fg("accent", this.title),
+      this.message,
+      "",
+      `Reason (required): ${this.reasonBuffer}\u2588`,
+    ];
+    if (this.state.reasonError) {
+      lines.push(this.theme.fg("error", this.state.reasonError));
+    }
+    lines.push("");
+    lines.push(this.theme.fg("muted", "enter submit · esc back"));
+    return lines;
+  }
+
+  private renderScope(): string[] {
+    const scope = this.config.sessionScope;
+    const subagentLabel = scope?.subagentLabel ?? "This subagent only";
+    const servingLabel = scope?.servingSessionLabel ?? "The whole session";
+    const rows: Array<{ label: string; serving: boolean }> = [
+      { label: subagentLabel, serving: false },
+      { label: servingLabel, serving: true },
+    ];
+    const lines = [
+      this.theme.fg("accent", this.title),
+      "Apply this session grant to:",
+      "",
+    ];
+    for (const row of rows) {
+      const selected = this.state.scopeServing === row.serving;
+      const marker = selected ? "▶" : " ";
+      const text = `${marker} ${row.label}`;
+      lines.push(selected ? this.theme.fg("accent", text) : text);
+    }
+    lines.push("");
+    lines.push(this.theme.fg("muted", "↑/↓ move · enter confirm · esc back"));
+    return lines;
+  }
+}
+
+function isPrintable(data: string): boolean {
+  if (data.length !== 1) {
+    return false;
+  }
+  const code = data.charCodeAt(0);
+  return code >= 0x20 && code !== 0x7f;
+}

package/src/authority/permission-prompt-decision.ts

@@ -0,0 +1,258 @@
+import {
+  createDeniedPermissionDecision,
+  normalizePermissionDenialReason,
+  type PermissionPromptDecision,
+  type RequestPermissionOptions,
+} from "#src/authority/permission-dialog";
+
+/**
+ * Pure decision model for the inline keybind permission dialog.
+ *
+ * The interaction logic — which hotkey produces which decision, double-press
+ * arming, step transitions, and reason validation — lives here with no SDK or
+ * TUI imports, so it is unit-testable directly. The `ctx.ui.custom` component
+ * ({@link file://./permission-prompt-component.ts}) is a thin adapter that
+ * forwards keystrokes to {@link reducePrompt} and renders the returned state.
+ */
+
+/** The four decision hotkeys, in display order. */
+export type PromptKey = "y" | "s" | "n" | "r";
+
+/** Which sub-view the dialog is showing. */
+export type PromptStep = "decision" | "reason" | "scope";
+
+const OPTION_ORDER: readonly PromptKey[] = ["y", "s", "n", "r"];
+
+const OPTION_VERBS: Record<PromptKey, string> = {
+  y: "approve",
+  s: "approve for this session",
+  n: "deny",
+  r: "deny with a reason",
+};
+
+/** Static configuration for a single prompt presentation. */
+export interface PromptModelConfig {
+  /** When true, a letter hotkey arms first and commits only on a second press. */
+  doublePressToConfirm: boolean;
+  /** Label shown beside the approve-for-session option. */
+  sessionLabel: string;
+  /**
+   * Forwarded asks only: when set, confirming `s` opens a second step choosing
+   * whether the grant applies to the requesting subagent only (least-privilege
+   * default) or the whole serving session.
+   */
+  sessionScope?: NonNullable<RequestPermissionOptions["sessionScope"]>;
+}
+
+/** The re-render view state the component draws from. */
+export interface PromptViewState {
+  step: PromptStep;
+  highlightedKey: PromptKey;
+  /** Set only while awaiting the confirming second press of a hotkey. */
+  armedKey?: PromptKey;
+  /** "Press y again to approve." while armed; empty otherwise. */
+  hint: string;
+  reasonDraft: string;
+  /** Set when an empty reason submit is rejected. */
+  reasonError?: string;
+  /** Scope step: false = subagent-only (default), true = whole serving session. */
+  scopeServing: boolean;
+}
+
+/** An input event the reducer understands. */
+export type PromptEvent =
+  | { type: "nav"; direction: "up" | "down" }
+  | { type: "hotkey"; key: PromptKey }
+  | { type: "confirm" }
+  | { type: "cancel" }
+  | { type: "submitReason"; draft: string };
+
+/** Either a re-render or a terminal decision. */
+export type PromptOutcome =
+  | { kind: "render"; state: PromptViewState }
+  | { kind: "decision"; decision: PermissionPromptDecision };
+
+export function initialPromptState(
+  _config: PromptModelConfig,
+): PromptViewState {
+  return {
+    step: "decision",
+    highlightedKey: "y",
+    armedKey: undefined,
+    hint: "",
+    reasonDraft: "",
+    reasonError: undefined,
+    scopeServing: false,
+  };
+}
+
+/**
+ * Advance the dialog by one input event, returning either the next view state
+ * to render or the committed {@link PermissionPromptDecision}.
+ */
+export function reducePrompt(
+  config: PromptModelConfig,
+  state: PromptViewState,
+  event: PromptEvent,
+): PromptOutcome {
+  switch (state.step) {
+    case "decision":
+      return reduceDecisionStep(config, state, event);
+    case "reason":
+      return reduceReasonStep(state, event);
+    case "scope":
+      return reduceScopeStep(state, event);
+  }
+}
+
+function reduceDecisionStep(
+  config: PromptModelConfig,
+  state: PromptViewState,
+  event: PromptEvent,
+): PromptOutcome {
+  switch (event.type) {
+    case "nav":
+      return render({
+        ...state,
+        highlightedKey: shiftKey(state.highlightedKey, event.direction),
+        armedKey: undefined,
+        hint: "",
+      });
+    case "hotkey":
+      return pressHotkey(config, state, event.key);
+    case "confirm":
+      return commit(config, state, state.highlightedKey);
+    case "cancel":
+      return { kind: "decision", decision: createDeniedPermissionDecision() };
+    case "submitReason":
+      return render(state);
+  }
+}
+
+function pressHotkey(
+  config: PromptModelConfig,
+  state: PromptViewState,
+  key: PromptKey,
+): PromptOutcome {
+  if (!config.doublePressToConfirm || state.armedKey === key) {
+    return commit(config, state, key);
+  }
+  return render({
+    ...state,
+    highlightedKey: key,
+    armedKey: key,
+    hint: `Press ${key} again to ${OPTION_VERBS[key]}.`,
+  });
+}
+
+function commit(
+  config: PromptModelConfig,
+  state: PromptViewState,
+  key: PromptKey,
+): PromptOutcome {
+  switch (key) {
+    case "y":
+      return {
+        kind: "decision",
+        decision: { approved: true, state: "approved" },
+      };
+    case "n":
+      return { kind: "decision", decision: createDeniedPermissionDecision() };
+    case "r":
+      return render({
+        ...state,
+        step: "reason",
+        highlightedKey: "r",
+        armedKey: undefined,
+        hint: "",
+        reasonDraft: "",
+        reasonError: undefined,
+      });
+    case "s":
+      if (config.sessionScope) {
+        return render({
+          ...state,
+          step: "scope",
+          highlightedKey: "s",
+          armedKey: undefined,
+          hint: "",
+          scopeServing: false,
+        });
+      }
+      return {
+        kind: "decision",
+        decision: { approved: true, state: "approved_for_session" },
+      };
+  }
+}
+
+function reduceReasonStep(
+  state: PromptViewState,
+  event: PromptEvent,
+): PromptOutcome {
+  if (event.type === "cancel") {
+    return render({
+      ...state,
+      step: "decision",
+      armedKey: undefined,
+      hint: "",
+      reasonDraft: "",
+      reasonError: undefined,
+    });
+  }
+  if (event.type === "submitReason") {
+    const reason = normalizePermissionDenialReason(event.draft);
+    if (reason === undefined) {
+      return render({
+        ...state,
+        reasonDraft: event.draft,
+        reasonError: "A reason is required.",
+      });
+    }
+    return {
+      kind: "decision",
+      decision: createDeniedPermissionDecision(reason),
+    };
+  }
+  return render(state);
+}
+
+function reduceScopeStep(
+  state: PromptViewState,
+  event: PromptEvent,
+): PromptOutcome {
+  switch (event.type) {
+    case "nav":
+      return render({ ...state, scopeServing: event.direction === "down" });
+    case "confirm":
+      return {
+        kind: "decision",
+        decision: {
+          approved: true,
+          state: state.scopeServing
+            ? "approved_for_serving_session"
+            : "approved_for_session",
+        },
+      };
+    case "cancel":
+      return render({
+        ...state,
+        step: "decision",
+        armedKey: undefined,
+        hint: "",
+      });
+    default:
+      return render(state);
+  }
+}
+
+function shiftKey(current: PromptKey, direction: "up" | "down"): PromptKey {
+  const index = OPTION_ORDER.indexOf(current);
+  const delta = direction === "down" ? 1 : -1;
+  const next = (index + delta + OPTION_ORDER.length) % OPTION_ORDER.length;
+  return OPTION_ORDER[next] ?? current;
+}
+
+function render(state: PromptViewState): PromptOutcome {
+  return { kind: "render", state };
+}

package/src/config-loader.ts

@@ -197,6 +197,9 @@ function formatConfigIssues(error: ZodError): string[] {
  * - Array fields (piInfrastructureReadPaths) replace the base when present in
  *   the override (override-wins, same as scalars).
  */
+// Scalar knobs merged by override-replaces-base; keep in sync with
+// PermissionSystemExtensionConfig booleans (debugLog, permissionReviewLog,
+// yoloMode, doublePressToConfirm).
 export function mergeUnifiedConfigs(
   base: UnifiedPermissionConfig,
   override: UnifiedPermissionConfig,
@@ -204,7 +207,12 @@ export function mergeUnifiedConfigs(
   const merged: UnifiedPermissionConfig = {};
 
   // Boolean scalars: override replaces base when defined
-  for (const key of ["debugLog", "permissionReviewLog", "yoloMode"] as const) {
+  for (const key of [
+    "debugLog",
+    "permissionReviewLog",
+    "yoloMode",
+    "doublePressToConfirm",
+  ] as const) {
     const value = override[key] ?? base[key];
     if (value !== undefined) {
       merged[key] = value;

package/src/config-modal.ts

@@ -51,6 +51,7 @@ function cloneDefaultConfig(): PermissionSystemExtensionConfig {
     debugLog: DEFAULT_EXTENSION_CONFIG.debugLog,
     permissionReviewLog: DEFAULT_EXTENSION_CONFIG.permissionReviewLog,
     yoloMode: DEFAULT_EXTENSION_CONFIG.yoloMode,
+    doublePressToConfirm: DEFAULT_EXTENSION_CONFIG.doublePressToConfirm,
   };
 }
 
@@ -113,6 +114,14 @@ function buildSettingItems(
       currentValue: toOnOff(config.debugLog),
       values: ON_OFF,
     },
+    {
+      id: "doublePressToConfirm",
+      label: "Double-press to confirm",
+      description:
+        "Require a confirming second press of a decision hotkey in the inline TUI permission dialog",
+      currentValue: toOnOff(config.doublePressToConfirm),
+      values: ON_OFF,
+    },
   ];
 }
 
@@ -128,6 +137,8 @@ function applySetting(
       return { ...config, permissionReviewLog: value === "on" };
     case "debugLog":
       return { ...config, debugLog: value === "on" };
+    case "doublePressToConfirm":
+      return { ...config, doublePressToConfirm: value === "on" };
     default:
       return config;
   }
@@ -143,6 +154,10 @@ function syncSettingValues(
     toOnOff(config.permissionReviewLog),
   );
   settingsList.updateValue("debugLog", toOnOff(config.debugLog));
+  settingsList.updateValue(
+    "doublePressToConfirm",
+    toOnOff(config.doublePressToConfirm),
+  );
 }
 
 function getArgumentCompletions(

package/src/config-schema.ts

@@ -180,6 +180,13 @@ export const unifiedConfigSchema = z
         "Auto-approve `ask`-state permission checks, including subagent approval forwarding.\n\n⚠️ **Use with caution** — this disables all interactive confirmation prompts.",
       default: false,
     }),
+    doublePressToConfirm: z.boolean().optional().meta({
+      description:
+        "Require a confirming second press of a decision hotkey in the inline permission dialog. Applies to TUI sessions only.",
+      markdownDescription:
+        "Require a confirming second press of a decision hotkey (`y`/`s`/`n`/`r`) in the inline permission dialog before it commits — the first press arms the action and shows a `Press y again to approve.` hint.\n\nApplies to interactive **TUI** sessions only; the non-TUI (RPC/frontend) prompt keeps its single-select flow. Set to `false` to commit decisions on the first hotkey press.",
+      default: true,
+    }),
     toolInputPreviewMaxLength: z.number().int().min(1).optional().meta({
       description:
         "Maximum character length of the inline-JSON tool-input preview shown in permission prompts. Omit to use the default (200). Set to a large value to disable truncation.",

package/src/extension-config.ts

@@ -13,6 +13,8 @@ export interface PermissionSystemExtensionConfig {
   debugLog: boolean;
   permissionReviewLog: boolean;
   yoloMode: boolean;
+  /** Require a confirming second press of a decision hotkey in the inline TUI dialog. Defaults to true. */
+  doublePressToConfirm: boolean;
   /** Additional directories to auto-allow for reads as Pi infrastructure. */
   piInfrastructureReadPaths?: string[];
   /** Max length of the inline-JSON input preview shown in permission prompts. Defaults to 200. */
@@ -27,6 +29,7 @@ export const DEFAULT_EXTENSION_CONFIG: PermissionSystemExtensionConfig = {
   debugLog: false,
   permissionReviewLog: true,
   yoloMode: false,
+  doublePressToConfirm: true,
 };
 
 function resolveExtensionRoot(moduleUrl = import.meta.url): string {
@@ -58,6 +61,7 @@ export function normalizePermissionSystemConfig(
     debugLog: raw.debugLog === true,
     permissionReviewLog: raw.permissionReviewLog !== false,
     yoloMode: raw.yoloMode === true,
+    doublePressToConfirm: raw.doublePressToConfirm !== false,
   };
   if (raw.piInfrastructureReadPaths !== undefined) {
     result.piInfrastructureReadPaths = raw.piInfrastructureReadPaths;

package/src/handlers/gates/bash-external-directory.ts

@@ -2,7 +2,6 @@ import type { BashProgram } from "#src/access-intent/bash/program";
 import type { ScopedPermissionResolver } from "#src/permission-resolver";
 import { SessionApproval } from "#src/session-approval";
 import { deriveApprovalPattern } from "#src/session-rules";
-import { getNonEmptyString, toRecord } from "#src/value-guards";
 import type { GateResult } from "./descriptor";
 import { formatBashExternalDirectoryAskPrompt } from "./external-directory-messages";
 import { selectUncoveredExternalPaths } from "./external-directory-policy";
@@ -13,21 +12,21 @@ import type { ToolCallContext } from "./types";
  *
  * Reads the external paths from the injected `BashProgram` and checks whether
  * any reference directories outside the working directory. Returns `null` when the gate
- * does not apply (tool is not bash, no CWD, or no external paths found).
+ * does not apply (not a shell invocation, no command, or no external paths found).
  * Returns a `GateBypass` when all paths are allowed (by config or session rule).
  * Returns a `GateDescriptor` with multi-pattern sessionApproval for uncovered paths.
+ *
+ * The shell command (native `bash` or an aliased shell tool) is read from the
+ * injected `BashProgram`, which owns the source text it was parsed from, so
+ * this gate does not re-derive the input field name (#574).
  */
 export function describeBashExternalDirectoryGate(
   tcc: ToolCallContext,
   bashProgram: BashProgram | null,
   resolver: ScopedPermissionResolver,
 ): GateResult {
-  if (tcc.toolName !== "bash") return null;
-
-  const command = getNonEmptyString(toRecord(tcc.input).command);
-  if (!command) return null;
-
   if (!bashProgram) return null;
+  const command = bashProgram.commandText();
 
   const externalPaths = bashProgram.externalPaths();
   if (externalPaths.length === 0) return null;