@ishlabs/cli 0.17.4 → 0.17.5

package/dist/index.js

@@ -26,7 +26,7 @@ import { tagAlias, ALIAS_PREFIX } from "./lib/alias-store.js";
 import { output } from "./lib/output.js";
 import { ishDir } from "./lib/paths.js";
 import { findInstalledSkill } from "./lib/skill-content.js";
-import { initObservability } from "./lib/observability.js";
+import { exitWithFlush, initObservability } from "./lib/observability.js";
 import { setSurfaceBaggage } from "./lib/baggage.js";
 import pkg from "../package.json" with { type: "json" };
 const { version } = pkg;
@@ -62,7 +62,8 @@ program.exitOverride((err) => {
     if (err.code === "commander.helpDisplayed"
         || err.code === "commander.version"
         || err.code === "commander.help") {
-        process.exit(0);
+        void exitWithFlush(0);
+        return;
     }
     // Detect --json without relying on parsed opts (parse may have failed).
     const useJson = process.argv.includes("--json") || !process.stdout.isTTY;
@@ -80,7 +81,7 @@ program.exitOverride((err) => {
         console.error(`Error: ${err.message}`);
         console.error("  → Run `ish <command> --help` for usage");
     }
-    process.exit(EXIT_USAGE);
+    void exitWithFlush(EXIT_USAGE);
 });
 // Global options
 program

package/dist/lib/command-helpers.js

@@ -10,6 +10,7 @@ import { outputError, setVerbose, setFields, setGetField } from "./output.js";
 import { setColorsEnabled, colorsEnabled } from "./colors.js";
 import { loadConfig } from "../config.js";
 import { resolveId } from "./alias-store.js";
+import { exitWithFlush } from "./observability.js";
 function isSimulatable(p) {
     return Boolean(p.simulation_config_id) || Boolean(p.simulation_config);
 }
@@ -277,6 +278,10 @@ export function getGlobals(cmd) {
             || process.argv.includes("--get")
             || !process.stdout.isTTY;
         outputError(err, useJson);
+        // Sync exit path: getGlobals is called from non-async Commander hooks,
+        // so we can't await exitWithFlush here. Usage errors are typed early-
+        // exits without rich Sentry signal; accept losing the flush on this
+        // one site rather than cascading async through every getGlobals caller.
         process.exit(exitCodeFromError(err));
     }
     // Apply side effects (verbose, fields, colors, get-field, active workspace)
@@ -409,7 +414,7 @@ export async function withClient(cmd, fn) {
     }
     catch (err) {
         outputError(err, globals.json);
-        process.exit(exitCodeFromError(err));
+        await exitWithFlush(exitCodeFromError(err));
     }
 }
 /**
@@ -424,7 +429,7 @@ export async function runInline(cmd, fn) {
     }
     catch (err) {
         outputError(err, globals.json);
-        process.exit(exitCodeFromError(err));
+        await exitWithFlush(exitCodeFromError(err));
     }
 }
 export function getWebUrl(globals, path) {

package/dist/lib/observability.d.ts

@@ -27,3 +27,28 @@
  * import time on some Bun-compile builds. */
 export declare function isBunRuntime(): boolean;
 export declare function initObservability(): Promise<void>;
+/**
+ * Drain the Sentry buffer before exiting the process.
+ *
+ * Why this exists: Sentry's transport buffers events asynchronously. `ish`
+ * is a short-lived process — most commands call `process.exit(code)` within
+ * milliseconds of init, so the buffered envelope is dropped before the HTTP
+ * batch fires. Net effect: zero telemetry from real CLI invocations.
+ *
+ * Wrap every `process.exit(code)` callsite with `exitWithFlush(code)` instead,
+ * OR await `flushObservability()` directly before exit.
+ *
+ * Always safe to call: no-op when Sentry wasn't initialised (no DSN, or
+ * init failed). Never throws — an observability outage must not crash the
+ * CLI.
+ */
+export declare function flushObservability(timeoutMs?: number): Promise<void>;
+/**
+ * Async-flush-then-exit helper. Use this in place of `process.exit(code)`
+ * anywhere we want telemetry to ship before teardown.
+ *
+ * The Node `beforeExit` event would fire automatically on natural process
+ * end, but it does NOT fire when `process.exit()` is called explicitly —
+ * which the CLI does from at least 5 sites. This helper closes that gap.
+ */
+export declare function exitWithFlush(code: number): Promise<never>;

package/dist/lib/observability.js

@@ -24,6 +24,10 @@
  */
 import pkg from "../../package.json" with { type: "json" };
 import { beforeSend } from "./sentry-scrub.js";
+/** Module-local reference to the loaded Sentry module so `flushObservability`
+ * can call `flush()` without re-importing (which would lose runtime-pinned
+ * state and create a second Hub in some bundler configurations). */
+let _sentryModule = null;
 /** Bun-global probe. ``typeof Bun !== 'undefined'`` is the only reliable
  * runtime-detect: ``process.versions.bun`` exists but is set up well after
  * import time on some Bun-compile builds. */
@@ -44,6 +48,7 @@ export async function initObservability() {
         const sentryModule = bun
             ? await import("@sentry/bun")
             : await import("@sentry/node");
+        _sentryModule = sentryModule;
         const init = sentryModule.init;
         init({
             dsn,
@@ -121,3 +126,40 @@ async function initOtelNode() {
         instrumentations: [new UndiciInstrumentation()],
     });
 }
+/**
+ * Drain the Sentry buffer before exiting the process.
+ *
+ * Why this exists: Sentry's transport buffers events asynchronously. `ish`
+ * is a short-lived process — most commands call `process.exit(code)` within
+ * milliseconds of init, so the buffered envelope is dropped before the HTTP
+ * batch fires. Net effect: zero telemetry from real CLI invocations.
+ *
+ * Wrap every `process.exit(code)` callsite with `exitWithFlush(code)` instead,
+ * OR await `flushObservability()` directly before exit.
+ *
+ * Always safe to call: no-op when Sentry wasn't initialised (no DSN, or
+ * init failed). Never throws — an observability outage must not crash the
+ * CLI.
+ */
+export async function flushObservability(timeoutMs = 2000) {
+    if (!_initialized || _sentryModule?.flush === undefined)
+        return;
+    try {
+        await _sentryModule.flush(timeoutMs);
+    }
+    catch {
+        // Swallow — same rationale as init failure.
+    }
+}
+/**
+ * Async-flush-then-exit helper. Use this in place of `process.exit(code)`
+ * anywhere we want telemetry to ship before teardown.
+ *
+ * The Node `beforeExit` event would fire automatically on natural process
+ * end, but it does NOT fire when `process.exit()` is called explicitly —
+ * which the CLI does from at least 5 sites. This helper closes that gap.
+ */
+export async function exitWithFlush(code) {
+    await flushObservability();
+    process.exit(code);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ishlabs/cli",
-  "version": "0.17.4",
+  "version": "0.17.5",
   "description": "The command-line interface for ish",
   "type": "module",
   "bin": {