@opencode/server 2.0.8 → 2.0.10

package/dist/handlers/integration.js

@@ -1,143 +1,11 @@
-import { Integration } from "@opencode/core/integration";
-import { Plugin } from "@opencode/core/plugin";
-import { Effect } from "effect";
-import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
-import { Api } from "../api";
 import {
-  IntegrationAttemptNotFoundError,
-  IntegrationMethodNotFoundError,
-  IntegrationNotFoundError,
-  InvalidRequestError
-} from "@opencode/protocol/errors";
-import { response } from "../location";
-import { WellKnown } from "@opencode/core/wellknown";
-const authorize = (effect) => effect.pipe(Effect.mapError((error) => new InvalidRequestError({
-  message: error.cause instanceof Error && error.cause.message.trim() ? error.cause.message : "Authentication failed",
-  kind: "integration_authorization"
-})));
-export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration", (handlers) => Effect.gen(function* () {
-  return handlers.handle("integration.list", Effect.fn(function* () {
-    yield* Plugin.awaitActivation;
-    const service = yield* Integration.Service;
-    return yield* response(service.list());
-  })).handle("integration.get", Effect.fn(function* (ctx) {
-    const integration = yield* (yield* Integration.Service).get(ctx.params.integrationID);
-    if (!integration)
-      return yield* new IntegrationNotFoundError({
-        integrationID: ctx.params.integrationID,
-        message: `Integration not found: ${ctx.params.integrationID}`
-      });
-    return yield* response(Effect.succeed(integration));
-  })).handle("integration.wellknown.add", Effect.fn(function* (ctx) {
-    const wellknown = yield* WellKnown.Service, integration = yield* Integration.Service;
-    yield* wellknown.add(ctx.payload.url).pipe(Effect.mapError((error) => new InvalidRequestError({ message: error.message, kind: "well_known_discovery" })));
-    yield* integration.reload();
-    return HttpApiSchema.NoContent.make();
-  })).handle("integration.connect.key", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service;
-    if (!(yield* service.get(ctx.params.integrationID)))
-      return yield* new IntegrationNotFoundError({
-        integrationID: ctx.params.integrationID,
-        message: `Integration not found: ${ctx.params.integrationID}`
-      });
-    yield* authorize(service.connection.key({
-      integrationID: ctx.params.integrationID,
-      key: ctx.payload.key,
-      answer: ctx.payload.answer,
-      label: ctx.payload.label
-    }));
-    return HttpApiSchema.NoContent.make();
-  })).handle("integration.oauth.connect", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service;
-    return yield* response(authorize(service.oauth.connect({
-      integrationID: ctx.params.integrationID,
-      methodID: ctx.payload.methodID,
-      answer: ctx.payload.answer,
-      label: ctx.payload.label
-    })));
-  })).handle("integration.oauth.status", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service;
-    if (!(yield* service.get(ctx.params.integrationID)))
-      return yield* new IntegrationNotFoundError({
-        integrationID: ctx.params.integrationID,
-        message: `Integration not found: ${ctx.params.integrationID}`
-      });
-    return yield* response(service.oauth.status({
-      integrationID: ctx.params.integrationID,
-      attemptID: ctx.params.attemptID
-    }).pipe(Effect.mapError((error) => new IntegrationAttemptNotFoundError({
-      integrationID: error.integrationID,
-      attemptID: error.attemptID,
-      message: `OAuth attempt not found: ${error.attemptID}`
-    }))));
-  })).handle("integration.oauth.complete", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service;
-    if (!(yield* service.get(ctx.params.integrationID)))
-      return yield* new IntegrationNotFoundError({
-        integrationID: ctx.params.integrationID,
-        message: `Integration not found: ${ctx.params.integrationID}`
-      });
-    yield* service.oauth.complete({
-      integrationID: ctx.params.integrationID,
-      attemptID: ctx.params.attemptID,
-      code: ctx.payload.code
-    }).pipe(Effect.mapError((error) => {
-      if (error._tag === "Integration.AttemptNotFound")
-        return new IntegrationAttemptNotFoundError({
-          integrationID: error.integrationID,
-          attemptID: error.attemptID,
-          message: `OAuth attempt not found: ${error.attemptID}`
-        });
-      return new InvalidRequestError({
-        message: error._tag === "Integration.CodeRequired" ? "Authorization code is required" : "Authentication failed",
-        kind: error._tag === "Integration.CodeRequired" ? "integration_code_required" : "integration_authorization"
-      });
-    }));
-    return HttpApiSchema.NoContent.make();
-  })).handle("integration.oauth.cancel", Effect.fn(function* (ctx) {
-    yield* (yield* Integration.Service).oauth.cancel({
-      integrationID: ctx.params.integrationID,
-      attemptID: ctx.params.attemptID
-    });
-    return HttpApiSchema.NoContent.make();
-  })).handle("integration.command.connect", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service, integration = yield* service.get(ctx.params.integrationID);
-    if (!integration)
-      return yield* new IntegrationNotFoundError({
-        integrationID: ctx.params.integrationID,
-        message: `Integration not found: ${ctx.params.integrationID}`
-      });
-    if (!integration.methods.some((method) => method.type === "command" && method.id === ctx.payload.methodID))
-      return yield* new IntegrationMethodNotFoundError({
-        integrationID: ctx.params.integrationID,
-        methodID: ctx.payload.methodID,
-        message: `Integration method not found: ${ctx.payload.methodID}`
-      });
-    return yield* response(authorize(service.command.connect({
-      integrationID: ctx.params.integrationID,
-      methodID: ctx.payload.methodID,
-      label: ctx.payload.label
-    })));
-  })).handle("integration.command.status", Effect.fn(function* (ctx) {
-    const service = yield* Integration.Service;
-    if (!(yield* service.get(ctx.params.integrationID)))
-      return yield* new IntegrationNotFoundError({
-        integrationID: ctx.params.integrationID,
-        message: `Integration not found: ${ctx.params.integrationID}`
-      });
-    return yield* response(service.command.status({
-      integrationID: ctx.params.integrationID,
-      attemptID: ctx.params.attemptID
-    }).pipe(Effect.mapError((error) => new IntegrationAttemptNotFoundError({
-      integrationID: error.integrationID,
-      attemptID: error.attemptID,
-      message: `Command attempt not found: ${error.attemptID}`
-    }))));
-  })).handle("integration.command.cancel", Effect.fn(function* (ctx) {
-    yield* (yield* Integration.Service).command.cancel({
-      integrationID: ctx.params.integrationID,
-      attemptID: ctx.params.attemptID
-    });
-    return HttpApiSchema.NoContent.make();
-  }));
-}));
+  IntegrationHandler2
+} from "../chunks/auth-erwrh284.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  IntegrationHandler2 as IntegrationHandler
+};

package/dist/handlers/location.js

@@ -1,16 +1,11 @@
-import { Location } from "@opencode/core/location";
-import { LocationServiceMap } from "@opencode/core/location-service-map";
-import { ServiceUnavailableError } from "@opencode/protocol/errors";
-import { Cause, Effect } from "effect";
-import { HttpApiBuilder } from "effect/unstable/httpapi";
-import { Api } from "../api";
-export const LocationHandler = HttpApiBuilder.group(Api, "server.location", (handlers) => Effect.gen(function* () {
-  const locations = yield* LocationServiceMap.Service;
-  return handlers.handle("location.get", Effect.fn(function* () {
-    const location = yield* Location.Service;
-    return new Location.Info({
-      directory: location.directory,
-      project: location.project
-    });
-  })).handle("location.reload", () => LocationServiceMap.reload().pipe(Effect.provideService(LocationServiceMap.Service, locations), Effect.catchCause((cause) => Cause.hasInterruptsOnly(cause) ? Effect.failCause(cause) : Effect.fail(new ServiceUnavailableError({ message: Cause.pretty(cause), service: "location" })))));
-}));
+import {
+  LocationHandler2
+} from "../chunks/auth-tk6nqkmh.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  LocationHandler2 as LocationHandler
+};

package/dist/handlers/mcp.js

@@ -1,31 +1,11 @@
-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());
-  }));
-}));
+import {
+  McpHandler2
+} from "../chunks/auth-8ygjd1s8.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  McpHandler2 as McpHandler
+};

package/dist/handlers/message.js

@@ -1,43 +1,11 @@
-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")));
-  }
+import {
+  MessageHandler2
+} from "../chunks/auth-40g8rvw4.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  MessageHandler2 as MessageHandler
 };
-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,
-      type: ctx.query.type,
-      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.js

@@ -1,7 +1,11 @@
-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();
-})));
+import {
+  MigrationHandler2
+} from "../chunks/auth-txhx6f1m.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  MigrationHandler2 as MigrationHandler
+};

package/dist/handlers/model.js

@@ -1,14 +1,11 @@
-import { Model } from "@opencode/core/model";
-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 models = yield* Model.Service;
-    return yield* response(models.available());
-  })).handle("model.default", Effect.fn(function* () {
-    const models = yield* Model.Service;
-    return yield* response(models.default());
-  }));
-}));
+import {
+  ModelHandler2
+} from "../chunks/auth-fyjxk8m3.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  ModelHandler2 as ModelHandler
+};

package/dist/handlers/permission.js

@@ -1,57 +1,11 @@
-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.decision, 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();
-  }));
-}));
+import {
+  PermissionHandler2
+} from "../chunks/auth-kv6ycdgm.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  PermissionHandler2 as PermissionHandler
+};

package/dist/handlers/persistent-pty.js

@@ -1,136 +1,13 @@
-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" });
+  PersistentPtyHandler2
+} from "../chunks/auth-0qzy9yxk.js";
+import"../chunks/auth-hezj1jdf.js";
+import"../chunks/auth-q4bn6dy8.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  PersistentPtyHandler2 as PersistentPtyHandler
+};

package/dist/handlers/plugin.js

@@ -1,47 +1,11 @@
-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.check", (ctx) => Effect.gen(function* () {
-  const inventory = yield* (yield* Plugin.Service).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, 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"
-    });
-})));
+import {
+  PluginHandler2
+} from "../chunks/auth-vgxn80m1.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  PluginHandler2 as PluginHandler
+};

package/dist/handlers/project.js

@@ -1,9 +1,11 @@
-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}`
-}))))));
+import {
+  ProjectHandler2
+} from "../chunks/auth-7qtja2kq.js";
+import"../chunks/auth-z6kg9h7e.js";
+import"../chunks/auth-23w8t84j.js";
+import"../chunks/auth-frv6gfy7.js";
+import"../chunks/auth-0ar9gf7q.js";
+import"../chunks/auth-smaf4a18.js";
+export {
+  ProjectHandler2 as ProjectHandler
+};