rird 2.1.231 → 2.3.0

package/test/fixture/lsp/fake-lsp-server.js

@@ -0,0 +1,77 @@
+// Simple JSON-RPC 2.0 LSP-like fake server over stdio
+// Implements a minimal LSP handshake and triggers a request upon notification
+
+const net = require("net")
+
+let nextId = 1
+
+function encode(message) {
+  const json = JSON.stringify(message)
+  const header = `Content-Length: ${Buffer.byteLength(json, "utf8")}\r\n\r\n`
+  return Buffer.concat([Buffer.from(header, "utf8"), Buffer.from(json, "utf8")])
+}
+
+function decodeFrames(buffer) {
+  const results = []
+  let idx
+  while ((idx = buffer.indexOf("\r\n\r\n")) !== -1) {
+    const header = buffer.slice(0, idx).toString("utf8")
+    const m = /Content-Length:\s*(\d+)/i.exec(header)
+    const len = m ? parseInt(m[1], 10) : 0
+    const bodyStart = idx + 4
+    const bodyEnd = bodyStart + len
+    if (buffer.length < bodyEnd) break
+    const body = buffer.slice(bodyStart, bodyEnd).toString("utf8")
+    results.push(body)
+    buffer = buffer.slice(bodyEnd)
+  }
+  return { messages: results, rest: buffer }
+}
+
+let readBuffer = Buffer.alloc(0)
+
+process.stdin.on("data", (chunk) => {
+  readBuffer = Buffer.concat([readBuffer, chunk])
+  const { messages, rest } = decodeFrames(readBuffer)
+  readBuffer = rest
+  for (const m of messages) handle(m)
+})
+
+function send(msg) {
+  process.stdout.write(encode(msg))
+}
+
+function sendRequest(method, params) {
+  const id = nextId++
+  send({ jsonrpc: "2.0", id, method, params })
+  return id
+}
+
+function handle(raw) {
+  let data
+  try {
+    data = JSON.parse(raw)
+  } catch {
+    return
+  }
+  if (data.method === "initialize") {
+    send({ jsonrpc: "2.0", id: data.id, result: { capabilities: {} } })
+    return
+  }
+  if (data.method === "initialized") {
+    return
+  }
+  if (data.method === "workspace/didChangeConfiguration") {
+    return
+  }
+  if (data.method === "test/trigger") {
+    const method = data.params && data.params.method
+    if (method) sendRequest(method, {})
+    return
+  }
+  if (typeof data.id !== "undefined") {
+    // Respond OK to any request from client to keep transport flowing
+    send({ jsonrpc: "2.0", id: data.id, result: null })
+    return
+  }
+}

package/test/helpers.ts

@@ -0,0 +1,172 @@
+import { test, expect } from "bun:test"
+import type { Server } from "bun"
+
+/**
+ * Test helper utilities for RIRD CLI tests
+ */
+
+export interface MockProvider {
+  name: string
+  apiKey: string
+  enabled: boolean
+}
+
+/**
+ * Create a mock provider for testing
+ */
+export function createMockProvider(
+  name: string = "test-provider",
+  apiKey: string = "test-api-key",
+  enabled: boolean = true
+): MockProvider {
+  return {
+    name,
+    apiKey,
+    enabled,
+  }
+}
+
+export interface MockLicense {
+  key: string
+  valid: boolean
+  email: string
+  plan: string
+  expiresAt: string
+}
+
+/**
+ * Create a mock license for testing
+ */
+export function createMockLicense(
+  key: string = "test-license-key",
+  email: string = "test@example.com",
+  plan: string = "pro"
+): MockLicense {
+  return {
+    key,
+    valid: true,
+    email,
+    plan,
+    expiresAt: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString(),
+  }
+}
+
+/**
+ * Mock HTTP server for testing API calls
+ */
+export async function mockHttpServer(
+  responses: Record<string, any | ((req: Request) => Promise<Response>)> = {}
+): Promise<{ server: ReturnType<typeof Bun.serve>; port: number; close: () => void }> {
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port: 0,
+    async fetch(req) {
+      const url = new URL(req.url)
+      const path = url.pathname
+
+      // Default response mapping
+      if (responses[path]) {
+        const response = responses[path]
+        if (typeof response === "function") {
+          return await response(req)
+        }
+        return new Response(JSON.stringify(response), {
+          headers: { "Content-Type": "application/json" },
+        })
+      }
+
+      // Default 404
+      return new Response(JSON.stringify({ error: "Not found" }), {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+      })
+    },
+  })
+
+  return {
+    server,
+    port: server.port ?? 0,
+    close: () => {
+      server.stop()
+    },
+  }
+}
+
+/**
+ * Create a test environment with temporary config
+ */
+export async function createTestConfig() {
+  const tmpDir = await Bun.file(
+    `${Bun.env.TMPDIR || "/tmp"}/rird-test-${Date.now()}`
+  ).exists()
+
+  return {
+    configDir: `${Bun.env.TMPDIR || "/tmp"}/rird-test-${Date.now()}`,
+    configFile: `${Bun.env.TMPDIR || "/tmp"}/rird-test-${Date.now()}/config.json`,
+  }
+}
+
+/**
+ * Wait for async operations to complete with timeout
+ */
+export async function waitFor(
+  fn: () => boolean | Promise<boolean>,
+  timeout: number = 5000,
+  interval: number = 100
+): Promise<void> {
+  const startTime = Date.now()
+  while (Date.now() - startTime < timeout) {
+    try {
+      const result = await fn()
+      if (result) {
+        return
+      }
+    } catch (e) {
+      // Continue waiting
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval))
+  }
+  throw new Error(`Timeout waiting for condition after ${timeout}ms`)
+}
+
+/**
+ * Mock environment variables
+ */
+export function mockEnv(vars: Record<string, string>): () => void {
+  const original = { ...process.env }
+  Object.assign(process.env, vars)
+
+  return () => {
+    // Restore original env
+    Object.keys(process.env).forEach((key) => {
+      if (!(key in original)) {
+        delete process.env[key]
+      }
+    })
+    Object.assign(process.env, original)
+  }
+}
+
+/**
+ * Create a temporary file for testing
+ */
+export async function createTmpFile(content: string, name: string = "test"): Promise<string> {
+  const tmpDir = Bun.env.TMPDIR || "/tmp"
+  const filePath = `${tmpDir}/rird-${name}-${Date.now()}`
+  await Bun.write(filePath, content)
+  return filePath
+}
+
+/**
+ * Clean up temporary files
+ */
+export async function cleanupTmpFile(filePath: string): Promise<void> {
+  try {
+    const file = Bun.file(filePath)
+    if (await file.exists()) {
+      await Bun.file(filePath).delete?.()
+    }
+  } catch {
+    // Ignore cleanup errors
+  }
+}

package/test/ide/ide.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, test, afterEach } from "bun:test"
+import { Ide } from "../../src/ide"
+
+describe("ide", () => {
+  const original = { ...process.env }
+
+  afterEach(() => {
+    Object.keys(process.env).forEach((key) => {
+      delete process.env[key]
+    })
+    Object.assign(process.env, original)
+  })
+
+  test("should detect Visual Studio Code", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/Visual Studio Code.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("Visual Studio Code")
+  })
+
+  test("should detect Visual Studio Code Insiders", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] =
+      "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("Visual Studio Code - Insiders")
+  })
+
+  test("should detect Cursor", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/Cursor.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("Cursor")
+  })
+
+  test("should detect VSCodium", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/VSCodium.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("VSCodium")
+  })
+
+  test("should detect Windsurf", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/Windsurf.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("Windsurf")
+  })
+
+  test("should return unknown when TERM_PROGRAM is not vscode", () => {
+    process.env["TERM_PROGRAM"] = "iTerm2"
+    process.env["GIT_ASKPASS"] =
+      "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/extensions/git/dist/askpass.sh"
+
+    expect(Ide.ide()).toBe("unknown")
+  })
+
+  test("should return unknown when GIT_ASKPASS does not contain IDE name", () => {
+    process.env["TERM_PROGRAM"] = "vscode"
+    process.env["GIT_ASKPASS"] = "/path/to/unknown/askpass.sh"
+
+    expect(Ide.ide()).toBe("unknown")
+  })
+
+  test("should recognize vscode-insiders OPENCODE_CALLER", () => {
+    process.env["OPENCODE_CALLER"] = "vscode-insiders"
+
+    expect(Ide.alreadyInstalled()).toBe(true)
+  })
+
+  test("should recognize vscode OPENCODE_CALLER", () => {
+    process.env["OPENCODE_CALLER"] = "vscode"
+
+    expect(Ide.alreadyInstalled()).toBe(true)
+  })
+
+  test("should return false for unknown OPENCODE_CALLER", () => {
+    process.env["OPENCODE_CALLER"] = "unknown"
+
+    expect(Ide.alreadyInstalled()).toBe(false)
+  })
+})

package/test/installation/installation.test.ts

@@ -0,0 +1,143 @@
+import { test, expect, describe, beforeEach } from "bun:test"
+import { Installation } from "../../src/installation"
+
+describe("Installation", () => {
+  test("should have VERSION constant defined", () => {
+    expect(Installation.VERSION).toBeDefined()
+    expect(typeof Installation.VERSION).toBe("string")
+  })
+
+  test("should have CHANNEL constant defined", () => {
+    expect(Installation.CHANNEL).toBeDefined()
+    expect(typeof Installation.CHANNEL).toBe("string")
+    // CHANNEL should be one of: local, latest, or a preview channel
+    expect(["local", "latest", "preview", "alpha", "beta"]).toContain(
+      Installation.CHANNEL.split("-")[0]
+    )
+  })
+
+  test("should have USER_AGENT with proper format", () => {
+    expect(Installation.USER_AGENT).toBeDefined()
+    expect(Installation.USER_AGENT).toContain("rird")
+    expect(Installation.USER_AGENT).toContain(Installation.CHANNEL)
+    expect(Installation.USER_AGENT).toContain(Installation.VERSION)
+  })
+
+  test("isLocal() should return true for local installations", async () => {
+    const isLocal = Installation.isLocal()
+    expect(typeof isLocal).toBe("boolean")
+    // In test environment, it will be true
+    if (Installation.CHANNEL === "local") {
+      expect(isLocal).toBe(true)
+    }
+  })
+
+  test("isPreview() should return true for preview channels", () => {
+    const isPreview = Installation.isPreview()
+    expect(typeof isPreview).toBe("boolean")
+
+    if (Installation.CHANNEL !== "latest") {
+      expect(isPreview).toBe(true)
+    }
+  })
+
+  test("should have method() function", async () => {
+    expect(Installation.method).toBeDefined()
+    expect(typeof Installation.method).toBe("function")
+
+    const method = await Installation.method()
+    expect(typeof method).toBe("string")
+    expect(["npm", "yarn", "pnpm", "bun", "brew", "curl", "unknown"]).toContain(method)
+  })
+
+  test("should have latest() function", async () => {
+    expect(Installation.latest).toBeDefined()
+    expect(typeof Installation.latest).toBe("function")
+
+    // Note: This will try to fetch from npm, so it might fail in CI
+    // but we just verify the function exists and returns a promise
+    const result = Installation.latest()
+    expect(result).toBeInstanceOf(Promise)
+  })
+
+  test("should have upgrade() function", async () => {
+    expect(Installation.upgrade).toBeDefined()
+    expect(typeof Installation.upgrade).toBe("function")
+  })
+
+  test("should have forceReinstall() function", async () => {
+    expect(Installation.forceReinstall).toBeDefined()
+    expect(typeof Installation.forceReinstall).toBe("function")
+  })
+
+  test("should have info() function", async () => {
+    expect(Installation.info).toBeDefined()
+    expect(typeof Installation.info).toBe("function")
+
+    const info = await Installation.info()
+    expect(info).toBeDefined()
+    expect(info.version).toBeDefined()
+    expect(info.latest).toBeDefined()
+    expect(typeof info.version).toBe("string")
+    expect(typeof info.latest).toBe("string")
+  })
+
+  test("should have Event definitions", () => {
+    expect(Installation.Event).toBeDefined()
+    expect(Installation.Event.Updated).toBeDefined()
+    expect(Installation.Event.UpdateAvailable).toBeDefined()
+    expect(Installation.Event.UpdateFailed).toBeDefined()
+  })
+
+  test("info() should return valid installation info", async () => {
+    const info = await Installation.info()
+    expect(info.version).toMatch(/^\d+\.\d+\.\d+$|local/)
+    // latest version should also be valid format or empty
+    expect(info.latest).toBeDefined()
+  })
+
+  test("method() should detect npm if running in npm context", async () => {
+    const method = await Installation.method()
+    // Should be a valid method name
+    expect(["npm", "yarn", "pnpm", "bun", "brew", "curl", "unknown"]).toContain(method)
+  })
+
+  test("VERSION should be valid semver or 'local'", () => {
+    const version = Installation.VERSION
+    // Either local or valid semver
+    if (version !== "local") {
+      expect(version).toMatch(/^\d+\.\d+\.\d+/)
+    }
+  })
+
+  test("UpgradeFailedError should be defined", () => {
+    expect(Installation.UpgradeFailedError).toBeDefined()
+  })
+
+  test("should have Info schema type", () => {
+    expect(Installation.Info).toBeDefined()
+    // Zod schema should be callable
+    expect(typeof Installation.Info.parse).toBe("function")
+  })
+
+  test("Info schema should validate correct data", () => {
+    const validInfo = {
+      version: "1.0.0",
+      latest: "1.1.0",
+    }
+    const result = Installation.Info.parse(validInfo)
+    expect(result.version).toBe("1.0.0")
+    expect(result.latest).toBe("1.1.0")
+  })
+
+  test("Info schema should reject invalid data", () => {
+    const invalidInfo = {
+      version: 123, // Should be string
+      latest: "1.1.0",
+    }
+
+    expect(() => {
+      Installation.Info.parse(invalidInfo)
+    }).toThrow()
+  })
+})