jonsoc 1.1.49 → 1.1.50

package/test/mcp/oauth-browser.test.ts

@@ -1,261 +0,0 @@
-import { test, expect, mock, beforeEach } from "bun:test"
-import { EventEmitter } from "events"
-
-// Track open() calls and control failure behavior
-let openShouldFail = false
-let openCalledWith: string | undefined
-
-mock.module("open", () => ({
-  default: async (url: string) => {
-    openCalledWith = url
-    // Return a mock subprocess that emits an error if openShouldFail is true
-    const subprocess = new EventEmitter()
-    if (openShouldFail) {
-      // Emit error asynchronously like a real subprocess would
-      setTimeout(() => {
-        subprocess.emit("error", new Error("spawn xdg-open ENOENT"))
-      }, 10)
-    }
-    return subprocess
-  },
-}))
-
-// Mock UnauthorizedError
-class MockUnauthorizedError extends Error {
-  constructor() {
-    super("Unauthorized")
-    this.name = "UnauthorizedError"
-  }
-}
-
-// Track what options were passed to each transport constructor
-const transportCalls: Array<{
-  type: "streamable" | "sse"
-  url: string
-  options: { authProvider?: unknown }
-}> = []
-
-// Mock the transport constructors
-mock.module("@modelcontextprotocol/sdk/client/streamableHttp.js", () => ({
-  StreamableHTTPClientTransport: class MockStreamableHTTP {
-    url: string
-    authProvider: { redirectToAuthorization?: (url: URL) => Promise<void> } | undefined
-    constructor(url: URL, options?: { authProvider?: { redirectToAuthorization?: (url: URL) => Promise<void> } }) {
-      this.url = url.toString()
-      this.authProvider = options?.authProvider
-      transportCalls.push({
-        type: "streamable",
-        url: url.toString(),
-        options: options ?? {},
-      })
-    }
-    async start() {
-      // Simulate OAuth redirect by calling the authProvider's redirectToAuthorization
-      if (this.authProvider?.redirectToAuthorization) {
-        await this.authProvider.redirectToAuthorization(new URL("https://auth.example.com/authorize?client_id=test"))
-      }
-      throw new MockUnauthorizedError()
-    }
-    async finishAuth(_code: string) {
-      // Mock successful auth completion
-    }
-  },
-}))
-
-mock.module("@modelcontextprotocol/sdk/client/sse.js", () => ({
-  SSEClientTransport: class MockSSE {
-    constructor(url: URL) {
-      transportCalls.push({
-        type: "sse",
-        url: url.toString(),
-        options: {},
-      })
-    }
-    async start() {
-      throw new Error("Mock SSE transport cannot connect")
-    }
-  },
-}))
-
-// Mock the MCP SDK Client to trigger OAuth flow
-mock.module("@modelcontextprotocol/sdk/client/index.js", () => ({
-  Client: class MockClient {
-    async connect(transport: { start: () => Promise<void> }) {
-      await transport.start()
-    }
-  },
-}))
-
-// Mock UnauthorizedError in the auth module
-mock.module("@modelcontextprotocol/sdk/client/auth.js", () => ({
-  UnauthorizedError: MockUnauthorizedError,
-}))
-
-beforeEach(() => {
-  openShouldFail = false
-  openCalledWith = undefined
-  transportCalls.length = 0
-})
-
-// Import modules after mocking
-const { MCP } = await import("../../src/mcp/index")
-const { Bus } = await import("../../src/bus")
-const { McpOAuthCallback } = await import("../../src/mcp/oauth-callback")
-const { Instance } = await import("../../src/project/instance")
-const { tmpdir } = await import("../fixture/fixture")
-
-test("BrowserOpenFailed event is published when open() throws", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        `${dir}/jonsoc.json`,
-        JSON.stringify({
-          $schema: "https://jonsoc.com/config.json",
-          mcp: {
-            "test-oauth-server": {
-              type: "remote",
-              url: "https://example.com/mcp",
-            },
-          },
-        }),
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      openShouldFail = true
-
-      const events: Array<{ mcpName: string; url: string }> = []
-      const unsubscribe = Bus.subscribe(MCP.BrowserOpenFailed, (evt) => {
-        events.push(evt.properties)
-      })
-
-      // Run authenticate with a timeout to avoid waiting forever for the callback
-      const authPromise = MCP.authenticate("test-oauth-server")
-
-      // Wait for the browser open attempt (error fires at 10ms, but we wait for event to be published)
-      await new Promise((resolve) => setTimeout(resolve, 200))
-
-      // Stop the callback server and cancel any pending auth
-      await McpOAuthCallback.stop()
-
-      // Wait for authenticate to reject (due to server stopping)
-      try {
-        await authPromise
-      } catch {
-        // Expected to fail
-      }
-
-      unsubscribe()
-
-      // Verify the BrowserOpenFailed event was published
-      expect(events.length).toBe(1)
-      expect(events[0].mcpName).toBe("test-oauth-server")
-      expect(events[0].url).toContain("https://")
-    },
-  })
-})
-
-test("BrowserOpenFailed event is NOT published when open() succeeds", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        `${dir}/jonsoc.json`,
-        JSON.stringify({
-          $schema: "https://jonsoc.com/config.json",
-          mcp: {
-            "test-oauth-server-2": {
-              type: "remote",
-              url: "https://example.com/mcp",
-            },
-          },
-        }),
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      openShouldFail = false
-
-      const events: Array<{ mcpName: string; url: string }> = []
-      const unsubscribe = Bus.subscribe(MCP.BrowserOpenFailed, (evt) => {
-        events.push(evt.properties)
-      })
-
-      // Run authenticate with a timeout to avoid waiting forever for the callback
-      const authPromise = MCP.authenticate("test-oauth-server-2")
-
-      // Wait for the browser open attempt and the 500ms error detection timeout
-      await new Promise((resolve) => setTimeout(resolve, 700))
-
-      // Stop the callback server and cancel any pending auth
-      await McpOAuthCallback.stop()
-
-      // Wait for authenticate to reject (due to server stopping)
-      try {
-        await authPromise
-      } catch {
-        // Expected to fail
-      }
-
-      unsubscribe()
-
-      // Verify NO BrowserOpenFailed event was published
-      expect(events.length).toBe(0)
-      // Verify open() was still called
-      expect(openCalledWith).toBeDefined()
-    },
-  })
-})
-
-test("open() is called with the authorization URL", async () => {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(
-        `${dir}/jonsoc.json`,
-        JSON.stringify({
-          $schema: "https://jonsoc.com/config.json",
-          mcp: {
-            "test-oauth-server-3": {
-              type: "remote",
-              url: "https://example.com/mcp",
-            },
-          },
-        }),
-      )
-    },
-  })
-
-  await Instance.provide({
-    directory: tmp.path,
-    fn: async () => {
-      openShouldFail = false
-      openCalledWith = undefined
-
-      // Run authenticate with a timeout to avoid waiting forever for the callback
-      const authPromise = MCP.authenticate("test-oauth-server-3")
-
-      // Wait for the browser open attempt and the 500ms error detection timeout
-      await new Promise((resolve) => setTimeout(resolve, 700))
-
-      // Stop the callback server and cancel any pending auth
-      await McpOAuthCallback.stop()
-
-      // Wait for authenticate to reject (due to server stopping)
-      try {
-        await authPromise
-      } catch {
-        // Expected to fail
-      }
-
-      // Verify open was called with a URL
-      expect(openCalledWith).toBeDefined()
-      expect(typeof openCalledWith).toBe("string")
-      expect(openCalledWith!).toContain("https://")
-    },
-  })
-})

package/test/patch/patch.test.ts

@@ -1,348 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test"
-import { Patch } from "../../src/patch"
-import * as fs from "fs/promises"
-import * as path from "path"
-import { tmpdir } from "os"
-
-describe("Patch namespace", () => {
-  let tempDir: string
-
-  beforeEach(async () => {
-    tempDir = await fs.mkdtemp(path.join(tmpdir(), "patch-test-"))
-  })
-
-  afterEach(async () => {
-    // Clean up temp directory
-    await fs.rm(tempDir, { recursive: true, force: true })
-  })
-
-  describe("parsePatch", () => {
-    test("should parse simple add file patch", () => {
-      const patchText = `*** Begin Patch
-*** Add File: test.txt
-+Hello World
-*** End Patch`
-
-      const result = Patch.parsePatch(patchText)
-      expect(result.hunks).toHaveLength(1)
-      expect(result.hunks[0]).toEqual({
-        type: "add",
-        path: "test.txt",
-        contents: "Hello World",
-      })
-    })
-
-    test("should parse delete file patch", () => {
-      const patchText = `*** Begin Patch
-*** Delete File: old.txt
-*** End Patch`
-
-      const result = Patch.parsePatch(patchText)
-      expect(result.hunks).toHaveLength(1)
-      const hunk = result.hunks[0]
-      expect(hunk.type).toBe("delete")
-      expect(hunk.path).toBe("old.txt")
-    })
-
-    test("should parse patch with multiple hunks", () => {
-      const patchText = `*** Begin Patch
-*** Add File: new.txt
-+This is a new file
-*** Update File: existing.txt
-@@
- old line
--new line
-+updated line
-*** End Patch`
-
-      const result = Patch.parsePatch(patchText)
-      expect(result.hunks).toHaveLength(2)
-      expect(result.hunks[0].type).toBe("add")
-      expect(result.hunks[1].type).toBe("update")
-    })
-
-    test("should parse file move operation", () => {
-      const patchText = `*** Begin Patch
-*** Update File: old-name.txt
-*** Move to: new-name.txt
-@@
--Old content
-+New content
-*** End Patch`
-
-      const result = Patch.parsePatch(patchText)
-      expect(result.hunks).toHaveLength(1)
-      const hunk = result.hunks[0]
-      expect(hunk.type).toBe("update")
-      expect(hunk.path).toBe("old-name.txt")
-      if (hunk.type === "update") {
-        expect(hunk.move_path).toBe("new-name.txt")
-      }
-    })
-
-    test("should throw error for invalid patch format", () => {
-      const invalidPatch = `This is not a valid patch`
-
-      expect(() => Patch.parsePatch(invalidPatch)).toThrow("Invalid patch format")
-    })
-  })
-
-  describe("maybeParseApplyPatch", () => {
-    test("should parse direct apply_patch command", () => {
-      const patchText = `*** Begin Patch
-*** Add File: test.txt
-+Content
-*** End Patch`
-
-      const result = Patch.maybeParseApplyPatch(["apply_patch", patchText])
-      expect(result.type).toBe(Patch.MaybeApplyPatch.Body)
-      if (result.type === Patch.MaybeApplyPatch.Body) {
-        expect(result.args.patch).toBe(patchText)
-        expect(result.args.hunks).toHaveLength(1)
-      }
-    })
-
-    test("should parse applypatch command", () => {
-      const patchText = `*** Begin Patch
-*** Add File: test.txt
-+Content
-*** End Patch`
-
-      const result = Patch.maybeParseApplyPatch(["applypatch", patchText])
-      expect(result.type).toBe(Patch.MaybeApplyPatch.Body)
-    })
-
-    test("should handle bash heredoc format", () => {
-      const script = `apply_patch <<'PATCH'
-*** Begin Patch
-*** Add File: test.txt
-+Content
-*** End Patch
-PATCH`
-
-      const result = Patch.maybeParseApplyPatch(["bash", "-lc", script])
-      expect(result.type).toBe(Patch.MaybeApplyPatch.Body)
-      if (result.type === Patch.MaybeApplyPatch.Body) {
-        expect(result.args.hunks).toHaveLength(1)
-      }
-    })
-
-    test("should return NotApplyPatch for non-patch commands", () => {
-      const result = Patch.maybeParseApplyPatch(["echo", "hello"])
-      expect(result.type).toBe(Patch.MaybeApplyPatch.NotApplyPatch)
-    })
-  })
-
-  describe("applyPatch", () => {
-    test("should add a new file", async () => {
-      const patchText = `*** Begin Patch
-*** Add File: ${tempDir}/new-file.txt
-+Hello World
-+This is a new file
-*** End Patch`
-
-      const result = await Patch.applyPatch(patchText)
-      expect(result.added).toHaveLength(1)
-      expect(result.modified).toHaveLength(0)
-      expect(result.deleted).toHaveLength(0)
-
-      const content = await fs.readFile(result.added[0], "utf-8")
-      expect(content).toBe("Hello World\nThis is a new file")
-    })
-
-    test("should delete an existing file", async () => {
-      const filePath = path.join(tempDir, "to-delete.txt")
-      await fs.writeFile(filePath, "This file will be deleted")
-
-      const patchText = `*** Begin Patch
-*** Delete File: ${filePath}
-*** End Patch`
-
-      const result = await Patch.applyPatch(patchText)
-      expect(result.deleted).toHaveLength(1)
-      expect(result.deleted[0]).toBe(filePath)
-
-      const exists = await fs
-        .access(filePath)
-        .then(() => true)
-        .catch(() => false)
-      expect(exists).toBe(false)
-    })
-
-    test("should update an existing file", async () => {
-      const filePath = path.join(tempDir, "to-update.txt")
-      await fs.writeFile(filePath, "line 1\nline 2\nline 3\n")
-
-      const patchText = `*** Begin Patch
-*** Update File: ${filePath}
-@@
- line 1
--line 2
-+line 2 updated
- line 3
-*** End Patch`
-
-      const result = await Patch.applyPatch(patchText)
-      expect(result.modified).toHaveLength(1)
-      expect(result.modified[0]).toBe(filePath)
-
-      const content = await fs.readFile(filePath, "utf-8")
-      expect(content).toBe("line 1\nline 2 updated\nline 3\n")
-    })
-
-    test("should move and update a file", async () => {
-      const oldPath = path.join(tempDir, "old-name.txt")
-      const newPath = path.join(tempDir, "new-name.txt")
-      await fs.writeFile(oldPath, "old content\n")
-
-      const patchText = `*** Begin Patch
-*** Update File: ${oldPath}
-*** Move to: ${newPath}
-@@
--old content
-+new content
-*** End Patch`
-
-      const result = await Patch.applyPatch(patchText)
-      expect(result.modified).toHaveLength(1)
-      expect(result.modified[0]).toBe(newPath)
-
-      const oldExists = await fs
-        .access(oldPath)
-        .then(() => true)
-        .catch(() => false)
-      expect(oldExists).toBe(false)
-
-      const newContent = await fs.readFile(newPath, "utf-8")
-      expect(newContent).toBe("new content\n")
-    })
-
-    test("should handle multiple operations in one patch", async () => {
-      const file1 = path.join(tempDir, "file1.txt")
-      const file2 = path.join(tempDir, "file2.txt")
-      const file3 = path.join(tempDir, "file3.txt")
-
-      await fs.writeFile(file1, "content 1")
-      await fs.writeFile(file2, "content 2")
-
-      const patchText = `*** Begin Patch
-*** Add File: ${file3}
-+new file content
-*** Update File: ${file1}
-@@
--content 1
-+updated content 1
-*** Delete File: ${file2}
-*** End Patch`
-
-      const result = await Patch.applyPatch(patchText)
-      expect(result.added).toHaveLength(1)
-      expect(result.modified).toHaveLength(1)
-      expect(result.deleted).toHaveLength(1)
-    })
-
-    test("should create parent directories when adding files", async () => {
-      const nestedPath = path.join(tempDir, "deep", "nested", "file.txt")
-
-      const patchText = `*** Begin Patch
-*** Add File: ${nestedPath}
-+Deep nested content
-*** End Patch`
-
-      const result = await Patch.applyPatch(patchText)
-      expect(result.added).toHaveLength(1)
-      expect(result.added[0]).toBe(nestedPath)
-
-      const exists = await fs
-        .access(nestedPath)
-        .then(() => true)
-        .catch(() => false)
-      expect(exists).toBe(true)
-    })
-  })
-
-  describe("error handling", () => {
-    test("should throw error when updating non-existent file", async () => {
-      const nonExistent = path.join(tempDir, "does-not-exist.txt")
-
-      const patchText = `*** Begin Patch
-*** Update File: ${nonExistent}
-@@
--old line
-+new line
-*** End Patch`
-
-      await expect(Patch.applyPatch(patchText)).rejects.toThrow()
-    })
-
-    test("should throw error when deleting non-existent file", async () => {
-      const nonExistent = path.join(tempDir, "does-not-exist.txt")
-
-      const patchText = `*** Begin Patch
-*** Delete File: ${nonExistent}
-*** End Patch`
-
-      await expect(Patch.applyPatch(patchText)).rejects.toThrow()
-    })
-  })
-
-  describe("edge cases", () => {
-    test("should handle empty files", async () => {
-      const emptyFile = path.join(tempDir, "empty.txt")
-      await fs.writeFile(emptyFile, "")
-
-      const patchText = `*** Begin Patch
-*** Update File: ${emptyFile}
-@@
-+First line
-*** End Patch`
-
-      const result = await Patch.applyPatch(patchText)
-      expect(result.modified).toHaveLength(1)
-
-      const content = await fs.readFile(emptyFile, "utf-8")
-      expect(content).toBe("First line\n")
-    })
-
-    test("should handle files with no trailing newline", async () => {
-      const filePath = path.join(tempDir, "no-newline.txt")
-      await fs.writeFile(filePath, "no newline")
-
-      const patchText = `*** Begin Patch
-*** Update File: ${filePath}
-@@
--no newline
-+has newline now
-*** End Patch`
-
-      const result = await Patch.applyPatch(patchText)
-      expect(result.modified).toHaveLength(1)
-
-      const content = await fs.readFile(filePath, "utf-8")
-      expect(content).toBe("has newline now\n")
-    })
-
-    test("should handle multiple update chunks in single file", async () => {
-      const filePath = path.join(tempDir, "multi-chunk.txt")
-      await fs.writeFile(filePath, "line 1\nline 2\nline 3\nline 4\n")
-
-      const patchText = `*** Begin Patch
-*** Update File: ${filePath}
-@@
- line 1
--line 2
-+LINE 2
-@@
- line 3
--line 4
-+LINE 4
-*** End Patch`
-
-      const result = await Patch.applyPatch(patchText)
-      expect(result.modified).toHaveLength(1)
-
-      const content = await fs.readFile(filePath, "utf-8")
-      expect(content).toBe("line 1\nLINE 2\nline 3\nLINE 4\n")
-    })
-  })
-})

package/test/permission/arity.test.ts

@@ -1,33 +0,0 @@
-import { test, expect } from "bun:test"
-import { BashArity } from "../../src/permission/arity"
-
-test("arity 1 - unknown commands default to first token", () => {
-  expect(BashArity.prefix(["unknown", "command", "subcommand"])).toEqual(["unknown"])
-  expect(BashArity.prefix(["touch", "foo.txt"])).toEqual(["touch"])
-})
-
-test("arity 2 - two token commands", () => {
-  expect(BashArity.prefix(["git", "checkout", "main"])).toEqual(["git", "checkout"])
-  expect(BashArity.prefix(["docker", "run", "nginx"])).toEqual(["docker", "run"])
-})
-
-test("arity 3 - three token commands", () => {
-  expect(BashArity.prefix(["aws", "s3", "ls", "my-bucket"])).toEqual(["aws", "s3", "ls"])
-  expect(BashArity.prefix(["npm", "run", "dev", "script"])).toEqual(["npm", "run", "dev"])
-})
-
-test("longest match wins - nested prefixes", () => {
-  expect(BashArity.prefix(["docker", "compose", "up", "service"])).toEqual(["docker", "compose", "up"])
-  expect(BashArity.prefix(["consul", "kv", "get", "config"])).toEqual(["consul", "kv", "get"])
-})
-
-test("exact length matches", () => {
-  expect(BashArity.prefix(["git", "checkout"])).toEqual(["git", "checkout"])
-  expect(BashArity.prefix(["npm", "run", "dev"])).toEqual(["npm", "run", "dev"])
-})
-
-test("edge cases", () => {
-  expect(BashArity.prefix([])).toEqual([])
-  expect(BashArity.prefix(["single"])).toEqual(["single"])
-  expect(BashArity.prefix(["git"])).toEqual(["git"])
-})