saeeol 1.3.0 → 1.4.0

package/test/cli/import.test.ts

@@ -0,0 +1,97 @@
+import { test, expect } from "bun:test"
+import {
+  parseShareUrl,
+  transformShareData,
+  bootstrapImportedSessionIngest,
+  ingestBootstrapWarning,
+  shouldAttachShareAuthHeaders,
+  type ShareData,
+} from "../../src/cli/cmd/import"
+
+// parseShareUrl tests
+test("parses valid Saeeol share URLs", () => {
+  expect(parseShareUrl("https://app.saeeol.ai/s/7a755b04-b0fe-4e66-8b30-0ab52a181bd4")).toBe(
+    "7a755b04-b0fe-4e66-8b30-0ab52a181bd4",
+  )
+  expect(parseShareUrl("https://app.saeeol.ai/s/Jsj3hNIW")).toBe("Jsj3hNIW")
+  expect(parseShareUrl("https://app.saeeol.ai/s/test_id-123")).toBe("test_id-123")
+})
+
+test("rejects invalid URLs", () => {
+  expect(parseShareUrl("https://app.saeeol.ai/s/")).toBeNull()
+  expect(parseShareUrl("https://app.saeeol.ai/s/id/extra")).toBeNull()
+  expect(parseShareUrl("https://opncd.ai/share/Jsj3hNIW")).toBeNull()
+  expect(parseShareUrl("https://other.example.com/s/abc")).toBeNull()
+  expect(parseShareUrl("not-a-url")).toBeNull()
+})
+
+test("only attaches share auth headers for same-origin URLs", () => {
+  expect(shouldAttachShareAuthHeaders("https://control.example.com/share/abc", "https://control.example.com")).toBe(
+    true,
+  )
+  expect(shouldAttachShareAuthHeaders("https://other.example.com/share/abc", "https://control.example.com")).toBe(false)
+  expect(shouldAttachShareAuthHeaders("https://control.example.com:443/share/abc", "https://control.example.com")).toBe(
+    true,
+  )
+  expect(shouldAttachShareAuthHeaders("not-a-url", "https://control.example.com")).toBe(false)
+})
+
+// transformShareData tests
+test("transforms share data to storage format", () => {
+  const data: ShareData[] = [
+    { type: "session", data: { id: "sess-1", title: "Test" } as any },
+    { type: "message", data: { id: "msg-1", sessionID: "sess-1" } as any },
+    { type: "part", data: { id: "part-1", messageID: "msg-1" } as any },
+    { type: "part", data: { id: "part-2", messageID: "msg-1" } as any },
+  ]
+
+  const result = transformShareData(data)!
+
+  expect(result.info.id).toBe("sess-1")
+  expect(result.messages).toHaveLength(1)
+  expect(result.messages[0].parts).toHaveLength(2)
+})
+
+test("returns null for invalid share data", () => {
+  expect(transformShareData([])).toBeNull()
+  expect(transformShareData([{ type: "message", data: {} as any }])).toBeNull()
+  expect(transformShareData([{ type: "session", data: { id: "s" } as any }])).toBeNull() // no messages
+})
+
+test("formats ingest bootstrap warning", () => {
+  expect(ingestBootstrapWarning("session-123", new Error("network failed"))).toContain("session-123")
+  expect(ingestBootstrapWarning("session-123", new Error("network failed"))).toContain("network failed")
+  expect(ingestBootstrapWarning("session-123", "oops")).toContain("oops")
+})
+
+test("bootstrapImportedSessionIngest runs bootstrap and does not warn on success", async () => {
+  const calls: string[] = []
+  const warnings: string[] = []
+
+  await bootstrapImportedSessionIngest("session-success", {
+    bootstrap: async (sessionId) => {
+      calls.push(sessionId)
+    },
+    warn: (message) => warnings.push(message),
+  })
+
+  expect(calls).toEqual(["session-success"])
+  expect(warnings).toHaveLength(0)
+})
+
+test("bootstrapImportedSessionIngest warns and continues on failure", async () => {
+  const warnings: string[] = []
+
+  await expect(
+    bootstrapImportedSessionIngest("session-fail", {
+      bootstrap: async () => {
+        throw new Error("boom")
+      },
+      warn: (message) => warnings.push(message),
+    }),
+  ).resolves.toBeUndefined()
+
+  expect(warnings).toHaveLength(1)
+  expect(warnings[0]).toContain("session-fail")
+  expect(warnings[0]).toContain("boom")
+})

package/test/cli/install-artifact.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test"
+import { $ } from "bun"
+import fs from "fs/promises"
+import os from "os"
+import path from "path"
+
+const root = path.join(import.meta.dir, "..", "..")
+const wrapper = path.join(root, "bin", "saeeol")
+
+describe("npm install artifact behavior", () => {
+  test("keeps the CLI wrapper contract", async () => {
+    const text = await fs.readFile(wrapper, "utf8")
+    expect(text.startsWith("#!/usr/bin/env node")).toBe(true)
+    expect(text).toContain("const envPath = process.env.SAEEOL_BIN_PATH")
+    expect(text).toContain('const base = "saeeol-" + platform + "-" + arch')
+    expect(text).toContain("function findBinary(startDir)")
+  })
+
+  test("links npm bin commands to the wrapper during local install", async () => {
+    const npmPath = Bun.which("npm")
+    if (!npmPath) {
+      console.warn("Skipping install artifact test: npm is not available in PATH")
+      return
+    }
+
+    const tmp = await fs.mkdtemp(path.join(os.tmpdir(), "saeeol-install-artifact-"))
+    try {
+      const pkg = path.join(tmp, "pkg")
+      const bin = path.join(pkg, "bin")
+      const prefix = path.join(tmp, "prefix")
+      await fs.mkdir(bin, { recursive: true })
+      await fs.mkdir(prefix, { recursive: true })
+      await fs.copyFile(wrapper, path.join(bin, "saeeol"))
+      await Bun.write(
+        path.join(pkg, "package.json"),
+        JSON.stringify(
+          {
+            name: "saeeol-install-artifact-repro",
+            version: "1.0.0",
+            bin: {
+              saeeol: "./bin/saeeol",
+            },
+          },
+          null,
+          2,
+        ),
+      )
+
+      await $`npm install --prefix ${prefix} ${pkg} --no-package-lock --ignore-scripts --no-audit --no-fund`.quiet()
+
+      const commands = ["saeeol", "saeeol"]
+      for (const name of commands) {
+        const link = path.join(prefix, "node_modules", ".bin", name)
+        const stat = await fs.lstat(link)
+        expect(stat.isSymbolicLink() || stat.isFile()).toBe(true)
+      }
+
+      const hidden = path.join(prefix, "node_modules", ".bin", ".saeeol")
+      const exists = await fs
+        .access(hidden)
+        .then(() => true)
+        .catch(() => false)
+      if (!exists) return
+
+      const stat = await fs.lstat(hidden)
+      expect(stat.isFile() || stat.isSymbolicLink()).toBe(true)
+      if (!stat.isSymbolicLink()) expect(stat.size).toBeGreaterThan(0)
+    } finally {
+      await fs.rm(tmp, { recursive: true, force: true })
+    }
+  }, 60_000) 
+})

package/test/cli/plugin-auth-picker.test.ts

@@ -0,0 +1,120 @@
+import { test, expect, describe } from "bun:test"
+import { resolvePluginProviders } from "../../src/cli/cmd/providers-auth"
+import type { Hooks } from "@saeeol/plugin"
+
+function hookWithAuth(provider: string): Hooks {
+  return {
+    auth: {
+      provider,
+      methods: [],
+    },
+  }
+}
+
+function hookWithoutAuth(): Hooks {
+  return {}
+}
+
+describe("resolvePluginProviders", () => {
+  test("returns plugin providers not in models.dev", () => {
+    const result = resolvePluginProviders({
+      hooks: [hookWithAuth("portkey")],
+      existingProviders: {},
+      disabled: new Set(),
+      providerNames: {},
+    })
+    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
+  })
+
+  test("skips providers already in models.dev", () => {
+    const result = resolvePluginProviders({
+      hooks: [hookWithAuth("anthropic")],
+      existingProviders: { anthropic: {} },
+      disabled: new Set(),
+      providerNames: {},
+    })
+    expect(result).toEqual([])
+  })
+
+  test("deduplicates across plugins", () => {
+    const result = resolvePluginProviders({
+      hooks: [hookWithAuth("portkey"), hookWithAuth("portkey")],
+      existingProviders: {},
+      disabled: new Set(),
+      providerNames: {},
+    })
+    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
+  })
+
+  test("respects disabled_providers", () => {
+    const result = resolvePluginProviders({
+      hooks: [hookWithAuth("portkey")],
+      existingProviders: {},
+      disabled: new Set(["portkey"]),
+      providerNames: {},
+    })
+    expect(result).toEqual([])
+  })
+
+  test("respects enabled_providers when provider is absent", () => {
+    const result = resolvePluginProviders({
+      hooks: [hookWithAuth("portkey")],
+      existingProviders: {},
+      disabled: new Set(),
+      enabled: new Set(["anthropic"]),
+      providerNames: {},
+    })
+    expect(result).toEqual([])
+  })
+
+  test("includes provider when in enabled set", () => {
+    const result = resolvePluginProviders({
+      hooks: [hookWithAuth("portkey")],
+      existingProviders: {},
+      disabled: new Set(),
+      enabled: new Set(["portkey"]),
+      providerNames: {},
+    })
+    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
+  })
+
+  test("resolves name from providerNames", () => {
+    const result = resolvePluginProviders({
+      hooks: [hookWithAuth("portkey")],
+      existingProviders: {},
+      disabled: new Set(),
+      providerNames: { portkey: "Portkey AI" },
+    })
+    expect(result).toEqual([{ id: "portkey", name: "Portkey AI" }])
+  })
+
+  test("falls back to id when no name configured", () => {
+    const result = resolvePluginProviders({
+      hooks: [hookWithAuth("portkey")],
+      existingProviders: {},
+      disabled: new Set(),
+      providerNames: {},
+    })
+    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
+  })
+
+  test("skips hooks without auth", () => {
+    const result = resolvePluginProviders({
+      hooks: [hookWithoutAuth(), hookWithAuth("portkey"), hookWithoutAuth()],
+      existingProviders: {},
+      disabled: new Set(),
+      providerNames: {},
+    })
+    expect(result).toEqual([{ id: "portkey", name: "portkey" }])
+  })
+
+  test("returns empty for no hooks", () => {
+    const result = resolvePluginProviders({
+      hooks: [],
+      existingProviders: {},
+      disabled: new Set(),
+      providerNames: {},
+    })
+    expect(result).toEqual([])
+  })
+})

package/test/cli/pr.test.ts

@@ -0,0 +1,59 @@
+import { expect, test } from "bun:test"
+import { cliCommand } from "../../src/cli/cmd/pr"
+
+test("cliCommand uses the current script when argv[1] is a file path", () => {
+  const result = cliCommand({
+    execPath: "/usr/bin/node",
+    argv: ["/usr/bin/node", "/tmp/saeeol.js", "pr", "1"],
+    exists: (file) => file === "/tmp/saeeol.js",
+  })
+
+  expect(result).toEqual(["/usr/bin/node", "/tmp/saeeol.js"])
+})
+
+test("cliCommand falls back to execPath when argv[1] is a subcommand", () => {
+  const result = cliCommand({
+    execPath: "/usr/local/bin/saeeol",
+    argv: ["/usr/local/bin/saeeol", "pr", "1"],
+    exists: () => false,
+  })
+
+  expect(result).toEqual(["/usr/local/bin/saeeol"])
+})
+
+test("cliCommand ignores subcommand token even when it exists on disk", () => {
+  const result = cliCommand({
+    execPath: "/usr/local/bin/saeeol",
+    argv: ["/usr/local/bin/saeeol", "pr", "1"],
+    exists: (file) => file === "pr",
+  })
+
+  expect(result).toEqual(["/usr/local/bin/saeeol"])
+})
+
+test("cliCommand falls back to execPath when argv[1] is missing", () => {
+  const result = cliCommand({
+    execPath: "/usr/local/bin/saeeol",
+    argv: ["/usr/local/bin/saeeol"],
+    exists: () => false,
+  })
+
+  expect(result).toEqual(["/usr/local/bin/saeeol"])
+})
+
+test("cliCommand falls back to execPath for bun virtual script paths", () => {
+  const unix = cliCommand({
+    execPath: "/tmp/saeeol",
+    argv: ["/tmp/saeeol", "/$bunfs/root/src/index.js", "pr", "1"],
+    exists: () => true,
+  })
+
+  const win = cliCommand({
+    execPath: "C:/tmp/saeeol.exe",
+    argv: ["C:/tmp/saeeol.exe", "B:/~BUN/root/src/index.js", "pr", "1"],
+    exists: () => true,
+  })
+
+  expect(unix).toEqual(["/tmp/saeeol"])
+  expect(win).toEqual(["C:/tmp/saeeol.exe"])
+})