bincode-cli 1.0.1

package/src/index.ts

@@ -0,0 +1,217 @@
+import yargs from "yargs"
+import { hideBin } from "yargs/helpers"
+import { RunCommand } from "./cli/cmd/run"
+import { GenerateCommand } from "./cli/cmd/generate"
+import { Log } from "./util/log"
+import { AuthCommand } from "./cli/cmd/auth"
+import { LoginCommand } from "./cli/cmd/login"
+import { LogoutCommand } from "./cli/cmd/logout"
+import { AgentCommand } from "./cli/cmd/agent"
+import { UpgradeCommand } from "./cli/cmd/upgrade"
+import { UninstallCommand } from "./cli/cmd/uninstall"
+import { ModelsCommand } from "./cli/cmd/models"
+import { UI } from "./cli/ui"
+import { Installation } from "./installation"
+import { NamedError } from "@bincode-ai/util/error"
+import { FormatError } from "./cli/error"
+import { ServeCommand } from "./cli/cmd/serve"
+import { DebugCommand } from "./cli/cmd/debug"
+import { StatsCommand } from "./cli/cmd/stats"
+import { McpCommand } from "./cli/cmd/mcp"
+import { GithubCommand } from "./cli/cmd/github"
+import { ExportCommand } from "./cli/cmd/export"
+import { ImportCommand } from "./cli/cmd/import"
+import { AttachCommand } from "./cli/cmd/tui/attach"
+import { TuiThreadCommand } from "./cli/cmd/tui/thread"
+import { TuiSpawnCommand } from "./cli/cmd/tui/spawn"
+import { AcpCommand } from "./cli/cmd/acp"
+import { EOL } from "os"
+import { WebCommand } from "./cli/cmd/web"
+import { PrCommand } from "./cli/cmd/pr"
+import { SessionCommand } from "./cli/cmd/session"
+import { checkAuth } from "./cli/auth-check"
+import { Filesystem } from "./util/filesystem"
+
+// Load .env file from project root (up the directory tree)
+// Bun automatically loads .env from current directory, but since we run with --cwd packages/bincode,
+// we need to manually load from project root
+async function loadEnvFile() {
+  const currentDir = process.cwd()
+  const envFiles = await Filesystem.findUp(".env", currentDir)
+  if (envFiles.length > 0) {
+    // Use the first .env file found (closest to current directory)
+    const envPath = envFiles[0]
+    try {
+      // Use Bun's built-in dotenv parser
+      const envContent = await Bun.file(envPath).text()
+      const lines = envContent.split("\n")
+      for (const line of lines) {
+        const trimmed = line.trim()
+        // Skip comments and empty lines
+        if (!trimmed || trimmed.startsWith("#")) continue
+        const match = trimmed.match(/^([^=]+)=(.*)$/)
+        if (match) {
+          const key = match[1].trim()
+          let value = match[2].trim()
+          // Remove quotes if present
+          if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1)
+          }
+          // Only set if not already set (env vars take precedence over .env file)
+          if (!process.env[key]) {
+            process.env[key] = value
+          }
+        }
+      }
+    } catch (error) {
+      // Silently fail if .env file can't be read
+    }
+  }
+}
+
+// Load .env file before anything else
+await loadEnvFile()
+
+process.on("unhandledRejection", (e) => {
+  Log.Default.error("rejection", {
+    e: e instanceof Error ? e.message : e,
+  })
+})
+
+process.on("uncaughtException", (e) => {
+  Log.Default.error("exception", {
+    e: e instanceof Error ? e.message : e,
+  })
+})
+
+const cli = yargs(hideBin(process.argv))
+  .parserConfiguration({ "populate--": true })
+  .scriptName("bincode")
+  .wrap(100)
+  .help("help", "show help")
+  .alias("help", "h")
+  .version("version", "show version number", Installation.VERSION)
+  .alias("version", "v")
+  .option("print-logs", {
+    describe: "print logs to stderr",
+    type: "boolean",
+  })
+  .option("log-level", {
+    describe: "log level",
+    type: "string",
+    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
+  })
+  .middleware(async (opts) => {
+    await Log.init({
+      print: process.argv.includes("--print-logs"),
+      dev: Installation.isLocal(),
+      level: (() => {
+        if (opts.logLevel) return opts.logLevel as Log.Level
+        if (Installation.isLocal()) return "DEBUG"
+        return "INFO"
+      })(),
+    })
+
+    process.env.AGENT = "1"
+    process.env.BINCODE = "1"
+
+    Log.Default.info("bincode", {
+      version: Installation.VERSION,
+      args: process.argv.slice(2),
+    })
+
+    // Check authentication before running commands (except auth and login commands)
+    const command = process.argv[2]
+    const authStatus = await checkAuth(command)
+    
+    if (authStatus.needsLogin) {
+      UI.error("Authentication required")
+      console.error("")
+      console.error("Please login first by running:")
+      console.error("  bincode login")
+      console.error("")
+      process.exit(1)
+    }
+  })
+  .usage("\n" + UI.logo())
+  .command(LoginCommand)
+  .command(LogoutCommand)
+  .command(AcpCommand)
+  .command(McpCommand)
+  .command(TuiThreadCommand)
+  .command(TuiSpawnCommand)
+  .command(AttachCommand)
+  .command(RunCommand)
+  .command(GenerateCommand)
+  .command(DebugCommand)
+  .command(AuthCommand)
+  .command(AgentCommand)
+  .command(UpgradeCommand)
+  .command(UninstallCommand)
+  .command(ServeCommand)
+  .command(WebCommand)
+  .command(ModelsCommand)
+  .command(StatsCommand)
+  .command(ExportCommand)
+  .command(ImportCommand)
+  .command(GithubCommand)
+  .command(PrCommand)
+  .command(SessionCommand)
+  .fail((msg) => {
+    if (
+      msg.startsWith("Unknown argument") ||
+      msg.startsWith("Not enough non-option arguments") ||
+      msg.startsWith("Invalid values:")
+    ) {
+      cli.showHelp("log")
+    }
+    process.exit(1)
+  })
+  .strict()
+
+try {
+  await cli.parse()
+} catch (e) {
+  let data: Record<string, any> = {}
+  if (e instanceof NamedError) {
+    const obj = e.toObject()
+    Object.assign(data, {
+      ...obj.data,
+    })
+  }
+
+  if (e instanceof Error) {
+    Object.assign(data, {
+      name: e.name,
+      message: e.message,
+      cause: e.cause?.toString(),
+      stack: e.stack,
+    })
+  }
+
+  if (e instanceof ResolveMessage) {
+    Object.assign(data, {
+      name: e.name,
+      message: e.message,
+      code: e.code,
+      specifier: e.specifier,
+      referrer: e.referrer,
+      position: e.position,
+      importKind: e.importKind,
+    })
+  }
+  Log.Default.error("fatal", data)
+  const formatted = FormatError(e)
+  if (formatted) UI.error(formatted)
+  if (formatted === undefined) {
+    UI.error("Unexpected error, check log file at " + Log.file() + " for more details" + EOL)
+    console.error(e)
+  }
+  process.exitCode = 1
+} finally {
+  // Some subprocesses don't react properly to SIGTERM and similar signals.
+  // Most notably, some docker-container-based MCP servers don't handle such signals unless
+  // run using `docker run --init`.
+  // Explicitly exit to avoid any hanging subprocesses.
+  process.exit()
+}

package/src/installation/index.ts

@@ -0,0 +1,196 @@
+import { BusEvent } from "@/bus/bus-event"
+import path from "path"
+import { $ } from "bun"
+import z from "zod"
+import { NamedError } from "@bincode-ai/util/error"
+import { Log } from "../util/log"
+import { iife } from "@/util/iife"
+import { Flag } from "../flag/flag"
+
+declare global {
+  const BINCODE_VERSION: string
+  const BINCODE_CHANNEL: string
+}
+
+export namespace Installation {
+  const log = Log.create({ service: "installation" })
+
+  export type Method = Awaited<ReturnType<typeof method>>
+
+  export const Event = {
+    Updated: BusEvent.define(
+      "installation.updated",
+      z.object({
+        version: z.string(),
+      }),
+    ),
+    UpdateAvailable: BusEvent.define(
+      "installation.update-available",
+      z.object({
+        version: z.string(),
+      }),
+    ),
+  }
+
+  export const Info = z
+    .object({
+      version: z.string(),
+      latest: z.string(),
+    })
+    .meta({
+      ref: "InstallationInfo",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export async function info() {
+    return {
+      version: VERSION,
+      latest: await latest(),
+    }
+  }
+
+  export function isPreview() {
+    return CHANNEL !== "latest"
+  }
+
+  export function isLocal() {
+    return CHANNEL === "local"
+  }
+
+  export async function method() {
+    if (process.execPath.includes(path.join(".bincode", "bin"))) return "curl"
+    if (process.execPath.includes(path.join(".local", "bin"))) return "curl"
+    const exec = process.execPath.toLowerCase()
+
+    const checks = [
+      {
+        name: "npm" as const,
+        command: () => $`npm list -g --depth=0`.throws(false).quiet().text(),
+      },
+      {
+        name: "yarn" as const,
+        command: () => $`yarn global list`.throws(false).quiet().text(),
+      },
+      {
+        name: "pnpm" as const,
+        command: () => $`pnpm list -g --depth=0`.throws(false).quiet().text(),
+      },
+      {
+        name: "bun" as const,
+        command: () => $`bun pm ls -g`.throws(false).quiet().text(),
+      },
+      {
+        name: "brew" as const,
+        command: () => $`brew list --formula bincode`.throws(false).quiet().text(),
+      },
+    ]
+
+    checks.sort((a, b) => {
+      const aMatches = exec.includes(a.name)
+      const bMatches = exec.includes(b.name)
+      if (aMatches && !bMatches) return -1
+      if (!aMatches && bMatches) return 1
+      return 0
+    })
+
+    for (const check of checks) {
+      const output = await check.command()
+      if (output.includes(check.name === "brew" ? "bincode" : "bincode-ai")) {
+        return check.name
+      }
+    }
+
+    return "unknown"
+  }
+
+  export const UpgradeFailedError = NamedError.create(
+    "UpgradeFailedError",
+    z.object({
+      stderr: z.string(),
+    }),
+  )
+
+  async function getBrewFormula() {
+    const tapFormula = await $`brew list --formula sst/tap/bincode`.throws(false).quiet().text()
+    if (tapFormula.includes("bincode")) return "sst/tap/bincode"
+    const coreFormula = await $`brew list --formula bincode`.throws(false).quiet().text()
+    if (coreFormula.includes("bincode")) return "bincode"
+    return "bincode"
+  }
+
+  export async function upgrade(method: Method, target: string) {
+    let cmd
+    switch (method) {
+      case "curl":
+        cmd = $`curl -fsSL https://bincode.ai/install | bash`.env({
+          ...process.env,
+          VERSION: target,
+        })
+        break
+      case "npm":
+        cmd = $`npm install -g bincode-ai@${target}`
+        break
+      case "pnpm":
+        cmd = $`pnpm install -g bincode-ai@${target}`
+        break
+      case "bun":
+        cmd = $`bun install -g bincode-ai@${target}`
+        break
+      case "brew": {
+        const formula = await getBrewFormula()
+        cmd = $`brew install ${formula}`.env({
+          HOMEBREW_NO_AUTO_UPDATE: "1",
+          ...process.env,
+        })
+        break
+      }
+      default:
+        throw new Error(`Unknown method: ${method}`)
+    }
+    const result = await cmd.quiet().throws(false)
+    log.info("upgraded", {
+      method,
+      target,
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString(),
+    })
+    if (result.exitCode !== 0)
+      throw new UpgradeFailedError({
+        stderr: result.stderr.toString("utf8"),
+      })
+  }
+
+  export const VERSION = typeof BINCODE_VERSION === "string" ? BINCODE_VERSION : "local"
+  export const CHANNEL = typeof BINCODE_CHANNEL === "string" ? BINCODE_CHANNEL : "local"
+  export const USER_AGENT = `bincode/${CHANNEL}/${VERSION}/${Flag.BINCODE_CLIENT}`
+
+  export async function latest(installMethod?: Method) {
+    const detectedMethod = installMethod || (await method())
+    if (detectedMethod === "brew") {
+      const formula = await getBrewFormula()
+      if (formula === "bincode") {
+        return fetch("https://formulae.brew.sh/api/formula/bincode.json")
+          .then((res) => {
+            if (!res.ok) throw new Error(res.statusText)
+            return res.json()
+          })
+          .then((data: any) => data.versions.stable)
+      }
+    }
+
+    const registry = await iife(async () => {
+      const r = (await $`npm config get registry`.quiet().nothrow().text()).trim()
+      const reg = r || "https://registry.npmjs.org"
+      return reg.endsWith("/") ? reg.slice(0, -1) : reg
+    })
+    const [major] = VERSION.split(".").map((x) => Number(x))
+    // const channel = CHANNEL === "latest" ? `latest-${major}` : CHANNEL
+    const channel = CHANNEL
+    return fetch(`${registry}/bincode-ai/${channel}`)
+      .then((res) => {
+        if (!res.ok) throw new Error(res.statusText)
+        return res.json()
+      })
+      .then((data: any) => data.version)
+  }
+}

package/src/lsp/client.ts

@@ -0,0 +1,229 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import path from "path"
+import { pathToFileURL, fileURLToPath } from "url"
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node"
+import type { Diagnostic as VSCodeDiagnostic } from "vscode-languageserver-types"
+import { Log } from "../util/log"
+import { LANGUAGE_EXTENSIONS } from "./language"
+import z from "zod"
+import type { LSPServer } from "./server"
+import { NamedError } from "@bincode-ai/util/error"
+import { withTimeout } from "../util/timeout"
+import { Instance } from "../project/instance"
+import { Filesystem } from "../util/filesystem"
+
+const DIAGNOSTICS_DEBOUNCE_MS = 150
+
+export namespace LSPClient {
+  const log = Log.create({ service: "lsp.client" })
+
+  export type Info = NonNullable<Awaited<ReturnType<typeof create>>>
+
+  export type Diagnostic = VSCodeDiagnostic
+
+  export const InitializeError = NamedError.create(
+    "LSPInitializeError",
+    z.object({
+      serverID: z.string(),
+    }),
+  )
+
+  export const Event = {
+    Diagnostics: BusEvent.define(
+      "lsp.client.diagnostics",
+      z.object({
+        serverID: z.string(),
+        path: z.string(),
+      }),
+    ),
+  }
+
+  export async function create(input: { serverID: string; server: LSPServer.Handle; root: string }) {
+    const l = log.clone().tag("serverID", input.serverID)
+    l.info("starting client")
+
+    const connection = createMessageConnection(
+      new StreamMessageReader(input.server.process.stdout as any),
+      new StreamMessageWriter(input.server.process.stdin as any),
+    )
+
+    const diagnostics = new Map<string, Diagnostic[]>()
+    connection.onNotification("textDocument/publishDiagnostics", (params) => {
+      const filePath = Filesystem.normalizePath(fileURLToPath(params.uri))
+      l.info("textDocument/publishDiagnostics", {
+        path: filePath,
+        count: params.diagnostics.length,
+      })
+      const exists = diagnostics.has(filePath)
+      diagnostics.set(filePath, params.diagnostics)
+      if (!exists && input.serverID === "typescript") return
+      Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+    })
+    connection.onRequest("window/workDoneProgress/create", (params) => {
+      l.info("window/workDoneProgress/create", params)
+      return null
+    })
+    connection.onRequest("workspace/configuration", async () => {
+      // Return server initialization options
+      return [input.server.initialization ?? {}]
+    })
+    connection.onRequest("client/registerCapability", async () => {})
+    connection.onRequest("client/unregisterCapability", async () => {})
+    connection.onRequest("workspace/workspaceFolders", async () => [
+      {
+        name: "workspace",
+        uri: pathToFileURL(input.root).href,
+      },
+    ])
+    connection.listen()
+
+    l.info("sending initialize")
+    await withTimeout(
+      connection.sendRequest("initialize", {
+        rootUri: pathToFileURL(input.root).href,
+        processId: input.server.process.pid,
+        workspaceFolders: [
+          {
+            name: "workspace",
+            uri: pathToFileURL(input.root).href,
+          },
+        ],
+        initializationOptions: {
+          ...input.server.initialization,
+        },
+        capabilities: {
+          window: {
+            workDoneProgress: true,
+          },
+          workspace: {
+            configuration: true,
+          },
+          textDocument: {
+            synchronization: {
+              didOpen: true,
+              didChange: true,
+            },
+            publishDiagnostics: {
+              versionSupport: true,
+            },
+          },
+        },
+      }),
+      45_000,
+    ).catch((err) => {
+      l.error("initialize error", { error: err })
+      throw new InitializeError(
+        { serverID: input.serverID },
+        {
+          cause: err,
+        },
+      )
+    })
+
+    await connection.sendNotification("initialized", {})
+
+    if (input.server.initialization) {
+      await connection.sendNotification("workspace/didChangeConfiguration", {
+        settings: input.server.initialization,
+      })
+    }
+
+    const files: {
+      [path: string]: number
+    } = {}
+
+    const result = {
+      root: input.root,
+      get serverID() {
+        return input.serverID
+      },
+      get connection() {
+        return connection
+      },
+      notify: {
+        async open(input: { path: string }) {
+          input.path = path.isAbsolute(input.path) ? input.path : path.resolve(Instance.directory, input.path)
+          const file = Bun.file(input.path)
+          const text = await file.text()
+          const extension = path.extname(input.path)
+          const languageId = LANGUAGE_EXTENSIONS[extension] ?? "plaintext"
+
+          const version = files[input.path]
+          if (version !== undefined) {
+            const next = version + 1
+            files[input.path] = next
+            log.info("textDocument/didChange", {
+              path: input.path,
+              version: next,
+            })
+            await connection.sendNotification("textDocument/didChange", {
+              textDocument: {
+                uri: pathToFileURL(input.path).href,
+                version: next,
+              },
+              contentChanges: [{ text }],
+            })
+            return
+          }
+
+          log.info("textDocument/didOpen", input)
+          diagnostics.delete(input.path)
+          await connection.sendNotification("textDocument/didOpen", {
+            textDocument: {
+              uri: pathToFileURL(input.path).href,
+              languageId,
+              version: 0,
+              text,
+            },
+          })
+          files[input.path] = 0
+          return
+        },
+      },
+      get diagnostics() {
+        return diagnostics
+      },
+      async waitForDiagnostics(input: { path: string }) {
+        const normalizedPath = Filesystem.normalizePath(
+          path.isAbsolute(input.path) ? input.path : path.resolve(Instance.directory, input.path),
+        )
+        log.info("waiting for diagnostics", { path: normalizedPath })
+        let unsub: () => void
+        let debounceTimer: ReturnType<typeof setTimeout> | undefined
+        return await withTimeout(
+          new Promise<void>((resolve) => {
+            unsub = Bus.subscribe(Event.Diagnostics, (event) => {
+              if (event.properties.path === normalizedPath && event.properties.serverID === result.serverID) {
+                // Debounce to allow LSP to send follow-up diagnostics (e.g., semantic after syntax)
+                if (debounceTimer) clearTimeout(debounceTimer)
+                debounceTimer = setTimeout(() => {
+                  log.info("got diagnostics", { path: normalizedPath })
+                  unsub?.()
+                  resolve()
+                }, DIAGNOSTICS_DEBOUNCE_MS)
+              }
+            })
+          }),
+          3000,
+        )
+          .catch(() => {})
+          .finally(() => {
+            if (debounceTimer) clearTimeout(debounceTimer)
+            unsub?.()
+          })
+      },
+      async shutdown() {
+        l.info("shutting down")
+        connection.end()
+        connection.dispose()
+        input.server.process.kill()
+        l.info("shutdown")
+      },
+    }
+
+    l.info("initialized")
+
+    return result
+  }
+}