saeeol 1.3.0 → 1.3.1

package/test/server/contract.test.ts

@@ -0,0 +1,357 @@
+/**
+ * contract.test.ts — SAEEOL 서버 계약 테스트
+ *
+ * closebook 패턴 기반:
+ * - response-conformance: Zod 스키마로 응답 바디 적합성 검사
+ * - consumer-contract: SDK/클라이언트가 기대하는 API 응답 스키마 검증
+ * - stateful-api-testing: 세션 생성 → 조회 → 수정 → 삭제 순차 테스트
+ *
+ * Hono app.request()로 실제 HTTP 서버 없이 테스트.
+ * Bun test + Zod 검증.
+ */
+
+import { afterAll, afterEach, describe, expect, test } from "bun:test"
+import { Flag } from "@saeeol/core/flag/flag"
+import { Server } from "../../src/server/server"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+import * as Log from "@saeeol/core/util/log"
+import { z } from "zod"
+import { checkHonoResponse } from "./lib/conformance"
+import { runSequence } from "./lib/stateful"
+
+void Log.init({ print: false })
+
+const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
+
+function app(experimental = true) {
+	Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = experimental
+	return experimental ? Server.Default().app : Server.Legacy().app
+}
+
+// ── Zod 스키마 (계약: 클라이언트가 기대하는 응답 형태) ──
+
+const HealthSchema = z.object({
+	healthy: z.boolean(),
+	version: z.string(),
+})
+
+const ConfigSchema = z
+	.object({
+		model: z.string().optional(),
+		username: z.string().optional(),
+	})
+	.passthrough()
+
+const SessionListSchema = z.array(
+	z
+		.object({
+			id: z.string(),
+			title: z.string().optional(),
+			createdAt: z.number().optional(),
+		})
+		.passthrough(),
+)
+
+const SessionInfoSchema = z
+	.object({
+		id: z.string(),
+	})
+	.passthrough()
+
+const AgentListSchema = z.array(z.unknown())
+
+const PathSchema = z.object({
+	home: z.string(),
+	state: z.string(),
+	config: z.string(),
+	worktree: z.string(),
+	directory: z.string(),
+})
+
+const SkillListSchema = z.array(z.unknown())
+
+const CommandListSchema = z.array(z.unknown())
+
+// ── 공통 정리 ──
+
+const cleanupQueue: Array<() => Promise<void>> = []
+
+afterAll(async () => {
+	Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
+	await disposeAllInstances()
+	await Bun.sleep(500)
+	for (const fn of cleanupQueue) await fn()
+})
+
+// ── response-conformance: 라우트별 응답 적합성 검증 ──
+
+describe("response conformance: server routes", () => {
+	describe("GET /global/health", () => {
+		test("legacy: matches HealthSchema", async () => {
+			const res = await app(false).request("/global/health")
+			const result = await checkHonoResponse(res, HealthSchema, [200])
+			expect(result.ok).toBe(true)
+			if (!result.ok) console.error("Health violations:", result.violations)
+		})
+
+		test("experimental: matches HealthSchema", async () => {
+			const res = await app(true).request("/global/health")
+			const result = await checkHonoResponse(res, HealthSchema, [200])
+			expect(result.ok).toBe(true)
+			if (!result.ok) console.error("Health violations:", result.violations)
+		})
+	})
+
+	describe("GET /global/config", () => {
+		test("legacy: matches ConfigSchema", async () => {
+			await using tmp = await tmpdir({ config: {} })
+			const res = await app(false).request("/global/config", {
+				headers: { "x-saeeol-directory": tmp.path },
+			})
+			const result = await checkHonoResponse(res, ConfigSchema, [200])
+			expect(result.ok).toBe(true)
+			if (!result.ok) console.error("Config violations:", result.violations)
+		})
+	})
+
+	describe("GET /agent", () => {
+		test("legacy: returns agent list", async () => {
+			await using tmp = await tmpdir({ config: {} })
+			const res = await app(false).request("/agent", {
+				headers: { "x-saeeol-directory": tmp.path },
+			})
+			const result = await checkHonoResponse(res, AgentListSchema, [200])
+			expect(result.ok).toBe(true)
+			if (!result.ok) console.error("Agent violations:", result.violations)
+		})
+	})
+
+	describe("GET /path", () => {
+		test("legacy: returns path info", async () => {
+			const tmp = await tmpdir({ git: true, config: {} })
+			cleanupQueue.push(() => tmp[Symbol.asyncDispose]())
+			const res = await app(false).request("/path", {
+				headers: { "x-saeeol-directory": tmp.path },
+			})
+			const result = await checkHonoResponse(res, PathSchema, [200])
+			expect(result.ok).toBe(true)
+			if (!result.ok) console.error("Path violations:", result.violations)
+		})
+	})
+
+	describe("GET /skill", () => {
+		test("legacy: returns skill list", async () => {
+			const tmp = await tmpdir({ git: true, config: {} })
+			cleanupQueue.push(() => tmp[Symbol.asyncDispose]())
+			const res = await app(false).request("/skill", {
+				headers: { "x-saeeol-directory": tmp.path },
+			})
+			const result = await checkHonoResponse(res, SkillListSchema, [200])
+			expect(result.ok).toBe(true)
+			if (!result.ok) console.error("Skill violations:", result.violations)
+		})
+	})
+
+	describe("GET /command", () => {
+		test("legacy: returns command list", async () => {
+			const tmp = await tmpdir({ config: {} })
+			cleanupQueue.push(() => tmp[Symbol.asyncDispose]())
+			const res = await app(false).request("/command", {
+				headers: { "x-saeeol-directory": tmp.path },
+			})
+			const result = await checkHonoResponse(res, CommandListSchema, [200])
+			expect(result.ok).toBe(true)
+			if (!result.ok) console.error("Command violations:", result.violations)
+		})
+	})
+})
+
+// ── stateful-api-testing: 세션 라이프사이클 순차 테스트 ──
+
+describe("stateful: session lifecycle", () => {
+	test("create → list → get → update → delete", async () => {
+		const tmp = await tmpdir({ git: true, config: {} })
+		cleanupQueue.push(() => tmp[Symbol.asyncDispose]())
+		Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = false
+		const headers = { "x-saeeol-directory": tmp.path }
+
+		const result = await runSequence({
+			app: app(false),
+			headers,
+			steps: [
+				{
+					name: "create session",
+					request: { method: "POST", path: "/session", body: { title: "stateful-test" } },
+					extract: { sessionId: (body: unknown) => (body as Record<string, unknown>).id },
+					validate: { status: 200, body: SessionInfoSchema },
+				},
+				{
+					name: "list sessions",
+					request: { method: "GET", path: "/session" },
+					validate: { status: 200, body: SessionListSchema },
+				},
+				{
+					name: "get session",
+					request: { method: "GET", path: "/session/{sessionId}" },
+					validate: { status: 200, body: SessionInfoSchema },
+				},
+				{
+					name: "update session title",
+					request: {
+						method: "PATCH",
+						path: "/session/{sessionId}",
+						body: { title: "updated-title" },
+					},
+					validate: { status: 200, body: SessionInfoSchema },
+				},
+				{
+					name: "delete session",
+					request: { method: "DELETE", path: "/session/{sessionId}" },
+					validate: { status: 200, body: z.boolean() },
+				},
+			],
+		})
+
+		expect(result.ok).toBe(true)
+		expect(result.captured.sessionId).toBeTruthy()
+
+		if (!result.ok) {
+			for (const step of result.steps) {
+				if (!step.ok) {
+					console.error(`FAIL [${step.step}]:`, step.violations)
+				}
+			}
+		}
+	})
+
+	test("create → list contains new session", async () => {
+		const tmp = await tmpdir({ git: true, config: {} })
+		cleanupQueue.push(() => tmp[Symbol.asyncDispose]())
+		Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = false
+		const headers = { "x-saeeol-directory": tmp.path }
+
+		const result = await runSequence({
+			app: app(false),
+			headers,
+			steps: [
+				{
+					name: "create session",
+					request: { method: "POST", path: "/session", body: {} },
+					extract: { sessionId: (body: unknown) => (body as Record<string, unknown>).id },
+					validate: { status: 200 },
+				},
+				{
+					name: "list sessions",
+					request: { method: "GET", path: "/session" },
+					validate: { status: 200, body: SessionListSchema },
+				},
+			],
+		})
+
+		expect(result.ok).toBe(true)
+		expect(result.captured.sessionId).toBeTruthy()
+		const listBody = result.steps[1].body as unknown[]
+		expect(listBody.length).toBeGreaterThanOrEqual(1)
+	})
+
+	test("create → get → children (empty)", async () => {
+		const tmp = await tmpdir({ git: true, config: {} })
+		cleanupQueue.push(() => tmp[Symbol.asyncDispose]())
+		Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = false
+		const headers = { "x-saeeol-directory": tmp.path }
+
+		const result = await runSequence({
+			app: app(false),
+			headers,
+			steps: [
+				{
+					name: "create session",
+					request: { method: "POST", path: "/session", body: {} },
+					extract: { sessionId: (body: unknown) => (body as Record<string, unknown>).id },
+					validate: { status: 200 },
+				},
+				{
+					name: "get children",
+					request: { method: "GET", path: "/session/{sessionId}/children" },
+					validate: { status: 200, body: z.array(z.unknown()) },
+				},
+			],
+		})
+
+		expect(result.ok).toBe(true)
+	})
+})
+
+// ── response-conformance: 에러 응답 검증 ──
+
+describe("response conformance: error routes", () => {
+	test("session get with invalid ID returns error", async () => {
+		const tmp = await tmpdir({ git: true, config: {} })
+		cleanupQueue.push(() => tmp[Symbol.asyncDispose]())
+		const res = await app(false).request("/session/nonexistent-id", {
+			headers: { "x-saeeol-directory": tmp.path },
+		})
+		expect([400, 404]).toContain(res.status)
+	})
+})
+
+// ── consumer-contract: 계약 파일 생성 ──
+
+describe("consumer contract: pact artifact generation", () => {
+	afterEach(async () => {
+		Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
+		await disposeAllInstances()
+	})
+
+	test("collects verified interactions into contract", async () => {
+		await using tmp = await tmpdir({ config: {} })
+		const headers = { "x-saeeol-directory": tmp.path }
+		const interactions = []
+
+		// Health 인터랙션
+		const healthRes = await app(false).request("/global/health")
+		const healthBody = await healthRes.json()
+		interactions.push({
+			description: "health check",
+			providerStates: [],
+			request: { method: "GET", path: "/global/health" },
+			response: { status: healthRes.status, body: healthBody },
+		})
+
+		// Config 인터랙션
+		const configRes = await app(false).request("/global/config", { headers })
+		const configBody = await configRes.json()
+		interactions.push({
+			description: "global config",
+			providerStates: [],
+			request: { method: "GET", path: "/global/config" },
+			response: { status: configRes.status, body: configBody },
+		})
+
+		// Agent 인터랙션
+		const agentRes = await app(false).request("/agent", { headers })
+		const agentBody = await agentRes.json()
+		interactions.push({
+			description: "agent list",
+			providerStates: [],
+			request: { method: "GET", path: "/agent" },
+			response: { status: agentRes.status, body: agentBody },
+		})
+
+		// 계약 파일 검증
+		const pact = {
+			consumer: { name: "saeeol-vscode" },
+			provider: { name: "saeeol-server" },
+			interactions,
+			metadata: { version: "1.0.0" },
+		}
+
+		expect(pact.interactions.length).toBe(3)
+		for (const ix of pact.interactions) {
+			expect(ix).toHaveProperty("description")
+			expect(ix).toHaveProperty("request")
+			expect(ix).toHaveProperty("response")
+			expect(ix.response.status).toBeLessThan(500)
+		}
+	})
+})

package/test/server/experimental-session-list.test.ts

@@ -0,0 +1,157 @@
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test"
+import { $ } from "bun"
+import path from "path"
+import * as Config from "../../src/config/config"
+import { Instance } from "../../src/project/instance"
+import * as Log from "@saeeol/core/util/log"
+import { resetDatabase } from "../fixture/db"
+import { tmpdir } from "../fixture/fixture"
+import { RemoteSender } from "../../src/sessions/remote-sender"
+
+beforeEach(() => {
+  spyOn(RemoteSender, "create").mockReturnValue({ handle() {}, dispose() {} })
+})
+
+Log.init({ print: false })
+
+afterEach(async () => {
+  mock.restore()
+  await resetDatabase()
+})
+
+describe("experimental.session.list", () => {
+  test("filters sessions by repo worktree family even when project IDs drift", async () => {
+    await using first = await tmpdir({ git: true })
+    await using second = await tmpdir({ git: true })
+    const worktree = path.join(first.path, "..", path.basename(first.path) + "-worktree")
+
+    try {
+      await $`git worktree add ${worktree} -b test-branch-${Date.now()}`.cwd(first.path).quiet()
+
+      spyOn(Config, "get").mockImplementation(
+        async () => ({ share: "manual" }) as Awaited<ReturnType<typeof Config.get>>,
+      )
+
+      try {
+        const { Server } = await import("../../src/server/server")
+        const { Session } = await import("../../src/session/session")
+
+        // Create worktree session first so it computes its own project ID via rev-list
+        const branch = await Instance.provide({
+          directory: worktree,
+          fn: async () => Session.create({ title: "worktree-session" }),
+        })
+
+        // Now write a stale project ID to .git/saeeol — this overrides the root's cached ID
+        await Bun.write(path.join(first.path, ".git", "saeeol"), "stale-project-id")
+
+        const root = await Instance.provide({
+          directory: first.path,
+          fn: async () => ({
+            app: Server.Default().app,
+            project: await Server.Default().app.request("/project/current", {
+              headers: { "x-saeeol-directory": first.path },
+            }),
+            session: await Session.create({ title: "root-session" }),
+          }),
+        })
+        await Bun.file(path.join(first.path, ".git", "saeeol")).delete()
+
+        await Instance.provide({
+          directory: second.path,
+          fn: async () => Session.create({ title: "other-project-session" }),
+        })
+
+        const app = root.app
+        const project = await root.project.json()
+        const response = await app.request(
+          `/experimental/session?projectID=${encodeURIComponent(project.id)}&roots=true&worktrees=true`,
+          {
+            headers: { "x-saeeol-directory": first.path },
+          },
+        )
+
+        expect(response.status).toBe(200)
+        const body = await response.json()
+        const ids = body.map((item: { id: string }) => item.id)
+        const dirs = body.map((item: { directory: string }) => item.directory)
+
+        expect(root.session.projectID).not.toBe(branch.projectID)
+        expect(project.id).toBe(root.session.projectID)
+        expect(ids).toContain(root.session.id)
+        expect(ids).toContain(branch.id)
+        expect(dirs).toContain(worktree)
+        expect(body.some((item: { title: string }) => item.title === "other-project-session")).toBe(false)
+      } finally {
+        mock.restore()
+      }
+    } finally {
+      await $`git worktree remove ${worktree}`.cwd(first.path).quiet().nothrow()
+    }
+  })
+
+  test("worktrees=true ignores SDK-injected directory query param", async () => {
+    await using first = await tmpdir({ git: true })
+    await using second = await tmpdir({ git: true })
+    const worktree = path.join(first.path, "..", path.basename(first.path) + "-worktree")
+
+    try {
+      await $`git worktree add ${worktree} -b test-branch-sdk-${Date.now()}`.cwd(first.path).quiet()
+
+      spyOn(Config, "get").mockImplementation(
+        async () => ({ share: "manual" }) as Awaited<ReturnType<typeof Config.get>>,
+      )
+
+      try {
+        const { Server } = await import("../../src/server/server")
+        const { Session } = await import("../../src/session/session")
+
+        const branch = await Instance.provide({
+          directory: worktree,
+          fn: async () => Session.create({ title: "worktree-session" }),
+        })
+
+        const root = await Instance.provide({
+          directory: first.path,
+          fn: async () => ({
+            app: Server.Default().app,
+            project: await Server.Default().app.request("/project/current", {
+              headers: { "x-saeeol-directory": first.path },
+            }),
+            session: await Session.create({ title: "root-session" }),
+          }),
+        })
+
+        await Instance.provide({
+          directory: second.path,
+          fn: async () => Session.create({ title: "other-project-session" }),
+        })
+
+        const app = root.app
+        const project = await root.project.json()
+
+        // Include directory in query params — mimics what the SDK rewrite interceptor does.
+        // Without the server fix, this would restrict results to only first.path sessions.
+        const response = await app.request(
+          `/experimental/session?projectID=${encodeURIComponent(project.id)}&roots=true&worktrees=true&directory=${encodeURIComponent(first.path)}`,
+          {
+            headers: { "x-saeeol-directory": first.path },
+          },
+        )
+
+        expect(response.status).toBe(200)
+        const body = await response.json()
+        const ids = body.map((item: { id: string }) => item.id)
+
+        // Both root and worktree sessions must be returned despite directory= in query
+        expect(ids).toContain(root.session.id)
+        expect(ids).toContain(branch.id)
+        expect(body.some((item: { title: string }) => item.title === "other-project-session")).toBe(false)
+      } finally {
+        mock.restore()
+      }
+    } finally {
+      await $`git worktree remove ${worktree}`.cwd(first.path).quiet().nothrow()
+    }
+  })
+})

package/test/server/global-session-list.test.ts

@@ -0,0 +1,155 @@
+import { $ } from "bun"
+import { afterEach, beforeEach, describe, expect, mock, spyOn, test } from "bun:test"
+import { Effect } from "effect"
+import path from "path"
+import z from "zod"
+import { Instance } from "../../src/project/instance"
+import { Project } from "@/project/project"
+import { Session as SessionNs } from "@/session/session"
+import * as Log from "@saeeol/core/util/log"
+import { resetDatabase } from "../fixture/db"
+import { tmpdir } from "../fixture/fixture"
+import { RemoteSender } from "../../src/sessions/remote-sender" 
+beforeEach(() => {
+  spyOn(RemoteSender, "create").mockReturnValue({ handle() {}, dispose() {} })
+})
+
+void Log.init({ print: false })
+afterEach(async () => {
+  mock.restore()
+  await resetDatabase()
+})
+
+function run<A, E>(fx: Effect.Effect<A, E, SessionNs.Service>) {
+  return Effect.runPromise(fx.pipe(Effect.provide(SessionNs.defaultLayer)))
+}
+
+const svc = {
+  ...SessionNs,
+  create(input?: SessionNs.CreateInput) {
+    return run(SessionNs.Service.use((svc) => svc.create(input)))
+  },
+  setArchived(input: z.output<typeof SessionNs.SetArchivedInput.zod>) {
+    return run(SessionNs.Service.use((svc) => svc.setArchived(input)))
+  },
+}
+
+describe("session.listGlobal", () => {
+  test("lists sessions across projects with project metadata", async () => {
+    await using first = await tmpdir({ git: true })
+    await using second = await tmpdir({ git: true })
+
+    const firstSession = await Instance.provide({
+      directory: first.path,
+      fn: async () => svc.create({ title: "first-session" }),
+    })
+    const secondSession = await Instance.provide({
+      directory: second.path,
+      fn: async () => svc.create({ title: "second-session" }),
+    })
+
+    const sessions = [...svc.listGlobal({ limit: 200 })]
+    const ids = sessions.map((session) => session.id)
+
+    expect(ids).toContain(firstSession.id)
+    expect(ids).toContain(secondSession.id)
+
+    const firstProject = Project.get(firstSession.projectID)
+    const secondProject = Project.get(secondSession.projectID)
+
+    const firstItem = sessions.find((session) => session.id === firstSession.id)
+    const secondItem = sessions.find((session) => session.id === secondSession.id)
+
+    expect(firstItem?.project?.id).toBe(firstProject?.id)
+    expect(firstItem?.project?.worktree).toBe(firstProject?.worktree)
+    expect(secondItem?.project?.id).toBe(secondProject?.id)
+    expect(secondItem?.project?.worktree).toBe(secondProject?.worktree)
+  })
+
+  test("excludes archived sessions by default", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const archived = await Instance.provide({
+      directory: tmp.path,
+      fn: async () => svc.create({ title: "archived-session" }),
+    })
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => svc.setArchived({ sessionID: archived.id, time: Date.now() }),
+    })
+
+    const sessions = [...svc.listGlobal({ limit: 200 })]
+    const ids = sessions.map((session) => session.id)
+
+    expect(ids).not.toContain(archived.id)
+
+    const allSessions = [...svc.listGlobal({ limit: 200, archived: true })]
+    const allIds = allSessions.map((session) => session.id)
+
+    expect(allIds).toContain(archived.id)
+  })
+
+  test("supports cursor pagination", async () => {
+    await using tmp = await tmpdir({ git: true })
+
+    const first = await Instance.provide({
+      directory: tmp.path,
+      fn: async () => svc.create({ title: "page-one" }),
+    })
+    await new Promise((resolve) => setTimeout(resolve, 5))
+    const second = await Instance.provide({
+      directory: tmp.path,
+      fn: async () => svc.create({ title: "page-two" }),
+    })
+
+    const page = [...svc.listGlobal({ directory: tmp.path, limit: 1 })]
+    expect(page.length).toBe(1)
+    expect(page[0]!.id).toBe(second.id)
+
+    const next = [...svc.listGlobal({ directory: tmp.path, limit: 10, cursor: page[0]!.time.updated })]
+    const ids = next.map((session) => session.id)
+
+    expect(ids).toContain(first.id)
+    expect(ids).not.toContain(second.id)
+  })
+  test("filters by project family across worktrees when project IDs drift", async () => {
+    await using first = await tmpdir({ git: true })
+    await using second = await tmpdir({ git: true })
+    const worktree = path.join(first.path, "..", path.basename(first.path) + "-worktree")
+
+    try {
+      await $`git worktree add ${worktree} -b test-branch-${Date.now()}`.cwd(first.path).quiet()
+
+      // Create worktree session first so it computes its own project ID via rev-list
+      const branch = await Instance.provide({
+        directory: worktree,
+        fn: async () => svc.create({ title: "worktree-session" }),
+      })
+
+      // Now write a stale project ID to .git/saeeol — this overrides the root's cached ID
+      await Bun.write(path.join(first.path, ".git", "saeeol"), "stale-project-id")
+
+      const root = await Instance.provide({
+        directory: first.path,
+        fn: async () => svc.create({ title: "root-session" }),
+      })
+      await Bun.file(path.join(first.path, ".git", "saeeol")).delete()
+      const other = await Instance.provide({
+        directory: second.path,
+        fn: async () => svc.create({ title: "other-session" }),
+      })
+
+      const sessions = [...svc.listGlobal({ projectID: root.projectID, roots: true, limit: 200 })]
+      const ids = sessions.map((session) => session.id)
+
+      expect(root.projectID).not.toBe(branch.projectID)
+      expect(ids).toContain(root.id)
+      expect(ids).toContain(branch.id)
+      expect(ids).not.toContain(other.id)
+      expect(sessions.find((session) => session.id === branch.id)?.directory).toBe(worktree)
+    } finally {
+      await $`git worktree remove ${worktree}`.cwd(first.path).quiet().nothrow()
+    }
+  })
+})