saeeol 1.2.5 → 1.2.7

package/test/server/httpapi-workspace.test.ts

@@ -1,427 +0,0 @@
-import { afterEach, describe, expect, mock } from "bun:test"
-import { NodeServices } from "@effect/platform-node"
-import { mkdir } from "node:fs/promises"
-import path from "node:path"
-import { Effect, Layer } from "effect"
-import { Flag } from "@saeeol/core/flag/flag"
-import { registerAdapter } from "../../src/control-plane/adapters"
-import type { WorkspaceAdapter } from "../../src/control-plane/types"
-import { Workspace } from "../../src/control-plane/workspace"
-import { WorkspacePaths } from "../../src/server/routes/instance/httpapi/groups/workspace"
-import { Session } from "@/session/session"
-import * as Log from "@saeeol/core/util/log"
-import { Server } from "../../src/server/server"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, provideInstance, tmpdirScoped } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-import { Project } from "../../src/project/project"
-import { InstancePaths } from "../../src/server/routes/instance/httpapi/groups/instance"
-import { WorkspaceRef } from "../../src/effect/instance-ref"
-import { testEffect } from "../lib/effect"
-
-void Log.init({ print: false })
-
-const originalWorkspaces = Flag.SAEEOL_EXPERIMENTAL_WORKSPACES
-const originalHttpApi = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-const it = testEffect(
-  Layer.mergeAll(NodeServices.layer, Project.defaultLayer, Session.defaultLayer, Workspace.defaultLayer),
-)
-
-function request(path: string, directory: string, init: RequestInit = {}, httpApi = true) {
-  return Effect.promise(() => {
-    Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = httpApi
-    const headers = new Headers(init.headers)
-    headers.set("x-saeeol-directory", directory)
-    return Promise.resolve(Server.Default().app.request(path, { ...init, headers }))
-  })
-}
-
-function localAdapter(directory: string): WorkspaceAdapter {
-  return {
-    name: "Local Test",
-    description: "Create a local test workspace",
-    configure(info) {
-      return {
-        ...info,
-        name: "local-test",
-        directory,
-      }
-    },
-    async create() {
-      await mkdir(directory, { recursive: true })
-    },
-    async remove() {},
-    target() {
-      return {
-        type: "local" as const,
-        directory,
-      }
-    },
-  }
-}
-
-function remoteAdapter(directory: string, url: string, headers?: HeadersInit): WorkspaceAdapter {
-  return {
-    name: "Remote Test",
-    description: "Create a remote test workspace",
-    configure(info) {
-      return {
-        ...info,
-        name: "remote-test",
-        directory,
-      }
-    },
-    async create() {
-      await mkdir(directory, { recursive: true })
-    },
-    async remove() {},
-    target() {
-      return {
-        type: "remote" as const,
-        url,
-        headers,
-      }
-    },
-  }
-}
-
-type ProxiedRequest = {
-  url: string
-  method: string
-  headers: Record<string, string>
-  body: string
-}
-
-function listenRemoteHttp(handler: (request: ProxiedRequest) => Response | Promise<Response>) {
-  return Bun.serve({
-    port: 0,
-    async fetch(request) {
-      return handler({
-        url: request.url,
-        method: request.method,
-        headers: Object.fromEntries(request.headers.entries()),
-        body: await request.text(),
-      })
-    },
-  })
-}
-
-function eventStreamResponse() {
-  return new Response(
-    new ReadableStream({
-      start(controller) {
-        controller.enqueue(
-          new TextEncoder().encode('data: {"payload":{"type":"server.connected","properties":{}}}\n\n'),
-        )
-      },
-    }),
-    {
-      status: 200,
-      headers: {
-        "content-type": "text/event-stream",
-      },
-    },
-  )
-}
-
-afterEach(async () => {
-  mock.restore()
-  Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = originalWorkspaces
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = originalHttpApi
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-describe("workspace HttpApi", () => {
-  it.live("serves read endpoints", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped({ git: true })
-
-      const [adapters, workspaces, status] = yield* Effect.all([
-        request(WorkspacePaths.adapters, dir),
-        request(WorkspacePaths.list, dir),
-        request(WorkspacePaths.status, dir),
-      ])
-
-      expect(adapters.status).toBe(200)
-      expect(yield* Effect.promise(() => adapters.json())).toContainEqual({
-        type: "worktree",
-        name: "Worktree",
-        description: "Create a git worktree",
-      })
-
-      expect(workspaces.status).toBe(200)
-      expect(yield* Effect.promise(() => workspaces.json())).toEqual([])
-
-      expect(status.status).toBe(200)
-      expect(yield* Effect.promise(() => status.json())).toEqual([])
-    }),
-  )
-
-  it.live("serves mutation endpoints", () =>
-    Effect.gen(function* () {
-      Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
-      const dir = yield* tmpdirScoped({ git: true })
-      const project = yield* Project.use.fromDirectory(dir)
-      registerAdapter(project.project.id, "local-test", localAdapter(path.join(dir, ".workspace")))
-
-      const created = yield* request(WorkspacePaths.list, dir, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ type: "local-test", branch: null, extra: null }),
-      })
-      expect(created.status).toBe(200)
-      const workspace = (yield* Effect.promise(() => created.json())) as Workspace.Info
-      expect(workspace).toMatchObject({ type: "local-test", name: "local-test" })
-
-      const session = yield* Session.Service.use((svc) => svc.create({})).pipe(provideInstance(dir))
-      const restored = yield* request(WorkspacePaths.sessionRestore.replace(":id", workspace.id), dir, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ sessionID: session.id }),
-      })
-      expect(restored.status).toBe(200)
-      expect((yield* Effect.promise(() => restored.json())) as { total: number }).toMatchObject({
-        total: expect.any(Number),
-      })
-
-      const removed = yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
-      expect(removed.status).toBe(200)
-      expect(yield* Effect.promise(() => removed.json())).toMatchObject({ id: workspace.id })
-
-      const listed = yield* request(WorkspacePaths.list, dir)
-      expect(listed.status).toBe(200)
-      expect(yield* Effect.promise(() => listed.json())).toEqual([])
-    }),
-  )
-
-  it.live("creates workspace with the TUI payload shape", () =>
-    Effect.gen(function* () {
-      Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
-      const dir = yield* tmpdirScoped({ git: true })
-      const project = yield* Project.use.fromDirectory(dir)
-      registerAdapter(project.project.id, "local-test", localAdapter(path.join(dir, ".workspace")))
-
-      const created = yield* request(WorkspacePaths.list, dir, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ type: "local-test", branch: null }),
-      })
-
-      expect(created.status).toBe(200)
-      expect((yield* Effect.promise(() => created.json())) as Workspace.Info).toMatchObject({
-        type: "local-test",
-        name: "local-test",
-        extra: null,
-      })
-    }),
-  )
-
-  it.live("creates a real git worktree workspace via the builtin adapter", () =>
-    Effect.gen(function* () {
-      Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
-      const dir = yield* tmpdirScoped({ git: true })
-
-      const created = yield* request(WorkspacePaths.list, dir, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ type: "worktree", branch: null }),
-      })
-
-      const body = yield* Effect.promise(() => created.text())
-      expect({ status: created.status, body }).toMatchObject({ status: 200 })
-      const workspace = JSON.parse(body) as Workspace.Info
-      expect(workspace).toMatchObject({ type: "worktree" })
-    }),
-  )
-
-  it.live("documents legacy Hono accepting the TUI payload shape", () =>
-    Effect.gen(function* () {
-      Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
-      const dir = yield* tmpdirScoped({ git: true })
-      const project = yield* Project.use.fromDirectory(dir)
-      registerAdapter(project.project.id, "local-test", localAdapter(path.join(dir, ".workspace")))
-
-      const created = yield* request(
-        WorkspacePaths.list,
-        dir,
-        {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ type: "local-test", branch: null }),
-        },
-        false,
-      )
-
-      expect(created.status).toBe(200)
-      expect((yield* Effect.promise(() => created.json())) as Workspace.Info).toMatchObject({
-        type: "local-test",
-        name: "local-test",
-        extra: null,
-      })
-    }),
-  )
-
-  it.live("routes local workspace requests through the workspace target directory", () =>
-    Effect.gen(function* () {
-      Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
-      const dir = yield* tmpdirScoped({ git: true })
-      const workspaceDir = path.join(dir, ".workspace-local")
-      const project = yield* Project.use.fromDirectory(dir)
-      registerAdapter(project.project.id, "local-target", localAdapter(workspaceDir))
-      const created = yield* request(WorkspacePaths.list, dir, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ type: "local-target", branch: null, extra: null }),
-      })
-      const workspace = (yield* Effect.promise(() => created.json())) as Workspace.Info
-
-      const url = new URL(`http://localhost${InstancePaths.path}`)
-      url.searchParams.set("workspace", workspace.id)
-
-      const response = yield* request(url.toString(), dir)
-
-      expect(response.status).toBe(200)
-      expect(yield* Effect.promise(() => response.json())).toMatchObject({ directory: workspaceDir })
-      yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
-    }),
-  )
-
-  it.live("proxies remote workspace HTTP requests with sanitized forwarding", () =>
-    Effect.gen(function* () {
-      Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
-      const dir = yield* tmpdirScoped({ git: true })
-      const proxied: ProxiedRequest[] = []
-      const remote = listenRemoteHttp((request) => {
-        proxied.push(request)
-        const url = new URL(request.url)
-        if (url.pathname === "/base/global/event") return eventStreamResponse()
-        if (url.pathname === "/base/sync/history") return Response.json([])
-        return new Response(
-          JSON.stringify({
-            proxied: true,
-            path: url.pathname,
-            keep: url.searchParams.get("keep"),
-            workspace: url.searchParams.get("workspace"),
-          }),
-          {
-            status: 201,
-            statusText: "Created",
-            headers: {
-              "content-length": "999",
-              "content-type": "application/json",
-              "x-remote": "yes",
-            },
-          },
-        )
-      })
-
-      const project = yield* Project.use.fromDirectory(dir)
-      registerAdapter(
-        project.project.id,
-        "remote-target",
-        remoteAdapter(path.join(dir, ".remote"), `http://127.0.0.1:${remote.port}/base`, {
-          "x-target-auth": "secret",
-        }),
-      )
-      const created = yield* request(WorkspacePaths.list, dir, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ type: "remote-target", branch: null, extra: null }),
-      })
-      const workspace = (yield* Effect.promise(() => created.json())) as Workspace.Info
-
-      const url = new URL("http://localhost/config")
-      url.searchParams.set("workspace", workspace.id)
-      url.searchParams.set("keep", "yes")
-
-      try {
-        const response = yield* request(url.toString(), dir, {
-          method: "PATCH",
-          headers: {
-            "accept-encoding": "br",
-            "content-type": "application/json",
-            "x-saeeol-workspace": "internal",
-          },
-          body: JSON.stringify({ $schema: "https://saeeol.ai/config.json" }),
-        })
-
-        const responseBody = yield* Effect.promise(() => response.text())
-        expect({ status: response.status, body: responseBody }).toMatchObject({ status: 201 })
-        expect(response.headers.get("content-length")).toBeNull()
-        expect(response.headers.get("x-remote")).toBe("yes")
-        expect(JSON.parse(responseBody)).toEqual({ proxied: true, path: "/base/config", keep: "yes", workspace: null })
-        const forwarded = proxied.filter((item) => new URL(item.url).pathname === "/base/config")
-        expect(forwarded).toEqual([
-          {
-            url: `http://127.0.0.1:${remote.port}/base/config?keep=yes`,
-            method: "PATCH",
-            headers: expect.objectContaining({
-              "content-type": "application/json",
-              "x-target-auth": "secret",
-            }),
-            body: JSON.stringify({ $schema: "https://saeeol.ai/config.json" }),
-          },
-        ])
-        expect(forwarded[0]?.headers).not.toHaveProperty("x-saeeol-directory")
-        expect(forwarded[0]?.headers).not.toHaveProperty("x-saeeol-workspace")
-      } finally {
-        void remote.stop(true)
-        yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
-      }
-    }),
-  )
-
-  it.live("proxies remote workspace requests selected from session ownership", () =>
-    Effect.gen(function* () {
-      Flag.SAEEOL_EXPERIMENTAL_WORKSPACES = true
-      const dir = yield* tmpdirScoped({ git: true })
-      const proxied: ProxiedRequest[] = []
-      const remote = listenRemoteHttp((request) => {
-        proxied.push(request)
-        const url = new URL(request.url)
-        if (url.pathname === "/base/global/event") return eventStreamResponse()
-        if (url.pathname === "/base/sync/history") return Response.json([])
-        return Response.json({ proxied: true, path: new URL(request.url).pathname })
-      })
-
-      const project = yield* Project.use.fromDirectory(dir)
-      registerAdapter(
-        project.project.id,
-        "remote-session-target",
-        remoteAdapter(path.join(dir, ".remote-session"), `http://127.0.0.1:${remote.port}/base`),
-      )
-      const created = yield* request(WorkspacePaths.list, dir, {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({ type: "remote-session-target", branch: null, extra: null }),
-      })
-      const workspace = (yield* Effect.promise(() => created.json())) as Workspace.Info
-      const session = yield* Session.Service.use((svc) => svc.create()).pipe(
-        Effect.provideService(WorkspaceRef, workspace.id),
-        provideInstance(dir),
-      )
-
-      try {
-        const response = yield* request(`http://localhost/session/${session.id}/message`, dir, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ parts: [{ type: "text", text: "hello" }] }),
-        })
-
-        const responseBody = yield* Effect.promise(() => response.text())
-        expect({ status: response.status, body: responseBody }).toMatchObject({ status: 200 })
-        expect(JSON.parse(responseBody)).toEqual({ proxied: true, path: `/base/session/${session.id}/message` })
-        expect(proxied.filter((item) => new URL(item.url).pathname === `/base/session/${session.id}/message`)).toEqual([
-          expect.objectContaining({
-            url: `http://127.0.0.1:${remote.port}/base/session/${session.id}/message`,
-            method: "POST",
-          }),
-        ])
-      } finally {
-        void remote.stop(true)
-        yield* request(WorkspacePaths.remove.replace(":id", workspace.id), dir, { method: "DELETE" })
-      }
-    }),
-  )
-})

package/test/server/project-init-git.test.ts

@@ -1,113 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import path from "path"
-import { GlobalBus } from "../../src/bus/global"
-import { Snapshot } from "../../src/snapshot"
-import { Server } from "../../src/server/server"
-import { Filesystem } from "@/util/filesystem"
-import * as Log from "@saeeol/core/util/log"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, provideInstance, tmpdir } from "../fixture/fixture"
-
-void Log.init({ print: false })
-
-afterEach(async () => {
-  await resetDatabase()
-})
-
-const disposedEvents = (seen: { directory?: string; payload: { type: string } }[], dir: string) =>
-  seen.filter((evt) => evt.directory === dir && evt.payload.type === "server.instance.disposed").length
-
-describe("project.initGit endpoint", () => {
-  test("initializes git and reloads immediately", async () => {
-    await using tmp = await tmpdir()
-    const app = Server.Default().app
-    const seen: { directory?: string; payload: { type: string } }[] = []
-    const fn = (evt: { directory?: string; payload: { type: string } }) => {
-      seen.push(evt)
-    }
-    GlobalBus.on("event", fn)
-
-    try {
-      const init = await app.request("/project/git/init", {
-        method: "POST",
-        headers: {
-          "x-saeeol-directory": tmp.path,
-        },
-      })
-      const body = await init.json()
-      expect(init.status).toBe(200)
-      expect(body).toMatchObject({
-        id: "global",
-        vcs: "git",
-        worktree: tmp.path,
-      })
-      // Reload behavior: bus emits exactly one server.instance.disposed for the directory.
-      expect(disposedEvents(seen, tmp.path)).toBe(1)
-      expect(await Filesystem.exists(path.join(tmp.path, ".git", "saeeol"))).toBe(false)
-
-      const current = await app.request("/project/current", {
-        headers: {
-          "x-saeeol-directory": tmp.path,
-        },
-      })
-      expect(current.status).toBe(200)
-      expect(await current.json()).toMatchObject({
-        id: "global",
-        vcs: "git",
-        worktree: tmp.path,
-      })
-
-      expect(
-        await Effect.runPromise(
-          Snapshot.Service.use((svc) => svc.track()).pipe(
-            provideInstance(tmp.path),
-            Effect.provide(Snapshot.defaultLayer),
-          ),
-        ),
-      ).toBeTruthy()
-    } finally {
-      await disposeAllInstances()
-      GlobalBus.off("event", fn)
-    }
-  })
-
-  test("does not reload when the project is already git", async () => {
-    await using tmp = await tmpdir({ git: true })
-    const app = Server.Default().app
-    const seen: { directory?: string; payload: { type: string } }[] = []
-    const fn = (evt: { directory?: string; payload: { type: string } }) => {
-      seen.push(evt)
-    }
-    GlobalBus.on("event", fn)
-
-    try {
-      const init = await app.request("/project/git/init", {
-        method: "POST",
-        headers: {
-          "x-saeeol-directory": tmp.path,
-        },
-      })
-      expect(init.status).toBe(200)
-      expect(await init.json()).toMatchObject({
-        vcs: "git",
-        worktree: tmp.path,
-      })
-      expect(disposedEvents(seen, tmp.path)).toBe(0)
-
-      const current = await app.request("/project/current", {
-        headers: {
-          "x-saeeol-directory": tmp.path,
-        },
-      })
-      expect(current.status).toBe(200)
-      expect(await current.json()).toMatchObject({
-        vcs: "git",
-        worktree: tmp.path,
-      })
-    } finally {
-      await disposeAllInstances()
-      GlobalBus.off("event", fn)
-    }
-  })
-})

package/test/server/proxy-util.test.ts

@@ -1,113 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { ProxyUtil } from "../../src/server/proxy-util"
-
-describe("ProxyUtil", () => {
-  describe("websocketTargetURL", () => {
-    test("converts http to ws", () => {
-      expect(ProxyUtil.websocketTargetURL("http://example.com/path")).toBe("ws://example.com/path")
-    })
-
-    test("converts https to wss", () => {
-      expect(ProxyUtil.websocketTargetURL("https://example.com/path")).toBe("wss://example.com/path")
-    })
-
-    test("preserves query params", () => {
-      expect(ProxyUtil.websocketTargetURL("http://example.com/path?foo=bar")).toBe("ws://example.com/path?foo=bar")
-    })
-
-    test("accepts URL objects", () => {
-      expect(ProxyUtil.websocketTargetURL(new URL("http://localhost:3000/ws"))).toBe("ws://localhost:3000/ws")
-    })
-  })
-
-  describe("websocketProtocols", () => {
-    test("returns empty array when no header", () => {
-      const req = new Request("http://localhost")
-      expect(ProxyUtil.websocketProtocols(req)).toEqual([])
-    })
-
-    test("parses single protocol", () => {
-      const req = new Request("http://localhost", {
-        headers: { "sec-websocket-protocol": "graphql-ws" },
-      })
-      expect(ProxyUtil.websocketProtocols(req)).toEqual(["graphql-ws"])
-    })
-
-    test("parses multiple protocols", () => {
-      const req = new Request("http://localhost", {
-        headers: { "sec-websocket-protocol": "graphql-ws, graphql-transport-ws" },
-      })
-      expect(ProxyUtil.websocketProtocols(req)).toEqual(["graphql-ws", "graphql-transport-ws"])
-    })
-
-    test("trims whitespace and filters empty", () => {
-      const req = new Request("http://localhost", {
-        headers: { "sec-websocket-protocol": " proto1 , , proto2 " },
-      })
-      expect(ProxyUtil.websocketProtocols(req)).toEqual(["proto1", "proto2"])
-    })
-  })
-
-  describe("headers", () => {
-    test("strips hop-by-hop headers", () => {
-      const req = new Request("http://localhost", {
-        headers: {
-          connection: "keep-alive",
-          "keep-alive": "timeout=5",
-          "transfer-encoding": "chunked",
-          "content-type": "application/json",
-        },
-      })
-      const result = ProxyUtil.headers(req)
-      expect(result.get("connection")).toBeNull()
-      expect(result.get("keep-alive")).toBeNull()
-      expect(result.get("transfer-encoding")).toBeNull()
-      expect(result.get("content-type")).toBe("application/json")
-    })
-
-    test("strips saeeol-specific headers", () => {
-      const req = new Request("http://localhost", {
-        headers: {
-          "x-saeeol-directory": "/home/user/project",
-          "x-saeeol-workspace": "ws_123",
-          "accept-encoding": "gzip",
-          "x-custom": "keep",
-        },
-      })
-      const result = ProxyUtil.headers(req)
-      expect(result.get("x-saeeol-directory")).toBeNull()
-      expect(result.get("x-saeeol-workspace")).toBeNull()
-      expect(result.get("accept-encoding")).toBeNull()
-      expect(result.get("x-custom")).toBe("keep")
-    })
-
-    test("merges extra headers", () => {
-      const req = new Request("http://localhost", {
-        headers: { "content-type": "application/json" },
-      })
-      const result = ProxyUtil.headers(req, { "x-auth": "token", "content-type": "text/plain" })
-      expect(result.get("x-auth")).toBe("token")
-      expect(result.get("content-type")).toBe("text/plain")
-    })
-
-    test("returns original headers when no extra", () => {
-      const req = new Request("http://localhost", {
-        headers: { "content-type": "application/json", "x-foo": "bar" },
-      })
-      const result = ProxyUtil.headers(req)
-      expect(result.get("content-type")).toBe("application/json")
-      expect(result.get("x-foo")).toBe("bar")
-    })
-
-    test("accepts plain object (HeadersInit) as input", () => {
-      const result = ProxyUtil.headers(
-        { "content-type": "application/json", connection: "keep-alive", "x-custom": "val" },
-        { "x-extra": "added" },
-      )
-      expect(result.get("connection")).toBeNull()
-      expect(result.get("content-type")).toBe("application/json")
-      expect(result.get("x-custom")).toBe("val")
-      expect(result.get("x-extra")).toBe("added")
-    })
-  })
-})