@gurulu/cli 0.1.0

package/dist/commands/install.js

@@ -0,0 +1,920 @@
+"use strict";
+/**
+ * Phase 16 A2 — `gurulu install` user-facing auto-install command.
+ *
+ * Runs the full bootstrap loop against a target repo:
+ *   1. scan            (scripts/gurulu-scan.mjs)
+ *   2. confirm         (interactive, skipped with --yes)
+ *   3. agentic plan    (scripts/gurulu-agentic-install.mjs --dry-run)
+ *   4. apply           (scripts/gurulu-agentic-install.mjs --apply)
+ *   5. npm install     (pm detected from lockfile)
+ *   6. .env merge      (.env.local for Next.js, .env otherwise)
+ *   7. ingest ping     (POST <ingestUrl>/api/ingest/v1/health)
+ *
+ * The command is designed so the flow orchestration (`runInstallFlow`) can
+ * be unit-tested with injected deps — no real spawns or fetches required.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveScriptsDir = resolveScriptsDir;
+exports.detectPackageManager = detectPackageManager;
+exports.packageInstallArgs = packageInstallArgs;
+exports.mergeEnvFile = mergeEnvFile;
+exports.createDefaultDeps = createDefaultDeps;
+exports.runInstallFlow = runInstallFlow;
+exports.repoHashOf = repoHashOf;
+exports.pickSite = pickSite;
+exports.emitInstallTelemetry = emitInstallTelemetry;
+exports.runAuthenticatedInstallFlow = runAuthenticatedInstallFlow;
+exports.installCommand = installCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+const ui_1 = require("../utils/ui");
+const config_1 = require("../config");
+const api_client_1 = require("../api-client");
+const install_intent_proposal_1 = require("../install-intent-proposal");
+// ---------------------------------------------------------------------------
+// Script resolution
+// ---------------------------------------------------------------------------
+/**
+ * Locate the repo scripts/ directory (works when installed from source tree
+ * or as a bundled package; falls back to GURULU_SCRIPTS_DIR env override).
+ */
+function resolveScriptsDir(startDir = __dirname) {
+    if (process.env.GURULU_SCRIPTS_DIR && fs.existsSync(process.env.GURULU_SCRIPTS_DIR)) {
+        return process.env.GURULU_SCRIPTS_DIR;
+    }
+    let dir = startDir;
+    for (let i = 0; i < 8; i++) {
+        const candidate = path.join(dir, 'scripts', 'gurulu-scan.mjs');
+        if (fs.existsSync(candidate))
+            return path.join(dir, 'scripts');
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    // Default to monorepo root guess (4 levels up from packages/cli/dist/commands)
+    return path.resolve(startDir, '..', '..', '..', '..', 'scripts');
+}
+// ---------------------------------------------------------------------------
+// Package-manager detection
+// ---------------------------------------------------------------------------
+function detectPackageManager(repoRoot) {
+    if (fs.existsSync(path.join(repoRoot, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs.existsSync(path.join(repoRoot, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+function packageInstallArgs(pm) {
+    if (pm === 'pnpm')
+        return ['add', '@gurulu/tracker-web'];
+    if (pm === 'yarn')
+        return ['add', '@gurulu/tracker-web'];
+    return ['install', '@gurulu/tracker-web'];
+}
+function mergeEnvFile(repoRoot, framework, vars) {
+    const isNext = framework.startsWith('nextjs') || framework === 'nextjs';
+    const filename = isNext ? '.env.local' : '.env';
+    const filePath = path.join(repoRoot, filename);
+    let existing = '';
+    if (fs.existsSync(filePath)) {
+        existing = fs.readFileSync(filePath, 'utf8');
+    }
+    const existingKeys = new Set(existing
+        .split('\n')
+        .map((l) => l.trim())
+        .filter((l) => l && !l.startsWith('#'))
+        .map((l) => l.split('=')[0].trim()));
+    const added = [];
+    const skipped = [];
+    const linesToAppend = [];
+    for (const [key, value] of Object.entries(vars)) {
+        if (existingKeys.has(key)) {
+            skipped.push(key);
+            continue;
+        }
+        linesToAppend.push(`${key}=${value}`);
+        added.push(key);
+    }
+    if (linesToAppend.length > 0) {
+        const separator = existing && !existing.endsWith('\n') ? '\n' : '';
+        const header = existing ? '' : '# Gurulu.io Analytics\n';
+        fs.appendFileSync(filePath, `${separator}${header}${linesToAppend.join('\n')}\n`);
+    }
+    return { file: filename, added, skipped };
+}
+// ---------------------------------------------------------------------------
+// Default dependency implementations (real spawn + real fetch)
+// ---------------------------------------------------------------------------
+function createDefaultDeps(scriptsDir) {
+    const runNode = (args, opts = {}) => new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)('node', args, {
+            cwd: opts.cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (c) => (stdout += c.toString()));
+        child.stderr.on('data', (c) => (stderr += c.toString()));
+        child.on('close', (code) => resolve({ code: code ?? 0, stdout, stderr }));
+        if (opts.input) {
+            child.stdin.write(opts.input);
+            child.stdin.end();
+        }
+    });
+    const runCmd = (cmd, args, opts = {}) => new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            cwd: opts.cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (c) => (stdout += c.toString()));
+        child.stderr.on('data', (c) => (stderr += c.toString()));
+        child.on('close', (code) => resolve({ code: code ?? 0, stdout, stderr }));
+        child.on('error', (err) => resolve({ code: 1, stdout, stderr: String(err) }));
+    });
+    const fetchJson = async (url, body) => {
+        try {
+            // Node 18+ has global fetch
+            const res = await globalThis.fetch(url, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(body),
+            });
+            return { ok: !!res.ok, status: res.status };
+        }
+        catch {
+            return { ok: false, status: 0 };
+        }
+    };
+    const verify = async (params) => {
+        const verifierScript = path.join(params.scriptsDir, 'gurulu-verify-install.mjs');
+        const args = [
+            verifierScript,
+            params.repoRoot,
+            '--framework',
+            params.framework,
+            '--site-id',
+            params.siteId,
+            '--tenant-id',
+            params.tenantId,
+            '--ingest-url',
+            params.ingestUrl,
+        ];
+        const res = await runNode(args);
+        // Parse the final VERIFY_RESULT <json> line if present.
+        const lines = (res.stdout || '').trim().split('\n');
+        let parsed = { ok: res.code === 0, reason: null };
+        for (let i = lines.length - 1; i >= 0; i--) {
+            const line = lines[i];
+            if (line.startsWith('VERIFY_RESULT ')) {
+                try {
+                    parsed = JSON.parse(line.slice('VERIFY_RESULT '.length));
+                }
+                catch {
+                    // fall through
+                }
+                break;
+            }
+        }
+        if (res.code !== 0 && parsed.ok)
+            parsed.ok = false;
+        return parsed;
+    };
+    return {
+        runNode,
+        runCmd,
+        fetchJson,
+        prompt: ui_1.prompt,
+        verify,
+        log: { info: ui_1.info, warn: ui_1.warn, error: ui_1.error, step: ui_1.step, success: ui_1.success },
+    };
+}
+// ---------------------------------------------------------------------------
+// Orchestration
+// ---------------------------------------------------------------------------
+function log(deps, level, msg) {
+    const l = deps.log;
+    if (!l)
+        return;
+    l[level](msg);
+}
+async function runInstallFlow(args, deps, scriptsDir) {
+    const repoRoot = path.resolve(args.path || process.cwd());
+    const summary = {
+        scan: null,
+        framework: null,
+        planDiff: '',
+        filesChanged: 0,
+        packageManager: null,
+        packageInstalled: false,
+        envKeysWritten: [],
+        ingestOk: null,
+        dryRun: !!args.dryRun,
+        verify: null,
+        rolledBack: false,
+        errors: [],
+    };
+    if (!args.siteId) {
+        const msg = 'Missing --site-id. Provide --site-id or run without --yes to enter interactively.';
+        summary.errors.push(msg);
+        log(deps, 'error', msg);
+        return summary;
+    }
+    if (!args.tenantId) {
+        const msg = 'Missing --tenant-id. Provide --tenant-id or run without --yes to enter interactively.';
+        summary.errors.push(msg);
+        log(deps, 'error', msg);
+        return summary;
+    }
+    const scanScript = path.join(scriptsDir, 'gurulu-scan.mjs');
+    const agenticScript = path.join(scriptsDir, 'gurulu-agentic-install.mjs');
+    // ---- 1. Scan ---------------------------------------------------------
+    log(deps, 'step', `Scanning ${(0, ui_1.cyan)(repoRoot)}...`);
+    const scanRes = await deps.runNode([scanScript, repoRoot, '--quiet']);
+    if (scanRes.code !== 0) {
+        const msg = `Scan failed (exit ${scanRes.code}): ${scanRes.stderr.trim()}`;
+        summary.errors.push(msg);
+        log(deps, 'error', msg);
+        return summary;
+    }
+    try {
+        summary.scan = JSON.parse(scanRes.stdout);
+    }
+    catch (err) {
+        const msg = `Scan produced invalid JSON: ${err.message}`;
+        summary.errors.push(msg);
+        log(deps, 'error', msg);
+        return summary;
+    }
+    const detectedFw = args.framework || summary.scan.framework?.name || 'auto';
+    summary.framework = detectedFw;
+    log(deps, 'info', `Framework: ${(0, ui_1.bold)(detectedFw)} · ORM: ${summary.scan.orm?.name || 'none'} · Auth: ${summary.scan.auth?.name || 'none'} · Routes: ${summary.scan.routes?.length ?? 0}`);
+    // ---- 2. Confirm ------------------------------------------------------
+    if (!args.yes) {
+        const answer = await deps.prompt('  Continue with install? (Y/n): ');
+        if (answer && answer.toLowerCase().startsWith('n')) {
+            log(deps, 'info', 'Aborted by user.');
+            return summary;
+        }
+    }
+    // ---- 3. Agentic dry-run (plan / diff) --------------------------------
+    log(deps, 'step', 'Generating patch plan (dry-run)...');
+    const planArgs = [
+        agenticScript,
+        repoRoot,
+        '--dry-run',
+        '--site-id',
+        args.siteId,
+        '--tenant-id',
+        args.tenantId,
+    ];
+    if (args.framework) {
+        planArgs.push('--framework', args.framework);
+    }
+    // Phase 18.7 B — include auto-instrument diff in the dry-run plan so the
+    // consent prompt / preview shows both script-tag + track-call changes.
+    if (args.autoInstrument) {
+        planArgs.push('--auto-instrument');
+        if (args.autoProperties) {
+            planArgs.push('--auto-properties');
+        }
+        if (args.intentResultPath) {
+            planArgs.push('--intent-result', args.intentResultPath);
+        }
+    }
+    const planRes = await deps.runNode(planArgs);
+    summary.planDiff = planRes.stdout;
+    if (planRes.code !== 0) {
+        const msg = `Planner failed (exit ${planRes.code}): ${planRes.stderr.trim()}`;
+        summary.errors.push(msg);
+        log(deps, 'error', msg);
+        return summary;
+    }
+    if (planRes.stdout.trim()) {
+        log(deps, 'info', 'Proposed changes:');
+        for (const line of planRes.stdout.split('\n').slice(0, 40)) {
+            if (line)
+                log(deps, 'info', `    ${(0, ui_1.dim)(line)}`);
+        }
+    }
+    // crude file-count: `+++ b/<path>` lines in unified diff
+    summary.filesChanged = (planRes.stdout.match(/^\+\+\+ /gm) || []).length;
+    // ---- 4. Apply (skipped on --dry-run) ---------------------------------
+    if (!args.dryRun) {
+        log(deps, 'step', 'Applying patches...');
+        const applyArgs = [
+            agenticScript,
+            repoRoot,
+            '--apply',
+            '--site-id',
+            args.siteId,
+            '--tenant-id',
+            args.tenantId,
+        ];
+        if (args.framework) {
+            applyArgs.push('--framework', args.framework);
+        }
+        // Phase 18.7 B — forward auto-instrument flag + intent result path.
+        if (args.autoInstrument) {
+            applyArgs.push('--auto-instrument');
+            if (args.autoProperties) {
+                applyArgs.push('--auto-properties');
+            }
+            if (args.intentResultPath) {
+                applyArgs.push('--intent-result', args.intentResultPath);
+            }
+        }
+        const applyRes = await deps.runNode(applyArgs);
+        if (applyRes.code !== 0) {
+            const msg = `Apply failed (exit ${applyRes.code}): ${applyRes.stderr.trim()}`;
+            summary.errors.push(msg);
+            log(deps, 'error', msg);
+            return summary;
+        }
+        // Parse the machine-readable auto-instrument result line if present.
+        if (args.autoInstrument) {
+            const lines = (applyRes.stdout || '').split('\n');
+            for (let i = lines.length - 1; i >= 0; i--) {
+                if (lines[i].startsWith('AUTO_INSTRUMENT_RESULT ')) {
+                    try {
+                        const parsed = JSON.parse(lines[i].slice('AUTO_INSTRUMENT_RESULT '.length));
+                        summary.instrumentation = {
+                            enabled: true,
+                            filesModified: parsed.filesModified || 0,
+                            eventsInstrumented: parsed.eventsInstrumented || 0,
+                            eventsSkipped: parsed.eventsSkipped || 0,
+                            notes: parsed.notes || [],
+                        };
+                    }
+                    catch {
+                        // fall through — telemetry will show enabled:true with zeros.
+                    }
+                    break;
+                }
+            }
+            if (!summary.instrumentation) {
+                summary.instrumentation = {
+                    enabled: true,
+                    filesModified: 0,
+                    eventsInstrumented: 0,
+                    eventsSkipped: 0,
+                };
+            }
+        }
+        log(deps, 'success', 'Patches applied.');
+    }
+    else {
+        log(deps, 'info', 'Dry-run: skipping apply, npm install, env merge, and ingest test.');
+    }
+    // ---- 5. npm install --------------------------------------------------
+    const pm = detectPackageManager(repoRoot);
+    summary.packageManager = pm;
+    if (args.skipNpm || args.dryRun) {
+        log(deps, 'info', `Skipping package install (${pm} add @gurulu/tracker-web)`);
+    }
+    else {
+        log(deps, 'step', `Installing @gurulu/tracker-web with ${(0, ui_1.bold)(pm)}...`);
+        const pmRes = await deps.runCmd(pm, packageInstallArgs(pm), { cwd: repoRoot });
+        if (pmRes.code !== 0) {
+            const msg = `${pm} install failed (exit ${pmRes.code}): ${pmRes.stderr.trim()}`;
+            summary.errors.push(msg);
+            log(deps, 'warn', msg);
+        }
+        else {
+            summary.packageInstalled = true;
+            log(deps, 'success', '@gurulu/tracker-web installed.');
+        }
+    }
+    // ---- 6. .env merge ---------------------------------------------------
+    const ingestUrl = args.ingestUrl || process.env.GURULU_INGEST_URL || 'https://api.gurulu.io';
+    const envVars = {
+        NEXT_PUBLIC_GURULU_SITE_ID: args.siteId,
+        NEXT_PUBLIC_GURULU_TENANT_ID: args.tenantId,
+        NEXT_PUBLIC_GURULU_INGEST_URL: ingestUrl,
+    };
+    if (args.skipEnv || args.dryRun) {
+        log(deps, 'info', 'Skipping .env merge.');
+    }
+    else {
+        const mergeRes = mergeEnvFile(repoRoot, detectedFw, envVars);
+        summary.envKeysWritten = mergeRes.added;
+        if (mergeRes.added.length > 0) {
+            log(deps, 'success', `Wrote ${mergeRes.added.length} key(s) to ${mergeRes.file}`);
+        }
+        if (mergeRes.skipped.length > 0) {
+            log(deps, 'warn', `Skipped existing key(s): ${mergeRes.skipped.join(', ')}`);
+        }
+    }
+    // ---- 7. Ingest ping --------------------------------------------------
+    if (!args.dryRun) {
+        const pingUrl = `${ingestUrl.replace(/\/$/, '')}/api/ingest/v1/health`;
+        log(deps, 'step', `Pinging ingest (${pingUrl})...`);
+        const pingRes = await deps.fetchJson(pingUrl, {
+            siteId: args.siteId,
+            tenantId: args.tenantId,
+            source: 'gurulu-cli-install',
+        });
+        summary.ingestOk = pingRes.ok;
+        if (pingRes.ok) {
+            log(deps, 'success', `Ingest reachable (status ${pingRes.status}).`);
+        }
+        else {
+            log(deps, 'warn', `Ingest ping failed (status ${pingRes.status}). Verify GURULU_INGEST_URL.`);
+        }
+    }
+    // ---- 8. Live smoke verify (Phase 16 A3) ------------------------------
+    if (args.verify && !args.dryRun) {
+        if (!deps.verify) {
+            log(deps, 'warn', 'Verify flag set but no verifier dep configured; skipping.');
+        }
+        else {
+            log(deps, 'step', 'Running live smoke verification...');
+            try {
+                const verifyRes = await deps.verify({
+                    repoRoot,
+                    framework: detectedFw,
+                    siteId: args.siteId,
+                    tenantId: args.tenantId,
+                    ingestUrl,
+                    scriptsDir,
+                });
+                summary.verify = verifyRes;
+                if (verifyRes.ok) {
+                    log(deps, 'success', 'Install verified: $page_view captured.');
+                }
+                else {
+                    const reason = verifyRes.reason || 'unknown';
+                    const msg = `Verification failed: ${reason}. Rolling back patches...`;
+                    summary.errors.push(msg);
+                    log(deps, 'error', msg);
+                    // Auto-rollback
+                    const rollbackArgs = [agenticScript, repoRoot, '--rollback'];
+                    const rbRes = await deps.runNode(rollbackArgs);
+                    if (rbRes.code === 0) {
+                        summary.rolledBack = true;
+                        log(deps, 'warn', 'Patches rolled back.');
+                    }
+                    else {
+                        log(deps, 'error', `Rollback failed (exit ${rbRes.code}): ${rbRes.stderr.trim()}`);
+                    }
+                }
+            }
+            catch (err) {
+                const msg = `Verify threw: ${err.message}`;
+                summary.errors.push(msg);
+                log(deps, 'error', msg);
+            }
+        }
+    }
+    // ---- Final summary ---------------------------------------------------
+    log(deps, 'info', '');
+    log(deps, 'info', (0, ui_1.bold)('  Install summary'));
+    log(deps, 'step', `Framework: ${summary.framework}`);
+    log(deps, 'step', `Files changed: ${summary.filesChanged}`);
+    log(deps, 'step', `Package manager: ${summary.packageManager}`);
+    log(deps, 'step', `Package installed: ${summary.packageInstalled ? 'yes' : 'no'}`);
+    log(deps, 'step', `.env keys written: ${summary.envKeysWritten.join(', ') || 'none'}`);
+    log(deps, 'step', `Ingest test: ${summary.ingestOk === null ? 'skipped' : summary.ingestOk ? 'ok' : 'failed'}`);
+    if (summary.verify) {
+        log(deps, 'step', `Live verify: ${summary.verify.ok ? 'verified' : `failed (${summary.verify.reason || 'unknown'})`}`);
+        if (summary.rolledBack) {
+            log(deps, 'step', 'Patches: rolled back');
+        }
+    }
+    if (summary.instrumentation && summary.instrumentation.enabled) {
+        log(deps, 'step', `Auto-instrument: ${summary.instrumentation.filesModified} file(s), ` +
+            `${summary.instrumentation.eventsInstrumented} event(s), ` +
+            `${summary.instrumentation.eventsSkipped} skipped`);
+    }
+    log(deps, 'info', '');
+    return summary;
+}
+function repoHashOf(repoRoot, remoteUrl = null) {
+    const h = crypto.createHash('sha256');
+    h.update(path.resolve(repoRoot));
+    if (remoteUrl)
+        h.update('\n' + remoteUrl);
+    return h.digest('hex');
+}
+function pickSite(sites, target) {
+    if (!target)
+        return sites.length === 1 ? sites[0] : null;
+    return (sites.find((s) => s.id === target) ||
+        sites.find((s) => s.name === target) ||
+        sites.find((s) => s.id.startsWith(target)) ||
+        null);
+}
+/** Send a telemetry POST. Never throws — quota errors are surfaced via `ok`. */
+async function emitInstallTelemetry(deps, payload) {
+    try {
+        const res = await deps.postVerify({
+            source: 'cli',
+            ...payload,
+        });
+        if (res.status === 402)
+            return { ok: false, quotaExceeded: true };
+        return { ok: !!res.ok, quotaExceeded: false };
+    }
+    catch {
+        return { ok: false, quotaExceeded: false };
+    }
+}
+async function runAuthenticatedInstallFlow(args, authDeps, installDeps, scriptsDir) {
+    // Site selection
+    let selected = pickSite(authDeps.sites, args.site);
+    if (!selected) {
+        if (authDeps.sites.length === 0) {
+            const msg = 'No sites found. Run `gurulu sites create --domain ...` first.';
+            installDeps.log?.error(msg);
+            return {
+                scan: null,
+                framework: null,
+                planDiff: '',
+                filesChanged: 0,
+                packageManager: null,
+                packageInstalled: false,
+                envKeysWritten: [],
+                ingestOk: null,
+                dryRun: !!args.dryRun,
+                verify: null,
+                rolledBack: false,
+                errors: [msg],
+            };
+        }
+        if (args.yes) {
+            // Non-interactive, multiple sites: pick the first.
+            selected = authDeps.sites[0];
+        }
+        else if (authDeps.promptSelect) {
+            const labels = authDeps.sites.map((s) => `${s.name || s.id} (${s.domain})`);
+            const idx = await authDeps.promptSelect('  Select site: ', labels);
+            selected = authDeps.sites[idx] || authDeps.sites[0];
+        }
+        else {
+            selected = authDeps.sites[0];
+        }
+    }
+    const filled = {
+        ...args,
+        siteId: selected.id,
+        tenantId: authDeps.tenantId,
+    };
+    // ---- Phase 18.6 — Intent discovery (pre-scan pass) ------------------
+    // Runs BEFORE the core flow so the user sees the proposal first. We use
+    // the scanner in --quiet mode, feed signals to the injected analyzer,
+    // and render a proposal. On --skip-intent or missing deps we fall
+    // straight through to the Phase 18.5 authenticated flow.
+    const intentRecord = {
+        skipped: !!args.skipIntent,
+        dryRun: !!args.intentDryRun,
+        analyzed: false,
+        preSeeded: false,
+    };
+    if (!args.skipIntent && authDeps.intent) {
+        const repoRoot = path.resolve(args.path || process.cwd());
+        const scanScript = path.join(scriptsDir, 'gurulu-scan.mjs');
+        installDeps.log?.step('Scanning for install-time intent signals...');
+        const scanRes = await installDeps.runNode([scanScript, repoRoot, '--quiet']);
+        if (scanRes.code !== 0) {
+            installDeps.log?.warn(`Intent scan failed (exit ${scanRes.code}); skipping intent discovery.`);
+            intentRecord.error = `scan_failed:${scanRes.code}`;
+        }
+        else {
+            let signals = null;
+            try {
+                signals = JSON.parse(scanRes.stdout);
+            }
+            catch (err) {
+                installDeps.log?.warn(`Intent scan produced invalid JSON: ${err.message}; skipping.`);
+                intentRecord.error = 'scan_invalid_json';
+            }
+            if (signals) {
+                let intent = null;
+                try {
+                    intent = await authDeps.intent.analyze(signals);
+                    intentRecord.analyzed = true;
+                    intentRecord.vertical = intent.vertical;
+                }
+                catch (err) {
+                    installDeps.log?.warn(`Intent analyzer failed: ${err.message}`);
+                    intentRecord.error = `analyze_failed:${err.message}`;
+                }
+                if (intent) {
+                    const io = authDeps.intent.io || {
+                        print: (l) => console.log(l),
+                        prompt: installDeps.prompt,
+                        isPiped: !process.stdout.isTTY,
+                    };
+                    const nonInteractive = !!args.yes || io.isPiped || !!args.intentDryRun;
+                    const decision = await (0, install_intent_proposal_1.runProposal)({ intent, io, nonInteractive });
+                    intentRecord.accepted = {
+                        events: decision.accepted.events.length,
+                        funnels: decision.accepted.funnels.length,
+                    };
+                    // Phase 18.7 B — stash the raw ProposedEvent list for the
+                    // auto-instrument bridge below. Not part of the persisted summary
+                    // shape — marked with an underscore so TypeScript narrowing sees
+                    // the public `accepted` counts only.
+                    intentRecord._acceptedEvents = decision.accepted.events;
+                    if (decision.quit) {
+                        installDeps.log?.info('Intent proposal dismissed by user.');
+                    }
+                    else if (args.intentDryRun) {
+                        installDeps.log?.info(`Intent dry-run: would pre-seed ${decision.accepted.events.length} events and ${decision.accepted.funnels.length} funnels.`);
+                    }
+                    else if (decision.accepted.events.length === 0 && decision.accepted.funnels.length === 0) {
+                        installDeps.log?.info('No events or funnels accepted; skipping pre-seed.');
+                    }
+                    else {
+                        const res = await authDeps.intent.preSeed({
+                            siteId: selected.id,
+                            intent,
+                            accepted: decision.accepted,
+                            rejected: decision.rejected,
+                        });
+                        if (res.quotaExceeded) {
+                            const msg = 'Install quota exceeded during pre-seed. Upgrade at https://gurulu.io/settings/billing';
+                            installDeps.log?.error(msg);
+                            intentRecord.error = 'quota_exceeded';
+                        }
+                        else if (!res.ok) {
+                            installDeps.log?.warn(`Pre-seed failed: ${res.error || 'unknown error'}`);
+                            intentRecord.error = res.error || 'pre_seed_failed';
+                        }
+                        else {
+                            intentRecord.preSeeded = true;
+                            intentRecord.proposalId = res.proposalId;
+                            intentRecord.created = res.created;
+                            installDeps.log?.success(`Pre-seeded ${res.created?.goals || 0} goals, ${res.created?.funnels || 0} funnels, ${res.created?.milestones || 0} milestones.`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else if (args.skipIntent) {
+        installDeps.log?.info('Intent discovery skipped (--skip-intent).');
+    }
+    // ---- Phase 18.7 B — Auto-instrumentation consent + intent-result file
+    // When --auto-instrument is set AND an intent with accepted events exists,
+    // serialize the decision to a tmp file so the agentic-install script can
+    // read it during --apply. We also show a prominent consent prompt listing
+    // the route files that will be touched (skippable with --yes).
+    let autoInstrumentEnabled = !!args.autoInstrument;
+    let intentResultPath;
+    if (autoInstrumentEnabled) {
+        if (!intentRecord.analyzed || !intentRecord.accepted || intentRecord.accepted.events === 0) {
+            installDeps.log?.warn('Auto-instrument requested but no accepted events from intent discovery; disabling.');
+            autoInstrumentEnabled = false;
+        }
+        else {
+            // Persist an `{ accepted: { events } }` envelope matching the
+            // agentic-install script's reader shape. We resolve the raw ProposedEvent
+            // list from the proposal IO if available — otherwise we fall back to
+            // writing an empty envelope and rely on scan-driven route detection.
+            const tmpDir = process.env.TMPDIR || '/tmp';
+            const uuid = crypto.randomBytes(8).toString('hex');
+            intentResultPath = path.join(tmpDir, `gurulu-intent-${uuid}.json`);
+            try {
+                fs.writeFileSync(intentResultPath, JSON.stringify({
+                    accepted: {
+                        events: intentRecord._acceptedEvents || [],
+                    },
+                }, null, 2), 'utf8');
+            }
+            catch (err) {
+                installDeps.log?.warn(`Failed to persist intent result: ${err.message}; disabling auto-instrument.`);
+                autoInstrumentEnabled = false;
+                intentResultPath = undefined;
+            }
+            // Consent prompt — unless --yes or --dry-run.
+            if (autoInstrumentEnabled && !args.yes && !args.dryRun) {
+                installDeps.log?.warn(`Auto-instrumentation will modify ${intentRecord.accepted.events} route file(s) to insert gurulu.track() calls.`);
+                installDeps.log?.info('  Changes are backed up to .gurulu-backup/ and can be rolled back with `gurulu install --rollback`.');
+                const answer = await installDeps.prompt('  Proceed with auto-instrumentation? [y/N]: ');
+                if (!answer || !/^y/i.test(answer.trim())) {
+                    installDeps.log?.info('Auto-instrumentation declined.');
+                    autoInstrumentEnabled = false;
+                    intentResultPath = undefined;
+                }
+            }
+        }
+    }
+    const runArgs = {
+        ...filled,
+        autoInstrument: autoInstrumentEnabled,
+        intentResultPath,
+    };
+    // Run the core flow.
+    const summary = await runInstallFlow(runArgs, installDeps, scriptsDir);
+    summary.intent = intentRecord;
+    if (autoInstrumentEnabled && !summary.instrumentation) {
+        summary.instrumentation = {
+            enabled: true,
+            filesModified: 0,
+            eventsInstrumented: 0,
+            eventsSkipped: 0,
+        };
+    }
+    // Telemetry after each terminal state.
+    const cliVersion = (() => {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            return require('../../package.json').version || '0.0.0';
+        }
+        catch {
+            return '0.0.0';
+        }
+    })();
+    const rh = repoHashOf(path.resolve(args.path || process.cwd()));
+    const fw = summary.framework || 'unknown';
+    if (args.dryRun) {
+        await emitInstallTelemetry(authDeps, {
+            siteId: selected.id,
+            status: 'dry-run',
+            framework: fw,
+            cliVersion,
+            repoHash: rh,
+        });
+    }
+    else if (summary.errors.length > 0) {
+        await emitInstallTelemetry(authDeps, {
+            siteId: selected.id,
+            status: 'failed',
+            framework: fw,
+            cliVersion,
+            repoHash: rh,
+            errorMessage: summary.errors[0] || null,
+        });
+    }
+    else {
+        const telemetry = await emitInstallTelemetry(authDeps, {
+            siteId: selected.id,
+            status: summary.verify?.ok ? 'verified' : 'applied',
+            framework: fw,
+            cliVersion,
+            repoHash: rh,
+            ...(summary.instrumentation
+                ? {
+                    instrumentation: {
+                        filesModified: summary.instrumentation.filesModified,
+                        eventsInstrumented: summary.instrumentation.eventsInstrumented,
+                        eventsSkipped: summary.instrumentation.eventsSkipped,
+                    },
+                }
+                : {}),
+        });
+        if (telemetry.quotaExceeded) {
+            const msg = 'Install quota exceeded for the current plan. Upgrade at https://gurulu.io/settings/billing';
+            installDeps.log?.error(msg);
+            summary.errors.push(msg);
+        }
+        if (summary.rolledBack) {
+            await emitInstallTelemetry(authDeps, {
+                siteId: selected.id,
+                status: 'rolled-back',
+                framework: fw,
+                cliVersion,
+                repoHash: rh,
+            });
+        }
+    }
+    return summary;
+}
+async function installCommand(args) {
+    const scriptsDir = resolveScriptsDir();
+    const deps = createDefaultDeps(scriptsDir);
+    // Legacy unauthenticated path: --site-id passed explicitly and no active profile.
+    const profile = await (0, config_1.getActiveProfile)({ profile: args.profile });
+    const legacyMode = !!args.siteId && !profile;
+    if (legacyMode) {
+        (0, ui_1.warn)('Legacy unauthenticated install. Run `gurulu login` for the full experience.');
+        let siteId = args.siteId || process.env.GURULU_SITE_ID;
+        let tenantId = args.tenantId || process.env.GURULU_TENANT_ID;
+        if (!args.yes) {
+            if (!siteId)
+                siteId = await deps.prompt('  Site ID: ');
+            if (!tenantId)
+                tenantId = await deps.prompt('  Tenant ID: ');
+        }
+        const filled = { ...args, siteId, tenantId };
+        const summary = await runInstallFlow(filled, deps, scriptsDir);
+        if (summary.errors.length > 0)
+            process.exit(1);
+        return;
+    }
+    if (!profile) {
+        (0, ui_1.error)('Not logged in. Run `gurulu login` first, or provide --site-id for legacy mode.');
+        process.exit(1);
+    }
+    // Authenticated: fetch /me, pick site, run flow, emit telemetry.
+    let me;
+    try {
+        const res = await (0, api_client_1.cliApi)('/api/cli/me', { preloadedProfile: profile });
+        me = await res.json();
+    }
+    catch (err) {
+        (0, ui_1.error)(`Failed to load account: ${err.message}`);
+        process.exit(1);
+    }
+    const sites = (me.sites || []).map((s) => ({
+        id: s.id,
+        name: s.name,
+        domain: s.domain,
+        publishableKey: s.publishableKey,
+    }));
+    const authDeps = {
+        profile,
+        sites,
+        tenantId: me.tenant?.id || '',
+        postVerify: async (body) => {
+            const res = await (0, api_client_1.cliApi)('/api/cli/install/verify', {
+                method: 'POST',
+                preloadedProfile: profile,
+                body: JSON.stringify(body),
+                noExitOnError: true,
+            });
+            return { ok: res.ok, status: res.status };
+        },
+        intent: {
+            analyze: async (signals) => {
+                const res = await (0, api_client_1.cliApi)('/api/cli/install/analyze-intent', {
+                    method: 'POST',
+                    preloadedProfile: profile,
+                    body: JSON.stringify({ signals }),
+                    noExitOnError: true,
+                });
+                const text = await res.text();
+                const parsed = text ? JSON.parse(text) : {};
+                if (!res.ok) {
+                    throw new Error((parsed && parsed.message) || `HTTP ${res.status}`);
+                }
+                return parsed.intent;
+            },
+            preSeed: async (body) => {
+                const res = await (0, api_client_1.cliApi)('/api/cli/install/pre-seed', {
+                    method: 'POST',
+                    preloadedProfile: profile,
+                    body: JSON.stringify(body),
+                    noExitOnError: true,
+                });
+                if (res.status === 402 || res.status === 429) {
+                    return { ok: false, quotaExceeded: true };
+                }
+                const text = await res.text();
+                const parsed = text ? JSON.parse(text) : {};
+                if (!res.ok) {
+                    return { ok: false, error: (parsed && parsed.message) || `HTTP ${res.status}` };
+                }
+                return {
+                    ok: true,
+                    proposalId: parsed.proposalId,
+                    created: parsed.created,
+                    skipped: parsed.skipped,
+                };
+            },
+        },
+    };
+    const summary = await runAuthenticatedInstallFlow(args, authDeps, deps, scriptsDir);
+    if (summary.errors.length > 0)
+        process.exit(1);
+}