feat(cli): pass error code as Sentry tag on captured exceptions

Adds the error code as an `error.code` tag to Sentry exceptions,
matching the v1 SentryClient behavior. The code is resolved via
resolveErrorCode in both reportError and TaskContextAdapter.

Made-with: Cursor

Author: FedeZara

packages/cli/cli-v2/src/context/adapter/TaskContextAdapter.ts

@@ -5,6 +5,7 @@ import {
     type Finishable,
     type InteractiveTaskContext,
     type PosthogEvent,
+    resolveErrorCode,
     type Startable,
     TaskAbortSignal,
     type TaskContext,
@@ -68,8 +69,9 @@ export class TaskContextAdapter implements TaskContext {
         reportError(this.context, error ?? new Error(message), options);
     }
 
-    public captureException(error: unknown, _code?: CliError.Code): void {
-        this.context.telemetry.captureException(error);
+    public captureException(error: unknown, code?: CliError.Code): void {
+        const errorCode = resolveErrorCode(error, code) ?? "INTERNAL_ERROR";
+        this.context.telemetry.captureException(error, { errorCode });
     }
 
     private getFullErrorMessage(message?: string, error?: unknown): string | undefined {

packages/cli/cli-v2/src/context/withContext.ts

@@ -114,7 +114,7 @@ export function reportError(context: Context, error: unknown, options?: { code?:
     }
     const code = resolveErrorCode(error, options?.code) ?? "INTERNAL_ERROR";
     if (shouldReportToSentry(code)) {
-        context.telemetry.captureException(error);
+        context.telemetry.captureException(error, { errorCode: code });
     }
     context.telemetry.sendLifecycleEvent({
         status: "error",

packages/cli/cli-v2/src/telemetry/TelemetryClient.ts

@@ -105,15 +105,15 @@ export class TelemetryClient {
      * The caller is responsible for deciding which errors are worth reporting
      * (see `shouldReportToSentry` in withContext.ts).
      */
-    public captureException(error: unknown): void {
+    public captureException(error: unknown, { errorCode }: { errorCode: string }): void {
         if (this.sentry === undefined) {
             return;
         }
         try {
             this.sentry.captureException(error, {
                 captureContext: {
                     user: { id: this.distinctId },
-                    tags: { ...this.baseTags, ...this.accumulatedTags }
+                    tags: { ...this.baseTags, ...this.accumulatedTags, "error.code": errorCode }
                 }
             });
         } catch {

packages/cli/cli/src/telemetry/SentryClient.ts

@@ -27,14 +27,10 @@ export class SentryClient {
             return;
         }
         try {
-            if (code != null) {
-                Sentry.withScope((scope) => {
-                    scope.setTag("error.code", code);
-                    this.sentry?.captureException(error);
-                });
-            } else {
-                this.sentry.captureException(error);
-            }
+            this.sentry.captureException(
+                error,
+                code != null ? { captureContext: { tags: { "error.code": code } } } : undefined
+            );
         } catch {
             // no-op
         }

packages/cli/cli/src/telemetry/__test__/SentryClient.test.ts

@@ -50,6 +50,18 @@ describe("SentryClient (cli-v1)", () => {
 
         expect(mockSentryInit).toHaveBeenCalledOnce();
         expect(mockSentryCaptureException).toHaveBeenCalledOnce();
+        expect(mockSentryCaptureException).toHaveBeenCalledWith(expect.any(Error), undefined);
+    });
+
+    it("passes error.code tag via captureContext when code is provided", () => {
+        const client = new SentryClient({ release: "cli@1.2.3" });
+        const error = new Error("something broke");
+
+        client.captureException(error, "INTERNAL_ERROR");
+
+        expect(mockSentryCaptureException).toHaveBeenCalledWith(error, {
+            captureContext: { tags: { "error.code": "INTERNAL_ERROR" } }
+        });
     });
 
     it("flushes the Sentry client", async () => {