@contentful/experience-design-system-cli 2.24.0 → 2.24.1-dev-build-58e271c.0

package/README.md

@@ -451,6 +451,29 @@ Wizard run history is separate: `~/.config/experiences/runs.json`.
 
 ---
 
+## Usage data
+
+The CLI collects **anonymous usage data** to help us understand which commands are used and where the import workflow succeeds or fails. This data does **not** include your source code, file paths, credentials, prompts, or any content you author.
+
+What may be included:
+
+- Command name and duration
+- CLI, Node.js, and operating-system version
+- Anonymous session identifiers that link steps within a single import run
+- Structural counts (for example, how many components were extracted or accepted)
+- Space and environment IDs you pass on the command line
+- Contentful request IDs from API responses (to correlate failures with server logs)
+
+You can turn this off at any time:
+
+```bash
+DISABLE_ANALYTICS=1 experiences import --project ./my-app
+```
+
+Setting `DISABLE_ANALYTICS` to any value disables collection for that invocation.
+
+---
+
 ## Development
 
 ```bash

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.24.0",
+  "version": "2.24.1-dev-build-58e271c.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -41,6 +41,7 @@
     "@contentful/experience-design-system-extraction": "workspace:*",
     "@contentful/experience-design-system-generation": "workspace:*",
     "@contentful/experience-design-system-types": "workspace:*",
+    "@segment/analytics-node": "^3.0.0",
     "commander": "^13.1.0",
     "ink": "^4.4.1",
     "react": "^18.3.1",

package/dist/src/analytics/apply.d.ts

@@ -0,0 +1,6 @@
+import type { ApplyOperationResponse } from '@contentful/experience-design-system-types';
+import type { ImportApiClient } from '../apply/api-client.js';
+/** Record apply/preview API outcomes on the active command. */
+export declare function recordApplyOutcome(client: ImportApiClient, spaceId: string, environmentId: string, operation: ApplyOperationResponse): void;
+/** Record Contentful target context without an apply operation (e.g. preview-only). */
+export declare function recordContentfulContext(client: ImportApiClient, spaceId: string, environmentId: string): void;

package/dist/src/analytics/apply.js

@@ -0,0 +1,30 @@
+import { enrichCommandResult, setCommandContext } from './tracker.js';
+function countWriteResult(items, entityType) {
+    const subset = items.filter((item) => item.entityType === entityType);
+    return {
+        created_count: subset.filter((item) => item.action === 'create' && item.status === 'succeeded').length,
+        updated_count: subset.filter((item) => item.action === 'update' && item.status === 'succeeded').length,
+        failed_count: subset.filter((item) => item.status === 'failed').length,
+    };
+}
+/** Record apply/preview API outcomes on the active command. */
+export function recordApplyOutcome(client, spaceId, environmentId, operation) {
+    setCommandContext({
+        space_key: spaceId,
+        environment_key: environmentId,
+        x_contentful_request_id: client.getLastRequestId(),
+    });
+    enrichCommandResult({
+        dsi_operation_id: operation.sys.id,
+        component_type_result: countWriteResult(operation.items ?? [], 'ComponentType'),
+        design_token_result: countWriteResult(operation.items ?? [], 'DesignToken'),
+    });
+}
+/** Record Contentful target context without an apply operation (e.g. preview-only). */
+export function recordContentfulContext(client, spaceId, environmentId) {
+    setCommandContext({
+        space_key: spaceId,
+        environment_key: environmentId,
+        x_contentful_request_id: client.getLastRequestId(),
+    });
+}

package/dist/src/analytics/client.d.ts

@@ -0,0 +1,7 @@
+export declare function cliVersion(): string;
+export declare function analyticsEnabled(): boolean;
+export declare function trackEvent(event: string, properties: Record<string, unknown>, anonymousId: string, options?: {
+    flush?: boolean;
+}): Promise<void>;
+export declare function flushAnalytics(): Promise<void>;
+export declare function resetAnalyticsClientForTests(): void;

package/dist/src/analytics/client.js

@@ -0,0 +1,68 @@
+import { createRequire } from 'node:module';
+import { Analytics } from '@segment/analytics-node';
+const require = createRequire(import.meta.url);
+const pkg = require('../../package.json');
+// Anonymous usage telemetry for the CLI. Disabled when DISABLE_ANALYTICS is set
+// or when no write key is configured. Never blocks command execution.
+let analyticsClient = null;
+export function cliVersion() {
+    return pkg.version;
+}
+export function analyticsEnabled() {
+    return !process.env.DISABLE_ANALYTICS && Boolean(resolveWriteKey());
+}
+function resolveWriteKey() {
+    const key = (process.env.SEGMENT_WRITE_KEY ?? '').trim();
+    return key.length > 0 ? key : undefined;
+}
+function getClient() {
+    if (!analyticsEnabled())
+        return null;
+    const writeKey = resolveWriteKey();
+    if (!writeKey)
+        return null;
+    if (!analyticsClient) {
+        analyticsClient = new Analytics({ writeKey });
+        analyticsClient.on('error', () => {
+            /* never block the CLI on telemetry errors */
+        });
+    }
+    return analyticsClient;
+}
+export async function trackEvent(event, properties, anonymousId, options) {
+    const client = getClient();
+    if (!client)
+        return;
+    try {
+        client.track({
+            event,
+            properties,
+            anonymousId,
+            timestamp: new Date(),
+        });
+        if (options?.flush)
+            await flushAnalytics();
+    }
+    catch {
+        // Telemetry must never affect CLI exit codes or output.
+    }
+}
+// CLI processes are short-lived — we flush (and recreate the client) after each
+// event so terminal telemetry survives process.exit. Do not "optimize" this into
+// a deferred batch flush on process exit; Node will not await async exit hooks.
+export async function flushAnalytics() {
+    if (!analyticsClient)
+        return;
+    try {
+        await analyticsClient.closeAndFlush();
+    }
+    catch {
+        // Swallow — telemetry must never affect CLI behavior.
+    }
+    finally {
+        analyticsClient = null;
+    }
+}
+export function resetAnalyticsClientForTests() {
+    analyticsClient = null;
+}

package/dist/src/analytics/constants.d.ts

@@ -0,0 +1,4 @@
+/** Parent pipeline session id propagated to orchestrator subprocesses. */
+export declare const ANALYTICS_SESSION_ENV = "EDS_ANALYTICS_SESSION_ID";
+/** Set when a command is spawned by the import orchestrator. */
+export declare const IMPORT_PIPELINE_ENV = "EDS_IMPORT_PIPELINE";

package/dist/src/analytics/constants.js

@@ -0,0 +1,4 @@
+/** Parent pipeline session id propagated to orchestrator subprocesses. */
+export const ANALYTICS_SESSION_ENV = 'EDS_ANALYTICS_SESSION_ID';
+/** Set when a command is spawned by the import orchestrator. */
+export const IMPORT_PIPELINE_ENV = 'EDS_IMPORT_PIPELINE';

package/dist/src/analytics/env.d.ts

@@ -0,0 +1,4 @@
+/** Merge pipeline analytics env into a subprocess environment. */
+export declare function analyticsEnvForSubprocess(env: NodeJS.ProcessEnv, analyticsSessionId: string): NodeJS.ProcessEnv;
+/** Debug + pipeline analytics env for orchestrator subprocesses. */
+export declare function pipelineSubprocessEnv(env: NodeJS.ProcessEnv, analyticsSessionId: string): NodeJS.ProcessEnv;

package/dist/src/analytics/env.js

@@ -0,0 +1,14 @@
+import { debugEnvForSubprocess } from '../lib/debug-logger.js';
+import { ANALYTICS_SESSION_ENV, IMPORT_PIPELINE_ENV } from './constants.js';
+/** Merge pipeline analytics env into a subprocess environment. */
+export function analyticsEnvForSubprocess(env, analyticsSessionId) {
+    return {
+        ...env,
+        [IMPORT_PIPELINE_ENV]: '1',
+        [ANALYTICS_SESSION_ENV]: analyticsSessionId,
+    };
+}
+/** Debug + pipeline analytics env for orchestrator subprocesses. */
+export function pipelineSubprocessEnv(env, analyticsSessionId) {
+    return analyticsEnvForSubprocess(debugEnvForSubprocess(env), analyticsSessionId);
+}

package/dist/src/analytics/exit.d.ts

@@ -0,0 +1,5 @@
+import type { ApiError } from '../apply/api-client.js';
+import type { CommandFailure } from './types.js';
+export declare function exitWithAnalytics(code: number, fields?: CommandFailure): Promise<never>;
+export declare function failureFromApiError(error: ApiError): CommandFailure;
+export declare function failureFromUnknown(error: unknown): CommandFailure;

package/dist/src/analytics/exit.js

@@ -0,0 +1,24 @@
+import { flushAnalytics } from './client.js';
+import { completeActiveCommand, failActiveCommand } from './tracker.js';
+export async function exitWithAnalytics(code, fields = {}) {
+    if (code === 0)
+        await completeActiveCommand();
+    else
+        await failActiveCommand({ exit_code: code, ...fields });
+    await flushAnalytics();
+    process.exit(code);
+    throw new Error('unreachable');
+}
+export function failureFromApiError(error) {
+    return {
+        error_name: error.name,
+        http_status_code: error.status,
+        exit_code: 1,
+    };
+}
+export function failureFromUnknown(error) {
+    if (error instanceof Error) {
+        return { error_name: error.name, exit_code: 1 };
+    }
+    return { error_name: 'Error', exit_code: 1 };
+}

package/dist/src/analytics/index.d.ts

@@ -0,0 +1,10 @@
+export { ANALYTICS_SESSION_ENV, IMPORT_PIPELINE_ENV } from './constants.js';
+export { analyticsEnvForSubprocess, pipelineSubprocessEnv } from './env.js';
+export { exitWithAnalytics, failureFromApiError, failureFromUnknown } from './exit.js';
+export { analyticsEnabled, cliVersion, flushAnalytics, resetAnalyticsClientForTests, trackEvent } from './client.js';
+export { isPipelineAnalyticsChild, resolveAnalyticsSessionId } from './session.js';
+export { normalizeCommand } from './normalize.js';
+export { getOsName } from './os.js';
+export { bindAnalyticsSession, bindAnalyticsSessionId, completeActiveCommand, emitSessionStarted, enrichCommandResult, failActiveCommand, getBoundSessionId, noteCommandStart, resetAnalyticsStateForTests, setCommandContext, } from './tracker.js';
+export { recordApplyOutcome, recordContentfulContext } from './apply.js';
+export type { CommandCompletion, CommandContext, CommandFailure, DsiCliCommand, EntryCommand, OsName, WriteResult, } from './types.js';

package/dist/src/analytics/index.js

@@ -0,0 +1,9 @@
+export { ANALYTICS_SESSION_ENV, IMPORT_PIPELINE_ENV } from './constants.js';
+export { analyticsEnvForSubprocess, pipelineSubprocessEnv } from './env.js';
+export { exitWithAnalytics, failureFromApiError, failureFromUnknown } from './exit.js';
+export { analyticsEnabled, cliVersion, flushAnalytics, resetAnalyticsClientForTests, trackEvent } from './client.js';
+export { isPipelineAnalyticsChild, resolveAnalyticsSessionId } from './session.js';
+export { normalizeCommand } from './normalize.js';
+export { getOsName } from './os.js';
+export { bindAnalyticsSession, bindAnalyticsSessionId, completeActiveCommand, emitSessionStarted, enrichCommandResult, failActiveCommand, getBoundSessionId, noteCommandStart, resetAnalyticsStateForTests, setCommandContext, } from './tracker.js';
+export { recordApplyOutcome, recordContentfulContext } from './apply.js';

package/dist/src/analytics/normalize.d.ts

@@ -0,0 +1,3 @@
+import type { DsiCliCommand } from './types.js';
+/** Map a Commander command chain (e.g. "apply push") to a tracked command id, if any. */
+export declare function normalizeCommand(commandChain: string): DsiCliCommand | undefined;

package/dist/src/analytics/normalize.js

@@ -0,0 +1,18 @@
+const COMMAND_MAP = {
+    'analyze extract': 'analyze_extract',
+    'analyze select': 'analyze_select',
+    'analyze select-agent': 'analyze_select',
+    'generate components': 'generate_components',
+    'generate tokens': 'generate_tokens',
+    'generate edit': 'generate_edit',
+    'apply preview': 'apply_preview',
+    'apply select': 'apply_select',
+    'apply push': 'apply_push',
+    'print components': 'print_components',
+    'print tokens': 'print_tokens',
+    import: 'import',
+};
+/** Map a Commander command chain (e.g. "apply push") to a tracked command id, if any. */
+export function normalizeCommand(commandChain) {
+    return COMMAND_MAP[commandChain];
+}

package/dist/src/analytics/os.d.ts

@@ -0,0 +1,2 @@
+import type { OsName } from './types.js';
+export declare function getOsName(): OsName;

package/dist/src/analytics/os.js

@@ -0,0 +1,13 @@
+const OS_NAMES = {
+    android: 'Android',
+    aix: 'Linux',
+    darwin: 'macOS',
+    freebsd: 'Linux',
+    linux: 'Linux',
+    openbsd: 'Linux',
+    sunos: 'Linux',
+    win32: 'Windows',
+};
+export function getOsName() {
+    return OS_NAMES[process.platform] ?? 'other';
+}

package/dist/src/analytics/session.d.ts

@@ -0,0 +1,3 @@
+/** Prefer the pipeline parent session, then an explicit id, then a new slug. */
+export declare function resolveAnalyticsSessionId(explicit?: string): string;
+export declare function isPipelineAnalyticsChild(): boolean;

package/dist/src/analytics/session.js

@@ -0,0 +1,15 @@
+import { generateSessionId } from '../session/session-id.js';
+import { ANALYTICS_SESSION_ENV } from './constants.js';
+/** Prefer the pipeline parent session, then an explicit id, then a new slug. */
+export function resolveAnalyticsSessionId(explicit) {
+    const inherited = process.env[ANALYTICS_SESSION_ENV]?.trim();
+    if (inherited)
+        return inherited;
+    const passed = explicit?.trim();
+    if (passed)
+        return passed;
+    return generateSessionId();
+}
+export function isPipelineAnalyticsChild() {
+    return Boolean(process.env[ANALYTICS_SESSION_ENV]?.trim());
+}

package/dist/src/analytics/tracker.d.ts

@@ -0,0 +1,17 @@
+import type { CommandCompletion, CommandContext, CommandFailure, EntryCommand } from './types.js';
+/** Record the start of a tracked command. Invoked is deferred until a session is bound. */
+export declare function noteCommandStart(commandChain: string): void;
+/** Bind a session id, preferring a pipeline parent id when present. */
+export declare function bindAnalyticsSessionId(sessionId: string | undefined, context?: CommandContext): Promise<string>;
+/** Attach Contentful target context for the active command. */
+export declare function setCommandContext(context: CommandContext): void;
+/** Merge optional completion fields before the terminal event fires. */
+export declare function enrichCommandResult(fields: CommandCompletion): void;
+export declare function getBoundSessionId(): string | undefined;
+/** Bind the pipeline session and emit invoked once both command and session are known. */
+export declare function bindAnalyticsSession(id: string, context?: CommandContext): Promise<void>;
+/** Emit session_started once per new pipeline head. */
+export declare function emitSessionStarted(entryCommand: EntryCommand): Promise<void>;
+export declare function completeActiveCommand(): Promise<void>;
+export declare function failActiveCommand(fields?: CommandFailure): Promise<void>;
+export declare function resetAnalyticsStateForTests(): void;

package/dist/src/analytics/tracker.js

@@ -0,0 +1,126 @@
+import { cliVersion, trackEvent } from './client.js';
+import { IMPORT_PIPELINE_ENV } from './constants.js';
+import { normalizeCommand } from './normalize.js';
+import { getOsName } from './os.js';
+import { resolveAnalyticsSessionId } from './session.js';
+let pending = null;
+let sessionId;
+let sessionStartedEmitted = false;
+function isPipelineStep() {
+    return process.env[IMPORT_PIPELINE_ENV] === '1';
+}
+function buildBaseProps(command) {
+    return {
+        dsi_session_id: sessionId,
+        command,
+        ...(isPipelineStep() ? { is_pipeline_step: true } : {}),
+    };
+}
+function mergeContext(target, source) {
+    if (source.space_key !== undefined)
+        target.space_key = source.space_key;
+    if (source.environment_key !== undefined)
+        target.environment_key = source.environment_key;
+    if (source.x_contentful_request_id !== undefined) {
+        target.x_contentful_request_id = source.x_contentful_request_id;
+    }
+}
+/** Record the start of a tracked command. Invoked is deferred until a session is bound. */
+export function noteCommandStart(commandChain) {
+    const command = normalizeCommand(commandChain);
+    if (!command)
+        return;
+    pending = {
+        command,
+        startedAt: Date.now(),
+        invoked: false,
+        terminalEmitted: false,
+        context: {},
+        completion: {},
+    };
+}
+/** Bind a session id, preferring a pipeline parent id when present. */
+export async function bindAnalyticsSessionId(sessionId, context) {
+    const id = resolveAnalyticsSessionId(sessionId);
+    await bindAnalyticsSession(id, context);
+    return id;
+}
+/** Attach Contentful target context for the active command. */
+export function setCommandContext(context) {
+    if (!pending)
+        return;
+    mergeContext(pending.context, context);
+    mergeContext(pending.completion, context);
+}
+/** Merge optional completion fields before the terminal event fires. */
+export function enrichCommandResult(fields) {
+    if (!pending)
+        return;
+    Object.assign(pending.completion, fields);
+    mergeContext(pending.context, fields);
+}
+export function getBoundSessionId() {
+    return sessionId;
+}
+/** Bind the pipeline session and emit invoked once both command and session are known. */
+export async function bindAnalyticsSession(id, context) {
+    sessionId = id;
+    if (context)
+        setCommandContext(context);
+    await emitInvokedIfReady();
+}
+/** Emit session_started once per new pipeline head. */
+export async function emitSessionStarted(entryCommand) {
+    if (!sessionId || sessionStartedEmitted)
+        return;
+    sessionStartedEmitted = true;
+    await trackEvent('dsi_cli_session_started', {
+        dsi_session_id: sessionId,
+        entry_command: entryCommand,
+        cli_version: cliVersion(),
+        node_version: process.version,
+        os_name: getOsName(),
+    }, sessionId, { flush: true });
+    await emitInvokedIfReady();
+}
+async function emitInvokedIfReady() {
+    if (!pending || pending.invoked || !sessionId)
+        return;
+    pending.invoked = true;
+    await trackEvent('dsi_cli_command_invoked', {
+        ...buildBaseProps(pending.command),
+        ...pending.context,
+    }, sessionId, { flush: true });
+}
+export async function completeActiveCommand() {
+    if (!pending || pending.terminalEmitted || !sessionId || !pending.invoked)
+        return;
+    pending.terminalEmitted = true;
+    const durationMs = Date.now() - pending.startedAt;
+    await trackEvent('dsi_cli_command_completed', {
+        ...buildBaseProps(pending.command),
+        ...pending.context,
+        ...pending.completion,
+        outcome: 'ok',
+        duration_ms: durationMs,
+    }, sessionId, { flush: true });
+}
+export async function failActiveCommand(fields = {}) {
+    if (!pending || pending.terminalEmitted || !sessionId || !pending.invoked)
+        return;
+    pending.terminalEmitted = true;
+    const durationMs = Date.now() - pending.startedAt;
+    const outcome = fields.exit_code === 130 ? 'interrupted' : 'error';
+    await trackEvent('dsi_cli_command_failed', {
+        ...buildBaseProps(pending.command),
+        ...pending.context,
+        ...fields,
+        outcome,
+        duration_ms: durationMs,
+    }, sessionId, { flush: true });
+}
+export function resetAnalyticsStateForTests() {
+    pending = null;
+    sessionId = undefined;
+    sessionStartedEmitted = false;
+}

package/dist/src/analytics/types.d.ts

@@ -0,0 +1,28 @@
+/** Tracked CLI commands — closed set aligned with the published event schema. */
+export type DsiCliCommand = 'analyze_extract' | 'analyze_select' | 'generate_components' | 'generate_tokens' | 'generate_edit' | 'apply_preview' | 'apply_select' | 'apply_push' | 'print_components' | 'print_tokens' | 'import';
+export type EntryCommand = 'analyze_extract' | 'import';
+export type OsName = 'macOS' | 'Linux' | 'Windows' | 'Android' | 'other';
+export type WriteResult = {
+    created_count: number;
+    updated_count: number;
+    failed_count: number;
+};
+export type CommandContext = {
+    space_key?: string;
+    environment_key?: string;
+    x_contentful_request_id?: string;
+};
+export type CommandCompletion = CommandContext & {
+    dsi_operation_id?: string;
+    extracted_component_count?: number;
+    accepted_component_count?: number;
+    component_type_result?: WriteResult;
+    design_token_result?: WriteResult;
+};
+export type CommandFailure = CommandContext & {
+    dsi_operation_id?: string;
+    error_name?: string;
+    error_code?: string;
+    http_status_code?: number;
+    exit_code?: number;
+};

package/dist/src/analytics/types.js

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

package/dist/src/analyze/command.js

@@ -24,6 +24,7 @@ import { DEFAULT_AGENT_NAME, isAgentName, runAgent, } from '@contentful/experien
 import { readExperiencesCredentials } from '../credentials-store.js';
 import { buildAnalyzeViewRows, partitionGlobalWarnings } from './build-analyze-view-rows.js';
 import { getInteractiveTerminalSupport } from '../lib/terminal-capabilities.js';
+import { bindAnalyticsSessionId, emitSessionStarted, enrichCommandResult, exitWithAnalytics, isPipelineAnalyticsChild, } from '../analytics/index.js';
 import { getDebugLogger } from '../lib/debug-logger.js';
 const SCANNED_FILE_EXTENSIONS = new Set(['.astro', '.js', '.jsx', '.svelte', '.ts', '.tsx', '.vue']);
 /**
@@ -264,6 +265,10 @@ export function registerAnalyzeCommand(program) {
             inputPath: projectRoot,
             outDir,
         });
+        await bindAnalyticsSessionId(sessionId);
+        if (!isPipelineAnalyticsChild()) {
+            await emitSessionStarted('analyze_extract');
+        }
         const stepId = createStep(db, sessionId, 'analyze extract', {
             project: projectRoot,
         });
@@ -537,6 +542,7 @@ export function registerAnalyzeCommand(program) {
         storeSlotCycles(db, sessionId, withBreaks);
         storeScannedFiles(db, sessionId, sourceFiles.map((f) => relative(projectRoot, f)));
         updateStep(db, stepId, 'complete', { sessionId });
+        enrichCommandResult({ extracted_component_count: validatedComponents.length });
         db.close();
         const allWarnings = [...extraction.warnings, ...filterWarnings];
         const { rows: componentRows, totalErrors } = buildAnalyzeViewRows(filteredComponents, validatedComponents, allWarnings);
@@ -558,7 +564,7 @@ export function registerAnalyzeCommand(program) {
         if (getInteractiveTerminalSupport().supported) {
             const { waitUntilExit } = render(createElement(AnalyzeView, {
                 result: analyzeResult,
-                onExit: () => process.exit(0),
+                onExit: () => void exitWithAnalytics(0),
             }));
             await waitUntilExit();
         }
@@ -585,7 +591,7 @@ export function registerAnalyzeCommand(program) {
                 summaryLines.push('Warnings: none');
             }
             process.stderr.write(summaryLines.join('\n') + '\n');
-            process.exit(0);
+            await exitWithAnalytics(0);
         }
     });
     registerAnalyzeEditCommand(analyze);

package/dist/src/analyze/select/command.js

@@ -8,6 +8,7 @@ import { loadReviewInput } from './parser.js';
 import { App } from './tui/App.js';
 import { openPipelineDb, loadRawComponents, storeRawComponents, createStep, updateStep } from '../../session/db.js';
 import { validateExtractedComponents, shouldExcludeDueToValidation, formatExclusionWarning, } from '@contentful/experience-design-system-extraction';
+import { bindAnalyticsSessionId, enrichCommandResult, exitWithAnalytics } from '../../analytics/index.js';
 const SAFE_PATH_RE = /^[a-zA-Z0-9_.$[\]=]+$/;
 const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
 function applyDotPath(obj, path, value) {
@@ -102,6 +103,7 @@ async function runNonInteractive(snapshot, opts, paths, sessionId) {
         }
         const accepted = snapshot.components.filter((c) => c.status === 'accepted').length;
         const rejected = snapshot.components.filter((c) => c.status === 'rejected').length + (names.length || 0);
+        enrichCommandResult({ accepted_component_count: accepted });
         process.stderr.write(`Accepted: ${accepted}  Rejected: ${rejected}\n`);
         return;
     }
@@ -130,7 +132,7 @@ async function runNonInteractive(snapshot, opts, paths, sessionId) {
             lines.push('');
             lines.push('Re-run with --exclude-invalid to auto-reject these components, or run analyze select interactively to fix them.');
             process.stderr.write(lines.join('\n') + '\n');
-            process.exit(1);
+            await exitWithAnalytics(1);
             return;
         }
     }
@@ -175,14 +177,14 @@ async function runNonInteractive(snapshot, opts, paths, sessionId) {
             const parsed = JSON.parse(raw);
             if (!Array.isArray(parsed)) {
                 process.stderr.write(`Error: --patch file must be a JSON array of patch operations: ${opts.patch}\n`);
-                process.exit(1);
+                await exitWithAnalytics(1);
                 return;
             }
             patchOps = parsed;
         }
         catch {
             process.stderr.write(`Error: cannot read or parse --patch file: ${opts.patch}\n`);
-            process.exit(1);
+            await exitWithAnalytics(1);
             return;
         }
         // Warn on unknown component names
@@ -229,6 +231,7 @@ async function runNonInteractive(snapshot, opts, paths, sessionId) {
             db.close();
         }
     }
+    enrichCommandResult({ accepted_component_count: accepted.length });
     process.stderr.write(`Accepted: ${accepted.length}  Rejected: ${rejected.length}\n`);
 }
 /**
@@ -345,7 +348,7 @@ export async function rejectComponentsByName(sessionId, names, opts = {}) {
     const components = snapshot.components.map((c) => (nameSet.has(c.name) ? { ...c, status: 'rejected' } : c));
     await saveReviewState(paths.statePath, { ...snapshot, components });
 }
-function resolveSessionId(sessionFlag) {
+async function resolveSessionId(sessionFlag) {
     if (sessionFlag)
         return sessionFlag;
     const db = openPipelineDb();
@@ -360,7 +363,7 @@ function resolveSessionId(sessionFlag) {
             .get();
         if (!row) {
             process.stderr.write('Error: no completed analyze extract session found. Run analyze extract first, or pass --session <id>.\n');
-            process.exit(1);
+            return await exitWithAnalytics(1);
         }
         return row.id;
     }
@@ -384,7 +387,8 @@ export function registerAnalyzeEditCommand(program) {
         .option('--exclude-invalid', 'With --select-all: auto-reject components with validation errors instead of failing loud (opt-in bypass for the gate)')
         .option('--exclude-components <names>', 'Comma-separated component names to force-reject, regardless of other selection flags')
         .action(async ({ session: sessionFlag, projectRoot, acceptAll, selectAll, reject, deselect, select, patch, excludeInvalid, excludeComponents, }) => {
-        const sessionId = resolveSessionId(sessionFlag);
+        const sessionId = await resolveSessionId(sessionFlag);
+        await bindAnalyticsSessionId(sessionId);
         const db = openPipelineDb();
         let rawComponentCount = 0;
         try {
@@ -395,7 +399,7 @@ export function registerAnalyzeEditCommand(program) {
         }
         if (rawComponentCount === 0) {
             process.stderr.write(`Error: session '${sessionId}' has no raw components. Run analyze extract first.\n`);
-            process.exit(1);
+            await exitWithAnalytics(1);
             return;
         }
         const artifactsRoot = getRefineArtifactsRoot();
@@ -420,7 +424,7 @@ export function registerAnalyzeEditCommand(program) {
         }
         catch (error) {
             process.stderr.write(`Error: unable to initialize refine session.\n${error instanceof Error ? error.message : String(error)}\n`);
-            process.exit(1);
+            await exitWithAnalytics(1);
             return;
         }
         // Non-interactive path
@@ -465,7 +469,7 @@ export function registerAnalyzeEditCommand(program) {
         });
         if (process.stdout.columns !== undefined && process.stdout.columns < 60) {
             process.stderr.write(`Error: terminal too narrow (${process.stdout.columns} cols). Resize to 60+ columns.\n`);
-            process.exit(1);
+            await exitWithAnalytics(1);
         }
         const { waitUntilExit } = render(createElement(App, {
             sessionId,