saeeol 1.3.0 → 1.3.1

package/test/saeeol/lsp-typescript-lightweight.test.ts

@@ -0,0 +1,89 @@
+// Tests for the lightweight TypeScript diagnostic mode.
+// These are regression guards — if an upstream Saeeol merge overwrites the
+// saeeol integration in shared LSP files, these tests catch it.
+
+import { describe, test, expect, spyOn, afterEach } from "bun:test"
+import path from "path"
+import * as LSPServer from "../../src/lsp/server"
+import { TsClient } from "../../src/overlay/ts-client"
+import { TsCheck } from "../../src/overlay/ts-check"
+import { Flag } from "@saeeol/core/flag/flag"
+import { Instance, type InstanceContext } from "../../src/project/instance"
+import { disposeAllInstances } from "../fixture/fixture"
+
+afterEach(async () => {
+  await disposeAllInstances()
+})
+
+// Typescript.spawn doesn't use ctx, so a cast-through is fine for these tests.
+const fakeCtx = {} as InstanceContext
+
+describe("typescript lightweight mode", () => {
+  describe("spawn gate", () => {
+    test("Typescript.spawn returns undefined when flag is off", async () => {
+      const saved = Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL
+      Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = false
+      try {
+        const result = await LSPServer.Typescript.spawn("/tmp/any", fakeCtx)
+        expect(result).toBeUndefined()
+      } finally {
+        Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = saved
+      }
+    })
+
+    test("Typescript.spawn calls native_tsgo when flag is on", async () => {
+      const saved = Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL
+      Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = true
+      const spy = spyOn(TsCheck, "native_tsgo").mockResolvedValue(undefined)
+
+      try {
+        const result = await LSPServer.Typescript.spawn("/tmp/any", fakeCtx)
+        expect(spy).toHaveBeenCalled()
+        expect(result).toBeUndefined() // undefined because mock returns no binary
+      } finally {
+        Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = saved
+        spy.mockRestore()
+      }
+    })
+  })
+
+  describe("TsClient", () => {
+    test("create returns a valid LSPClient.Info", () => {
+      const client = TsClient.create({ root: "/tmp/test" })
+      expect(client.serverID).toBe("typescript")
+      expect(client.root).toBe("/tmp/test")
+      expect(client.diagnostics).toBeInstanceOf(Map)
+      expect(typeof client.shutdown).toBe("function")
+      expect(typeof client.waitForDiagnostics).toBe("function")
+      expect(typeof client.notify.open).toBe("function")
+    })
+
+    test("connection.sendRequest rejects with descriptive error", async () => {
+      const client = TsClient.create({ root: "/tmp/test" })
+      await expect(client.connection.sendRequest("anything")).rejects.toThrow("lightweight diagnostic mode")
+    })
+
+    test("shutdown clears diagnostics", async () => {
+      const client = TsClient.create({ root: "/tmp/test" })
+      await client.shutdown()
+      expect(client.diagnostics.size).toBe(0)
+    })
+  })
+
+  describe("source integration guards", () => {
+    // These tests verify that saeeol integration code exists in shared
+    // files. If an upstream merge strips the integration blocks, these fail.
+
+    test("lsp/server.ts gates Typescript.spawn behind flag", async () => {
+      const src = await Bun.file(path.resolve(import.meta.dir, "../../src/lsp/server.ts")).text()
+      expect(src).toContain("SAEEOL_EXPERIMENTAL_LSP_TOOL")
+      expect(src).toContain("native_tsgo")
+    })
+
+    test("lsp/lsp.ts uses TsClient for lightweight diagnostics", async () => {
+      const src = await Bun.file(path.resolve(import.meta.dir, "../../src/lsp/lsp.ts")).text()
+      expect(src).toContain("TsClient.create")
+      expect(src).toContain("SAEEOL_EXPERIMENTAL_LSP_TOOL")
+    })
+  })
+})

package/test/saeeol/mcp-branding.test.ts

@@ -0,0 +1,33 @@
+import { describe, test, expect } from "bun:test"
+import path from "path"
+
+// Regression guard for branding drift in user-facing MCP strings.
+//
+// History: upstream Saeeol has repeatedly overwritten the Saeeol-branded
+// toast message and MCP client `name` field during large refactors — most
+// recently in upstream PR #22913 (commit 5fccdc9fc, "refactor: collapse mcp
+// barrel into mcp/index.ts") which Saeeol picked up via the v1.4.7 merge (PR
+// #9346, commit 57630eaf1). The original fix was PR #7174.
+//
+// This test asserts the surviving Saeeol-branded strings directly against the
+// source so that the next upstream churn on this file fails the Saeeol test
+// suite instead of shipping an "saeeol mcp auth" popup to end users.
+
+const mcpSource = path.join(__dirname, "..", "..", "src", "mcp", "index.ts")
+
+describe("Saeeol MCP branding", () => {
+  test("auth toast tells the user to run `saeeol mcp auth`, never `saeeol mcp auth`", async () => {
+    const src = await Bun.file(mcpSource).text()
+    expect(src).toContain("Run: saeeol mcp auth ${key}")
+    expect(src).not.toContain("Run: saeeol mcp auth")
+  })
+
+  test("MCP `Client` instances identify themselves as `saeeol`", async () => {
+    const src = await Bun.file(mcpSource).text()
+    // `name: "saeeol"` is the upstream default and appears in the protocol
+    // handshake / client identification fields. Any new `new Client({ ... })`
+    // must use the Saeeol brand.
+    const saeeolClientName = /name:\s*"saeeol"/g
+    expect(src.match(saeeolClientName)).toBeNull()
+  })
+})

package/test/saeeol/mcp-docker-rm.test.ts

@@ -0,0 +1,32 @@
+import { test, expect, describe } from "bun:test"
+import { MCP } from "../../src/mcp"
+
+describe("ensureDockerRm", () => {
+  test("injects --rm after 'run' for docker run commands", () => {
+    const result = MCP.ensureDockerRm("docker", ["run", "-i", "my-image"])
+    expect(result).toEqual(["run", "--rm", "-i", "my-image"])
+  })
+
+  test("skips adding --rm when already present (idempotent)", () => {
+    const args = ["run", "--rm", "-i", "my-image"]
+    const result = MCP.ensureDockerRm("docker", args)
+    expect(result).toBe(args)
+  })
+
+  test("does not modify non-docker commands", () => {
+    const args = ["-y", "@modelcontextprotocol/server-filesystem"]
+    const result = MCP.ensureDockerRm("npx", args)
+    expect(result).toBe(args)
+  })
+
+  test("does not modify docker commands that are not 'run'", () => {
+    const args = ["build", "-t", "my-image", "."]
+    const result = MCP.ensureDockerRm("docker", args)
+    expect(result).toBe(args)
+  })
+
+  test("handles docker run with no additional args", () => {
+    const result = MCP.ensureDockerRm("docker", ["run"])
+    expect(result).toEqual(["run", "--rm"])
+  })
+})