@xingular/harness 0.1.7 → 1.0.0

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

@@ -0,0 +1,145 @@
+import { matchesKey, stripTerminalSequences, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { doctorReportSchema } from "../../../doctor/types.js";
+export class DoctorPage {
+    options;
+    focused = false;
+    report;
+    error;
+    timer;
+    disposed = false;
+    busy = false;
+    offset = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    tabs() { return [{ id: 'doctor', title: 'Doctor' }]; }
+    activeTab() { return 'doctor'; }
+    hint() { return '↑/↓ scroll · r refresh · t retry finding · l live checks · c cancel · Esc close'; }
+    activate() { if (!this.report && !this.busy)
+        void this.start(); }
+    dispose() {
+        this.disposed = true;
+        clearTimeout(this.timer);
+        if (this.report?.state === 'running')
+            void this.options.call('terminal.doctor.cancel', { id: this.report.id }).catch(() => undefined);
+    }
+    async start(mode = 'local', checks = []) {
+        if (this.busy || this.disposed)
+            return;
+        this.busy = true;
+        this.error = undefined;
+        clearTimeout(this.timer);
+        try {
+            if (this.report?.state === 'running')
+                await this.options.call('terminal.doctor.cancel', { id: this.report.id });
+            const result = await this.options.call('terminal.doctor.start', { ...this.options.selection(), mode, checks, confirmed: mode === 'live' });
+            this.report = doctorReportSchema.parse(result);
+            this.offset = 0;
+            if (this.disposed) {
+                await this.options.call('terminal.doctor.cancel', { id: this.report.id });
+                return;
+            }
+            this.poll();
+        }
+        catch {
+            this.error = 'Diagnostics could not be started. Check the host connection.';
+        }
+        finally {
+            this.busy = false;
+            if (!this.disposed)
+                this.options.changed();
+        }
+    }
+    poll() {
+        if (this.disposed || this.report?.state !== 'running')
+            return;
+        const id = this.report.id;
+        this.timer = setTimeout(() => {
+            void this.options.call('terminal.doctor.read', { id }).then(result => {
+                if (this.disposed || this.report?.id !== id)
+                    return;
+                this.report = doctorReportSchema.parse(result);
+                this.options.changed();
+                this.poll();
+            }).catch(() => { this.error = 'The diagnostic host connection was lost.'; this.options.changed(); });
+        }, 200);
+    }
+    async chooseLive() {
+        const report = this.report;
+        if (!report || this.busy || report.state === 'running')
+            return;
+        const selected = [];
+        const checks = report.liveChecks;
+        while (!this.disposed) {
+            const labels = checks.map(check => `${selected.includes(check.id) ? '[x]' : '[ ]'} ${check.title}`);
+            const run = 'Run selected checks';
+            const choice = await this.options.select('Select live checks', [...labels, run]);
+            if (!choice || this.disposed)
+                return;
+            if (choice === run)
+                break;
+            const check = checks[labels.indexOf(choice)];
+            if (check) {
+                const index = selected.indexOf(check.id);
+                if (index < 0)
+                    selected.push(check.id);
+                else
+                    selected.splice(index, 1);
+            }
+        }
+        if (!selected.length || this.disposed)
+            return;
+        const notice = [`Account: ${report.context.accountId ?? 'none'}`, `Model: ${report.context.model ?? 'none'}`, ...checks.filter(check => selected.includes(check.id)).map(check => `${check.title}: ${check.notice}`)].join('\n\n');
+        if (await this.options.confirm('Run these live diagnostics?', notice) && !this.disposed)
+            await this.start('live', selected);
+    }
+    async retry() {
+        const report = this.report;
+        if (!report || this.busy || report.state === 'running')
+            return;
+        const labels = report.findings.map(finding => `${finding.status}: ${finding.title}`);
+        const selected = await this.options.select('Retry local readiness check', labels);
+        const finding = selected ? report.findings[labels.indexOf(selected)] : undefined;
+        if (finding && !this.disposed)
+            await this.start('local', finding.id === 'doctor' ? [] : [finding.id]);
+    }
+    handleInput(data) {
+        if (matchesKey(data, 'up'))
+            this.offset = Math.max(0, this.offset - 1);
+        else if (matchesKey(data, 'down'))
+            this.offset++;
+        else if (data === 'r')
+            void this.start();
+        else if (data === 'l')
+            void this.chooseLive();
+        else if (data === 't')
+            void this.retry();
+        else if (data === 'c' && this.report?.state === 'running') {
+            void this.options.call('terminal.doctor.cancel', { id: this.report.id }).then(result => {
+                this.report = doctorReportSchema.parse(result);
+                clearTimeout(this.timer);
+                this.options.changed();
+            }).catch(() => { this.error = 'Could not cancel diagnostics.'; this.options.changed(); });
+        }
+        else
+            return false;
+        return true;
+    }
+    render(width, rows) {
+        if (width < 1 || rows < 1)
+            return [];
+        const report = this.report;
+        const counts = report?.findings.reduce((all, finding) => { all[finding.status] = (all[finding.status] ?? 0) + 1; return all; }, {}) ?? {};
+        const lines = [
+            this.error ?? (report ? `${report.mode} · ${report.state} · ${report.completed}/${report.total} checks` : 'Preparing diagnostics…'),
+            report ? `Account ${report.context.accountId ?? 'none'} · Model ${report.context.model ?? 'none'}` : '',
+            Object.entries(counts).map(([status, count]) => `${count} ${status}`).join(' · '),
+            ...report?.findings.flatMap(finding => [
+                '', `[${finding.status}] ${finding.category} · ${finding.title} (${finding.verification})`,
+                finding.evidence, ...(finding.remedy ? [`Action: ${finding.remedy}`] : [])
+            ]) ?? []
+        ].flatMap(line => stripTerminalSequences(line).replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, ' ').split('\n').flatMap(part => wrapTextWithAnsi(part, width)));
+        this.offset = Math.max(0, Math.min(this.offset, lines.length - rows));
+        return lines.slice(this.offset, this.offset + rows).map(line => this.options.theme().fg('text', line));
+    }
+}

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

@@ -0,0 +1,39 @@
+/**
+ * The Hub page: the reviewed catalog of skills, plugins and reusable documents. Installing asks first,
+ * installs exactly the listed version, and leaves code switched off and untrusted.
+ */
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { MenuCall, MenuUi } from "../../pluginMenu.js";
+import { type TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+import type { TerminalMouseInput } from "../mouse.js";
+export interface HubPageOptions {
+    theme: () => Theme;
+    call: MenuCall;
+    ui: MenuUi;
+    changed(): void;
+}
+export declare class HubPage implements TerminalPage {
+    private readonly options;
+    private catalog;
+    private section;
+    private error;
+    private busy;
+    private disposed;
+    private readonly list;
+    constructor(options: HubPageOptions);
+    get focused(): boolean;
+    set focused(value: boolean);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    private load;
+    private fill;
+    private rows;
+    private activateRow;
+    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/hubPage.js

@@ -0,0 +1,128 @@
+import { matchesKey, truncateToWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+import { installHubEntry } from "../../hubMenu.js";
+import { safeText } from "../chrome.js";
+import { FilterList } from "../list.js";
+const SECTIONS = [
+    { id: 'catalog', title: 'Catalog' },
+    { id: 'installed', title: 'Installed' }
+];
+const REFRESH = 'action:refresh';
+export class HubPage {
+    options;
+    catalog;
+    section = 'catalog';
+    error;
+    busy = false;
+    disposed = false;
+    list;
+    constructor(options) {
+        this.options = options;
+        this.list = new FilterList({
+            theme: options.theme, search: 'always', noun: ['entry', 'entries'], empty: 'The catalog has no entries.',
+            onActivate: row => { void this.activateRow(row.id); }
+        });
+    }
+    get focused() { return this.list.focused; }
+    set focused(value) { this.list.focused = value; }
+    activate() { if (!this.catalog)
+        void this.load(false); }
+    dispose() { this.disposed = true; }
+    tabs() { return SECTIONS; }
+    activeTab() { return this.section; }
+    hint() {
+        return this.list.query ? 'Enter open · Esc clear' : this.section === 'catalog' ? 'Enter review and install · type to search' : 'Select an installed entry · type to search';
+    }
+    async load(refresh) {
+        try {
+            const catalog = await this.options.call('hub.list', refresh ? { refresh: true } : {});
+            this.catalog = catalog;
+            this.error = undefined;
+            if (refresh && catalog.error)
+                this.options.ui.notify(`${catalog.error} Using ${catalog.origin} content.`, 'warning');
+        }
+        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() {
+        if (this.section === 'installed') {
+            return [
+                ...(this.catalog?.installed ?? []).map(receipt => ({
+                    id: 'installed:' + receipt.entry.id + '@' + receipt.entry.version,
+                    label: safeText(receipt.entry.title),
+                    group: receipt.entry.category,
+                    detail: (receipt.state ?? 'installed') + ' · ' + receipt.entry.version,
+                    tone: receipt.state === 'installed' ? 'success' : 'warning',
+                    searchText: receipt.entry.title + ' ' + receipt.entry.category + ' ' + receipt.entry.id + ' ' + receipt.entry.publisher + ' ' + (receipt.state ?? '')
+                }))
+            ];
+        }
+        const entries = [...(this.catalog?.entries ?? [])].sort((left, right) => left.category.localeCompare(right.category));
+        return [
+            ...entries.map(entry => ({
+                id: entry.id + '@' + entry.version, label: safeText(entry.title), group: safeText(entry.category),
+                detail: entry.version, tone: 'muted', searchText: entry.title + ' ' + entry.category + ' ' + entry.id + ' ' + entry.publisher
+            })),
+            { id: REFRESH, label: '⟳ Refresh catalog', group: 'Actions', tone: 'accent' }
+        ];
+    }
+    async activateRow(id) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        try {
+            if (id === REFRESH) {
+                await this.load(true);
+                return;
+            }
+            if (id.startsWith('installed:'))
+                return;
+            const entry = this.catalog?.entries.find(candidate => candidate.id + '@' + candidate.version === id);
+            if (entry)
+                await installHubEntry(this.options.ui, this.options.call, entry);
+        }
+        finally {
+            this.busy = false;
+        }
+    }
+    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 === 'catalog' ? 'installed' : 'catalog';
+                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.catalog)
+            return [theme.fg(this.error ? 'error' : 'dim', this.error ? 'Could not read the catalog: ' + this.error : 'Reading the catalog…')];
+        const selectedId = this.list.selected?.id;
+        const installed = this.section === 'installed'
+            ? this.catalog.installed.find(receipt => 'installed:' + receipt.entry.id + '@' + receipt.entry.version === selectedId)
+            : undefined;
+        const entry = installed?.entry ?? this.catalog.entries.find(candidate => candidate.id + '@' + candidate.version === selectedId);
+        const detail = entry && rows >= 9
+            ? [...wrapTextWithAnsi(safeText(entry.description), width).slice(0, 3), entry.publisher + ' · ' + entry.license + ' · ' + entry.id,
+                ...(installed ? ['Installed ' + installed.installedAt + ' · ' + (installed.state ?? 'installed')] : [])]
+            : [];
+        const lines = this.list.render(width, Math.max(2, rows - (detail.length ? detail.length + 1 : 0)));
+        if (detail.length)
+            lines.push('', ...detail.map(line => theme.fg('muted', safeText(line))));
+        return lines.slice(0, rows).map(line => truncateToWidth(line, width, ''));
+    }
+}

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

@@ -0,0 +1,38 @@
+import type { Theme } from '@earendil-works/pi-coding-agent';
+import type { TerminalTrajectorySnapshot } from "../../trajectory.js";
+import type { TabInfo } from "../chrome.js";
+import type { TerminalPage } from "../page.js";
+export interface LogSection {
+    title: string;
+    text: string;
+}
+export declare function formatRunEventLog(snapshots: TerminalTrajectorySnapshot[]): string;
+export interface LogPageOptions {
+    theme: () => Theme;
+    /** The diagnostic sources, read when the page is first shown and not again while the overlay is open. */
+    load(): Promise<LogSection[]>;
+    changed(): void;
+}
+/** A static view of the diagnostic snapshot taken when the page was first shown. */
+export declare class LogPage implements TerminalPage {
+    private readonly options;
+    focused: boolean;
+    private sections;
+    private error;
+    private source;
+    private offset;
+    private atEnd;
+    private maxOffset;
+    private rows;
+    private disposed;
+    constructor(options: LogPageOptions);
+    activate(): void;
+    dispose(): void;
+    tabs(): readonly TabInfo[];
+    activeTab(): string;
+    hint(): string;
+    private changeSource;
+    private currentOffset;
+    handleInput(data: string): boolean;
+    render(width: number, rows: number): string[];
+}

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/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[];
+}