openAgent

1#!/usr/bin/env bun
2 
3import { $ } from "bun"
4import path from "path"
5import { fileURLToPath } from "url"
6import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
7 
8const __filename = fileURLToPath(import.meta.url)
9const __dirname = path.dirname(__filename)
10const dir = path.resolve(__dirname, "..")
11 
12process.chdir(dir)
13 
14const generated = await import("./generate.ts")
15 
16import { Script } from "@opencode-ai/script"
17import pkg from "../package.json"
18 
19const singleFlag = process.argv.includes("--single")
20const baselineFlag = process.argv.includes("--baseline")
21const skipInstall = process.argv.includes("--skip-install")
22const sourcemapsFlag = process.argv.includes("--sourcemaps")
23const plugin = createSolidTransformPlugin()
24const skipEmbedWebUi = process.argv.includes("--skip-embed-web-ui")
25 
26const createEmbeddedWebUIBundle = async () => {
27  console.log(`Building Web UI to embed in the binary`)
28  const appDir = path.join(import.meta.dirname, "../../app")
29  const dist = path.join(appDir, "dist")
30  await $`OPENCODE_CHANNEL=${Script.channel} bun run --cwd ${appDir} build`
31  const files = (await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: dist })))
32    .map((file) => file.replaceAll("\\", "/"))
33    .filter((file) => !file.endsWith(".map"))
34    .sort()
35  const imports = files.map((file, i) => {
36    const spec = path.relative(dir, path.join(dist, file)).replaceAll("\\", "/")
37    return `import file_${i} from ${JSON.stringify(spec.startsWith(".") ? spec : `./${spec}`)} with { type: "file" };`
38  })
39  const entries = files.map((file, i) => `  ${JSON.stringify(file)}: file_${i},`)
40  return [
41    `// Import all files as file_$i with type: "file"`,
42    ...imports,
43    `// Export with original mappings`,
44    `export default {`,
45    ...entries,
46    `}`,
47  ].join("\n")
48}
49 
50const embeddedFileMap = skipEmbedWebUi ? null : await createEmbeddedWebUIBundle()
51const treeSitterWorker = await Bun.file(fileURLToPath(import.meta.resolve("@opentui/core/parser.worker"))).text()
52 
53const allTargets: {
54  os: string
55  arch: "arm64" | "x64"
56  abi?: "musl"
57  avx2?: false
58}[] = [
59  {
60    os: "linux",
61    arch: "arm64",
62  },
63  {
64    os: "linux",
65    arch: "x64",
66  },
67  {
68    os: "linux",
69    arch: "x64",
70    avx2: false,
71  },
72  {
73    os: "linux",
74    arch: "arm64",
75    abi: "musl",
76  },
77  {
78    os: "linux",
79    arch: "x64",
80    abi: "musl",
81  },
82  {
83    os: "linux",
84    arch: "x64",
85    abi: "musl",
86    avx2: false,
87  },
88  {
89    os: "darwin",
90    arch: "arm64",
91  },
92  {
93    os: "darwin",
94    arch: "x64",
95  },
96  {
97    os: "darwin",
98    arch: "x64",
99    avx2: false,
100  },
101  {
102    os: "win32",
103    arch: "arm64",
104  },
105  {
106    os: "win32",
107    arch: "x64",
108  },
109  {
110    os: "win32",
111    arch: "x64",
112    avx2: false,
113  },
114]
115 
116const targets = singleFlag
117  ? allTargets.filter((item) => {
118      if (item.os !== process.platform || item.arch !== process.arch) {
119        return false
120      }
121 
122      // When building for the current platform, prefer a single native binary by default.
123      // Baseline binaries require additional Bun artifacts and can be flaky to download.
124      if (item.avx2 === false) {
125        return baselineFlag
126      }
127 
128      // also skip abi-specific builds for the same reason
129      if (item.abi !== undefined) {
130        return false
131      }
132 
133      return true
134    })
135  : allTargets
136 
137await $`rm -rf dist`
138 
139const binaries: Record<string, string> = {}
140if (!skipInstall) {
141  await $`bun install --os="*" --cpu="*" @opentui/core@${pkg.dependencies["@opentui/core"]}`
142  await $`bun install --os="*" --cpu="*" @parcel/watcher@${pkg.dependencies["@parcel/watcher"]}`
143  await $`bun install --os="*" --cpu="*" @ff-labs/fff-bun@${pkg.dependencies["@ff-labs/fff-bun"]}`
144}
145for (const item of targets) {
146  const name = [
147    pkg.name,
148    // changing to win32 flags npm for some reason
149    item.os === "win32" ? "windows" : item.os,
150    item.arch,
151    item.avx2 === false ? "baseline" : undefined,
152    item.abi === undefined ? undefined : item.abi,
153  ]
154    .filter(Boolean)
155    .join("-")
156  console.log(`building ${name}`)
157  await $`mkdir -p dist/${name}/bin`
158 
159  const workerPath = "./src/cli/tui/worker.ts"
160  const treeSitterWorkerPath = "opentui-tree-sitter-worker.js"
161  const bunfsRoot = item.os === "win32" ? "B:/~BUN/root/" : "/$bunfs/root/"
162 
163  await Bun.build({
164    conditions: ["bun", "node"],
165    tsconfig: "./tsconfig.json",
166    plugins: [plugin],
167    external: ["node-gyp"],
168    format: "esm",
169    minify: true,
170    sourcemap: sourcemapsFlag ? "linked" : "none",
171    splitting: true,
172    compile: {
173      autoloadBunfig: false,
174      autoloadDotenv: false,
175      autoloadTsconfig: true,
176      autoloadPackageJson: true,
177      target: name.replace(pkg.name, "bun") as any,
178      outfile: `dist/${name}/bin/openagent`,
179      execArgv: [`--user-agent=openagent/${Script.version}`, "--use-system-ca", "--"],
180      windows: {},
181    },
182    files: {
183      [treeSitterWorkerPath]: treeSitterWorker,
184      ...(embeddedFileMap ? { "opencode-web-ui.gen.ts": embeddedFileMap } : {}),
185    },
186    entrypoints: [
187      "./src/index.ts",
188      workerPath,
189      treeSitterWorkerPath,
190      ...(embeddedFileMap ? ["opencode-web-ui.gen.ts"] : []),
191    ],
192    define: {
193      FFF_LIBC: JSON.stringify(item.abi === "musl" ? "musl" : "gnu"),
194      OPENAGENT_VERSION: `'${Script.version}'`,
195      OPENCODE_VERSION: `'${Script.version}'`,
196      OPENCODE_MODELS_DEV: generated.modelsData,
197      OTUI_TREE_SITTER_WORKER_PATH: bunfsRoot + treeSitterWorkerPath,
198      OPENCODE_WORKER_PATH: workerPath,
199      OPENAGENT_CHANNEL: `'${Script.channel}'`,
200      OPENCODE_CHANNEL: `'${Script.channel}'`,
201      OPENCODE_LIBC: item.os === "linux" ? `'${item.abi ?? "glibc"}'` : "",
202      ...(item.os === "linux" ? { "process.env.OPENTUI_LIBC": JSON.stringify(item.abi ?? "glibc") } : {}),
203    },
204  })
205 
206  // Copy openagent binary to opencode for backwards compatibility
207  const ext = item.os === "win32" ? ".exe" : ""
208  await $`cp dist/${name}/bin/openagent${ext} dist/${name}/bin/opencode${ext}`
209 
210  // Smoke test: only run if binary is for current platform
211  if (item.os === process.platform && item.arch === process.arch && !item.abi) {
212    const binaryPath = `dist/${name}/bin/openagent`
213    console.log(`Running smoke test: ${binaryPath} --version`)
214    try {
215      const versionOutput = await $`${binaryPath} --version`.text()
216      console.log(`Smoke test passed: ${versionOutput.trim()}`)
217    } catch (e) {
218      console.error(`Smoke test failed for ${name}:`, e)
219      process.exit(1)
220    }
221  }
222 
223  await $`rm -rf ./dist/${name}/bin/tui`
224  await Bun.file(`dist/${name}/package.json`).write(
225    JSON.stringify(
226      {
227        name,
228        version: Script.version,
229        preferUnplugged: true,
230        os: [item.os],
231        cpu: [item.arch],
232        ...(item.abi ? { libc: [item.abi] } : {}),
233      },
234      null,
235      2,
236    ),
237  )
238  binaries[name] = Script.version
239}
240 
241if (Script.release) {
242  for (const key of Object.keys(binaries)) {
243    if (key.includes("linux")) {
244      await $`tar -czf ../../${key}.tar.gz *`.cwd(`dist/${key}/bin`)
245    } else {
246      await $`zip -r ../../${key}.zip *`.cwd(`dist/${key}/bin`)
247    }
248  }
249  await $`gh release upload v${Script.version} ./dist/*.zip ./dist/*.tar.gz --clobber --repo ${process.env.GH_REPO}`
250}
251 
252export { binaries }
253