@opencode/server 2.0.7 → 2.0.9

package/dist/chunks/fetch-ceh2h0m9.js

@@ -0,0 +1,25 @@
+import {
+  response2
+} from "./fetch-6gkz39ey.js";
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/agent.ts
+import { Agent } from "@opencode/core/agent";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { AgentNotFoundError } from "@opencode/protocol/errors";
+var AgentHandler2 = HttpApiBuilder.group(Api2, "server.agent", (handlers) => handlers.handle("agent.list", () => Effect.gen(function* () {
+  return yield* response2(Agent.Service.use((agent) => agent.list()));
+})).handle("agent.get", Effect.fn(function* (ctx) {
+  const agent = yield* Agent.Service.use((service) => service.get(ctx.params.agentID));
+  if (!agent)
+    return yield* new AgentNotFoundError({
+      agentID: ctx.params.agentID,
+      message: `Agent not found: ${ctx.params.agentID}`
+    });
+  return yield* response2(Effect.succeed(agent));
+})));
+
+export { AgentHandler2 };

package/dist/chunks/fetch-csspsf0t.js

@@ -0,0 +1,99 @@
+import {
+  GenerateHandler2
+} from "./fetch-4vn5bvkr.js";
+import {
+  MessageHandler2
+} from "./fetch-rcg4y18n.js";
+import {
+  ModelHandler2
+} from "./fetch-254zvkj6.js";
+import {
+  ProviderHandler2
+} from "./fetch-pnqq1zxv.js";
+import {
+  SessionHandler2
+} from "./fetch-1c4qas2w.js";
+import {
+  PermissionHandler2
+} from "./fetch-arj41x43.js";
+import {
+  FileSystemHandler2
+} from "./fetch-hjnxtxmk.js";
+import {
+  FormHandler2
+} from "./fetch-6nvan4e0.js";
+import {
+  CommandHandler2
+} from "./fetch-r7e9r02j.js";
+import {
+  SkillHandler2
+} from "./fetch-q0ycym90.js";
+import {
+  RpcHandler2
+} from "./fetch-bjrwanme.js";
+import {
+  layer5
+} from "./fetch-99sfd1j8.js";
+import {
+  EventHandler2
+} from "./fetch-d4bshj6j.js";
+import {
+  AgentHandler2
+} from "./fetch-ceh2h0m9.js";
+import {
+  PluginHandler2
+} from "./fetch-19c9ysa1.js";
+import {
+  ServerHandler2
+} from "./fetch-4cf3x1kw.js";
+import {
+  DebugHandler2
+} from "./fetch-00nn3k4b.js";
+import {
+  PtyHandler2
+} from "./fetch-ychamt23.js";
+import {
+  PersistentPtyHandler2
+} from "./fetch-n0er2m55.js";
+import {
+  ShellHandler2
+} from "./fetch-br99j6q1.js";
+import {
+  ReferenceHandler2
+} from "./fetch-ysabas57.js";
+import {
+  LocationHandler2
+} from "./fetch-req22b70.js";
+import {
+  IntegrationHandler2
+} from "./fetch-a6yp8301.js";
+import {
+  WebSearchHandler2
+} from "./fetch-b0b71rwa.js";
+import {
+  McpHandler2
+} from "./fetch-8bajbwjh.js";
+import {
+  CredentialHandler2
+} from "./fetch-04xw3v55.js";
+import {
+  ProjectHandler2
+} from "./fetch-zp2jm6dt.js";
+import {
+  WorktreeHandler2
+} from "./fetch-j2pfq4q6.js";
+import {
+  VcsHandler2
+} from "./fetch-4g0fa6m0.js";
+import {
+  MigrationHandler2
+} from "./fetch-7rzt3wm8.js";
+import {
+  ConfigHandler2
+} from "./fetch-qnwpcgp7.js";
+
+// src/handlers.ts
+import { Layer } from "effect";
+var handlers2 = Layer.mergeAll(ServerHandler2, DebugHandler2, MigrationHandler2, LocationHandler2, AgentHandler2, PluginHandler2, SessionHandler2, MessageHandler2, ModelHandler2, GenerateHandler2, ProviderHandler2, IntegrationHandler2, WebSearchHandler2, McpHandler2, CredentialHandler2, ProjectHandler2, FormHandler2, PermissionHandler2, FileSystemHandler2, CommandHandler2, SkillHandler2, RpcHandler2, EventHandler2.pipe(Layer.provide(layer5)), PtyHandler2, PersistentPtyHandler2, ShellHandler2, ReferenceHandler2, WorktreeHandler2, VcsHandler2, ConfigHandler2);
+
+export { handlers2 };

package/dist/chunks/fetch-d4bshj6j.js

@@ -0,0 +1,37 @@
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+import {
+  Service4,
+  frame2
+} from "./fetch-99sfd1j8.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* Service4;
+  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/fetch-hezj1jdf.js

@@ -0,0 +1,7 @@
+// src/handlers/pty-socket.ts
+import { Effect } from "effect";
+function runPtySocket2(drain, socket, detach) {
+  return Effect.raceFirst(drain, socket).pipe(Effect.ensuring(Effect.sync(detach)));
+}
+
+export { runPtySocket2 };

package/dist/chunks/fetch-hjnxtxmk.js

@@ -0,0 +1,34 @@
+import {
+  response2
+} from "./fetch-6gkz39ey.js";
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/fs.ts
+import { FileSystem } from "@opencode/core/filesystem";
+import { RelativePath } from "@opencode/core/schema";
+import { FileNotFoundError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var FileSystemHandler2 = HttpApiBuilder.group(Api2, "server.fs", (handlers) => Effect.gen(function* () {
+  return handlers.handleRaw("fs.read", (ctx) => Effect.gen(function* () {
+    const fs = yield* FileSystem.Service;
+    const file = yield* fs.read({
+      path: RelativePath.make(decodeURIComponent(new URL(ctx.request.url, "http://localhost").pathname.slice(13)))
+    }).pipe(Effect.mapError((error) => new FileNotFoundError({ path: error.path, message: `File not found: ${error.path}` })));
+    return HttpServerResponse.uint8Array(file.content, { contentType: file.mime });
+  })).handle("fs.list", (ctx) => response2(Effect.gen(function* () {
+    const fs = yield* FileSystem.Service;
+    return yield* fs.list(ctx.query);
+  }))).handle("fs.find", (ctx) => response2(Effect.gen(function* () {
+    const fs = yield* FileSystem.Service;
+    return yield* fs.find(ctx.query);
+  }))).handle("fs.write", (ctx) => response2(Effect.gen(function* () {
+    const fs = yield* FileSystem.Service;
+    return yield* fs.write({ path: ctx.query.path, data: ctx.payload });
+  })));
+}));
+
+export { FileSystemHandler2 };

package/dist/chunks/fetch-j2pfq4q6.js

@@ -0,0 +1,42 @@
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/worktree.ts
+import { Git } from "@opencode/core/git";
+import { Worktree } from "@opencode/core/worktree";
+import { ProjectNotFoundError } from "@opencode/protocol/errors";
+import { WorktreeError } from "@opencode/protocol/groups/worktree";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+var WorktreeHandler2 = HttpApiBuilder.group(Api2, "server.worktree", (handlers) => Effect.gen(function* () {
+  const worktrees = yield* Worktree.Service;
+  return handlers.handle("worktree.list", (ctx) => worktrees.list(ctx.query).pipe(Effect.catchTag("Project.NotFoundError", missingProject))).handle("worktree.create", (ctx) => worktrees.create(ctx.payload).pipe(badRequest)).handle("worktree.remove", (ctx) => worktrees.remove(ctx.payload).pipe(badRequest, Effect.as(HttpApiSchema.NoContent.make()))).handle("worktree.refresh", (ctx) => worktrees.refresh(ctx.payload).pipe(badRequest, Effect.as(HttpApiSchema.NoContent.make())));
+}));
+function badRequest(effect) {
+  return effect.pipe(Effect.catchTag("Project.NotFoundError", missingProject), Effect.mapError((error) => error instanceof ProjectNotFoundError ? error : new WorktreeError({
+    name: "WorktreeError",
+    data: {
+      message: message(error),
+      forceRequired: error instanceof Git.WorktreeError || error instanceof Worktree.OperationError ? error.forceRequired : undefined
+    }
+  })));
+}
+function missingProject(error) {
+  return Effect.fail(new ProjectNotFoundError({ projectID: error.projectID, message: `Project not found: ${error.projectID}` }));
+}
+function message(error) {
+  if (error instanceof Worktree.SourceDirectoryNotFoundError)
+    return error.directory ? `Worktree source not found: ${error.directory}` : `Worktree source not found for project: ${error.projectID}`;
+  if (error instanceof Worktree.DestinationExistsError)
+    return `Worktree destination already exists: ${error.directory}`;
+  if (error instanceof Worktree.DirectoryUnavailableError)
+    return `Worktree directory unavailable: ${error.directory}`;
+  if (error instanceof Worktree.InvalidDirectoryError)
+    return `Invalid worktree directory: ${error.directory}`;
+  if (error instanceof Worktree.StrategyUnavailableError)
+    return `Worktree strategy unavailable: ${error.strategy}`;
+  return error.message;
+}
+
+export { WorktreeHandler2 };

package/dist/chunks/fetch-m6wvgbfq.js

@@ -0,0 +1,60 @@
+import {
+  Config2,
+  required2,
+  authorized2
+} from "./fetch-zyv89x5n.js";
+
+// src/middleware/authorization.ts
+import { UnauthorizedError } from "@opencode/protocol/errors";
+import { Authorization } from "@opencode/protocol/middleware/authorization";
+import { Authorization as Authorization2 } from "@opencode/protocol/middleware/authorization";
+import { hasPtyConnectTicketURL } from "@opencode/protocol/groups/pty";
+import { hasPersistentPtyConnectTicketURL } from "@opencode/protocol/groups/persistent-pty";
+import { Effect, Encoding, Layer, Redacted } from "effect";
+import { HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+var AUTH_TOKEN_QUERY = "auth_token";
+var WWW_AUTHENTICATE = 'Basic realm="Secure Area"';
+function emptyCredential() {
+  return { username: "", password: Redacted.make("") };
+}
+function decodeCredential(input) {
+  return Effect.fromResult(Encoding.decodeBase64String(input)).pipe(Effect.match({
+    onFailure: emptyCredential,
+    onSuccess: (header) => {
+      const separator = header.indexOf(":");
+      if (separator === -1)
+        return emptyCredential();
+      return { username: header.slice(0, separator), password: Redacted.make(header.slice(separator + 1)) };
+    }
+  }));
+}
+function credentialFromRequest(request) {
+  const url = new URL(request.url, "http://localhost");
+  const token = url.searchParams.get(AUTH_TOKEN_QUERY);
+  if (token)
+    return decodeCredential(token);
+  const match = /^Basic\s+(.+)$/i.exec(request.headers.authorization ?? "");
+  if (match)
+    return decodeCredential(match[1]);
+  return Effect.succeed(emptyCredential());
+}
+function authorizedRequest2(request, config) {
+  return credentialFromRequest(request).pipe(Effect.map((credential) => authorized2(credential, config)));
+}
+var authorizationLayer2 = Layer.effect(Authorization, Effect.gen(function* () {
+  const config = yield* Config2;
+  if (!required2(config))
+    return Authorization.of((effect) => effect);
+  return Authorization.of((effect) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const url = new URL(request.url, "http://localhost");
+    if (hasPtyConnectTicketURL(url) || hasPersistentPtyConnectTicketURL(url))
+      return yield* effect;
+    if (yield* authorizedRequest2(request, config))
+      return yield* effect;
+    yield* HttpEffect.appendPreResponseHandler((_request, response) => Effect.succeed(HttpServerResponse.setHeader(response, "www-authenticate", WWW_AUTHENTICATE)));
+    return yield* new UnauthorizedError({ message: "Authentication required" });
+  }));
+}));
+
+export { authorizedRequest2, authorizationLayer2, Authorization2 };

package/dist/chunks/fetch-n0er2m55.js

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

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

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

@@ -0,0 +1,26 @@
+import {
+  isAllowedCorsOrigin2
+} from "./fetch-q4bn6dy8.js";
+import {
+  createRoutes2
+} from "./fetch-vgpejxxy.js";
+import {
+  __export
+} from "./fetch-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/fetch-qnwpcgp7.js

@@ -0,0 +1,22 @@
+import {
+  Api2
+} from "./fetch-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/fetch-r7e9r02j.js

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