@opencode/server 2.0.8 → 2.0.10

package/dist/api.d.ts

@@ -6654,7 +6654,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
                 readonly [x: string]: unknown;
             };
             readonly command: string;
-            readonly status: "running" | "exited" | "timeout" | "killed";
+            readonly status: "timeout" | "running" | "exited" | "killed";
             readonly time: {
                 readonly started: number;
                 readonly completed?: number | undefined;
@@ -6679,7 +6679,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
     readonly id: string & import("effect/Brand").Brand<"Event.ID">;
     readonly data: {
         readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
-        readonly status: "running" | "exited" | "timeout" | "killed";
+        readonly status: "timeout" | "running" | "exited" | "killed";
         readonly exit?: number | undefined;
     };
     readonly type: "shell.exited";
@@ -7276,7 +7276,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
                 readonly [x: string]: unknown;
             };
             readonly command: string;
-            readonly status: "running" | "exited" | "timeout" | "killed";
+            readonly status: "timeout" | "running" | "exited" | "killed";
             readonly time: {
                 readonly started: number;
                 readonly completed?: number | undefined;
@@ -7312,7 +7312,7 @@ export declare const Api: import("@opencode/protocol/api").Api<LocationMiddlewar
                 readonly [x: string]: unknown;
             };
             readonly command: string;
-            readonly status: "running" | "exited" | "timeout" | "killed";
+            readonly status: "timeout" | "running" | "exited" | "killed";
             readonly time: {
                 readonly started: number;
                 readonly completed?: number | undefined;

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/auth-z6kg9h7e.js";
+import"./chunks/auth-23w8t84j.js";
+import"./chunks/auth-frv6gfy7.js";
+import"./chunks/auth-0ar9gf7q.js";
+import"./chunks/auth-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/auth-zyv89x5n.js";
+export {
+  Config2 as Config,
+  exports_auth as ServerAuth,
+  authorized2 as authorized,
+  required2 as required
+};

package/dist/chunks/auth-0ar9gf7q.js

@@ -0,0 +1,55 @@
+import {
+  missingSession2
+} from "./auth-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 layer5 = 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, layer5 };

package/dist/chunks/auth-0qzy9yxk.js

@@ -0,0 +1,163 @@
+import {
+  Api2
+} from "./auth-z6kg9h7e.js";
+import {
+  CorsConfig2,
+  isAllowedRequestOrigin2
+} from "./auth-q4bn6dy8.js";
+import {
+  runPtySocket2
+} from "./auth-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/auth-1wj0ectp.js

@@ -0,0 +1,22 @@
+import {
+  Api2
+} from "./auth-z6kg9h7e.js";
+
+// src/handlers/rpc.ts
+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";
+var RpcHandler2 = HttpApiBuilder.group(Api2, "server.rpc", (handlers) => handlers.handle("rpc.call", ({ params, payload }) => Effect.gen(function* () {
+  yield* Plugin.awaitActivation;
+  const rpc = yield* Rpc.Service;
+  const output = yield* rpc.call(params.rpcID, params.method, payload.input);
+  return output === undefined ? {} : { 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 === undefined ? {} : { 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" }))))))));
+
+export { RpcHandler2 };

package/dist/chunks/auth-23w8t84j.js

@@ -0,0 +1,26 @@
+import {
+  sessionInfo2
+} from "./auth-0ar9gf7q.js";
+
+// src/middleware/session-location.ts
+import { Instance } from "@opencode/core/instance/service";
+import { Session } from "@opencode/core/session";
+import { Effect, Layer } from "effect";
+import { HttpRouter } from "effect/unstable/http";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { InvalidRequestError, SessionNotFoundError } from "@opencode/protocol/errors";
+class SessionLocationMiddleware2 extends HttpApiMiddleware.Service()("@opencode/HttpApiSessionLocation", {
+  error: [InvalidRequestError, SessionNotFoundError]
+}) {
+}
+var sessionLocationLayer2 = Layer.effect(SessionLocationMiddleware2, Effect.gen(function* () {
+  const sessions = yield* Session.Service;
+  const instances = yield* Instance.Service;
+  return SessionLocationMiddleware2.of((effect) => Effect.gen(function* () {
+    const route = yield* HttpRouter.RouteContext;
+    const session = yield* sessionInfo2(sessions, route.params.sessionID);
+    return yield* effect.pipe(instances.provide(session));
+  }));
+}));
+
+export { SessionLocationMiddleware2, sessionLocationLayer2 };

package/dist/chunks/auth-34e6wr3b.js

@@ -0,0 +1,13 @@
+import {
+  response2
+} from "./auth-0ar9gf7q.js";
+import {
+  Api2
+} from "./auth-z6kg9h7e.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/auth-3582t7j8.js

@@ -0,0 +1,139 @@
+import {
+  response2
+} from "./auth-0ar9gf7q.js";
+import {
+  Api2
+} from "./auth-z6kg9h7e.js";
+import {
+  CorsConfig2,
+  isAllowedRequestOrigin2
+} from "./auth-q4bn6dy8.js";
+import {
+  Service2
+} from "./auth-bkk2wfbz.js";
+import {
+  runPtySocket2
+} from "./auth-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/auth-40g8rvw4.js

@@ -0,0 +1,59 @@
+import {
+  missingSession2,
+  failedMessageDecode2
+} from "./auth-smaf4a18.js";
+import {
+  Api2
+} from "./auth-z6kg9h7e.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/auth-5p62ed52.js

@@ -0,0 +1,36 @@
+import {
+  __export
+} from "./auth-9rqn6x4v.js";
+
+// src/server-info.ts
+var exports_server_info = {};
+__export(exports_server_info, {
+  ServerInfo: () => exports_server_info,
+  Service: () => Service4,
+  connectionURLs: () => connectionURLs2,
+  layer: () => layer4
+});
+import { Context, Layer } from "effect";
+import { networkInterfaces } from "node:os";
+
+class Service4 extends Context.Service()("@opencode/server/ServerInfo") {
+}
+function layer4(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, layer4, connectionURLs2, exports_server_info };

package/dist/chunks/auth-6aya8ky6.js

@@ -0,0 +1,39 @@
+import {
+  response2
+} from "./auth-0ar9gf7q.js";
+import {
+  Api2
+} from "./auth-z6kg9h7e.js";
+
+// src/handlers/websearch.ts
+import { WebSearch } from "@opencode/core/websearch";
+import { InvalidRequestError, ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var WebSearchHandler2 = HttpApiBuilder.group(Api2, "server.websearch", (handlers) => Effect.gen(function* () {
+  return handlers.handle("websearch.providers", Effect.fn("server.websearch.providers")(function* () {
+    const websearch = yield* WebSearch.Service;
+    return yield* response2(websearch.providers());
+  })).handle("websearch.query", Effect.fn("server.websearch.query")(function* (request) {
+    const websearch = yield* WebSearch.Service;
+    return yield* response2(websearch.query(request.payload).pipe(Effect.catchTags({
+      "WebSearch.ProviderRequired": () => new InvalidRequestError({
+        message: "Web search provider is required",
+        kind: "websearch_provider_required",
+        field: "providerID"
+      }),
+      "WebSearch.ProviderNotFound": (error) => new InvalidRequestError({
+        message: `Web search provider not found: ${error.providerID}`,
+        kind: "websearch_provider_not_found",
+        field: "providerID"
+      }),
+      "WebSearch.Disabled": () => new InvalidRequestError({ message: "Web search is disabled", kind: "websearch_disabled" }),
+      "WebSearch.Request": (error) => new ServiceUnavailableError({
+        message: `Web search request failed: ${error.providerID}`,
+        service: error.providerID
+      })
+    })));
+  }));
+}));
+
+export { WebSearchHandler2 };