@happy-creative/iroder 1.0.0

package/script/build.ts

@@ -0,0 +1,281 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+import fs from "fs"
+import path from "path"
+import { fileURLToPath } from "url"
+import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const dir = path.resolve(__dirname, "..")
+
+process.chdir(dir)
+
+import { Script } from "@happy-creative/script"
+import pkg from "../package.json"
+
+const modelsUrl = process.env.IRODER_MODELS_URL || "https://models.dev"
+// Fetch and generate models.dev snapshot
+const modelsData = process.env.MODELS_DEV_API_JSON
+  ? await Bun.file(process.env.MODELS_DEV_API_JSON).text()
+  : await fetch(`${modelsUrl}/api.json`).then((x) => x.text())
+await Bun.write(
+  path.join(dir, "src/provider/models-snapshot.js"),
+  `// @ts-nocheck\n// Auto-generated by build.ts - do not edit\nexport const snapshot = ${modelsData}\n`,
+)
+await Bun.write(
+  path.join(dir, "src/provider/models-snapshot.d.ts"),
+  `// Auto-generated by build.ts - do not edit\nexport declare const snapshot: Record<string, unknown>\n`,
+)
+console.log("Generated models-snapshot.js")
+
+// Load migrations from migration directories
+const migrationDirs = (
+  await fs.promises.readdir(path.join(dir, "migration"), {
+    withFileTypes: true,
+  })
+)
+  .filter((entry) => entry.isDirectory() && /^\d{4}\d{2}\d{2}\d{2}\d{2}\d{2}/.test(entry.name))
+  .map((entry) => entry.name)
+  .sort()
+
+const migrations = await Promise.all(
+  migrationDirs.map(async (name) => {
+    const file = path.join(dir, "migration", name, "migration.sql")
+    const sql = await Bun.file(file).text()
+    const match = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/.exec(name)
+    const timestamp = match
+      ? Date.UTC(
+        Number(match[1]),
+        Number(match[2]) - 1,
+        Number(match[3]),
+        Number(match[4]),
+        Number(match[5]),
+        Number(match[6]),
+      )
+      : 0
+    return { sql, timestamp, name }
+  }),
+)
+console.log(`Loaded ${migrations.length} migrations`)
+
+const singleFlag = process.argv.includes("--single")
+const baselineFlag = process.argv.includes("--baseline")
+const skipInstall = process.argv.includes("--skip-install")
+const plugin = createSolidTransformPlugin()
+const skipEmbedWebUi = process.argv.includes("--skip-embed-web-ui")
+const skipSmokeTest =
+  process.argv.includes("--skip-smoke-test") ||
+  process.env.IRODER_SKIP_SMOKE_TEST === "1" ||
+  process.env.IRODER_SKIP_SMOKE_TEST === "true"
+
+const createEmbeddedWebUIBundle = async () => {
+  console.log(`Building Web UI to embed in the binary`)
+  const appDir = path.join(import.meta.dirname, "../../app")
+  const dist = path.join(appDir, "dist")
+  await $`bun run --cwd ${appDir} build`
+  const files = (await Array.fromAsync(new Bun.Glob("**/*").scan({ cwd: dist })))
+    .map((file) => file.replaceAll("\\", "/"))
+    .sort()
+  const imports = files.map((file, i) => {
+    const spec = path.relative(dir, path.join(dist, file)).replaceAll("\\", "/")
+    return `import file_${i} from ${JSON.stringify(spec.startsWith(".") ? spec : `./${spec}`)} with { type: "file" };`
+  })
+  const entries = files.map((file, i) => `  ${JSON.stringify(file)}: file_${i},`)
+  return [
+    `// Import all files as file_$i with type: "file"`,
+    ...imports,
+    `// Export with original mappings`,
+    `export default {`,
+    ...entries,
+    `}`,
+  ].join("\n")
+}
+
+const embeddedFileMap = skipEmbedWebUi ? null : await createEmbeddedWebUIBundle()
+
+const allTargets: {
+  os: string
+  arch: "arm64" | "x64"
+  abi?: "musl"
+  avx2?: false
+}[] = [
+    {
+      os: "linux",
+      arch: "arm64",
+    },
+    {
+      os: "linux",
+      arch: "x64",
+    },
+    {
+      os: "linux",
+      arch: "x64",
+      avx2: false,
+    },
+    {
+      os: "linux",
+      arch: "arm64",
+      abi: "musl",
+    },
+    {
+      os: "linux",
+      arch: "x64",
+      abi: "musl",
+    },
+    {
+      os: "linux",
+      arch: "x64",
+      abi: "musl",
+      avx2: false,
+    },
+    {
+      os: "darwin",
+      arch: "arm64",
+    },
+    {
+      os: "darwin",
+      arch: "x64",
+    },
+    {
+      os: "darwin",
+      arch: "x64",
+      avx2: false,
+    },
+    {
+      os: "win32",
+      arch: "arm64",
+    },
+    {
+      os: "win32",
+      arch: "x64",
+    },
+    {
+      os: "win32",
+      arch: "x64",
+      avx2: false,
+    },
+  ]
+
+const targets = singleFlag
+  ? allTargets.filter((item) => {
+    if (item.os !== process.platform || item.arch !== process.arch) {
+      return false
+    }
+
+    // When building for the current platform, prefer a single native binary by default.
+    // Baseline binaries require additional Bun artifacts and can be flaky to download.
+    if (item.avx2 === false) {
+      return baselineFlag
+    }
+
+    // also skip abi-specific builds for the same reason
+    if (item.abi !== undefined) {
+      return false
+    }
+
+    return true
+  })
+  : allTargets
+
+await $`rm -rf dist`
+
+const binaries: Record<string, string> = {}
+if (!skipInstall) {
+  await $`bun install --os="*" --cpu="*" @opentui/core@${pkg.dependencies["@opentui/core"]}`
+  await $`bun install --os="*" --cpu="*" @parcel/watcher@${pkg.dependencies["@parcel/watcher"]}`
+}
+for (const item of targets) {
+  const name = [
+    pkg.name,
+    // changing to win32 flags npm for some reason
+    item.os === "win32" ? "windows" : item.os,
+    item.arch,
+    item.avx2 === false ? "baseline" : undefined,
+    item.abi === undefined ? undefined : item.abi,
+  ]
+    .filter(Boolean)
+    .join("-")
+  console.log(`building ${name}`)
+  await $`mkdir -p dist/${name}/bin`
+
+  const localPath = path.resolve(dir, "node_modules/@opentui/core/parser.worker.js")
+  const rootPath = path.resolve(dir, "../../node_modules/@opentui/core/parser.worker.js")
+  const parserWorker = fs.realpathSync(fs.existsSync(localPath) ? localPath : rootPath)
+  const workerPath = "./src/cli/cmd/tui/worker.ts"
+
+  // Use platform-specific bunfs root path based on target OS
+  const bunfsRoot = item.os === "win32" ? "B:/~BUN/root/" : "/$bunfs/root/"
+  const workerRelativePath = path.relative(dir, parserWorker).replaceAll("\\", "/")
+
+  await Bun.build({
+    conditions: ["browser"],
+    tsconfig: "./tsconfig.json",
+    plugins: [plugin],
+    external: ["node-gyp"],
+    compile: {
+      autoloadBunfig: false,
+      autoloadDotenv: false,
+      autoloadTsconfig: true,
+      autoloadPackageJson: true,
+      target: name.replace(pkg.name, "bun") as any,
+      outfile: `dist/${name}/bin/iroder`,
+      execArgv: [`--user-agent=iroder/${Script.version}`, "--use-system-ca", "--"],
+      windows: {},
+    },
+    files: {
+      ...(embeddedFileMap ? { "iroder-web-ui.gen.ts": embeddedFileMap } : {}),
+    },
+    entrypoints: ["./src/index.ts", parserWorker, workerPath, ...(embeddedFileMap ? ["iroder-web-ui.gen.ts"] : [])],
+    define: {
+      IRODER_VERSION: `'${Script.version}'`,
+      IRODER_MIGRATIONS: JSON.stringify(migrations),
+      OTUI_TREE_SITTER_WORKER_PATH: bunfsRoot + workerRelativePath,
+      IRODER_WORKER_PATH: workerPath,
+      IRODER_CHANNEL: `'${Script.channel}'`,
+      IRODER_LIBC: item.os === "linux" ? `'${item.abi ?? "glibc"}'` : "",
+    },
+  })
+
+  // Smoke test: only run if binary is for current platform
+  if (!skipSmokeTest && item.os === process.platform && item.arch === process.arch && !item.abi) {
+    const binaryPath = `dist/${name}/bin/iroder`
+    console.log(`Running smoke test: ${binaryPath} --version`)
+    try {
+      const versionOutput = await $`${binaryPath} --version`.text()
+      console.log(`Smoke test passed: ${versionOutput.trim()}`)
+    } catch (e) {
+      console.error(`Smoke test failed for ${name}:`, e)
+      process.exit(1)
+    }
+  }
+
+  await $`rm -rf ./dist/${name}/bin/tui`
+  await Bun.file(`dist/${name}/package.json`).write(
+    JSON.stringify(
+      {
+        name,
+        version: Script.version,
+        os: [item.os],
+        cpu: [item.arch],
+      },
+      null,
+      2,
+    ),
+  )
+  binaries[name] = Script.version
+}
+
+if (Script.release) {
+  for (const key of Object.keys(binaries)) {
+    if (key.includes("linux")) {
+      await $`tar -czf ../../${key}.tar.gz *`.cwd(`dist/${key}/bin`)
+    } else {
+      await $`zip -r ../../${key}.zip *`.cwd(`dist/${key}/bin`)
+    }
+  }
+  await $`gh release upload v${Script.version} ./dist/*.zip ./dist/*.tar.gz --clobber --repo ${process.env.GH_REPO}`
+}
+
+export { binaries }

package/script/check-migrations.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+
+import { $ } from "bun"
+
+// drizzle-kit check compares schema to migrations, exits non-zero if drift
+const result = await $`bun drizzle-kit check`.quiet().nothrow()
+
+if (result.exitCode !== 0) {
+  console.error("Schema has changes not captured in migrations!")
+  console.error("Run: bun drizzle-kit generate")
+  console.error("")
+  console.error(result.stderr.toString())
+  process.exit(1)
+}
+
+console.log("Migrations are up to date")

package/script/e2e-local-real-key.ts

@@ -0,0 +1,197 @@
+#!/usr/bin/env bun
+import { createIroderClient, type Part } from "@happy-creative/sdk/v2/client"
+import { fileURLToPath } from "node:url"
+
+const host = process.env.IRODER_E2E_HOST ?? "127.0.0.1"
+const port = Number(process.env.IRODER_E2E_PORT ?? "4111")
+const prompt = process.env.IRODER_E2E_PROMPT ?? "请用一句话回复：e2e-ok"
+const timeout = Number(process.env.IRODER_E2E_TIMEOUT_MS ?? "90000")
+const baseUrl = `http://${host}:${port}`
+const root = fileURLToPath(new URL("../", import.meta.url))
+
+let logs = ""
+const text = new TextDecoder()
+
+const read = async (stream: ReadableStream<Uint8Array> | null | undefined) => {
+  if (!stream) return
+  const reader = stream.getReader()
+  while (true) {
+    const chunk = await reader.read()
+    if (chunk.done) return
+    logs += text.decode(chunk.value)
+  }
+}
+
+const proc = Bun.spawn(["bun", "run", "dev", "serve", "--hostname", host, "--port", String(port)], {
+  cwd: root,
+  stdout: "pipe",
+  stderr: "pipe",
+  env: process.env,
+})
+
+void read(proc.stdout)
+void read(proc.stderr)
+
+const stop = async () => {
+  proc.kill()
+  await proc.exited.catch(() => undefined)
+}
+
+const fail = async (msg: string) => {
+  console.error(msg)
+  if (logs.trim()) {
+    console.error("\n--- server logs ---\n" + logs.trim())
+  }
+  await stop()
+  process.exit(1)
+}
+
+const waitHealth = async () => {
+  const start = Date.now()
+  while (Date.now() - start < timeout) {
+    const ok = await fetch(`${baseUrl}/global/health`)
+      .then((res) => res.ok)
+      .catch(() => false)
+    if (ok) return true
+
+    const done = await Promise.race([proc.exited.then(() => true), Bun.sleep(500).then(() => false)])
+    if (done) return false
+  }
+  return false
+}
+
+const asText = (parts: Array<{ type: string; text?: string }> | undefined) =>
+  (parts ?? [])
+    .flatMap((part) => {
+      if (part.type !== "text") return []
+      if (typeof part.text !== "string") return []
+      return [part.text]
+    })
+    .join("")
+    .trim()
+
+const prefProvider = [
+  "alibaba-coding-plan-cn",
+  "alibaba-coding-plan",
+  "alibaba-cn",
+  "alibaba",
+  "zhipuai",
+  "kimi",
+]
+
+const prefModel = ["qwen3-coder-plus", "qwen3-coder-next", "qwen3.6-plus", "qwen3.5-plus", "glm-5", "kimi-k2.5"]
+
+const pick = async (sdk: ReturnType<typeof createIroderClient>) => {
+  const data = await sdk.config.providers().then((res) => res.data)
+  const providers = data?.providers ?? []
+  if (providers.length === 0) {
+    await fail("local e2e failed: no providers are available")
+    throw new Error("unreachable")
+  }
+
+  const rawModel = (process.env.IRODER_E2E_MODEL ?? "").trim()
+  const rawProvider = (process.env.IRODER_E2E_PROVIDER ?? "").trim()
+
+  if (rawModel.includes("/")) {
+    const [providerID, modelID] = rawModel.split("/", 2)
+    if (providerID && modelID) return { providerID, modelID }
+  }
+
+  if (rawProvider && rawModel) return { providerID: rawProvider, modelID: rawModel }
+
+  if (rawModel) {
+    for (const provider of providers) {
+      if (provider.models[rawModel]) return { providerID: provider.id, modelID: rawModel }
+    }
+    await fail(`local e2e failed: model not found in providers: ${rawModel}`)
+    throw new Error("unreachable")
+  }
+
+  if (rawProvider) {
+    const provider = providers.find((item) => item.id === rawProvider)
+    if (!provider) {
+      await fail(`local e2e failed: provider not found: ${rawProvider}`)
+      throw new Error("unreachable")
+    }
+    for (const modelID of prefModel) {
+      if (provider.models[modelID]) return { providerID: rawProvider, modelID }
+    }
+    const first = Object.keys(provider.models)[0]
+    if (!first) {
+      await fail(`local e2e failed: provider has no models: ${rawProvider}`)
+      throw new Error("unreachable")
+    }
+    return { providerID: rawProvider, modelID: first }
+  }
+
+  const preferred = prefProvider.flatMap((providerID) => prefModel.map((modelID) => ({ providerID, modelID })))
+  for (const item of preferred) {
+    const provider = providers.find((x) => x.id === item.providerID)
+    if (!provider) continue
+    if (!provider.models[item.modelID]) continue
+    return item
+  }
+
+  const defaults = data?.default ?? {}
+  for (const [providerID, modelID] of Object.entries(defaults)) {
+    if (typeof modelID !== "string" || !modelID) continue
+    const provider = providers.find((x) => x.id === providerID)
+    if (!provider) continue
+    if (!provider.models[modelID]) continue
+    return { providerID, modelID }
+  }
+
+  const firstProvider = providers[0]
+  const firstModel = Object.keys(firstProvider.models)[0]
+  if (!firstModel) {
+    await fail("local e2e failed: provider list has no models")
+    throw new Error("unreachable")
+  }
+  return { providerID: firstProvider.id, modelID: firstModel }
+}
+
+if (!(await waitHealth())) {
+  await fail("local e2e failed: server did not become healthy (or exited early)")
+}
+
+const sdk = createIroderClient({ baseUrl })
+const session = await sdk.session.create()
+const id = session.data?.id ?? ""
+if (!id) {
+  await fail("local e2e failed: session.create returned no session id")
+}
+
+const model = await pick(sdk)
+const result = await sdk.session
+  .prompt({
+    sessionID: id,
+    model,
+    parts: [{ type: "text", text: prompt }],
+  })
+  .catch(async (err: unknown) => {
+    const msg = err instanceof Error ? err.message : String(err)
+    await fail(`local e2e failed: prompt request error: ${msg}`)
+  })
+
+let reply = asText((result?.data?.parts ?? []) as Part[])
+
+if (!reply) {
+  const items = await sdk.session
+    .messages({ sessionID: id, limit: 20 })
+    .then((res) => res.data ?? [])
+    .catch(() => [])
+  const item = [...items].reverse().find((x) => x.info.role === "assistant")
+  reply = asText(item?.parts)
+}
+
+if (!reply) {
+  await fail("local e2e failed: prompt returned no assistant text")
+}
+
+console.log(`e2e_ok=true`)
+console.log(`base_url=${baseUrl}`)
+console.log(`session_id=${id}`)
+console.log(`model=${model.providerID}/${model.modelID}`)
+console.log(`reply=${reply.replaceAll(/\\s+/g, " ").slice(0, 240)}`)
+
+await stop()

package/script/fix-node-pty.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env bun
+
+import fs from "fs/promises"
+import path from "path"
+import { fileURLToPath } from "url"
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const dir = path.resolve(__dirname, "..")
+
+if (process.platform !== "win32") {
+  const root = path.join(dir, "node_modules", "node-pty", "prebuilds")
+  const dirs = await fs.readdir(root, { withFileTypes: true }).catch(() => [])
+  const files = dirs.filter((x) => x.isDirectory()).map((x) => path.join(root, x.name, "spawn-helper"))
+  const result = await Promise.all(
+    files.map(async (file) => {
+      const stat = await fs.stat(file).catch(() => undefined)
+      if (!stat) return
+      if ((stat.mode & 0o111) === 0o111) return
+      await fs.chmod(file, stat.mode | 0o755)
+      return file
+    }),
+  )
+  const fixed = result.filter(Boolean)
+  if (fixed.length) {
+    console.log(`fixed node-pty permissions for ${fixed.length} helper${fixed.length === 1 ? "" : "s"}`)
+  }
+}

package/script/postinstall.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+
+function detectPlatformAndArch() {
+  // Map platform names
+  let platform
+  switch (os.platform()) {
+    case "darwin":
+      platform = "darwin"
+      break
+    case "linux":
+      platform = "linux"
+      break
+    case "win32":
+      platform = "windows"
+      break
+    default:
+      platform = os.platform()
+      break
+  }
+
+  // Map architecture names
+  let arch
+  switch (os.arch()) {
+    case "x64":
+      arch = "x64"
+      break
+    case "arm64":
+      arch = "arm64"
+      break
+    case "arm":
+      arch = "arm"
+      break
+    default:
+      arch = os.arch()
+      break
+  }
+
+  return { platform, arch }
+}
+
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch()
+  const packageName = `iroder-${platform}-${arch}`
+  const binaryName = platform === "windows" ? "iroder.exe" : "iroder"
+
+  try {
+    // Use require.resolve to find the package
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageDir = path.dirname(packageJsonPath)
+    const binaryPath = path.join(packageDir, "bin", binaryName)
+
+    if (!fs.existsSync(binaryPath)) {
+      throw new Error(`Binary not found at ${binaryPath}`)
+    }
+
+    return { binaryPath, binaryName }
+  } catch (error) {
+    throw new Error(`Could not find package ${packageName}: ${error.message}`)
+  }
+}
+
+function prepareBinDirectory(binaryName) {
+  const binDir = path.join(__dirname, "bin")
+  const targetPath = path.join(binDir, binaryName)
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true })
+  }
+
+  // Remove existing binary/symlink if it exists
+  if (fs.existsSync(targetPath)) {
+    fs.unlinkSync(targetPath)
+  }
+
+  return { binDir, targetPath }
+}
+
+function symlinkBinary(sourcePath, binaryName) {
+  const { targetPath } = prepareBinDirectory(binaryName)
+
+  fs.symlinkSync(sourcePath, targetPath)
+  console.log(`iroder binary symlinked: ${targetPath} -> ${sourcePath}`)
+
+  // Verify the file exists after operation
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`Failed to symlink binary to ${targetPath}`)
+  }
+}
+
+async function main() {
+  try {
+    if (os.platform() === "win32") {
+      // On Windows, the .exe is already included in the package and bin field points to it
+      // No postinstall setup needed
+      console.log("Windows detected: binary setup not needed (using packaged .exe)")
+      return
+    }
+
+    // On non-Windows platforms, just verify the binary package exists
+    // Don't replace the wrapper script - it handles binary execution
+    const { binaryPath } = findBinary()
+    const target = path.join(__dirname, "bin", ".iroder")
+    if (fs.existsSync(target)) fs.unlinkSync(target)
+    try {
+      fs.linkSync(binaryPath, target)
+    } catch {
+      fs.copyFileSync(binaryPath, target)
+    }
+    fs.chmodSync(target, 0o755)
+  } catch (error) {
+    console.error("Failed to setup iroder binary:", error.message)
+    process.exit(1)
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  console.error("Postinstall script error:", error.message)
+  process.exit(0)
+}