@opencode-ai/server 0.0.0-dev-17880

package/dist/handlers/mcp.js

@@ -0,0 +1,31 @@
+import { MCP } from "@opencode-ai/core/mcp/index";
+import { McpServerNotFoundError } from "@opencode-ai/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+const notFound = (effect) => effect.pipe(Effect.mapError((error) => new McpServerNotFoundError({ server: error.server, message: error.message })));
+export const McpHandler = HttpApiBuilder.group(Api, "server.mcp", (handlers) => Effect.gen(function* () {
+  return handlers.handle("mcp.list", Effect.fn(function* () {
+    const service = yield* MCP.Service;
+    return yield* response(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) {
+    yield* (yield* MCP.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* response(service.resourceCatalog());
+  }));
+}));

package/dist/handlers/message.d.ts

@@ -0,0 +1,2 @@
+import { Session } from "@opencode-ai/core/session";
+export declare const MessageHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.message">, never, Session.Service | (import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization)>;

package/dist/handlers/message.js

@@ -0,0 +1,42 @@
+import { SessionMessage } from "@opencode-ai/core/session/message";
+import { Session } from "@opencode-ai/core/session";
+import { Effect, Schema } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { InvalidCursorError } from "@opencode-ai/protocol/errors";
+import { failedMessageDecode, missingSession } from "./session-error";
+const DefaultMessagesLimit = 50, Cursor = Schema.Struct({
+  id: SessionMessage.ID,
+  order: Schema.Union([Schema.Literal("asc"), Schema.Literal("desc")]),
+  direction: Schema.Union([Schema.Literal("previous"), Schema.Literal("next")])
+}), decodeCursor = Schema.decodeUnknownSync(Cursor), cursor = {
+  encode(message, order, direction) {
+    return Buffer.from(JSON.stringify({ id: message.id, order, direction })).toString("base64url");
+  },
+  decode(input) {
+    return decodeCursor(JSON.parse(Buffer.from(input, "base64url").toString("utf8")));
+  }
+};
+export const MessageHandler = HttpApiBuilder.group(Api, "server.message", (handlers) => Effect.gen(function* () {
+  const session = yield* Session.Service;
+  return handlers.handle("session.messages", Effect.fn(function* (ctx) {
+    if (ctx.query.cursor && ctx.query.order !== void 0)
+      return yield* new InvalidCursorError({ message: "Cursor cannot be combined with order" });
+    const decoded = yield* Effect.try({
+      try: () => ctx.query.cursor ? cursor.decode(ctx.query.cursor) : void 0,
+      catch: () => new InvalidCursorError({ message: "Invalid cursor" })
+    }), order = decoded?.order ?? ctx.query.order ?? "desc", messages = yield* session.messages({
+      sessionID: ctx.params.sessionID,
+      limit: ctx.query.limit ?? DefaultMessagesLimit,
+      order,
+      cursor: decoded ? { id: decoded.id, direction: decoded.direction } : void 0
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession), Effect.catchTag("Session.MessageDecodeError", failedMessageDecode)), first = messages[0], last = messages.at(-1);
+    return {
+      data: messages,
+      cursor: {
+        previous: first ? cursor.encode(first, order, "previous") : void 0,
+        next: last ? cursor.encode(last, order, "next") : void 0
+      }
+    };
+  }));
+}));

package/dist/handlers/migration.d.ts

@@ -0,0 +1 @@
+export declare const MigrationHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.migration">, never, import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode-ai/core/database/database").Service>>;

package/dist/handlers/migration.js

@@ -0,0 +1,7 @@
+import { V1Migration } from "@opencode-ai/core/database/v1-migration";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Effect } from "effect";
+import { Api } from "../api";
+export const MigrationHandler = HttpApiBuilder.group(Api, "server.migration", (handlers) => handlers.handle("migration.v1.status", Effect.fn(function* () {
+  return yield* V1Migration.status();
+})));

package/dist/handlers/model.d.ts

@@ -0,0 +1 @@
+export declare const ModelHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.model">, never, import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/model.js

@@ -0,0 +1,22 @@
+import { Catalog } from "@opencode-ai/core/catalog";
+import { ServiceUnavailableError } from "@opencode-ai/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+import { pluginReadiness } from "./plugin-readiness";
+const flushPlugins = pluginReadiness(() => new ServiceUnavailableError({
+  message: "Model catalog initialization timed out",
+  service: "model.catalog"
+}));
+export const ModelHandler = HttpApiBuilder.group(Api, "server.model", (handlers) => Effect.gen(function* () {
+  return handlers.handle("model.list", Effect.fn(function* () {
+    yield* flushPlugins;
+    const catalog = yield* Catalog.Service;
+    return yield* response(catalog.model.available());
+  })).handle("model.default", Effect.fn(function* () {
+    yield* flushPlugins;
+    const catalog = yield* Catalog.Service;
+    return yield* response(catalog.model.default());
+  }));
+}));

package/dist/handlers/permission.d.ts

@@ -0,0 +1,2 @@
+import { PermissionSaved } from "@opencode-ai/core/permission/saved";
+export declare const PermissionHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.permission">, never, import("../middleware/session-location").SessionLocationMiddleware | (import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware | import("effect/unstable/http/HttpRouter").Request<"Requires", PermissionSaved.Service>)>;

package/dist/handlers/permission.js

@@ -0,0 +1,56 @@
+import { Location } from "@opencode-ai/core/location";
+import { Permission } from "@opencode-ai/core/permission";
+import { PermissionSaved } from "@opencode-ai/core/permission/saved";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { PermissionNotFoundError, SessionNotFoundError } from "@opencode-ai/protocol/errors";
+import { response } from "../location";
+function missingRequest(id) {
+  return new PermissionNotFoundError({ requestID: id, message: `Permission request not found: ${id}` });
+}
+export const PermissionHandler = HttpApiBuilder.group(Api, "server.permission", (handlers) => Effect.gen(function* () {
+  const requireOwnedRequest = Effect.fnUntraced(function* (sessionID, requestID) {
+    const permission = yield* Permission.Service, request = yield* permission.get(requestID);
+    if (!request || request.sessionID !== sessionID)
+      return yield* missingRequest(requestID);
+    return { permission, request };
+  });
+  return handlers.handle("permission.request.list", Effect.fn(function* () {
+    const permission = yield* Permission.Service;
+    return yield* response(permission.list());
+  })).handle("session.permission.create", Effect.fn(function* (ctx) {
+    return {
+      data: yield* (yield* Permission.Service).ask({
+        id: ctx.payload.id,
+        sessionID: ctx.params.sessionID,
+        action: ctx.payload.action,
+        resources: ctx.payload.resources,
+        save: ctx.payload.save,
+        metadata: ctx.payload.metadata,
+        source: ctx.payload.source,
+        agent: ctx.payload.agent
+      }).pipe(Effect.catchTag("Session.NotFoundError", (error) => new SessionNotFoundError({
+        sessionID: error.sessionID,
+        message: `Session not found: ${error.sessionID}`
+      })))
+    };
+  })).handle("session.permission.list", Effect.fn(function* (ctx) {
+    return { data: yield* (yield* Permission.Service).forSession(ctx.params.sessionID) };
+  })).handle("session.permission.get", Effect.fn(function* (ctx) {
+    return { data: (yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID)).request };
+  })).handle("session.permission.reply", Effect.fn(function* (ctx) {
+    yield* (yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID)).permission.reply({ requestID: ctx.params.requestID, reply: ctx.payload.reply, message: ctx.payload.message }).pipe(Effect.catchTag("Permission.NotFoundError", () => missingRequest(ctx.params.requestID)));
+    return HttpApiSchema.NoContent.make();
+  })).handle("permission.saved.list", Effect.fn(function* (ctx) {
+    const location = yield* Location.Service;
+    return {
+      data: yield* (yield* PermissionSaved.Service).list({
+        projectID: ctx.query.projectID ?? location.project.id
+      })
+    };
+  })).handle("permission.saved.remove", Effect.fn(function* (ctx) {
+    yield* (yield* PermissionSaved.Service).remove(ctx.params.id);
+    return HttpApiSchema.NoContent.make();
+  }));
+}));

package/dist/handlers/plugin-readiness.d.ts

@@ -0,0 +1,4 @@
+import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor";
+import { ServiceUnavailableError } from "@opencode-ai/protocol/errors";
+import { Effect } from "effect";
+export declare function pluginReadiness(error: () => ServiceUnavailableError): Effect.Effect<void, ServiceUnavailableError, PluginSupervisor.Service>;

package/dist/handlers/plugin-readiness.js

@@ -0,0 +1,9 @@
+import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor";
+import { ServiceUnavailableError } from "@opencode-ai/protocol/errors";
+import { Effect } from "effect";
+export function pluginReadiness(error) {
+  return PluginSupervisor.Service.pipe(Effect.flatMap((plugins) => plugins.flush), Effect.timeoutOrElse({
+    duration: "5 seconds",
+    orElse: () => Effect.fail(error())
+  }));
+}

package/dist/handlers/plugin.d.ts

@@ -0,0 +1 @@
+export declare const PluginHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.plugin">, never, import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/plugin.js

@@ -0,0 +1,8 @@
+import { Plugin } from "@opencode-ai/core/plugin";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+export const PluginHandler = HttpApiBuilder.group(Api, "server.plugin", (handlers) => handlers.handle("plugin.list", () => Effect.gen(function* () {
+  return yield* response(Plugin.Service.use((plugin) => plugin.list()));
+})));

package/dist/handlers/project.d.ts

@@ -0,0 +1,2 @@
+import { Project } from "@opencode-ai/core/project";
+export declare const ProjectHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.project">, never, import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware | import("effect/unstable/http/HttpRouter").Request<"Requires", Project.Service>>;

package/dist/handlers/project.js

@@ -0,0 +1,10 @@
+import { Location } from "@opencode-ai/core/location";
+import { Project } from "@opencode-ai/core/project";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+export const ProjectHandler = HttpApiBuilder.group(Api, "server.project", (handlers) => handlers.handle("project.list", () => Project.Service.use((project) => project.list())).handle("project.current", () => Location.Service.use((location) => Effect.succeed({
+  id: location.project.id,
+  directory: location.project.directory,
+  canonical: location.project.canonical
+}))));

package/dist/handlers/provider.d.ts

@@ -0,0 +1 @@
+export declare const ProviderHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.provider">, never, import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/provider.js

@@ -0,0 +1,20 @@
+import { Catalog } from "@opencode-ai/core/catalog";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { ProviderNotFoundError } from "@opencode-ai/protocol/errors";
+import { response } from "../location";
+export const ProviderHandler = HttpApiBuilder.group(Api, "server.provider", (handlers) => Effect.gen(function* () {
+  return handlers.handle("provider.list", Effect.fn(function* () {
+    const catalog = yield* Catalog.Service;
+    return yield* response(catalog.provider.available());
+  })).handle("provider.get", Effect.fn(function* (ctx) {
+    const provider = yield* (yield* Catalog.Service).provider.get(ctx.params.providerID);
+    if (!provider)
+      return yield* new ProviderNotFoundError({
+        providerID: ctx.params.providerID,
+        message: `Provider not found: ${ctx.params.providerID}`
+      });
+    return yield* response(Effect.succeed(provider));
+  }));
+}));

package/dist/handlers/pty.d.ts

@@ -0,0 +1,3 @@
+import { PtyTicket } from "@opencode-ai/core/pty/ticket";
+import { PtyEnvironment } from "../pty-environment";
+export declare const PtyHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.pty">, never, PtyTicket.Service | PtyEnvironment.Service | (import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware)>;

package/dist/handlers/pty.js

@@ -0,0 +1,109 @@
+import { Pty } from "@opencode-ai/core/pty";
+import { PtyProtocol } from "@opencode-ai/core/pty/protocol";
+import { PtyTicket } from "@opencode-ai/core/pty/ticket";
+import { PluginSupervisor } from "@opencode-ai/core/plugin/supervisor-service";
+import { Location } from "@opencode-ai/core/location";
+import { Effect, Queue } from "effect";
+import { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { Socket } from "effect/unstable/socket";
+import { Api } from "../api";
+import { CorsConfig, isAllowedRequestOrigin } from "../cors";
+import { ForbiddenError, PtyNotFoundError } from "@opencode-ai/protocol/errors";
+import {
+  PTY_CONNECT_TICKET_QUERY,
+  PTY_CONNECT_TOKEN_HEADER,
+  PTY_CONNECT_TOKEN_HEADER_VALUE
+} from "@opencode-ai/protocol/groups/pty";
+import { response } from "../location";
+import { PtyEnvironment } from "../pty-environment";
+const ticketScope = Effect.gen(function* () {
+  const location = yield* Location.Service;
+  return { directory: location.directory, workspaceID: location.workspaceID };
+});
+export const PtyHandler = HttpApiBuilder.group(Api, "server.pty", (handlers) => Effect.gen(function* () {
+  const tickets = yield* PtyTicket.Service, cors = yield* CorsConfig, environment = yield* PtyEnvironment.Service;
+  return handlers.handle("pty.list", Effect.fn(function* () {
+    const pty = yield* Pty.Service;
+    return yield* response(pty.list());
+  })).handle("pty.create", Effect.fn(function* (ctx) {
+    yield* (yield* PluginSupervisor.Service).flush;
+    const pty = yield* Pty.Service, location = yield* Location.Service, cwd = ctx.payload.cwd || location.directory;
+    return yield* response(pty.create({
+      ...ctx.payload,
+      args: ctx.payload.args ? [...ctx.payload.args] : void 0,
+      cwd,
+      env: {
+        ...ctx.payload.env,
+        ...yield* environment.get({ directory: location.directory, cwd })
+      }
+    }));
+  })).handle("pty.get", Effect.fn(function* (ctx) {
+    const pty = yield* Pty.Service;
+    return yield* response(pty.get(ctx.params.ptyID).pipe(Effect.catchTag("Pty.NotFoundError", () => new PtyNotFoundError({
+      ptyID: ctx.params.ptyID,
+      message: `PTY session not found: ${ctx.params.ptyID}`
+    }))));
+  })).handle("pty.update", Effect.fn(function* (ctx) {
+    const pty = yield* Pty.Service;
+    return yield* response(pty.update(ctx.params.ptyID, {
+      ...ctx.payload,
+      size: ctx.payload.size ? { ...ctx.payload.size } : void 0
+    }).pipe(Effect.catchTag("Pty.NotFoundError", () => new PtyNotFoundError({
+      ptyID: ctx.params.ptyID,
+      message: `PTY session not found: ${ctx.params.ptyID}`
+    }))));
+  })).handle("pty.remove", Effect.fn(function* (ctx) {
+    yield* (yield* Pty.Service).remove(ctx.params.ptyID).pipe(Effect.catchTag("Pty.NotFoundError", () => new PtyNotFoundError({
+      ptyID: ctx.params.ptyID,
+      message: `PTY session not found: ${ctx.params.ptyID}`
+    })));
+    return HttpApiSchema.NoContent.make();
+  })).handle("pty.connectToken", Effect.fn(function* (ctx) {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    if (request.headers[PTY_CONNECT_TOKEN_HEADER] !== PTY_CONNECT_TOKEN_HEADER_VALUE || !isAllowedRequestOrigin(request.headers.origin, request.headers.host, cors))
+      return yield* new ForbiddenError({ message: "Invalid PTY connect token request" });
+    yield* (yield* Pty.Service).get(ctx.params.ptyID).pipe(Effect.catchTag("Pty.NotFoundError", () => new PtyNotFoundError({
+      ptyID: ctx.params.ptyID,
+      message: `PTY session not found: ${ctx.params.ptyID}`
+    })));
+    return yield* response(tickets.issue({ ptyID: ctx.params.ptyID, ...yield* ticketScope }));
+  })).handleRaw("pty.connect", Effect.fn("PtyHandler.connect")(function* (ctx) {
+    const pty = yield* Pty.Service;
+    if (!(yield* pty.get(ctx.params.ptyID).pipe(Effect.as(!0), Effect.catchTag("Pty.NotFoundError", () => Effect.succeed(!1)))))
+      return HttpServerResponse.empty({ status: 404 });
+    const url = new URL(ctx.request.url, "http://localhost"), ticket = url.searchParams.get(PTY_CONNECT_TICKET_QUERY);
+    if (ticket) {
+      if (!(isAllowedRequestOrigin(ctx.request.headers.origin, ctx.request.headers.host, cors) ? yield* tickets.consume({ ticket, ptyID: ctx.params.ptyID, ...yield* ticketScope }) : !1))
+        return HttpServerResponse.empty({ status: 403 });
+    }
+    const parsedCursor = url.searchParams.get("cursor"), cursorNumber = parsedCursor === null ? void 0 : Number(parsedCursor), cursor = cursorNumber !== void 0 && Number.isSafeInteger(cursorNumber) && cursorNumber >= -1 ? cursorNumber : void 0, socket = yield* Effect.orDie(ctx.request.upgrade), write = yield* socket.writer, closeAccepted = (event) => socket.runRaw(() => Effect.void, { onOpen: write(event).pipe(Effect.catch(() => Effect.void)) }).pipe(Effect.timeout("1 second"), Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void), Effect.catch(() => Effect.void)), outbox = yield* Queue.unbounded(), attachment = yield* pty.attach(ctx.params.ptyID, {
+      cursor,
+      onData: (chunk) => Queue.offerUnsafe(outbox, chunk),
+      onEnd: () => Queue.offerUnsafe(outbox, new Socket.CloseEvent(1000))
+    }).pipe(Effect.catchTags({
+      "Pty.NotFoundError": () => closeAccepted(new Socket.CloseEvent(4404, "session not found")).pipe(Effect.as(void 0)),
+      "Pty.ExitedError": () => closeAccepted(new Socket.CloseEvent(4404, "session exited")).pipe(Effect.as(void 0))
+    }));
+    if (!attachment)
+      return HttpServerResponse.empty();
+    for (const chunk of PtyProtocol.chunks(attachment.replay))
+      Queue.offerUnsafe(outbox, chunk);
+    Queue.offerUnsafe(outbox, PtyProtocol.metaFrame(attachment.cursor));
+    attachment.activate();
+    const drain = Effect.gen(function* () {
+      while (!0) {
+        const item = yield* Queue.take(outbox);
+        yield* write(item);
+        if (item instanceof Socket.CloseEvent)
+          return;
+      }
+    });
+    yield* Effect.race(drain, socket.runRaw((message) => {
+      const decoded = PtyProtocol.decodeInput(message);
+      if (decoded !== void 0)
+        attachment.write(decoded);
+    })).pipe(Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void), Effect.ensuring(Effect.sync(() => attachment.detach())), Effect.orDie);
+    return HttpServerResponse.empty();
+  }));
+}));

package/dist/handlers/reference.d.ts

@@ -0,0 +1 @@
+export declare const ReferenceHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.reference">, never, import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/reference.js

@@ -0,0 +1,5 @@
+import { Reference } from "@opencode-ai/core/reference";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+export const ReferenceHandler = HttpApiBuilder.group(Api, "server.reference", (handlers) => handlers.handle("reference.list", () => response(Reference.Service.use((reference) => reference.list()))));

package/dist/handlers/server.d.ts

@@ -0,0 +1,2 @@
+import { ServerInfo } from "../server-info";
+export declare const ServerHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.server">, never, import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("effect/unstable/http/HttpRouter").Request<"Requires", ServerInfo.Service>>;

package/dist/handlers/server.js

@@ -0,0 +1,7 @@
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { ServerInfo } from "../server-info";
+export const ServerHandler = HttpApiBuilder.group(Api, "server.server", (handlers) => handlers.handle("server.get", () => Effect.gen(function* () {
+  return { urls: (yield* ServerInfo.Service).urls() };
+})));

package/dist/handlers/session-error.d.ts

@@ -0,0 +1,5 @@
+import { Session } from "@opencode-ai/core/session";
+import { SessionNotFoundError, UnknownError } from "@opencode-ai/protocol/errors";
+import { Effect } from "effect";
+export declare function missingSession(error: Session.NotFoundError): SessionNotFoundError;
+export declare function failedMessageDecode(error: Session.MessageDecodeError): Effect.Effect<never, UnknownError, never>;

package/dist/handlers/session-error.js

@@ -0,0 +1,13 @@
+import { Session } from "@opencode-ai/core/session";
+import { SessionNotFoundError, UnknownError } from "@opencode-ai/protocol/errors";
+import { Effect } from "effect";
+export function missingSession(error) {
+  return new SessionNotFoundError({
+    sessionID: error.sessionID,
+    message: `Session not found: ${error.sessionID}`
+  });
+}
+export function failedMessageDecode(error) {
+  const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+  return Effect.logError("failed to decode session message").pipe(Effect.annotateLogs({ ref, sessionID: error.sessionID, messageID: error.messageID }), Effect.andThen(Effect.fail(new UnknownError({ message: "Unexpected server error. Check server logs for details.", ref }))));
+}

package/dist/handlers/session.d.ts

@@ -0,0 +1,3 @@
+import { Session } from "@opencode-ai/core/session";
+import { SessionTransfer } from "@opencode-ai/core/session/transfer";
+export declare const SessionHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.session">, never, Session.Service | import("../middleware/session-location").SessionLocationMiddleware | SessionTransfer.Service | (import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization)>;