@crouton-kit/crouter 0.3.70 → 0.3.79

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',
@@ -13,8 +134,8 @@ const PACKAGE_COPY = {
     },
     'mode-switch': {
         name: 'pi-mode-switch',
-        shortDescription: 'Alt+M cycles spec / plan / normal modes; injects mode-specific guidance on change.',
-        longDescription: 'Press Alt+M to rotate between three operating modes — spec (requirements gathering), plan (design before code), and normal (execution). Each switch appends mode-tailored guidance to keep the agent in the right gear.',
+        shortDescription: 'Alt+Shift+P cycles spec / plan / normal modes; injects mode-specific guidance on change.',
+        longDescription: 'Press Alt+Shift+P to rotate between three operating modes — spec (requirements gathering), plan (design before code), and normal (execution). Each switch appends mode-tailored guidance to keep the agent in the right gear.',
     },
     'oauth-adapter': {
         name: 'pi-claude-oauth-adapter',
@@ -231,6 +352,25 @@ export function resolveSettingsPath(homeDir = homedir()) {
 export function resolveExaKeyPath(homeDir = homedir()) {
     return join(homeDir, '.crouter', 'exa.key');
 }
+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);
@@ -240,7 +380,7 @@ export function buildSetupInitialState(opts = {}) {
     const commandExists = opts.commandExists ?? detectCommandOnPath;
     const packageManager = opts.packageManager ?? detectPackageManager(process.platform, commandExists);
     const systemTools = ['tmux', 'nvim'].map((tool) => buildSystemToolState(tool, packageManager, commandExists));
-    return { manifest, installedPackageIds, systemTools, exaKeyPath: resolveExaKeyPath(homeDir) };
+    return { manifest, installedPackageIds, systemTools, exaKeyPath: resolveExaKeyPath(homeDir), composioKeyPath: resolveComposioKeyPath(homeDir) };
 }
 export function buildSetupStaticInstructions(opts) {
     return {
@@ -257,6 +397,7 @@ export function buildSetupStaticInstructions(opts) {
             return `- ${plan.tool}: ${plan.hint}`;
         }),
         exaLine: `- Exa key: write to ${opts.exaKeyPath} or set EXA_API_KEY`,
+        composioLine: `- Composio key: write to ${opts.composioKeyPath} or set COMPOSIO_API_KEY`,
         footer: 'Run `crtr sys setup` in a TTY to open the wizard.',
     };
 }
@@ -266,11 +407,12 @@ export function renderSetupStaticInstructions(state) {
         installedPackageIds: state.installedPackageIds,
         systemPlans: state.systemTools.map((tool) => tool.plan),
         exaKeyPath: state.exaKeyPath,
+        composioKeyPath: state.composioKeyPath,
     });
     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,
@@ -279,6 +421,7 @@ export function renderSetupStaticInstructions(state) {
         ...instructions.systemLines,
         '',
         instructions.exaLine,
+        instructions.composioLine,
         instructions.footer,
     ].join('\n') + '\n';
 }
@@ -299,12 +442,19 @@ export async function writeExaKey(exaKeyPath, exaKey) {
     await writeFile(exaKeyPath, `${exaKey}\n`, 'utf8');
     await chmod(exaKeyPath, 0o600).catch(() => undefined);
 }
+export async function writeComposioKey(composioKeyPath, composioKey) {
+    await mkdir(dirname(composioKeyPath), { recursive: true });
+    await writeFile(composioKeyPath, `${composioKey}\n`, 'utf8');
+    await chmod(composioKeyPath, 0o600).catch(() => undefined);
+}
 export function summarizeSetupExecution(result) {
     return {
         installed: [...result.installedPackages, ...result.installedSystemDeps],
         skipped: [...result.skippedPackages, ...result.skippedSystemDeps],
         exaKeyWritten: result.exaKeyWritten,
         exaKeyPath: result.exaKeyPath,
+        composioKeyWritten: result.composioKeyWritten,
+        composioKeyPath: result.composioKeyPath,
     };
 }
 export function formatSetupExecutionSummary(summary) {
@@ -313,6 +463,7 @@ export function formatSetupExecutionSummary(summary) {
         summary.installed.length > 0 ? `installed: ${summary.installed.join(', ')}` : 'installed: none',
         summary.skipped.length > 0 ? `skipped: ${summary.skipped.join(', ')}` : 'skipped: none',
         summary.exaKeyWritten ? `exa key written: ${summary.exaKeyPath}` : 'exa key written: no',
+        summary.composioKeyWritten ? `composio key written: ${summary.composioKeyPath}` : 'composio key written: no',
     ].join('\n') + '\n';
 }
 export async function executeSetupSubmission(submission) {
@@ -344,6 +495,10 @@ export async function executeSetupSubmission(submission) {
     if (exaKeyWritten) {
         await writeExaKey(submission.exaKeyPath, submission.exaKey);
     }
+    const composioKeyWritten = submission.composioKey.trim() !== '';
+    if (composioKeyWritten) {
+        await writeComposioKey(submission.composioKeyPath, submission.composioKey);
+    }
     return summarizeSetupExecution({
         installedPackages,
         skippedPackages,
@@ -351,5 +506,7 @@ export async function executeSetupSubmission(submission) {
         skippedSystemDeps,
         exaKeyWritten,
         exaKeyPath: submission.exaKeyPath,
+        composioKeyWritten,
+        composioKeyPath: submission.composioKeyPath,
     });
 }

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;