@miaws/miaw 1.18.5 → 1.18.6

package/test/server/project-copy.test.ts

@@ -1,121 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { $ } from "bun"
-import fs from "fs/promises"
-import path from "path"
-import { Effect, Layer } from "effect"
-import { HttpClientResponse } from "effect/unstable/http"
-import { FSUtil } from "@miaw/core/fs-util"
-import { Database } from "@miaw/core/database/database"
-import { Snapshot } from "@/snapshot"
-import { InstanceBootstrap } from "@/project/bootstrap-service"
-import { InstanceStore } from "@/project/instance-store"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { httpApiLayer, requestInDirectory } from "./httpapi-layer"
-
-afterEach(async () => {
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-const noopBootstrap = Layer.succeed(InstanceBootstrap.Service, InstanceBootstrap.Service.of({ run: Effect.void }))
-const testInstanceStore = InstanceStore.defaultLayer.pipe(Layer.provide(noopBootstrap))
-const it = testEffect(
-  Layer.mergeAll(FSUtil.defaultLayer, Database.defaultLayer, Snapshot.defaultLayer, testInstanceStore, httpApiLayer),
-)
-
-function request(directory: string, url: string, init: RequestInit = {}) {
-  return requestInDirectory(url, directory, init)
-}
-
-function json<T>(response: HttpClientResponse.HttpClientResponse) {
-  return response.json.pipe(Effect.map((value) => value as T))
-}
-
-describe("project directories and copies endpoints", () => {
-  type ProjectDirectory = { directory: string; strategy?: string }
-
-  it.instance(
-    "lists directories and manages git worktree copies",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const current = yield* request(test.directory, "/project/current")
-        const projectID = (yield* json<{ id: string }>(current)).id
-        const base = `/project/${projectID}`
-        const copies = `/experimental/project/${projectID}/copy?location%5Bdirectory%5D=${encodeURIComponent(test.directory)}`
-        const createdParent = path.join(test.directory, "..", path.basename(test.directory) + "-http-copy")
-        const createdDirectory = path.join(createdParent, "copy")
-        yield* Effect.addFinalizer(() =>
-          Effect.promise(() => fs.rm(createdParent, { recursive: true, force: true })).pipe(Effect.ignore),
-        )
-
-        const initial = yield* request(test.directory, `${base}/directories`)
-        expect(initial.status).toBe(200)
-        expect(yield* json<ProjectDirectory[]>(initial)).toEqual([{ directory: test.directory }])
-
-        const generated = yield* request(test.directory, `/experimental/project/${projectID}/copy/generate-name`, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ context: undefined }),
-        })
-        expect(generated.status).toBe(200)
-        expect((yield* json<{ name: string }>(generated)).name).toBeString()
-
-        const create = yield* request(test.directory, copies, {
-          method: "POST",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ strategy: "git_worktree", directory: createdParent, name: "copy" }),
-        })
-        expect(create.status).toBe(200)
-        const created = yield* json<{ directory: string }>(create)
-        expect(created.directory).toBe(createdDirectory)
-
-        const listed = yield* request(test.directory, `${base}/directories`)
-        expect(yield* json<ProjectDirectory[]>(listed)).toContainEqual({
-          directory: created.directory,
-          strategy: "git_worktree",
-        })
-
-        yield* Effect.promise(() => Bun.write(path.join(created.directory, "dirty.txt"), "dirty"))
-
-        const remove = yield* request(test.directory, copies, {
-          method: "DELETE",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ directory: created.directory, force: false }),
-        })
-        expect(remove.status).toBe(400)
-        expect(yield* json<{ data: { forceRequired?: boolean } }>(remove)).toMatchObject({
-          data: { forceRequired: true },
-        })
-
-        const forced = yield* request(test.directory, copies, {
-          method: "DELETE",
-          headers: { "content-type": "application/json" },
-          body: JSON.stringify({ directory: created.directory, force: true }),
-        })
-        expect(forced.status).toBe(204)
-
-        const externalDirectory = path.join(test.directory, "..", path.basename(test.directory) + "-http-refresh")
-        yield* Effect.addFinalizer(() =>
-          Effect.promise(() => fs.rm(externalDirectory, { recursive: true, force: true })).pipe(Effect.ignore),
-        )
-        yield* Effect.promise(() => $`git worktree add --detach ${externalDirectory} HEAD`.cwd(test.directory).quiet())
-        const refresh = yield* request(
-          test.directory,
-          `/experimental/project/${projectID}/copy/refresh?location%5Bdirectory%5D=${encodeURIComponent(test.directory)}`,
-          {
-            method: "POST",
-          },
-        )
-        expect(refresh.status).toBe(204)
-        const refreshed = yield* request(test.directory, `${base}/directories`)
-        expect(yield* json<ProjectDirectory[]>(refreshed)).toEqual([
-          { directory: externalDirectory, strategy: "git_worktree" },
-          { directory: test.directory },
-        ])
-      }),
-    { git: true },
-  )
-})

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

@@ -1,114 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { FSUtil } from "@miaw/core/fs-util"
-import { Effect, Layer } from "effect"
-import { HttpClientResponse } from "effect/unstable/http"
-import path from "path"
-import { InstanceRef } from "../../src/effect/instance-ref"
-import { InstanceBootstrap } from "../../src/project/bootstrap-service"
-import { InstanceStore } from "../../src/project/instance-store"
-import { GlobalBus, type GlobalEvent } from "../../src/bus/global"
-import { Snapshot } from "../../src/snapshot"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { httpApiLayer, requestInDirectory } from "./httpapi-layer"
-
-afterEach(async () => {
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-const noopBootstrap = Layer.succeed(InstanceBootstrap.Service, InstanceBootstrap.Service.of({ run: Effect.void }))
-const testInstanceStore = InstanceStore.defaultLayer.pipe(Layer.provide(noopBootstrap))
-
-const it = testEffect(Layer.mergeAll(FSUtil.defaultLayer, Snapshot.defaultLayer, testInstanceStore, httpApiLayer))
-
-function request(directory: string, url: string, init: RequestInit = {}) {
-  return requestInDirectory(url, directory, init)
-}
-
-function json<T>(response: HttpClientResponse.HttpClientResponse) {
-  return response.json.pipe(Effect.map((value) => value as T))
-}
-
-function collectGlobalEvents() {
-  return Effect.acquireRelease(
-    Effect.sync(() => {
-      const seen: GlobalEvent[] = []
-      const on = (event: GlobalEvent) => {
-        seen.push(event)
-      }
-      GlobalBus.on("event", on)
-      return { seen, on }
-    }),
-    ({ on }) => Effect.sync(() => GlobalBus.off("event", on)),
-  )
-}
-
-const disposedEvents = (seen: GlobalEvent[], dir: string) =>
-  seen.filter((evt) => evt.directory === dir && evt.payload.type === "server.instance.disposed").length
-
-describe("project.initGit endpoint", () => {
-  it.instance("initializes git and reloads immediately", () =>
-    Effect.gen(function* () {
-      const tmp = yield* TestInstance
-      const fs = yield* FSUtil.Service
-      const events = yield* collectGlobalEvents()
-
-      const init = yield* request(tmp.directory, "/project/git/init", {
-        method: "POST",
-      })
-      const body = yield* json(init)
-      expect(init.status).toBe(200)
-      expect(body).toMatchObject({
-        id: "global",
-        vcs: "git",
-        worktree: tmp.directory,
-      })
-      // Reload behavior: bus emits exactly one server.instance.disposed for the directory.
-      expect(disposedEvents(events.seen, tmp.directory)).toBe(1)
-      expect(yield* fs.exists(path.join(tmp.directory, ".git", "miaw"))).toBe(false)
-
-      const current = yield* request(tmp.directory, "/project/current")
-      expect(current.status).toBe(200)
-      expect(yield* json(current)).toMatchObject({
-        id: "global",
-        vcs: "git",
-        worktree: tmp.directory,
-      })
-
-      const ctx = yield* InstanceStore.use.reload({ directory: tmp.directory })
-      const tracked = yield* Snapshot.Service.use((snapshot) => snapshot.track()).pipe(
-        Effect.provideService(InstanceRef, ctx),
-      )
-      expect(tracked).toBeTruthy()
-    }),
-  )
-
-  it.instance(
-    "does not reload when the project is already git",
-    () =>
-      Effect.gen(function* () {
-        const tmp = yield* TestInstance
-        const events = yield* collectGlobalEvents()
-
-        const init = yield* request(tmp.directory, "/project/git/init", {
-          method: "POST",
-        })
-        expect(init.status).toBe(200)
-        expect(yield* json(init)).toMatchObject({
-          vcs: "git",
-          worktree: tmp.directory,
-        })
-        expect(disposedEvents(events.seen, tmp.directory)).toBe(0)
-
-        const current = yield* request(tmp.directory, "/project/current")
-        expect(current.status).toBe(200)
-        expect(yield* json(current)).toMatchObject({
-          vcs: "git",
-          worktree: tmp.directory,
-        })
-      }),
-    { git: true },
-  )
-})

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 miaw-specific headers", () => {
-      const req = new Request("http://localhost", {
-        headers: {
-          "x-miaw-directory": "/home/user/project",
-          "x-miaw-workspace": "ws_123",
-          "accept-encoding": "gzip",
-          "x-custom": "keep",
-        },
-      })
-      const result = ProxyUtil.headers(req)
-      expect(result.get("x-miaw-directory")).toBeNull()
-      expect(result.get("x-miaw-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")
-    })
-  })
-})

package/test/server/sdk-error-shape.test.ts

@@ -1,81 +0,0 @@
-/**
- * Regression tests for the SDK error shape — the v2 SDK's `throwOnError: true`
- * path used to throw raw values (empty strings or POJOs from JSON-decoded
- * error bodies). The TUI catches those and `e.message`/`e.stack` are
- * undefined, so users see `[object Object]` or a blank crash.
- *
- * Both cases must throw a real `Error` instance with a non-empty `.message`
- * extracted from the response body, plus `.status` and `.body` attached.
- */
-import { afterEach, describe, expect, test } from "bun:test"
-import { createMiawClient } from "@miaw/sdk/v2"
-import { Server } from "../../src/server/server"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { resetDatabase } from "../fixture/db"
-
-afterEach(async () => {
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-function client(directory: string) {
-  return createMiawClient({
-    baseUrl: "http://test",
-    directory,
-    fetch: ((req: Request) => Server.Default().app.fetch(req)) as unknown as typeof fetch,
-  })
-}
-
-describe("v2 SDK error shape", () => {
-  test("404 with NamedError body throws a real Error carrying the server message", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const sdk = client(tmp.path)
-
-    let caught: unknown
-    try {
-      await sdk.session.get({ sessionID: "ses_no_such" }, { throwOnError: true })
-    } catch (e) {
-      caught = e
-    }
-
-    expect(caught).toBeInstanceOf(Error)
-    const err = caught as Error
-    const cause = err.cause as { body?: any; status?: number }
-    expect(err.message).toContain("Session not found")
-    expect(cause.status).toBe(404)
-    expect(cause.body).toMatchObject({
-      name: "NotFoundError",
-      data: { message: expect.stringContaining("Session not found") },
-    })
-  })
-
-  test("400 schema rejection: SDK extracts the field-level reason from the NamedError body", async () => {
-    // Canary for the #26631 wire shape. Asserts the contract end-to-end:
-    // server emits {name:"BadRequest", data:{message, kind}}, SDK's
-    // wrapClientError extracts .data.message into Error.message. If either
-    // side regresses (#26457 reverted because both layers were missing),
-    // this test fails before users see (empty response body).
-    await using tmp = await tmpdir({ config: { formatter: false, lsp: false } })
-    const sdk = client(tmp.path)
-
-    let caught: unknown
-    try {
-      await sdk.sync.history.list({ body: { aggregate: -1 } as any }, { throwOnError: true })
-    } catch (e) {
-      caught = e
-    }
-
-    expect(caught).toBeInstanceOf(Error)
-    const err = caught as Error
-    const cause = err.cause as { body?: any; status?: number }
-    expect(cause.status).toBe(400)
-    expect(cause.body).toMatchObject({
-      name: "BadRequest",
-      data: { kind: expect.stringMatching(/^(Body|Payload)$/) },
-    })
-    expect(typeof cause.body.data.message).toBe("string")
-    expect(cause.body.data.message.length).toBeGreaterThan(0)
-    // Whatever the server put in data.message must be what the user sees.
-    expect(err.message).toBe(cause.body.data.message)
-  })
-})

package/test/server/sdk-v1-smoke.test.ts

@@ -1,57 +0,0 @@
-// Smoke test: v1 SDK (the plugin contract) can actually reach core endpoints
-// against the current server. v1 generation has been frozen since #5216
-// (2025-12-07) so types may be stale, but runtime calls should still work
-// for endpoints the v1 SDK was generated against.
-import { afterEach, describe, expect, test } from "bun:test"
-import { createMiawClient } from "@miaw/sdk"
-import { Server } from "../../src/server/server"
-import { tmpdir, disposeAllInstances } from "../fixture/fixture"
-import { resetDatabase } from "../fixture/db"
-
-afterEach(async () => {
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-function client(directory: string) {
-  return createMiawClient({
-    baseUrl: "http://test",
-    directory,
-    fetch: ((req: Request) => Server.Default().app.fetch(req)) as unknown as typeof fetch,
-  })
-}
-
-describe("v1 SDK runtime smoke", () => {
-  test("session.list reaches the server and returns 200", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const sdk = client(tmp.path)
-    const result = await sdk.session.list()
-    expect(result.error).toBeUndefined()
-    expect(Array.isArray(result.data)).toBe(true)
-  })
-
-  test("path.get reaches the server and returns 200", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const sdk = client(tmp.path)
-    const result = await sdk.path.get()
-    expect(result.error).toBeUndefined()
-    expect(result.data).toBeDefined()
-  })
-
-  test("config.get reaches the server and returns 200", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const sdk = client(tmp.path)
-    const result = await sdk.config.get()
-    expect(result.error).toBeUndefined()
-    expect(result.data).toBeDefined()
-  })
-
-  test("session 404: result-tuple path returns the error body", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const sdk = client(tmp.path)
-    const result = await sdk.session.get({ path: { id: "ses_no_such" } as never })
-    expect(result.error).toBeDefined()
-    // wire body for 404 is NamedError-shaped
-    expect(result.error).toMatchObject({ name: "NotFoundError" })
-  })
-})

package/test/server/session-actions.test.ts

@@ -1,109 +0,0 @@
-import { afterEach, describe, expect, mock } from "bun:test"
-import { Effect, Layer } from "effect"
-import { Session as SessionNs } from "@/session/session"
-import { disposeAllInstances, TestInstance } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-import { httpApiLayer, requestInDirectory } from "./httpapi-layer"
-
-const it = testEffect(Layer.mergeAll(SessionNs.defaultLayer, httpApiLayer))
-
-afterEach(async () => {
-  mock.restore()
-  await disposeAllInstances()
-})
-
-describe("session action routes", () => {
-  it.instance(
-    "session routes expose metadata on create, update, get, and fork",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const headers = { "Content-Type": "application/json" }
-
-        const created = yield* requestInDirectory("/session", test.directory, {
-          method: "POST",
-          headers,
-          body: JSON.stringify({
-            title: "meta-session",
-            metadata: { source: "sdk", trace: { id: "abc" } },
-          }),
-        })
-        expect(created.status).toBe(200)
-
-        const session = (yield* created.json) as SessionNs.Info
-        expect(session.metadata).toEqual({ source: "sdk", trace: { id: "abc" } })
-
-        const updated = yield* requestInDirectory(`/session/${session.id}`, test.directory, {
-          method: "PATCH",
-          headers,
-          body: JSON.stringify({ metadata: { source: "sdk", trace: { id: "def" }, tags: ["one"] } }),
-        })
-        expect(updated.status).toBe(200)
-
-        const next = (yield* updated.json) as SessionNs.Info
-        expect(next.metadata).toEqual({ source: "sdk", trace: { id: "def" }, tags: ["one"] })
-
-        const fetched = yield* requestInDirectory(`/session/${session.id}`, test.directory)
-        expect(fetched.status).toBe(200)
-        expect(((yield* fetched.json) as SessionNs.Info).metadata).toEqual(next.metadata)
-
-        const forked = yield* requestInDirectory(`/session/${session.id}/fork`, test.directory, {
-          method: "POST",
-          headers,
-          body: JSON.stringify({}),
-        })
-        expect(forked.status).toBe(200)
-
-        const fork = (yield* forked.json) as SessionNs.Info
-        expect(fork.metadata).toEqual(next.metadata)
-
-        const reset = yield* requestInDirectory(`/session/${session.id}`, test.directory, {
-          method: "PATCH",
-          headers,
-          body: JSON.stringify({ metadata: {} }),
-        })
-        expect(reset.status).toBe(200)
-        expect(((yield* reset.json) as SessionNs.Info).metadata).toEqual({})
-
-        yield* SessionNs.Service.use((svc) => svc.remove(fork.id).pipe(Effect.ignore))
-        yield* SessionNs.Service.use((svc) => svc.remove(session.id).pipe(Effect.ignore))
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "abort route returns success",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const session = yield* Effect.acquireRelease(SessionNs.use.create({}), (created) =>
-          SessionNs.use.remove(created.id).pipe(Effect.ignore),
-        )
-
-        const res = yield* requestInDirectory(`/session/${session.id}/abort`, test.directory, { method: "POST" })
-
-        expect(res.status).toBe(200)
-        expect(yield* res.json).toBe(true)
-      }),
-    { git: true },
-  )
-
-  it.instance(
-    "experimental background route is a no-op without synchronous subagents",
-    () =>
-      Effect.gen(function* () {
-        const test = yield* TestInstance
-        const session = yield* Effect.acquireRelease(SessionNs.use.create({}), (created) =>
-          SessionNs.use.remove(created.id).pipe(Effect.ignore),
-        )
-
-        const res = yield* requestInDirectory(`/experimental/session/${session.id}/background`, test.directory, {
-          method: "POST",
-        })
-
-        expect(res.status).toBe(200)
-        expect(yield* res.json).toBe(false)
-      }),
-    { git: true },
-  )
-})