rird 2.1.231 → 2.3.0

package/src/auth/index.ts

@@ -0,0 +1,70 @@
+import path from "path"
+import { Global } from "../global"
+import fs from "fs/promises"
+import z from "zod"
+
+export namespace Auth {
+  export const Oauth = z
+    .object({
+      type: z.literal("oauth"),
+      refresh: z.string(),
+      access: z.string(),
+      expires: z.number(),
+      enterpriseUrl: z.string().optional(),
+    })
+    .meta({ ref: "OAuth" })
+
+  export const Api = z
+    .object({
+      type: z.literal("api"),
+      key: z.string(),
+    })
+    .meta({ ref: "ApiAuth" })
+
+  export const WellKnown = z
+    .object({
+      type: z.literal("wellknown"),
+      key: z.string(),
+      token: z.string(),
+    })
+    .meta({ ref: "WellKnownAuth" })
+
+  export const Info = z.discriminatedUnion("type", [Oauth, Api, WellKnown]).meta({ ref: "Auth" })
+  export type Info = z.infer<typeof Info>
+
+  const filepath = path.join(Global.Path.data, "auth.json")
+
+  export async function get(providerID: string) {
+    const auth = await all()
+    return auth[providerID]
+  }
+
+  export async function all(): Promise<Record<string, Info>> {
+    const file = Bun.file(filepath)
+    const data = await file.json().catch(() => ({}) as Record<string, unknown>)
+    return Object.entries(data).reduce(
+      (acc, [key, value]) => {
+        const parsed = Info.safeParse(value)
+        if (!parsed.success) return acc
+        acc[key] = parsed.data
+        return acc
+      },
+      {} as Record<string, Info>,
+    )
+  }
+
+  export async function set(key: string, info: Info) {
+    const file = Bun.file(filepath)
+    const data = await all()
+    await Bun.write(file, JSON.stringify({ ...data, [key]: info }, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+
+  export async function remove(key: string) {
+    const file = Bun.file(filepath)
+    const data = await all()
+    delete data[key]
+    await Bun.write(file, JSON.stringify(data, null, 2))
+    await fs.chmod(file.name!, 0o600)
+  }
+}

package/src/bun/index.ts

@@ -0,0 +1,114 @@
+import z from "zod"
+import { Global } from "../global"
+import { Log } from "../util/log"
+import path from "path"
+import { NamedError } from "@opencode-ai/util/error"
+import { readableStreamToText } from "bun"
+import { createRequire } from "module"
+import { Lock } from "../util/lock"
+
+export namespace BunProc {
+  const log = Log.create({ service: "bun" })
+  const req = createRequire(import.meta.url)
+
+  export async function run(cmd: string[], options?: Bun.SpawnOptions.OptionsObject<any, any, any>) {
+    log.info("running", {
+      cmd: [which(), ...cmd],
+      ...options,
+    })
+    const result = Bun.spawn([which(), ...cmd], {
+      ...options,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        ...options?.env,
+        BUN_BE_BUN: "1",
+      },
+    })
+    const code = await result.exited
+    const stdout = result.stdout
+      ? typeof result.stdout === "number"
+        ? result.stdout
+        : await readableStreamToText(result.stdout)
+      : undefined
+    const stderr = result.stderr
+      ? typeof result.stderr === "number"
+        ? result.stderr
+        : await readableStreamToText(result.stderr)
+      : undefined
+    log.info("done", {
+      code,
+      stdout,
+      stderr,
+    })
+    if (code !== 0) {
+      throw new Error(`Command failed with exit code ${result.exitCode}: ${stderr}`)
+    }
+    return result
+  }
+
+  export function which() {
+    return process.execPath
+  }
+
+  export const InstallFailedError = NamedError.create(
+    "BunInstallFailedError",
+    z.object({
+      pkg: z.string(),
+      version: z.string(),
+    }),
+  )
+
+  export async function install(pkg: string, version = "latest") {
+    // Use lock to ensure only one install at a time
+    using _ = await Lock.write("bun-install")
+
+    const mod = path.join(Global.Path.cache, "node_modules", pkg)
+    const pkgjson = Bun.file(path.join(Global.Path.cache, "package.json"))
+    const parsed = await pkgjson.json().catch(async () => {
+      const result = { dependencies: {} }
+      await Bun.write(pkgjson.name!, JSON.stringify(result, null, 2))
+      return result
+    })
+    if (parsed.dependencies[pkg] === version) return mod
+
+    // Build command arguments
+    const args = ["add", "--force", "--exact", "--cwd", Global.Path.cache, pkg + "@" + version]
+
+    // Let Bun handle registry resolution:
+    // - If .npmrc files exist, Bun will use them automatically
+    // - If no .npmrc files exist, Bun will default to https://registry.npmjs.org
+    // - No need to pass --registry flag
+    log.info("installing package using Bun's default registry resolution", {
+      pkg,
+      version,
+    })
+
+    await BunProc.run(args, {
+      cwd: Global.Path.cache,
+    }).catch((e) => {
+      throw new InstallFailedError(
+        { pkg, version },
+        {
+          cause: e,
+        },
+      )
+    })
+
+    // Resolve actual version from installed package when using "latest"
+    // This ensures subsequent starts use the cached version until explicitly updated
+    let resolvedVersion = version
+    if (version === "latest") {
+      const installedPkgJson = Bun.file(path.join(mod, "package.json"))
+      const installedPkg = await installedPkgJson.json().catch(() => null)
+      if (installedPkg?.version) {
+        resolvedVersion = installedPkg.version
+      }
+    }
+
+    parsed.dependencies[pkg] = resolvedVersion
+    await Bun.write(pkgjson.name!, JSON.stringify(parsed, null, 2))
+    return mod
+  }
+}

package/src/bus/bus-event.ts

@@ -0,0 +1,43 @@
+import z from "zod"
+import type { ZodType } from "zod"
+import { Log } from "../util/log"
+
+export namespace BusEvent {
+  const log = Log.create({ service: "event" })
+
+  export type Definition = ReturnType<typeof define>
+
+  const registry = new Map<string, Definition>()
+
+  export function define<Type extends string, Properties extends ZodType>(type: Type, properties: Properties) {
+    const result = {
+      type,
+      properties,
+    }
+    registry.set(type, result)
+    return result
+  }
+
+  export function payloads() {
+    return z
+      .discriminatedUnion(
+        "type",
+        registry
+          .entries()
+          .map(([type, def]) => {
+            return z
+              .object({
+                type: z.literal(type),
+                properties: def.properties,
+              })
+              .meta({
+                ref: "Event" + "." + def.type,
+              })
+          })
+          .toArray() as any,
+      )
+      .meta({
+        ref: "Event",
+      })
+  }
+}

package/src/bus/global.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "events"
+
+export const GlobalBus = new EventEmitter<{
+  event: [
+    {
+      directory?: string
+      payload: any
+    },
+  ]
+}>()

package/src/bus/index.ts

@@ -0,0 +1,105 @@
+import z from "zod"
+import { Log } from "../util/log"
+import { Instance } from "../project/instance"
+import { BusEvent } from "./bus-event"
+import { GlobalBus } from "./global"
+
+export namespace Bus {
+  const log = Log.create({ service: "bus" })
+  type Subscription = (event: any) => void
+
+  export const InstanceDisposed = BusEvent.define(
+    "server.instance.disposed",
+    z.object({
+      directory: z.string(),
+    }),
+  )
+
+  const state = Instance.state(
+    () => {
+      const subscriptions = new Map<any, Subscription[]>()
+
+      return {
+        subscriptions,
+      }
+    },
+    async (entry) => {
+      const wildcard = entry.subscriptions.get("*")
+      if (!wildcard) return
+      const event = {
+        type: InstanceDisposed.type,
+        properties: {
+          directory: Instance.directory,
+        },
+      }
+      for (const sub of [...wildcard]) {
+        sub(event)
+      }
+    },
+  )
+
+  export async function publish<Definition extends BusEvent.Definition>(
+    def: Definition,
+    properties: z.output<Definition["properties"]>,
+  ) {
+    const payload = {
+      type: def.type,
+      properties,
+    }
+    log.info("publishing", {
+      type: def.type,
+    })
+    const pending = []
+    for (const key of [def.type, "*"]) {
+      const match = state().subscriptions.get(key)
+      for (const sub of match ?? []) {
+        pending.push(sub(payload))
+      }
+    }
+    GlobalBus.emit("event", {
+      directory: Instance.directory,
+      payload,
+    })
+    return Promise.all(pending)
+  }
+
+  export function subscribe<Definition extends BusEvent.Definition>(
+    def: Definition,
+    callback: (event: { type: Definition["type"]; properties: z.infer<Definition["properties"]> }) => void,
+  ) {
+    return raw(def.type, callback)
+  }
+
+  export function once<Definition extends BusEvent.Definition>(
+    def: Definition,
+    callback: (event: {
+      type: Definition["type"]
+      properties: z.infer<Definition["properties"]>
+    }) => "done" | undefined,
+  ) {
+    const unsub = subscribe(def, (event) => {
+      if (callback(event)) unsub()
+    })
+  }
+
+  export function subscribeAll(callback: (event: any) => void) {
+    return raw("*", callback)
+  }
+
+  function raw(type: string, callback: (event: any) => void) {
+    log.info("subscribing", { type })
+    const subscriptions = state().subscriptions
+    let match = subscriptions.get(type) ?? []
+    match.push(callback)
+    subscriptions.set(type, match)
+
+    return () => {
+      log.info("unsubscribing", { type })
+      const match = subscriptions.get(type)
+      if (!match) return
+      const index = match.indexOf(callback)
+      if (index === -1) return
+      match.splice(index, 1)
+    }
+  }
+}

package/src/cli/bootstrap.ts

@@ -0,0 +1,17 @@
+import { InstanceBootstrap } from "../project/bootstrap"
+import { Instance } from "../project/instance"
+
+export async function bootstrap<T>(directory: string, cb: () => Promise<T>) {
+  return Instance.provide({
+    directory,
+    init: InstanceBootstrap,
+    fn: async () => {
+      try {
+        const result = await cb()
+        return result
+      } finally {
+        await Instance.dispose()
+      }
+    },
+  })
+}

package/src/cli/cmd/acp.ts

@@ -0,0 +1,104 @@
+import { Log } from "@/util/log"
+import { bootstrap } from "../bootstrap"
+import { cmd } from "./cmd"
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
+import { ACP } from "@/acp/agent"
+import { Server } from "@/server/server"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2"
+import { handleError, setupGlobalErrorHandlers, setupGracefulShutdown } from "@/lib/error-handler"
+import { ServerError } from "@/lib/errors"
+
+const log = Log.create({ service: "acp-command" })
+
+setupGlobalErrorHandlers()
+
+export const AcpCommand = cmd({
+  command: "acp",
+  describe: "start ACP (Agent Client Protocol) server for rird",
+  builder: (yargs) => {
+    return yargs
+      .option("cwd", {
+        describe: "working directory",
+        type: "string",
+        default: process.cwd(),
+      })
+      .option("port", {
+        type: "number",
+        describe: "port to listen on",
+        default: 0,
+      })
+      .option("hostname", {
+        type: "string",
+        describe: "hostname to listen on",
+        default: "127.0.0.1",
+      })
+  },
+  handler: async (args) => {
+    try {
+      let server: any = null
+      await bootstrap(process.cwd(), async () => {
+        try {
+          server = Server.listen({
+            port: args.port,
+            hostname: args.hostname,
+          })
+
+          const sdk = createOpencodeClient({
+            baseUrl: `http://${server.hostname}:${server.port}`,
+          })
+
+          const input = new WritableStream<Uint8Array>({
+            write(chunk) {
+              return new Promise<void>((resolve, reject) => {
+                process.stdout.write(chunk, (err) => {
+                  if (err) {
+                    reject(err)
+                  } else {
+                    resolve()
+                  }
+                })
+              })
+            },
+          })
+          const output = new ReadableStream<Uint8Array>({
+            start(controller) {
+              process.stdin.on("data", (chunk: Buffer) => {
+                controller.enqueue(new Uint8Array(chunk))
+              })
+              process.stdin.on("end", () => controller.close())
+              process.stdin.on("error", (err) => controller.error(err))
+            },
+          })
+
+          const stream = ndJsonStream(input, output)
+          const agent = await ACP.init({ sdk })
+
+          new AgentSideConnection((conn) => {
+            return agent.create(conn, { sdk })
+          }, stream)
+
+          setupGracefulShutdown(async () => {
+            if (server) {
+              server.stop()
+            }
+          })
+
+          log.info("ACP server listening", { hostname: args.hostname, port: args.port })
+          process.stdin.resume()
+          await new Promise((resolve, reject) => {
+            process.stdin.on("end", resolve)
+            process.stdin.on("error", reject)
+          })
+        } catch (error) {
+          throw new ServerError("Failed to start ACP server", {
+            code: "ACP_STARTUP_FAILED",
+            originalError: error as Error,
+            details: { hostname: args.hostname, port: args.port },
+          })
+        }
+      })
+    } catch (error) {
+      await handleError(error, "acp-command", { exitOnError: true })
+    }
+  },
+})

package/src/cli/cmd/activate.ts

@@ -0,0 +1,50 @@
+import { cmd } from "./cmd"
+import { UI } from "../ui"
+import { saveLicenseKey, clearLicenseCache, validateLicense } from "../../util/license"
+import * as prompts from "@clack/prompts"
+
+export const ActivateCommand = cmd({
+  command: "activate <key>",
+  describe: "activate RIRD with your license key",
+  builder: (yargs) =>
+    yargs.positional("key", {
+      describe: "your license key from rird.ai",
+      type: "string",
+      demandOption: true,
+    }),
+  async handler(args) {
+    UI.empty()
+    prompts.intro("Activating RIRD")
+
+    const key = args.key as string
+    if (!key || key.length < 10) {
+      prompts.log.error("Invalid license key format")
+      prompts.outro("Get your key at: https://rird.ai")
+      process.exit(1)
+    }
+
+    // Save the key
+    saveLicenseKey(key)
+    clearLicenseCache()
+    prompts.log.step("License key saved")
+
+    // Validate it
+    const spinner = prompts.spinner()
+    spinner.start("Validating license...")
+
+    const result = await validateLicense()
+
+    if (result.valid) {
+      spinner.stop("License activated!")
+      if (result.user?.email) {
+        prompts.log.success(`Welcome, ${result.user.email}`)
+      }
+      prompts.outro("Run 'rird' to get started")
+    } else {
+      spinner.stop("Activation failed", 1)
+      prompts.log.error(result.message)
+      prompts.outro("Check your key and try again")
+      process.exit(1)
+    }
+  },
+})