saeeol 1.2.9 → 1.3.1

package/test/share/share-next.test.ts

@@ -0,0 +1,333 @@
+import { NodeFileSystem } from "@effect/platform-node"
+import { beforeEach, describe, expect } from "bun:test"
+import { Effect, Exit, Layer, Option } from "effect"
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
+
+import { AccessToken, AccountID, OrgID, RefreshToken } from "../../src/account/schema"
+import { Account } from "../../src/account/account"
+import { AccountRepo } from "../../src/account/repo"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { Bus } from "../../src/bus"
+import { Config } from "@/config/config"
+import { Provider } from "@/provider/provider"
+import { Session } from "@/session/session"
+import type { SessionID } from "../../src/session/schema"
+import { ShareNext } from "@/share/share-next"
+import { SessionShareTable } from "../../src/share/share.sql"
+import { Database } from "@/storage/db"
+import { eq } from "drizzle-orm"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { resetDatabase } from "../fixture/db"
+import { testEffect } from "../lib/effect"
+
+const env = Layer.mergeAll(
+  Session.defaultLayer,
+  AccountRepo.layer,
+  NodeFileSystem.layer,
+  CrossSpawnSpawner.defaultLayer,
+)
+const it = testEffect(env)
+
+const json = (req: Parameters<typeof HttpClientResponse.fromWeb>[0], body: unknown, status = 200) =>
+  HttpClientResponse.fromWeb(
+    req,
+    new Response(JSON.stringify(body), {
+      status,
+      headers: { "content-type": "application/json" },
+    }),
+  )
+
+const none = HttpClient.make(() => Effect.die("unexpected http call"))
+
+function live(client: HttpClient.HttpClient) {
+  const http = Layer.succeed(HttpClient.HttpClient, client)
+  return ShareNext.layer.pipe(
+    Layer.provide(Bus.layer),
+    Layer.provide(Account.layer.pipe(Layer.provide(AccountRepo.layer), Layer.provide(http))),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(http),
+    Layer.provide(Provider.defaultLayer),
+    Layer.provide(Session.defaultLayer),
+  )
+}
+
+function wired(client: HttpClient.HttpClient) {
+  const http = Layer.succeed(HttpClient.HttpClient, client)
+  return Layer.mergeAll(
+    Bus.layer,
+    ShareNext.layer,
+    Session.defaultLayer,
+    AccountRepo.layer,
+    NodeFileSystem.layer,
+    CrossSpawnSpawner.defaultLayer,
+  ).pipe(
+    Layer.provide(Bus.layer),
+    Layer.provide(Account.layer.pipe(Layer.provide(AccountRepo.layer), Layer.provide(http))),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(http),
+    Layer.provide(Provider.defaultLayer),
+  )
+}
+
+const share = (id: SessionID) =>
+  Database.use((db) => db.select().from(SessionShareTable).where(eq(SessionShareTable.session_id, id)).get())
+
+const seed = (url: string, org?: string) =>
+  AccountRepo.Service.use((repo) =>
+    repo.persistAccount({
+      id: AccountID.make("account-1"),
+      email: "user@example.com",
+      url,
+      accessToken: AccessToken.make("st_test_token"),
+      refreshToken: RefreshToken.make("rt_test_token"),
+      expiry: Date.now() + 10 * 60_000,
+      orgID: org ? Option.some(OrgID.make(org)) : Option.none(),
+    }),
+  )
+
+beforeEach(async () => {
+  await resetDatabase()
+})
+
+describe("ShareNext", () => {
+  it.live("request uses legacy share API without active org account", () =>
+    provideTmpdirInstance(
+      () =>
+        ShareNext.Service.use((svc) =>
+          Effect.gen(function* () {
+            const req = yield* svc.request()
+
+            expect(req.api.create).toBe("/api/share")
+            expect(req.api.sync("shr_123")).toBe("/api/share/shr_123/sync")
+            expect(req.api.remove("shr_123")).toBe("/api/share/shr_123")
+            expect(req.api.data("shr_123")).toBe("/api/share/shr_123/data")
+            expect(req.baseUrl).toBe("https://legacy-share.example.com")
+            expect(req.headers).toEqual({})
+          }),
+        ).pipe(Effect.provide(live(none))),
+      { config: { enterprise: { url: "https://legacy-share.example.com" } } },
+    ),
+  )
+
+  it.live("request uses default URL when no enterprise config", () =>
+    provideTmpdirInstance(() =>
+      ShareNext.Service.use((svc) =>
+        Effect.gen(function* () {
+          const req = yield* svc.request()
+
+          expect(req.baseUrl).toBe("https://opncd.ai")
+          expect(req.api.create).toBe("/api/share")
+          expect(req.headers).toEqual({})
+        }),
+      ).pipe(Effect.provide(live(none))),
+    ),
+  )
+
+  it.live("request uses org share API with auth headers when account is active", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        yield* seed("https://control.example.com", "org-1")
+
+        const req = yield* ShareNext.Service.use((svc) => svc.request()).pipe(Effect.provide(live(none)))
+
+        expect(req.api.create).toBe("/api/shares")
+        expect(req.api.sync("shr_123")).toBe("/api/shares/shr_123/sync")
+        expect(req.api.remove("shr_123")).toBe("/api/shares/shr_123")
+        expect(req.api.data("shr_123")).toBe("/api/shares/shr_123/data")
+        expect(req.baseUrl).toBe("https://control.example.com")
+        expect(req.headers).toEqual({
+          authorization: "Bearer st_test_token",
+          "x-org-id": "org-1",
+        })
+      }),
+    ),
+  )
+
+  it.live("create posts share, persists it, and returns the result", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const session = yield* Session.Service.use((svc) => svc.create({ title: "test" }))
+          const seen: HttpClientRequest.HttpClientRequest[] = []
+          const client = HttpClient.make((req) => {
+            seen.push(req)
+            if (req.url.endsWith("/api/share")) {
+              return Effect.succeed(
+                json(req, {
+                  id: "shr_abc",
+                  url: "https://legacy-share.example.com/share/abc",
+                  secret: "sec_123",
+                }),
+              )
+            }
+            return Effect.succeed(json(req, { ok: true }))
+          })
+
+          const result = yield* ShareNext.Service.use((svc) => svc.create(session.id)).pipe(
+            Effect.provide(live(client)),
+          )
+
+          expect(result.id).toBe("shr_abc")
+          expect(result.url).toBe("https://legacy-share.example.com/share/abc")
+          expect(result.secret).toBe("sec_123")
+
+          const row = share(session.id)
+          expect(row?.id).toBe("shr_abc")
+          expect(row?.url).toBe("https://legacy-share.example.com/share/abc")
+          expect(row?.secret).toBe("sec_123")
+
+          expect(seen).toHaveLength(1)
+          expect(seen[0].method).toBe("POST")
+          expect(seen[0].url).toBe("https://legacy-share.example.com/api/share")
+        }),
+      { config: { enterprise: { url: "https://legacy-share.example.com" } } },
+    ),
+  )
+
+  it.live("remove deletes the persisted share and calls the delete endpoint", () =>
+    provideTmpdirInstance(
+      () =>
+        Effect.gen(function* () {
+          const session = yield* Session.Service.use((svc) => svc.create({ title: "test" }))
+          const seen: HttpClientRequest.HttpClientRequest[] = []
+          const client = HttpClient.make((req) => {
+            seen.push(req)
+            if (req.method === "POST") {
+              return Effect.succeed(
+                json(req, {
+                  id: "shr_abc",
+                  url: "https://legacy-share.example.com/share/abc",
+                  secret: "sec_123",
+                }),
+              )
+            }
+            return Effect.succeed(HttpClientResponse.fromWeb(req, new Response(null, { status: 200 })))
+          })
+
+          yield* Effect.gen(function* () {
+            yield* ShareNext.Service.use((svc) => svc.create(session.id))
+            yield* ShareNext.Service.use((svc) => svc.remove(session.id))
+          }).pipe(Effect.provide(live(client)))
+
+          expect(share(session.id)).toBeUndefined()
+          expect(seen.map((req) => [req.method, req.url])).toEqual([
+            ["POST", "https://legacy-share.example.com/api/share"],
+            ["DELETE", "https://legacy-share.example.com/api/share/shr_abc"],
+          ])
+        }),
+      { config: { enterprise: { url: "https://legacy-share.example.com" } } },
+    ),
+  )
+
+  it.live("create fails on a non-ok response and does not persist a share", () =>
+    provideTmpdirInstance(() =>
+      Effect.gen(function* () {
+        const session = yield* Session.Service.use((svc) => svc.create({ title: "test" }))
+        const client = HttpClient.make((req) => Effect.succeed(json(req, { error: "bad" }, 500)))
+
+        const exit = yield* ShareNext.Service.use((svc) => Effect.exit(svc.create(session.id))).pipe(
+          Effect.provide(live(client)),
+        )
+
+        expect(Exit.isFailure(exit)).toBe(true)
+        expect(share(session.id)).toBeUndefined()
+      }),
+    ),
+  )
+
+  it.live("ShareNext coalesces rapid diff events into one delayed sync with latest data", () =>
+    provideTmpdirInstance(
+      () => {
+        const seen: Array<{ url: string; body: string }> = []
+        const client = HttpClient.make((req) => {
+          if (req.url.endsWith("/sync") && req.body._tag === "Uint8Array") {
+            seen.push({ url: req.url, body: new TextDecoder().decode(req.body.body) })
+          }
+          return Effect.succeed(json(req, { ok: true }))
+        })
+
+        return Effect.gen(function* () {
+          const bus = yield* Bus.Service
+          const share = yield* ShareNext.Service
+          const session = yield* Session.Service
+
+          const info = yield* session.create({ title: "first" })
+          yield* share.init()
+          yield* Effect.sleep(50)
+          yield* Effect.sync(() =>
+            Database.use((db) =>
+              db
+                .insert(SessionShareTable)
+                .values({
+                  session_id: info.id,
+                  id: "shr_abc",
+                  url: "https://legacy-share.example.com/share/abc",
+                  secret: "sec_123",
+                })
+                .run(),
+            ),
+          )
+
+          yield* bus.publish(Session.Event.Diff, {
+            sessionID: info.id,
+            diff: [
+              {
+                file: "a.ts",
+                patch:
+                  "Index: a.ts\n===================================================================\n--- a.ts\t\n+++ a.ts\t\n@@ -1,1 +1,1 @@\n-one\n\\n+two\n\\n",
+                additions: 1,
+                deletions: 1,
+                status: "modified",
+              },
+            ],
+          })
+          yield* bus.publish(Session.Event.Diff, {
+            sessionID: info.id,
+            diff: [
+              {
+                file: "b.ts",
+                patch:
+                  "Index: b.ts\n===================================================================\n--- b.ts\t\n+++ b.ts\t\n@@ -1,1 +1,1 @@\n-old\n\\n+new\n\\n",
+                additions: 2,
+                deletions: 0,
+                status: "modified",
+              },
+            ],
+          })
+          yield* Effect.sleep(1_250)
+
+          expect(seen).toHaveLength(1)
+          expect(seen[0].url).toBe("https://legacy-share.example.com/api/share/shr_abc/sync")
+
+          const body = JSON.parse(seen[0].body) as {
+            secret: string
+            data: Array<{
+              type: string
+              data: Array<{
+                file: string
+                patch: string
+                additions: number
+                deletions: number
+                status?: string
+              }>
+            }>
+          }
+          expect(body.secret).toBe("sec_123")
+          expect(body.data).toHaveLength(1)
+          expect(body.data[0].type).toBe("session_diff")
+          expect(body.data[0].data).toEqual([
+            {
+              file: "b.ts",
+              patch:
+                "Index: b.ts\n===================================================================\n--- b.ts\t\n+++ b.ts\t\n@@ -1,1 +1,1 @@\n-old\n\\n+new\n\\n",
+              additions: 2,
+              deletions: 0,
+              status: "modified",
+            },
+          ])
+        }).pipe(Effect.provide(wired(client)))
+      },
+      { config: { enterprise: { url: "https://legacy-share.example.com" } } },
+    ),
+  )
+})

package/test/shell/shell.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from "bun:test"
+import path from "path"
+import { Shell } from "../../src/shell/shell"
+import { Filesystem } from "@/util/filesystem"
+import { which } from "../../src/util/which"
+
+const withShell = async (shell: string | undefined, fn: () => void | Promise<void>) => {
+  const prev = process.env.SHELL
+  if (shell === undefined) delete process.env.SHELL
+  else process.env.SHELL = shell
+  Shell.acceptable.reset()
+  Shell.preferred.reset()
+  try {
+    await fn()
+  } finally {
+    if (prev === undefined) delete process.env.SHELL
+    else process.env.SHELL = prev
+    Shell.acceptable.reset()
+    Shell.preferred.reset()
+  }
+}
+
+describe("shell", () => {
+  test("normalizes shell names", () => {
+    expect(Shell.name("/bin/bash")).toBe("bash")
+    if (process.platform === "win32") {
+      expect(Shell.name("C:/tools/NU.EXE")).toBe("nu")
+      expect(Shell.name("C:/tools/PWSH.EXE")).toBe("pwsh")
+    }
+  })
+
+  test("detects login shells", () => {
+    expect(Shell.login("/bin/bash")).toBe(true)
+    expect(Shell.login("C:/tools/pwsh.exe")).toBe(false)
+  })
+
+  test("detects posix shells", () => {
+    expect(Shell.posix("/bin/bash")).toBe(true)
+    expect(Shell.posix("/bin/fish")).toBe(false)
+    expect(Shell.posix("C:/tools/pwsh.exe")).toBe(false)
+  })
+
+  test("falls back when configured shell cannot be resolved", async () => {
+    await withShell(undefined, async () => {
+      const preferred = Shell.preferred()
+      const acceptable = Shell.acceptable()
+      expect(Shell.preferred("saeeol-missing-shell")).toBe(preferred)
+      expect(Shell.acceptable("saeeol-missing-shell")).toBe(acceptable)
+    })
+  })
+
+  test("falls back for terminal-only acceptable shells", () => {
+    expect(Shell.name(Shell.acceptable("fish"))).not.toBe("fish")
+    expect(Shell.name(Shell.acceptable("nu"))).not.toBe("nu")
+  })
+
+  if (process.platform === "win32") {
+    test("rejects blacklisted shells case-insensitively", async () => {
+      await withShell("NU.EXE", async () => {
+        expect(Shell.name(Shell.acceptable())).not.toBe("nu")
+      })
+    })
+
+    test("normalizes Git Bash shell paths from env", async () => {
+      const shell = "/cygdrive/c/Program Files/Git/bin/bash.exe"
+      await withShell(shell, async () => {
+        expect(Shell.preferred()).toBe(Filesystem.windowsPath(shell))
+      })
+    })
+
+    test("resolves /usr/bin/bash from env to Git Bash", async () => {
+      const bash = Shell.gitbash()
+      if (!bash) return
+      await withShell("/usr/bin/bash", async () => {
+        expect(Shell.acceptable()).toBe(bash)
+        expect(Shell.preferred()).toBe(bash)
+      })
+    })
+
+    test("resolves bare bash to Git Bash before PATH", async () => {
+      const bash = Shell.gitbash()
+      if (!bash) return
+      expect(Shell.acceptable("bash")).toBe(bash)
+      expect(Shell.preferred("bash")).toBe(bash)
+      await withShell("bash", async () => {
+        expect(Shell.acceptable()).toBe(bash)
+        expect(Shell.preferred()).toBe(bash)
+      })
+    })
+
+    test("resolves bare PowerShell shells", async () => {
+      const shell = which("pwsh") || which("powershell")
+      if (!shell) return
+      await withShell(path.win32.basename(shell), async () => {
+        expect(Shell.preferred()).toBe(shell)
+      })
+    })
+  }
+})

package/test/skill/discovery.test.ts

@@ -0,0 +1,116 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test"
+import { Effect } from "effect"
+import { Discovery } from "../../src/skill/discovery"
+import { Global } from "@saeeol/core/global"
+import { Filesystem } from "@/util/filesystem"
+import { rm } from "fs/promises"
+import path from "path"
+
+let CLOUDFLARE_SKILLS_URL: string
+let server: ReturnType<typeof Bun.serve>
+let downloadCount = 0
+
+const fixturePath = path.join(import.meta.dir, "../fixture/skills")
+const cacheDir = path.join(Global.Path.cache, "skills")
+
+beforeAll(async () => {
+  await rm(cacheDir, { recursive: true, force: true })
+
+  server = Bun.serve({
+    port: 0,
+    async fetch(req) {
+      const url = new URL(req.url)
+
+      // route /.well-known/skills/* to the fixture directory
+      if (url.pathname.startsWith("/.well-known/skills/")) {
+        const filePath = url.pathname.replace("/.well-known/skills/", "")
+        const fullPath = path.join(fixturePath, filePath)
+
+        if (await Filesystem.exists(fullPath)) {
+          if (!fullPath.endsWith("index.json")) {
+            downloadCount++
+          }
+          return new Response(Bun.file(fullPath))
+        }
+      }
+
+      return new Response("Not Found", { status: 404 })
+    },
+  })
+
+  CLOUDFLARE_SKILLS_URL = `http://localhost:${server.port}/.well-known/skills/`
+})
+
+afterAll(async () => {
+  void server?.stop()
+  await rm(cacheDir, { recursive: true, force: true })
+})
+
+describe("Discovery.pull", () => {
+  const pull = (url: string) =>
+    Effect.runPromise(Discovery.Service.use((s) => s.pull(url)).pipe(Effect.provide(Discovery.defaultLayer)))
+
+  test("downloads skills from cloudflare url", async () => {
+    const dirs = await pull(CLOUDFLARE_SKILLS_URL)
+    expect(dirs.length).toBeGreaterThan(0)
+    for (const dir of dirs) {
+      expect(dir).toStartWith(cacheDir)
+      const md = path.join(dir, "SKILL.md")
+      expect(await Filesystem.exists(md)).toBe(true)
+    }
+  })
+
+  test("url without trailing slash works", async () => {
+    const dirs = await pull(CLOUDFLARE_SKILLS_URL.replace(/\/$/, ""))
+    expect(dirs.length).toBeGreaterThan(0)
+    for (const dir of dirs) {
+      const md = path.join(dir, "SKILL.md")
+      expect(await Filesystem.exists(md)).toBe(true)
+    }
+  })
+
+  test("returns empty array for invalid url", async () => {
+    const dirs = await pull(`http://localhost:${server.port}/invalid-url/`)
+    expect(dirs).toEqual([])
+  })
+
+  test("returns empty array for non-json response", async () => {
+    // any url not explicitly handled in server returns 404 text "Not Found"
+    const dirs = await pull(`http://localhost:${server.port}/some-other-path/`)
+    expect(dirs).toEqual([])
+  })
+
+  test("downloads reference files alongside SKILL.md", async () => {
+    const dirs = await pull(CLOUDFLARE_SKILLS_URL)
+    // find a skill dir that should have reference files (e.g. agents-sdk)
+    const agentsSdk = dirs.find((d) => d.endsWith(path.sep + "agents-sdk"))
+    expect(agentsSdk).toBeDefined()
+    if (agentsSdk) {
+      const refs = path.join(agentsSdk, "references")
+      expect(await Filesystem.exists(path.join(agentsSdk, "SKILL.md"))).toBe(true)
+      // agents-sdk has reference files per the index
+      const refDir = await Array.fromAsync(new Bun.Glob("**/*.md").scan({ cwd: refs, onlyFiles: true }))
+      expect(refDir.length).toBeGreaterThan(0)
+    }
+  })
+
+  test("caches downloaded files on second pull", async () => {
+    // clear dir and downloadCount
+    await rm(cacheDir, { recursive: true, force: true })
+    downloadCount = 0
+
+    // first pull to populate cache
+    const first = await pull(CLOUDFLARE_SKILLS_URL)
+    expect(first.length).toBeGreaterThan(0)
+    const firstCount = downloadCount
+    expect(firstCount).toBeGreaterThan(0)
+
+    // second pull should return same results from cache
+    const second = await pull(CLOUDFLARE_SKILLS_URL)
+    expect(second.length).toBe(first.length)
+    expect(second.sort()).toEqual(first.sort())
+
+    // second pull should NOT increment download count
+    expect(downloadCount).toBe(firstCount)
+  })
+})