@opencode/server 0.0.0-dev-19795 → 0.0.0-dev-19812

package/dist/api.js

@@ -1,9 +1,10 @@
-import { makeDefaultApi } from "@opencode/protocol/api";
-import { LocationMiddleware } from "./location";
-import { FormLocationMiddleware } from "./middleware/form-location";
-import { SessionLocationMiddleware } from "./middleware/session-location";
-export const Api = makeDefaultApi({
-  locationMiddleware: LocationMiddleware,
-  formLocationMiddleware: FormLocationMiddleware,
-  sessionLocationMiddleware: SessionLocationMiddleware
-});
+import {
+  Api2
+} from "./chunks/process-ks9pc2xc.js";
+import"./chunks/process-kb9735wh.js";
+import"./chunks/process-27edjygf.js";
+import"./chunks/process-8j6eh3dh.js";
+import"./chunks/process-smaf4a18.js";
+export {
+  Api2 as Api
+};

package/dist/auth.js

@@ -1,17 +1,12 @@
-export * as ServerAuth from "./auth";
-import { Context, Layer, Option, Redacted } from "effect";
-
-export class Config extends Context.Service()("@opencode/ServerAuthConfig") {
-  static configLayer(input) {
-    return Layer.succeed(this, this.of({ ...input, username: "opencode" }));
-  }
-  static get layer() {
-    return this.configLayer({ password: Option.none() });
-  }
-}
-export function required(config) {
-  return Option.isSome(config.password) && config.password.value !== "";
-}
-export function authorized(credentials, config) {
-  return Option.isSome(config.password) && credentials.username === config.username && Redacted.value(credentials.password) === config.password.value;
-}
+import {
+  Config2,
+  required2,
+  authorized2,
+  exports_auth
+} from "./chunks/process-zyv89x5n.js";
+export {
+  Config2 as Config,
+  exports_auth as ServerAuth,
+  authorized2 as authorized,
+  required2 as required
+};

package/dist/chunks/process-172x6jgf.js

@@ -0,0 +1,139 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+import {
+  CorsConfig2,
+  isAllowedRequestOrigin2
+} from "./process-q4bn6dy8.js";
+import {
+  Service2
+} from "./process-t7k3q1ah.js";
+import {
+  runPtySocket2
+} from "./process-hezj1jdf.js";
+
+// src/handlers/pty.ts
+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 { 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";
+var ticketScope = Effect.gen(function* () {
+  const location = yield* Location.Service;
+  return { directory: location.directory, workspaceID: location.workspaceID };
+});
+var PtyHandler2 = HttpApiBuilder.group(Api2, "server.pty", (handlers) => Effect.gen(function* () {
+  const tickets = yield* PtyTicket.Service;
+  const cors = yield* CorsConfig2;
+  const environment = yield* Service2;
+  return handlers.handle("pty.list", Effect.fn(function* () {
+    const pty = yield* Pty.Service;
+    return yield* response2(pty.list());
+  })).handle("pty.create", Effect.fn(function* (ctx) {
+    const pty = yield* Pty.Service;
+    const location = yield* Location.Service;
+    const cwd = ctx.payload.cwd || location.directory;
+    return yield* response2(pty.create({
+      ...ctx.payload,
+      args: ctx.payload.args ? [...ctx.payload.args] : undefined,
+      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* response2(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* response2(pty.update(ctx.params.ptyID, {
+      ...ctx.payload,
+      size: ctx.payload.size ? { ...ctx.payload.size } : undefined
+    }).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) {
+    const pty = yield* Pty.Service;
+    yield* pty.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 || !isAllowedRequestOrigin2(request.headers.origin, request.headers.host, cors))
+      return yield* new ForbiddenError({ message: "Invalid PTY connect token request" });
+    const pty = yield* Pty.Service;
+    yield* pty.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* response2(tickets.issue({ ptyID: ctx.params.ptyID, ...yield* ticketScope }));
+  })).handleRaw("pty.connect", Effect.fn("PtyHandler.connect")(function* (ctx) {
+    const pty = yield* Pty.Service;
+    const exists = yield* pty.get(ctx.params.ptyID).pipe(Effect.as(true), Effect.catchTag("Pty.NotFoundError", () => Effect.succeed(false)));
+    if (!exists)
+      return HttpServerResponse.empty({ status: 404 });
+    const url = new URL(ctx.request.url, "http://localhost");
+    const ticket = url.searchParams.get(PTY_CONNECT_TICKET_QUERY);
+    if (ticket) {
+      const valid = isAllowedRequestOrigin2(ctx.request.headers.origin, ctx.request.headers.host, cors) ? yield* tickets.consume({ ticket, ptyID: ctx.params.ptyID, ...yield* ticketScope }) : false;
+      if (!valid)
+        return HttpServerResponse.empty({ status: 403 });
+    }
+    const parsedCursor = url.searchParams.get("cursor");
+    const cursorNumber = parsedCursor === null ? undefined : Number(parsedCursor);
+    const cursor = cursorNumber !== undefined && Number.isSafeInteger(cursorNumber) && cursorNumber >= -1 ? cursorNumber : undefined;
+    const socket = yield* Effect.orDie(ctx.request.upgrade);
+    const write = yield* socket.writer;
+    const 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));
+    const outbox = yield* Queue.unbounded();
+    const 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(undefined)),
+      "Pty.ExitedError": () => closeAccepted(new Socket.CloseEvent(4404, "session exited")).pipe(Effect.as(undefined))
+    }));
+    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 (true) {
+        const item = yield* Queue.take(outbox);
+        yield* write(item);
+        if (item instanceof Socket.CloseEvent)
+          return;
+      }
+    });
+    yield* runPtySocket2(drain, socket.runRaw((message) => {
+      const decoded = PtyProtocol.decodeInput(message);
+      if (decoded !== undefined)
+        attachment.write(decoded);
+    }), attachment.detach).pipe(Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void), Effect.orDie);
+    return HttpServerResponse.empty();
+  }));
+}));
+
+export { PtyHandler2 };

package/dist/chunks/process-18k6g42r.js

@@ -0,0 +1,36 @@
+import {
+  __export
+} from "./process-9rqn6x4v.js";
+
+// src/server-info.ts
+var exports_server_info = {};
+__export(exports_server_info, {
+  ServerInfo: () => exports_server_info,
+  Service: () => Service4,
+  connectionURLs: () => connectionURLs2,
+  layer: () => layer5
+});
+import { Context, Layer } from "effect";
+import { networkInterfaces } from "node:os";
+
+class Service4 extends Context.Service()("@opencode/server/ServerInfo") {
+}
+function layer5(urls, tmp, app = {}) {
+  return Layer.succeed(Service4, Service4.of({ urls, app, paths: { tmp } }));
+}
+function connectionURLs2(value, requestedHostname) {
+  const url = new URL(value);
+  const hostname = requestedHostname ?? url.hostname;
+  const family = hostname === "0.0.0.0" ? "IPv4" : hostname === "::" || hostname === "[::]" ? "IPv6" : undefined;
+  if (family === undefined)
+    return [value];
+  return [
+    ...new Set(Object.values(networkInterfaces()).flatMap((entries) => entries ?? []).filter((entry) => !entry.internal && entry.family === family).map((entry) => {
+      const result = new URL(value);
+      result.hostname = family === "IPv6" ? `[${entry.address}]` : entry.address;
+      return result.toString().replace(/\/$/, "");
+    }))
+  ];
+}
+
+export { Service4, layer5, connectionURLs2, exports_server_info };

package/dist/chunks/process-1crq7hen.js

@@ -0,0 +1,13 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/command.ts
+import { Command } from "@opencode/core/command";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var CommandHandler2 = HttpApiBuilder.group(Api2, "server.command", (handlers) => handlers.handle("command.list", () => response2(Command.Service.use((command) => command.list()))));
+
+export { CommandHandler2 };

package/dist/chunks/process-27edjygf.js

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

package/dist/chunks/process-3esm6t0a.js

@@ -0,0 +1,156 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/integration.ts
+import { Integration } from "@opencode/core/integration";
+import { Plugin } from "@opencode/core/plugin";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import {
+  IntegrationAttemptNotFoundError,
+  IntegrationMethodNotFoundError,
+  IntegrationNotFoundError,
+  InvalidRequestError
+} from "@opencode/protocol/errors";
+import { WellKnown } from "@opencode/core/wellknown";
+var 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"
+})));
+var IntegrationHandler2 = HttpApiBuilder.group(Api2, "server.integration", (handlers) => Effect.gen(function* () {
+  return handlers.handle("integration.list", Effect.fn(function* () {
+    yield* Plugin.awaitActivation;
+    const service = yield* Integration.Service;
+    return yield* response2(service.list());
+  })).handle("integration.get", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    const integration = yield* service.get(ctx.params.integrationID);
+    if (!integration)
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    return yield* response2(Effect.succeed(integration));
+  })).handle("integration.wellknown.add", Effect.fn(function* (ctx) {
+    const wellknown = yield* WellKnown.Service;
+    const 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* response2(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* response2(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) {
+    const service = yield* Integration.Service;
+    yield* 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;
+    const 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* response2(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* response2(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) {
+    const service = yield* Integration.Service;
+    yield* service.command.cancel({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID
+    });
+    return HttpApiSchema.NoContent.make();
+  }));
+}));
+
+export { IntegrationHandler2 };

package/dist/chunks/process-3ra48t04.js

@@ -0,0 +1,26 @@
+import {
+  isAllowedCorsOrigin2
+} from "./process-q4bn6dy8.js";
+import {
+  createRoutes2
+} from "./process-kgbwhj3q.js";
+import {
+  __export
+} from "./process-9rqn6x4v.js";
+
+// src/fetch.ts
+var exports_fetch = {};
+__export(exports_fetch, {
+  ServerFetch: () => exports_fetch,
+  make: () => make3
+});
+import { Context, Effect, Layer } from "effect";
+import { HttpEffect, HttpMiddleware, HttpRouter, HttpServer } from "effect/unstable/http";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+var make3 = Effect.fn("ServerFetch.make")(function* (options = {}, boot = {}) {
+  const context = yield* Layer.build(createRoutes2(options, () => [], boot.overrides ?? []).pipe(Layer.provide(HttpServer.layerServices)));
+  yield* Effect.forkDetach(Context.get(context, SessionRestart.Service).resumeSuspendedSessions);
+  return Context.get(context, HttpRouter.HttpRouter).asHttpEffect().pipe(HttpMiddleware.cors({ allowedOrigins: (origin) => isAllowedCorsOrigin2(origin, options), maxAge: 86400 }), HttpEffect.toWebHandlerWith(context));
+});
+
+export { make3, exports_fetch };

package/dist/chunks/process-8j6eh3dh.js

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

package/dist/chunks/process-910kejdj.js

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

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

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

package/dist/chunks/process-b0dj656z.js

@@ -0,0 +1,13 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/reference.ts
+import { Reference } from "@opencode/core/reference";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var ReferenceHandler2 = HttpApiBuilder.group(Api2, "server.reference", (handlers) => handlers.handle("reference.list", () => response2(Reference.Service.use((reference) => reference.list()))));
+
+export { ReferenceHandler2 };

package/dist/chunks/process-b4s3wxap.js

@@ -0,0 +1,23 @@
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/credential.ts
+import { Credential } from "@opencode/core/credential";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+var CredentialHandler2 = HttpApiBuilder.group(Api2, "server.credential", (handlers) => handlers.handle("credential.update", Effect.fn(function* (ctx) {
+  const credential = yield* Credential.Service;
+  yield* credential.update(ctx.params.credentialID, { label: ctx.payload.label });
+  return HttpApiSchema.NoContent.make();
+})).handle("credential.activate", Effect.fn(function* (ctx) {
+  const credential = yield* Credential.Service;
+  yield* credential.activate(ctx.params.credentialID);
+  return HttpApiSchema.NoContent.make();
+})).handle("credential.remove", Effect.fn(function* (ctx) {
+  const credential = yield* Credential.Service;
+  yield* credential.remove(ctx.params.credentialID);
+  return HttpApiSchema.NoContent.make();
+})));
+
+export { CredentialHandler2 };

package/dist/chunks/process-c23ng5tp.js

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