@yagni-app/code 1.0.6 → 1.0.7

package/dist/extension/sandbox/manager.js

@@ -0,0 +1,216 @@
+/**
+ * Sandbox manager adapter — wraps @anthropic-ai/sandbox-runtime's
+ * SandboxManager with YAGNI Code wiring: dependency check against the
+ * vendored ripgrep, settings-derived runtime config (config.ts merge), and
+ * an injectable network ask-callback so the UI layer owns prompting (M5)
+ * while headless fails closed (deny).
+ *
+ * All state is session-scoped behind a single holder; nothing module-global
+ * is mutated except the underlying srt manager, which initialize/reset
+ * bracket. Pure functions (config building) live in config.ts.
+ */
+import { SandboxManager as SrtSandboxManager } from "@anthropic-ai/sandbox-runtime";
+import { logEvent } from "../errorSink.js";
+import { codeStateHome } from "../stateHome.js";
+import { loadSandboxSettings, mergeRulesIntoSandbox, } from "./config.js";
+/** Default vendored rg shipped with the CLI install. */
+export function defaultRgPath(env = process.env) {
+    const agentDir = env.PI_CODING_AGENT_DIR;
+    if (!agentDir)
+        return undefined;
+    return `${agentDir.replace(/\/$/, "")}/bin/rg`;
+}
+export class YagniSandboxManager {
+    state = { initialized: false, dependencies: null, settings: null };
+    askHandler = null;
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+        this.askHandler = opts.askHandler ?? null;
+    }
+    get initialized() { return this.state.initialized; }
+    get settings() { return this.state.settings; }
+    get dependencies() { return this.state.dependencies; }
+    setAskHandler(handler) {
+        this.askHandler = handler;
+    }
+    /** The failure-trail wrapper handed to srt — exported for tests so the
+     * catch-and-log contract (fail closed + sink line) is observable without
+     * driving a real wrapped network connection. */
+    async networkAsk(host) {
+        if (!this.askHandler)
+            return false; // fail closed (headless)
+        try {
+            return await this.askHandler(host);
+        }
+        catch (err) {
+            // Fail closed, but never silently — a denied host with no trail is
+            // undebuggable. Metadata only (host + error class): no command content.
+            logEvent({
+                source: "sandbox",
+                level: "warn",
+                event: "network_ask_failed",
+                fields: {
+                    host,
+                    errorClass: err instanceof Error ? err.constructor.name : String(err),
+                },
+            });
+            return false;
+        }
+    }
+    checkDependencies() {
+        // No explicit rgPath/PI_CODING_AGENT_DIR: fall through to srt's own check,
+        // which uses { command: 'rg' } and consults PATH — rg on PATH is a
+        // legitimate resolution (CI runners, bare-metal Linux installs). The
+        // vendored-rg case is the explicit path above.
+        const rg = this.opts.rgPath ?? defaultRgPath(this.opts.env ?? process.env);
+        const check = rg
+            ? SrtSandboxManager.checkDependencies({ command: rg, args: ["--version"] })
+            : SrtSandboxManager.checkDependencies();
+        return { errors: [...check.errors], warnings: [...check.warnings] };
+    }
+    /**
+     * Build the runtime filesystem/network config from current settings +
+     * permission rules. Exposed for diagnostics (/sandbox config display) and
+     * tests; initialize() consumes it internally.
+     */
+    buildRuntimeMerge(rules) {
+        const { settings } = loadSandboxSettings({
+            cwd: this.opts.cwd,
+            env: this.opts.env,
+            userHome: this.opts.userHome,
+            stateHomeOverride: this.opts.stateHomeOverride,
+        });
+        return mergeRulesIntoSandbox(settings, rules, {
+            cwd: this.opts.cwd,
+            userStateHome: this.opts.stateHomeOverride ?? codeStateHome(null, this.opts.env, this.opts.userHome),
+            projectRoot: this.opts.projectRoot ?? null,
+            homeDir: this.opts.userHome,
+        });
+    }
+    runtimeConfig(merge, settings) {
+        return {
+            network: {
+                allowedDomains: merge.network.allowedDomains,
+                deniedDomains: merge.network.deniedDomains,
+                allowUnixSockets: merge.network.allowUnixSockets,
+                allowAllUnixSockets: merge.network.allowAllUnixSockets,
+                allowLocalBinding: merge.network.allowLocalBinding,
+                httpProxyPort: merge.network.httpProxyPort,
+                socksProxyPort: merge.network.socksProxyPort,
+            },
+            filesystem: {
+                allowRead: merge.filesystem.allowRead,
+                denyRead: merge.filesystem.denyRead,
+                allowWrite: merge.filesystem.allowWrite,
+                denyWrite: merge.filesystem.denyWrite,
+            },
+            ignoreViolations: settings.ignoreViolations,
+            enableWeakerNestedSandbox: settings.enableWeakerNestedSandbox,
+            enableWeakerNetworkIsolation: settings.enableWeakerNetworkIsolation,
+        };
+    }
+    /**
+     * Initialize srt for this session. Returns an error string when the sandbox
+     * cannot start (deps/platform) — the caller decides fail-soft (notify) vs
+     * fail-hard (refuse to run, `failIfUnavailable`). Idempotent: a second call
+     * while initialized is a no-op.
+     *
+     * `force` bypasses the disk `enabled` check: the session-level toggle
+     * (/sandbox enable, Alt+S) must be able to START the sandbox in a
+     * default-off config — that is its entire purpose. Config-driven starts
+     * (session_start) never pass force.
+     */
+    async initialize(rules, opts = {}) {
+        if (this.state.initialized)
+            return undefined;
+        // Config-first (Claude's order): a sandbox the user did not enable must
+        // never report a dependency problem — disabled is disabled regardless of
+        // the machine's health. `force` (session toggle) reads config the same
+        // way; the dep check below still guards the actual start.
+        const load = loadSandboxSettings({
+            cwd: this.opts.cwd,
+            env: this.opts.env,
+            userHome: this.opts.userHome,
+            stateHomeOverride: this.opts.stateHomeOverride,
+        });
+        if (!load.settings.enabled && !opts.force)
+            return "sandbox disabled by config";
+        const deps = this.checkDependencies();
+        this.state.dependencies = deps;
+        if (deps.errors.length > 0)
+            return `sandbox dependencies unavailable: ${deps.errors.join(", ")}`;
+        const merge = this.buildRuntimeMerge(rules);
+        const ask = async (hostPattern) => this.networkAsk(hostPattern.host);
+        try {
+            await SrtSandboxManager.initialize(this.runtimeConfig(merge, load.settings), ask);
+        }
+        catch (err) {
+            this.state.dependencies = null;
+            return `sandbox initialization failed: ${err instanceof Error ? err.message : String(err)}`;
+        }
+        this.state.initialized = true;
+        this.state.settings = load.settings;
+        this.opts.events?.onStateChange?.(true);
+        return undefined;
+    }
+    /**
+     * Rebuild + push the srt config without reset (settings changed or a grant
+     * landed). No-op when not initialized.
+     */
+    refreshConfig(rules) {
+        if (!this.state.initialized)
+            return;
+        const merge = this.buildRuntimeMerge(rules);
+        SrtSandboxManager.updateConfig(this.runtimeConfig(merge, loadSandboxSettings({
+            cwd: this.opts.cwd,
+            env: this.opts.env,
+            userHome: this.opts.userHome,
+            stateHomeOverride: this.opts.stateHomeOverride,
+        }).settings));
+    }
+    /**
+     * Re-init from scratch (config grant changed semantics srt can't hot-swap,
+     * or a toggle). Tears down proxies + violation store first.
+     */
+    async reinitialize(rules) {
+        if (this.state.initialized) {
+            await this.reset();
+        }
+        return this.initialize(rules);
+    }
+    /** Tear down srt (proxies, violation store, seatbelt state). */
+    async reset() {
+        this.state = { initialized: false, dependencies: null, settings: null };
+        try {
+            await SrtSandboxManager.reset();
+        }
+        catch {
+            // teardown errors are non-fatal; state is already cleared
+        }
+        this.opts.events?.onStateChange?.(false);
+    }
+    // --- command wrapping (thin, typed passthroughs) ---
+    async wrapWithSandbox(command, binShell) {
+        if (!this.state.initialized)
+            return command;
+        return SrtSandboxManager.wrapWithSandbox(command, binShell);
+    }
+    cleanupAfterCommand() {
+        if (!this.state.initialized)
+            return;
+        SrtSandboxManager.cleanupAfterCommand();
+    }
+    annotateStderrWithSandboxFailures(command, stderr) {
+        if (!this.state.initialized)
+            return stderr;
+        return SrtSandboxManager.annotateStderrWithSandboxFailures(command, stderr);
+    }
+    getProxyPort() {
+        return this.state.initialized ? SrtSandboxManager.getProxyPort() : undefined;
+    }
+    getSocksProxyPort() {
+        return this.state.initialized ? SrtSandboxManager.getSocksProxyPort() : undefined;
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/extension/sandbox/panel.d.ts

@@ -0,0 +1,111 @@
+/**
+ * /sandbox interactive TUI panel — mirrors Claude Code's SandboxSettings
+ * tabs (Mode / Overrides / Config, plus Dependencies when checkDependencies
+ * reports errors). Rendered via ctx.ui.custom() in TUI mode; RPC/headless
+ * keeps the text summary (custom() is unavailable there).
+ *
+ * Structure follows Claude's components (SandboxSettings/SandboxModeTab/
+ * SandboxOverridesTab/SandboxConfigTab): tabs switched with left/right,
+ * SelectList-driven option tabs, read-only config tab, off-state
+ * placeholders on Overrides/Config. Copy mirrors Claude's where the
+ * mechanism is identical; persistence deviates deliberately (see
+ * persistSandboxMode in session.ts) until the project-local settings tier
+ * lands.
+ *
+ * Input contract (verified against pi's interactive mode): pi focuses the
+ * ROOT component and calls only root.handleInput(data). Children without
+ * their own handleInput (Box, Text) are never consulted — so the panel
+ * keeps a direct reference to the active SelectList and forwards keys to
+ * it. A Box wrapper does NOT forward input.
+ */
+import { Container, type SelectItem } from "@earendil-works/pi-tui";
+import { type SandboxRuntimeMerge, type SandboxRuntimePaths, type SandboxSettings } from "./config.js";
+import type { RenderTheme } from "../subagentRender.js";
+import type { PermissionRule } from "../permissionRules/loadConfig.js";
+export type SandboxPanelTab = "mode" | "overrides" | "config" | "dependencies";
+export type SandboxModeChoice = "auto-allow" | "regular" | "disabled";
+export type SandboxOverrideChoice = "open" | "closed";
+/** Everything the panel needs, resolved by the caller (session.ts). */
+export interface SandboxPanelState {
+    settings: SandboxSettings;
+    /** Session-only toggle state (false = forced off this session). */
+    sessionToggledOff: boolean;
+    /** Dependencies status for the Dependencies tab + warnings on Config. */
+    dependencyErrors: string[];
+    dependencyWarnings: string[];
+    /** Runtime merge output (rules + settings) for the Config tab. */
+    merge: SandboxRuntimeMerge;
+    /** Domains granted this session (memory-only). */
+    sessionGrants: string[];
+}
+export interface SandboxPanelActions {
+    /** Persist a mode choice. Resolves with the confirmation to surface
+     * after the panel closes (Claude's onComplete(message) contract). */
+    onModeSelect: (choice: SandboxModeChoice) => Promise<SandboxPanelOutcome>;
+    /** Persist an override choice. Same contract. */
+    onOverrideSelect: (choice: SandboxOverrideChoice) => Promise<SandboxPanelOutcome>;
+}
+/** What the panel hands back when it closes: the confirmation (or error)
+ * the session surfaces via notify once custom() resolves. */
+export interface SandboxPanelOutcome {
+    text: string;
+    level: "info" | "error";
+}
+/** Current mode derived from resolved settings (Claude's currentMode). */
+export declare function deriveCurrentMode(settings: SandboxSettings, sessionToggledOff: boolean): SandboxModeChoice;
+export declare function deriveCurrentOverride(settings: SandboxSettings): SandboxOverrideChoice;
+export declare function modeOptions(current: SandboxModeChoice): SelectItem[];
+export declare function overrideOptions(current: SandboxOverrideChoice): SelectItem[];
+/** Per-mode explanation (Claude's copy, adapted to our surfaces). */
+export declare function modeExplanation(mode: SandboxModeChoice): string;
+export declare function overrideExplanation(choice: SandboxOverrideChoice): string;
+/**
+ * Config tab sections, conditional like Claude's SandboxConfigTab: empty
+ * sections are omitted entirely (Excluded Commands — Claude's one always-on
+ * section — shows None). Structured as title + detail lines so the tab can
+ * space sections apart instead of rendering one dense text block.
+ */
+export interface ConfigSection {
+    title: string;
+    detail: string[];
+}
+export declare function configSections(state: SandboxPanelState): ConfigSection[];
+/** Tabs offered, mirroring Claude: Dependencies appears only on errors. */
+export declare function panelTabs(dependencyErrors: string[]): SandboxPanelTab[];
+/**
+ * The /sandbox panel. Structure: top border · tab strip · blank · tab
+ * content · blank · footer · bottom border. pi focuses this root and calls
+ * its handleInput; the panel forwards keys to the active tab's SelectList
+ * (when one exists) and switches tabs on left/right.
+ */
+export declare class SandboxPanel extends Container {
+    private readonly state;
+    private readonly actions;
+    private readonly theme;
+    private readonly done;
+    private activeTab;
+    private readonly tabs;
+    /** The active tab's SelectList (mode/overrides) or null (config/deps) —
+     * input forwards here. */
+    private activeList;
+    /** Padded content frame; children[0] = tab strip, children[1] = body. */
+    private readonly content;
+    constructor(state: SandboxPanelState, actions: SandboxPanelActions, theme: RenderTheme, done: (outcome?: SandboxPanelOutcome) => void);
+    private setTab;
+    private buildBody;
+    private buildTabContent;
+    private buildModeTab;
+    private buildOverridesTab;
+    private buildConfigTab;
+    private buildDependenciesTab;
+    handleInput(data: string): void;
+}
+/**
+ * Build the panel state from the pieces session.ts already holds. Exported
+ * for unit tests; the TUI component consumes it.
+ */
+export declare function buildPanelState(settings: SandboxSettings, sessionToggledOff: boolean, rules: readonly PermissionRule[], paths: SandboxRuntimePaths, sessionGrants: readonly string[], dependencyStatus: {
+    errors: string[];
+    warnings: string[];
+}): SandboxPanelState;
+//# sourceMappingURL=panel.d.ts.map

package/dist/extension/sandbox/panel.js

@@ -0,0 +1,342 @@
+/**
+ * /sandbox interactive TUI panel — mirrors Claude Code's SandboxSettings
+ * tabs (Mode / Overrides / Config, plus Dependencies when checkDependencies
+ * reports errors). Rendered via ctx.ui.custom() in TUI mode; RPC/headless
+ * keeps the text summary (custom() is unavailable there).
+ *
+ * Structure follows Claude's components (SandboxSettings/SandboxModeTab/
+ * SandboxOverridesTab/SandboxConfigTab): tabs switched with left/right,
+ * SelectList-driven option tabs, read-only config tab, off-state
+ * placeholders on Overrides/Config. Copy mirrors Claude's where the
+ * mechanism is identical; persistence deviates deliberately (see
+ * persistSandboxMode in session.ts) until the project-local settings tier
+ * lands.
+ *
+ * Input contract (verified against pi's interactive mode): pi focuses the
+ * ROOT component and calls only root.handleInput(data). Children without
+ * their own handleInput (Box, Text) are never consulted — so the panel
+ * keeps a direct reference to the active SelectList and forwards keys to
+ * it. A Box wrapper does NOT forward input.
+ */
+import { Box, Container, HStack, Key, SelectList, Text, matchesKey, } from "@earendil-works/pi-tui";
+import { mergeRulesIntoSandbox } from "./config.js";
+// ---------------------------------------------------------------------------
+// Pure derivation helpers (unit-tested; no TUI dependency)
+// ---------------------------------------------------------------------------
+/** Current mode derived from resolved settings (Claude's currentMode). */
+export function deriveCurrentMode(settings, sessionToggledOff) {
+    if (!settings.enabled || sessionToggledOff)
+        return "disabled";
+    return settings.autoAllowBashIfSandboxed !== false ? "auto-allow" : "regular";
+}
+export function deriveCurrentOverride(settings) {
+    return settings.allowUnsandboxedCommands !== false ? "open" : "closed";
+}
+export function modeOptions(current) {
+    return [
+        { value: "auto-allow", label: `Sandbox BashTool, with auto-allow${current === "auto-allow" ? " (current)" : ""}` },
+        { value: "regular", label: `Sandbox BashTool, with regular permissions${current === "regular" ? " (current)" : ""}` },
+        { value: "disabled", label: `No Sandbox${current === "disabled" ? " (current)" : ""}` },
+    ];
+}
+export function overrideOptions(current) {
+    return [
+        { value: "open", label: `Allow unsandboxed fallback${current === "open" ? " (current)" : ""}` },
+        { value: "closed", label: `Strict sandbox mode${current === "closed" ? " (current)" : ""}` },
+    ];
+}
+/** Per-mode explanation (Claude's copy, adapted to our surfaces). */
+export function modeExplanation(mode) {
+    switch (mode) {
+        case "auto-allow":
+            return "Bash commands run inside the OS sandbox and are auto-allowed; explicit deny/ask permission rules still win. Writes stay confined to the workspace and /tmp; network follows the domain allowlist.";
+        case "regular":
+            return "Bash commands run inside the OS sandbox, but each command still goes through the normal permission flow (sandboxed execution is not auto-allowed).";
+        case "disabled":
+            return "No OS-level sandbox. Bash commands run through the ordinary permission system only.";
+    }
+}
+export function overrideExplanation(choice) {
+    return choice === "open"
+        ? "When a command fails due to sandbox restrictions, the agent can retry with dangerouslyDisableSandbox to run outside the sandbox (falling back to default permissions)."
+        : "All bash commands invoked by the model must run in the sandbox unless they are explicitly listed in excludedCommands.";
+}
+export function configSections(state) {
+    const { settings, merge } = state;
+    const sections = [];
+    const excluded = settings.excludedCommands ?? [];
+    sections.push({
+        title: "Excluded Commands",
+        detail: [excluded.length > 0 ? excluded.join(", ") : "None"],
+    });
+    if (merge.filesystem.denyRead.length > 0) {
+        const detail = [`Denied: ${merge.filesystem.denyRead.join(", ")}`];
+        if (merge.filesystem.allowRead.length > 0)
+            detail.push(`Allowed within denied: ${merge.filesystem.allowRead.join(", ")}`);
+        sections.push({ title: "Filesystem Read Restrictions", detail });
+    }
+    if (merge.filesystem.allowWrite.length > 0) {
+        const detail = [`Allowed: ${merge.filesystem.allowWrite.join(", ")}`];
+        if (merge.filesystem.denyWrite.length > 0)
+            detail.push(`Denied within allowed: ${merge.filesystem.denyWrite.join(", ")}`);
+        sections.push({ title: "Filesystem Write Restrictions", detail });
+    }
+    if (merge.network.allowedDomains.length > 0 || merge.network.deniedDomains.length > 0) {
+        const detail = [];
+        if (merge.network.allowedDomains.length > 0)
+            detail.push(`Allowed: ${merge.network.allowedDomains.join(", ")}`);
+        if (merge.network.deniedDomains.length > 0)
+            detail.push(`Denied: ${merge.network.deniedDomains.join(", ")}`);
+        sections.push({ title: "Network Restrictions", detail });
+    }
+    const unixSockets = settings.network?.allowUnixSockets ?? [];
+    if (unixSockets.length > 0)
+        sections.push({ title: "Allowed Unix Sockets", detail: [unixSockets.join(", ")] });
+    if (state.sessionGrants.length > 0) {
+        sections.push({ title: "Session Grants (memory-only)", detail: [state.sessionGrants.join(", ")] });
+    }
+    return sections;
+}
+/** Tabs offered, mirroring Claude: Dependencies appears only on errors. */
+export function panelTabs(dependencyErrors) {
+    const tabs = ["mode", "overrides", "config"];
+    if (dependencyErrors.length > 0)
+        tabs.push("dependencies");
+    return tabs;
+}
+// ---------------------------------------------------------------------------
+// TUI component
+// ---------------------------------------------------------------------------
+const TAB_LABELS = {
+    mode: "Mode",
+    overrides: "Overrides",
+    config: "Config",
+    dependencies: "Dependencies",
+};
+/** Horizontal breathing room for panel content — the same left/right
+ * margin the footer chip uses. The border lines span the full width;
+ * everything between them is inset by this. */
+const CONTENT_PADDING_X = 2;
+function selectListTheme(theme) {
+    return {
+        selectedPrefix: (t) => theme.fg("accent", t),
+        selectedText: (t) => theme.fg("accent", t),
+        description: (t) => theme.fg("muted", t),
+        scrollInfo: (t) => theme.fg("muted", t),
+        noMatch: (t) => theme.fg("muted", t),
+    };
+}
+/** Full-width border line (the house DynamicBorder pattern, color fn passed
+ * explicitly — extensions never read pi's global theme). */
+class Border {
+    color;
+    constructor(color) {
+        this.color = color;
+    }
+    render(width) {
+        return [this.color("─".repeat(Math.max(1, width)))];
+    }
+    invalidate() { }
+}
+/**
+ * The /sandbox panel. Structure: top border · tab strip · blank · tab
+ * content · blank · footer · bottom border. pi focuses this root and calls
+ * its handleInput; the panel forwards keys to the active tab's SelectList
+ * (when one exists) and switches tabs on left/right.
+ */
+export class SandboxPanel extends Container {
+    state;
+    actions;
+    theme;
+    done;
+    activeTab;
+    tabs;
+    /** The active tab's SelectList (mode/overrides) or null (config/deps) —
+     * input forwards here. */
+    activeList = null;
+    /** Padded content frame; children[0] = tab strip, children[1] = body. */
+    content;
+    constructor(state, actions, theme, done) {
+        super();
+        this.state = state;
+        this.actions = actions;
+        this.theme = theme;
+        this.done = done;
+        this.tabs = panelTabs(state.dependencyErrors);
+        this.activeTab = this.tabs[0];
+        this.content = new Box(CONTENT_PADDING_X, 0);
+        this.content.addChild(new Text("", 0, 0)); // tab strip placeholder
+        this.content.addChild(new Text("", 0, 0)); // body placeholder
+        this.addChild(new Border((s) => theme.fg("borderMuted", s)));
+        this.addChild(this.content);
+        this.addChild(new Border((s) => theme.fg("borderMuted", s)));
+        this.setTab(this.activeTab);
+    }
+    setTab(tab) {
+        this.activeTab = tab;
+        const t = this.theme;
+        const parts = this.tabs.map((candidate) => {
+            const active = candidate === tab;
+            return t.fg(active ? "accent" : "muted", `${active ? "[" : " "}${TAB_LABELS[candidate]}${active ? "]" : " "}`);
+        });
+        const strip = new HStack();
+        strip.addChild(new Text(parts.join(""), 0, 1));
+        this.content.children[0] = strip;
+        this.content.children[1] = this.buildBody();
+        this.invalidate();
+    }
+    buildBody() {
+        const wrap = new Container();
+        wrap.addChild(this.buildTabContent());
+        // Footer on its own line with a top margin — a distinct element, and
+        // consistent across every tab.
+        wrap.addChild(new Text(this.theme.fg("muted", "left/right to switch tabs · up/down to navigate · Enter to select · Esc to close"), 0, 1));
+        return wrap;
+    }
+    buildTabContent() {
+        const t = this.theme;
+        switch (this.activeTab) {
+            case "mode":
+                return this.buildModeTab();
+            case "overrides":
+                return this.buildOverridesTab();
+            case "config":
+                return this.buildConfigTab();
+            case "dependencies":
+                return this.buildDependenciesTab();
+        }
+    }
+    buildModeTab() {
+        const t = this.theme;
+        const current = deriveCurrentMode(this.state.settings, this.state.sessionToggledOff);
+        const options = modeOptions(current);
+        const list = new SelectList(options, 10, selectListTheme(t));
+        const preselect = options.findIndex((o) => o.value === current);
+        if (preselect >= 0)
+            list.setSelectedIndex(preselect);
+        // Top margin (paddingY=1 + the container's separator) separates the
+        // explanation from the option list — it's a distinct element and reads
+        // too tight flush to it.
+        const explanation = new Text(t.fg("muted", modeExplanation(current)), 0, 1);
+        list.onSelectionChange = (item) => {
+            explanation.setText(t.fg("muted", modeExplanation(item.value)));
+            this.invalidate();
+        };
+        list.onSelect = (item) => {
+            // The outcome (confirmation or write-failure) rides done() out of the
+            // panel; the session notifies it once custom() resolves — Claude's
+            // onComplete(message) flow. It must NOT be dropped here.
+            void this.actions
+                .onModeSelect(item.value)
+                .then((outcome) => this.done(outcome))
+                .catch(() => this.done());
+        };
+        list.onCancel = () => this.done();
+        this.activeList = list;
+        const wrap = new Container();
+        wrap.addChild(new Text(t.bold("Configure mode:"), 0, 0));
+        wrap.addChild(list);
+        wrap.addChild(explanation);
+        return wrap;
+    }
+    buildOverridesTab() {
+        const t = this.theme;
+        if (!this.state.settings.enabled) {
+            this.activeList = null;
+            return new Text(t.fg("muted", "Sandbox is not enabled. Enable sandbox to configure override settings."), 0, 0);
+        }
+        const current = deriveCurrentOverride(this.state.settings);
+        const options = overrideOptions(current);
+        const list = new SelectList(options, 10, selectListTheme(t));
+        const preselect = options.findIndex((o) => o.value === current);
+        if (preselect >= 0)
+            list.setSelectedIndex(preselect);
+        const explanation = new Text(t.fg("muted", overrideExplanation(current)), 0, 1);
+        list.onSelectionChange = (item) => {
+            explanation.setText(t.fg("muted", overrideExplanation(item.value)));
+            this.invalidate();
+        };
+        list.onSelect = (item) => {
+            void this.actions
+                .onOverrideSelect(item.value)
+                .then((outcome) => this.done(outcome))
+                .catch(() => this.done());
+        };
+        list.onCancel = () => this.done();
+        this.activeList = list;
+        const wrap = new Container();
+        wrap.addChild(new Text(t.bold("Configure Overrides:"), 0, 0));
+        wrap.addChild(list);
+        wrap.addChild(explanation);
+        return wrap;
+    }
+    buildConfigTab() {
+        const t = this.theme;
+        this.activeList = null;
+        if (!this.state.settings.enabled) {
+            const lines = [t.fg("muted", "Sandbox is not enabled")];
+            for (const w of this.state.dependencyWarnings)
+                lines.push(t.fg("muted", w));
+            return new Text(lines.join("\n"), 0, 0);
+        }
+        // One block per section, bold title + muted detail lines, with a blank
+        // line between sections — a structured read, not one dense paragraph.
+        // Sections are one Text block each (bold title + detail lines), and
+        // Text(paddingY) pads ABOVE and below — so section 1 stays flush and
+        // every later section carries the blank-line separation. No doubling:
+        // Container adds no separator of its own.
+        const wrap = new Container();
+        let first = true;
+        for (const section of configSections(this.state)) {
+            const block = [t.bold(section.title), ...section.detail.map((d) => t.fg("muted", d))].join("\n");
+            wrap.addChild(new Text(block, 0, first ? 0 : 1));
+            first = false;
+        }
+        if (this.state.dependencyWarnings.length > 0) {
+            wrap.addChild(new Text(this.state.dependencyWarnings.map((w) => t.fg("warning", w)).join("\n"), 0, 1));
+        }
+        return wrap;
+    }
+    buildDependenciesTab() {
+        const t = this.theme;
+        this.activeList = null;
+        const lines = this.state.dependencyErrors.map((e) => t.fg("error", e));
+        lines.push(...this.state.dependencyWarnings.map((w) => t.fg("warning", w)));
+        return new Text(lines.join("\n"), 0, 0);
+    }
+    handleInput(data) {
+        // Tab switching first — works from every tab (Claude's </> + arrows).
+        if (matchesKey(data, Key.left) || matchesKey(data, "<")) {
+            const i = this.tabs.indexOf(this.activeTab);
+            this.setTab(this.tabs[(i - 1 + this.tabs.length) % this.tabs.length]);
+            return;
+        }
+        if (matchesKey(data, Key.right) || matchesKey(data, ">")) {
+            const i = this.tabs.indexOf(this.activeTab);
+            this.setTab(this.tabs[(i + 1) % this.tabs.length]);
+            return;
+        }
+        if (matchesKey(data, Key.escape)) {
+            this.done();
+            return;
+        }
+        // Everything else (up/down/enter) goes to the active SelectList.
+        this.activeList?.handleInput(data);
+        this.invalidate();
+    }
+}
+/**
+ * Build the panel state from the pieces session.ts already holds. Exported
+ * for unit tests; the TUI component consumes it.
+ */
+export function buildPanelState(settings, sessionToggledOff, rules, paths, sessionGrants, dependencyStatus) {
+    return {
+        settings,
+        sessionToggledOff,
+        dependencyErrors: dependencyStatus.errors,
+        dependencyWarnings: dependencyStatus.warnings,
+        merge: mergeRulesIntoSandbox(settings, rules, paths),
+        sessionGrants: [...sessionGrants],
+    };
+}
+//# sourceMappingURL=panel.js.map