lua-cli 3.12.2 → 3.14.0

package/dist/commands/status.js

@@ -0,0 +1,731 @@
+/**
+ * Status Command
+ *
+ * Unified state dump of the lua-cli + project + server.
+ * Print (or emit as JSON) the full state across all "doctor" sections:
+ * environment, install method, updates, auth, project, per-primitive sync,
+ * persona, backup, telemetry, and derived next-step hints.
+ *
+ * Aliases: lua describe.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { performance } from 'perf_hooks';
+import * as os from 'os';
+import { withErrorHandling } from '../utils/cli.js';
+import { hintsDisabled } from '../utils/hints.js';
+import { trackEvent } from '../services/analytics.js';
+import { loadApiKey } from '../services/auth.js';
+import AuthApi from '../api/auth.api.service.js';
+import { readYamlConfig } from '../utils/files.js';
+import { loadManifest, getAgentName } from '../utils/artifact-loader.js';
+import { syncableHandlers, isVersionedHandler } from '../primitives/index.js';
+import { compareVersions, parseVersion } from '../utils/semver.js';
+import { isUpdateAvailable, getCachedVersionCheck } from '../utils/version-check.js';
+import { checkPersonaDrift } from '../utils/sync-fetch.js';
+import { getCurrentProjectHash, isBackupOutOfSync } from '../utils/backup-helpers.js';
+import { BASE_URLS, CLI_CONFIG_DIR, TELEMETRY_FILE } from '../config/constants.js';
+import { COMPILE_FILES } from '../config/compile.constants.js';
+import { PrimitiveKind } from '../compiler/types.js';
+// =============================================================================
+// HELPERS
+// =============================================================================
+function getCliVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const pkg = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf8'));
+        return pkg.version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+function detectInstallMethod(execPath) {
+    if (execPath.includes('/.volta/'))
+        return 'volta';
+    if (execPath.includes('/.nvm/versions/')) {
+        const nodeMajor = process.version.split('.')[0].replace('v', '');
+        return `nvm-${nodeMajor}`;
+    }
+    if (execPath.includes('/.fnm/'))
+        return 'fnm';
+    if (execPath.includes('/pnpm/global/'))
+        return 'pnpm-global';
+    if (execPath.includes('/.bun/install/'))
+        return 'bun-install';
+    if (execPath.startsWith('/usr/local/') || execPath.startsWith('/opt/homebrew/')) {
+        return 'homebrew-or-npm-global';
+    }
+    if (execPath.includes('/node_modules/.bin'))
+        return 'project-local';
+    return 'unknown';
+}
+function detectChannel(currentVersion) {
+    const { preRelease } = parseVersion(currentVersion);
+    if (!preRelease)
+        return 'latest';
+    const tag = preRelease.split('.')[0].replace(/[0-9]/g, '');
+    return tag || 'latest';
+}
+function formatRelativeTime(checkedAtMs) {
+    if (!checkedAtMs)
+        return null;
+    return new Date(checkedAtMs).toISOString();
+}
+// =============================================================================
+// SECTION GATHERERS
+// =============================================================================
+function gatherEnvironment(currentVersion) {
+    return {
+        cliVersion: currentVersion,
+        channel: detectChannel(currentVersion),
+        nodeVersion: process.version,
+        platform: os.platform(),
+        arch: os.arch(),
+        osRelease: os.release(),
+        installMethod: detectInstallMethod(process.execPath),
+        execPath: process.execPath,
+        configDir: CLI_CONFIG_DIR,
+        apiBase: BASE_URLS.API,
+        authBase: BASE_URLS.AUTH,
+        envOverrides: {
+            LUA_API_URL: process.env.LUA_API_URL ?? null,
+            LUA_AUTH_URL: process.env.LUA_AUTH_URL ?? null,
+            LUA_API_KEY: process.env.LUA_API_KEY ? 'set' : 'not set',
+            LUA_TELEMETRY: process.env.LUA_TELEMETRY ?? null,
+            LUA_NO_HINTS: process.env.LUA_NO_HINTS ?? null,
+        },
+    };
+}
+async function gatherUpdates(currentVersion) {
+    const preFetchCache = getCachedVersionCheck();
+    try {
+        const result = await isUpdateAvailable(currentVersion);
+        const postFetchCache = getCachedVersionCheck();
+        return {
+            current: currentVersion,
+            latest: result.latest,
+            available: result.available,
+            lastCheckedAt: postFetchCache ? formatRelativeTime(postFetchCache.checkedAt) : null,
+            fromCache: !!preFetchCache,
+        };
+    }
+    catch {
+        const postFetchCache = getCachedVersionCheck();
+        return {
+            current: currentVersion,
+            latest: postFetchCache?.latestVersion ?? null,
+            available: false,
+            lastCheckedAt: postFetchCache ? formatRelativeTime(postFetchCache.checkedAt) : null,
+            fromCache: !!preFetchCache,
+        };
+    }
+}
+async function gatherAuth() {
+    let apiKey = null;
+    try {
+        apiKey = loadApiKey();
+    }
+    catch {
+        apiKey = null;
+    }
+    if (!apiKey) {
+        let serverReachable = null;
+        let reachabilityMs = null;
+        try {
+            const start = performance.now();
+            const response = await fetch(BASE_URLS.API, {
+                method: 'HEAD',
+                signal: AbortSignal.timeout(3000),
+            });
+            reachabilityMs = Math.round(performance.now() - start);
+            serverReachable = response.ok || (response.status >= 200 && response.status < 500);
+        }
+        catch {
+            serverReachable = false;
+            reachabilityMs = null;
+        }
+        return {
+            authenticated: false,
+            source: null,
+            email: null,
+            userId: null,
+            organizations: [],
+            serverReachable,
+            reachabilityMs,
+        };
+    }
+    const source = process.env.LUA_API_KEY ? 'env' : 'credentials file';
+    let email = null;
+    let userId = null;
+    let organizations = [];
+    let serverReachable = null;
+    let reachabilityMs = null;
+    let keyAccepted = false;
+    try {
+        const authApi = new AuthApi(BASE_URLS.API);
+        const start = performance.now();
+        const result = await authApi.checkApiKey(apiKey);
+        reachabilityMs = Math.round(performance.now() - start);
+        serverReachable = true; // got a network response (key may still be rejected)
+        if (result.success && result.data) {
+            keyAccepted = true;
+            email = result.data.email ?? null;
+            userId = result.data.uid ?? null;
+            const orgs = result.data.admin?.orgs ?? [];
+            organizations = orgs.map((o) => ({
+                id: o.id ?? o.orgId ?? '',
+                name: o.registeredName ?? o.name ?? '',
+            }));
+        }
+    }
+    catch {
+        serverReachable = false; // network error — couldn't reach the server
+    }
+    return {
+        authenticated: keyAccepted,
+        source,
+        email,
+        userId,
+        organizations,
+        serverReachable,
+        reachabilityMs,
+    };
+}
+function gatherProject(config) {
+    if (!config) {
+        return {
+            inProject: false,
+            rootDir: null,
+            configPath: null,
+            agentId: null,
+            agentName: null,
+            manifest: { found: false, primitiveCount: 0 },
+        };
+    }
+    const rootDir = process.cwd();
+    const configPath = join(rootDir, COMPILE_FILES.LUA_SKILL_YAML);
+    const agentId = config.agent?.agentId != null ? String(config.agent.agentId) : null;
+    let agentName = null;
+    let manifestFound = false;
+    let primitiveCount = 0;
+    try {
+        agentName = getAgentName() ?? null;
+    }
+    catch {
+        agentName = null;
+    }
+    try {
+        const manifest = loadManifest();
+        manifestFound = true;
+        primitiveCount = manifest.primitives.filter((p) => p.kind !== PrimitiveKind.AGENT).length;
+    }
+    catch {
+        manifestFound = false;
+    }
+    return {
+        inProject: true,
+        rootDir,
+        configPath,
+        agentId,
+        agentName,
+        manifest: { found: manifestFound, primitiveCount },
+    };
+}
+async function gatherPrimitives(input, warnings) {
+    const { apiKey, agentId, config } = input;
+    if (!config)
+        return [];
+    const sections = [];
+    // Local items per handler (sync — read from yaml)
+    const localPerHandler = new Map();
+    for (const handler of syncableHandlers) {
+        const yamlItems = handler.getFromYaml(config);
+        const items = yamlItems.map((item) => ({
+            name: item.name,
+            version: item.version || '',
+            entityId: item[handler.yamlConfig.idField] ?? '',
+        }));
+        localPerHandler.set(handler, items);
+    }
+    // Fetch server state per handler in parallel — Promise.allSettled to isolate failures.
+    const serverPerHandler = new Map();
+    if (apiKey && agentId) {
+        const fetchResults = await Promise.allSettled(syncableHandlers.map((handler) => handler.fetchServerState(apiKey, agentId)));
+        syncableHandlers.forEach((handler, i) => {
+            const result = fetchResults[i];
+            if (result.status === 'fulfilled') {
+                if (result.value.fetchError) {
+                    warnings.push(`Failed to fetch server state for ${handler.displayNamePlural}: ${result.value.fetchError}`);
+                    serverPerHandler.set(handler, null);
+                }
+                else {
+                    serverPerHandler.set(handler, result.value.serverItems ?? []);
+                }
+            }
+            else {
+                warnings.push(`Failed to fetch server state for ${handler.displayNamePlural}: ${result.reason?.message ?? 'unknown error'}`);
+                serverPerHandler.set(handler, null);
+            }
+        });
+    }
+    for (const handler of syncableHandlers) {
+        const local = localPerHandler.get(handler) ?? [];
+        const serverItems = serverPerHandler.get(handler) ?? null;
+        const versioned = isVersionedHandler(handler);
+        const server = (serverItems ?? []).map((s) => ({
+            name: s.name,
+            activeVersion: versioned ? handler.getActiveVersion(s) : null,
+            active: handler.isActive?.(s) ?? true,
+        }));
+        const serverByName = new Map();
+        for (const s of serverItems ?? []) {
+            serverByName.set(s.name, s);
+        }
+        const diffs = [];
+        if (serverItems !== null) {
+            for (const item of local) {
+                const serverItem = serverByName.get(item.name);
+                const activeVersion = versioned && serverItem ? handler.getActiveVersion(serverItem) : null;
+                let status;
+                if (!versioned) {
+                    // Non-versioned (MCP servers): present on server = synced, absent = not deployed
+                    status = serverItem ? 'synced' : 'not deployed';
+                }
+                else if (!item.version || activeVersion === null) {
+                    status = 'not deployed';
+                }
+                else {
+                    const cmp = compareVersions(item.version, activeVersion);
+                    if (cmp > 0)
+                        status = 'ahead';
+                    else if (cmp < 0)
+                        status = 'behind';
+                    else
+                        status = 'synced';
+                }
+                diffs.push({
+                    name: item.name,
+                    localVersion: item.version,
+                    serverVersion: activeVersion,
+                    status,
+                });
+            }
+        }
+        const orphans = [];
+        if (serverItems !== null) {
+            const localNames = new Set(local.map((i) => i.name));
+            const isProcessor = handler.kind === PrimitiveKind.PREPROCESSOR || handler.kind === PrimitiveKind.POSTPROCESSOR;
+            for (const s of serverItems) {
+                if (localNames.has(s.name))
+                    continue;
+                if (!(handler.isActive?.(s) ?? true))
+                    continue;
+                if (!handler.shouldConsiderForOrphan(s))
+                    continue;
+                const flagName = `--${handler.displayName.toLowerCase().replace(/\s+/g, '-')}-name`;
+                // Some primitive types have no CLI delete command yet
+                const cleanupCommand = handler.kind !== PrimitiveKind.DEVICE_TRIGGER ? `${handler.deleteCommand} ${flagName} "${s.name}"` : '';
+                orphans.push({
+                    name: s.name,
+                    cleanupCommand,
+                    critical: isProcessor,
+                });
+            }
+        }
+        sections.push({
+            kind: handler.kind,
+            displayName: handler.displayNamePlural,
+            local,
+            server,
+            diffs,
+            orphans,
+        });
+    }
+    return sections;
+}
+async function gatherPersona(apiKey, agentId) {
+    if (!apiKey || !agentId)
+        return { status: 'unknown' };
+    try {
+        const drift = await checkPersonaDrift(apiKey, agentId);
+        return { status: drift ? 'drift' : 'synced' };
+    }
+    catch {
+        return { status: 'unknown' };
+    }
+}
+function gatherBackup(config) {
+    if (!config)
+        return { status: 'unknown' };
+    let currentHash = null;
+    try {
+        currentHash = getCurrentProjectHash();
+    }
+    catch {
+        currentHash = null;
+    }
+    if (!currentHash)
+        return { status: 'never-compiled' };
+    try {
+        const out = isBackupOutOfSync(currentHash, config.backup);
+        return { status: out ? 'out-of-sync' : 'synced' };
+    }
+    catch {
+        return { status: 'unknown' };
+    }
+}
+function gatherTelemetry() {
+    const envVal = process.env.LUA_TELEMETRY;
+    const envOverride = envVal !== undefined;
+    let enabled = true;
+    if (envOverride) {
+        enabled = !['false', '0', 'off', 'no'].includes(envVal.toLowerCase());
+    }
+    else {
+        try {
+            if (existsSync(TELEMETRY_FILE)) {
+                const raw = readFileSync(TELEMETRY_FILE, 'utf8');
+                const cfg = JSON.parse(raw);
+                if (typeof cfg.enabled === 'boolean')
+                    enabled = cfg.enabled;
+            }
+        }
+        catch {
+            // default enabled = true
+        }
+    }
+    return { enabled, envOverride };
+}
+// =============================================================================
+// HINTS
+// =============================================================================
+function deriveHints(report) {
+    const hints = [];
+    if (report.updates.available && report.updates.latest) {
+        hints.push({
+            command: 'lua update',
+            reason: `Upgrade lua-cli (${report.updates.current} → ${report.updates.latest})`,
+        });
+    }
+    if (!report.auth.authenticated) {
+        hints.push({
+            command: 'lua auth configure',
+            reason: 'Authenticate for full server comparison',
+        });
+    }
+    for (const section of report.primitives) {
+        for (const orphan of section.orphans) {
+            if (!orphan.cleanupCommand)
+                continue;
+            hints.push({
+                command: orphan.cleanupCommand,
+                reason: orphan.critical
+                    ? `Remove orphan ${section.displayName} "${orphan.name}" (causes errors)`
+                    : `Remove orphan ${section.displayName} "${orphan.name}"`,
+            });
+        }
+    }
+    if (report.backup.status === 'out-of-sync') {
+        hints.push({
+            command: 'lua push backup',
+            reason: 'Sync source backup',
+        });
+    }
+    if (report.persona.status === 'drift') {
+        hints.push({
+            command: 'lua sync',
+            reason: 'Resolve persona drift',
+        });
+    }
+    return hints;
+}
+// =============================================================================
+// RENDERERS
+// =============================================================================
+function pad(s, n) {
+    return s.length >= n ? s : s + ' '.repeat(n - s.length);
+}
+function printJson(report) {
+    console.log(JSON.stringify(report));
+}
+function printHuman(report) {
+    const lines = [];
+    lines.push('');
+    lines.push('== lua status ==');
+    lines.push('');
+    // Environment
+    const env = report.environment;
+    lines.push('Environment');
+    lines.push(`  CLI version       ${env.cliVersion}  (channel: ${env.channel})`);
+    lines.push(`  Node              ${env.nodeVersion}`);
+    lines.push(`  OS                ${env.platform} ${env.osRelease} (${env.arch})`);
+    lines.push(`  Install method    ${env.installMethod}`);
+    lines.push(`  Exec path         ${env.execPath}`);
+    lines.push(`  Config dir        ${env.configDir}`);
+    lines.push(`  API base          ${env.apiBase}`);
+    lines.push(`  Auth base         ${env.authBase}`);
+    const overrides = env.envOverrides;
+    const overridesStr = [
+        `LUA_API_URL: ${overrides.LUA_API_URL ?? 'not set'}`,
+        `LUA_AUTH_URL: ${overrides.LUA_AUTH_URL ?? 'not set'}`,
+        `LUA_API_KEY: ${overrides.LUA_API_KEY}`,
+        `LUA_TELEMETRY: ${overrides.LUA_TELEMETRY ?? 'not set'}`,
+        `LUA_NO_HINTS: ${overrides.LUA_NO_HINTS ?? 'not set'}`,
+    ].join(', ');
+    lines.push(`  Env overrides     ${overridesStr}`);
+    lines.push('');
+    // Updates
+    const u = report.updates;
+    lines.push('Updates');
+    lines.push(`  Current           ${u.current}`);
+    lines.push(`  Latest published  ${u.latest ?? 'unknown'}`);
+    lines.push(`  Status            ${u.available ? 'update available — run `lua update`' : 'up to date'}`);
+    if (u.lastCheckedAt) {
+        lines.push(`  Last checked      ${u.lastCheckedAt}${u.fromCache ? ' (cache)' : ''}`);
+    }
+    lines.push('');
+    // Auth
+    const a = report.auth;
+    lines.push('Auth');
+    if (a.source) {
+        lines.push(`  Key source        ${a.source}`);
+        if (a.authenticated) {
+            lines.push(`  Email             ${a.email ?? 'unknown'}`);
+            lines.push(`  User ID           ${a.userId ?? 'unknown'}`);
+            if (a.organizations.length > 0) {
+                const orgNames = a.organizations
+                    .map((o) => o.name || o.id)
+                    .filter(Boolean)
+                    .join(', ');
+                lines.push(`  Organizations     ${a.organizations.length} (${orgNames})`);
+            }
+            else {
+                lines.push(`  Organizations     0`);
+            }
+            lines.push(`  Status            authenticated${a.reachabilityMs !== null ? ` (${a.reachabilityMs}ms)` : ''}`);
+        }
+        else if (a.serverReachable) {
+            lines.push(`  Status            key rejected by server${a.reachabilityMs !== null ? ` (${a.reachabilityMs}ms)` : ''}`);
+        }
+        else {
+            lines.push(`  Status            key found, server unreachable`);
+        }
+    }
+    else {
+        lines.push(`  Status            no API key configured — run \`lua auth configure\``);
+        if (a.serverReachable !== null) {
+            lines.push(`  Server            ${a.serverReachable ? 'reachable' : 'unreachable'}${a.reachabilityMs !== null ? ` (${a.reachabilityMs}ms)` : ''}`);
+        }
+    }
+    lines.push('');
+    // Project
+    const p = report.project;
+    lines.push('Project');
+    if (p.inProject) {
+        lines.push(`  Path              ${p.rootDir}`);
+        lines.push(`  Config            ${p.configPath} (found)`);
+        lines.push(`  Agent             ${p.agentName ?? 'unnamed'}${p.agentId ? ` (${p.agentId.substring(0, 8)})` : ''}`);
+        if (p.manifest.found) {
+            lines.push(`  Manifest          dist-v2/manifest.json (compiled, ${p.manifest.primitiveCount} primitives)`);
+        }
+        else {
+            lines.push(`  Manifest          (never compiled)`);
+        }
+    }
+    else {
+        lines.push(`  (not in a lua project)`);
+    }
+    lines.push('');
+    // Per-primitive sections
+    for (const section of report.primitives) {
+        const label = section.displayName.charAt(0).toUpperCase() + section.displayName.slice(1);
+        const localCount = section.local.length;
+        const serverCount = section.server.length;
+        lines.push(`${pad(label, 22)}${localCount} local  ${serverCount} server`);
+        if (localCount === 0 && section.orphans.length === 0) {
+            lines.push('  (none)');
+            lines.push('');
+            continue;
+        }
+        lines.push(`  ${pad('name', 22)}${pad('local', 10)}${pad('server', 10)}status`);
+        lines.push('');
+        for (const diff of section.diffs) {
+            const sv = diff.serverVersion ?? '--';
+            lines.push(`  ${pad(diff.name, 22)}${pad(diff.localVersion, 10)}${pad(sv, 10)}${diff.status}`);
+        }
+        for (const orphan of section.orphans) {
+            const serverEntry = section.server.find((s) => s.name === orphan.name);
+            const sv = serverEntry?.activeVersion ?? '--';
+            lines.push(`  ${pad(orphan.name, 22)}${pad('--', 10)}${pad(sv, 10)}server only${orphan.critical ? '  ⚠ causes errors' : ''}`);
+        }
+        lines.push('');
+    }
+    // Persona
+    const personaLabel = report.persona.status === 'synced'
+        ? '[synced]'
+        : report.persona.status === 'drift'
+            ? '[drift detected] Local differs from server'
+            : '[unknown]';
+    lines.push(`Persona     ${personaLabel}`);
+    // Backup
+    const backupLabel = report.backup.status === 'synced'
+        ? '[synced]'
+        : report.backup.status === 'out-of-sync'
+            ? '[out of sync] Source files changed since last push'
+            : report.backup.status === 'never-compiled'
+                ? '[never-compiled] Run `lua compile` first'
+                : '[unknown]';
+    lines.push(`Backup      ${backupLabel}`);
+    // Telemetry
+    lines.push(`Telemetry   ${report.telemetry.enabled ? 'enabled' : 'disabled'}${report.telemetry.envOverride ? ' (LUA_TELEMETRY override)' : ''}`);
+    lines.push('');
+    // Warnings
+    if (report.warnings.length > 0) {
+        lines.push('Warnings');
+        for (const w of report.warnings) {
+            lines.push(`  - ${w}`);
+        }
+        lines.push('');
+    }
+    // Next steps
+    if (report.hints.length > 0) {
+        lines.push('Next steps');
+        for (const h of report.hints) {
+            lines.push(`  - ${h.reason}: \`${h.command}\``);
+        }
+        lines.push('');
+    }
+    console.log(lines.join('\n'));
+}
+// =============================================================================
+// ENTRY POINT
+// =============================================================================
+export async function statusCommand(options) {
+    return withErrorHandling(async () => {
+        const warnings = [];
+        const currentVersion = getCliVersion();
+        const environment = gatherEnvironment(currentVersion);
+        // Gather concurrent sections via allSettled — each failure becomes a warning, never aborts.
+        const [updatesResult, authResult] = await Promise.allSettled([gatherUpdates(currentVersion), gatherAuth()]);
+        const updates = updatesResult.status === 'fulfilled'
+            ? updatesResult.value
+            : (() => {
+                warnings.push(`updates: ${updatesResult.reason?.message ?? 'unknown'}`);
+                return {
+                    current: currentVersion,
+                    latest: null,
+                    available: false,
+                    lastCheckedAt: null,
+                    fromCache: false,
+                };
+            })();
+        const auth = authResult.status === 'fulfilled'
+            ? authResult.value
+            : (() => {
+                warnings.push(`auth: ${authResult.reason?.message ?? 'unknown'}`);
+                return {
+                    authenticated: false,
+                    source: null,
+                    email: null,
+                    userId: null,
+                    organizations: [],
+                    serverReachable: null,
+                    reachabilityMs: null,
+                };
+            })();
+        let config = null;
+        try {
+            config = readYamlConfig();
+        }
+        catch (err) {
+            warnings.push(`config: ${err?.message ?? 'unknown'}`);
+        }
+        let project;
+        try {
+            project = gatherProject(config);
+        }
+        catch (err) {
+            warnings.push(`project: ${err?.message ?? 'unknown'}`);
+            project = {
+                inProject: false,
+                rootDir: null,
+                configPath: null,
+                agentId: null,
+                agentName: null,
+                manifest: { found: false, primitiveCount: 0 },
+            };
+        }
+        const apiKey = (() => {
+            try {
+                return loadApiKey();
+            }
+            catch {
+                return null;
+            }
+        })();
+        const [primitivesResult, personaResult] = await Promise.allSettled([
+            gatherPrimitives({ apiKey, agentId: project.agentId, config }, warnings),
+            gatherPersona(apiKey, project.agentId),
+        ]);
+        const primitives = primitivesResult.status === 'fulfilled'
+            ? primitivesResult.value
+            : (() => {
+                warnings.push(`primitives: ${primitivesResult.reason?.message ?? 'unknown'}`);
+                return [];
+            })();
+        const persona = personaResult.status === 'fulfilled'
+            ? personaResult.value
+            : (() => {
+                warnings.push(`persona: ${personaResult.reason?.message ?? 'unknown'}`);
+                return { status: 'unknown' };
+            })();
+        let backup;
+        try {
+            backup = gatherBackup(config);
+        }
+        catch (err) {
+            warnings.push(`backup: ${err?.message ?? 'unknown'}`);
+            backup = { status: 'unknown' };
+        }
+        let telemetry;
+        try {
+            telemetry = gatherTelemetry();
+        }
+        catch (err) {
+            warnings.push(`telemetry: ${err?.message ?? 'unknown'}`);
+            telemetry = { enabled: true, envOverride: false };
+        }
+        const reportNoHints = {
+            schemaVersion: 1,
+            command: 'status',
+            generatedAt: new Date().toISOString(),
+            environment,
+            updates,
+            auth,
+            project,
+            primitives,
+            persona,
+            backup,
+            telemetry,
+            warnings,
+        };
+        const hints = hintsDisabled() ? [] : deriveHints(reportNoHints);
+        const report = { ...reportNoHints, hints };
+        if (options.json) {
+            printJson(report);
+        }
+        else {
+            printHuman(report);
+        }
+        trackEvent('cli_status_completed', {
+            has_server: !!apiKey,
+            in_project: project.inProject,
+            json_mode: !!options.json,
+            sections_failed: warnings.length,
+        });
+    }, 'status');
+}
+//# sourceMappingURL=status.js.map