saeeol 1.2.5 → 1.2.8

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

@@ -1,333 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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)
-  })
-})