saeeol 1.3.0 → 1.4.0

package/test/saeeol/external-directory-boundary.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, test } from "bun:test"
+import { Effect } from "effect"
+import path from "path"
+import type { Permission } from "../../src/permission"
+import { Instance } from "../../src/project/instance"
+import { InstanceStore } from "../../src/project/instance-store"
+import { SessionID, MessageID } from "../../src/session/schema"
+import { assertExternalDirectory } from "../../src/tool/external-directory"
+import type { Tool } from "../../src/tool/tool"
+import { Filesystem } from "../../src/util/filesystem"
+import { AppFileSystem } from "@saeeol/core/filesystem"
+import { tmpdir } from "../fixture/fixture"
+
+const base: Omit<Tool.Context, "ask"> = {
+  sessionID: SessionID.make("ses_test-boundary-session"),
+  messageID: MessageID.make(""),
+  callID: "",
+  agent: "code",
+  abort: AbortSignal.any([]),
+  messages: [],
+  metadata: () => Effect.void,
+}
+
+const glob = (p: string) =>
+  process.platform === "win32" ? AppFileSystem.normalizePathPattern(p) : p.replaceAll("\\", "/")
+
+const asks = () => {
+  const items: Array<Omit<Permission.Request, "id" | "sessionID" | "tool">> = []
+  const ctx: Tool.Context = {
+    ...base,
+    ask: (req) =>
+      Effect.sync(() => {
+        items.push(req)
+      }),
+  }
+  return { items, ctx }
+}
+
+describe("saeeol external directory boundaries", () => {
+  test("asks before accessing outside a repo-root session", async () => {
+    await using repo = await tmpdir({ git: true })
+    await using outer = await tmpdir()
+    const file = path.join(outer.path, "outside.txt")
+    const { items, ctx } = asks()
+
+    await Instance.provide({
+      directory: repo.path,
+      fn: async () => {
+        try {
+          await assertExternalDirectory(ctx, file)
+        } finally {
+          await InstanceStore.disposeInstance(Instance.current)
+        }
+      },
+    })
+
+    const ext = items.find((item) => item.permission === "external_directory")
+    expect(ext).toBeDefined()
+    expect(ext!.patterns).toEqual([glob(path.join(outer.path, "*"))])
+    expect(ext!.always).toEqual([glob(path.join(outer.path, "*"))])
+    expect(ext!.metadata).toMatchObject({ filepath: file, parentDir: outer.path })
+  })
+
+  test("asks when the instance directory is a filesystem root", async () => {
+    await using outer = await tmpdir()
+    const root = path.parse(outer.path).root
+    const file = path.join(outer.path, "outside-root.txt")
+    const { items, ctx } = asks()
+
+    await Instance.provide({
+      directory: root,
+      fn: async () => {
+        try {
+          await assertExternalDirectory(ctx, file)
+        } finally {
+          await InstanceStore.disposeInstance(Instance.current)
+        }
+      },
+    })
+
+    const ext = items.find((item) => item.permission === "external_directory")
+    expect(ext).toBeDefined()
+    expect(ext!.patterns).toEqual([glob(path.join(outer.path, "*"))])
+    expect(ext!.metadata).toMatchObject({ filepath: file, parentDir: outer.path })
+  })
+
+  test("contains helpers keep dot-prefixed child names internal", () => {
+    expect(Filesystem.contains("/project", "/project/..cache/file")).toBe(true)
+    expect(AppFileSystem.contains("/a/b", "/a/b/..cache/file")).toBe(true)
+  })
+
+  test("AppFileSystem.contains rejects cross-drive paths on Windows", () => {
+    if (process.platform !== "win32") return
+    expect(AppFileSystem.contains("C:\\repo", "D:\\outside\\file.txt")).toBe(false)
+  })
+})

package/test/saeeol/gateway-headers.test.ts

@@ -0,0 +1,88 @@
+import { describe, it, expect, afterEach } from "bun:test"
+import { buildSaeeolHeaders, getFeatureHeader, getEditorNameHeader } from "@saeeol/gateway"
+import { HEADER_FEATURE, ENV_FEATURE, ENV_VERSION, DEFAULT_EDITOR_NAME } from "@saeeol/gateway"
+
+describe("getFeatureHeader", () => {
+  const original = process.env[ENV_FEATURE]
+
+  afterEach(() => {
+    if (original === undefined) {
+      delete process.env[ENV_FEATURE]
+    } else {
+      process.env[ENV_FEATURE] = original
+    }
+  })
+
+  it("returns undefined when env var is not set", () => {
+    delete process.env[ENV_FEATURE]
+    expect(getFeatureHeader()).toBeUndefined()
+  })
+
+  it("returns the env var value when set", () => {
+    process.env[ENV_FEATURE] = "cloud-agent"
+    expect(getFeatureHeader()).toBe("cloud-agent")
+  })
+
+  it("returns undefined for empty string", () => {
+    process.env[ENV_FEATURE] = ""
+    expect(getFeatureHeader()).toBeUndefined()
+  })
+})
+
+describe("getEditorNameHeader", () => {
+  const originalVersion = process.env[ENV_VERSION]
+
+  afterEach(() => {
+    if (originalVersion === undefined) {
+      delete process.env[ENV_VERSION]
+    } else {
+      process.env[ENV_VERSION] = originalVersion
+    }
+  })
+
+  it("returns default editor name without version when SAEEOL_VERSION is not set", () => {
+    delete process.env[ENV_VERSION]
+    expect(getEditorNameHeader()).toBe(DEFAULT_EDITOR_NAME)
+  })
+
+  it("appends version when SAEEOL_VERSION is set", () => {
+    process.env[ENV_VERSION] = "1.2.3"
+    expect(getEditorNameHeader()).toBe(`${DEFAULT_EDITOR_NAME} 1.2.3`)
+  })
+})
+
+describe("buildSaeeolHeaders", () => {
+  const original = process.env[ENV_FEATURE]
+
+  afterEach(() => {
+    if (original === undefined) {
+      delete process.env[ENV_FEATURE]
+    } else {
+      process.env[ENV_FEATURE] = original
+    }
+  })
+
+  it("includes feature header when env var is set", () => {
+    process.env[ENV_FEATURE] = "vscode-extension"
+    const headers = buildSaeeolHeaders()
+    expect(headers[HEADER_FEATURE]).toBe("vscode-extension")
+  })
+
+  it("omits feature header when env var is not set", () => {
+    delete process.env[ENV_FEATURE]
+    const headers = buildSaeeolHeaders()
+    expect(headers[HEADER_FEATURE]).toBeUndefined()
+  })
+
+  it("always includes editor name header", () => {
+    delete process.env[ENV_FEATURE]
+    const headers = buildSaeeolHeaders()
+    expect(headers["X-SAEEOL-EDITORNAME"]).toBe(getEditorNameHeader())
+  })
+
+  it("passes through any feature value from env", () => {
+    process.env[ENV_FEATURE] = "custom-feature"
+    const headers = buildSaeeolHeaders()
+    expect(headers[HEADER_FEATURE]).toBe("custom-feature")
+  })
+})

package/test/saeeol/help.test.ts

@@ -0,0 +1,191 @@
+import { describe, test, expect } from "bun:test"
+import path from "path"
+import { generateHelp, generateCommandTable } from "../../src/overlay/help"
+import { AcpCommand } from "../../src/cli/cmd/acp"
+import { McpCommand } from "../../src/cli/cmd/mcp"
+import { RunCommand } from "../../src/cli/cmd/run"
+import { GenerateCommand } from "../../src/cli/cmd/generate"
+import { DebugCommand } from "../../src/cli/cmd/debug"
+import { ProvidersCommand } from "../../src/cli/cmd/providers" 
+import { AgentCommand } from "../../src/cli/cmd/agent"
+import { UpgradeCommand } from "../../src/cli/cmd/upgrade"
+import { UninstallCommand } from "../../src/cli/cmd/uninstall"
+import { ServeCommand } from "../../src/cli/cmd/serve"
+import { WebCommand } from "../../src/cli/cmd/web"
+import { ModelsCommand } from "../../src/cli/cmd/models"
+import { StatsCommand } from "../../src/cli/cmd/stats"
+import { ExportCommand } from "../../src/cli/cmd/export"
+import { ImportCommand } from "../../src/cli/cmd/import"
+import { PrCommand } from "../../src/cli/cmd/pr"
+import { SessionCommand } from "../../src/cli/cmd/session"
+import { RemoteCommand } from "../../src/cli/cmd/remote"
+import { ConfigCommand as ConfigCLICommand } from "../../src/cli/cmd/config"
+import { PluginCommand } from "../../src/cli/cmd/plug"
+import { DbCommand } from "../../src/cli/cmd/db"
+import { HelpCommand } from "../../src/overlay/help-command"
+
+// Stand-in for TuiThreadCommand — the real one imports @opentui/solid which
+// doesn't resolve in the test environment. Only command/describe matter here.
+const TuiStub = {
+  command: "$0 [project]",
+  describe: "start saeeol tui",
+  handler() {},
+}
+
+// Stand-in for AttachCommand — same reason as TuiStub above.
+const AttachStub = {
+  command: "attach <url>",
+  describe: "attach to a running saeeol server",
+  handler() {},
+}
+
+// Synthetic entry for the yargs built-in .completion() command
+const CompletionStub = {
+  command: "completion",
+  describe: "generate shell completion script",
+  handler() {},
+}
+
+const commands = [
+  AcpCommand,
+  McpCommand,
+  TuiStub,
+  AttachStub,
+  RunCommand,
+  GenerateCommand,
+  DebugCommand,
+  ProvidersCommand,
+  AgentCommand,
+  UpgradeCommand,
+  UninstallCommand,
+  ServeCommand,
+  WebCommand,
+  ModelsCommand,
+  StatsCommand,
+  ExportCommand,
+  ImportCommand,
+  PrCommand,
+  SessionCommand,
+  RemoteCommand,
+  DbCommand,
+  ConfigCLICommand,
+  PluginCommand,
+  HelpCommand,
+  CompletionStub,
+] as any[]
+
+describe("saeeol help --all (markdown)", () => {
+  test("contains ## heading for each known top-level command", async () => {
+    const output = await generateHelp({ all: true, format: "md", commands })
+    for (const cmd of ["run", "auth", "debug", "mcp", "session", "agent"]) {
+      expect(output).toContain(`## saeeol ${cmd}`)
+    }
+  })
+
+  test("contains headings for nested subcommands", async () => {
+    const output = await generateHelp({ all: true, format: "md", commands })
+    expect(output).toContain("saeeol auth login")
+    expect(output).toContain("saeeol auth logout")
+    expect(output).toContain("saeeol debug config")
+  })
+})
+
+describe("saeeol help --all (text)", () => {
+  test("does NOT contain Markdown ## headings or triple-backtick fences", async () => {
+    const output = await generateHelp({ all: true, format: "text", commands })
+    expect(output).not.toMatch(/^##\s/m)
+    expect(output).not.toContain("```")
+  })
+
+  test("still contains each command name", async () => {
+    const output = await generateHelp({ all: true, format: "text", commands })
+    for (const cmd of ["run", "auth", "debug", "mcp", "session", "agent"]) {
+      expect(output).toContain(`saeeol ${cmd}`)
+    }
+  })
+})
+
+describe("saeeol help <command>", () => {
+  test("saeeol help auth contains auth subcommand headings", async () => {
+    const output = await generateHelp({ command: "auth", format: "md", commands })
+    expect(output).toContain("saeeol auth login")
+    expect(output).toContain("saeeol auth logout")
+    expect(output).toContain("saeeol auth list")
+  })
+
+  test("saeeol help auth does NOT contain run or debug headings", async () => {
+    const output = await generateHelp({ command: "auth", format: "md", commands })
+    expect(output).not.toContain("## saeeol run")
+    expect(output).not.toContain("## saeeol debug")
+  })
+})
+
+describe("edge cases", () => {
+  test("output contains no ANSI escape sequences", async () => {
+    const output = await generateHelp({ all: true, format: "md", commands })
+    expect(/\x1b\[/.test(output)).toBe(false)
+  })
+
+  test("saeeol help nonexistent throws unknown command error", async () => {
+    await expect(generateHelp({ command: "nonexistent", commands })).rejects.toThrow("unknown command")
+  })
+})
+
+describe("generateCommandTable", () => {
+  test("returns a string containing a markdown table header", async () => {
+    const output = await generateCommandTable({ commands })
+    expect(output).toContain("| Command | Description |")
+  })
+
+  test("contains rows for known commands", async () => {
+    const output = await generateCommandTable({ commands })
+    for (const name of ["run", "auth", "debug", "mcp"]) {
+      expect(output).toContain(`saeeol ${name}`)
+    }
+  })
+
+  test("default command appears as saeeol [project], not $0", async () => {
+    const output = await generateCommandTable({ commands })
+    expect(output).toContain("`saeeol [project]`")
+    expect(output).not.toContain("$0")
+  })
+
+  test("contains no ANSI escape sequences", async () => {
+    const output = await generateCommandTable({ commands })
+    expect(/\x1b\[/.test(output)).toBe(false)
+  })
+
+  test("skips commands with no describe", async () => {
+    const output = await generateCommandTable({ commands })
+    expect(output).not.toContain("`saeeol generate`")
+  })
+
+  test("contains saeeol completion row", async () => {
+    const output = await generateCommandTable({ commands })
+    expect(output).toContain("`saeeol completion`")
+  })
+
+  test("contains saeeol help row", async () => {
+    const output = await generateCommandTable({ commands })
+    expect(output).toContain("`saeeol help")
+  })
+})
+
+describe("commands.ts stays in sync with index.ts", () => {
+  test("every .command() in index.ts has an entry in the commands array", async () => {
+    const index = await Bun.file(path.resolve(import.meta.dir, "../../src/index.ts")).text()
+    const barrel = await Bun.file(path.resolve(import.meta.dir, "../../src/overlay/commands.ts")).text()
+
+    // Match uncommented .command(XxxCommand) calls in index.ts
+    const registered = [...index.matchAll(/^\s*\.command\((\w+)\)/gm)].map((m) => m[1]!)
+    expect(registered.length).toBeGreaterThan(0)
+
+    // Extract identifiers inside the exported commands = [...] array, not just anywhere in the file
+    const arrayMatch = barrel.match(/export const commands\s*=\s*\[([\s\S]*?)\]/)
+    expect(arrayMatch).toBeTruthy()
+    const entries = [...arrayMatch![1]!.matchAll(/\b(\w+Command)\b/g)].map((m) => m[1]!)
+
+    const missing = registered.filter((name) => !entries.includes(name))
+    expect(missing).toEqual([])
+  })
+})

package/test/saeeol/ignore-migrator.test.ts

@@ -0,0 +1,308 @@
+import { test, expect, describe } from "bun:test"
+import { IgnoreMigrator } from "../../src/overlay/ignore-migrator"
+import { tmpdir } from "../fixture/fixture"
+import path from "path"
+
+describe("IgnoreMigrator", () => {
+  describe("parseIgnoreContent", () => {
+    test("parses basic patterns", () => {
+      const content = `
+# Comment
+secrets/
+*.env
+!.env.example
+`
+      const patterns = IgnoreMigrator.parseIgnoreContent(content)
+
+      expect(patterns).toEqual([
+        { pattern: "secrets/", negated: false },
+        { pattern: "*.env", negated: false },
+        { pattern: ".env.example", negated: true },
+      ])
+    })
+
+    test("ignores empty lines and comments", () => {
+      const content = `
+# This is a comment
+pattern1
+
+# Another comment
+pattern2
+`
+      const patterns = IgnoreMigrator.parseIgnoreContent(content)
+
+      expect(patterns).toHaveLength(2)
+      expect(patterns[0].pattern).toBe("pattern1")
+      expect(patterns[1].pattern).toBe("pattern2")
+    })
+
+    test("handles negation patterns", () => {
+      const content = `*.log
+!important.log`
+      const patterns = IgnoreMigrator.parseIgnoreContent(content)
+
+      expect(patterns[0]).toEqual({ pattern: "*.log", negated: false })
+      expect(patterns[1]).toEqual({ pattern: "important.log", negated: true })
+    })
+
+    test("handles empty content", () => {
+      const patterns = IgnoreMigrator.parseIgnoreContent("")
+      expect(patterns).toHaveLength(0)
+    })
+
+    test("handles content with only comments", () => {
+      const content = `# Comment 1
+# Comment 2`
+      const patterns = IgnoreMigrator.parseIgnoreContent(content)
+      expect(patterns).toHaveLength(0)
+    })
+
+    test("trims whitespace from patterns", () => {
+      const content = `  secrets/  
+  *.env  `
+      const patterns = IgnoreMigrator.parseIgnoreContent(content)
+
+      expect(patterns[0].pattern).toBe("secrets/")
+      expect(patterns[1].pattern).toBe("*.env")
+    })
+  })
+
+  describe("convertToGlob", () => {
+    test("converts directory pattern", () => {
+      expect(IgnoreMigrator.convertToGlob("secrets/")).toBe("secrets/*")
+    })
+
+    test("preserves simple filename pattern", () => {
+      // Saeeol's * already matches any path depth
+      expect(IgnoreMigrator.convertToGlob("*.env")).toBe("*.env")
+    })
+
+    test("converts rooted patterns", () => {
+      expect(IgnoreMigrator.convertToGlob("/root-only")).toBe("root-only")
+    })
+
+    test("preserves patterns with path separators", () => {
+      expect(IgnoreMigrator.convertToGlob("src/secrets/")).toBe("src/secrets/*")
+    })
+
+    test("handles double-star patterns", () => {
+      expect(IgnoreMigrator.convertToGlob("**/deep/")).toBe("*deep/*")
+    })
+
+    test("preserves simple filename without extension", () => {
+      // Saeeol's * already matches any path depth
+      expect(IgnoreMigrator.convertToGlob("Dockerfile")).toBe("Dockerfile")
+    })
+
+    test("preserves extension-only pattern", () => {
+      expect(IgnoreMigrator.convertToGlob("*.log")).toBe("*.log")
+    })
+
+    test("preserves nested path pattern", () => {
+      expect(IgnoreMigrator.convertToGlob("config/secrets.json")).toBe("config/secrets.json")
+    })
+  })
+
+  describe("buildPermissionRules", () => {
+    test("creates default allow rule", () => {
+      const rules = IgnoreMigrator.buildPermissionRules([])
+      expect(rules["*"]).toBe("allow")
+    })
+
+    test("creates deny rules for patterns", () => {
+      const patterns = [{ pattern: "secrets/", negated: false, source: "project" as const }]
+      const rules = IgnoreMigrator.buildPermissionRules(patterns)
+
+      expect(rules["*"]).toBe("allow")
+      expect(rules["secrets/*"]).toBe("deny")
+    })
+
+    test("creates allow rules for negated patterns", () => {
+      const patterns = [
+        { pattern: "*.env", negated: false, source: "project" as const },
+        { pattern: ".env.example", negated: true, source: "project" as const },
+      ]
+      const rules = IgnoreMigrator.buildPermissionRules(patterns)
+
+      expect(rules["*.env"]).toBe("deny")
+      expect(rules[".env.example"]).toBe("allow")
+    })
+
+    test("handles multiple deny patterns", () => {
+      const patterns = [
+        { pattern: "secrets/", negated: false, source: "project" as const },
+        { pattern: "*.env", negated: false, source: "project" as const },
+        { pattern: "*.key", negated: false, source: "project" as const },
+      ]
+      const rules = IgnoreMigrator.buildPermissionRules(patterns)
+
+      expect(rules["secrets/*"]).toBe("deny")
+      expect(rules["*.env"]).toBe("deny")
+      expect(rules["*.key"]).toBe("deny")
+    })
+
+    test("negated patterns override deny patterns", () => {
+      const patterns = [
+        { pattern: "config/", negated: false, source: "project" as const },
+        { pattern: "config/public.json", negated: true, source: "project" as const },
+      ]
+      const rules = IgnoreMigrator.buildPermissionRules(patterns)
+
+      expect(rules["config/*"]).toBe("deny")
+      expect(rules["config/public.json"]).toBe("allow")
+    })
+  })
+
+  describe("migrate", () => {
+    test("returns empty permission for project without .saeeolignore", async () => {
+      await using tmp = await tmpdir()
+
+      const result = await IgnoreMigrator.migrate({
+        projectDir: tmp.path,
+        skipGlobalPaths: true,
+      })
+
+      expect(result.patternCount).toBe(0)
+      expect(Object.keys(result.permission)).toHaveLength(0)
+    })
+
+    test("loads project .saeeolignore", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(path.join(dir, ".saeeolignore"), "secrets/\n*.env")
+        },
+      })
+
+      const result = await IgnoreMigrator.migrate({
+        projectDir: tmp.path,
+        skipGlobalPaths: true,
+      })
+
+      expect(result.patternCount).toBe(2)
+      expect(result.permission.read).toBeDefined()
+      expect(result.permission.edit).toBeDefined()
+    })
+
+    test("applies patterns to both read and edit", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(path.join(dir, ".saeeolignore"), "secrets/")
+        },
+      })
+
+      const result = await IgnoreMigrator.migrate({
+        projectDir: tmp.path,
+        skipGlobalPaths: true,
+      })
+
+      const readRules = result.permission.read as Record<string, string>
+      const editRules = result.permission.edit as Record<string, string>
+
+      expect(readRules["secrets/*"]).toBe("deny")
+      expect(editRules["secrets/*"]).toBe("deny")
+    })
+
+    test("handles negation patterns correctly", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(path.join(dir, ".saeeolignore"), "*.env\n!.env.example")
+        },
+      })
+
+      const result = await IgnoreMigrator.migrate({
+        projectDir: tmp.path,
+        skipGlobalPaths: true,
+      })
+
+      const readRules = result.permission.read as Record<string, string>
+
+      expect(readRules["*.env"]).toBe("deny")
+      expect(readRules[".env.example"]).toBe("allow")
+    })
+
+    test("handles complex .saeeolignore file", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(
+            path.join(dir, ".saeeolignore"),
+            `# Secrets
+secrets/
+*.env
+!.env.example
+
+# Keys
+*.key
+*.pem
+
+# Config
+/config/private/
+!config/private/public.json
+`,
+          )
+        },
+      })
+
+      const result = await IgnoreMigrator.migrate({
+        projectDir: tmp.path,
+        skipGlobalPaths: true,
+      })
+
+      expect(result.patternCount).toBe(7)
+
+      const readRules = result.permission.read as Record<string, string>
+      expect(readRules["*"]).toBe("allow")
+      expect(readRules["secrets/*"]).toBe("deny")
+      expect(readRules["*.env"]).toBe("deny")
+      expect(readRules[".env.example"]).toBe("allow")
+      expect(readRules["*.key"]).toBe("deny")
+      expect(readRules["*.pem"]).toBe("deny")
+      expect(readRules["config/private/*"]).toBe("deny")
+      expect(readRules["config/private/public.json"]).toBe("allow")
+    })
+
+    test("returns empty warnings array", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(path.join(dir, ".saeeolignore"), "secrets/")
+        },
+      })
+
+      const result = await IgnoreMigrator.migrate({
+        projectDir: tmp.path,
+        skipGlobalPaths: true,
+      })
+
+      expect(result.warnings).toHaveLength(0)
+    })
+  })
+
+  describe("loadIgnoreConfig", () => {
+    test("returns empty object for project without .saeeolignore", async () => {
+      await using tmp = await tmpdir()
+
+      const permission = await IgnoreMigrator.loadIgnoreConfig(tmp.path, true)
+
+      expect(Object.keys(permission)).toHaveLength(0)
+    })
+
+    test("returns permission config for project with .saeeolignore", async () => {
+      await using tmp = await tmpdir({
+        init: async (dir) => {
+          await Bun.write(path.join(dir, ".saeeolignore"), "secrets/")
+        },
+      })
+
+      const permission = await IgnoreMigrator.loadIgnoreConfig(tmp.path, true)
+
+      expect(permission.read).toBeDefined()
+      expect(permission.edit).toBeDefined()
+    })
+
+    test("handles errors gracefully", async () => {
+      // Pass a non-existent directory
+      const permission = await IgnoreMigrator.loadIgnoreConfig("/non/existent/path", true)
+
+      expect(Object.keys(permission)).toHaveLength(0)
+    })
+  })
+})