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

package/dist/chunks/workerd-n0er2m55.js

@@ -0,0 +1,163 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+import {
+  CorsConfig2,
+  isAllowedRequestOrigin2
+} from "./workerd-q4bn6dy8.js";
+import {
+  runPtySocket2
+} from "./workerd-hezj1jdf.js";
+
+// src/handlers/persistent-pty.ts
+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";
+var PersistentPtyHandler2 = HttpApiBuilder.group(Api2, "server.experimental", (handlers) => Effect.gen(function* () {
+  const tickets = yield* PtyTicket.Service;
+  const cors = yield* CorsConfig2;
+  const 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 || !isAllowedRequestOrigin2(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");
+    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 }) : false;
+      if (!valid)
+        return HttpServerResponse.empty({ status: 403 });
+    }
+    const cursor = Number(url.searchParams.get("cursor") ?? "0");
+    const role = url.searchParams.get("role") === "observer" ? "observer" : "controller";
+    const framedInput = url.searchParams.get("input_protocol") === "1";
+    const 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);
+    const write = yield* socket.writer;
+    const outbox = yield* Queue.unbounded();
+    const 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(undefined),
+        "PersistentPty.UnavailableError": () => Effect.succeed(undefined)
+      }));
+      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();
+    });
+    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) => 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);
+      const type = data[0];
+      const cols = view.getUint16(1);
+      const 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();
+  }));
+}));
+var mapUnavailable = (effect) => effect.pipe(Effect.catchTag("PersistentPty.UnavailableError", unavailable));
+var mapTerminalError = (effect) => effect.pipe(Effect.catchTags({
+  "PersistentPty.NotFoundError": (error) => new PtyNotFoundError({ ptyID: error.ptyID, message: `PTY session not found: ${error.ptyID}` }),
+  "PersistentPty.UnavailableError": unavailable
+}));
+var unavailable = (error) => new ServiceUnavailableError({ message: error.message, service: "opencode-pty" });
+
+export { PersistentPtyHandler2 };

package/dist/chunks/workerd-pnqq1zxv.js

@@ -0,0 +1,29 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/provider.ts
+import { Provider } from "@opencode/core/provider";
+import { ProviderNotFoundError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var ProviderHandler2 = HttpApiBuilder.group(Api2, "server.provider", (handlers) => Effect.gen(function* () {
+  return handlers.handle("provider.list", Effect.fn(function* () {
+    const providers = yield* Provider.Service;
+    return yield* response2(providers.available());
+  })).handle("provider.get", Effect.fn(function* (ctx) {
+    const providers = yield* Provider.Service;
+    const provider = yield* providers.get(ctx.params.providerID);
+    if (!provider)
+      return yield* new ProviderNotFoundError({
+        providerID: ctx.params.providerID,
+        message: `Provider not found: ${ctx.params.providerID}`
+      });
+    return yield* response2(Effect.succeed(provider));
+  }));
+}));
+
+export { ProviderHandler2 };

package/dist/chunks/workerd-q0ycym90.js

@@ -0,0 +1,13 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/skill.ts
+import { Skill } from "@opencode/core/skill";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var SkillHandler2 = HttpApiBuilder.group(Api2, "server.skill", (handlers) => handlers.handle("skill.list", () => response2(Skill.Service.use((skill) => skill.list()))));
+
+export { SkillHandler2 };

package/dist/chunks/workerd-q4bn6dy8.js

@@ -0,0 +1,39 @@
+// src/cors.ts
+import { Context } from "effect";
+var opencodeOrigin = /^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/;
+var CorsConfig2 = Context.Reference("@opencode/ServerCorsConfig", {
+  defaultValue: () => {
+    return;
+  }
+});
+function isAllowedCorsOrigin2(input, opts) {
+  if (!input)
+    return true;
+  if (input.startsWith("http://localhost:"))
+    return true;
+  if (input.startsWith("http://127.0.0.1:"))
+    return true;
+  if (input.startsWith("oc://renderer"))
+    return true;
+  if (input === "tauri://localhost" || input === "http://tauri.localhost" || input === "https://tauri.localhost")
+    return true;
+  if (opencodeOrigin.test(input))
+    return true;
+  return opts?.cors?.includes(input) ?? false;
+}
+function isAllowedRequestOrigin2(input, host, opts) {
+  if (!input)
+    return true;
+  if (host && sameHost(input, host))
+    return true;
+  return isAllowedCorsOrigin2(input, opts);
+}
+function sameHost(origin, host) {
+  try {
+    return new URL(origin).host === host;
+  } catch {
+    return false;
+  }
+}
+
+export { CorsConfig2, isAllowedCorsOrigin2, isAllowedRequestOrigin2 };

package/dist/chunks/workerd-qnwpcgp7.js

@@ -0,0 +1,22 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/config.ts
+import { Config } from "@opencode/core/config";
+import { ShellSelect } from "@opencode/core/shell/select";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var ConfigHandler2 = HttpApiBuilder.group(Api2, "server.config", (handlers) => handlers.handle("config.get", () => Config.Service.use((config) => config.entries())).handle("config.update", Effect.fn(function* (ctx) {
+  const config = yield* Config.Service;
+  if (!config.update)
+    return yield* Effect.die(new Error("Config updates are unavailable"));
+  return yield* config.update(ctx.payload).pipe(Effect.orDie);
+})).handle("config.shells", Effect.fn(function* () {
+  const shell = yield* ShellSelect.Service;
+  if (!shell.list)
+    return yield* Effect.die(new Error("Shell discovery is unavailable"));
+  return yield* shell.list();
+})));
+
+export { ConfigHandler2 };

package/dist/chunks/workerd-qzap92t7.js

@@ -0,0 +1,139 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+import {
+  CorsConfig2,
+  isAllowedRequestOrigin2
+} from "./workerd-q4bn6dy8.js";
+import {
+  Service4
+} from "./workerd-75c938bc.js";
+import {
+  runPtySocket2
+} from "./workerd-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* Service4;
+  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/workerd-r7e9r02j.js

@@ -0,0 +1,13 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.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/workerd-rcg4y18n.js

@@ -0,0 +1,59 @@
+import {
+  missingSession2,
+  failedMessageDecode2
+} from "./workerd-smaf4a18.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/message.ts
+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 { InvalidCursorError } from "@opencode/protocol/errors";
+var DefaultMessagesLimit = 50;
+var Cursor = Schema.Struct({
+  id: SessionMessage.ID,
+  order: Schema.Union([Schema.Literal("asc"), Schema.Literal("desc")]),
+  direction: Schema.Union([Schema.Literal("previous"), Schema.Literal("next")])
+});
+var decodeCursor = Schema.decodeUnknownSync(Cursor);
+var 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")));
+  }
+};
+var MessageHandler2 = HttpApiBuilder.group(Api2, "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 !== undefined)
+      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) : undefined,
+      catch: () => new InvalidCursorError({ message: "Invalid cursor" })
+    });
+    const order = decoded?.order ?? ctx.query.order ?? "desc";
+    const 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 } : undefined
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageDecodeError", failedMessageDecode2));
+    const first = messages[0];
+    const last = messages.at(-1);
+    return {
+      data: messages,
+      cursor: {
+        previous: first ? cursor.encode(first, order, "previous") : undefined,
+        next: last ? cursor.encode(last, order, "next") : undefined
+      }
+    };
+  }));
+}));
+
+export { MessageHandler2 };

package/dist/chunks/workerd-req22b70.js

@@ -0,0 +1,22 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/location.ts
+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";
+var LocationHandler2 = HttpApiBuilder.group(Api2, "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" })))));
+}));
+
+export { LocationHandler2 };

package/dist/chunks/workerd-smaf4a18.js

@@ -0,0 +1,28 @@
+// src/handlers/session-error.ts
+import { MessageNotFoundError, SessionNotFoundError, UnknownError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+function missingSession2(error) {
+  return new SessionNotFoundError({
+    sessionID: error.sessionID,
+    message: `Session not found: ${error.sessionID}`
+  });
+}
+function missingMessage2(error) {
+  return new MessageNotFoundError({
+    sessionID: error.sessionID,
+    messageID: error.messageID,
+    message: `Message not found: ${error.messageID}`
+  });
+}
+function failedMessageDecode2(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 }))));
+}
+function failedSnapshot2(operation, sessionID) {
+  return (error) => {
+    const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+    return Effect.logError(`failed to ${operation}`, { cause: error }).pipe(Effect.annotateLogs({ ref, sessionID }), Effect.andThen(Effect.fail(new UnknownError({ message: "Unexpected server error. Check server logs for details.", ref }))));
+  };
+}
+
+export { missingSession2, missingMessage2, failedMessageDecode2, failedSnapshot2 };

package/dist/chunks/workerd-t8yzmczr.js

@@ -0,0 +1,18 @@
+// src/middleware/schema-error.ts
+import { Effect } from "effect";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { InvalidRequestError } from "@opencode/protocol/errors";
+import { SchemaErrorMiddleware } from "@opencode/protocol/middleware/schema-error";
+import { SchemaErrorMiddleware as SchemaErrorMiddleware2 } from "@opencode/protocol/middleware/schema-error";
+var REASON_LIMIT = 1024;
+function truncateReason(reason) {
+  if (reason.length <= REASON_LIMIT)
+    return reason;
+  return reason.slice(0, REASON_LIMIT) + `... (${reason.length - REASON_LIMIT} more chars)`;
+}
+var schemaErrorLayer2 = HttpApiMiddleware.layerSchemaErrorTransform(SchemaErrorMiddleware, (error) => {
+  const reason = truncateReason(error.cause.message);
+  return Effect.logWarning("schema rejection").pipe(Effect.annotateLogs({ kind: error.kind, reason }), Effect.andThen(Effect.fail(new InvalidRequestError({ message: reason, kind: error.kind }))));
+});
+
+export { schemaErrorLayer2, SchemaErrorMiddleware2 };

package/dist/chunks/workerd-x1haxfjx.js

@@ -0,0 +1,21 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+import {
+  Service3
+} from "./workerd-mzr9gftb.js";
+
+// src/handlers/server.ts
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var ServerHandler2 = HttpApiBuilder.group(Api2, "server.server", (handlers) => handlers.handle("server.info", () => Effect.gen(function* () {
+  const info = yield* Service3;
+  return {
+    version: info.app.version ?? "unknown",
+    pid: process.pid ?? 0,
+    urls: info.urls(),
+    paths: info.paths
+  };
+})));
+
+export { ServerHandler2 };

package/dist/chunks/workerd-yc7nft6q.js

@@ -0,0 +1,5 @@
+// src/request-tracing.ts
+import { Context, Effect, Tracer } from "effect";
+var withoutParentSpan2 = (effect) => effect.pipe(Effect.updateContext((context) => Context.omit(Tracer.ParentSpan)(context)));
+
+export { withoutParentSpan2 };

package/dist/chunks/workerd-ysabas57.js

@@ -0,0 +1,13 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.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/workerd-z5shrcz9.js

@@ -0,0 +1,19 @@
+import {
+  LocationMiddleware2
+} from "./workerd-6gkz39ey.js";
+import {
+  FormLocationMiddleware2
+} from "./workerd-5rwqcaw2.js";
+import {
+  SessionLocationMiddleware2
+} from "./workerd-3kzx88w9.js";
+
+// src/api.ts
+import { makeDefaultApi } from "@opencode/protocol/api";
+var Api2 = makeDefaultApi({
+  locationMiddleware: LocationMiddleware2,
+  formLocationMiddleware: FormLocationMiddleware2,
+  sessionLocationMiddleware: SessionLocationMiddleware2
+});
+
+export { Api2 };

package/dist/chunks/workerd-zp2jm6dt.js

@@ -0,0 +1,15 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/project.ts
+import { Project } from "@opencode/core/project";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { ProjectNotFoundError } from "@opencode/protocol/errors";
+var ProjectHandler2 = HttpApiBuilder.group(Api2, "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}`
+}))))));
+
+export { ProjectHandler2 };