saeeol 1.3.0 → 1.4.0

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

@@ -0,0 +1,427 @@
+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/lib/conformance.ts

@@ -0,0 +1,88 @@
+/**
+ * conformance.ts — 응답 적합성 검증 유틸리티
+ *
+ * closebook: response-conformance
+ * Zod 스키마로 Hono 응답의 상태코드 + Content-Type + 바디 적합성 검사.
+ * Hono app.request() 기반, 실제 HTTP 서버 불필요.
+ */
+
+import { z } from "zod"
+
+export interface ConformanceResult {
+	ok: boolean
+	statusOk: boolean
+	bodyOk: boolean
+	contentTypeOk: boolean
+	violations: Array<{ path: string; message: string; value?: unknown }>
+}
+
+// 응답 적합성 검증 — 상태코드 + Content-Type + 바디 스키마
+export function checkResponseConformance(cfg: {
+	status: number
+	headers?: Record<string, string>
+	body: unknown
+	schema: z.ZodType
+	allowedStatuses?: number[]
+}): ConformanceResult {
+	const { status, headers, body, schema, allowedStatuses = [200, 201] } = cfg
+	const violations: ConformanceResult["violations"] = []
+
+	// 1. 상태 코드 검사
+	const statusOk = allowedStatuses.length === 0 || allowedStatuses.includes(status)
+	if (!statusOk) {
+		violations.push({
+			path: "status",
+			message: `Expected one of ${allowedStatuses.join("/")}, got ${status}`,
+		})
+	}
+
+	// 2. Content-Type 검사
+	const contentType = headers?.["content-type"] ?? ""
+	const contentTypeOk = !headers || contentType.includes("application/json")
+	if (!contentTypeOk) {
+		violations.push({
+			path: "content-type",
+			message: `Expected application/json, got ${contentType}`,
+		})
+	}
+
+	// 3. 바디 스키마 검증 (Zod)
+	const parsed = schema.safeParse(body)
+	const bodyOk = parsed.success
+	if (!parsed.success) {
+		for (const issue of parsed.error.issues) {
+			violations.push({
+				path: issue.path.join(".") || "(root)",
+				message: issue.message,
+			})
+		}
+	}
+
+	return {
+		ok: violations.length === 0,
+		statusOk,
+		bodyOk,
+		contentTypeOk,
+		violations,
+	}
+}
+
+// Hono Response에서 적합성 검증
+export async function checkHonoResponse(
+	res: Response,
+	schema: z.ZodType,
+	allowedStatuses?: number[],
+): Promise<ConformanceResult> {
+	const body = await res.json()
+	const headers: Record<string, string> = {}
+	res.headers.forEach((v, k) => {
+		headers[k] = v
+	})
+	return checkResponseConformance({
+		status: res.status,
+		headers,
+		body,
+		schema,
+		allowedStatuses,
+	})
+}

package/test/server/lib/stateful.ts

@@ -0,0 +1,112 @@
+/**
+ * stateful.ts — 상태 API 순차 테스트 유틸리티
+ *
+ * closebook: stateful-api-testing
+ * Hono app.request() 기반으로 여러 API 단계를 순차 실행.
+ * 이전 응답에서 파라미터를 추출해 다음 요청에 주입.
+ */
+
+import { z } from "zod"
+
+export interface ApiStep {
+	name: string
+	request: { method: string; path: string; body?: unknown }
+	/** 이전 응답에서 파라미터 추출 → 다음 요청에 주입 */
+	extract?: Record<string, (body: unknown) => unknown>
+	validate: { status: number; body?: z.ZodType }
+}
+
+export interface StepResult {
+	step: string
+	status: number
+	body: unknown
+	extracted: Record<string, unknown>
+	ok: boolean
+	violations: Array<{ path: string; message: string }>
+}
+
+export interface SequenceResult {
+	ok: boolean
+	steps: StepResult[]
+	captured: Record<string, unknown>
+}
+
+// 경로 파라미터 치환: "/session/{sessionId}" → "/session/abc123"
+function resolvePath(template: string, vars: Record<string, unknown>): string {
+	return template.replace(/\{(\w+)\}/g, (_, key) => String(vars[key] ?? `{${key}}`))
+}
+
+// 바디 내 {key} 치환
+function resolveBody(body: unknown, vars: Record<string, unknown>): unknown {
+	if (typeof body !== "object" || body === null) return body
+	const str = JSON.stringify(body)
+	const resolved = str.replace(/\{(\w+)\}/g, (_, key) => {
+		const val = vars[key]
+		return val !== undefined ? String(val) : `{${key}}`
+	})
+	return JSON.parse(resolved)
+}
+
+type TestableApp = {
+	request(input: string | URL | Request, init?: RequestInit): Response | Promise<Response>
+}
+
+// 순차 API 테스트 실행
+export async function runSequence(cfg: {
+	app: TestableApp
+	steps: ApiStep[]
+	headers?: Record<string, string>
+}): Promise<SequenceResult> {
+	const { app, steps, headers: baseHeaders } = cfg
+	const captured: Record<string, unknown> = {}
+	const results: StepResult[] = []
+
+	for (const step of steps) {
+		const path = resolvePath(step.request.path, captured)
+		const body = step.request.body ? resolveBody(step.request.body, captured) : undefined
+
+		const init: RequestInit = { method: step.request.method, headers: baseHeaders }
+		if (body !== undefined) {
+			init.body = JSON.stringify(body)
+			const merged = { ...(init.headers as Record<string, string>), "Content-Type": "application/json" }
+			init.headers = merged
+		}
+
+		const res = await app.request(path, init)
+		const resBody = await res.json()
+
+		// 응답 검증
+		const violations: StepResult["violations"] = []
+		if (res.status !== step.validate.status) {
+			violations.push({ path: "status", message: `Expected ${step.validate.status}, got ${res.status}` })
+		}
+		if (step.validate.body) {
+			const parsed = step.validate.body.safeParse(resBody)
+			if (!parsed.success) {
+				for (const issue of parsed.error.issues) {
+					violations.push({ path: issue.path.join(".") || "(root)", message: issue.message })
+				}
+			}
+		}
+
+		// 응답에서 파라미터 추출
+		const extracted: Record<string, unknown> = {}
+		if (step.extract) {
+			for (const [key, fn] of Object.entries(step.extract)) {
+				extracted[key] = fn(resBody)
+				captured[key] = extracted[key]
+			}
+		}
+
+		results.push({
+			step: step.name,
+			status: res.status,
+			body: resBody,
+			extracted,
+			ok: violations.length === 0,
+			violations,
+		})
+	}
+
+	return { ok: results.every((r) => r.ok), steps: results, captured }
+}