saeeol 1.2.5 → 1.2.8

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

@@ -1,153 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, FileSystem, Layer, Path } from "effect"
-import { NodeFileSystem, NodePath } from "@effect/platform-node"
-import { Flag } from "@saeeol/core/flag/flag"
-import { Instance } from "../../src/project/instance"
-import { InstanceStore } from "../../src/project/instance-store"
-import { Server } from "../../src/server/server"
-import * as Log from "@saeeol/core/util/log"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, provideInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-void Log.init({ print: false })
-
-const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-const it = testEffect(Layer.mergeAll(NodeFileSystem.layer, NodePath.layer))
-const providerID = "test-oauth-parity"
-const oauthURL = "https://example.com/oauth"
-const oauthInstructions = "Finish OAuth"
-
-function app(experimental: boolean) {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = experimental
-  return experimental ? Server.Default().app : Server.Legacy().app
-}
-
-function requestAuthorize(input: {
-  app: ReturnType<typeof app>
-  providerID: string
-  method: number
-  headers: HeadersInit
-}) {
-  return Effect.promise(async () => {
-    const response = await input.app.request(`/provider/${input.providerID}/oauth/authorize`, {
-      method: "POST",
-      headers: input.headers,
-      body: JSON.stringify({ method: input.method }),
-    })
-    return {
-      status: response.status,
-      body: await response.text(),
-    }
-  })
-}
-
-function writeProviderAuthPlugin(dir: string) {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const path = yield* Path.Path
-
-    yield* fs.makeDirectory(path.join(dir, ".saeeol", "plugin"), { recursive: true })
-    yield* fs.writeFileString(
-      path.join(dir, ".saeeol", "plugin", "provider-oauth-parity.ts"),
-      [
-        "export default {",
-        '  id: "test.provider-oauth-parity",',
-        "  server: async () => ({",
-        "    auth: {",
-        `      provider: "${providerID}",`,
-        "      methods: [",
-        '        { type: "api", label: "API key" },',
-        "        {",
-        '          type: "oauth",',
-        '          label: "OAuth",',
-        "          authorize: async () => ({",
-        `            url: "${oauthURL}",`,
-        '            method: "code",',
-        `            instructions: "${oauthInstructions}",`,
-        "            callback: async () => ({ type: 'success', key: 'token' }),",
-        "          }),",
-        "        },",
-        "      ],",
-        "    },",
-        "  }),",
-        "}",
-        "",
-      ].join("\n"),
-    )
-  })
-}
-
-function withProviderProject<A, E, R>(self: (dir: string) => Effect.Effect<A, E, R>) {
-  return Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const path = yield* Path.Path
-    const dir = yield* fs.makeTempDirectoryScoped({ prefix: "saeeol-test-" })
-
-    yield* fs.writeFileString(
-      path.join(dir, "saeeol.json"),
-      JSON.stringify({ $schema: "https://saeeol.ai/config.json", formatter: false, lsp: false }),
-    )
-    yield* writeProviderAuthPlugin(dir)
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(() =>
-        Instance.provide({ directory: dir, fn: () => InstanceStore.disposeInstance(Instance.current) }),
-      ).pipe(Effect.ignore),
-    )
-
-    return yield* self(dir).pipe(provideInstance(dir))
-  })
-}
-
-afterEach(async () => {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-describe("provider HttpApi", () => {
-  it.live(
-    "matches legacy OAuth authorize response shapes",
-    withProviderProject((dir) =>
-      Effect.gen(function* () {
-        const headers = { "x-saeeol-directory": dir, "content-type": "application/json" }
-        const legacy = app(false)
-        const httpapi = app(true)
-
-        const apiLegacy = yield* requestAuthorize({
-          app: legacy,
-          providerID,
-          method: 0,
-          headers,
-        })
-        const apiHttpApi = yield* requestAuthorize({
-          app: httpapi,
-          providerID,
-          method: 0,
-          headers,
-        })
-        expect(apiLegacy).toEqual({ status: 200, body: "" })
-        expect(apiHttpApi).toEqual(apiLegacy)
-
-        const oauthLegacy = yield* requestAuthorize({
-          app: legacy,
-          providerID,
-          method: 1,
-          headers,
-        })
-        const oauthHttpApi = yield* requestAuthorize({
-          app: httpapi,
-          providerID,
-          method: 1,
-          headers,
-        })
-        expect(oauthHttpApi).toEqual(oauthLegacy)
-        expect(JSON.parse(oauthHttpApi.body)).toEqual({
-          url: oauthURL,
-          method: "code",
-          instructions: oauthInstructions,
-        })
-      }),
-    ),
-  )
-})

package/test/server/httpapi-pty-websocket.test.ts

@@ -1,16 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { handlePtyInput } from "../../src/pty/input"
-
-describe("pty HttpApi websocket input", () => {
-  test("does not forward invalid binary frames to the PTY handler", async () => {
-    const messages: Array<string | ArrayBuffer> = []
-    const handler = { onMessage: (message: string | ArrayBuffer) => messages.push(message) }
-
-    await Effect.runPromise(handlePtyInput(handler, "ready"))
-    await Effect.runPromise(handlePtyInput(handler, new Uint8Array([0xff, 0xfe, 0xfd])))
-    await Effect.runPromise(handlePtyInput(handler, new TextEncoder().encode("hello")))
-
-    expect(messages).toEqual(["ready", "hello"])
-  })
-})

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

@@ -1,175 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { NodeHttpServer, NodeServices } from "@effect/platform-node"
-import { Flag } from "@saeeol/core/flag/flag"
-import { PtyID } from "../../src/pty/schema"
-import { Instance } from "../../src/project/instance"
-import { Server } from "../../src/server/server"
-import { PtyPaths } from "../../src/server/routes/instance/httpapi/groups/pty"
-import * as Log from "@saeeol/core/util/log"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, tmpdir, tmpdirScoped } from "../fixture/fixture"
-import { Config, Effect, Layer, Queue, Schema } from "effect"
-import { HttpClient, HttpClientRequest, HttpRouter, HttpServer } from "effect/unstable/http"
-import * as Socket from "effect/unstable/socket/Socket"
-import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
-import { Pty } from "../../src/pty"
-import { testEffect } from "../lib/effect"
-
-void Log.init({ print: false })
-
-const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-const testPty = process.platform === "win32" ? test.skip : test
-
-const testStateLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = true
-    yield* Effect.promise(() => resetDatabase())
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(async () => {
-        Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
-        await resetDatabase()
-      }),
-    )
-  }),
-)
-
-const servedRoutes: Layer.Layer<never, Config.ConfigError, HttpServer.HttpServer> = HttpRouter.serve(
-  ExperimentalHttpApiServer.routes,
-  { disableListenLog: true, disableLogger: true },
-)
-
-const effectIt = testEffect(
-  Layer.mergeAll(
-    testStateLayer,
-    Socket.layerWebSocketConstructorGlobal,
-    servedRoutes.pipe(
-      Layer.provide(Socket.layerWebSocketConstructorGlobal),
-      Layer.provideMerge(NodeHttpServer.layerTest),
-      Layer.provideMerge(NodeServices.layer),
-    ),
-  ),
-)
-
-function app() {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = true
-  return Server.Default().app
-}
-
-function serverUrl() {
-  return HttpServer.HttpServer.use((server) => Effect.succeed(HttpServer.formatAddress(server.address)))
-}
-
-const directoryHeader = (dir: string) => HttpClientRequest.setHeader("x-saeeol-directory", dir)
-
-afterEach(async () => {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-describe("pty HttpApi bridge", () => {
-  test("serves available shell list through experimental Effect routes", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const response = await app().request(PtyPaths.shells, { headers: { "x-saeeol-directory": tmp.path } })
-
-    expect(response.status).toBe(200)
-    expect(await response.json()).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          path: expect.any(String),
-          name: expect.any(String),
-          acceptable: expect.any(Boolean),
-        }),
-      ]),
-    )
-  })
-
-  testPty("serves PTY JSON routes through experimental Effect routes", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const headers = { "x-saeeol-directory": tmp.path }
-    const list = await app().request(PtyPaths.list, { headers })
-    expect(list.status).toBe(200)
-    expect(await list.json()).toEqual([])
-
-    const created = await app().request(PtyPaths.create, {
-      method: "POST",
-      headers: { ...headers, "content-type": "application/json" },
-      body: JSON.stringify({ command: "/usr/bin/env", args: ["sh", "-c", "sleep 5"], title: "demo" }),
-    })
-    expect(created.status).toBe(200)
-    const info = await created.json()
-
-    try {
-      expect(info).toMatchObject({ title: "demo", command: "/usr/bin/env", status: "running" })
-
-      const found = await app().request(PtyPaths.get.replace(":ptyID", info.id), { headers })
-      expect(found.status).toBe(200)
-      expect(await found.json()).toMatchObject({ id: info.id, title: "demo" })
-
-      const updated = await app().request(PtyPaths.update.replace(":ptyID", info.id), {
-        method: "PUT",
-        headers: { ...headers, "content-type": "application/json" },
-        body: JSON.stringify({ title: "renamed", size: { cols: 80, rows: 24 } }),
-      })
-      expect(updated.status).toBe(200)
-      expect(await updated.json()).toMatchObject({ id: info.id, title: "renamed" })
-    } finally {
-      await app().request(PtyPaths.remove.replace(":ptyID", info.id), { method: "DELETE", headers })
-    }
-
-    const missing = await app().request(PtyPaths.get.replace(":ptyID", info.id), { headers })
-    expect(missing.status).toBe(404)
-  })
-
-  test("returns 404 for missing PTY websocket before upgrade", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const response = await app().request(PtyPaths.connect.replace(":ptyID", PtyID.ascending()), {
-      headers: { "x-saeeol-directory": tmp.path },
-    })
-    expect(response.status).toBe(404)
-  })
-  ;(process.platform === "win32" ? effectIt.live.skip : effectIt.live)(
-    "serves PTY websocket output and input through Effect routes",
-    () =>
-      Effect.gen(function* () {
-        const dir = yield* tmpdirScoped({ git: true, config: { formatter: false, lsp: false } })
-        const created = yield* HttpClientRequest.post(PtyPaths.create).pipe(
-          directoryHeader(dir),
-          HttpClientRequest.bodyJson({ command: "/bin/cat", title: "websocket" }),
-          Effect.flatMap(HttpClient.execute),
-        )
-        expect(created.status).toBe(200)
-        const info = yield* Schema.decodeUnknownEffect(Pty.Info)(yield* created.json)
-
-        const socket = yield* Socket.makeWebSocket(
-          `${(yield* serverUrl()).replace(/^http/, "ws")}${PtyPaths.connect.replace(":ptyID", info.id)}?cursor=-1&directory=${encodeURIComponent(dir)}`,
-          { closeCodeIsError: () => false },
-        )
-        const messages = yield* Queue.unbounded<string>()
-        yield* socket
-          .runRaw((message) =>
-            Queue.offer(messages, typeof message === "string" ? message : new TextDecoder().decode(message)),
-          )
-          .pipe(Effect.catch(() => Effect.void))
-          .pipe(Effect.forkScoped)
-        const write = yield* socket.writer
-
-        const takeUntil = (expected: string, seen = ""): Effect.Effect<string, unknown> =>
-          Effect.gen(function* () {
-            const next = seen + (yield* Queue.take(messages).pipe(Effect.timeout("5 seconds")))
-            if (next.includes(expected)) return next
-            return yield* takeUntil(expected, next)
-          })
-
-        yield* write("ping-route\n")
-        expect(yield* takeUntil("ping-route")).toContain("ping-route")
-        yield* write(new Socket.CloseEvent(1000, "done")).pipe(Effect.catch(() => Effect.void))
-
-        const removed = yield* HttpClientRequest.delete(PtyPaths.remove.replace(":ptyID", info.id)).pipe(
-          directoryHeader(dir),
-          HttpClient.execute,
-        )
-        expect(removed.status).toBe(200)
-      }),
-  )
-})

package/test/server/httpapi-raw-route-auth.test.ts

@@ -1,89 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { ConfigProvider, Layer } from "effect"
-import { HttpRouter } from "effect/unstable/http"
-import { Flag } from "@saeeol/core/flag/flag"
-import { Instance } from "../../src/project/instance"
-import { EventPaths } from "../../src/server/routes/instance/httpapi/event"
-import { PtyPaths } from "../../src/server/routes/instance/httpapi/groups/pty"
-import { ExperimentalHttpApiServer } from "../../src/server/routes/instance/httpapi/server"
-import { PtyID } from "../../src/pty/schema"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import * as Log from "@saeeol/core/util/log"
-
-void Log.init({ print: false })
-
-const originalHttpApi = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
-
-function app(input: { password?: string; username?: string }) {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = true
-  const handler = HttpRouter.toWebHandler(
-    ExperimentalHttpApiServer.routes.pipe(
-      Layer.provide(
-        ConfigProvider.layer(
-          ConfigProvider.fromUnknown({
-            SAEEOL_SERVER_PASSWORD: input.password,
-            SAEEOL_SERVER_USERNAME: input.username,
-          }),
-        ),
-      ),
-    ),
-    { disableLogger: true },
-  ).handler
-
-  return {
-    fetch: (request: Request) => handler(request, ExperimentalHttpApiServer.context),
-    request(input: string | URL | Request, init?: RequestInit) {
-      return this.fetch(input instanceof Request ? input : new Request(new URL(input, "http://localhost"), init))
-    },
-  }
-}
-
-function basic(username: string, password: string) {
-  return `Basic ${Buffer.from(`${username}:${password}`).toString("base64")}`
-}
-
-async function cancelBody(response: Response) {
-  await response.body?.cancel().catch(() => {})
-}
-
-afterEach(async () => {
-  Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = originalHttpApi
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-describe("HttpApi raw route authorization", () => {
-  test("requires configured auth before opening the raw instance event stream", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const server = app({ password: "secret" })
-    const headers = { "x-saeeol-directory": tmp.path }
-
-    const missing = await server.request(EventPaths.event, { headers })
-    await cancelBody(missing)
-    expect(missing.status).toBe(401)
-
-    const authed = await server.request(EventPaths.event, {
-      headers: { ...headers, authorization: basic("saeeol", "secret") }, 
-    })
-    await cancelBody(authed)
-    expect(authed.status).toBe(200)
-  })
-
-  test("requires configured auth before resolving the raw PTY websocket route", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const server = app({ password: "secret" })
-    const route = PtyPaths.connect.replace(":ptyID", PtyID.ascending())
-    const headers = { "x-saeeol-directory": tmp.path }
-
-    const missing = await server.request(route, { headers })
-    await cancelBody(missing)
-    expect(missing.status).toBe(401)
-
-    const authed = await server.request(route, {
-      headers: { ...headers, authorization: basic("saeeol", "secret") }, 
-    })
-    await cancelBody(authed)
-    expect(authed.status).toBe(404)
-  })
-})