@opencode/server 0.0.0-beta-19275

package/dist/handlers/mcp.js

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

package/dist/handlers/message.js

@@ -0,0 +1,42 @@
+import { SessionMessage } from "@opencode/core/session/message";
+import { Session } from "@opencode/core/session";
+import { Effect, Schema } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { InvalidCursorError } from "@opencode/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/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/database/database").Service>>;

package/dist/handlers/migration.js

@@ -0,0 +1,7 @@
+import { V1Migration } from "@opencode/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/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/model.js

@@ -0,0 +1,14 @@
+import { Catalog } from "@opencode/core/catalog";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+export const ModelHandler = HttpApiBuilder.group(Api, "server.model", (handlers) => Effect.gen(function* () {
+  return handlers.handle("model.list", Effect.fn(function* () {
+    const catalog = yield* Catalog.Service;
+    return yield* response(catalog.model.available());
+  })).handle("model.default", Effect.fn(function* () {
+    const catalog = yield* Catalog.Service;
+    return yield* response(catalog.model.default());
+  }));
+}));

package/dist/handlers/permission.d.ts

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

package/dist/handlers/permission.js

@@ -0,0 +1,57 @@
+import { Instance } from "@opencode/core/instance/service";
+import { Location } from "@opencode/core/location";
+import { Permission } from "@opencode/core/permission";
+import { PermissionSaved } from "@opencode/core/permission/saved";
+import { Session } from "@opencode/core/session";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { PermissionNotFoundError } from "@opencode/protocol/errors";
+import { response, sessionInfo } from "../location";
+import { missingSession } from "./session-error";
+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 instances = yield* Instance.Service, sessions = yield* Session.Service, 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", missingSession))
+    };
+  })).handle("session.permission.list", Effect.fn(function* (ctx) {
+    const session = yield* sessionInfo(sessions, ctx.params.sessionID);
+    return { data: yield* Permission.Service.use((permission) => permission.forSession(ctx.params.sessionID)).pipe(instances.provide(session)) };
+  })).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/persistent-pty.d.ts

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

package/dist/handlers/persistent-pty.js

@@ -0,0 +1,136 @@
+import { PersistentPty } from "@opencode/core/persistent-pty";
+import { PtyTicket } from "@opencode/core/pty/ticket";
+import { ForbiddenError, PtyNotFoundError, ServiceUnavailableError } from "@opencode/protocol/errors";
+import {
+  PTY_CONNECT_TICKET_QUERY,
+  PTY_CONNECT_TOKEN_HEADER,
+  PTY_CONNECT_TOKEN_HEADER_VALUE
+} from "@opencode/protocol/groups/persistent-pty";
+import { Effect, Queue, Semaphore } 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 { runPtySocket } from "./pty-socket";
+export const PersistentPtyHandler = HttpApiBuilder.group(Api, "server.experimental", (handlers) => Effect.gen(function* () {
+  const tickets = yield* PtyTicket.Service, cors = yield* CorsConfig, pty = yield* PersistentPty.Service;
+  return handlers.handle("persistentPty.read", Effect.fn(function* (ctx) {
+    return { data: yield* pty.read(ctx.params.sessionID, ctx.query.lines).pipe(mapUnavailable) };
+  })).handle("persistentPty.list", Effect.fn(function* (ctx) {
+    return { data: yield* pty.list(ctx.params.sessionID).pipe(mapUnavailable) };
+  })).handle("persistentPty.create", Effect.fn(function* (ctx) {
+    return {
+      data: yield* pty.create(ctx.params.sessionID, {
+        command: ctx.payload.command,
+        args: ctx.payload.args,
+        cwd: ctx.payload.cwd,
+        title: ctx.payload.title,
+        env: ctx.payload.env,
+        cols: ctx.payload.size?.cols,
+        rows: ctx.payload.size?.rows
+      }).pipe(Effect.catchTag("PersistentPty.UnavailableError", unavailable))
+    };
+  })).handle("persistentPty.shutdown", Effect.fn(function* () {
+    yield* pty.shutdown().pipe(mapUnavailable);
+    return HttpApiSchema.NoContent.make();
+  })).handle("persistentPty.handoff", Effect.fn(function* () {
+    return { handoff: yield* pty.handoff().pipe(mapUnavailable) };
+  })).handle("persistentPty.get", Effect.fn(function* (ctx) {
+    return { data: yield* pty.get(ctx.params.ptyID).pipe(mapTerminalError) };
+  })).handle("persistentPty.update", Effect.fn(function* (ctx) {
+    yield* pty.resize(ctx.params.ptyID, ctx.payload.size.cols, ctx.payload.size.rows, ctx.payload.attachmentID).pipe(mapTerminalError);
+    return { data: yield* pty.get(ctx.params.ptyID).pipe(mapTerminalError) };
+  })).handle("persistentPty.snapshot", Effect.fn(function* (ctx) {
+    return { data: yield* pty.snapshot(ctx.params.ptyID).pipe(mapTerminalError) };
+  })).handle("persistentPty.remove", Effect.fn(function* (ctx) {
+    yield* pty.remove(ctx.params.ptyID).pipe(mapTerminalError);
+    return HttpApiSchema.NoContent.make();
+  })).handle("persistentPty.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 persistent PTY connect token request" });
+    yield* pty.get(ctx.params.ptyID).pipe(mapTerminalError);
+    return { data: yield* tickets.issue({ ptyID: ctx.params.ptyID }) };
+  })).handleRaw("persistentPty.connect", Effect.fn("PersistentPtyHandler.connect")(function* (ctx) {
+    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 }) : !1))
+        return HttpServerResponse.empty({ status: 403 });
+    }
+    const cursor = Number(url.searchParams.get("cursor") ?? "0"), role = url.searchParams.get("role") === "observer" ? "observer" : "controller", framedInput = url.searchParams.get("input_protocol") === "1", attachmentID = url.searchParams.get("attachment_id") ?? crypto.randomUUID();
+    if (!Number.isSafeInteger(cursor) || cursor < 0)
+      return HttpServerResponse.empty({ status: 400 });
+    const socket = yield* Effect.orDie(ctx.request.upgrade), write = yield* socket.writer, outbox = yield* Queue.unbounded(), input = yield* Semaphore.make(1);
+    let attachment;
+    const onOpen = Effect.gen(function* () {
+      attachment = yield* pty.attach(ctx.params.ptyID, {
+        cursor,
+        attachmentID,
+        role,
+        takeover: url.searchParams.get("takeover") === "true",
+        onEvent: (event) => {
+          if (event.type === "output")
+            Queue.offerUnsafe(outbox, event.data);
+          if (event.type === "resized")
+            Queue.offerUnsafe(outbox, JSON.stringify({ ...event, checkpoint: Buffer.from(event.checkpoint).toString("base64") }));
+          if (event.type !== "output" && event.type !== "resized")
+            Queue.offerUnsafe(outbox, JSON.stringify(event));
+        },
+        onEnd: () => Queue.offerUnsafe(outbox, new Socket.CloseEvent(1000))
+      }).pipe(Effect.catchTags({
+        "PersistentPty.NotFoundError": () => Effect.succeed(void 0),
+        "PersistentPty.UnavailableError": () => Effect.succeed(void 0)
+      }));
+      if (!attachment) {
+        Queue.offerUnsafe(outbox, new Socket.CloseEvent(4404, "terminal unavailable"));
+        return;
+      }
+      Queue.offerUnsafe(outbox, JSON.stringify({
+        type: "attached",
+        attachmentID,
+        inputProtocol: framedInput ? 1 : 0,
+        info: attachment.info,
+        role: attachment.role,
+        generation: attachment.generation,
+        replay: {
+          requestedOffset: attachment.replay.requestedOffset,
+          availableOffset: attachment.replay.availableOffset,
+          endOffset: attachment.replay.endOffset,
+          truncated: attachment.replay.truncated
+        }
+      }));
+      if (attachment.replay.data.length > 0)
+        Queue.offerUnsafe(outbox, attachment.replay.data);
+      Queue.offerUnsafe(outbox, JSON.stringify({ type: "replay_complete", endOffset: attachment.replay.endOffset }));
+      attachment.activate();
+    }), drain = Effect.gen(function* () {
+      while (!0) {
+        const item = yield* Queue.take(outbox);
+        yield* write(item);
+        if (item instanceof Socket.CloseEvent)
+          return;
+      }
+    });
+    yield* runPtySocket(drain, socket.runRaw((message) => input.withPermit(Effect.suspend(() => {
+      if (!attachment)
+        return Effect.void;
+      const data = typeof message === "string" ? Buffer.from(message) : message;
+      if (!framedInput)
+        return pty.input(ctx.params.ptyID, attachmentID, attachment.info.size.cols, attachment.info.size.rows, data).pipe(Effect.ignore);
+      if (data.byteLength < 5)
+        return Effect.void;
+      const view = new DataView(data.buffer, data.byteOffset, data.byteLength), type = data[0], cols = view.getUint16(1), rows = view.getUint16(3);
+      if (type !== 0 && type !== 1 || cols === 0 || rows === 0)
+        return Effect.void;
+      if (type === 0)
+        return pty.control(ctx.params.ptyID, attachmentID, cols, rows).pipe(Effect.ignore);
+      return pty.input(ctx.params.ptyID, attachmentID, cols, rows, data.subarray(5)).pipe(Effect.ignore);
+    })), { onOpen }), () => attachment?.detach()).pipe(Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void), Effect.orDie);
+    return HttpServerResponse.empty();
+  }));
+}));
+const mapUnavailable = (effect) => effect.pipe(Effect.catchTag("PersistentPty.UnavailableError", unavailable)), mapTerminalError = (effect) => effect.pipe(Effect.catchTags({
+  "PersistentPty.NotFoundError": (error) => new PtyNotFoundError({ ptyID: error.ptyID, message: `PTY session not found: ${error.ptyID}` }),
+  "PersistentPty.UnavailableError": unavailable
+})), unavailable = (error) => new ServiceUnavailableError({ message: error.message, service: "opencode-pty" });

package/dist/handlers/plugin.d.ts

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

package/dist/handlers/plugin.js

@@ -0,0 +1,51 @@
+import { Plugin } from "@opencode/core/plugin";
+import { PluginUpdate } from "@opencode/core/plugin/update";
+import { InvalidRequestError, ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Cause, Effect, Exit } 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()));
+})).handle("plugin.awaitActivation", () => Plugin.awaitActivation).handle("plugin.check", (ctx) => Effect.gen(function* () {
+  const plugins = yield* Plugin.Service;
+  yield* plugins.awaitActivation;
+  const inventory = yield* plugins.list(), targets = [
+    ...new Set(inventory.flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : []))
+  ].filter((target) => ctx.payload.target === void 0 || target === ctx.payload.target);
+  if (ctx.payload.target !== void 0 && !targets.length)
+    return yield* new InvalidRequestError({
+      message: `Plugin package is not in the current server inventory: ${ctx.payload.target}`,
+      field: "target"
+    });
+  const updates = yield* PluginUpdate.Service, outdated = new Map(yield* Effect.forEach(targets, (target) => updates.check(target, { refresh: !0 }).pipe(Effect.map((value) => [target, value])), { concurrency: "unbounded" }));
+  return yield* response(Effect.succeed(inventory.map((plugin) => {
+    if (plugin.source.type !== "package" || !outdated.has(plugin.source.target))
+      return plugin;
+    return {
+      ...plugin,
+      source: {
+        type: "package",
+        target: plugin.source.target,
+        ...plugin.source.version ? { version: plugin.source.version } : {},
+        ...outdated.get(plugin.source.target) ? { outdated: !0 } : {},
+        ...plugin.source.updating ? { updating: !0 } : {}
+      }
+    };
+  })));
+})).handle("plugin.update", (ctx) => Effect.gen(function* () {
+  const plugins = yield* Plugin.Service;
+  yield* plugins.awaitActivation;
+  const inventory = new Set((yield* plugins.list()).flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : [])), unknown = ctx.payload.targets.filter((target) => !inventory.has(target));
+  if (unknown.length)
+    return yield* new InvalidRequestError({
+      message: `Plugin packages are not in the current server inventory: ${unknown.join(", ")}`,
+      field: "targets"
+    });
+  const updates = yield* PluginUpdate.Service, failures = yield* Effect.forEach(ctx.payload.targets, (target) => updates.update(target).pipe(Effect.exit, Effect.map((exit) => Exit.isFailure(exit) ? [`${target}: ${Cause.pretty(exit.cause)}`] : [])), { concurrency: "unbounded" }).pipe(Effect.map((results) => results.flat()));
+  if (failures.length)
+    return yield* new ServiceUnavailableError({
+      message: `Failed to update plugin packages: ${failures.join("; ")}`,
+      service: "plugin"
+    });
+})));

package/dist/handlers/project.d.ts

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

package/dist/handlers/project.js

@@ -0,0 +1,14 @@
+import { Location } from "@opencode/core/location";
+import { Project } from "@opencode/core/project";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { ProjectNotFoundError } from "@opencode/protocol/errors";
+export const ProjectHandler = HttpApiBuilder.group(Api, "server.project", (handlers) => handlers.handle("project.list", () => Project.Service.use((project) => project.list())).handle("project.update", (ctx) => Project.Service.use((project) => project.update({ ...ctx.payload, projectID: ctx.params.projectID }).pipe(Effect.mapError(() => new ProjectNotFoundError({
+  projectID: ctx.params.projectID,
+  message: `Project not found: ${ctx.params.projectID}`
+}))))).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/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/provider.js

@@ -0,0 +1,20 @@
+import { Catalog } from "@opencode/core/catalog";
+import { ProviderNotFoundError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+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-socket.d.ts

@@ -0,0 +1,2 @@
+import { Effect } from "effect";
+export declare function runPtySocket<A, E, R, A2, E2, R2>(drain: Effect.Effect<A, E, R>, socket: Effect.Effect<A2, E2, R2>, detach: () => void): Effect.Effect<A | A2, E | E2, R | R2>;

package/dist/handlers/pty-socket.js

@@ -0,0 +1,4 @@
+import { Effect } from "effect";
+export function runPtySocket(drain, socket, detach) {
+  return Effect.raceFirst(drain, socket).pipe(Effect.ensuring(Effect.sync(detach)));
+}

package/dist/handlers/pty.d.ts

@@ -0,0 +1,3 @@
+import { PtyTicket } from "@opencode/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/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware)>;

package/dist/handlers/pty.js

@@ -0,0 +1,108 @@
+import { Pty } from "@opencode/core/pty";
+import { PtyProtocol } from "@opencode/core/pty/protocol";
+import { PtyTicket } from "@opencode/core/pty/ticket";
+import { Location } from "@opencode/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/protocol/errors";
+import {
+  PTY_CONNECT_TICKET_QUERY,
+  PTY_CONNECT_TOKEN_HEADER,
+  PTY_CONNECT_TOKEN_HEADER_VALUE
+} from "@opencode/protocol/groups/pty";
+import { response } from "../location";
+import { PtyEnvironment } from "../pty-environment";
+import { runPtySocket } from "./pty-socket";
+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) {
+    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* runPtySocket(drain, socket.runRaw((message) => {
+      const decoded = PtyProtocol.decodeInput(message);
+      if (decoded !== void 0)
+        attachment.write(decoded);
+    }), attachment.detach).pipe(Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void), 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/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/reference.js

@@ -0,0 +1,5 @@
+import { Reference } from "@opencode/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/rpc.d.ts

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

package/dist/handlers/rpc.js

@@ -0,0 +1,15 @@
+import { Rpc } from "@opencode/core/rpc";
+import { Plugin } from "@opencode/core/plugin";
+import { RpcError, RpcInternalError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+export const RpcHandler = HttpApiBuilder.group(Api, "server.rpc", (handlers) => handlers.handle("rpc.call", ({ params, payload }) => Effect.gen(function* () {
+  yield* Plugin.awaitActivation;
+  const output = yield* (yield* Rpc.Service).call(params.rpcID, params.method, payload.input);
+  return output === void 0 ? {} : { output };
+}).pipe(Effect.mapError((error) => error.type === "rpc.invalid_output" || error.type === "rpc.internal" ? new RpcInternalError({ type: error.type, message: error.message }) : new RpcError({
+  type: error.type,
+  message: error.message,
+  ...error.data === void 0 ? {} : { data: error.data }
+})), Effect.catchDefect((defect) => Effect.logError("rpc call failed", { rpc: params.rpcID, method: params.method, defect }).pipe(Effect.andThen(Effect.fail(new RpcInternalError({ type: "rpc.internal", message: "RPC call failed" }))))))));

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/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/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/core/session";
+import { SessionNotFoundError, UnknownError } from "@opencode/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/core/session";
+import { SessionNotFoundError, UnknownError } from "@opencode/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/core/session";
+import { SessionTransfer } from "@opencode/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("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/database/database").Service> | (import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization)>;