rird 1.0.200

package/test/keybind.test.ts

@@ -0,0 +1,421 @@
+import { describe, test, expect } from "bun:test"
+import { Keybind } from "../src/util/keybind"
+
+describe("Keybind.toString", () => {
+  test("should convert simple key to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "f" }
+    expect(Keybind.toString(info)).toBe("f")
+  })
+
+  test("should convert ctrl modifier to string", () => {
+    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    expect(Keybind.toString(info)).toBe("ctrl+x")
+  })
+
+  test("should convert leader key to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
+    expect(Keybind.toString(info)).toBe("<leader> f")
+  })
+
+  test("should convert multiple modifiers to string", () => {
+    const info: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
+    expect(Keybind.toString(info)).toBe("ctrl+alt+g")
+  })
+
+  test("should convert all modifiers to string", () => {
+    const info: Keybind.Info = { ctrl: true, meta: true, shift: true, leader: true, name: "h" }
+    expect(Keybind.toString(info)).toBe("<leader> ctrl+alt+shift+h")
+  })
+
+  test("should convert shift modifier to string", () => {
+    const info: Keybind.Info = {
+      ctrl: false,
+      meta: false,
+      shift: true,
+      leader: false,
+      name: "return",
+    }
+    expect(Keybind.toString(info)).toBe("shift+return")
+  })
+
+  test("should convert function key to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "f2" }
+    expect(Keybind.toString(info)).toBe("f2")
+  })
+
+  test("should convert special key to string", () => {
+    const info: Keybind.Info = {
+      ctrl: false,
+      meta: false,
+      shift: false,
+      leader: false,
+      name: "pgup",
+    }
+    expect(Keybind.toString(info)).toBe("pgup")
+  })
+
+  test("should handle empty name", () => {
+    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "" }
+    expect(Keybind.toString(info)).toBe("ctrl")
+  })
+
+  test("should handle only modifiers", () => {
+    const info: Keybind.Info = { ctrl: true, meta: true, shift: true, leader: true, name: "" }
+    expect(Keybind.toString(info)).toBe("<leader> ctrl+alt+shift")
+  })
+
+  test("should handle only leader with no other parts", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "" }
+    expect(Keybind.toString(info)).toBe("<leader>")
+  })
+
+  test("should convert super modifier to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
+    expect(Keybind.toString(info)).toBe("super+z")
+  })
+
+  test("should convert super+shift modifier to string", () => {
+    const info: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
+    expect(Keybind.toString(info)).toBe("super+shift+z")
+  })
+
+  test("should handle super with ctrl modifier", () => {
+    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, super: true, leader: false, name: "a" }
+    expect(Keybind.toString(info)).toBe("ctrl+super+a")
+  })
+
+  test("should handle super with all modifiers", () => {
+    const info: Keybind.Info = { ctrl: true, meta: true, shift: true, super: true, leader: false, name: "x" }
+    expect(Keybind.toString(info)).toBe("ctrl+alt+super+shift+x")
+  })
+
+  test("should handle undefined super field (omitted)", () => {
+    const info: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "c" }
+    expect(Keybind.toString(info)).toBe("ctrl+c")
+  })
+})
+
+describe("Keybind.match", () => {
+  test("should match identical keybinds", () => {
+    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match different key names", () => {
+    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "y" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should not match different modifiers", () => {
+    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "x" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "x" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should match leader keybinds", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match leader vs non-leader", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: true, name: "f" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "f" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should match complex keybinds", () => {
+    const a: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
+    const b: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match with one modifier different", () => {
+    const a: Keybind.Info = { ctrl: true, meta: true, shift: false, leader: false, name: "g" }
+    const b: Keybind.Info = { ctrl: true, meta: true, shift: true, leader: false, name: "g" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should match simple key without modifiers", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "a" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, leader: false, name: "a" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should match super modifier keybinds", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match super vs non-super", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: false, super: true, leader: false, name: "z" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: false, super: false, leader: false, name: "z" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+
+  test("should match undefined super with false super", () => {
+    const a: Keybind.Info = { ctrl: true, meta: false, shift: false, leader: false, name: "c" }
+    const b: Keybind.Info = { ctrl: true, meta: false, shift: false, super: false, leader: false, name: "c" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should match super+shift combination", () => {
+    const a: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
+    const b: Keybind.Info = { ctrl: false, meta: false, shift: true, super: true, leader: false, name: "z" }
+    expect(Keybind.match(a, b)).toBe(true)
+  })
+
+  test("should not match when only super differs", () => {
+    const a: Keybind.Info = { ctrl: true, meta: true, shift: true, super: true, leader: false, name: "a" }
+    const b: Keybind.Info = { ctrl: true, meta: true, shift: true, super: false, leader: false, name: "a" }
+    expect(Keybind.match(a, b)).toBe(false)
+  })
+})
+
+describe("Keybind.parse", () => {
+  test("should parse simple key", () => {
+    const result = Keybind.parse("f")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "f",
+      },
+    ])
+  })
+
+  test("should parse leader key syntax", () => {
+    const result = Keybind.parse("<leader>f")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: true,
+        name: "f",
+      },
+    ])
+  })
+
+  test("should parse ctrl modifier", () => {
+    const result = Keybind.parse("ctrl+x")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "x",
+      },
+    ])
+  })
+
+  test("should parse multiple modifiers", () => {
+    const result = Keybind.parse("ctrl+alt+u")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: true,
+        shift: false,
+        leader: false,
+        name: "u",
+      },
+    ])
+  })
+
+  test("should parse shift modifier", () => {
+    const result = Keybind.parse("shift+f2")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: true,
+        leader: false,
+        name: "f2",
+      },
+    ])
+  })
+
+  test("should parse meta/alt modifier", () => {
+    const result = Keybind.parse("meta+g")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: true,
+        shift: false,
+        leader: false,
+        name: "g",
+      },
+    ])
+  })
+
+  test("should parse leader with modifier", () => {
+    const result = Keybind.parse("<leader>h")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: true,
+        name: "h",
+      },
+    ])
+  })
+
+  test("should parse multiple keybinds separated by comma", () => {
+    const result = Keybind.parse("ctrl+c,<leader>q")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "c",
+      },
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: true,
+        name: "q",
+      },
+    ])
+  })
+
+  test("should parse shift+return combination", () => {
+    const result = Keybind.parse("shift+return")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: true,
+        leader: false,
+        name: "return",
+      },
+    ])
+  })
+
+  test("should parse ctrl+j combination", () => {
+    const result = Keybind.parse("ctrl+j")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "j",
+      },
+    ])
+  })
+
+  test("should handle 'none' value", () => {
+    const result = Keybind.parse("none")
+    expect(result).toEqual([])
+  })
+
+  test("should handle special keys", () => {
+    const result = Keybind.parse("pgup")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "pgup",
+      },
+    ])
+  })
+
+  test("should handle function keys", () => {
+    const result = Keybind.parse("f2")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "f2",
+      },
+    ])
+  })
+
+  test("should handle complex multi-modifier combination", () => {
+    const result = Keybind.parse("ctrl+alt+g")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: true,
+        shift: false,
+        leader: false,
+        name: "g",
+      },
+    ])
+  })
+
+  test("should be case insensitive", () => {
+    const result = Keybind.parse("CTRL+X")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "x",
+      },
+    ])
+  })
+
+  test("should parse super modifier", () => {
+    const result = Keybind.parse("super+z")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        super: true,
+        leader: false,
+        name: "z",
+      },
+    ])
+  })
+
+  test("should parse super with shift modifier", () => {
+    const result = Keybind.parse("super+shift+z")
+    expect(result).toEqual([
+      {
+        ctrl: false,
+        meta: false,
+        shift: true,
+        super: true,
+        leader: false,
+        name: "z",
+      },
+    ])
+  })
+
+  test("should parse multiple keybinds with super", () => {
+    const result = Keybind.parse("ctrl+-,super+z")
+    expect(result).toEqual([
+      {
+        ctrl: true,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "-",
+      },
+      {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        super: true,
+        leader: false,
+        name: "z",
+      },
+    ])
+  })
+})

package/test/lsp/client.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test, beforeEach } from "bun:test"
+import path from "path"
+import { LSPClient } from "../../src/lsp/client"
+import { LSPServer } from "../../src/lsp/server"
+import { Instance } from "../../src/project/instance"
+import { Log } from "../../src/util/log"
+
+// Minimal fake LSP server that speaks JSON-RPC over stdio
+function spawnFakeServer() {
+  const { spawn } = require("child_process")
+  const serverPath = path.join(__dirname, "../fixture/lsp/fake-lsp-server.js")
+  return {
+    process: spawn(process.execPath, [serverPath], {
+      stdio: "pipe",
+    }),
+  }
+}
+
+describe("LSPClient interop", () => {
+  beforeEach(async () => {
+    await Log.init({ print: true })
+  })
+
+  test("handles workspace/workspaceFolders request", async () => {
+    const handle = spawnFakeServer() as any
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: process.cwd(),
+        }),
+    })
+
+    await client.connection.sendNotification("test/trigger", {
+      method: "workspace/workspaceFolders",
+    })
+
+    await new Promise((r) => setTimeout(r, 100))
+
+    expect(client.connection).toBeDefined()
+
+    await client.shutdown()
+  })
+
+  test("handles client/registerCapability request", async () => {
+    const handle = spawnFakeServer() as any
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: process.cwd(),
+        }),
+    })
+
+    await client.connection.sendNotification("test/trigger", {
+      method: "client/registerCapability",
+    })
+
+    await new Promise((r) => setTimeout(r, 100))
+
+    expect(client.connection).toBeDefined()
+
+    await client.shutdown()
+  })
+
+  test("handles client/unregisterCapability request", async () => {
+    const handle = spawnFakeServer() as any
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: process.cwd(),
+        }),
+    })
+
+    await client.connection.sendNotification("test/trigger", {
+      method: "client/unregisterCapability",
+    })
+
+    await new Promise((r) => setTimeout(r, 100))
+
+    expect(client.connection).toBeDefined()
+
+    await client.shutdown()
+  })
+})

package/test/mcp/headers.test.ts

@@ -0,0 +1,153 @@
+import { test, expect, mock, beforeEach } from "bun:test"
+
+// Track what options were passed to each transport constructor
+const transportCalls: Array<{
+  type: "streamable" | "sse"
+  url: string
+  options: { authProvider?: unknown; requestInit?: RequestInit }
+}> = []
+
+// Mock the transport constructors to capture their arguments
+mock.module("@modelcontextprotocol/sdk/client/streamableHttp.js", () => ({
+  StreamableHTTPClientTransport: class MockStreamableHTTP {
+    constructor(url: URL, options?: { authProvider?: unknown; requestInit?: RequestInit }) {
+      transportCalls.push({
+        type: "streamable",
+        url: url.toString(),
+        options: options ?? {},
+      })
+    }
+    async start() {
+      throw new Error("Mock transport cannot connect")
+    }
+  },
+}))
+
+mock.module("@modelcontextprotocol/sdk/client/sse.js", () => ({
+  SSEClientTransport: class MockSSE {
+    constructor(url: URL, options?: { authProvider?: unknown; requestInit?: RequestInit }) {
+      transportCalls.push({
+        type: "sse",
+        url: url.toString(),
+        options: options ?? {},
+      })
+    }
+    async start() {
+      throw new Error("Mock transport cannot connect")
+    }
+  },
+}))
+
+beforeEach(() => {
+  transportCalls.length = 0
+})
+
+// Import MCP after mocking
+const { MCP } = await import("../../src/mcp/index")
+const { Instance } = await import("../../src/project/instance")
+const { tmpdir } = await import("../fixture/fixture")
+
+test("headers are passed to transports when oauth is enabled (default)", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        `${dir}/opencode.json`,
+        JSON.stringify({
+          $schema: "https://rird.ai/config.json",
+          mcp: {
+            "test-server": {
+              type: "remote",
+              url: "https://example.com/mcp",
+              headers: {
+                Authorization: "Bearer test-token",
+                "X-Custom-Header": "custom-value",
+              },
+            },
+          },
+        }),
+      )
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      // Trigger MCP initialization - it will fail to connect but we can check the transport options
+      await MCP.add("test-server", {
+        type: "remote",
+        url: "https://example.com/mcp",
+        headers: {
+          Authorization: "Bearer test-token",
+          "X-Custom-Header": "custom-value",
+        },
+      }).catch(() => {})
+
+      // Both transports should have been created with headers
+      expect(transportCalls.length).toBeGreaterThanOrEqual(1)
+
+      for (const call of transportCalls) {
+        expect(call.options.requestInit).toBeDefined()
+        expect(call.options.requestInit?.headers).toEqual({
+          Authorization: "Bearer test-token",
+          "X-Custom-Header": "custom-value",
+        })
+        // OAuth should be enabled by default, so authProvider should exist
+        expect(call.options.authProvider).toBeDefined()
+      }
+    },
+  })
+})
+
+test("headers are passed to transports when oauth is explicitly disabled", async () => {
+  await using tmp = await tmpdir()
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      transportCalls.length = 0
+
+      await MCP.add("test-server-no-oauth", {
+        type: "remote",
+        url: "https://example.com/mcp",
+        oauth: false,
+        headers: {
+          Authorization: "Bearer test-token",
+        },
+      }).catch(() => {})
+
+      expect(transportCalls.length).toBeGreaterThanOrEqual(1)
+
+      for (const call of transportCalls) {
+        expect(call.options.requestInit).toBeDefined()
+        expect(call.options.requestInit?.headers).toEqual({
+          Authorization: "Bearer test-token",
+        })
+        // OAuth is disabled, so no authProvider
+        expect(call.options.authProvider).toBeUndefined()
+      }
+    },
+  })
+})
+
+test("no requestInit when headers are not provided", async () => {
+  await using tmp = await tmpdir()
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      transportCalls.length = 0
+
+      await MCP.add("test-server-no-headers", {
+        type: "remote",
+        url: "https://example.com/mcp",
+      }).catch(() => {})
+
+      expect(transportCalls.length).toBeGreaterThanOrEqual(1)
+
+      for (const call of transportCalls) {
+        // No headers means requestInit should be undefined
+        expect(call.options.requestInit).toBeUndefined()
+      }
+    },
+  })
+})