fix: resolve TUI worker startup crash from circular dependency (#47)

The TUI showed an empty screen because the worker thread crashed on startup.
ModelsDev.refresh() ran at module load time and accessed Installation.USER_AGENT
before the Installation module finished initializing (circular import chain:
worker.ts → config.ts → models.ts → installation). Deferring the initial
refresh via setTimeout(…, 0) ensures all modules are fully loaded first.

Also improves worker error logging to extract the actual error message from
ErrorEvent (previously logged as useless "[object ErrorEvent]"), and adds an
e2e test that spawns the worker and verifies it starts without errors.

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: anandgupta42

packages/altimate-code/src/cli/cmd/tui/thread.ts

@@ -117,7 +117,7 @@ export const TuiThreadCommand = cmd({
         ),
       })
       worker.onerror = (e) => {
-        Log.Default.error(e)
+        Log.Default.error(e.message, { error: e.error?.stack ?? e.error ?? String(e) })
       }
       const client = Rpc.client<typeof rpc>(worker)
       process.on("uncaughtException", (e) => {

packages/altimate-code/src/provider/models.ts

@@ -122,11 +122,15 @@ export namespace ModelsDev {
 }
 
 if (!Flag.ALTIMATE_CLI_DISABLE_MODELS_FETCH && !process.argv.includes("--get-yargs-completions")) {
-  ModelsDev.refresh()
-  setInterval(
-    async () => {
-      await ModelsDev.refresh()
-    },
-    60 * 1000 * 60,
-  ).unref()
+  // Defer initial refresh to avoid circular dependency — Installation may not
+  // be fully initialized when this module is first evaluated.
+  setTimeout(() => {
+    ModelsDev.refresh()
+    setInterval(
+      async () => {
+        await ModelsDev.refresh()
+      },
+      60 * 1000 * 60,
+    ).unref()
+  }, 0)
 }

packages/altimate-code/test/cli/tui/worker.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, test, afterEach } from "bun:test"
+import { Rpc } from "../../../src/util/rpc"
+import type { rpc } from "../../../src/cli/cmd/tui/worker"
+import path from "path"
+import { fileURLToPath } from "url"
+import { Filesystem } from "../../../src/util/filesystem"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const workerSrc = path.resolve(__dirname, "../../../src/cli/cmd/tui/worker.ts")
+
+describe("tui worker", () => {
+  let worker: Worker | undefined
+
+  afterEach(() => {
+    worker?.terminate()
+    worker = undefined
+  })
+
+  test("starts without errors", async () => {
+    const errors: string[] = []
+
+    worker = new Worker(workerSrc, {
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined),
+      ),
+    })
+
+    worker.onerror = (e) => {
+      errors.push(e.message ?? String(e))
+    }
+
+    // Give the worker time to initialize — module loading,
+    // top-level awaits, and side effects all run during this window.
+    await new Promise((r) => setTimeout(r, 3000))
+
+    expect(errors).toEqual([])
+  }, 10_000)
+
+  test("responds to RPC calls after startup", async () => {
+    const errors: string[] = []
+
+    worker = new Worker(workerSrc, {
+      env: Object.fromEntries(
+        Object.entries(process.env).filter((entry): entry is [string, string] => entry[1] !== undefined),
+      ),
+    })
+
+    worker.onerror = (e) => {
+      errors.push(e.message ?? String(e))
+    }
+
+    // Wait for worker to be ready
+    await new Promise((r) => setTimeout(r, 3000))
+    expect(errors).toEqual([])
+
+    // Verify RPC communication works — the worker exports a `fetch` method
+    const client = Rpc.client<typeof rpc>(worker)
+    const result = await Promise.race([
+      client.call("fetch", {
+        url: "http://altimate-code.internal/health",
+        method: "GET",
+        headers: {},
+      }),
+      new Promise<never>((_, reject) => setTimeout(() => reject(new Error("RPC timeout")), 5000)),
+    ])
+
+    expect(result).toBeDefined()
+    expect(typeof result.status).toBe("number")
+  }, 15_000)
+})