@miaws/miaw 1.18.3 → 1.18.5

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

@@ -0,0 +1,223 @@
+import { describe, expect } from "bun:test"
+import { Context, Effect, Layer } from "effect"
+import { HttpApiApp } from "../../src/server/routes/instance/httpapi/server"
+import { McpPaths } from "../../src/server/routes/instance/httpapi/groups/mcp"
+import { Server } from "../../src/server/server"
+import { resetDatabase } from "../fixture/db"
+import { TestInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const context = Context.empty() as Context.Context<unknown>
+const testStateLayer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    yield* Effect.promise(() => resetDatabase())
+    yield* Effect.addFinalizer(() => Effect.promise(() => resetDatabase()).pipe(Effect.ignore))
+  }),
+)
+const it = testEffect(testStateLayer)
+
+function app() {
+  return Server.Default().app
+}
+type TestApp = ReturnType<typeof app>
+type TestHandler = ReturnType<typeof HttpApiApp.webHandler>
+
+const request = Effect.fnUntraced(function* (
+  handler: TestHandler,
+  route: string,
+  directory: string,
+  init?: RequestInit,
+) {
+  const headers = new Headers(init?.headers)
+  headers.set("x-miaw-directory", directory)
+  return yield* Effect.promise(() =>
+    Promise.resolve(
+      handler.handler(
+        new Request(`http://localhost${route}`, {
+          ...init,
+          headers,
+        }),
+        context,
+      ),
+    ),
+  )
+})
+
+const json = <A>(response: Response) => Effect.promise(() => response.json() as Promise<A>)
+
+const readResponse = Effect.fnUntraced(function* (input: { app: TestApp; path: string; headers: HeadersInit }) {
+  const response = yield* Effect.promise(() =>
+    Promise.resolve(input.app.request(input.path, { method: "POST", headers: input.headers })),
+  )
+  return {
+    status: response.status,
+    body: yield* Effect.promise(() => response.text()),
+  }
+})
+
+describe("mcp HttpApi", () => {
+  it.instance(
+    "serves status endpoint",
+    () =>
+      Effect.gen(function* () {
+        const tmp = yield* TestInstance
+        const handler = HttpApiApp.webHandler()
+        const response = yield* request(handler, McpPaths.status, tmp.directory)
+
+        expect(response.status).toBe(200)
+        expect(yield* json(response)).toEqual({ demo: { status: "disabled" } })
+      }),
+    {
+      config: {
+        mcp: {
+          demo: {
+            type: "local",
+            command: ["echo", "demo"],
+            enabled: false,
+          },
+        },
+      },
+    },
+  )
+
+  it.instance(
+    "serves add, connect, and disconnect endpoints",
+    () =>
+      Effect.gen(function* () {
+        const tmp = yield* TestInstance
+        const handler = HttpApiApp.webHandler()
+        const added = yield* request(handler, McpPaths.status, tmp.directory, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({
+            name: "added",
+            config: {
+              type: "local",
+              command: ["echo", "added"],
+              enabled: false,
+            },
+          }),
+        })
+        expect(added.status).toBe(200)
+        expect(yield* json(added)).toMatchObject({ added: { status: "disabled" } })
+
+        const addedDisconnected = yield* request(handler, "/mcp/added/disconnect", tmp.directory, { method: "POST" })
+        expect(addedDisconnected.status).toBe(200)
+        expect(yield* json(addedDisconnected)).toBe(true)
+
+        const connected = yield* request(handler, "/mcp/demo/connect", tmp.directory, { method: "POST" })
+        expect(connected.status).toBe(200)
+        expect(yield* json(connected)).toBe(true)
+
+        const disconnected = yield* request(handler, "/mcp/demo/disconnect", tmp.directory, { method: "POST" })
+        expect(disconnected.status).toBe(200)
+        expect(yield* json(disconnected)).toBe(true)
+      }),
+    {
+      config: {
+        mcp: {
+          demo: {
+            type: "local",
+            command: ["echo", "demo"],
+            enabled: false,
+          },
+        },
+      },
+    },
+  )
+
+  it.instance(
+    "serves deterministic OAuth endpoints",
+    () =>
+      Effect.gen(function* () {
+        const tmp = yield* TestInstance
+        const handler = HttpApiApp.webHandler()
+        const start = yield* request(handler, "/mcp/demo/auth", tmp.directory, { method: "POST" })
+        expect(start.status).toBe(400)
+
+        const authenticate = yield* request(handler, "/mcp/demo/auth/authenticate", tmp.directory, { method: "POST" })
+        expect(authenticate.status).toBe(400)
+
+        const removed = yield* request(handler, "/mcp/demo/auth", tmp.directory, { method: "DELETE" })
+        expect(removed.status).toBe(200)
+        expect(yield* json(removed)).toEqual({ success: true })
+      }),
+    {
+      config: {
+        mcp: {
+          demo: {
+            type: "local",
+            command: ["echo", "demo"],
+            enabled: false,
+          },
+        },
+      },
+    },
+  )
+
+  it.instance(
+    "returns unsupported OAuth error responses",
+    () =>
+      Effect.gen(function* () {
+        const tmp = yield* TestInstance
+        const dir = tmp.directory
+        const headers = { "x-miaw-directory": dir }
+
+        yield* Effect.forEach(["/mcp/demo/auth", "/mcp/demo/auth/authenticate"], (path) =>
+          Effect.gen(function* () {
+            const response = yield* readResponse({ app: app(), path, headers })
+
+            expect(response).toEqual({
+              status: 400,
+              body: JSON.stringify({ error: "MCP server demo does not support OAuth" }),
+            })
+          }),
+        )
+      }),
+    {
+      config: {
+        formatter: false,
+        lsp: false,
+        mcp: {
+          demo: {
+            type: "local",
+            command: ["echo", "demo"],
+            enabled: false,
+          },
+        },
+      },
+    },
+  )
+
+  it.instance(
+    "returns typed not found errors for missing MCP servers",
+    () =>
+      Effect.gen(function* () {
+        const tmp = yield* TestInstance
+        const handler = HttpApiApp.webHandler()
+
+        for (const input of [
+          { method: "POST", route: "/mcp/missing/auth" },
+          { method: "POST", route: "/mcp/missing/auth/authenticate" },
+          { method: "POST", route: "/mcp/missing/auth/callback", body: JSON.stringify({ code: "code" }) },
+          { method: "DELETE", route: "/mcp/missing/auth" },
+          { method: "POST", route: "/mcp/missing/connect" },
+          { method: "POST", route: "/mcp/missing/disconnect" },
+        ]) {
+          const response = yield* request(handler, input.route, tmp.directory, {
+            method: input.method,
+            headers: input.body ? { "content-type": "application/json" } : undefined,
+            body: input.body,
+          })
+
+          expect(response.status).toBe(404)
+          expect(yield* json(response)).toEqual({
+            _tag: "McpServerNotFoundError",
+            name: "missing",
+            message: "MCP server not found: missing",
+          })
+        }
+      }),
+    { config: { mcp: {} } },
+  )
+})

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

@@ -0,0 +1,79 @@
+import { afterEach, describe, expect, mock, test } from "bun:test"
+import { Flag } from "@miaw/core/flag/flag"
+import { withTimeout } from "../../src/util/timeout"
+import { resetDatabase } from "../fixture/db"
+import { disposeAllInstances } from "../fixture/fixture"
+
+type Event = { kind: "publish"; port: number; name: string } | { kind: "unpublishAll" } | { kind: "destroy" }
+const events: Event[] = []
+
+void mock.module("bonjour-service", () => ({
+  Bonjour: class {
+    publish(opts: { port: number; name: string }) {
+      events.push({ kind: "publish", port: opts.port, name: opts.name })
+      return { on: () => {} }
+    }
+    unpublishAll() {
+      events.push({ kind: "unpublishAll" })
+    }
+    destroy() {
+      events.push({ kind: "destroy" })
+    }
+  },
+}))
+
+// Import Server AFTER the mock so the MDNS module picks up the stub.
+const { Server } = await import("../../src/server/server")
+
+const original = {
+  MIAW_SERVER_PASSWORD: Flag.MIAW_SERVER_PASSWORD,
+  MIAW_SERVER_USERNAME: Flag.MIAW_SERVER_USERNAME,
+}
+
+afterEach(async () => {
+  events.length = 0
+  Flag.MIAW_SERVER_PASSWORD = original.MIAW_SERVER_PASSWORD
+  Flag.MIAW_SERVER_USERNAME = original.MIAW_SERVER_USERNAME
+  await disposeAllInstances()
+  await resetDatabase()
+})
+
+describe("HttpApi Server.listen mDNS", () => {
+  test("skips publish for loopback hostnames", async () => {
+    Flag.MIAW_SERVER_PASSWORD = "mdns-secret"
+    Flag.MIAW_SERVER_USERNAME = "miaw"
+    const listener = await Server.listen({ hostname: "127.0.0.1", port: 0, mdns: true })
+    try {
+      expect(events.filter((e) => e.kind === "publish")).toEqual([])
+    } finally {
+      await withTimeout(listener.stop(true), 10_000, "timed out stopping loopback mdns listener")
+    }
+    expect(events.filter((e) => e.kind === "publish")).toEqual([])
+  })
+
+  test("publishes for non-loopback hostnames and unpublishes on stop", async () => {
+    Flag.MIAW_SERVER_PASSWORD = "mdns-secret"
+    Flag.MIAW_SERVER_USERNAME = "miaw"
+    const listener = await Server.listen({ hostname: "0.0.0.0", port: 0, mdns: true })
+    try {
+      const published = events.filter((e) => e.kind === "publish")
+      expect(published.length).toBe(1)
+      expect(published[0]!.port).toBe(listener.port)
+      expect(published[0]!.name).toBe(`miaw-${listener.port}`)
+    } finally {
+      await withTimeout(listener.stop(true), 10_000, "timed out stopping mdns listener")
+    }
+    expect(events.some((e) => e.kind === "unpublishAll")).toBe(true)
+    expect(events.some((e) => e.kind === "destroy")).toBe(true)
+  })
+
+  test("scope finalizer unpublishes even if stop() is not called for force-close", async () => {
+    Flag.MIAW_SERVER_PASSWORD = "mdns-secret"
+    Flag.MIAW_SERVER_USERNAME = "miaw"
+    const listener = await Server.listen({ hostname: "0.0.0.0", port: 0, mdns: true })
+    expect(events.filter((e) => e.kind === "publish").length).toBe(1)
+    // Plain (graceful) stop without close=true should still unpublish.
+    await withTimeout(listener.stop(), 10_000, "timed out stopping graceful mdns listener")
+    expect(events.some((e) => e.kind === "unpublishAll")).toBe(true)
+  })
+})

package/test/server/httpapi-promptasync-context.test.ts

@@ -0,0 +1,223 @@
+// Regression coverage for issue #26526's claim that promptAsync's
+// Effect.forkIn loses the request's InstanceRef/WorkspaceRef. It does not —
+// forkIn preserves Context.Reference values via standard fiber inheritance.
+//
+// The companion claim that the streaming prompt handler "captures and
+// provides" those services is true and load-bearing: Stream.fromEffect's
+// body runs detached from the request fiber's context, so the explicit
+// Effect.provideService calls there are required, not defensive duplication.
+
+import { NodeHttpServer, NodeServices } from "@effect/platform-node"
+import { describe, expect } from "bun:test"
+import { Deferred, Effect, Layer, Schema, Scope } from "effect"
+import * as Stream from "effect/Stream"
+import { HttpClient, HttpRouter, HttpServerResponse } from "effect/unstable/http"
+import * as Socket from "effect/unstable/socket/Socket"
+import { HttpApi, HttpApiBuilder, HttpApiEndpoint, HttpApiGroup, HttpApiSchema } from "effect/unstable/httpapi"
+import { mkdir } from "node:fs/promises"
+import { registerAdapter } from "../../src/control-plane/adapters"
+import { Ripgrep } from "@miaw/core/ripgrep"
+import type { WorkspaceAdapter } from "../../src/control-plane/types"
+import { Workspace } from "../../src/control-plane/workspace"
+import { InstanceRef, WorkspaceRef } from "../../src/effect/instance-ref"
+import { InstanceLayer } from "../../src/project/instance-layer"
+import { Project } from "../../src/project/project"
+import { Session } from "../../src/session/session"
+import {
+  InstanceContextMiddleware,
+  instanceContextLayer,
+} from "../../src/server/routes/instance/httpapi/middleware/instance-context"
+import {
+  WorkspaceRoutingMiddleware,
+  WorkspaceRoutingQuery,
+  workspaceRoutingLayer,
+} from "../../src/server/routes/instance/httpapi/middleware/workspace-routing"
+import { resetDatabase } from "../fixture/db"
+import { disposeAllInstances, tmpdirScoped } from "../fixture/fixture"
+import { workspaceLayerWithRuntimeFlags } from "../fixture/workspace"
+import { testEffect } from "../lib/effect"
+
+const testStateLayer = Layer.effectDiscard(
+  Effect.gen(function* () {
+    yield* Effect.promise(() => resetDatabase())
+    yield* Effect.addFinalizer(() =>
+      Effect.promise(async () => {
+        await disposeAllInstances()
+        await resetDatabase()
+      }),
+    )
+  }),
+)
+
+const workspaceLayer = workspaceLayerWithRuntimeFlags({ experimentalWorkspaces: true })
+
+const it = testEffect(
+  Layer.mergeAll(
+    testStateLayer,
+    NodeHttpServer.layerTest,
+    NodeServices.layer,
+    InstanceLayer.layer,
+    Project.defaultLayer,
+    workspaceLayer,
+  ).pipe(Layer.provide(Ripgrep.defaultLayer)),
+)
+
+const instanceContextTestLayer = Layer.mergeAll(
+  instanceContextLayer,
+  workspaceRoutingLayer.pipe(Layer.provide(Socket.layerWebSocketConstructorGlobal)),
+)
+
+const localAdapter = (directory: string): WorkspaceAdapter => ({
+  name: "Local Test",
+  description: "Create a local test workspace",
+  configure: (info) => ({ ...info, name: "local-test", directory }),
+  create: async () => {
+    await mkdir(directory, { recursive: true })
+  },
+  async remove() {},
+  target: () => ({ type: "local" as const, directory }),
+})
+
+const setupWorkspace = (kind: string) =>
+  Effect.gen(function* () {
+    const dir = yield* tmpdirScoped({ git: true })
+    yield* Project.use.fromDirectory(dir)
+    const projectID = yield* Project.Service.use((svc) => svc.fromDirectory(dir).pipe(Effect.map((p) => p.project.id)))
+    registerAdapter(projectID, kind, localAdapter(dir))
+    const workspace = yield* Workspace.Service.use((svc) =>
+      svc.create({ type: kind, branch: null, extra: null, projectID }),
+    )
+    return { dir, workspace }
+  })
+
+type Capture = { directory?: string; workspaceID?: string }
+
+const captureInstance = Effect.gen(function* () {
+  const instance = yield* InstanceRef
+  const workspaceID = yield* WorkspaceRef
+  return { directory: instance?.directory, workspaceID } satisfies Capture
+})
+
+const ProbeApi = HttpApi.make("handler-context-probe").add(
+  HttpApiGroup.make("probe")
+    .add(
+      HttpApiEndpoint.post("fork", "/fork-probe", { query: WorkspaceRoutingQuery, success: Schema.Boolean }),
+      HttpApiEndpoint.post("streamWithout", "/stream-probe-without", {
+        query: WorkspaceRoutingQuery,
+        success: Schema.String.pipe(HttpApiSchema.asText({ contentType: "application/json" })),
+      }),
+      HttpApiEndpoint.post("streamWith", "/stream-probe-with", {
+        query: WorkspaceRoutingQuery,
+        success: Schema.String.pipe(HttpApiSchema.asText({ contentType: "application/json" })),
+      }),
+    )
+    .middleware(InstanceContextMiddleware)
+    .middleware(WorkspaceRoutingMiddleware),
+)
+
+const serveProbes = (input: {
+  fork?: Effect.Effect<boolean, never, Scope.Scope>
+  streamWithout?: Effect.Effect<HttpServerResponse.HttpServerResponse>
+  streamWith?: Effect.Effect<HttpServerResponse.HttpServerResponse>
+}) =>
+  HttpApiBuilder.layer(ProbeApi).pipe(
+    Layer.provide(
+      HttpApiBuilder.group(ProbeApi, "probe", (handlers) =>
+        handlers
+          .handle("fork", () => input.fork ?? Effect.succeed(false))
+          .handleRaw(
+            "streamWithout",
+            () => input.streamWithout ?? Effect.succeed(HttpServerResponse.empty({ status: 404 })),
+          )
+          .handleRaw("streamWith", () => input.streamWith ?? Effect.succeed(HttpServerResponse.empty({ status: 404 }))),
+      ),
+    ),
+    Layer.provide(instanceContextTestLayer),
+    Layer.provide(Layer.mock(Session.Service)({})),
+    HttpRouter.serve,
+    Layer.build,
+  )
+
+describe("HttpApi handler context inheritance", () => {
+  // Mirrors handlers/session.ts:281 promptAsync. The forked fiber inherits
+  // the request's Context — including InstanceRef and WorkspaceRef provided
+  // by InstanceContextMiddleware — without any explicit re-provide.
+  it.live("Effect.forkIn preserves InstanceRef/WorkspaceRef across the fork", () =>
+    Effect.gen(function* () {
+      const { dir, workspace } = yield* setupWorkspace("local-fork")
+      const capture = yield* Deferred.make<Capture>()
+
+      yield* serveProbes({
+        fork: Effect.gen(function* () {
+          const scope = yield* Scope.Scope
+          yield* Effect.gen(function* () {
+            yield* Deferred.succeed(capture, yield* captureInstance)
+          }).pipe(Effect.forkIn(scope, { startImmediately: true }))
+          return true
+        }),
+      })
+
+      const response = yield* HttpClient.post(
+        `/fork-probe?directory=${encodeURIComponent(dir)}&workspace=${encodeURIComponent(workspace.id)}`,
+      )
+      expect(response.status).toBe(200)
+
+      const observed = yield* Deferred.await(capture).pipe(Effect.timeout("2 seconds"))
+      expect(observed.directory).toBe(dir)
+      expect(observed.workspaceID).toBe(workspace.id)
+    }),
+  )
+
+  // Mirrors handlers/session.ts:255 prompt — the streaming handler reads
+  // InstanceRef/WorkspaceRef in the request fiber and re-provides them to
+  // the Stream.fromEffect body. This test locks in why the explicit
+  // provides are required: without them the stream body sees undefined.
+  it.live("Stream.fromEffect body needs explicit provides — inheritance does not carry through", () =>
+    Effect.gen(function* () {
+      const { dir, workspace } = yield* setupWorkspace("local-stream")
+      const withoutCapture = yield* Deferred.make<Capture>()
+      const withCapture = yield* Deferred.make<Capture>()
+
+      yield* serveProbes({
+        streamWithout: Effect.gen(function* () {
+          return HttpServerResponse.stream(
+            Stream.fromEffect(
+              Effect.gen(function* () {
+                yield* Deferred.succeed(withoutCapture, yield* captureInstance)
+                return ""
+              }),
+            ).pipe(Stream.encodeText),
+            { contentType: "application/json" },
+          )
+        }),
+        streamWith: Effect.gen(function* () {
+          const instance = yield* InstanceRef
+          const workspaceID = yield* WorkspaceRef
+          return HttpServerResponse.stream(
+            Stream.fromEffect(
+              Effect.gen(function* () {
+                yield* Deferred.succeed(withCapture, yield* captureInstance)
+                return ""
+              }).pipe(Effect.provideService(InstanceRef, instance), Effect.provideService(WorkspaceRef, workspaceID)),
+            ).pipe(Stream.encodeText),
+            { contentType: "application/json" },
+          )
+        }),
+      })
+
+      const queryString = `directory=${encodeURIComponent(dir)}&workspace=${encodeURIComponent(workspace.id)}`
+      const responseWithout = yield* HttpClient.post(`/stream-probe-without?${queryString}`)
+      yield* responseWithout.text
+      const responseWith = yield* HttpClient.post(`/stream-probe-with?${queryString}`)
+      yield* responseWith.text
+
+      const without = yield* Deferred.await(withoutCapture).pipe(Effect.timeout("2 seconds"))
+      expect(without.directory).toBeUndefined()
+      expect(without.workspaceID).toBeUndefined()
+
+      const withProvide = yield* Deferred.await(withCapture).pipe(Effect.timeout("2 seconds"))
+      expect(withProvide.directory).toBe(dir)
+      expect(withProvide.workspaceID).toBe(workspace.id)
+    }),
+  )
+})