@opencode/server 0.0.0-dev-19794 → 0.0.0-dev-19808

package/dist/chunks/workerd-2sy3c7de.js

@@ -0,0 +1,83 @@
+import {
+  __export
+} from "./workerd-9rqn6x4v.js";
+
+// src/event-feed.ts
+var exports_event_feed = {};
+__export(exports_event_feed, {
+  EncodingError: () => EncodingError2,
+  EventFeed: () => exports_event_feed,
+  Service: () => Service2,
+  SubscriberCapacity: () => SubscriberCapacity2,
+  SubscriberOverflowError: () => SubscriberOverflowError2,
+  frame: () => frame2,
+  layer: () => layer2,
+  make: () => make4
+});
+import { Bus } from "@opencode/core/bus";
+import { Event } from "@opencode/schema/event";
+import { isOpenCodeEvent } from "@opencode/protocol/groups/event";
+import { Cause, Context, Effect, Layer, Queue, Schema, Stream } from "effect";
+var SubscriberCapacity2 = 4096;
+
+class SubscriberOverflowError2 extends Schema.TaggedError()("EventFeed.SubscriberOverflow", { capacity: Schema.Int }) {
+}
+
+class EncodingError2 extends Schema.TaggedError()("EventFeed.EncodingError", {
+  eventID: Event.ID,
+  eventType: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+
+class Service2 extends Context.Service()("@opencode/server/EventFeed") {
+}
+function frame2(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+var make4 = Effect.fn("EventFeed.make")(function* (observe, options) {
+  const capacity = options?.capacity ?? SubscriberCapacity2;
+  const render = options?.encode ?? frame2;
+  const subscribers = new Set;
+  const fail = (error) => Effect.sync(() => {
+    const current = Array.from(subscribers);
+    subscribers.clear();
+    for (const subscriber of current)
+      Queue.failCauseUnsafe(subscriber, Cause.fail(error));
+  });
+  const publish = Effect.fnUntraced(function* (event) {
+    if (!isOpenCodeEvent(event))
+      return;
+    if (subscribers.size === 0)
+      return;
+    const encoded = yield* Effect.try({
+      try: () => render(event),
+      catch: (cause) => new EncodingError2({ eventID: event.id, eventType: event.type, cause })
+    }).pipe(Effect.catch((error) => Effect.logError("Failed to encode public event", {
+      eventID: error.eventID,
+      eventType: error.eventType,
+      cause: error.cause
+    }).pipe(Effect.andThen(fail(error)), Effect.as(undefined))));
+    if (encoded === undefined)
+      return;
+    for (const subscriber of subscribers) {
+      if (Queue.offerUnsafe(subscriber, encoded))
+        continue;
+      subscribers.delete(subscriber);
+      Queue.failCauseUnsafe(subscriber, Cause.fail(new SubscriberOverflowError2({ capacity })));
+    }
+  });
+  const unsubscribe = yield* observe(publish);
+  yield* Effect.addFinalizer(() => unsubscribe);
+  return Service2.of({
+    subscribe: Effect.acquireRelease(Queue.dropping(capacity).pipe(Effect.tap((queue) => Effect.sync(() => subscribers.add(queue)))), (queue) => Effect.sync(() => subscribers.delete(queue)).pipe(Effect.andThen(Queue.shutdown(queue)), Effect.asVoid)).pipe(Effect.map(Stream.fromQueue))
+  });
+});
+var layer2 = Layer.effect(Service2, Effect.gen(function* () {
+  const bus = yield* Bus.Service;
+  return yield* make4(bus.listen);
+}));
+
+export { SubscriberCapacity2, SubscriberOverflowError2, EncodingError2, Service2, frame2, make4, layer2, exports_event_feed };

package/dist/chunks/workerd-3kzx88w9.js

@@ -0,0 +1,26 @@
+import {
+  sessionInfo2
+} from "./workerd-6gkz39ey.js";
+
+// src/middleware/session-location.ts
+import { Instance } from "@opencode/core/instance/service";
+import { Session } from "@opencode/core/session";
+import { Effect, Layer } from "effect";
+import { HttpRouter } from "effect/unstable/http";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { InvalidRequestError, SessionNotFoundError } from "@opencode/protocol/errors";
+class SessionLocationMiddleware2 extends HttpApiMiddleware.Service()("@opencode/HttpApiSessionLocation", {
+  error: [InvalidRequestError, SessionNotFoundError]
+}) {
+}
+var sessionLocationLayer2 = Layer.effect(SessionLocationMiddleware2, Effect.gen(function* () {
+  const sessions = yield* Session.Service;
+  const instances = yield* Instance.Service;
+  return SessionLocationMiddleware2.of((effect) => Effect.gen(function* () {
+    const route = yield* HttpRouter.RouteContext;
+    const session = yield* sessionInfo2(sessions, route.params.sessionID);
+    return yield* effect.pipe(instances.provide(session));
+  }));
+}));
+
+export { SessionLocationMiddleware2, sessionLocationLayer2 };

package/dist/chunks/workerd-4g0fa6m0.js

@@ -0,0 +1,32 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/vcs.ts
+import { Vcs } from "@opencode/core/vcs";
+import { ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var VcsHandler2 = HttpApiBuilder.group(Api2, "server.vcs", (handlers) => Effect.gen(function* () {
+  return handlers.handle("vcs.get", () => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.info();
+  }))).handle("vcs.base", () => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.base().pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));
+  }))).handle("vcs.status", () => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.status();
+  }))).handle("vcs.branch.list", (ctx) => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.branches({ search: ctx.query.search, limit: Math.min(ctx.query.limit ?? 50, 100) });
+  }))).handle("vcs.diff", (ctx) => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.diff(ctx.query.mode, { context: ctx.query.context, base: ctx.query.base }).pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));
+  })));
+}));
+
+export { VcsHandler2 };

package/dist/chunks/workerd-4vn5bvkr.js

@@ -0,0 +1,25 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/generate.ts
+import { Generate } from "@opencode/core/generate";
+import { Location } from "@opencode/core/location";
+import { LocationServiceMap } from "@opencode/core/location-services";
+import { AbsolutePath } from "@opencode/core/schema";
+import { InvalidRequestError, ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Global } from "@opencode/util/global";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var GenerateHandler2 = HttpApiBuilder.group(Api2, "server.generate", (handlers) => Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const locations = yield* LocationServiceMap.Service;
+  const services = locations.get(Location.Ref.make({ directory: AbsolutePath.make(global.config) }));
+  return handlers.handle("generate.text", Effect.fn("server.generate.text")(function* (request) {
+    const generate = yield* Generate.Service;
+    const text = yield* generate.text(request.payload).pipe(Effect.mapError((error) => error._tag === "Generate.ModelSelectionError" ? new InvalidRequestError({ message: error.message }) : new ServiceUnavailableError({ message: error.message, service: error.service })));
+    return { data: { text } };
+  }, Effect.provide(services)));
+}));
+
+export { GenerateHandler2 };

package/dist/chunks/workerd-5rwqcaw2.js

@@ -0,0 +1,33 @@
+import {
+  sessionInfo2,
+  requestRef2
+} from "./workerd-6gkz39ey.js";
+
+// src/middleware/form-location.ts
+import { Instance } from "@opencode/core/instance/service";
+import { LocationServiceMap } from "@opencode/core/location-services";
+import { Session } from "@opencode/core/session";
+import { InvalidRequestError, SessionNotFoundError } from "@opencode/protocol/errors";
+import { Effect, Layer } from "effect";
+import { HttpRouter, HttpServerRequest } from "effect/unstable/http";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+class FormLocationMiddleware2 extends HttpApiMiddleware.Service()("@opencode/HttpApiFormLocation", {
+  error: [InvalidRequestError, SessionNotFoundError]
+}) {
+}
+var formLocationLayer2 = Layer.effect(FormLocationMiddleware2, Effect.gen(function* () {
+  const sessions = yield* Session.Service;
+  const instances = yield* Instance.Service;
+  const locations = yield* LocationServiceMap.Service;
+  return FormLocationMiddleware2.of((effect) => Effect.gen(function* () {
+    const route = yield* HttpRouter.RouteContext;
+    if (route.params.sessionID === "global") {
+      const request = yield* HttpServerRequest.HttpServerRequest;
+      return yield* effect.pipe(Effect.provide(locations.get(requestRef2(request))));
+    }
+    const session = yield* sessionInfo2(sessions, route.params.sessionID);
+    return yield* effect.pipe(instances.provide(session));
+  }));
+}));
+
+export { FormLocationMiddleware2, formLocationLayer2 };

package/dist/chunks/workerd-5w24ch67.js

@@ -0,0 +1,23 @@
+import {
+  __export
+} from "./workerd-9rqn6x4v.js";
+
+// src/service-status.ts
+var exports_service_status = {};
+__export(exports_service_status, {
+  Status: () => exports_service_status,
+  make: () => make3
+});
+import { Effect, Ref } from "effect";
+var make3 = Effect.fnUntraced(function* (options = {}) {
+  const current = yield* Ref.make(options.initial ?? { type: "starting" });
+  const beginStopping = Ref.update(current, (status) => status.type === "stopping" ? status : { type: "stopping" });
+  return {
+    current: Ref.get(current),
+    ready: Ref.update(current, (status) => status.type === "starting" ? { type: "ready" } : status),
+    fail: Ref.update(current, (status) => status.type === "starting" ? { type: "failed" } : status),
+    beginStopping
+  };
+});
+
+export { make3, exports_service_status };

package/dist/chunks/workerd-6gkz39ey.js

@@ -0,0 +1,55 @@
+import {
+  missingSession2
+} from "./workerd-smaf4a18.js";
+
+// src/location.ts
+import { Location } from "@opencode/core/location";
+import { LocationServiceMap } from "@opencode/core/location-services";
+import { AbsolutePath } from "@opencode/core/schema";
+import { Session } from "@opencode/core/session";
+import { InvalidRequestError } from "@opencode/protocol/errors";
+import { Effect, Layer, Schema } from "effect";
+import { HttpServerRequest } from "effect/unstable/http";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+class LocationMiddleware2 extends HttpApiMiddleware.Service()("@opencode/HttpApiLocation") {
+}
+function response2(data) {
+  return Effect.gen(function* () {
+    const location = yield* Location.Service;
+    return {
+      location: new Location.Info({
+        directory: location.directory,
+        project: location.project
+      }),
+      data: yield* data
+    };
+  });
+}
+var decodeSessionID = Schema.decodeUnknownEffect(Session.ID);
+var sessionInfo2 = Effect.fnUntraced(function* (sessions, sessionID) {
+  const id = yield* decodeSessionID(sessionID).pipe(Effect.mapError(() => new InvalidRequestError({ message: "Invalid session ID", field: "sessionID" })));
+  return yield* sessions.get(id).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+});
+function requestRef2(request) {
+  const query = new URL(request.url, "http://localhost").searchParams;
+  const directory = query.get("location[directory]") || (request.headers["x-opencode-directory"] ? decode(request.headers["x-opencode-directory"]) : process.cwd());
+  return Location.Ref.make({
+    directory: AbsolutePath.make(directory)
+  });
+}
+function decode(input) {
+  try {
+    return decodeURIComponent(input);
+  } catch {
+    return input;
+  }
+}
+var layer4 = Layer.effect(LocationMiddleware2, Effect.gen(function* () {
+  const locations = yield* LocationServiceMap.Service;
+  return LocationMiddleware2.of((effect) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    return yield* effect.pipe(Effect.provide(locations.get(requestRef2(request))));
+  }));
+}));
+
+export { LocationMiddleware2, response2, sessionInfo2, requestRef2, layer4 };

package/dist/chunks/workerd-6nvan4e0.js

@@ -0,0 +1,17 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/form.ts
+import { Form } from "@opencode/core/form";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var FormHandler2 = HttpApiBuilder.group(Api2, "server.form", (handlers) => handlers.handle("form.list", Effect.fn(function* () {
+  const form = yield* Form.Service;
+  return yield* response2(form.list());
+})));
+
+export { FormHandler2 };

package/dist/chunks/workerd-6ptwb1q1.js

@@ -0,0 +1,149 @@
+import {
+  layer4
+} from "./workerd-6gkz39ey.js";
+import {
+  formLocationLayer2
+} from "./workerd-5rwqcaw2.js";
+import {
+  sessionLocationLayer2
+} from "./workerd-3kzx88w9.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+import {
+  Config2
+} from "./workerd-zyv89x5n.js";
+import {
+  CorsConfig2
+} from "./workerd-q4bn6dy8.js";
+import {
+  layer3
+} from "./workerd-mzr9gftb.js";
+import {
+  node2
+} from "./workerd-75c938bc.js";
+import {
+  handlers2
+} from "./workerd-2rvsests.js";
+import {
+  authorizationLayer2
+} from "./workerd-m6wvgbfq.js";
+import {
+  schemaErrorLayer2
+} from "./workerd-t8yzmczr.js";
+
+// src/routes.ts
+import { Database } from "@opencode/core/database/database";
+import { V1Migration } from "@opencode/core/database/v1-migration";
+import { App } from "@opencode/core/app";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder";
+import { Bus } from "@opencode/core/bus";
+import { EventLogger } from "@opencode/core/event-logger";
+import { FileSystemSearch } from "@opencode/core/filesystem/search";
+import { Credential } from "@opencode/core/credential";
+import { Config } from "@opencode/core/config";
+import { PermissionSaved } from "@opencode/core/permission/saved";
+import { PtyTicket } from "@opencode/core/pty/ticket";
+import { PersistentPty } from "@opencode/core/persistent-pty";
+import { Project } from "@opencode/core/project";
+import { Worktree } from "@opencode/core/worktree";
+import { Session } from "@opencode/core/session";
+import { Instance } from "@opencode/core/instance/service";
+import { SessionTransfer } from "@opencode/core/session/transfer";
+import { ShellSelect } from "@opencode/core/shell/select";
+import { Job } from "@opencode/core/job";
+import { Mcp } from "@opencode/core/mcp/index";
+import { Global } from "@opencode/util/global";
+import { InstructionDiscovery } from "@opencode/core/instruction-discovery";
+import { LocationServiceMap } from "@opencode/core/location-service-map";
+import { LocationActivity } from "@opencode/core/location-activity";
+import { ModelsDev } from "@opencode/core/models-dev";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+import { PluginUpdate } from "@opencode/core/plugin/update";
+import { SdkPlugins } from "@opencode/core/plugin/sdk";
+import { WellKnown } from "@opencode/core/wellknown";
+import { Workspace } from "@opencode/core/workspace";
+import { Watcher } from "@opencode/core/filesystem/watcher";
+import { HttpRouter } from "effect/unstable/http";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Context, Effect, Layer, Option } from "effect";
+var applicationServiceNodes = [
+  Global.node,
+  Database.node,
+  Bus.node,
+  EventLogger.node,
+  httpClient,
+  Job.node,
+  Project.node,
+  Worktree.node,
+  Session.node,
+  Instance.node,
+  SessionTransfer.node,
+  SdkPlugins.node,
+  PluginUpdate.node,
+  PermissionSaved.node,
+  PtyTicket.node,
+  PersistentPty.node,
+  Credential.node,
+  WellKnown.node,
+  node2,
+  LocationServiceMap.node,
+  LocationActivity.node,
+  SessionRestart.node,
+  Workspace.node
+];
+var applicationServices = LayerNode.group(applicationServiceNodes);
+function createRoutes2(options = {}, serviceURLs = () => [], overrides = []) {
+  return makeRoutes(options.password ? Config2.configLayer({ password: Option.some(options.password) }) : Config2.layer, options, serviceURLs, overrides);
+}
+function createEmbeddedRoutes2(options = {}, overrides = [], instances) {
+  return makeRoutes(Config2.configLayer({ password: Option.none() }), options, () => [], overrides, instances);
+}
+function makeRoutes(auth, options, serviceURLs, overrides, instances) {
+  const standard = [
+    Database.node.replace(Database.configured(options.database)),
+    PersistentPty.node.replace(PersistentPty.configured(options.pty)),
+    Bus.node.replace(Bus.configured({ persist: options.events?.persist })),
+    App.node.replace(App.configured(options.app)),
+    ModelsDev.node.replace(ModelsDev.configured(options.models)),
+    Watcher.node.replace(Watcher.configured({ enabled: options.fs?.filewatcher })),
+    FileSystemSearch.node.replace(FileSystemSearch.configured({ fff: options.fs?.fff })),
+    Global.node.replace(Global.layerWith(options.config?.directory ? { config: options.config.directory } : {})),
+    Config.node.replace(Config.configured({
+      project: options.config?.project,
+      file: options.config?.file,
+      content: options.config?.content
+    })),
+    InstructionDiscovery.node.replace(InstructionDiscovery.configured({ project: options.config?.project })),
+    ShellSelect.node.replace(ShellSelect.configured({ gitbash: options.windows?.gitbash })),
+    Mcp.node.replace(Mcp.configured({
+      clientInfo: {
+        name: options.app?.name ?? "opencode",
+        version: options.app?.version ?? "unknown"
+      }
+    }))
+  ];
+  const build = (overrides) => {
+    const replacements = [
+      ...standard,
+      ...instances ? [Instance.node.replace(instances(() => replacements))] : [],
+      ...overrides
+    ];
+    return AppNodeBuilder.build(applicationServices, replacements);
+  };
+  const serviceLayer = options.simulation ? Layer.unwrap(Effect.gen(function* () {
+    const { simulationReplacements } = yield* Effect.promise(() => import("@opencode/simulation/backend"));
+    const simulation = yield* simulationReplacements({ version: App.make(options.app).version });
+    return build([...overrides, ...simulation]);
+  })) : build(overrides);
+  return serviceLayer.pipe(Layer.flatMap((context) => {
+    const services = Layer.succeedContext(context);
+    const requestServices = Layer.merge(Layer.succeedContext(Context.pick(Database.Service, Credential.Service, PermissionSaved.Service, PluginUpdate.Service, Project.Service, WellKnown.Service)(context)), layer3(serviceURLs, Context.get(context, Global.Service).tmp, options.app));
+    const api = HttpApiBuilder.layer(Api2, { openapiPath: "/openapi.json" }).pipe(Layer.provide(handlers2.pipe(Layer.provide(services), Layer.provide(Layer.succeed(CorsConfig2, options)))), Layer.provide(formLocationLayer2), Layer.provide(sessionLocationLayer2), Layer.provide(layer4), Layer.provide(authorizationLayer2), Layer.provide(schemaErrorLayer2), Layer.provide(auth), HttpRouter.provideRequest(requestServices), Layer.provideMerge(services), Layer.provideMerge(HttpRouter.layer));
+    return Layer.merge(api, V1Migration.layer.pipe(Layer.provide(services)));
+  }));
+}
+
+export { createRoutes2, createEmbeddedRoutes2 };

package/dist/chunks/workerd-75c938bc.js

@@ -0,0 +1,23 @@
+import {
+  __export
+} from "./workerd-9rqn6x4v.js";
+
+// src/pty-environment.ts
+var exports_pty_environment = {};
+__export(exports_pty_environment, {
+  PtyEnvironment: () => exports_pty_environment,
+  Service: () => Service4,
+  layer: () => layer5,
+  node: () => node2
+});
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+
+class Service4 extends Context.Service()("@opencode/ServerPtyEnvironment") {
+}
+var layer5 = Layer.succeed(Service4, Service4.of({
+  get: () => Effect.succeed({})
+}));
+var node2 = makeGlobalNode({ service: Service4, layer: layer5, deps: [] });
+
+export { Service4, layer5, node2, exports_pty_environment };

package/dist/chunks/workerd-7cfyat0f.js

@@ -0,0 +1,37 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+import {
+  Service2,
+  frame2
+} from "./workerd-2sy3c7de.js";
+
+// src/handlers/event.ts
+import { Event } from "@opencode/schema/event";
+import { Effect, Stream } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var EventHandler2 = HttpApiBuilder.group(Api2, "server.event", (handlers) => Effect.gen(function* () {
+  const feed = yield* Service2;
+  return handlers.handleRaw("event.subscribe", () => Effect.gen(function* () {
+    const connected = {
+      id: Event.ID.create(),
+      type: "server.connected",
+      data: {}
+    };
+    const output = Stream.unwrap(feed.subscribe.pipe(Effect.map((live) => Stream.make(frame2(connected)).pipe(Stream.concat(live)))));
+    const heartbeat = Stream.tick("15 seconds").pipe(Stream.map(() => `: heartbeat
+
+`));
+    return HttpServerResponse.stream(output.pipe(Stream.merge(heartbeat, { haltStrategy: "left" }), Stream.encodeText), {
+      contentType: "text/event-stream",
+      headers: {
+        "Cache-Control": "no-cache, no-transform",
+        "X-Accel-Buffering": "no",
+        "X-Content-Type-Options": "nosniff"
+      }
+    });
+  }));
+}));
+
+export { EventHandler2 };

package/dist/chunks/workerd-7rzt3wm8.js

@@ -0,0 +1,13 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/migration.ts
+import { V1Migration } from "@opencode/core/database/v1-migration";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Effect } from "effect";
+var MigrationHandler2 = HttpApiBuilder.group(Api2, "server.migration", (handlers) => handlers.handle("migration.v1.status", Effect.fn(function* () {
+  return yield* V1Migration.status();
+})));
+
+export { MigrationHandler2 };

package/dist/chunks/workerd-8bajbwjh.js

@@ -0,0 +1,40 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/mcp.ts
+import { Mcp } from "@opencode/core/mcp/index";
+import { McpServerNotFoundError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+var notFound = (effect) => effect.pipe(Effect.mapError((error) => new McpServerNotFoundError({ server: error.server, message: error.message })));
+var McpHandler2 = HttpApiBuilder.group(Api2, "server.mcp", (handlers) => Effect.gen(function* () {
+  return handlers.handle("mcp.list", Effect.fn(function* () {
+    const service = yield* Mcp.Service;
+    return yield* response2(service.servers().pipe(Effect.map((servers) => servers.map((info) => ({ name: info.name, status: info.status, integrationID: info.integrationID })))));
+  })).handle("mcp.add", Effect.fn(function* (ctx) {
+    const service = yield* Mcp.Service;
+    yield* service.add(ctx.params.server, ctx.payload.config);
+    return HttpApiSchema.NoContent.make();
+  })).handle("mcp.remove", Effect.fn(function* (ctx) {
+    const service = yield* Mcp.Service;
+    yield* notFound(service.remove(ctx.params.server));
+    return HttpApiSchema.NoContent.make();
+  })).handle("mcp.connect", Effect.fn(function* (ctx) {
+    const service = yield* Mcp.Service;
+    yield* notFound(service.connect(ctx.params.server));
+    return HttpApiSchema.NoContent.make();
+  })).handle("mcp.disconnect", Effect.fn(function* (ctx) {
+    const service = yield* Mcp.Service;
+    yield* notFound(service.disconnect(ctx.params.server));
+    return HttpApiSchema.NoContent.make();
+  })).handle("mcp.resource.catalog", Effect.fn(function* () {
+    const service = yield* Mcp.Service;
+    return yield* response2(service.resourceCatalog());
+  }));
+}));
+
+export { McpHandler2 };

package/dist/chunks/workerd-9rqn6x4v.js

@@ -0,0 +1,16 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+export { __export };