@crouton-kit/crouter 0.3.32 → 0.3.34

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

@@ -0,0 +1,352 @@
+import { spawnSync } from 'node:child_process';
+import { chmod, mkdir, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, dirname, join, resolve } from 'node:path';
+import { builtinPiPackageDir } from '../../core/scope.js';
+import { readJsonIfExists } from '../../core/fs-utils.js';
+const PACKAGE_COPY = {
+    'crtr-extensions': {
+        name: 'pi-crtr-extensions',
+        shortDescription: 'crtr companion extensions — command palette, help gating, statusline, subscription/OAuth rotation, nested context.',
+        longDescription: 'Bundles the extensions built for crtr: a crtr slash-command palette, crtr/crouter help gating, surfacing of Claude Code marketplace plugin commands, nested AGENTS.md/CLAUDE.md loading, a model/subscription/token statusline badge, OAuth login + rotation across multiple Claude subscriptions (provider-rotation), and system-prompt trimming. The OAuth/rotation piece is what lets crtr authenticate your Claude account.',
+    },
+    '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.',
+    },
+    'oauth-adapter': {
+        name: 'pi-claude-oauth-adapter',
+        shortDescription: 'Anthropic OAuth / Claude Code credential compatibility for pi.',
+        longDescription: 'Third-party adapter (minzique/dotfiles-agents) letting pi authenticate with Claude using Claude Code OAuth credentials. Installed from npm, pinned to 0.1.2.',
+    },
+};
+const PACKAGE_SOURCES = {
+    'crtr-extensions': { kind: 'local-path', source: builtinPiPackageDir('pi-crtr-extensions') },
+    'mode-switch': { kind: 'local-path', source: builtinPiPackageDir('pi-mode-switch') },
+    'oauth-adapter': { kind: 'npm', source: 'npm:pi-claude-oauth-adapter@0.1.2' },
+};
+const LOCAL_PACKAGE_NAME_ALIASES = {
+    'crtr-extensions': ['pi-crtr-extensions'],
+    'mode-switch': ['pi-mode-switch'],
+    'oauth-adapter': [],
+};
+export function buildSetupManifest(resolveBuiltinPackageDir = builtinPiPackageDir) {
+    return [
+        'crtr-extensions',
+        'mode-switch',
+        'oauth-adapter',
+    ].map((id) => {
+        const copy = PACKAGE_COPY[id];
+        const source = id === 'oauth-adapter'
+            ? PACKAGE_SOURCES[id].source
+            : resolveBuiltinPackageDir(copy.name);
+        return {
+            id,
+            name: copy.name,
+            sourceKind: PACKAGE_SOURCES[id].kind,
+            installSource: source,
+            shortDescription: copy.shortDescription,
+            longDescription: copy.longDescription,
+        };
+    });
+}
+function expandTilde(pathValue, homeDir) {
+    if (pathValue === '~')
+        return homeDir;
+    if (pathValue.startsWith('~/'))
+        return join(homeDir, pathValue.slice(2));
+    return pathValue;
+}
+function npmPackageName(source) {
+    if (!source.startsWith('npm:'))
+        return null;
+    const spec = source.slice(4);
+    const versionIndex = spec.startsWith('@') ? spec.indexOf('@', 1) : spec.lastIndexOf('@');
+    return versionIndex > 0 ? spec.slice(0, versionIndex) : spec;
+}
+export function normalizePackageIdentity(source, settingsDir, homeDir) {
+    const npmName = npmPackageName(source);
+    if (npmName !== null)
+        return `npm:${npmName}`;
+    const expanded = expandTilde(source, homeDir);
+    return resolve(settingsDir, expanded);
+}
+function packageNameIdentity(name) {
+    return `package:${name}`;
+}
+function localPackageNameIdentities(source) {
+    if (source.startsWith('npm:'))
+        return [];
+    return [packageNameIdentity(basename(source))];
+}
+function manifestIdentities(entry, settingsDir, homeDir) {
+    const identities = [normalizePackageIdentity(entry.installSource, settingsDir, homeDir)];
+    if (entry.sourceKind === 'local-path') {
+        identities.push(packageNameIdentity(entry.name));
+        for (const alias of LOCAL_PACKAGE_NAME_ALIASES[entry.id])
+            identities.push(packageNameIdentity(alias));
+    }
+    return identities;
+}
+export function detectInstalledSetupPackageIds(settingsJson, manifest = buildSetupManifest(), settingsPath = join(homedir(), '.pi', 'agent', 'settings.json'), homeDir = homedir()) {
+    const settingsDir = dirname(settingsPath);
+    const installed = new Set();
+    const manifestByIdentity = new Map();
+    for (const entry of manifest) {
+        for (const identity of manifestIdentities(entry, settingsDir, homeDir)) {
+            manifestByIdentity.set(identity, entry.id);
+        }
+    }
+    const rawPackages = settingsJson && typeof settingsJson === 'object'
+        ? settingsJson.packages
+        : undefined;
+    if (!Array.isArray(rawPackages))
+        return installed;
+    for (const raw of rawPackages) {
+        const source = typeof raw === 'string'
+            ? raw
+            : raw && typeof raw === 'object' && typeof raw.source === 'string'
+                ? raw.source
+                : null;
+        if (source === null)
+            continue;
+        const identities = [
+            normalizePackageIdentity(source, settingsDir, homeDir),
+            ...localPackageNameIdentities(source),
+        ];
+        for (const identity of identities) {
+            const id = manifestByIdentity.get(identity);
+            if (id !== undefined)
+                installed.add(id);
+        }
+    }
+    return installed;
+}
+export function detectCommandOnPath(command) {
+    const res = spawnSync('sh', ['-lc', `command -v ${command} >/dev/null 2>&1`], { stdio: 'ignore' });
+    return res.status === 0;
+}
+export function detectPackageManager(platform = process.platform, commandExists = detectCommandOnPath) {
+    switch (platform) {
+        case 'darwin':
+            return commandExists('brew') ? 'brew' : 'manual';
+        case 'linux':
+            if (commandExists('apt-get'))
+                return 'apt-get';
+            if (commandExists('dnf'))
+                return 'dnf';
+            if (commandExists('pacman'))
+                return 'pacman';
+            return 'manual';
+        default:
+            return 'manual';
+    }
+}
+export function buildSystemInstallPlan(tool, packageManager, installed) {
+    const label = `Install ${tool}`;
+    if (installed) {
+        return {
+            tool,
+            label,
+            installed: true,
+            checked: false,
+            packageManager,
+            command: null,
+            hint: 'already installed',
+            autoInstall: false,
+        };
+    }
+    const packageName = tool === 'nvim' ? 'neovim' : 'tmux';
+    switch (packageManager) {
+        case 'brew':
+            return {
+                tool,
+                label,
+                installed: false,
+                checked: true,
+                packageManager,
+                command: `brew install ${packageName}`,
+                hint: 'Homebrew install',
+                autoInstall: true,
+            };
+        case 'apt-get':
+            return {
+                tool,
+                label,
+                installed: false,
+                checked: true,
+                packageManager,
+                command: `sudo apt-get update && sudo apt-get install -y ${packageName}`,
+                hint: 'apt-get install',
+                autoInstall: true,
+            };
+        case 'dnf':
+            return {
+                tool,
+                label,
+                installed: false,
+                checked: true,
+                packageManager,
+                command: `sudo dnf install -y ${packageName}`,
+                hint: 'dnf install',
+                autoInstall: true,
+            };
+        case 'pacman':
+            return {
+                tool,
+                label,
+                installed: false,
+                checked: true,
+                packageManager,
+                command: `sudo pacman -S --noconfirm ${packageName}`,
+                hint: 'pacman install',
+                autoInstall: true,
+            };
+        default:
+            return {
+                tool,
+                label,
+                installed: false,
+                checked: false,
+                packageManager: 'manual',
+                command: null,
+                hint: `manual install required for ${tool}`,
+                autoInstall: false,
+            };
+    }
+}
+export function buildSystemToolState(tool, packageManager, commandExists = detectCommandOnPath) {
+    const installed = commandExists(tool);
+    return {
+        tool,
+        installed,
+        plan: buildSystemInstallPlan(tool, packageManager, installed),
+    };
+}
+export function resolveSettingsPath(homeDir = homedir()) {
+    return join(homeDir, '.pi', 'agent', 'settings.json');
+}
+export function resolveExaKeyPath(homeDir = homedir()) {
+    return join(homeDir, '.crouter', 'exa.key');
+}
+export function buildSetupInitialState(opts = {}) {
+    const homeDir = opts.homeDir ?? homedir();
+    const settingsPath = opts.settingsPath ?? resolveSettingsPath(homeDir);
+    const manifest = opts.manifest ?? buildSetupManifest(builtinPiPackageDir);
+    const settingsJson = readJsonIfExists(settingsPath);
+    const installedPackageIds = detectInstalledSetupPackageIds(settingsJson, manifest, settingsPath, homeDir);
+    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) };
+}
+export function buildSetupStaticInstructions(opts) {
+    return {
+        headline: 'crtr sys setup (non-interactive)',
+        packageLines: opts.manifest.map((entry) => {
+            const installed = opts.installedPackageIds.has(entry.id) ? 'installed' : 'not installed';
+            return `- ${entry.name} — ${entry.shortDescription} (${installed})`;
+        }),
+        systemLines: opts.systemPlans.map((plan) => {
+            if (plan.installed)
+                return `- ${plan.tool}: ✓ installed`;
+            if (plan.command)
+                return `- ${plan.tool}: ${plan.command}`;
+            return `- ${plan.tool}: ${plan.hint}`;
+        }),
+        exaLine: `- Exa key: write to ${opts.exaKeyPath} or set EXA_API_KEY`,
+        footer: 'Run `crtr sys setup` in a TTY to open the wizard.',
+    };
+}
+export function renderSetupStaticInstructions(state) {
+    const instructions = buildSetupStaticInstructions({
+        manifest: state.manifest,
+        installedPackageIds: state.installedPackageIds,
+        systemPlans: state.systemTools.map((tool) => tool.plan),
+        exaKeyPath: state.exaKeyPath,
+    });
+    return [
+        instructions.headline,
+        '',
+        'Packages:',
+        ...instructions.packageLines,
+        '',
+        'System deps:',
+        ...instructions.systemLines,
+        '',
+        instructions.exaLine,
+        instructions.footer,
+    ].join('\n') + '\n';
+}
+function runShellCommand(command) {
+    const result = spawnSync('sh', ['-lc', command], { stdio: 'inherit' });
+    if (result.status !== 0) {
+        throw new Error(`command failed: ${command}`);
+    }
+}
+function installPiPackage(source) {
+    const result = spawnSync('pi', ['install', source], { stdio: 'inherit' });
+    if (result.status !== 0) {
+        throw new Error(`pi install failed: ${source}`);
+    }
+}
+export async function writeExaKey(exaKeyPath, exaKey) {
+    await mkdir(dirname(exaKeyPath), { recursive: true });
+    await writeFile(exaKeyPath, `${exaKey}\n`, 'utf8');
+    await chmod(exaKeyPath, 0o600).catch(() => undefined);
+}
+export function summarizeSetupExecution(result) {
+    return {
+        installed: [...result.installedPackages, ...result.installedSystemDeps],
+        skipped: [...result.skippedPackages, ...result.skippedSystemDeps],
+        exaKeyWritten: result.exaKeyWritten,
+        exaKeyPath: result.exaKeyPath,
+    };
+}
+export function formatSetupExecutionSummary(summary) {
+    return [
+        'crtr sys setup complete',
+        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',
+    ].join('\n') + '\n';
+}
+export async function executeSetupSubmission(submission) {
+    const installedPackages = [];
+    const skippedPackages = [];
+    const installedSystemDeps = [];
+    const skippedSystemDeps = [];
+    for (const entry of submission.packages) {
+        if (submission.installedPackageIds.has(entry.id)) {
+            skippedPackages.push(`${entry.name} (already installed)`);
+            continue;
+        }
+        installPiPackage(entry.installSource);
+        installedPackages.push(entry.name);
+    }
+    for (const plan of submission.systemDeps) {
+        if (!plan.checked || plan.installed) {
+            skippedSystemDeps.push(`${plan.tool} (already installed)`);
+            continue;
+        }
+        if (!plan.autoInstall || !plan.command) {
+            skippedSystemDeps.push(`${plan.tool} (${plan.hint})`);
+            continue;
+        }
+        runShellCommand(plan.command);
+        installedSystemDeps.push(plan.tool);
+    }
+    const exaKeyWritten = submission.exaKey.trim() !== '';
+    if (exaKeyWritten) {
+        await writeExaKey(submission.exaKeyPath, submission.exaKey);
+    }
+    return summarizeSetupExecution({
+        installedPackages,
+        skippedPackages,
+        installedSystemDeps,
+        skippedSystemDeps,
+        exaKeyWritten,
+        exaKeyPath: submission.exaKeyPath,
+    });
+}

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

@@ -0,0 +1,2 @@
+import type { LeafDef } from '../../core/command.js';
+export declare const sysSetupLeaf: LeafDef;