@miaws/miaw 1.18.5 → 1.18.6

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

@@ -1,400 +0,0 @@
-import { describe, expect } from "bun:test"
-import { FSUtil } from "@miaw/core/fs-util"
-import { Effect, Layer } from "effect"
-import path from "path"
-import { resetDatabase } from "../fixture/db"
-import { TestInstance } from "../fixture/fixture"
-import { markPluginDependenciesReady } from "../fixture/plugin"
-import { testEffect } from "../lib/effect"
-import { httpApiLayer, request } from "./httpapi-layer"
-
-const testStateLayer = Layer.effectDiscard(
-  Effect.acquireRelease(
-    Effect.promise(() => resetDatabase()),
-    () => Effect.promise(() => resetDatabase()),
-  ),
-)
-
-const it = testEffect(Layer.mergeAll(testStateLayer, FSUtil.defaultLayer, httpApiLayer))
-const projectOptions = { config: { formatter: false, lsp: false } }
-const providerID = "test-oauth-parity"
-const oauthURL = "https://example.com/oauth"
-const oauthInstructions = "Finish OAuth"
-
-function providerListHasFetch(list: unknown) {
-  if (!Array.isArray(list)) return false
-  return list.some((item: unknown) => {
-    if (typeof item !== "object" || item === null || !("id" in item) || !("options" in item)) return false
-    if (item.id !== "google") return false
-    if (typeof item.options !== "object" || item.options === null) return false
-    return "fetch" in item.options
-  })
-}
-
-function hasProviderWithFetch(input: unknown, key: "all" | "providers") {
-  if (typeof input !== "object" || input === null) return false
-  if (key === "all") return "all" in input && providerListHasFetch(input.all)
-  return "providers" in input && providerListHasFetch(input.providers)
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-}
-
-function providerList(input: unknown, key: "all" | "providers") {
-  if (!isRecord(input)) return []
-  if (!Array.isArray(input[key])) return []
-  return input[key]
-}
-
-function providerByID(input: unknown, key: "all" | "providers", id: string) {
-  return providerList(input, key).find((provider) => isRecord(provider) && provider.id === id)
-}
-
-function hasNonZeroModelCost(input: unknown, key: "all" | "providers", id: string) {
-  const provider = providerByID(input, key, id)
-  if (!isRecord(provider) || !isRecord(provider.models)) return false
-  return Object.values(provider.models).some((model) => {
-    if (!isRecord(model) || !isRecord(model.cost) || !isRecord(model.cost.cache)) return false
-    return [model.cost.input, model.cost.output, model.cost.cache.read, model.cost.cache.write].some(
-      (cost) => typeof cost === "number" && cost > 0,
-    )
-  })
-}
-
-function hasProviderMutationMarker(input: unknown, key: "all" | "providers", id: string) {
-  const provider = providerByID(input, key, id)
-  if (!isRecord(provider)) return false
-  if (provider.name === "mutated-provider") return true
-  return isRecord(provider.options) && provider.options.mutatedByPlugin === true
-}
-
-function requestAuthorize(input: {
-  providerID: string
-  method: number
-  headers: HeadersInit
-  inputs?: Record<string, string>
-}) {
-  return Effect.gen(function* () {
-    const response = yield* request(`/provider/${input.providerID}/oauth/authorize`, {
-      method: "POST",
-      headers: input.headers,
-      body: JSON.stringify({ method: input.method, ...(input.inputs ? { inputs: input.inputs } : {}) }),
-    })
-    return {
-      status: response.status,
-      body: yield* response.text,
-    }
-  })
-}
-
-function requestCallback(input: { providerID: string; method: number; headers: HeadersInit; code?: string }) {
-  return Effect.gen(function* () {
-    const response = yield* request(`/provider/${input.providerID}/oauth/callback`, {
-      method: "POST",
-      headers: input.headers,
-      body: JSON.stringify({ method: input.method, ...(input.code ? { code: input.code } : {}) }),
-    })
-    return {
-      status: response.status,
-      body: yield* response.text,
-    }
-  })
-}
-
-function writeProviderAuthPlugin(dir: string) {
-  return Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    yield* Effect.promise(() => markPluginDependenciesReady(path.join(dir, ".miaw")))
-
-    yield* fs.writeWithDirs(
-      path.join(dir, ".miaw", "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 writeProviderAuthValidationPlugin(dir: string) {
-  return Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    yield* Effect.promise(() => markPluginDependenciesReady(path.join(dir, ".miaw")))
-
-    yield* fs.writeWithDirs(
-      path.join(dir, ".miaw", "plugin", "provider-oauth-validation.ts"),
-      [
-        "export default {",
-        '  id: "test.provider-oauth-validation",',
-        "  server: async () => ({",
-        "    auth: {",
-        '      provider: "test-oauth-validation",',
-        "      methods: [",
-        "        {",
-        '          type: "oauth",',
-        '          label: "OAuth",',
-        "          prompts: [",
-        "            {",
-        '              type: "text",',
-        '              key: "token",',
-        '              message: "Token",',
-        "              validate: (value) => value === 'ok' ? undefined : 'Token must be ok',",
-        "            },",
-        "          ],",
-        "          authorize: async () => ({",
-        `            url: "${oauthURL}",`,
-        '            method: "code",',
-        `            instructions: "${oauthInstructions}",`,
-        "            callback: async () => ({ type: 'success', key: 'token' }),",
-        "          }),",
-        "        },",
-        "      ],",
-        "    },",
-        "  }),",
-        "}",
-        "",
-      ].join("\n"),
-    )
-  })
-}
-
-function writeFunctionOptionsPlugin(dir: string) {
-  return Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    yield* Effect.promise(() => markPluginDependenciesReady(path.join(dir, ".miaw")))
-
-    yield* fs.writeWithDirs(
-      path.join(dir, ".miaw", "plugin", "provider-function-options.ts"),
-      [
-        "export default {",
-        '  id: "test.provider-function-options",',
-        "  server: async () => ({",
-        "    auth: {",
-        '      provider: "google",',
-        "      loader: async (_getAuth, provider) => {",
-        "        for (const model of Object.values(provider.models ?? {})) {",
-        "          model.cost = { input: 0, output: 0 }",
-        "        }",
-        "        return {",
-        '        apiKey: "",',
-        "        fetch: async (input, init) => fetch(input, init),",
-        "        }",
-        "      },",
-        "      methods: [{ type: 'api', label: 'API key' }],",
-        "    },",
-        "  }),",
-        "}",
-        "",
-      ].join("\n"),
-    )
-  })
-}
-
-function writeProviderModelsMutationPlugin(dir: string) {
-  return Effect.gen(function* () {
-    const fs = yield* FSUtil.Service
-    yield* Effect.promise(() => markPluginDependenciesReady(path.join(dir, ".miaw")))
-
-    yield* fs.writeWithDirs(
-      path.join(dir, ".miaw", "plugin", "provider-models-mutation.ts"),
-      [
-        "export default {",
-        '  id: "test.provider-models-mutation",',
-        "  server: async () => ({",
-        "    provider: {",
-        '      id: "google",',
-        "      models: async (provider) => {",
-        "        const models = Object.fromEntries(",
-        "          Object.entries(provider.models ?? {}).map(([id, model]) => [id, { ...model }]),",
-        "        )",
-        '        provider.name = "mutated-provider"',
-        "        provider.options = { ...provider.options, mutatedByPlugin: true }",
-        "        for (const model of Object.values(provider.models ?? {})) {",
-        "          model.cost = { input: 0, output: 0 }",
-        "        }",
-        "        return models",
-        "      },",
-        "    },",
-        "  }),",
-        "}",
-        "",
-      ].join("\n"),
-    )
-  })
-}
-
-function setEnvScoped(key: string, value: string) {
-  return Effect.acquireRelease(
-    Effect.sync(() => {
-      const previous = process.env[key]
-      process.env[key] = value
-      return previous
-    }),
-    (previous) =>
-      Effect.sync(() => {
-        if (previous === undefined) delete process.env[key]
-        else process.env[key] = previous
-      }),
-  )
-}
-
-describe("provider HttpApi", () => {
-  it.instance.skip(
-    "returns public v2 provider not found errors",
-    Effect.gen(function* () {
-      const directory = (yield* TestInstance).directory
-      const response = yield* request("/api/provider/missing", {
-        headers: { "x-miaw-directory": directory },
-      })
-
-      expect(response.status).toBe(404)
-      expect(yield* response.json).toEqual({
-        _tag: "ProviderNotFoundError",
-        providerID: "missing",
-        message: "Provider not found: missing",
-      })
-    }),
-    projectOptions,
-  )
-
-  it.instance(
-    "serves OAuth authorize response shapes",
-    Effect.gen(function* () {
-      const directory = (yield* TestInstance).directory
-      const headers = { "x-miaw-directory": directory, "content-type": "application/json" }
-      const api = yield* requestAuthorize({
-        providerID,
-        method: 0,
-        headers,
-      })
-      // method 0 (api-key style) — authorize() resolves with no further
-      // redirect; #26474 changed the wire format to JSON `null` so clients
-      // can `.json()` parse uniformly instead of getting an empty body
-      // that throws.
-      expect(api).toEqual({ status: 200, body: "null" })
-
-      const oauth = yield* requestAuthorize({
-        providerID,
-        method: 1,
-        headers,
-      })
-      expect(JSON.parse(oauth.body)).toEqual({
-        url: oauthURL,
-        method: "code",
-        instructions: oauthInstructions,
-      })
-    }),
-    { ...projectOptions, init: writeProviderAuthPlugin },
-    30000,
-  )
-
-  it.instance(
-    "returns declared provider auth validation errors",
-    Effect.gen(function* () {
-      const directory = (yield* TestInstance).directory
-      const response = yield* requestAuthorize({
-        providerID: "test-oauth-validation",
-        method: 0,
-        inputs: { token: "nope" },
-        headers: { "x-miaw-directory": directory, "content-type": "application/json" },
-      })
-
-      expect(response.status).toBe(400)
-      expect(JSON.parse(response.body)).toEqual({
-        name: "ProviderAuthValidationFailed",
-        data: { field: "token", message: "Token must be ok" },
-      })
-    }),
-    { ...projectOptions, init: writeProviderAuthValidationPlugin },
-    30000,
-  )
-
-  it.instance(
-    "returns declared provider auth callback errors",
-    Effect.gen(function* () {
-      const directory = (yield* TestInstance).directory
-      const response = yield* requestCallback({
-        providerID,
-        method: 0,
-        headers: { "x-miaw-directory": directory, "content-type": "application/json" },
-      })
-
-      expect(response.status).toBe(400)
-      expect(JSON.parse(response.body)).toEqual({
-        name: "ProviderAuthOauthMissing",
-        data: { providerID },
-      })
-    }),
-    projectOptions,
-    30000,
-  )
-
-  it.instance(
-    "serves provider lists when auth loaders add runtime fetch options",
-    Effect.gen(function* () {
-      const directory = (yield* TestInstance).directory
-      yield* setEnvScoped(
-        "MIAW_AUTH_CONTENT",
-        JSON.stringify({
-          google: { type: "oauth", refresh: "dummy", access: "dummy", expires: 9999999999999 },
-        }),
-      )
-      const headers = { "x-miaw-directory": directory }
-      const providerResponse = yield* request("/provider", { headers })
-      const configResponse = yield* request("/config/providers", { headers })
-
-      expect(providerResponse.status).toBe(200)
-      expect(configResponse.status).toBe(200)
-
-      const providerBody = yield* providerResponse.json
-      const configBody = yield* configResponse.json
-      expect(hasProviderWithFetch(providerBody, "all")).toBe(false)
-      expect(hasProviderWithFetch(configBody, "providers")).toBe(false)
-      expect(hasNonZeroModelCost(providerBody, "all", "google")).toBe(true)
-      expect(hasNonZeroModelCost(configBody, "providers", "google")).toBe(true)
-    }),
-    { ...projectOptions, init: writeFunctionOptionsPlugin },
-  )
-
-  it.instance(
-    "keeps provider.models hook input mutations out of provider state",
-    Effect.gen(function* () {
-      const directory = (yield* TestInstance).directory
-
-      const headers = { "x-miaw-directory": directory }
-      const providerResponse = yield* request("/provider", { headers })
-      const configResponse = yield* request("/config/providers", { headers })
-
-      expect(providerResponse.status).toBe(200)
-      expect(configResponse.status).toBe(200)
-
-      const providerBody = yield* providerResponse.json
-      const configBody = yield* configResponse.json
-      expect(hasProviderMutationMarker(providerBody, "all", "google")).toBe(false)
-      expect(hasProviderMutationMarker(configBody, "providers", "google")).toBe(false)
-      expect(hasNonZeroModelCost(providerBody, "all", "google")).toBe(true)
-    }),
-    { ...projectOptions, init: writeProviderModelsMutationPlugin },
-  )
-})

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

@@ -1,299 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test"
-import { NodeHttpServer, NodeServices } from "@effect/platform-node"
-import { PtyID } from "@miaw/core/pty/schema"
-import { Server } from "../../src/server/server"
-import { PtyPaths } from "../../src/server/routes/instance/httpapi/groups/pty"
-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 { HttpApiApp } from "../../src/server/routes/instance/httpapi/server"
-import { Pty } from "@miaw/core/pty"
-import { testEffect } from "../lib/effect"
-
-const testPty = process.platform === "win32" ? test.skip : test
-
-const testStateLayer = Layer.effectDiscard(
-  Effect.gen(function* () {
-    yield* Effect.promise(() => resetDatabase())
-    yield* Effect.addFinalizer(() =>
-      Effect.promise(async () => {
-        await resetDatabase()
-      }),
-    )
-  }),
-)
-
-const servedRoutes: Layer.Layer<never, Config.ConfigError, HttpServer.HttpServer> = HttpRouter.serve(
-  HttpApiApp.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() {
-  return Server.Default().app
-}
-
-function serverUrl() {
-  return HttpServer.HttpServer.use((server) => Effect.succeed(HttpServer.formatAddress(server.address)))
-}
-
-const directoryHeader = (dir: string) => HttpClientRequest.setHeader("x-miaw-directory", dir)
-
-afterEach(async () => {
-  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-miaw-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-miaw-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)
-    expect(await missing.json()).toEqual({
-      _tag: "PtyNotFoundError",
-      ptyID: info.id,
-      message: `PTY session not found: ${info.id}`,
-    })
-
-    const missingUpdate = await app().request(PtyPaths.update.replace(":ptyID", info.id), {
-      method: "PUT",
-      headers: { ...headers, "content-type": "application/json" },
-      body: JSON.stringify({ title: "missing" }),
-    })
-    expect(missingUpdate.status).toBe(404)
-    expect(await missingUpdate.json()).toEqual({
-      _tag: "PtyNotFoundError",
-      ptyID: info.id,
-      message: `PTY session not found: ${info.id}`,
-    })
-
-    const missingRemove = await app().request(PtyPaths.remove.replace(":ptyID", info.id), { method: "DELETE", headers })
-    expect(missingRemove.status).toBe(404)
-    expect(await missingRemove.json()).toEqual({
-      _tag: "PtyNotFoundError",
-      ptyID: info.id,
-      message: `PTY session not found: ${info.id}`,
-    })
-  })
-
-  testPty("hides exited sessions on the legacy surface", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const headers = { "x-miaw-directory": tmp.path }
-    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", "exit 0"] }),
-    })
-    expect(created.status).toBe(200)
-    const info = await created.json()
-
-    // Exited sessions are retained by core for the canonical surface, but the legacy
-    // routes preserve pre-retention behavior: exited sessions are invisible here.
-    const deadline = Date.now() + 5_000
-    while (Date.now() < deadline) {
-      const found = await app().request(PtyPaths.get.replace(":ptyID", info.id), { headers })
-      if (found.status === 404) break
-      await new Promise((resolve) => setTimeout(resolve, 50))
-    }
-    const found = await app().request(PtyPaths.get.replace(":ptyID", info.id), { headers })
-    expect(found.status).toBe(404)
-
-    const list = await app().request(PtyPaths.list, { headers })
-    expect(list.status).toBe(200)
-    expect(await list.json()).toEqual([])
-  })
-
-  testPty("disposes PTY sessions with their legacy instance", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const headers = { "x-miaw-directory": tmp.path }
-    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"] }),
-    })
-    expect(created.status).toBe(200)
-
-    await disposeAllInstances()
-
-    const list = await app().request(PtyPaths.list, { headers })
-    expect(list.status).toBe(200)
-    expect(await list.json()).toEqual([])
-  })
-
-  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-miaw-directory": tmp.path },
-    })
-    expect(response.status).toBe(404)
-  })
-
-  test("returns 404 for missing PTY websocket before decoding cursor query", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const response = await app().request(`${PtyPaths.connect.replace(":ptyID", PtyID.ascending())}?cursor=a&cursor=b`, {
-      headers: { "x-miaw-directory": tmp.path },
-    })
-    expect(response.status).toBe(404)
-  })
-
-  test("returns typed not found errors for missing PTY HTTP resources", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const headers = { "x-miaw-directory": tmp.path }
-    const missingID = String(PtyID.ascending())
-    const expected = {
-      _tag: "PtyNotFoundError",
-      ptyID: missingID,
-      message: `PTY session not found: ${missingID}`,
-    }
-
-    const found = await app().request(PtyPaths.get.replace(":ptyID", missingID), { headers })
-    expect(found.status).toBe(404)
-    expect(await found.json()).toEqual(expected)
-
-    const updated = await app().request(PtyPaths.update.replace(":ptyID", missingID), {
-      method: "PUT",
-      headers: { ...headers, "content-type": "application/json" },
-      body: JSON.stringify({ title: "missing" }),
-    })
-    expect(updated.status).toBe(404)
-    expect(await updated.json()).toEqual(expected)
-
-    const removed = await app().request(PtyPaths.remove.replace(":ptyID", missingID), { method: "DELETE", headers })
-    expect(removed.status).toBe(404)
-    expect(await removed.json()).toEqual(expected)
-  })
-
-  test("returns typed errors for PTY connect token failures", async () => {
-    await using tmp = await tmpdir({ git: true, config: { formatter: false, lsp: false } })
-    const headers = { "x-miaw-directory": tmp.path }
-    const missingID = String(PtyID.ascending())
-
-    const forbidden = await app().request(PtyPaths.connectToken.replace(":ptyID", missingID), {
-      method: "POST",
-      headers,
-    })
-    expect(forbidden.status).toBe(403)
-    expect(await forbidden.json()).toEqual({
-      _tag: "PtyForbiddenError",
-      message: "Invalid PTY connect token request",
-    })
-
-    const missing = await app().request(PtyPaths.connectToken.replace(":ptyID", missingID), {
-      method: "POST",
-      headers: {
-        ...headers,
-        "x-miaw-ticket": "1",
-      },
-    })
-    expect(missing.status).toBe(404)
-    expect(await missing.json()).toEqual({
-      _tag: "PtyNotFoundError",
-      ptyID: missingID,
-      message: `PTY session not found: ${missingID}`,
-    })
-  })
-  ;(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)
-      }),
-  )
-})