fix(cli): bound Telemetry.shutdown so unreachable PostHog endpoint cannot block CLI exit

packages/kilo-telemetry/src/__tests__/telemetry.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect, beforeEach } from "bun:test"
+import { describe, test, expect, beforeEach, mock } from "bun:test"
 import { Identity } from "../identity.js"
 import { TelemetryEvent } from "../events.js"
 import { Telemetry } from "../telemetry.js"
@@ -89,3 +89,43 @@ describe("Telemetry", () => {
     expect(typeof Telemetry.trackIndexingError).toBe("function")
   })
 })
+
+describe("Telemetry.shutdown timeout (#9788)", () => {
+  test("passes timeoutMs through to PostHog.shutdown and skips unbounded explicit flush()", async () => {
+    // Reproduces the CLI exit hang reported in #9788: when the PostHog endpoint
+    // is unreachable (offline, firewall, DNS adblock resolving the host to
+    // 0.0.0.0), an explicit flush() call before shutdown retries 3x with 3s
+    // gaps plus 10s per attempt before throwing, blocking process.exit on
+    // short-lived commands like `kilo --help`. The fix drops the explicit
+    // flush() (PostHog.shutdown drains the queue itself) and threads a caller-
+    // supplied timeoutMs through to PostHog.shutdown.
+    let flushCalls = 0
+    const shutdownCalls: Array<number | undefined> = []
+    mock.module("posthog-node", () => ({
+      PostHog: class {
+        async flush() {
+          flushCalls += 1
+          await new Promise((resolve) => setTimeout(resolve, 60_000))
+        }
+        async shutdown(timeoutMs?: number) {
+          shutdownCalls.push(timeoutMs)
+        }
+        optIn() {}
+        optOut() {}
+        capture() {}
+        alias() {}
+      },
+    }))
+
+    const { Telemetry } = await import("../telemetry.js")
+    const { Client } = await import("../client.js")
+    Client.init()
+    const start = Date.now()
+    await Telemetry.shutdown(50)
+    const elapsed = Date.now() - start
+
+    expect(flushCalls).toBe(0)
+    expect(shutdownCalls).toEqual([50])
+    expect(elapsed).toBeLessThan(1000)
+  })
+})

packages/kilo-telemetry/src/client.ts

@@ -68,12 +68,18 @@ export namespace Client {
     })
   }
 
-  export async function shutdown(): Promise<void> {
+  export async function shutdown(timeoutMs?: number): Promise<void> {
     if (client) {
-      // Flush any pending events before shutdown
-      await client.flush()
-      await client.shutdown()
-      client = null
+      try {
+        // PostHog's shutdown drains the queue internally and is bounded by
+        // shutdownTimeoutMs. Calling flush() first is redundant and unbounded:
+        // when the endpoint is unreachable (offline, firewall, DNS adblock),
+        // flush retries up to 3x with 3s delays plus 10s per attempt before
+        // throwing, blocking process exit before shutdown's outer cap kicks in.
+        await client.shutdown(timeoutMs)
+      } finally {
+        client = null
+      }
     }
   }
 }

packages/kilo-telemetry/src/telemetry.ts

@@ -241,7 +241,7 @@ export namespace Telemetry {
     track(TelemetryEvent.ERROR, { error, context })
   }
 
-  export async function shutdown(): Promise<void> {
-    await Client.shutdown()
+  export async function shutdown(timeoutMs?: number): Promise<void> {
+    await Client.shutdown(timeoutMs)
   }
 }

packages/opencode/src/index.ts

@@ -316,7 +316,10 @@ try {
   // kilocode_change start - Track CLI exit and shutdown telemetry
   const exitCode = typeof process.exitCode === "number" ? process.exitCode : undefined
   Telemetry.trackCliExit(exitCode)
-  await Telemetry.shutdown()
+  // Bound telemetry shutdown so an unreachable endpoint (offline, firewall,
+  // DNS adblock resolving the host to 0.0.0.0) cannot block process exit on
+  // short-lived commands like `kilo --help` / `kilo --version` (#9788).
+  await Telemetry.shutdown(2000)
   // kilocode_change end
 
   await Instance.disposeAll() // kilocode_change - safety net disposal (no-op if already disposed)