@contentful/experience-design-system-cli 2.23.2-dev-build-b213913.0 → 2.23.2-dev-build-8b2cfc9.0

package/README.md

@@ -450,6 +450,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.23.2-dev-build-b213913.0",
+  "version": "2.23.2-dev-build-8b2cfc9.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,3 @@
+export declare function cliVersion(): string;
+export declare function analyticsEnabled(): boolean;
+export declare function trackEvent(event: string, properties: Record<string, unknown>, anonymousId: string): Promise<void>;

package/dist/src/analytics/client.js

@@ -0,0 +1,39 @@
+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.
+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;
+}
+export async function trackEvent(event, properties, anonymousId) {
+    if (!analyticsEnabled())
+        return;
+    const writeKey = resolveWriteKey();
+    if (!writeKey)
+        return;
+    try {
+        const client = new Analytics({ writeKey });
+        client.on('error', () => {
+            /* never block the CLI on telemetry errors */
+        });
+        client.track({
+            event,
+            properties,
+            anonymousId,
+            timestamp: new Date(),
+        });
+        await client.closeAndFlush();
+    }
+    catch {
+        // Telemetry must never affect CLI exit codes or output.
+    }
+}

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

@@ -0,0 +1,6 @@
+export { analyticsEnabled, cliVersion, trackEvent } from './client.js';
+export { normalizeCommand } from './normalize.js';
+export { getOsName } from './os.js';
+export { bindAnalyticsSession, bindAnalyticsSessionId, completeActiveCommand, emitSessionStarted, enrichCommandResult, failActiveCommand, getBoundSessionId, noteCommandStart, registerAnalyticsExitHook, 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,5 @@
+export { analyticsEnabled, cliVersion, trackEvent } from './client.js';
+export { normalizeCommand } from './normalize.js';
+export { getOsName } from './os.js';
+export { bindAnalyticsSession, bindAnalyticsSessionId, completeActiveCommand, emitSessionStarted, enrichCommandResult, failActiveCommand, getBoundSessionId, noteCommandStart, registerAnalyticsExitHook, 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,17 @@
+const COMMAND_MAP = {
+    'analyze extract': 'analyze_extract',
+    'analyze select': '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/tracker.d.ts

@@ -0,0 +1,19 @@
+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, minting one when the command has no pipeline session. */
+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>;
+/** Best-effort terminal event when the process exits without a clean postAction hook. */
+export declare function registerAnalyticsExitHook(): void;
+export declare function resetAnalyticsStateForTests(): void;

package/dist/src/analytics/tracker.js

@@ -0,0 +1,157 @@
+import { cliVersion, trackEvent } from './client.js';
+import { generateSessionId } from '../session/session-id.js';
+import { normalizeCommand } from './normalize.js';
+import { getOsName } from './os.js';
+let pending = null;
+let sessionId;
+let sessionStartedEmitted = false;
+function isPipelineStep() {
+    return process.env.EDS_IMPORT_PIPELINE === '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, minting one when the command has no pipeline session. */
+export async function bindAnalyticsSessionId(sessionId, context) {
+    const id = sessionId ?? generateSessionId();
+    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);
+    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);
+}
+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);
+}
+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);
+}
+let exitHookRegistered = false;
+/** Best-effort terminal event when the process exits without a clean postAction hook. */
+export function registerAnalyticsExitHook() {
+    if (exitHookRegistered)
+        return;
+    exitHookRegistered = true;
+    process.on('exit', (code) => {
+        if (!pending || pending.terminalEmitted || !sessionId || !pending.invoked)
+            return;
+        const durationMs = Date.now() - pending.startedAt;
+        const outcome = code === 0 ? 'ok' : code === 130 ? 'interrupted' : 'error';
+        const event = code === 0 ? 'dsi_cli_command_completed' : 'dsi_cli_command_failed';
+        const props = code === 0
+            ? {
+                ...buildBaseProps(pending.command),
+                ...pending.context,
+                ...pending.completion,
+                outcome: 'ok',
+                duration_ms: durationMs,
+            }
+            : {
+                ...buildBaseProps(pending.command),
+                ...pending.context,
+                outcome: outcome === 'interrupted' ? 'interrupted' : 'error',
+                duration_ms: durationMs,
+                exit_code: code,
+            };
+        // Synchronous best-effort — async flush cannot run on 'exit'.
+        void trackEvent(event, props, sessionId);
+    });
+}
+export function resetAnalyticsStateForTests() {
+    pending = null;
+    sessionId = undefined;
+    sessionStartedEmitted = false;
+    exitHookRegistered = false;
+}

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

@@ -0,0 +1,29 @@
+/** 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;
+    x_contentful_request_id?: string;
+    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 { bindAnalyticsSession, emitSessionStarted, enrichCommandResult } 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,8 @@ export function registerAnalyzeCommand(program) {
             inputPath: projectRoot,
             outDir,
         });
+        await bindAnalyticsSession(sessionId);
+        await emitSessionStarted('analyze_extract');
         const stepId = createStep(db, sessionId, 'analyze extract', {
             project: projectRoot,
         });
@@ -537,6 +540,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);

package/dist/src/apply/api-client.d.ts

@@ -45,6 +45,9 @@ export declare class ImportApiClient {
     private spaceId;
     private environmentId;
     private retry;
+    private lastRequestId?;
+    getLastRequestId(): string | undefined;
+    private noteRequestId;
     constructor(opts: ApiClientOptions);
     private base;
     private headers;

package/dist/src/apply/api-client.js

@@ -180,6 +180,15 @@ export class ImportApiClient {
     spaceId;
     environmentId;
     retry;
+    lastRequestId;
+    getLastRequestId() {
+        return this.lastRequestId;
+    }
+    noteRequestId(response) {
+        const requestId = response.headers.get('x-contentful-request-id');
+        if (requestId)
+            this.lastRequestId = requestId;
+    }
     constructor(opts) {
         this.host = toApiHost(opts.host);
         this.token = opts.cmaToken;
@@ -237,8 +246,10 @@ export class ImportApiClient {
                 await this.retry.sleep(delayMs);
                 continue;
             }
-            if (!isTransientStatus(result.response.status))
+            if (!isTransientStatus(result.response.status)) {
+                this.noteRequestId(result.response);
                 return result;
+            }
             if (attempt === this.retry.maxAttempts) {
                 const body = stringifyError(result.error);
                 const guidance = `The ${phase} request failed after ${attempt} attempts because the service remained unavailable. ` +
@@ -273,6 +284,7 @@ export class ImportApiClient {
         // false positives that don't apply to the design-systems API authorization path.
         const url = `${this.host}/users/me`;
         const res = await request(url, { token: this.token });
+        this.noteRequestId(res);
         if (res.status === 401) {
             throw new ApiError('CMA token is invalid or revoked', res.status, await res.text());
         }
@@ -298,6 +310,7 @@ export class ImportApiClient {
         catch {
             return; // network error — don't block; the real call will surface it
         }
+        this.noteRequestId(res);
         if (res.ok)
             return;
         if (res.status >= 500)

package/dist/src/apply/command.js

@@ -16,7 +16,9 @@ import { addArtifactInputOptions, addCompositionOptions, addContentfulTargetOpti
 import { stripAllowedComponents } from '../import/strip-allowed-components.js';
 import { readExperiencesCredentials } from '../credentials-store.js';
 import { getInteractiveTerminalSupport, requireInteractiveTerminal } from '../lib/terminal-capabilities.js';
+import { bindAnalyticsSessionId, completeActiveCommand, failActiveCommand, recordApplyOutcome, recordContentfulContext, } from '../analytics/index.js';
 function die(message) {
+    void failActiveCommand({ exit_code: 1 });
     process.stderr.write(`${message}\n`);
     process.exit(1);
 }
@@ -431,6 +433,12 @@ export function registerApplyCommand(program) {
             throw e;
         }
         const { components, tokens, client } = inputs;
+        const spaceId = opts.spaceId;
+        const environmentId = opts.environmentId;
+        await bindAnalyticsSessionId(opts.session, {
+            space_key: spaceId,
+            environment_key: environmentId,
+        });
         try {
             await client.validateToken();
         }
@@ -450,8 +458,7 @@ export function registerApplyCommand(program) {
                 die(`Error: ${formatApiError(e)}`);
             throw e;
         }
-        const spaceId = opts.spaceId;
-        const environmentId = opts.environmentId;
+        recordContentfulContext(client, spaceId, environmentId);
         if (getInteractiveTerminalSupport().supported) {
             const { waitUntilExit } = render(createElement(ServerPreviewApp, {
                 preview,
@@ -490,6 +497,12 @@ export function registerApplyCommand(program) {
             throw e;
         }
         const { components, tokens, client } = inputs;
+        const spaceId = opts.spaceId;
+        const environmentId = opts.environmentId;
+        await bindAnalyticsSessionId(opts.session, {
+            space_key: spaceId,
+            environment_key: environmentId,
+        });
         assertNoSlotCycles(components);
         try {
             await client.validateToken();
@@ -509,8 +522,6 @@ export function registerApplyCommand(program) {
                 die(`Error: ${formatApiError(e, opts.verbose)}`);
             throw e;
         }
-        const spaceId = opts.spaceId;
-        const environmentId = opts.environmentId;
         if (opts.dryRun) {
             if (isTTY) {
                 const { waitUntilExit } = render(createElement(ServerPreviewApp, {
@@ -564,8 +575,14 @@ export function registerApplyCommand(program) {
                 throw e;
             }
             const summary = buildApplyOutput(operation, spaceId, environmentId, opts.host);
+            recordApplyOutcome(client, spaceId, environmentId, operation);
             process.stdout.write(JSON.stringify(summary, null, 2) + '\n');
-            process.exit(operation.sys.status === 'succeeded' ? 0 : 1);
+            const exitCode = operation.sys.status === 'succeeded' ? 0 : 1;
+            if (exitCode === 0)
+                await completeActiveCommand();
+            else
+                await failActiveCommand({ exit_code: exitCode });
+            process.exit(exitCode);
             return;
         }
         await new Promise((resolvePromise) => {

package/dist/src/import/orchestrator.js

@@ -7,6 +7,7 @@ import { detectSlotCycles, formatSlotCycleReport } from '../apply/command.js';
 import { PREVIEW_ERROR_PREFIX, VALIDATION_FAILED_CODE, parsePreviewValidationErrors } from '../apply/api-client.js';
 import { buildPostPushUrl } from '../lib/contentful-urls.js';
 import { getDebugLogger, debugEnvForSubprocess } from '../lib/debug-logger.js';
+import { bindAnalyticsSession, emitSessionStarted } from '../analytics/index.js';
 function findCliPath() {
     return join(fileURLToPath(import.meta.url), '..', '..', '..', '..', 'bin', 'cli.js');
 }
@@ -16,7 +17,7 @@ async function runStep(args, cliPath, env = {}, streamStderr = false) {
     debug.event('import', 'subprocess.spawn', { cliPath, args });
     return new Promise((res) => {
         const child = execFile('node', [cliPath, ...args], {
-            env: debugEnvForSubprocess({ ...process.env, ...env }),
+            env: debugEnvForSubprocess({ ...process.env, ...env, EDS_IMPORT_PIPELINE: '1' }),
         });
         let stdout = '';
         let stderr = '';
@@ -108,6 +109,10 @@ export async function runPipeline(opts, progressWriter, cliPathOverride) {
         inputPath: projectRoot,
         outDir,
     });
+    await bindAnalyticsSession(sessionId, {
+        ...(opts.spaceId ? { space_key: opts.spaceId, environment_key: opts.environmentId } : {}),
+    });
+    await emitSessionStarted('import');
     progressWriter(`Experience Design System CLI — Pipeline Import`);
     progressWriter(`Project:     ${projectRoot}`);
     progressWriter(`Output:      ${outDir}`);

package/dist/src/index.js

@@ -1,7 +1,11 @@
 import { createProgram } from './program.js';
+import { failActiveCommand } from './analytics/index.js';
 createProgram()
     .parseAsync()
-    .catch((err) => {
+    .catch(async (err) => {
+    await failActiveCommand({
+        error_name: err instanceof Error ? err.name : 'Error',
+    });
     process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}\n`);
     process.exit(1);
 });

package/dist/src/program.js

@@ -12,6 +12,7 @@ import { registerImportCommand } from './import/command.js';
 import { registerSetupCommand } from './setup/command.js';
 import { registerRunsCommand } from './runs/ls-command.js';
 import { beginCommand } from './lib/debug-preamble.js';
+import { completeActiveCommand, noteCommandStart, registerAnalyticsExitHook } from './analytics/index.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 /**
@@ -73,6 +74,7 @@ export function createProgram() {
     // and a bright-green "debug logs at <path>" banner is printed to stderr.
     program.option('--debug', 'Write a JSONL trace of every decision to ~/.contentful/experience-design-system-cli/debug/');
     program.option('--no-debug', 'Force debug logging off (overrides EDSI_DEBUG and persisted setup preference)');
+    registerAnalyticsExitHook();
     program.hook('preAction', async (_thisCommand, actionCommand) => {
         // Merge opts from actionCommand and all ancestors — root-level --debug
         // set alongside a subcommand ends up on the root command's opts, not the
@@ -89,7 +91,12 @@ export function createProgram() {
         const chain = [];
         for (let c = actionCommand; c && c.parent; c = c.parent)
             chain.unshift(c.name());
-        await beginCommand(chain.join(' ') || actionCommand.name(), { ...(debug !== undefined ? { debug } : {}) });
+        const commandChain = chain.join(' ') || actionCommand.name();
+        noteCommandStart(commandChain);
+        await beginCommand(commandChain, { ...(debug !== undefined ? { debug } : {}) });
+    });
+    program.hook('postAction', async () => {
+        await completeActiveCommand();
     });
     return program;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentful/experience-design-system-cli",
-  "version": "2.23.2-dev-build-b213913.0",
+  "version": "2.23.2-dev-build-8b2cfc9.0",
   "description": "Contentful Experiences design system import CLI",
   "license": "MIT",
   "type": "module",
@@ -28,15 +28,16 @@
     "prompts/"
   ],
   "dependencies": {
+    "@segment/analytics-node": "^3.0.0",
     "commander": "^13.1.0",
     "ink": "^4.4.1",
     "react": "^18.3.1",
     "react-devtools-core": "^4.19.1",
     "react-dom": "^18.3.1",
-    "@contentful/experience-design-system-client": "2.23.2-dev-build-b213913.0",
-    "@contentful/experience-design-system-extraction": "2.23.2-dev-build-b213913.0",
-    "@contentful/experience-design-system-generation": "2.23.2-dev-build-b213913.0",
-    "@contentful/experience-design-system-types": "2.23.2-dev-build-b213913.0"
+    "@contentful/experience-design-system-client": "2.23.2-dev-build-8b2cfc9.0",
+    "@contentful/experience-design-system-extraction": "2.23.2-dev-build-8b2cfc9.0",
+    "@contentful/experience-design-system-generation": "2.23.2-dev-build-8b2cfc9.0",
+    "@contentful/experience-design-system-types": "2.23.2-dev-build-8b2cfc9.0"
   },
   "devDependencies": {
     "@tsconfig/node24": "^24.0.4",