@crouton-kit/crouter 0.3.78 → 0.3.80

package/dist/commands/sys/setup-core.js

@@ -1,10 +1,131 @@
 import { spawnSync } from 'node:child_process';
 import { chmod, mkdir, writeFile } from 'node:fs/promises';
+import { readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
+import { isDeepStrictEqual } from 'node:util';
+import { BINDING_CATALOG, normalizeGesture, resolveKeybindings, } from '../../core/keybindings/index.js';
 import { builtinPiPackageDir } from '../../core/scope.js';
 import { readJsonIfExists } from '../../core/fs-utils.js';
 import { resolveBundledPiCliPath } from '../../core/runtime/pi-cli.js';
+function isKeybindingsObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function cloneKeybindings(value) {
+    if (!isKeybindingsObject(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).map(([id, gestures]) => [
+        id,
+        Array.isArray(gestures) ? [...gestures] : gestures,
+    ]));
+}
+/** Transactional sparse keybinding draft used by the full-screen setup tab. */
+export class SetupKeybindingsDraft {
+    expected;
+    baseline;
+    current;
+    baselineInvalidRoot;
+    invalidRoot;
+    constructor(rawKeybindings) {
+        this.expected = rawKeybindings;
+        this.baseline = cloneKeybindings(rawKeybindings);
+        this.current = cloneKeybindings(rawKeybindings);
+        this.baselineInvalidRoot = rawKeybindings !== undefined && !isKeybindingsObject(rawKeybindings) ? rawKeybindings : undefined;
+        this.invalidRoot = this.baselineInvalidRoot;
+    }
+    get dirty() {
+        return !isDeepStrictEqual(this.current, this.baseline)
+            || !isDeepStrictEqual(this.invalidRoot, this.baselineInvalidRoot);
+    }
+    overrides() {
+        return cloneKeybindings(this.current);
+    }
+    expectedKeybindings() {
+        return this.expected;
+    }
+    resolution() {
+        return resolveKeybindings(this.invalidRoot === undefined ? this.current : this.invalidRoot);
+    }
+    /** True while the persisted `keybindings` root is a non-object (e.g. a string):
+     *  edits cannot be layered onto an invalid root, so the tab must reset-all first. */
+    hasInvalidRoot() {
+        return this.invalidRoot !== undefined;
+    }
+    expression(id) {
+        return this.resolution().gestures(id).join(', ');
+    }
+    edit(id, expression) {
+        if (this.invalidRoot !== undefined) {
+            return {
+                ok: false,
+                diagnostics: [{
+                        severity: 'error',
+                        code: 'invalid-keybindings',
+                        offendingValue: this.invalidRoot,
+                        message: 'Reset all before editing: the saved keybindings root is invalid.',
+                    }],
+            };
+        }
+        const definition = BINDING_CATALOG.find((candidate) => candidate.id === id);
+        let gestures;
+        try {
+            gestures = expression.trim() === ''
+                ? []
+                : expression.split(',').map((gesture) => normalizeGesture(gesture.trim(), definition));
+        }
+        catch (error) {
+            return {
+                ok: false,
+                diagnostics: [{
+                        severity: 'error',
+                        code: 'invalid-override',
+                        bindingId: id,
+                        offendingValue: expression,
+                        message: error instanceof Error ? error.message : String(error),
+                    }],
+            };
+        }
+        const deduped = [...new Set(gestures)];
+        // Sparse invariant: a member is stored only when it changes the effective
+        // resolution. If the committed gestures equal the catalog default for this
+        // id, drop the member instead of recording a redundant override — otherwise
+        // committing an unchanged default flips the row to a spurious user/unsaved
+        // state that persistence would then strip anyway.
+        const withoutId = { ...this.current };
+        delete withoutId[id];
+        const defaultGestures = [...resolveKeybindings(withoutId).gestures(id)];
+        const prospective = isDeepStrictEqual(deduped, defaultGestures)
+            ? withoutId
+            : { ...this.current, [id]: deduped };
+        const resolution = resolveKeybindings(prospective);
+        const relevant = resolution.diagnostics.filter((diagnostic) => diagnostic.bindingId === id || diagnostic.relatedBindingIds?.includes(id));
+        if (relevant.length > 0)
+            return { ok: false, diagnostics: relevant };
+        this.current = prospective;
+        return { ok: true, diagnostics: resolution.diagnostics };
+    }
+    unbind(id) {
+        return this.edit(id, '');
+    }
+    resetRow(id) {
+        delete this.current[id];
+    }
+    resetAll() {
+        this.current = {};
+        this.invalidRoot = undefined;
+    }
+    discard() {
+        this.current = cloneKeybindings(this.baseline);
+        this.invalidRoot = this.baselineInvalidRoot;
+    }
+    markSaved(overrides) {
+        this.expected = Object.keys(overrides).length === 0 ? undefined : cloneKeybindings(overrides);
+        this.baseline = cloneKeybindings(overrides);
+        this.current = cloneKeybindings(overrides);
+        this.baselineInvalidRoot = undefined;
+        this.invalidRoot = undefined;
+    }
+}
 const PACKAGE_COPY = {
     'crtr-extensions': {
         name: 'pi-crtr-extensions',
@@ -234,6 +355,22 @@ export function resolveExaKeyPath(homeDir = homedir()) {
 export function resolveComposioKeyPath(homeDir = homedir()) {
     return join(homeDir, '.crouter', 'composio.key');
 }
+function detectApiKey(envVar, keyPath) {
+    if ((process.env[envVar] ?? '').trim() !== '')
+        return { present: true, source: 'env' };
+    try {
+        if (readFileSync(keyPath, 'utf8').trim() !== '')
+            return { present: true, source: 'file' };
+    }
+    catch { /* absent/unreadable → not present */ }
+    return { present: false };
+}
+export function detectExaKey(homeDir = homedir()) {
+    return detectApiKey('EXA_API_KEY', resolveExaKeyPath(homeDir));
+}
+export function detectComposioKey(homeDir = homedir()) {
+    return detectApiKey('COMPOSIO_API_KEY', resolveComposioKeyPath(homeDir));
+}
 export function buildSetupInitialState(opts = {}) {
     const homeDir = opts.homeDir ?? homedir();
     const settingsPath = opts.settingsPath ?? resolveSettingsPath(homeDir);
@@ -275,7 +412,7 @@ export function renderSetupStaticInstructions(state) {
     return [
         instructions.headline,
         '',
-        'Provider login: open the wizard in a TTY and use the Login tab (same flow as /login) to authenticate a model provider.',
+        'Provider login: open the wizard in a TTY and use the Providers tab (same flow as /login) to authenticate a model provider.',
         '',
         'Packages:',
         ...instructions.packageLines,

package/dist/commands/sys/setup.d.ts

@@ -1,2 +1,90 @@
 import type { LeafDef } from '../../core/command.js';
+import { TUI, type Component, type Focusable } from '@earendil-works/pi-tui';
+import { type BindingId, type BindingResolution } from '../../core/keybindings/index.js';
+import { type SetupPackageId, type SetupPackageManifestEntry, type SetupSubmission, type SetupSystemToolState } from './setup-core.js';
+export declare class SetupWizard implements Component, Focusable {
+    private readonly manifest;
+    private readonly installedPackageIds;
+    private readonly systemTools;
+    private readonly exaInput;
+    private readonly composioInput;
+    private readonly keyInput;
+    private readonly openingBindings;
+    private readonly keyDraft;
+    private readonly terminalRows;
+    private readonly selectedPackageIds;
+    private readonly selectedSystemTools;
+    private readonly providers;
+    private activeTab;
+    private pluginIndex;
+    private systemIndex;
+    private expandedPluginId;
+    private confirming;
+    private keyIndex;
+    private keyScroll;
+    private keyFilter;
+    private filteringKeys;
+    private editingKey;
+    private keyEditError;
+    private keyDiagnostics;
+    private keyConfirm;
+    private keyNotice;
+    private cachedWidth;
+    private cachedLines;
+    private _focused;
+    onSubmit?: (submission: SetupSubmission) => void;
+    onCancel?: () => void;
+    constructor(manifest: SetupPackageManifestEntry[], installedPackageIds: Set<SetupPackageId>, systemTools: SetupSystemToolState[], tui: TUI, agentDir: string, openingBindings: BindingResolution<BindingId>, rawKeybindings: unknown, terminalRows: () => number);
+    set focused(value: boolean);
+    get focused(): boolean;
+    invalidate(): void;
+    private setTab;
+    private moveTab;
+    private cancel;
+    dispose(): void;
+    private matches;
+    /** Human hint label for an action, derived from the opening snapshot so footers
+     *  reflect the effective (possibly remapped) gestures the wizard actually honors. */
+    private label;
+    /** Like `label`, but drops gestures a focused pi text Input consumes as data
+     *  (single printable chars and the arrow keys), so the Exa/Composio footers do
+     *  not claim keys that never reach the wizard while a field owns focus. */
+    private fieldSafeLabel;
+    private handleGlobalTabSwitch;
+    private selectedPackage;
+    private selectedSystem;
+    private movePlugin;
+    private moveSystem;
+    private togglePackage;
+    private toggleSystem;
+    private toggleDetails;
+    private hasPendingInstalls;
+    private buildSubmission;
+    private finalize;
+    private filteredKeybindings;
+    private selectedKeybinding;
+    private moveKey;
+    private keyViewportLines;
+    private keyPageSize;
+    private beginKeyEdit;
+    private commitKeyEdit;
+    private cancelKeyEdit;
+    private saveKeybindings;
+    private refreshTmuxBindingsAfterSave;
+    private confirmKeyAction;
+    private handleKeybindingsInput;
+    handleInput(data: string): void;
+    private renderHeader;
+    private renderFooter;
+    private renderProviders;
+    private renderPlugins;
+    private renderSystems;
+    private renderExa;
+    private renderComposio;
+    private renderConfirm;
+    private keyRowHasMessage;
+    private keyLineCost;
+    private renderKeybindings;
+    render(width: number): string[];
+}
 export declare const sysSetupLeaf: LeafDef;