@xingular/harness 0.1.7 → 1.1.1

package/dist/sdk/terminal/tui/pages/logPage.js

@@ -0,0 +1,189 @@
+import { matchesKey, stripTerminalSequences, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { redactLogText } from "../../../core/bus.js";
+const payloadOf = (event) => event.payload && typeof event.payload === 'object' ? event.payload : {};
+const stringOf = (value) => typeof value === 'string' ? value : undefined;
+const numberOf = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+function safe(text) {
+    return redactLogText(stripTerminalSequences(text)).replace(/[\x00-\x08\x0b-\x1f\x7f]/g, ' ').replace(/\t/g, '    ');
+}
+function timeOf(value) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? new Date(parsed).toLocaleTimeString() : value;
+}
+function webError(output) {
+    try {
+        const value = JSON.parse(output);
+        if (typeof value.error !== 'string')
+            return undefined;
+        const status = numberOf(value.status);
+        return `${status === undefined ? '' : `HTTP ${status}: `}${value.error}`;
+    }
+    catch {
+        return /^(?:The page could not be read:|The search could not be completed:)/.test(output) ? output : undefined;
+    }
+}
+function eventDetail(event) {
+    const payload = payloadOf(event);
+    switch (event.type) {
+        case 'context.snapshot':
+            return ['prompt and tool definitions omitted'];
+        case 'message.delta':
+        case 'message.completed':
+        case 'message.steered':
+            return ['message content omitted'];
+        case 'tool.started':
+            return [`tool ${stringOf(payload.name) ?? 'unknown'} started; inputs omitted`];
+        case 'tool.completed': {
+            const name = stringOf(payload.name) ?? 'unknown';
+            const duration = numberOf(payload.durationMs);
+            const result = [`tool ${name} ${payload.ok === false ? 'failed' : 'completed'}${duration === undefined ? '' : ` · ${duration} ms`}`];
+            const output = stringOf(payload.output);
+            const webFailure = (name === 'web_fetch' || name === 'web_search') && output ? webError(output) : undefined;
+            if (webFailure)
+                result.push(`  ${webFailure}`);
+            else if (payload.ok === false && output)
+                result.push(`  ${output}`);
+            if (payload.outputTruncated === true)
+                result.push('  recorded output was truncated');
+            return result;
+        }
+        case 'retry.started':
+        case 'retry.ended':
+            return [`attempt ${numberOf(payload.attempt) ?? '?'}${numberOf(payload.maxAttempts) === undefined ? '' : ` of ${numberOf(payload.maxAttempts)}`}${numberOf(payload.delayMs) === undefined ? '' : ` · retry delay ${numberOf(payload.delayMs)} ms`}`, ...(stringOf(payload.error) ? [`  ${payload.error}`] : [])];
+        case 'compaction.ended':
+            return [payload.aborted === true ? 'compaction aborted' : 'compaction completed', ...(stringOf(payload.error) ? [`  ${payload.error}`] : [])];
+        case 'extension.notice':
+            return payload.kind === 'error' || payload.level === 'error' ? [stringOf(payload.text) ?? 'extension error'] : ['non-error extension notice omitted'];
+        case 'account.status': {
+            const message = stringOf(payload.message);
+            return [stringOf(payload.category) ?? 'account status', ...(message ? [message] : [])];
+        }
+        case 'status.changed': {
+            const reason = stringOf(payload.reason);
+            return [stringOf(payload.status) ?? 'status changed', ...(reason ? [reason] : [])];
+        }
+        case 'failed': {
+            const message = stringOf(payload.message);
+            return [stringOf(payload.code) ?? 'run failed', ...(message ? [message] : [])];
+        }
+        case 'usage.updated': {
+            const request = payload.request && typeof payload.request === 'object' ? payload.request : {};
+            return [`${stringOf(request.provider) ?? stringOf(payload.provider) ?? 'provider'}/${stringOf(request.model) ?? stringOf(payload.model) ?? 'model'} · request ${numberOf(request.index) ?? numberOf(payload.requests) ?? '?'}`];
+        }
+        case 'approval.requested':
+        case 'approval.resolved':
+            return [`tool ${stringOf(payload.target) ?? ''} · decision ${stringOf(payload.decision) ?? 'pending'}; action details omitted`];
+        case 'question.requested':
+        case 'question.answered':
+            return ['question content omitted'];
+        default:
+            return [];
+    }
+}
+export function formatRunEventLog(snapshots) {
+    if (!snapshots.length)
+        return 'No run events recorded for this conversation.';
+    const sections = [];
+    for (const snapshot of snapshots) {
+        sections.push(`Run ${snapshot.run.id} · ${snapshot.run.status} · ${snapshot.run.mode}`);
+        const events = snapshot.events.slice().sort((left, right) => left.sequence - right.sequence);
+        if (!events.length)
+            sections.push('  No recorded events');
+        for (const event of events) {
+            sections.push(`${timeOf(event.timestamp)}  #${event.sequence}  ${event.type}`);
+            sections.push(...eventDetail(event).map(detail => `  ${detail}`));
+        }
+        sections.push('');
+    }
+    return safe(sections.join('\n').trimEnd());
+}
+/** A static view of the diagnostic snapshot taken when the page was first shown. */
+export class LogPage {
+    options;
+    focused = false;
+    sections;
+    error;
+    source = 0;
+    offset = 0;
+    atEnd = true;
+    maxOffset = 0;
+    rows = 1;
+    disposed = false;
+    constructor(options) {
+        this.options = options;
+    }
+    activate() {
+        if (this.sections || this.disposed)
+            return;
+        this.options.load().then(sections => { this.sections = sections; }, error => { this.error = error instanceof Error ? error.message : String(error); }).finally(() => { if (!this.disposed)
+            this.options.changed(); });
+    }
+    dispose() { this.disposed = true; }
+    tabs() {
+        return this.sections?.map((item, index) => ({ id: String(index), title: item.title })) ?? [
+            { id: '0', title: 'Diagnostics' }, { id: '1', title: 'Run Events' }
+        ];
+    }
+    activeTab() { return String(this.source); }
+    hint() { return '↑/↓ scroll · PgUp/PgDn page'; }
+    changeSource(direction) {
+        const count = this.sections?.length ?? 0;
+        if (!count)
+            return;
+        this.source = (this.source + direction + count) % count;
+        this.offset = 0;
+        this.atEnd = true;
+    }
+    currentOffset() { return this.atEnd ? this.maxOffset : this.offset; }
+    handleInput(data) {
+        const page = Math.max(1, this.rows - 1);
+        if (matchesKey(data, 'tab'))
+            this.changeSource(1);
+        else if (matchesKey(data, 'shift+tab'))
+            this.changeSource(-1);
+        else if (matchesKey(data, 'home')) {
+            this.offset = 0;
+            this.atEnd = false;
+        }
+        else if (matchesKey(data, 'end'))
+            this.atEnd = true;
+        else if (matchesKey(data, 'up')) {
+            this.offset = Math.max(0, this.currentOffset() - 1);
+            this.atEnd = false;
+        }
+        else if (matchesKey(data, 'down')) {
+            this.offset = this.currentOffset() + 1;
+            this.atEnd = false;
+        }
+        else if (matchesKey(data, 'pageUp')) {
+            this.offset = Math.max(0, this.currentOffset() - page);
+            this.atEnd = false;
+        }
+        else if (matchesKey(data, 'pageDown')) {
+            this.offset = this.currentOffset() + page;
+            this.atEnd = false;
+        }
+        else
+            return false;
+        return true;
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (!this.sections)
+            return [theme.fg(this.error ? 'error' : 'dim', this.error ? `Could not read logs: ${this.error}` : 'Reading logs…')];
+        const section = this.sections[this.source] ?? { title: 'Logs', text: 'No log sources are available.' };
+        const bodyRows = Math.max(0, rows - 2);
+        this.rows = Math.max(1, bodyRows);
+        const lines = safe(section.text).split('\n').flatMap(line => line ? wrapTextWithAnsi(line, width) : ['']);
+        this.maxOffset = Math.max(0, lines.length - bodyRows);
+        if (this.atEnd)
+            this.offset = this.maxOffset;
+        else
+            this.offset = Math.max(0, Math.min(this.maxOffset, this.offset));
+        const last = Math.min(lines.length, this.offset + bodyRows);
+        const position = theme.fg('dim', `lines ${lines.length ? this.offset + 1 : 0}-${last}/${lines.length}`);
+        return [position, ...lines.slice(this.offset, last)].slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/pages/notesPage.d.ts

@@ -0,0 +1,75 @@
+/**
+ * The Page notes page (`/plugin:notes`, `/plugin:annotate [url]`): notes a person keeps about web pages. A new note
+ * is captured in a visible browser window: the whole page, text the person selects, or an element
+ * they click. A note is private until it is shared with this session, whose agent can then read it
+ * with `page_notes_read` (PROP-0017).
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { MenuCall, MenuUi } from "../../pluginMenu.js";
+import type { TabInfo } from "../chrome.js";
+import { type ListRow } from "../list.js";
+import type { TerminalMouseInput } from "../mouse.js";
+import type { TerminalPage } from "../page.js";
+import type { Note } from "../../../annotations/store.js";
+export interface NotesPageOptions {
+    theme(): Theme;
+    call: MenuCall;
+    ui: MenuUi & {
+        input(title: string, placeholder?: string): Promise<string | undefined>;
+    };
+    changed(): void;
+    /** Start a new note as soon as the page opens (`/plugin:annotate [url]`), on this address when given. */
+    start?: {
+        url?: string;
+    };
+}
+type Row = {
+    kind: 'new';
+} | {
+    kind: 'note';
+    note: Note;
+};
+export declare const NOTE_KINDS: {
+    readonly page: "The whole page";
+    readonly text: "Text I select in the window";
+    readonly element: "An element I click in the window";
+};
+export declare const NOTE_ACTIONS: {
+    readonly reveal: "Show it in the browser window";
+    readonly edit: "Edit the note";
+    readonly resolve: "Mark resolved";
+    readonly reopen: "Reopen";
+    readonly share: "Let this session's agent read it";
+    readonly unshare: "Stop sharing it with this session";
+    readonly delete: "Delete";
+};
+export declare class NotesPage implements TerminalPage {
+    private readonly options;
+    presentation: "centered";
+    private notes;
+    private sessionId;
+    private error;
+    private busy;
+    private disposed;
+    private readonly list;
+    constructor(options: NotesPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    reload(): Promise<void>;
+    private shared;
+    rows(): ListRow<Row>[];
+    private attempt;
+    activateRow(row: Row): Promise<void>;
+    /** Opens the capture window, takes what the person points at, and saves their note. */
+    newNote(startUrl?: string): Promise<void>;
+    private noteMenu;
+    handleMouse(event: TerminalMouseInput): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}
+export {};

package/dist/sdk/terminal/tui/pages/notesPage.js

@@ -0,0 +1,201 @@
+import { truncateToWidth } from '@earendil-works/pi-tui';
+import { FilterList } from "../list.js";
+const TABS = [{ id: 'notes', title: 'Page notes' }];
+export const NOTE_KINDS = { page: 'The whole page', text: 'Text I select in the window', element: 'An element I click in the window' };
+export const NOTE_ACTIONS = {
+    reveal: 'Show it in the browser window',
+    edit: 'Edit the note',
+    resolve: 'Mark resolved',
+    reopen: 'Reopen',
+    share: 'Let this session\'s agent read it',
+    unshare: 'Stop sharing it with this session',
+    delete: 'Delete'
+};
+const clip = (text, size) => (text.length > size ? `${text.slice(0, size - 1)}…` : text);
+function describeTarget(target) {
+    if (target.kind === 'text')
+        return `“${clip(target.exact.replace(/\s+/g, ' '), 60)}”`;
+    if (target.kind === 'element')
+        return `<${target.tag}> ${clip(target.name || target.text, 50)}`;
+    return 'whole page';
+}
+export class NotesPage {
+    options;
+    presentation = 'centered';
+    notes;
+    sessionId = null;
+    error;
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['note', 'notes'], empty: 'No page notes yet',
+            onActivate: row => { if (row.data)
+                void this.activateRow(row.data); }
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    activate() {
+        void this.reload().then(() => {
+            if (this.options.start)
+                void this.newNote(this.options.start.url);
+        });
+    }
+    dispose() { this.disposed = true; }
+    tabs() { return TABS; }
+    activeTab() { return 'notes'; }
+    hint() { return 'Enter choose · type to search · Esc close'; }
+    async reload() {
+        try {
+            const result = await this.options.call('terminal.annotations.list');
+            this.notes = result.notes;
+            this.sessionId = result.sessionId;
+            this.error = undefined;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        if (this.disposed)
+            return;
+        this.list.setRows(this.rows());
+        this.options.changed();
+    }
+    shared(note) {
+        return note.grants.some(grant => grant.principal.sessionId && grant.principal.sessionId === this.sessionId);
+    }
+    rows() {
+        const rows = [{ id: 'new', label: 'New note on a page…', group: 'Actions', detail: 'opens a browser window', tone: 'accent', data: { kind: 'new' } }];
+        for (const note of this.notes ?? []) {
+            rows.push({
+                id: `note:${note.id}`, label: clip(note.body.replace(/\s+/g, ' '), 60), group: 'Notes',
+                detail: `${describeTarget(note.target)} · ${note.status}${this.shared(note) ? ' · shared here' : ''}`,
+                tone: note.status === 'resolved' ? 'dim' : this.shared(note) ? 'success' : 'muted',
+                searchText: `${note.body} ${note.source.url} ${note.source.title} ${note.tags.join(' ')}`,
+                data: { kind: 'note', note }
+            });
+        }
+        return rows;
+    }
+    async attempt(work) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        try {
+            const message = await work();
+            if (message)
+                this.options.ui.notify(message, 'info');
+        }
+        catch (error) {
+            this.options.ui.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+        finally {
+            this.busy = false;
+        }
+        await this.reload();
+    }
+    async activateRow(row) {
+        if (row.kind === 'new')
+            return this.newNote();
+        return this.noteMenu(row.note);
+    }
+    /** Opens the capture window, takes what the person points at, and saves their note. */
+    newNote(startUrl) {
+        const { call, ui } = this.options;
+        return this.attempt(async () => {
+            const url = startUrl ?? await ui.input('Page address', 'https://');
+            if (!url)
+                return;
+            await call('terminal.annotations.open', { url });
+            const kind = await ui.select('What does the note point at?', Object.values(NOTE_KINDS));
+            if (!kind)
+                return;
+            let envelope;
+            if (kind === NOTE_KINDS.page) {
+                const identity = await call('terminal.annotations.identity');
+                envelope = { ...identity, target: { kind: 'page' } };
+            }
+            else {
+                const element = kind === NOTE_KINDS.element;
+                const { captureId } = await call('terminal.annotations.begin', { kind: element ? 'element' : 'text' });
+                const ready = await ui.confirm(element ? 'Click the element in the browser window' : 'Select the text in the browser window', 'When it is selected, choose Yes to capture it. Choose No to cancel.');
+                if (!ready) {
+                    await call('terminal.annotations.cancel', { captureId });
+                    return;
+                }
+                envelope = await call('terminal.annotations.capture', { captureId });
+                if (!envelope)
+                    return 'Nothing was selected in the browser window, so no note was made.';
+            }
+            const body = await ui.input('Note', 'What should be remembered about it?');
+            if (!body?.trim())
+                return 'A note needs some text; nothing was saved.';
+            const tags = (await ui.input('Tags (optional, comma separated)', '') ?? '').split(',').map(tag => tag.trim()).filter(Boolean);
+            const share = await ui.confirm('Share it with this session?', 'This session\'s agent can then read the note with page_notes_read. You can stop sharing it later.');
+            await call('terminal.annotations.create', {
+                source: { url: envelope.url, title: envelope.title, capturedAt: new Date().toISOString(), surface: 'terminal', representationHint: envelope.documentId },
+                target: envelope.target, body, tags, share
+            });
+            return share ? 'Note saved and shared with this session.' : 'Note saved. It stays private until you share it.';
+        });
+    }
+    async noteMenu(note) {
+        const { call, ui } = this.options;
+        const choices = [
+            NOTE_ACTIONS.reveal,
+            NOTE_ACTIONS.edit,
+            note.status === 'open' ? NOTE_ACTIONS.resolve : NOTE_ACTIONS.reopen,
+            this.shared(note) ? NOTE_ACTIONS.unshare : NOTE_ACTIONS.share,
+            NOTE_ACTIONS.delete
+        ];
+        const choice = await ui.select(`${clip(note.source.title || note.source.url, 60)} · ${describeTarget(note.target)}`, choices);
+        const id = note.id;
+        if (choice === NOTE_ACTIONS.reveal)
+            return this.attempt(async () => {
+                const result = await call('terminal.annotations.reveal', { id });
+                return result.state === 'matched' ? 'Marked in the browser window.' : `The target is ${result.state}${result.reason ? `: ${result.reason}` : ''}.`;
+            });
+        if (choice === NOTE_ACTIONS.edit)
+            return this.attempt(async () => {
+                const body = await ui.input('Note', note.body);
+                if (!body?.trim() || body === note.body)
+                    return;
+                await call('terminal.annotations.update', { id, expectedVersion: note.version, patch: { body } });
+                return 'Note saved.';
+            });
+        if (choice === NOTE_ACTIONS.resolve || choice === NOTE_ACTIONS.reopen)
+            return this.attempt(async () => {
+                await call('terminal.annotations.update', { id, expectedVersion: note.version, patch: { status: choice === NOTE_ACTIONS.resolve ? 'resolved' : 'open' } });
+            });
+        if (choice === NOTE_ACTIONS.share || choice === NOTE_ACTIONS.unshare)
+            return this.attempt(async () => {
+                await call(choice === NOTE_ACTIONS.share ? 'terminal.annotations.share' : 'terminal.annotations.unshare', { id });
+                return choice === NOTE_ACTIONS.share ? 'This session\'s agent can read the note.' : 'The note is no longer shared with this session.';
+            });
+        if (choice === NOTE_ACTIONS.delete)
+            return this.attempt(async () => {
+                if (!await ui.confirm('Delete this note?', 'It cannot be restored.'))
+                    return;
+                await call('terminal.annotations.delete', { id, expectedVersion: note.version });
+                return 'Note deleted.';
+            });
+    }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        return this.list.handleInput(data);
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (this.error)
+            return [theme.fg('error', `Could not read page notes: ${this.error}`)];
+        if (!this.notes)
+            return [theme.fg('dim', 'Reading page notes…')];
+        return this.list.render(width, rows).slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

package/dist/sdk/terminal/tui/pages/permissionsPage.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The Permissions page: Full Permission, then every tool with whether a call needs asking.
+ * The state lives in the local Harness state through the runtime's `permissions` calls.
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+import type { TerminalPermissionState } from "../runtime.js";
+export interface PermissionsPageOptions {
+    theme: () => Theme;
+    permissions(): Promise<TerminalPermissionState>;
+    setFullPermission(enabled: boolean): Promise<void>;
+    setGlobalTool(tool: string, allowed: boolean): Promise<void>;
+    /** The tools this session has switched on. */
+    activeTools(): string[];
+    confirm(title: string, message: string): Promise<boolean>;
+    notify(message: string, type?: string): void;
+    changed(): void;
+}
+export declare class PermissionsPage implements TerminalPage {
+    private readonly options;
+    private state;
+    private section;
+    private error;
+    private busy;
+    private disposed;
+    private readonly list;
+    constructor(options: PermissionsPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    private reload;
+    private fill;
+    private rows;
+    private toggle;
+    handleMouse(event: TerminalMouseInput): import("@earendil-works/pi-tui").TuiMouseEventResult | undefined;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}

package/dist/sdk/terminal/tui/pages/permissionsPage.js

@@ -0,0 +1,124 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { FilterList } from "../list.js";
+const SECTIONS = [
+    { id: 'overview', title: 'Overview' },
+    { id: 'tools', title: 'Tools' }
+];
+const FULL = 'full';
+const NOTE = 'Applies to future approvals only. Hard denials and disabled tools still apply.';
+const FULL_WARNING = 'Automatically approve eligible future requests in every Pi terminal session sharing this local Harness state. Hard denials and disabled tools still apply; human-only requests stay manual unless the host explicitly opts them in. Requests already waiting are not approved.';
+export class PermissionsPage {
+    options;
+    state;
+    section = 'overview';
+    error;
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['tool', 'tools'], empty: 'No tools to show',
+            onActivate: row => { void this.toggle(row.id); },
+            onToggle: row => { void this.toggle(row.id); }
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    activate() { void this.reload(); }
+    dispose() { this.disposed = true; }
+    tabs() { return SECTIONS; }
+    activeTab() { return this.section; }
+    hint() { return this.list.query ? 'Enter toggle · Esc clear' : 'Space or Enter toggle · type to search'; }
+    async reload() {
+        try {
+            this.state = await this.options.permissions();
+            this.error = undefined;
+        }
+        catch (error) {
+            this.error = error instanceof Error ? error.message : String(error);
+        }
+        if (this.disposed)
+            return;
+        this.fill();
+        this.options.changed();
+    }
+    fill() {
+        this.list.setRows(this.rows());
+    }
+    rows() {
+        const state = this.state;
+        if (!state)
+            return [];
+        if (this.section === 'overview') {
+            return [{ id: FULL, label: 'Full Permission', group: 'Mode', detail: state.full ? 'ON' : 'OFF', tone: state.full ? 'warning' : 'muted', searchText: 'full permission approve everything' }];
+        }
+        const granted = new Set(state.globalTools);
+        const active = this.options.activeTools();
+        const inactive = [...granted].filter(tool => !active.includes(tool));
+        const byName = (left, right) => left.localeCompare(right);
+        const tool = (name, group) => ({
+            id: 'tool:' + name, label: name, group,
+            detail: granted.has(name) ? '● allowed everywhere' : '○ asks each time',
+            tone: granted.has(name) ? 'success' : 'muted'
+        });
+        return [
+            ...[...active].sort(byName).map(name => tool(name, 'Tools in this session')),
+            ...inactive.sort(byName).map(name => tool(name, 'Granted, not active here'))
+        ];
+    }
+    async toggle(id) {
+        if (this.busy || !this.state)
+            return;
+        this.busy = true;
+        try {
+            if (id === FULL) {
+                const desired = !this.state.full;
+                const latest = await this.options.permissions();
+                if (latest.full !== desired && (!desired || await this.options.confirm('Enable Full Permission?', FULL_WARNING)))
+                    await this.options.setFullPermission(desired);
+            }
+            else {
+                const tool = id.slice('tool:'.length);
+                if (!tool)
+                    return;
+                const desired = !this.state.globalTools.includes(tool);
+                const latest = await this.options.permissions();
+                if (latest.globalTools.includes(tool) !== desired)
+                    await this.options.setGlobalTool(tool, desired);
+            }
+        }
+        catch (error) {
+            this.options.notify(error instanceof Error ? error.message : String(error), 'error');
+        }
+        finally {
+            this.busy = false;
+        }
+        await this.reload();
+    }
+    handleMouse(event) {
+        return this.list.handleMouse(event);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'tab') || matchesKey(data, 'shift+tab')) {
+            if (!this.list.query) {
+                this.section = this.section === 'overview' ? 'tools' : 'overview';
+                this.fill();
+            }
+            return true;
+        }
+        return this.list.handleInput(data);
+    }
+    render(width, rows) {
+        const theme = this.options.theme();
+        if (width < 1 || rows < 1)
+            return [];
+        if (!this.state)
+            return [theme.fg(this.error ? 'error' : 'dim', this.error ? `Could not read permissions: ${this.error}` : 'Reading permissions…')];
+        const note = this.section === 'overview' && rows >= 8 ? wrapTextWithAnsi(NOTE, width).slice(0, 2) : [];
+        const lines = this.list.render(width, Math.max(1, rows - (note.length ? note.length + 1 : 0)));
+        if (note.length)
+            lines.push('', ...note.map(line => theme.fg('dim', line)));
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}