rird 1.0.200

package/src/tests/config.test.ts

@@ -0,0 +1,664 @@
+import { describe, test, expect } from "bun:test"
+import z from "zod"
+import { Config } from "../config/config"
+
+describe("Config.Info schema", () => {
+  test("config schema has expected top-level fields", () => {
+    const shape = Config.Info.shape
+
+    expect(shape.$schema).toBeDefined()
+    expect(shape.theme).toBeDefined()
+    expect(shape.keybinds).toBeDefined()
+    expect(shape.command).toBeDefined()
+    expect(shape.plugin).toBeDefined()
+    expect(shape.model).toBeDefined()
+    expect(shape.agent).toBeDefined()
+    expect(shape.provider).toBeDefined()
+    expect(shape.mcp).toBeDefined()
+    expect(shape.permission).toBeDefined()
+    expect(shape.tools).toBeDefined()
+  })
+
+  test("empty config is valid", () => {
+    const result = Config.Info.safeParse({})
+    expect(result.success).toBe(true)
+  })
+
+  test("config with schema field validates", () => {
+    const config = {
+      $schema: "https://rird.ai/config.json",
+    }
+
+    const result = Config.Info.safeParse(config)
+    expect(result.success).toBe(true)
+  })
+
+  test("config with model string validates", () => {
+    const config = {
+      model: "anthropic/claude-3-opus",
+    }
+
+    const result = Config.Info.safeParse(config)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.model).toBe("anthropic/claude-3-opus")
+    }
+  })
+
+  test("config with invalid field fails strict validation", () => {
+    const config = {
+      invalid_field: "should fail",
+    }
+
+    const result = Config.Info.safeParse(config)
+    expect(result.success).toBe(false)
+  })
+})
+
+describe("Config.Permission enum", () => {
+  test("permission has correct values", () => {
+    const validValues = ["ask", "allow", "deny"]
+
+    for (const value of validValues) {
+      const result = Config.Permission.safeParse(value)
+      expect(result.success).toBe(true)
+    }
+  })
+
+  test("invalid permission value fails", () => {
+    const result = Config.Permission.safeParse("invalid")
+    expect(result.success).toBe(false)
+  })
+})
+
+describe("Config.Agent schema", () => {
+  test("agent config with model validates", () => {
+    const agent = {
+      model: "openai/gpt-4",
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+  })
+
+  test("agent config with temperature validates", () => {
+    const agent = {
+      temperature: 0.7,
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.temperature).toBe(0.7)
+    }
+  })
+
+  test("agent config with top_p validates", () => {
+    const agent = {
+      top_p: 0.9,
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.top_p).toBe(0.9)
+    }
+  })
+
+  test("agent config with prompt validates", () => {
+    const agent = {
+      prompt: "You are a helpful coding assistant",
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.prompt).toBe("You are a helpful coding assistant")
+    }
+  })
+
+  test("agent config with tools validates", () => {
+    const agent = {
+      tools: {
+        bash: true,
+        edit: false,
+        read: true,
+      },
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.tools?.bash).toBe(true)
+      expect(result.data.tools?.edit).toBe(false)
+    }
+  })
+
+  test("agent config with disable flag validates", () => {
+    const agent = {
+      disable: true,
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.disable).toBe(true)
+    }
+  })
+
+  test("agent config with mode validates", () => {
+    const modes = ["subagent", "primary", "all"]
+
+    for (const mode of modes) {
+      const agent = { mode }
+      const result = Config.Agent.safeParse(agent)
+      expect(result.success).toBe(true)
+    }
+  })
+
+  test("agent config with invalid mode fails", () => {
+    const agent = {
+      mode: "invalid_mode",
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(false)
+  })
+
+  test("agent config with color validates hex format", () => {
+    const validColors = ["#FF5733", "#000000", "#FFFFFF", "#abc123"]
+
+    for (const color of validColors) {
+      const agent = { color }
+      const result = Config.Agent.safeParse(agent)
+      expect(result.success).toBe(true)
+    }
+  })
+
+  test("agent config with invalid color fails", () => {
+    const invalidColors = ["red", "#FFF", "FF5733", "#GGGGGG"]
+
+    for (const color of invalidColors) {
+      const agent = { color }
+      const result = Config.Agent.safeParse(agent)
+      expect(result.success).toBe(false)
+    }
+  })
+
+  test("agent config with maxSteps validates positive integer", () => {
+    const agent = {
+      maxSteps: 50,
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.maxSteps).toBe(50)
+    }
+  })
+
+  test("agent config with permission validates", () => {
+    const agent = {
+      permission: {
+        edit: "allow",
+        bash: "ask",
+        webfetch: "deny",
+      },
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.permission?.edit).toBe("allow")
+      expect(result.data.permission?.bash).toBe("ask")
+    }
+  })
+
+  test("agent config with bash permission record validates", () => {
+    const agent = {
+      permission: {
+        bash: {
+          "*": "deny",
+          "echo *": "allow",
+          "ls *": "allow",
+        },
+      },
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.permission?.bash).toEqual({
+        "*": "deny",
+        "echo *": "allow",
+        "ls *": "allow",
+      })
+    }
+  })
+
+  test("agent config allows additional properties", () => {
+    const agent = {
+      model: "test/model",
+      customProperty: "custom value",
+    }
+
+    const result = Config.Agent.safeParse(agent)
+    expect(result.success).toBe(true)
+  })
+})
+
+describe("Config.Command schema", () => {
+  test("command with template validates", () => {
+    const command = {
+      template: "Run npm test",
+    }
+
+    const result = Config.Command.safeParse(command)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.template).toBe("Run npm test")
+    }
+  })
+
+  test("command with all fields validates", () => {
+    const command = {
+      template: "Run the build process",
+      description: "Builds the project",
+      agent: "act",
+      model: "anthropic/claude-3-opus",
+      subtask: true,
+    }
+
+    const result = Config.Command.safeParse(command)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.template).toBe("Run the build process")
+      expect(result.data.description).toBe("Builds the project")
+      expect(result.data.agent).toBe("act")
+      expect(result.data.subtask).toBe(true)
+    }
+  })
+
+  test("command without template fails", () => {
+    const command = {
+      description: "Missing template",
+    }
+
+    const result = Config.Command.safeParse(command)
+    expect(result.success).toBe(false)
+  })
+})
+
+describe("Config.Mcp schemas", () => {
+  test("local mcp config validates", () => {
+    const mcp = {
+      type: "local" as const,
+      command: ["node", "server.js"],
+    }
+
+    const result = Config.McpLocal.safeParse(mcp)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.type).toBe("local")
+      expect(result.data.command).toEqual(["node", "server.js"])
+    }
+  })
+
+  test("local mcp with environment validates", () => {
+    const mcp = {
+      type: "local" as const,
+      command: ["python", "-m", "server"],
+      environment: {
+        API_KEY: "secret",
+        DEBUG: "true",
+      },
+    }
+
+    const result = Config.McpLocal.safeParse(mcp)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.environment?.API_KEY).toBe("secret")
+    }
+  })
+
+  test("local mcp with enabled flag validates", () => {
+    const mcp = {
+      type: "local" as const,
+      command: ["npx", "mcp-server"],
+      enabled: false,
+    }
+
+    const result = Config.McpLocal.safeParse(mcp)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.enabled).toBe(false)
+    }
+  })
+
+  test("local mcp with timeout validates", () => {
+    const mcp = {
+      type: "local" as const,
+      command: ["mcp"],
+      timeout: 10000,
+    }
+
+    const result = Config.McpLocal.safeParse(mcp)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.timeout).toBe(10000)
+    }
+  })
+
+  test("remote mcp config validates", () => {
+    const mcp = {
+      type: "remote" as const,
+      url: "https://mcp.example.com/api",
+    }
+
+    const result = Config.McpRemote.safeParse(mcp)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.type).toBe("remote")
+      expect(result.data.url).toBe("https://mcp.example.com/api")
+    }
+  })
+
+  test("remote mcp with headers validates", () => {
+    const mcp = {
+      type: "remote" as const,
+      url: "https://mcp.example.com",
+      headers: {
+        Authorization: "Bearer token123",
+        "Content-Type": "application/json",
+      },
+    }
+
+    const result = Config.McpRemote.safeParse(mcp)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.headers?.Authorization).toBe("Bearer token123")
+    }
+  })
+
+  test("remote mcp with oauth config validates", () => {
+    const mcp = {
+      type: "remote" as const,
+      url: "https://mcp.example.com",
+      oauth: {
+        clientId: "client123",
+        clientSecret: "secret456",
+        scope: "read write",
+      },
+    }
+
+    const result = Config.McpRemote.safeParse(mcp)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.oauth).toEqual({
+        clientId: "client123",
+        clientSecret: "secret456",
+        scope: "read write",
+      })
+    }
+  })
+
+  test("remote mcp with oauth disabled validates", () => {
+    const mcp = {
+      type: "remote" as const,
+      url: "https://mcp.example.com",
+      oauth: false,
+    }
+
+    const result = Config.McpRemote.safeParse(mcp)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.oauth).toBe(false)
+    }
+  })
+
+  test("discriminated union Mcp validates local", () => {
+    const mcp = {
+      type: "local" as const,
+      command: ["test"],
+    }
+
+    const result = Config.Mcp.safeParse(mcp)
+    expect(result.success).toBe(true)
+  })
+
+  test("discriminated union Mcp validates remote", () => {
+    const mcp = {
+      type: "remote" as const,
+      url: "https://example.com",
+    }
+
+    const result = Config.Mcp.safeParse(mcp)
+    expect(result.success).toBe(true)
+  })
+})
+
+describe("Config.Keybinds schema", () => {
+  test("keybinds has sensible defaults", () => {
+    const result = Config.Keybinds.safeParse({})
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.leader).toBe("ctrl+x")
+      expect(result.data.app_exit).toBe("ctrl+c,ctrl+d,<leader>q")
+      expect(result.data.session_new).toBe("<leader>n")
+      expect(result.data.input_submit).toBe("return")
+    }
+  })
+
+  test("keybinds can be customized", () => {
+    const keybinds = {
+      leader: "ctrl+a",
+      app_exit: "ctrl+q",
+    }
+
+    const result = Config.Keybinds.safeParse(keybinds)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.leader).toBe("ctrl+a")
+      expect(result.data.app_exit).toBe("ctrl+q")
+    }
+  })
+
+  test("keybinds rejects invalid fields (strict mode)", () => {
+    const keybinds = {
+      invalid_keybind: "ctrl+x",
+    }
+
+    const result = Config.Keybinds.safeParse(keybinds)
+    expect(result.success).toBe(false)
+  })
+})
+
+describe("Config.Provider schema", () => {
+  test("provider with options validates", () => {
+    const provider = {
+      options: {
+        apiKey: "sk-123",
+        baseURL: "https://api.example.com",
+      },
+    }
+
+    const result = Config.Provider.safeParse(provider)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.options?.apiKey).toBe("sk-123")
+      expect(result.data.options?.baseURL).toBe("https://api.example.com")
+    }
+  })
+
+  test("provider with whitelist validates", () => {
+    const provider = {
+      whitelist: ["gpt-4", "gpt-4-turbo"],
+    }
+
+    const result = Config.Provider.safeParse(provider)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.whitelist).toEqual(["gpt-4", "gpt-4-turbo"])
+    }
+  })
+
+  test("provider with blacklist validates", () => {
+    const provider = {
+      blacklist: ["gpt-3.5-turbo"],
+    }
+
+    const result = Config.Provider.safeParse(provider)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.blacklist).toEqual(["gpt-3.5-turbo"])
+    }
+  })
+
+  test("provider with timeout number validates", () => {
+    const provider = {
+      options: {
+        timeout: 60000,
+      },
+    }
+
+    const result = Config.Provider.safeParse(provider)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.options?.timeout).toBe(60000)
+    }
+  })
+
+  test("provider with timeout false validates", () => {
+    const provider = {
+      options: {
+        timeout: false,
+      },
+    }
+
+    const result = Config.Provider.safeParse(provider)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.options?.timeout).toBe(false)
+    }
+  })
+})
+
+describe("Config share field", () => {
+  test("share accepts valid values", () => {
+    const validValues = ["manual", "auto", "disabled"]
+
+    for (const share of validValues) {
+      const result = Config.Info.safeParse({ share })
+      expect(result.success).toBe(true)
+    }
+  })
+
+  test("share rejects invalid value", () => {
+    const result = Config.Info.safeParse({ share: "invalid" })
+    expect(result.success).toBe(false)
+  })
+})
+
+describe("Config experimental field", () => {
+  test("experimental with batch_tool validates", () => {
+    const config = {
+      experimental: {
+        batch_tool: true,
+      },
+    }
+
+    const result = Config.Info.safeParse(config)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.experimental?.batch_tool).toBe(true)
+    }
+  })
+
+  test("experimental with openTelemetry validates", () => {
+    const config = {
+      experimental: {
+        openTelemetry: true,
+      },
+    }
+
+    const result = Config.Info.safeParse(config)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.experimental?.openTelemetry).toBe(true)
+    }
+  })
+
+  test("experimental with chatMaxRetries validates", () => {
+    const config = {
+      experimental: {
+        chatMaxRetries: 3,
+      },
+    }
+
+    const result = Config.Info.safeParse(config)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.experimental?.chatMaxRetries).toBe(3)
+    }
+  })
+})
+
+describe("Config full example", () => {
+  test("comprehensive config validates", () => {
+    const config = {
+      $schema: "https://rird.ai/config.json",
+      theme: "dark",
+      model: "anthropic/claude-3-opus",
+      small_model: "anthropic/claude-3-haiku",
+      username: "developer",
+      default_agent: "act",
+      share: "auto",
+      autoupdate: true,
+      snapshot: true,
+      disabled_providers: ["google"],
+      enabled_providers: ["anthropic", "openai"],
+      agent: {
+        act: {
+          model: "anthropic/claude-3-opus",
+          temperature: 0.7,
+        },
+        plan: {
+          disable: true,
+        },
+      },
+      command: {
+        test: {
+          template: "Run all tests",
+          description: "Execute test suite",
+        },
+      },
+      provider: {
+        anthropic: {
+          options: {
+            apiKey: "sk-ant-123",
+          },
+        },
+      },
+      permission: {
+        edit: "ask",
+        bash: {
+          "*": "ask",
+          "git *": "allow",
+        },
+      },
+      tools: {
+        bash: true,
+        edit: true,
+      },
+    }
+
+    const result = Config.Info.safeParse(config)
+    expect(result.success).toBe(true)
+    if (result.success) {
+      expect(result.data.model).toBe("anthropic/claude-3-opus")
+      expect(result.data.username).toBe("developer")
+      expect(result.data.agent?.act?.temperature).toBe(0.7)
+      expect(result.data.agent?.plan?.disable).toBe(true)
+    }
+  })
+})