@fern-api/fern-api-dev 5.23.3-94-g1434a7f90c8 → 5.23.3-99-g2ce21a4a41d

package/cli.cjs

@@ -44559,6 +44559,7 @@ function createMockTaskContext({ logger: logger4 = CONSOLE_LOGGER } = {}) {
       context3.failAndThrow(message, error50);
     },
     captureException: () => {
+      return void 0;
     },
     getResult: () => TaskResult.Success,
     getLastFailureMessage: () => void 0,
@@ -667930,13 +667931,20 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "5.23.3-94-g1434a7f90c8",
+          version: "5.23.3-99-g2ce21a4a41d",
           usingAccessToken: true,
           ...getRunIdProperties()
         }
       });
     }
   }
+  sendAutomationEvent(event) {
+    this.posthog.capture({
+      distinctId: event.distinctId,
+      event: event.event,
+      properties: event.properties
+    });
+  }
   async flush() {
     try {
       await Promise.race([this.posthog.flush(), new Promise((resolve15) => setTimeout(resolve15, 3e3))]);
@@ -667949,6 +667957,8 @@ var AccessTokenPosthogManager = class {
 var NoopPosthogManager = class {
   async sendEvent() {
   }
+  async sendAutomationEvent() {
+  }
   async identify() {
   }
   async flush() {
@@ -667985,7 +667995,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "5.23.3-94-g1434a7f90c8",
+        version: "5.23.3-99-g2ce21a4a41d",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -667994,6 +668004,13 @@ var UserPosthogManager = class {
       }
     });
   }
+  sendAutomationEvent(event) {
+    this.posthog.capture({
+      distinctId: event.distinctId,
+      event: event.event,
+      properties: event.properties
+    });
+  }
   async flush() {
     try {
       await Promise.race([this.posthog.flush(), new Promise((resolve15) => setTimeout(resolve15, 3e3))]);
@@ -671960,18 +671977,26 @@ var TelemetryClient = class _TelemetryClient {
    * The caller is responsible for deciding which errors are worth reporting
    * (see `shouldReportToSentry` in withContext.ts).
    */
-  captureException(error50, { errorCode }) {
+  captureException(error50, options2) {
     if (this.sentry === void 0) {
-      return;
+      return void 0;
     }
     try {
-      this.sentry.captureException(error50, {
-        captureContext: {
-          user: { id: this.distinctId },
-          tags: { ...this.baseTags, ...this.accumulatedTags, "error.code": errorCode }
+      const tags = { ...this.baseTags, ...this.accumulatedTags, ...options2?.tags };
+      const context3 = options2?.context;
+      return withScope2((scope) => {
+        scope.setTags(tags);
+        if (context3 != null) {
+          for (const [key2, value2] of Object.entries(context3)) {
+            if (value2 != null) {
+              scope.setContext(key2, value2);
+            }
+          }
         }
+        return this.sentry?.captureException(error50, void 0, scope);
       });
     } catch {
+      return void 0;
     }
   }
   async flush() {
@@ -673459,7 +673484,9 @@ function reportError(context3, error50, options2) {
   const capturable = error50 ?? new CliError({ message: options2?.message ?? "", code: code5 });
   if (shouldReportToSentry(code5)) {
     context3.telemetry.captureException(capturable, {
-      errorCode: code5
+      tags: {
+        "error.code": code5
+      }
     });
   }
   context3.telemetry.sendLifecycleEvent({
@@ -673658,9 +673685,8 @@ var TaskContextAdapter = class {
   getLastFailureMessage() {
     return this.lastFailureMessage;
   }
-  captureException(error50, code5) {
-    const errorCode = resolveErrorCode(error50, code5);
-    this.context.telemetry.captureException(error50, { errorCode });
+  captureException(error50, options2) {
+    return this.context.telemetry.captureException(error50, options2);
   }
   getFullErrorMessage(message, error50) {
     const errorDetails = this.formatError(error50);
@@ -859541,7 +859567,7 @@ var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 var MAX_LOGS_DIR_SIZE_BYTES = 100 * 1024 * 1024;
 function getCliSource() {
-  const version7 = "5.23.3-94-g1434a7f90c8";
+  const version7 = "5.23.3-99-g2ce21a4a41d";
   return `cli@${version7}`;
 }
 var DebugLogger = class {
@@ -873514,7 +873540,7 @@ var LegacyDocsPublisher = class {
         previewId,
         disableTemplates: void 0,
         skipUpload,
-        cliVersion: "5.23.3-94-g1434a7f90c8",
+        cliVersion: "5.23.3-99-g2ce21a4a41d",
         loginCommand: "fern auth login"
       });
       if (taskContext.getResult() === TaskResult.Failure) {
@@ -947728,6 +947754,260 @@ var esm_default16 = createPrompt((config5, done) => {
 // src/cli-context/CliContext.ts
 init_lodash();
 
+// src/telemetry/automationTelemetryEvent.ts
+var AUTOMATION_EVENT_NAMES = {
+  GENERATION_STARTED: "generation_started",
+  GENERATION_COMPLETED: "generation_completed",
+  GENERATION_FAILED: "generation_failed",
+  VERIFICATION_FAILED: "verification_failed",
+  SDK_PR_CREATED: "sdk_pr_created",
+  UPGRADE_APPLIED: "upgrade_applied",
+  MAJOR_VERSION_BUMP: "major_version_bump"
+};
+var AUTOMATION_EVENT_FAILURE = {
+  [AUTOMATION_EVENT_NAMES.GENERATION_STARTED]: false,
+  [AUTOMATION_EVENT_NAMES.GENERATION_COMPLETED]: false,
+  [AUTOMATION_EVENT_NAMES.GENERATION_FAILED]: true,
+  [AUTOMATION_EVENT_NAMES.VERIFICATION_FAILED]: true,
+  [AUTOMATION_EVENT_NAMES.SDK_PR_CREATED]: false,
+  [AUTOMATION_EVENT_NAMES.UPGRADE_APPLIED]: false,
+  [AUTOMATION_EVENT_NAMES.MAJOR_VERSION_BUMP]: false
+};
+function isFailureAutomationEventName(event) {
+  return AUTOMATION_EVENT_FAILURE[event];
+}
+function toPosthogProperties(event, context3) {
+  return {
+    automation_mode: true,
+    surface: "cli",
+    action: context3.action,
+    run_id: context3.run_id,
+    github_run_id: context3.github_run_id,
+    github_run_url: context3.github_run_url,
+    org: context3.org,
+    config_repo: context3.config_repo,
+    config_commit_sha: context3.config_commit_sha,
+    config_branch: context3.config_branch,
+    config_pr_number: context3.config_pr_number,
+    trigger: context3.trigger,
+    cli_version: context3.cli_version,
+    ...event.errorCode !== void 0 ? { error_code: event.errorCode } : {},
+    ...event.attributes ?? {}
+  };
+}
+function toSentryTags(event, context3) {
+  function appendStringIfPresent(target, key2, value2) {
+    if (value2 != null) {
+      target[key2] = value2;
+    }
+  }
+  const tags = {
+    surface: "cli",
+    automation_mode: "true"
+  };
+  appendStringIfPresent(tags, "event", event.event);
+  appendStringIfPresent(tags, "action", context3.action);
+  appendStringIfPresent(tags, "run_id", context3.run_id);
+  appendStringIfPresent(tags, "org", context3.org);
+  appendStringIfPresent(tags, "config_repo", context3.config_repo);
+  appendStringIfPresent(tags, "trigger", context3.trigger);
+  appendStringIfPresent(tags, "error_code", event.errorCode ?? "none");
+  return tags;
+}
+function toSentryContext(event, context3) {
+  return {
+    github_run_id: context3.github_run_id,
+    github_run_url: context3.github_run_url,
+    config_commit_sha: context3.config_commit_sha,
+    config_branch: context3.config_branch,
+    config_pr_number: context3.config_pr_number,
+    cli_version: context3.cli_version,
+    ...event.attributes ?? {}
+  };
+}
+function toAutomationEventApiBody(event, context3) {
+  return {
+    event: event.event,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    surface: "cli",
+    action: context3.action,
+    run_id: context3.run_id,
+    github_run_id: context3.github_run_id,
+    github_run_url: context3.github_run_url,
+    org: context3.org,
+    config_repo: context3.config_repo,
+    config_commit_sha: context3.config_commit_sha,
+    config_branch: context3.config_branch,
+    config_pr_number: context3.config_pr_number,
+    trigger: context3.trigger,
+    cli_version: context3.cli_version,
+    ...event.errorCode !== void 0 ? { error_code: event.errorCode } : {},
+    ...event.attributes ?? {}
+  };
+}
+function failureEventNameForCommand(argv) {
+  const joined = argv.join(" ");
+  if (/\bautomations\s+generate\b/.test(joined)) {
+    return AUTOMATION_EVENT_NAMES.GENERATION_FAILED;
+  }
+  if (/\bautomations\s+preview\b/.test(joined)) {
+    return AUTOMATION_EVENT_NAMES.VERIFICATION_FAILED;
+  }
+  return AUTOMATION_EVENT_NAMES.GENERATION_FAILED;
+}
+
+// src/telemetry/AutomationEventApiClient.ts
+var DEFAULT_AUTOMATION_EVENTS_ORIGIN = "";
+var AUTOMATION_EVENTS_ORIGIN_ENV_VAR = "FERN_AUTOMATION_EVENTS_ORIGIN";
+var POST_TIMEOUT_MS = 3e3;
+var AutomationEventApiClient = class _AutomationEventApiClient {
+  static instance;
+  origin;
+  inflight = [];
+  static getInstance() {
+    if (_AutomationEventApiClient.instance == null) {
+      _AutomationEventApiClient.instance = new _AutomationEventApiClient(
+        process.env[AUTOMATION_EVENTS_ORIGIN_ENV_VAR] ?? DEFAULT_AUTOMATION_EVENTS_ORIGIN
+      );
+    }
+    return _AutomationEventApiClient.instance;
+  }
+  constructor(origin2) {
+    this.origin = origin2;
+  }
+  /**
+   * Resolves the automation event API endpoint from the baked origin.
+   * Returns undefined when no origin is configured - callers silently skip
+   * the POST in that case.
+   */
+  resolveEndpoint() {
+    if (this.origin.length === 0) {
+      return void 0;
+    }
+    return `${this.origin.replace(/\/$/, "")}/v1/automation/events`;
+  }
+  /**
+   * Enqueues an automation event POST to the automation event API.
+   *
+   * Best-effort: on any failure (timeout, DNS, non-2xx, missing endpoint),
+   * the request settles without throwing. Sentry + PostHog already captured
+   * the incident.
+   */
+  post(event, context3) {
+    this.inflight.push(this.send(event, context3));
+  }
+  async shutdown() {
+    const pending = this.inflight;
+    this.inflight = [];
+    if (pending.length > 0) {
+      await Promise.allSettled(pending);
+    }
+  }
+  async send(event, context3) {
+    const endpoint3 = this.resolveEndpoint();
+    if (endpoint3 == null) {
+      return;
+    }
+    const controller = new AbortController();
+    const timer2 = setTimeout(() => controller.abort(), POST_TIMEOUT_MS);
+    try {
+      const headers2 = { "content-type": "application/json" };
+      const token = await getAccessToken();
+      if (token != null && token.value.length > 0) {
+        headers2.Authorization = `Bearer ${token.value}`;
+      }
+      const response = await fetch(endpoint3, {
+        method: "POST",
+        headers: headers2,
+        body: JSON.stringify(toAutomationEventApiBody(event, context3)),
+        signal: controller.signal
+      });
+      void response;
+    } catch {
+      return;
+    } finally {
+      clearTimeout(timer2);
+    }
+  }
+};
+
+// src/telemetry/automationTelemetryContext.ts
+function getAutomationContextFromEnv() {
+  const { fern_run_id, github_run_id } = getRunIdProperties();
+  return {
+    action: process.env.FERN_ACTION,
+    run_id: fern_run_id,
+    github_run_id,
+    github_run_url: process.env.FERN_GITHUB_RUN_URL,
+    org: void 0,
+    config_repo: process.env.FERN_CONFIG_REPO,
+    config_commit_sha: process.env.FERN_CONFIG_COMMIT_SHA,
+    config_branch: process.env.FERN_CONFIG_BRANCH,
+    config_pr_number: process.env.FERN_CONFIG_PR_NUMBER,
+    trigger: process.env.GITHUB_EVENT_NAME,
+    cli_version: "5.23.3-99-g2ce21a4a41d"
+  };
+}
+function isAutomationMode() {
+  return process.env.FERN_AUTOMATION === "true";
+}
+
+// src/telemetry/AutomationTelemetryManager.ts
+var AutomationTelemetryManager = class {
+  constructor(reporter, automationEventApiClient = AutomationEventApiClient.getInstance()) {
+    this.reporter = reporter;
+    this.automationEventApiClient = automationEventApiClient;
+    this.context = getAutomationContextFromEnv();
+  }
+  reporter;
+  automationEventApiClient;
+  context;
+  setOrganization(organization) {
+    this.context = { ...this.context, org: organization };
+  }
+  emit(event, options2) {
+    const sentryEventId = this.captureSentryForFailure({
+      event,
+      context: this.context,
+      error: options2?.error
+    });
+    const eventWithSentry = sentryEventId == null ? event : { ...event, attributes: { ...event.attributes ?? {}, sentry_event_id: sentryEventId } };
+    this.capturePostHogEvent({ event: eventWithSentry, context: this.context });
+    this.captureAutomationEventApiEvent(eventWithSentry, this.context);
+  }
+  async flush() {
+    await this.automationEventApiClient.shutdown();
+  }
+  capturePostHogEvent({
+    event,
+    context: context3
+  }) {
+    this.reporter.instrumentPostHogAutomationEvent({
+      distinctId: context3.run_id ?? void 0,
+      event: event.event,
+      properties: toPosthogProperties(event, context3)
+    });
+  }
+  captureSentryForFailure({
+    event,
+    context: context3,
+    error: error50
+  }) {
+    if (!isFailureAutomationEventName(event.event) || event.errorCode == null) {
+      return void 0;
+    }
+    return this.reporter.captureException(error50, {
+      tags: toSentryTags(event, context3),
+      context: {
+        automation: toSentryContext(event, context3)
+      }
+    });
+  }
+  captureAutomationEventApiEvent(event, context3) {
+    this.automationEventApiClient.post(event, context3);
+  }
+};
+
 // src/telemetry/reportError.ts
 init_lib6();
 function reportError2(reporter, error50, options2) {
@@ -947735,17 +948015,47 @@ function reportError2(reporter, error50, options2) {
     return;
   }
   const code5 = resolveErrorCode(error50, options2?.code);
+  const argv = options2?.argv ?? process.argv;
+  const command3 = argv.join(" ");
+  const errorMessage = options2?.message ?? (error50 instanceof Error ? error50.message : void 0) ?? "";
+  const reportedError = error50 ?? new CliError({ message: errorMessage, code: code5 });
+  if (isAutomationMode()) {
+    reportErrorForAutomationMode(argv, reporter, code5, errorMessage, reportedError);
+  } else {
+    reportErrorForNormalMode(reporter, command3, code5, reportedError);
+  }
+}
+function reportErrorForNormalMode(reporter, command3, code5, reportedError) {
   reporter.instrumentPostHogEvent({
-    command: process.argv.join(" "),
+    command: command3,
     properties: {
       failed: true,
       errorCode: code5
     }
   });
   if (shouldReportToSentry(code5)) {
-    reporter.captureException(error50 ?? new CliError({ message: options2?.message ?? "", code: code5 }), code5);
+    reporter.captureException(reportedError, {
+      tags: {
+        "error.code": code5
+      }
+    });
   }
 }
+function reportErrorForAutomationMode(argv, reporter, code5, errorMessage, reportedError) {
+  const failureEventName = failureEventNameForCommand(argv);
+  reporter.emitAutomationTelemetryEvent(
+    {
+      event: failureEventName,
+      errorCode: code5,
+      attributes: {
+        error_message: errorMessage
+      }
+    },
+    {
+      error: reportedError
+    }
+  );
+}
 
 // src/telemetry/SentryClient.ts
 init_lib6();
@@ -947755,12 +948065,26 @@ function isTelemetryDisabled() {
   return process.env.FERN_DISABLE_TELEMETRY === "true";
 }
 
+// src/telemetry/shouldInitializeTelemetry.ts
+function shouldInitializeTelemetry({
+  cliName,
+  packageVersion: packageVersion3,
+  isLocal
+}) {
+  if (isTelemetryDisabled() || isLocal) {
+    return false;
+  }
+  const isLocalDev = packageVersion3 === "0.0.0";
+  const isProductionCli = cliName === "fern" && false;
+  return !isLocalDev && isProductionCli;
+}
+
 // src/telemetry/SentryClient.ts
 var SentryClient = class {
   sentry;
-  constructor({ release: release2 }) {
+  constructor({ release: release2, telemetry }) {
     const sentryDsn = "https://84f58b5e457f06999d92f11ce4b79158@o4509504076185600.ingest.us.sentry.io/4511021546602496";
-    if (!isTelemetryDisabled() && sentryDsn != null && sentryDsn.length > 0) {
+    if (shouldInitializeTelemetry(telemetry) && sentryDsn != null && sentryDsn.length > 0) {
       const sentryEnvironment = "development";
       if (sentryEnvironment == null || sentryEnvironment.length === 0) {
         throw new CliError({
@@ -947803,16 +948127,33 @@ var SentryClient = class {
       setSentryRunIdTags();
     }
   }
-  captureException(error50, code5) {
+  captureException(error50, options2) {
     if (this.sentry == null) {
-      return;
+      return void 0;
     }
     try {
-      this.sentry.captureException(
-        error50,
-        code5 != null ? { captureContext: { tags: { "error.code": code5 } } } : void 0
-      );
+      const tags = options2?.tags;
+      const context3 = options2?.context;
+      const hasTags = tags != null && Object.keys(tags).length > 0;
+      const hasContext = context3 != null && Object.values(context3).some((value2) => value2 != null);
+      if (!hasTags && !hasContext) {
+        return this.sentry.captureException(error50);
+      }
+      return withScope2((scope) => {
+        if (hasTags) {
+          scope.setTags(tags);
+        }
+        if (context3 != null) {
+          for (const [key2, value2] of Object.entries(context3)) {
+            if (value2 != null) {
+              scope.setContext(key2, value2);
+            }
+          }
+        }
+        return this.sentry?.captureException(error50, void 0, scope);
+      });
     } catch {
+      return void 0;
     }
   }
   async flush() {
@@ -947878,6 +948219,7 @@ var TaskContextImpl = class {
   onResult;
   instrumentPostHogEventImpl;
   captureExceptionImpl;
+  emitAutomationTelemetryEventImpl;
   constructor({
     logImmediately,
     logPrefix,
@@ -947886,7 +948228,8 @@ var TaskContextImpl = class {
     onResult,
     shouldBufferLogs,
     instrumentPostHogEvent,
-    captureException: captureException2
+    captureException: captureException2,
+    emitAutomationTelemetryEvent
   }) {
     this.logImmediately = logImmediately;
     this.logPrefix = logPrefix ?? "";
@@ -947896,6 +948239,7 @@ var TaskContextImpl = class {
     this.shouldBufferLogs = shouldBufferLogs;
     this.instrumentPostHogEventImpl = instrumentPostHogEvent;
     this.captureExceptionImpl = captureException2;
+    this.emitAutomationTelemetryEventImpl = emitAutomationTelemetryEvent;
   }
   start() {
     this.status = "running";
@@ -947935,8 +948279,11 @@ var TaskContextImpl = class {
   getLastFailureMessage() {
     return this.lastFailureMessage;
   }
-  captureException(error50, code5) {
-    this.captureExceptionImpl?.(error50, code5);
+  captureException(error50, options2) {
+    return this.captureExceptionImpl?.(error50, options2);
+  }
+  emitAutomationTelemetryEvent(event, options2) {
+    this.emitAutomationTelemetryEventImpl(event, options2);
   }
   getResult() {
     return this.result;
@@ -947979,7 +948326,8 @@ var TaskContextImpl = class {
       onResult: this.onResult,
       shouldBufferLogs: this.shouldBufferLogs,
       instrumentPostHogEvent: (event) => this.instrumentPostHogEventImpl(event),
-      captureException: this.captureExceptionImpl
+      captureException: this.captureExceptionImpl,
+      emitAutomationTelemetryEvent: this.emitAutomationTelemetryEventImpl
     });
     this.subtasks.push(subtask);
     return subtask;
@@ -948376,6 +948724,7 @@ var CliContext = class _CliContext {
   environment;
   sentryClient;
   posthogManager;
+  automationTelemetryManager;
   didSucceed = true;
   numTasks = 0;
   ttyAwareLogger;
@@ -948402,7 +948751,15 @@ var CliContext = class _CliContext {
       packageVersion: packageVersion3,
       cliName
     };
-    this.sentryClient = new SentryClient({ release: `cli@${this.environment.packageVersion}` });
+    this.sentryClient = new SentryClient({
+      release: `cli@${this.environment.packageVersion}`,
+      telemetry: {
+        cliName: this.environment.cliName,
+        packageVersion: this.environment.packageVersion,
+        isLocal: this.isLocal
+      }
+    });
+    this.automationTelemetryManager = new AutomationTelemetryManager(this);
   }
   getPackageName() {
     if (false) {
@@ -948414,7 +948771,7 @@ var CliContext = class _CliContext {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "5.23.3-94-g1434a7f90c8";
+    return "5.23.3-99-g2ce21a4a41d";
   }
   getCliName() {
     if (false) {
@@ -948479,6 +948836,7 @@ var CliContext = class _CliContext {
     } catch {
     }
     await this.sentryClient.flush();
+    await this.automationTelemetryManager.flush();
     this.exitProgram({ code: code5 });
   }
   async nudgeUpgradeIfAvailable() {
@@ -948521,6 +948879,7 @@ var CliContext = class _CliContext {
   project;
   registerProject(project) {
     this.project = project;
+    this.automationTelemetryManager.setOrganization(project.config.organization);
   }
   runTask(run) {
     return this.runTaskWithInit(this.constructTaskInit(), run);
@@ -948555,8 +948914,16 @@ var CliContext = class _CliContext {
       this.posthogManager.sendEvent(event);
     }
   }
-  captureException(error50, code5) {
-    this.sentryClient.captureException(error50, code5);
+  instrumentPostHogAutomationEvent(event) {
+    if (!this.isLocal) {
+      this.posthogManager.sendAutomationEvent(event);
+    }
+  }
+  captureException(error50, options2) {
+    return this.sentryClient.captureException(error50, options2);
+  }
+  emitAutomationTelemetryEvent(event, options2) {
+    this.automationTelemetryManager.emit(event, options2);
   }
   logger = createLogger((level, ...args) => this.log(level, ...args));
   stderr = createLogger((level, ...args) => this.logStderr(level, ...args));
@@ -948586,9 +948953,8 @@ var CliContext = class _CliContext {
         this.instrumentPostHogEvent(event);
       },
       shouldBufferLogs: false,
-      captureException: (error50, code5) => {
-        this.sentryClient.captureException(error50, code5);
-      }
+      captureException: (error50, options2) => this.sentryClient.captureException(error50, options2),
+      emitAutomationTelemetryEvent: (event, options2) => this.emitAutomationTelemetryEvent(event, options2)
     };
   }
   log(level, ...parts) {
@@ -967784,6 +968150,40 @@ function evaluateRuntime4() {
   };
 }
 
+// src/telemetry/processHandlers.ts
+init_lib6();
+function installProcessHandlers(cliContext, { isLocal }) {
+  if (!shouldInitializeTelemetry({
+    cliName: cliContext.environment.cliName,
+    packageVersion: cliContext.environment.packageVersion,
+    isLocal
+  })) {
+    return;
+  }
+  let isHandlingFatal = false;
+  const handleFatal = async (label, error50) => {
+    if (isHandlingFatal) {
+      process.exit(1);
+    }
+    isHandlingFatal = true;
+    try {
+      cliContext.failWithoutThrowing(label, error50, { code: CliError.Code.InternalError });
+    } catch {
+    }
+    try {
+      await cliContext.exit({ code: 1 });
+    } catch {
+      process.exit(1);
+    }
+  };
+  process.on("uncaughtException", (error50) => {
+    void handleFatal("uncaught exception", error50);
+  });
+  process.on("unhandledRejection", (reason) => {
+    void handleFatal("unhandled promise rejection", reason);
+  });
+}
+
 // src/cli.ts
 if (process.platform === "linux" && parseInt(process.versions.node.split(".")[0] ?? "0", 10) >= 26 && process.env.UV_USE_IO_URING !== "0") {
   const result = (0, import_node_child_process7.spawnSync)(process.execPath, process.argv.slice(1), {
@@ -967806,6 +968206,7 @@ async function runCli() {
   if (isCompletion) {
     cliContext.suppressUpgradeMessage();
   }
+  installProcessHandlers(cliContext, { isLocal });
   const exit3 = async () => {
     await cliContext.exit();
   };

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "5.23.3-94-g1434a7f90c8",
+  "version": "5.23.3-99-g2ce21a4a41d",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",