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,
@@ -60,16 +61,21 @@ export class TaskContextAdapter implements TaskContext {
     }
 
     public failWithoutThrowing(message?: string, error?: unknown, options?: { code?: CliErrorCode }): void {
+        this.result = TaskResult.Failure;
+        if (error instanceof TaskAbortSignal) {
+            return;
+        }
         const fullMessage = this.getFullErrorMessage(message, error);
         if (fullMessage != null) {
             this.logger.error(fullMessage);
         }
-        this.result = TaskResult.Failure;
-        reportError(this.context, error ?? new Error(message), options);
+
+        reportError(this.context, error, { ...options, message });
     }
 
-    public captureException(error: unknown, _code?: CliErrorCode): void {
-        this.context.telemetry.captureException(error);
+    public captureException(error: unknown, code?: CliErrorCode): 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,14 +114,20 @@ function handleError(context: Context, error: unknown): void {
  * Called from the top-level catch in withContext and from
  * TaskContextAdapter.failWithoutThrowing.
  */
-<<<<<<< HEAD
-export function reportError(context: Context, error: unknown, options?: { code?: CliErrorCode }): void {
+export function reportError(
+    context: Context,
+    error: unknown,
+    options?: { message?: string; code?: CliErrorCode }
+): void {
     if (error instanceof TaskAbortSignal) {
         return;
     }
-    const code = resolveErrorCode(error, options?.code) ?? "INTERNAL_ERROR";
+    const code = resolveErrorCode(error, options?.code);
+    const capturable = error ?? new CliError({ message: options?.message ?? "", code });
     if (shouldReportToSentry(code)) {
-        context.telemetry.captureException(error);
+        context.telemetry.captureException(capturable, {
+            errorCode: code
+        });
     }
     context.telemetry.sendLifecycleEvent({
         status: "error",

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

@@ -107,15 +107,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

@@ -29,14 +29,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

@@ -51,6 +51,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 () => {