rird 2.1.231 → 2.3.0

package/test/tool/patch.test.ts

@@ -0,0 +1,259 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { PatchTool } from "../../src/tool/patch"
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"
+import { Permission } from "../../src/permission"
+import * as fs from "fs/promises"
+
+const ctx = {
+  sessionID: "test",
+  messageID: "",
+  toolCallID: "",
+  agent: "act",
+  abort: AbortSignal.any([]),
+  metadata: () => {},
+}
+
+const patchTool = await PatchTool.init()
+
+describe("tool.patch", () => {
+  test("should validate required parameters", async () => {
+    await Instance.provide({
+      directory: "/tmp",
+      fn: async () => {
+        expect(patchTool.execute({ patchText: "" }, ctx)).rejects.toThrow("patchText is required")
+      },
+    })
+  })
+
+  test("should validate patch format", async () => {
+    await Instance.provide({
+      directory: "/tmp",
+      fn: async () => {
+        expect(patchTool.execute({ patchText: "invalid patch" }, ctx)).rejects.toThrow("Failed to parse patch")
+      },
+    })
+  })
+
+  test("should handle empty patch", async () => {
+    await Instance.provide({
+      directory: "/tmp",
+      fn: async () => {
+        const emptyPatch = `*** Begin Patch
+*** End Patch`
+
+        expect(patchTool.execute({ patchText: emptyPatch }, ctx)).rejects.toThrow("No file changes found in patch")
+      },
+    })
+  })
+
+  test.skip("should ask permission for files outside working directory", async () => {
+    await Instance.provide({
+      directory: "/tmp",
+      fn: async () => {
+        const maliciousPatch = `*** Begin Patch
+*** Add File: /etc/passwd
++malicious content
+*** End Patch`
+        patchTool.execute({ patchText: maliciousPatch }, ctx)
+        // TODO: this sucks
+        await new Promise((resolve) => setTimeout(resolve, 1000))
+        expect(Permission.pending()[ctx.sessionID]).toBeDefined()
+      },
+    })
+  })
+
+  test("should handle simple add file operation", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: test-file.txt
++Hello World
++This is a test file
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("files changed")
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify file was created
+        const filePath = path.join(fixture.path, "test-file.txt")
+        const content = await fs.readFile(filePath, "utf-8")
+        expect(content).toBe("Hello World\nThis is a test file")
+      },
+    })
+  })
+
+  test("should handle file with context update", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: config.js
++const API_KEY = "test-key"
++const DEBUG = false
++const VERSION = "1.0"
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("files changed")
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify file was created with correct content
+        const filePath = path.join(fixture.path, "config.js")
+        const content = await fs.readFile(filePath, "utf-8")
+        expect(content).toBe('const API_KEY = "test-key"\nconst DEBUG = false\nconst VERSION = "1.0"')
+      },
+    })
+  })
+
+  test("should handle multiple file operations", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: file1.txt
++Content of file 1
+*** Add File: file2.txt
++Content of file 2
+*** Add File: file3.txt
++Content of file 3
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("3 files changed")
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify all files were created
+        for (let i = 1; i <= 3; i++) {
+          const filePath = path.join(fixture.path, `file${i}.txt`)
+          const content = await fs.readFile(filePath, "utf-8")
+          expect(content).toBe(`Content of file ${i}`)
+        }
+      },
+    })
+  })
+
+  test("should create parent directories when adding nested files", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: deep/nested/file.txt
++Deep nested content
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("files changed")
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify nested file was created
+        const nestedPath = path.join(fixture.path, "deep", "nested", "file.txt")
+        const exists = await fs
+          .access(nestedPath)
+          .then(() => true)
+          .catch(() => false)
+        expect(exists).toBe(true)
+
+        const content = await fs.readFile(nestedPath, "utf-8")
+        expect(content).toBe("Deep nested content")
+      },
+    })
+  })
+
+  test("should generate proper unified diff in metadata", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        // First create a file with simple content
+        const patchText1 = `*** Begin Patch
+*** Add File: test.txt
++line 1
++line 2
++line 3
+*** End Patch`
+
+        await patchTool.execute({ patchText: patchText1 }, ctx)
+
+        // Now create an update patch
+        const patchText2 = `*** Begin Patch
+*** Update File: test.txt
+@@
+ line 1
+-line 2
++line 2 updated
+ line 3
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText: patchText2 }, ctx)
+
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.metadata.diff).toContain("@@")
+        expect(result.metadata.diff).toContain("-line 2")
+        expect(result.metadata.diff).toContain("+line 2 updated")
+      },
+    })
+  })
+
+  test("should handle complex patch with multiple operations", async () => {
+    await using fixture = await tmpdir()
+
+    await Instance.provide({
+      directory: fixture.path,
+      fn: async () => {
+        const patchText = `*** Begin Patch
+*** Add File: new.txt
++This is a new file
++with multiple lines
+*** Add File: existing.txt
++old content
++new line
++more content
+*** Add File: config.json
++{
++  "version": "1.0",
++  "debug": true
++}
+*** End Patch`
+
+        const result = await patchTool.execute({ patchText }, ctx)
+
+        expect(result.title).toContain("3 files changed")
+        expect(result.metadata.diff).toBeDefined()
+        expect(result.output).toContain("Patch applied successfully")
+
+        // Verify all files were created
+        const newPath = path.join(fixture.path, "new.txt")
+        const newContent = await fs.readFile(newPath, "utf-8")
+        expect(newContent).toBe("This is a new file\nwith multiple lines")
+
+        const existingPath = path.join(fixture.path, "existing.txt")
+        const existingContent = await fs.readFile(existingPath, "utf-8")
+        expect(existingContent).toBe("old content\nnew line\nmore content")
+
+        const configPath = path.join(fixture.path, "config.json")
+        const configContent = await fs.readFile(configPath, "utf-8")
+        expect(configContent).toBe('{\n  "version": "1.0",\n  "debug": true\n}')
+      },
+    })
+  })
+})

package/test/tool/read.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { ReadTool } from "../../src/tool/read"
+import { Instance } from "../../src/project/instance"
+import { tmpdir } from "../fixture/fixture"
+
+const ctx = {
+  sessionID: "test",
+  messageID: "",
+  callID: "",
+  agent: "act",
+  abort: AbortSignal.any([]),
+  metadata: () => {},
+}
+
+describe("tool.read env file blocking", () => {
+  test.each([
+    [".env", true],
+    [".env.local", true],
+    [".env.production", true],
+    [".env.sample", false],
+    [".env.example", false],
+    [".envrc", false],
+    ["environment.ts", false],
+  ])("%s blocked=%s", async (filename, blocked) => {
+    await using tmp = await tmpdir({
+      init: (dir) => Bun.write(path.join(dir, filename), "content"),
+    })
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const read = await ReadTool.init()
+        const promise = read.execute({ filePath: path.join(tmp.path, filename) }, ctx)
+        if (blocked) {
+          await expect(promise).rejects.toThrow("blocked")
+        } else {
+          expect((await promise).output).toContain("content")
+        }
+      },
+    })
+  })
+})

package/test/util/iife.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test"
+import { iife } from "../../src/util/iife"
+
+describe("util.iife", () => {
+  test("should execute function immediately and return result", () => {
+    let called = false
+    const result = iife(() => {
+      called = true
+      return 42
+    })
+
+    expect(called).toBe(true)
+    expect(result).toBe(42)
+  })
+
+  test("should work with async functions", async () => {
+    let called = false
+    const result = await iife(async () => {
+      called = true
+      return "async result"
+    })
+
+    expect(called).toBe(true)
+    expect(result).toBe("async result")
+  })
+
+  test("should handle functions with no return value", () => {
+    let called = false
+    const result = iife(() => {
+      called = true
+    })
+
+    expect(called).toBe(true)
+    expect(result).toBeUndefined()
+  })
+})

package/test/util/lazy.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from "bun:test"
+import { lazy } from "../../src/util/lazy"
+
+describe("util.lazy", () => {
+  test("should call function only once", () => {
+    let callCount = 0
+    const getValue = () => {
+      callCount++
+      return "expensive value"
+    }
+
+    const lazyValue = lazy(getValue)
+
+    expect(callCount).toBe(0)
+
+    const result1 = lazyValue()
+    expect(result1).toBe("expensive value")
+    expect(callCount).toBe(1)
+
+    const result2 = lazyValue()
+    expect(result2).toBe("expensive value")
+    expect(callCount).toBe(1)
+  })
+
+  test("should preserve the same reference", () => {
+    const obj = { value: 42 }
+    const lazyObj = lazy(() => obj)
+
+    const result1 = lazyObj()
+    const result2 = lazyObj()
+
+    expect(result1).toBe(obj)
+    expect(result2).toBe(obj)
+    expect(result1).toBe(result2)
+  })
+
+  test("should work with different return types", () => {
+    const lazyString = lazy(() => "string")
+    const lazyNumber = lazy(() => 123)
+    const lazyBoolean = lazy(() => true)
+    const lazyNull = lazy(() => null)
+    const lazyUndefined = lazy(() => undefined)
+
+    expect(lazyString()).toBe("string")
+    expect(lazyNumber()).toBe(123)
+    expect(lazyBoolean()).toBe(true)
+    expect(lazyNull()).toBe(null)
+    expect(lazyUndefined()).toBe(undefined)
+  })
+})

package/test/util/license.test.ts

@@ -0,0 +1,235 @@
+import { test, expect, describe, beforeEach, afterEach } from "bun:test"
+import path from "path"
+import os from "os"
+import fs from "fs"
+import {
+  validateLicense,
+  saveLicenseKey,
+  clearLicenseCache,
+  getValidatedLicenseKey,
+} from "../../src/util/license"
+import { createMockLicense, mockEnv, mockHttpServer } from "../helpers"
+
+describe("License Validation", () => {
+  let restoreEnv: () => void
+  let backupLicenseKeyPath: string | null = null
+
+  beforeEach(() => {
+    // Clear license cache before each test
+    clearLicenseCache()
+    process.env.RIRD_LICENSE_KEY = undefined as any
+
+    // Tests should not depend on a developer machine's real license file.
+    const realLicenseKeyPath = path.join(os.homedir(), ".rird", "license.key")
+    if (fs.existsSync(realLicenseKeyPath)) {
+      backupLicenseKeyPath = `${realLicenseKeyPath}.bak-test-${Date.now()}`
+      fs.renameSync(realLicenseKeyPath, backupLicenseKeyPath)
+    }
+  })
+
+  afterEach(() => {
+    clearLicenseCache()
+    if (restoreEnv) {
+      restoreEnv()
+    }
+
+    const realLicenseKeyPath = path.join(os.homedir(), ".rird", "license.key")
+    if (backupLicenseKeyPath) {
+      try {
+        if (fs.existsSync(realLicenseKeyPath)) fs.unlinkSync(realLicenseKeyPath)
+        fs.renameSync(backupLicenseKeyPath, realLicenseKeyPath)
+      } catch {
+        // Best-effort restore
+      } finally {
+        backupLicenseKeyPath = null
+      }
+    }
+  })
+
+  test("should fail when no license key exists", async () => {
+    // Ensure no license key is set
+    delete process.env.RIRD_LICENSE_KEY
+
+    const result = await validateLicense()
+    expect(result.valid).toBe(false)
+    expect(result.message).toContain("No license key found")
+  })
+
+  test("should load license key from environment variable", async () => {
+    const mockLicense = createMockLicense("env-test-key", "user@example.com", "starter")
+    restoreEnv = mockEnv({ RIRD_LICENSE_KEY: mockLicense.key })
+
+    // Note: This will fail validation since we don't have a real server
+    // but we can verify the key is read
+    const result = await validateLicense()
+    expect(result).toBeDefined()
+    // Will fail because server is unreachable, but key was read
+    expect(result.valid).toBe(false) // No real server to validate
+  })
+
+  test("should save and retrieve license key from file", async () => {
+    const testKey = "test-license-key-12345"
+    const licenseDir = path.join(os.homedir(), ".rird")
+
+    // Ensure directory exists
+    if (!fs.existsSync(licenseDir)) {
+      fs.mkdirSync(licenseDir, { recursive: true, mode: 0o700 })
+    }
+
+    try {
+      saveLicenseKey(testKey)
+
+      const licenseKeyPath = path.join(licenseDir, "license.key")
+      expect(fs.existsSync(licenseKeyPath)).toBe(true)
+
+      const savedKey = fs.readFileSync(licenseKeyPath, "utf-8").trim()
+      expect(savedKey).toBe(testKey)
+    } finally {
+      // Cleanup
+      const licenseKeyPath = path.join(licenseDir, "license.key")
+      if (fs.existsSync(licenseKeyPath)) {
+        fs.unlinkSync(licenseKeyPath)
+      }
+    }
+  })
+
+  test("should handle invalid license gracefully", async () => {
+    const testKey = "invalid-key"
+    restoreEnv = mockEnv({ RIRD_LICENSE_KEY: testKey })
+
+    const result = await validateLicense()
+    expect(result.valid).toBe(false)
+    expect(result.message).toBeDefined()
+  })
+
+  test("should cache valid license validation", async () => {
+    // This test verifies caching behavior
+    const licenseDir = path.join(os.homedir(), ".rird")
+    const cacheFile = path.join(licenseDir, "license_cache.json")
+
+    try {
+      // Clear existing cache
+      if (fs.existsSync(cacheFile)) {
+        fs.unlinkSync(cacheFile)
+      }
+
+      // Create fake valid cache
+      if (!fs.existsSync(licenseDir)) {
+        fs.mkdirSync(licenseDir, { recursive: true, mode: 0o700 })
+      }
+
+      const cacheData = {
+        license_key: "cached-test-key",
+        valid: true,
+        email: "cached@example.com",
+        plan: "pro",
+        cached_at: new Date().toISOString(),
+        providers: {},
+      }
+
+      fs.writeFileSync(cacheFile, JSON.stringify(cacheData), { mode: 0o600 })
+
+      // Set env to match cached key
+      restoreEnv = mockEnv({ RIRD_LICENSE_KEY: "cached-test-key" })
+
+      const result = await validateLicense()
+      expect(result.valid).toBe(true)
+      expect(result.message).toContain("cached")
+    } finally {
+      if (fs.existsSync(cacheFile)) {
+        fs.unlinkSync(cacheFile)
+      }
+    }
+  })
+
+  test("should clear license cache", () => {
+    const licenseDir = path.join(os.homedir(), ".rird")
+    const cacheFile = path.join(licenseDir, "license_cache.json")
+
+    try {
+      // Create cache file
+      if (!fs.existsSync(licenseDir)) {
+        fs.mkdirSync(licenseDir, { recursive: true, mode: 0o700 })
+      }
+      fs.writeFileSync(cacheFile, JSON.stringify({}), { mode: 0o600 })
+
+      // Verify it exists
+      expect(fs.existsSync(cacheFile)).toBe(true)
+
+      // Clear it
+      clearLicenseCache()
+
+      // Verify it's gone
+      expect(fs.existsSync(cacheFile)).toBe(false)
+    } finally {
+      if (fs.existsSync(cacheFile)) {
+        fs.unlinkSync(cacheFile)
+      }
+    }
+  })
+
+  test("should handle network errors gracefully", async () => {
+    const testKey = "network-test-key"
+    restoreEnv = mockEnv({ RIRD_LICENSE_KEY: testKey })
+
+    // This will fail due to no network, which is expected
+    const result = await validateLicense()
+    expect(result.valid).toBe(false)
+    expect(result.message).toBeDefined()
+  })
+
+  test("should get validated license key after validation", async () => {
+    const licenseDir = path.join(os.homedir(), ".rird")
+    const cacheFile = path.join(licenseDir, "license_cache.json")
+
+    try {
+      // Create fake valid cache
+      if (!fs.existsSync(licenseDir)) {
+        fs.mkdirSync(licenseDir, { recursive: true, mode: 0o700 })
+      }
+
+      const cacheData = {
+        license_key: "get-key-test",
+        valid: true,
+        email: "test@example.com",
+        plan: "pro",
+        cached_at: new Date().toISOString(),
+        providers: {},
+      }
+
+      fs.writeFileSync(cacheFile, JSON.stringify(cacheData), { mode: 0o600 })
+
+      restoreEnv = mockEnv({ RIRD_LICENSE_KEY: "get-key-test" })
+
+      await validateLicense()
+      const key = getValidatedLicenseKey()
+      expect(key).toBe("get-key-test")
+    } finally {
+      if (fs.existsSync(cacheFile)) {
+        fs.unlinkSync(cacheFile)
+      }
+    }
+  })
+
+  test("should trim whitespace from license key", async () => {
+    const testKey = "  test-key-with-spaces  "
+    const licenseDir = path.join(os.homedir(), ".rird")
+
+    if (!fs.existsSync(licenseDir)) {
+      fs.mkdirSync(licenseDir, { recursive: true, mode: 0o700 })
+    }
+
+    try {
+      saveLicenseKey(testKey)
+
+      const licenseKeyPath = path.join(licenseDir, "license.key")
+      const savedKey = fs.readFileSync(licenseKeyPath, "utf-8")
+      expect(savedKey).toBe("test-key-with-spaces") // Should be trimmed
+    } finally {
+      const licenseKeyPath = path.join(licenseDir, "license.key")
+      if (fs.existsSync(licenseKeyPath)) {
+        fs.unlinkSync(licenseKeyPath)
+      }
+    }
+  })
+})

package/test/util/timeout.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, test } from "bun:test"
+import { withTimeout } from "../../src/util/timeout"
+
+describe("util.timeout", () => {
+  test("should resolve when promise completes before timeout", async () => {
+    const fastPromise = new Promise<string>((resolve) => {
+      setTimeout(() => resolve("fast"), 10)
+    })
+
+    const result = await withTimeout(fastPromise, 100)
+    expect(result).toBe("fast")
+  })
+
+  test("should reject when promise exceeds timeout", async () => {
+    const slowPromise = new Promise<string>((resolve) => {
+      setTimeout(() => resolve("slow"), 200)
+    })
+
+    await expect(withTimeout(slowPromise, 50)).rejects.toThrow("Operation timed out after 50ms")
+  })
+})

package/test/util/wildcard.test.ts

@@ -0,0 +1,55 @@
+import { test, expect } from "bun:test"
+import { Wildcard } from "../../src/util/wildcard"
+
+test("match handles glob tokens", () => {
+  expect(Wildcard.match("file1.txt", "file?.txt")).toBe(true)
+  expect(Wildcard.match("file12.txt", "file?.txt")).toBe(false)
+  expect(Wildcard.match("foo+bar", "foo+bar")).toBe(true)
+})
+
+test("all picks the most specific pattern", () => {
+  const rules = {
+    "*": "deny",
+    "git *": "ask",
+    "git status": "allow",
+  }
+  expect(Wildcard.all("git status", rules)).toBe("allow")
+  expect(Wildcard.all("git log", rules)).toBe("ask")
+  expect(Wildcard.all("echo hi", rules)).toBe("deny")
+})
+
+test("allStructured matches command sequences", () => {
+  const rules = {
+    "git *": "ask",
+    "git status*": "allow",
+  }
+  expect(Wildcard.allStructured({ head: "git", tail: ["status", "--short"] }, rules)).toBe("allow")
+  expect(Wildcard.allStructured({ head: "npm", tail: ["run", "build", "--watch"] }, { "npm run *": "allow" })).toBe(
+    "allow",
+  )
+  expect(Wildcard.allStructured({ head: "ls", tail: ["-la"] }, rules)).toBeUndefined()
+})
+
+test("allStructured prioritizes flag-specific patterns", () => {
+  const rules = {
+    "find *": "allow",
+    "find * -delete*": "ask",
+    "sort*": "allow",
+    "sort -o *": "ask",
+  }
+  expect(Wildcard.allStructured({ head: "find", tail: ["src", "-delete"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "find", tail: ["src", "-print"] }, rules)).toBe("allow")
+  expect(Wildcard.allStructured({ head: "sort", tail: ["-o", "out.txt"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "sort", tail: ["--reverse"] }, rules)).toBe("allow")
+})
+
+test("allStructured handles sed flags", () => {
+  const rules = {
+    "sed * -i*": "ask",
+    "sed -n*": "allow",
+  }
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-i", "file"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-i.bak", "file"] }, rules)).toBe("ask")
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-n", "1p", "file"] }, rules)).toBe("allow")
+  expect(Wildcard.allStructured({ head: "sed", tail: ["-i", "-n", "/./p", "myfile.txt"] }, rules)).toBe("ask")
+})