nix flake: initial flake and patches for ts

Author: Alb-O

flake.nix

@@ -0,0 +1,58 @@
+{
+  description = "OpenCode development flake";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+  };
+
+  outputs =
+    {
+      nixpkgs,
+      ...
+    }:
+    let
+      systems = [
+        "aarch64-linux"
+        "x86_64-linux"
+      ];
+      forEachSystem = nixpkgs.lib.genAttrs systems;
+    in
+    {
+      devShells = forEachSystem (
+        system:
+        let
+          pkgs = import nixpkgs { inherit system; };
+        in
+        {
+          default = pkgs.mkShell {
+            packages = with pkgs; [
+              bun
+              nodejs_20
+              pkg-config
+              openssl
+              git
+            ];
+          };
+        }
+      );
+
+      apps = forEachSystem (
+        system:
+        let
+          pkgs = import nixpkgs { inherit system; };
+        in
+        {
+          opencode-dev = {
+            type = "app";
+            program = pkgs.writeShellApplication {
+              name = "opencode-dev";
+              runtimeInputs = [ pkgs.bun ];
+              text = ''
+                exec bun run dev "$@"
+              '';
+            };
+          };
+        }
+      );
+    };
+}

packages/opencode/src/cli/cmd/tui/thread.ts

@@ -7,6 +7,8 @@ import { Session } from "@/session"
 import { bootstrap } from "@/cli/bootstrap"
 import path from "path"
 import { UI } from "@/cli/ui"
+import { Server } from "@/server/server"
+import { Instance } from "@/project/instance"
 
 declare global {
   const OPENCODE_WORKER_PATH: string
@@ -65,11 +67,9 @@ export const TuiThreadCommand = cmd({
     // Resolve relative paths against PWD to preserve behavior when using --cwd flag
     const baseCwd = process.env.PWD ?? process.cwd()
     const cwd = args.project ? path.resolve(baseCwd, args.project) : process.cwd()
-    let workerPath: string | URL = new URL("./worker.ts", import.meta.url)
-
-    if (typeof OPENCODE_WORKER_PATH !== "undefined") {
-      workerPath = OPENCODE_WORKER_PATH
-    }
+    const defaultWorker = new URL("./worker.ts", import.meta.url)
+    const workerPath =
+      typeof OPENCODE_WORKER_PATH !== "undefined" ? OPENCODE_WORKER_PATH : defaultWorker
     try {
       process.chdir(cwd)
     } catch (e) {
@@ -100,33 +100,64 @@ export const TuiThreadCommand = cmd({
         return undefined
       })()
 
-      const worker = new Worker(workerPath, {
-        env: Object.fromEntries(
+      const setup = await (async () => {
+        const env = Object.fromEntries(
           Object.entries(process.env).filter(
             (entry): entry is [string, string] => entry[1] !== undefined,
           ),
-        ),
-      })
-      worker.onerror = console.error
-      const client = Rpc.client<typeof rpc>(worker)
-      process.on("uncaughtException", (e) => {
-        console.error(e)
-      })
-      process.on("unhandledRejection", (e) => {
-        console.error(e)
-      })
-      const server = await client.call("server", {
-        port: args.port,
-        hostname: args.hostname,
-      })
+        )
+        const worker = await Promise.resolve()
+          .then(
+            () =>
+              new Worker(workerPath, {
+                env,
+              }),
+          )
+          .catch((error) => {
+            console.debug("opencode tui worker disabled", error)
+            return undefined
+          })
+        if (worker) {
+          worker.onerror = console.error
+          const client = Rpc.client<typeof rpc>(worker)
+          process.on("uncaughtException", (error) => {
+            console.error(error)
+          })
+          process.on("unhandledRejection", (error) => {
+            console.error(error)
+          })
+          const remote = await client.call("server", {
+            port: args.port,
+            hostname: args.hostname,
+          })
+          return {
+            url: remote.url,
+            stop: async () => {
+              await client.call("shutdown", undefined)
+              worker.terminate()
+            },
+          }
+        }
+        const inline = Server.listen({
+          port: args.port ?? 0,
+          hostname: args.hostname ?? "127.0.0.1",
+        })
+        return {
+          url: inline.url.toString(),
+          stop: async () => {
+            await Instance.disposeAll()
+            await inline.stop(true)
+          },
+        }
+      })()
       await tui({
-        url: server.url,
+        url: setup.url,
         sessionID,
         model: args.model,
         agent: args.agent,
         prompt,
         onExit: async () => {
-          await client.call("shutdown", undefined)
+          await setup.stop()
         },
       })
     })

packages/opencode/src/provider/models-macro.ts

@@ -1,4 +1,11 @@
 export async function data() {
+  const path = Bun.env.MODELS_DEV_API_JSON
+  if (path) {
+    const file = Bun.file(path)
+    if (await file.exists()) {
+      return await file.text()
+    }
+  }
   const json = await fetch("https://models.dev/api.json").then((x) => x.text())
   return json
 }

packages/sdk/js/src/gen/client/utils.gen.ts

@@ -169,8 +169,11 @@ export const buildUrl: Client["buildUrl"] = (options) =>
 
 export const mergeConfigs = (a: Config, b: Config): Config => {
   const config = { ...a, ...b }
-  if (config.baseUrl?.endsWith("/")) {
-    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1)
+  if (config.baseUrl) {
+    const base =
+      typeof config.baseUrl === "string" ? config.baseUrl : String(config.baseUrl)
+    const trimmed = base.endsWith("/") ? base.substring(0, base.length - 1) : base
+    config.baseUrl = trimmed
   }
   config.headers = mergeHeaders(a.headers, b.headers)
   return config