@crouton-kit/crouter 0.3.68 → 0.3.78

package/dist/commands/profile/new.js

@@ -1,9 +1,10 @@
 import { defineLeaf } from '../../core/command.js';
-import { createProfile, profileRoot } from '../../core/profiles/manifest.js';
+import { usage } from '../../core/errors.js';
+import { createProfile, ensureRootProfile, profileRoot } from '../../core/profiles/manifest.js';
 export const newLeaf = defineLeaf({
     name: 'new',
     description: 'create a new profile',
-    whenToUse: 'you are establishing a new agent identity — a stable id, a display name, and its own memory store. Pass at most one initial project directory here (the parser has no repeatable-flag support); use `profile project add` afterward for every additional one.',
+    whenToUse: 'you are establishing a new agent identity — a stable id, a display name, and its own memory store. Pass at most one initial project directory here (the parser has no repeatable-flag support); use `profile project add` afterward for every additional one. Use `--root` (no name) to provision the canonical stable root profile — the default identity a home falls back to — idempotently, without spawning a node.',
     help: {
         name: 'profile new',
         summary: 'create a profile: `<profiles-root>/<slug>-<id>/` with a manifest + its own `memory/` store',
@@ -12,8 +13,15 @@ export const newLeaf = defineLeaf({
                 kind: 'flag',
                 name: 'name',
                 type: 'string',
-                required: true,
-                constraint: 'Display name for the profile. Also slugified into the stable profile id — the id never changes on later rename.',
+                required: false,
+                constraint: 'Display name for the profile. Also slugified into the stable profile id — the id never changes on later rename. Required unless `--root` is given; mutually exclusive with `--root`.',
+            },
+            {
+                kind: 'flag',
+                name: 'root',
+                type: 'bool',
+                required: false,
+                constraint: 'Provision the canonical stable root profile (fixed id `root-00000000`, name `root`) — the fallback default identity for a home — instead of a fresh named one. Idempotent: re-running returns the existing root. Node-free (no `node new --root` needed). Mutually exclusive with `--name`/`--project`.',
             },
             {
                 kind: 'flag',
@@ -32,11 +40,28 @@ export const newLeaf = defineLeaf({
             { name: 'follow_up', type: 'string', required: true, constraint: 'Concrete next commands.' },
         ],
         outputKind: 'object',
-        effects: ['Creates `<profile-dir>/profile.json` and `<profile-dir>/memory/`.'],
+        effects: ['Creates `<profile-dir>/profile.json` and `<profile-dir>/memory/` (the fixed root dir when `--root`).'],
     },
     run: async (input) => {
         const name = input['name'];
         const project = input['project'];
+        const root = input['root'] === true;
+        if (root) {
+            if (name !== undefined || project !== undefined) {
+                throw usage('`--root` provisions the canonical stable root profile and takes no `--name`/`--project`.');
+            }
+            const { profileId, manifest } = ensureRootProfile();
+            return {
+                profile_id: profileId,
+                name: manifest.name,
+                path: profileRoot(profileId),
+                projects: manifest.projects,
+                created_at: manifest.created_at,
+                follow_up: `Root profile ensured. Spawn nodes under it with \`--profile ${profileId}\`, or widen its purview with \`crtr profile project add ${profileId} --dir <path>\`.`,
+            };
+        }
+        if (name === undefined)
+            throw usage('provide `--name <name>` to create a profile, or `--root` to provision the stable root profile.');
         const { profileId, manifest } = createProfile(name, project !== undefined ? [project] : []);
         return {
             profile_id: profileId,

package/dist/commands/surface-tmux-spread.js

@@ -2,9 +2,7 @@
 //
 // A genuine viewer-placement decision (tile every live viewer in a subtree into
 // one window), so it lives under `surface` alongside view/attach/workspace/web.
-// Also bound to the `/graph` view's `e` key (src/pi-extensions/canvas-nav.ts),
-// which shells this leaf directly for the cursor node. It "expands" the graph
-// you are watching: the caller's
+// The command expands the graph being watched: the caller's
 // own viewer pane is broken out into a BRAND-NEW window, then a surface-attach
 // viewer pane is tiled beside it for every broker-alive node in the local
 // subtree (ancestry root → self → descendants), so the user lands on a single

package/dist/commands/sys/__tests__/config-keybindings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/sys/__tests__/config-keybindings.test.js

@@ -0,0 +1,55 @@
+import { after, before, beforeEach, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { configBranch } from '../config.js';
+import { ensureScopeInitialized } from '../../../core/config.js';
+import { resetScopeCache } from '../../../core/scope.js';
+function leaf(name) {
+    const found = (configBranch.children ?? []).find((child) => child.name === name);
+    if (found === undefined || found.kind !== 'leaf')
+        throw new Error(`no leaf '${name}' under sys config`);
+    return found;
+}
+let home;
+let realHome;
+before(() => { realHome = process.env['HOME']; });
+beforeEach(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-config-keybindings-'));
+    process.env['HOME'] = home;
+});
+after(() => {
+    if (realHome === undefined)
+        delete process.env['HOME'];
+    else
+        process.env['HOME'] = realHome;
+});
+test.afterEach(() => rmSync(home, { recursive: true, force: true }));
+test('a new project scope initializes through the config lock', () => {
+    const project = mkdtempSync(join(tmpdir(), 'crtr-config-project-'));
+    const previous = process.cwd();
+    try {
+        process.chdir(project);
+        resetScopeCache();
+        const root = join(project, '.crouter');
+        ensureScopeInitialized('project', root);
+        assert.equal(JSON.parse(readFileSync(join(root, 'config.json'), 'utf8')).keybindings, undefined);
+    }
+    finally {
+        process.chdir(previous);
+        resetScopeCache();
+        rmSync(project, { recursive: true, force: true });
+    }
+});
+test('sys config exposes whole user keybindings read-only and routes edits to setup', async () => {
+    mkdirSync(join(home, '.crouter'), { recursive: true });
+    writeFileSync(join(home, '.crouter', 'config.json'), JSON.stringify({
+        keybindings: { 'crtr.graph.down': ['down'] },
+    }));
+    const result = await leaf('get').run({ key: 'keybindings', scope: 'user' });
+    assert.deepEqual(result['value'], { 'crtr.graph.down': ['down'] });
+    await assert.rejects(() => leaf('get').run({ key: 'keybindings.crtr.graph.down', scope: 'user' }), /whole user-scope object/);
+    await assert.rejects(() => leaf('set').run({ key: 'keybindings', value: '{}' }), /crtr sys setup/);
+    assert.doesNotMatch(JSON.stringify(configBranch), /canvasNav/);
+});

package/dist/commands/sys/__tests__/config-model-ladders.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/sys/__tests__/config-model-ladders.test.js

@@ -0,0 +1,121 @@
+// config-model-ladders.test.ts — regression coverage for the live Hearth
+// incident where a home's config.json had `openai-codex/gpt-5.6-*` baked into
+// `modelLadders` while the guest's own installed model registry only had
+// `gpt-5.5`. Root cause: both `ensureScopeInitialized` (fresh scope) and
+// `sys config set modelLadders...` (a targeted edit) persisted the FULLY
+// materialized ladder (all 4 strengths x 2 providers) rather than only the
+// genuine override, freezing whatever concrete model ids happened to be
+// compiled into the crouter build that ran at that moment. A later
+// crouter/pi upgrade (or rollback) that changes the registry can then never
+// reach the frozen rungs again.
+import { test, before, after, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ensureScopeInitialized, readConfig, updateConfig } from '../../../core/config.js';
+import { configBranch } from '../config.js';
+function leaf(name) {
+    const found = (configBranch.children ?? []).find((c) => c.name === name);
+    if (found === undefined || found.kind !== 'leaf')
+        throw new Error(`no leaf '${name}' under sys config`);
+    return found;
+}
+let home;
+let realHome;
+before(() => {
+    realHome = process.env['HOME'];
+});
+beforeEach(() => {
+    home = mkdtempSync(join(tmpdir(), 'crtr-config-ladders-'));
+    process.env['HOME'] = home;
+});
+// Every test allocates its own temp HOME in beforeEach, so each must be removed
+// in afterEach -- a single `after` would leak all but the last dir.
+afterEach(() => {
+    rmSync(home, { recursive: true, force: true });
+});
+after(() => {
+    if (realHome !== undefined)
+        process.env['HOME'] = realHome;
+    else
+        delete process.env['HOME'];
+});
+test('ensureScopeInitialized does NOT bake concrete modelLadders model ids into a fresh config.json', () => {
+    const root = join(home, '.crouter');
+    ensureScopeInitialized('user', root);
+    const cfgPath = join(root, 'config.json');
+    assert.equal(existsSync(cfgPath), true);
+    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
+    // The file must exist (so `sys config path` has something to point at) but
+    // must NOT freeze a modelLadders snapshot -- that key should be absent so
+    // `readConfig` always re-derives it live from whichever build is running.
+    assert.equal(raw.modelLadders, undefined);
+    // readConfig must still default-fill a full, usable ladder despite the
+    // omission -- a config-less scope is never worse off.
+    const cfg = readConfig('user');
+    assert.equal(typeof cfg.modelLadders.anthropic.strong, 'string');
+    assert.equal(typeof cfg.modelLadders.openai.strong, 'string');
+});
+test('sys config set modelLadders.<provider>.<strength> persists ONLY the touched rung, not the whole materialized ladder', async () => {
+    const root = join(home, '.crouter');
+    ensureScopeInitialized('user', root);
+    await leaf('set').run({ key: 'modelLadders.openai.strong', value: 'openai-codex/gpt-5.5:high' });
+    const cfgPath = join(root, 'config.json');
+    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
+    assert.equal(raw.modelLadders.openai.strong, 'openai-codex/gpt-5.5:high');
+    // The other three openai rungs, and the entire anthropic ladder, must stay
+    // UNSET on disk -- baking them in would freeze this scope to today's
+    // compiled defaults for rungs the user never touched, the exact staleness
+    // bug that produced the live `gpt-5.6` vs. installed-`gpt-5.5` mismatch.
+    assert.equal(raw.modelLadders.openai.ultra, undefined);
+    assert.equal(raw.modelLadders.openai.medium, undefined);
+    assert.equal(raw.modelLadders.openai.light, undefined);
+    assert.equal(raw.modelLadders.anthropic, undefined);
+    // readConfig still resolves a full ladder: the one override layered over
+    // live compiled defaults for everything else.
+    const cfg = readConfig('user');
+    assert.equal(cfg.modelLadders.openai.strong, 'openai-codex/gpt-5.5:high');
+    assert.equal(typeof cfg.modelLadders.openai.ultra, 'string');
+    assert.equal(typeof cfg.modelLadders.anthropic.strong, 'string');
+});
+test('an unrelated updateConfig mutation (as fresh bootstrap does) does NOT freeze modelLadders to disk', () => {
+    const root = join(home, '.crouter');
+    ensureScopeInitialized('user', root);
+    // Mimic `ensureOfficialMarketplace`'s bootstrap write: updateConfig mutating an
+    // unrelated field on a fresh scope. This must not materialize a full ladder.
+    updateConfig('user', (c) => {
+        c.marketplaces['crouter-official-marketplace'] = {
+            url: 'https://example.invalid/x.git',
+            ref: 'main',
+            installed_at: '2026-01-01T00:00:00.000Z',
+        };
+    });
+    const cfgPath = join(root, 'config.json');
+    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
+    assert.equal(raw.modelLadders, undefined);
+    assert.ok(raw.marketplaces['crouter-official-marketplace']);
+});
+test('a non-ladder sys config set does NOT freeze modelLadders to disk', async () => {
+    const root = join(home, '.crouter');
+    ensureScopeInitialized('user', root);
+    await leaf('set').run({ key: 'max_panes_per_window', value: '5' });
+    const cfgPath = join(root, 'config.json');
+    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
+    // The touched key persists; modelLadders stays absent so a later build's
+    // registry change still reaches every rung.
+    assert.equal(raw.max_panes_per_window, 5);
+    assert.equal(raw.modelLadders, undefined);
+});
+test('a second sys config set for a different rung does not clobber an earlier override', async () => {
+    const root = join(home, '.crouter');
+    ensureScopeInitialized('user', root);
+    await leaf('set').run({ key: 'modelLadders.openai.strong', value: 'openai-codex/gpt-5.5:high' });
+    await leaf('set').run({ key: 'modelLadders.anthropic.light', value: 'anthropic/claude-haiku-4-5:high' });
+    const cfgPath = join(root, 'config.json');
+    const raw = JSON.parse(readFileSync(cfgPath, 'utf8'));
+    assert.equal(raw.modelLadders.openai.strong, 'openai-codex/gpt-5.5:high');
+    assert.equal(raw.modelLadders.anthropic.light, 'anthropic/claude-haiku-4-5:high');
+    assert.equal(raw.modelLadders.openai.ultra, undefined);
+    assert.equal(raw.modelLadders.anthropic.strong, undefined);
+});

package/dist/commands/sys/config.js

@@ -1,5 +1,5 @@
 import { defineBranch, defineLeaf } from '../../core/command.js';
-import { readConfig, writeConfig, configPath as coreConfigPath } from '../../core/config.js';
+import { readConfig, updateConfig, configPath as coreConfigPath } from '../../core/config.js';
 import { usage, notFound } from '../../core/errors.js';
 import { scopeRoot, listScopes } from '../../core/scope.js';
 import { resolveScope } from './shared.js';
@@ -11,7 +11,6 @@ const TOP_LEVEL_KEYS = new Set([
     'marketplaces',
     'plugins',
     'max_panes_per_window',
-    'canvasNav',
     'modelLadders',
 ]);
 const MODEL_PROVIDERS = new Set(['anthropic', 'openai']);
@@ -44,6 +43,9 @@ function parseConfigValue(raw) {
 function setNestedValue(cfg, key, rawValue, value) {
     const parts = key.split('.');
     const topKey = parts[0];
+    if (topKey === 'keybindings') {
+        throw usage('keybindings are edited only through `crtr sys setup`');
+    }
     if (!TOP_LEVEL_KEYS.has(topKey)) {
         throw usage(`unknown config key: ${topKey} (expected: ${[...TOP_LEVEL_KEYS].join('|')})`);
     }
@@ -69,16 +71,6 @@ function setNestedValue(cfg, key, rawValue, value) {
         cfg.max_panes_per_window = Math.floor(value);
         return;
     }
-    if (topKey === 'canvasNav') {
-        // Only the scalar prefixKey is settable here; the prefixBinds/graphBinds
-        // record tables are edited directly in config.json (run `crtr sys config
-        // path` to locate it).
-        if (key === 'canvasNav.prefixKey') {
-            cfg.canvasNav.prefixKey = rawValue;
-            return;
-        }
-        throw usage(`canvasNav.${parts.slice(1).join('.') || '*'} is a record table — edit config.json directly (run \`crtr sys config path\`). Only canvasNav.prefixKey is settable via this command.`);
-    }
     if (topKey === 'modelLadders') {
         if (parts.length === 2 && parts[1] === 'defaultProvider') {
             if (!isModelProvider(rawValue)) {
@@ -121,12 +113,12 @@ function setNestedValue(cfg, key, rawValue, value) {
 const configGet = defineLeaf({
     name: 'get',
     description: 'read a config value by key',
-    whenToUse: 'you want to read a single config value by its dotted key — the current auto_update policy, max_panes_per_window, the canvasNav prefix key, or model ladders — optionally from a specific scope. Use sys config set instead to change a value, sys config path to locate the file for hand-editing.',
+    whenToUse: 'you want to inspect one config value — including the whole user keybindings object — optionally from a specific scope. Use sys setup to edit keybindings and sys config set for supported scalar settings.',
     help: {
         name: 'sys config get',
         summary: 'read a config value by dotted key',
         params: [
-            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Top-level keys: auto_update, marketplaces, plugins, max_panes_per_window, canvasNav, modelLadders (read whole; edit canvasNav.prefixBinds/graphBinds in config.json directly).' },
+            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Top-level keys: auto_update, marketplaces, plugins, max_panes_per_window, modelLadders, or the whole keybindings object. Keybindings are edited only through sys setup.' },
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to read from. Default: user.' },
         ],
         output: [
@@ -140,6 +132,9 @@ const configGet = defineLeaf({
     run: async (input) => {
         const key = input['key'];
         const scope = resolveScope(input['scope']);
+        if (key.startsWith('keybindings.') || (key === 'keybindings' && scope !== 'user')) {
+            throw notFound('keybindings are available only as the whole user-scope object');
+        }
         const cfg = readConfig(scope);
         const value = getNestedValue(cfg, key);
         if (value === undefined) {
@@ -151,12 +146,12 @@ const configGet = defineLeaf({
 const configSet = defineLeaf({
     name: 'set',
     description: 'write a config value by key',
-    whenToUse: 'you want to change a crtr setting — flip auto_update.crtr or auto_update.content to notify, apply, or off, raise max_panes_per_window, rebind canvasNav.prefixKey, or set model ladders — written to the user or project scope. Use sys config get instead to read a value; the canvasNav record tables are not settable here, so edit config.json directly (sys config path) for those.',
+    whenToUse: 'you want to change a supported scalar crtr setting in user or project scope. Use sys setup instead for keybindings, and sys config get to inspect values.',
     help: {
         name: 'sys config set',
         summary: 'write a config value by dotted key',
         params: [
-            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Supported: auto_update.crtr, auto_update.content, auto_update.interval_hours, max_panes_per_window, canvasNav.prefixKey, modelLadders.defaultProvider, modelLadders.<anthropic|openai>.<ultra|strong|medium|light>. The canvasNav.prefixBinds/graphBinds record tables are not settable here — edit config.json directly (`crtr sys config path`).' },
+            { kind: 'positional', name: 'key', type: 'string', required: true, constraint: 'Dotted key path. Supported: auto_update.crtr, auto_update.content, auto_update.interval_hours, max_panes_per_window, modelLadders.defaultProvider, modelLadders.<anthropic|openai>.<ultra|strong|medium|light>. Keybindings are edited only through sys setup.' },
             { kind: 'flag', name: 'value', type: 'string', required: true, constraint: 'value VALUE — string, required. Stored as-is if quoted; coerced to number or boolean when unambiguous.' },
             { kind: 'flag', name: 'scope', type: 'enum', choices: ['user', 'project'], required: false, constraint: 'Scope to write to. Default: user.' },
         ],
@@ -174,9 +169,11 @@ const configSet = defineLeaf({
         const scope = resolveScope(input['scope']);
         // Flags are stringly-typed; coerce to number or boolean when unambiguous
         const parsed = parseConfigValue(rawValue);
-        const cfg = readConfig(scope);
-        setNestedValue(cfg, key, rawValue, parsed);
-        writeConfig(scope, cfg);
+        // Mutate + persist through the central raw-partial path. `updateConfig`
+        // writes only the keys this set actually touched -- a non-ladder set never
+        // freezes a materialized `modelLadders`, and a direct
+        // `modelLadders.<provider>.<strength>` set persists only the touched rung.
+        const cfg = updateConfig(scope, (c) => setNestedValue(c, key, rawValue, parsed));
         // Read back the written value for echo
         const written = getNestedValue(cfg, key);
         return { key, value: written, scope };
@@ -185,7 +182,7 @@ const configSet = defineLeaf({
 const configPath = defineLeaf({
     name: 'path',
     description: 'print path(s) to config.json',
-    whenToUse: 'you need the absolute path to config.json — typically to hand-edit settings sys config set cannot reach, like the canvasNav.prefixBinds and graphBinds record tables.',
+    whenToUse: 'you need the absolute path to a user or project config.json for inspection or backup.',
     help: {
         name: 'sys config path',
         summary: 'print absolute path(s) to config.json',
@@ -225,7 +222,7 @@ const configPath = defineLeaf({
 export const configBranch = defineBranch({
     name: 'config',
     description: 'read and write configuration',
-    whenToUse: 'inspecting or changing crtr settings — read a value with sys config get, change one with sys config set (auto_update policy, max_panes_per_window, canvasNav.prefixKey, model ladders), or locate config.json with sys config path to hand-edit the record tables set cannot reach.',
+    whenToUse: 'inspecting crtr settings, changing supported scalar values, or locating config.json. Keybinding changes belong in sys setup.',
     help: {
         name: 'sys config',
         summary: 'read and write crtr configuration, including model ladders',

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

@@ -31,6 +31,7 @@ export interface SetupStaticInstructions {
     packageLines: string[];
     systemLines: string[];
     exaLine: string;
+    composioLine: string;
     footer: string;
 }
 export interface SetupSubmission {
@@ -39,18 +40,23 @@ export interface SetupSubmission {
     systemDeps: SetupSystemInstallPlan[];
     exaKey: string;
     exaKeyPath: string;
+    composioKey: string;
+    composioKeyPath: string;
 }
 export interface SetupExecutionSummary {
     installed: string[];
     skipped: string[];
     exaKeyWritten: boolean;
     exaKeyPath: string;
+    composioKeyWritten: boolean;
+    composioKeyPath: string;
 }
 export interface SetupInitialState {
     manifest: SetupPackageManifestEntry[];
     installedPackageIds: Set<SetupPackageId>;
     systemTools: SetupSystemToolState[];
     exaKeyPath: string;
+    composioKeyPath: string;
 }
 export declare function buildSetupManifest(resolveBuiltinPackageDir?: (name: string) => string): SetupPackageManifestEntry[];
 export declare function normalizePackageIdentity(source: string, settingsDir: string, homeDir: string): SetupPackageIdentity;
@@ -61,6 +67,7 @@ export declare function buildSystemInstallPlan(tool: SetupTool, packageManager:
 export declare function buildSystemToolState(tool: SetupTool, packageManager: PackageManager, commandExists?: (command: string) => boolean): SetupSystemToolState;
 export declare function resolveSettingsPath(homeDir?: string): string;
 export declare function resolveExaKeyPath(homeDir?: string): string;
+export declare function resolveComposioKeyPath(homeDir?: string): string;
 export declare function buildSetupInitialState(opts?: {
     manifest?: SetupPackageManifestEntry[];
     settingsPath?: string;
@@ -73,9 +80,11 @@ export declare function buildSetupStaticInstructions(opts: {
     installedPackageIds: Set<SetupPackageId>;
     systemPlans: SetupSystemInstallPlan[];
     exaKeyPath: string;
+    composioKeyPath: string;
 }): SetupStaticInstructions;
-export declare function renderSetupStaticInstructions(state: Pick<SetupInitialState, 'manifest' | 'installedPackageIds' | 'systemTools' | 'exaKeyPath'>): string;
+export declare function renderSetupStaticInstructions(state: Pick<SetupInitialState, 'manifest' | 'installedPackageIds' | 'systemTools' | 'exaKeyPath' | 'composioKeyPath'>): string;
 export declare function writeExaKey(exaKeyPath: string, exaKey: string): Promise<void>;
+export declare function writeComposioKey(composioKeyPath: string, composioKey: string): Promise<void>;
 export declare function summarizeSetupExecution(result: {
     installedPackages: string[];
     skippedPackages: string[];
@@ -83,6 +92,8 @@ export declare function summarizeSetupExecution(result: {
     skippedSystemDeps: string[];
     exaKeyWritten: boolean;
     exaKeyPath: string;
+    composioKeyWritten: boolean;
+    composioKeyPath: string;
 }): SetupExecutionSummary;
 export declare function formatSetupExecutionSummary(summary: SetupExecutionSummary): string;
 export declare function executeSetupSubmission(submission: SetupSubmission): Promise<SetupExecutionSummary>;

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

@@ -13,8 +13,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 +231,9 @@ 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');
+}
 export function buildSetupInitialState(opts = {}) {
     const homeDir = opts.homeDir ?? homedir();
     const settingsPath = opts.settingsPath ?? resolveSettingsPath(homeDir);
@@ -240,7 +243,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 +260,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,10 +270,13 @@ 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.',
+        '',
         'Packages:',
         ...instructions.packageLines,
         '',
@@ -277,6 +284,7 @@ export function renderSetupStaticInstructions(state) {
         ...instructions.systemLines,
         '',
         instructions.exaLine,
+        instructions.composioLine,
         instructions.footer,
     ].join('\n') + '\n';
 }
@@ -297,12 +305,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) {
@@ -311,6 +326,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) {
@@ -342,6 +358,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,
@@ -349,5 +369,7 @@ export async function executeSetupSubmission(submission) {
         skippedSystemDeps,
         exaKeyWritten,
         exaKeyPath: submission.exaKeyPath,
+        composioKeyWritten,
+        composioKeyPath: submission.composioKeyPath,
     });
 }