@opencode/server 2.0.8 → 2.0.9

package/dist/chunks/fetch-4g0fa6m0.js

@@ -0,0 +1,32 @@
+import {
+  response2
+} from "./fetch-6gkz39ey.js";
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/vcs.ts
+import { Vcs } from "@opencode/core/vcs";
+import { ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var VcsHandler2 = HttpApiBuilder.group(Api2, "server.vcs", (handlers) => Effect.gen(function* () {
+  return handlers.handle("vcs.get", () => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.info();
+  }))).handle("vcs.base", () => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.base().pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));
+  }))).handle("vcs.status", () => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.status();
+  }))).handle("vcs.branch.list", (ctx) => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.branches({ search: ctx.query.search, limit: Math.min(ctx.query.limit ?? 50, 100) });
+  }))).handle("vcs.diff", (ctx) => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.diff(ctx.query.mode, { context: ctx.query.context, base: ctx.query.base }).pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));
+  })));
+}));
+
+export { VcsHandler2 };

package/dist/chunks/fetch-4vn5bvkr.js

@@ -0,0 +1,25 @@
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/generate.ts
+import { Generate } from "@opencode/core/generate";
+import { Location } from "@opencode/core/location";
+import { LocationServiceMap } from "@opencode/core/location-services";
+import { AbsolutePath } from "@opencode/core/schema";
+import { InvalidRequestError, ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Global } from "@opencode/util/global";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var GenerateHandler2 = HttpApiBuilder.group(Api2, "server.generate", (handlers) => Effect.gen(function* () {
+  const global = yield* Global.Service;
+  const locations = yield* LocationServiceMap.Service;
+  const services = locations.get(Location.Ref.make({ directory: AbsolutePath.make(global.config) }));
+  return handlers.handle("generate.text", Effect.fn("server.generate.text")(function* (request) {
+    const generate = yield* Generate.Service;
+    const text = yield* generate.text(request.payload).pipe(Effect.mapError((error) => error._tag === "Generate.ModelSelectionError" ? new InvalidRequestError({ message: error.message }) : new ServiceUnavailableError({ message: error.message, service: error.service })));
+    return { data: { text } };
+  }, Effect.provide(services)));
+}));
+
+export { GenerateHandler2 };

package/dist/chunks/fetch-5rwqcaw2.js

@@ -0,0 +1,33 @@
+import {
+  sessionInfo2,
+  requestRef2
+} from "./fetch-6gkz39ey.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/fetch-6gkz39ey.js

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

package/dist/chunks/fetch-6nvan4e0.js

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

package/dist/chunks/fetch-7rzt3wm8.js

@@ -0,0 +1,13 @@
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/migration.ts
+import { V1Migration } from "@opencode/core/database/v1-migration";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Effect } from "effect";
+var MigrationHandler2 = HttpApiBuilder.group(Api2, "server.migration", (handlers) => handlers.handle("migration.v1.status", Effect.fn(function* () {
+  return yield* V1Migration.status();
+})));
+
+export { MigrationHandler2 };

package/dist/chunks/fetch-8bajbwjh.js

@@ -0,0 +1,40 @@
+import {
+  response2
+} from "./fetch-6gkz39ey.js";
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/mcp.ts
+import { Mcp } from "@opencode/core/mcp/index";
+import { McpServerNotFoundError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+var notFound = (effect) => effect.pipe(Effect.mapError((error) => new McpServerNotFoundError({ server: error.server, message: error.message })));
+var McpHandler2 = HttpApiBuilder.group(Api2, "server.mcp", (handlers) => Effect.gen(function* () {
+  return handlers.handle("mcp.list", Effect.fn(function* () {
+    const service = yield* Mcp.Service;
+    return yield* response2(service.servers().pipe(Effect.map((servers) => servers.map((info) => ({ name: info.name, status: info.status, integrationID: info.integrationID })))));
+  })).handle("mcp.add", Effect.fn(function* (ctx) {
+    const service = yield* Mcp.Service;
+    yield* service.add(ctx.params.server, ctx.payload.config);
+    return HttpApiSchema.NoContent.make();
+  })).handle("mcp.remove", Effect.fn(function* (ctx) {
+    const service = yield* Mcp.Service;
+    yield* notFound(service.remove(ctx.params.server));
+    return HttpApiSchema.NoContent.make();
+  })).handle("mcp.connect", Effect.fn(function* (ctx) {
+    const service = yield* Mcp.Service;
+    yield* notFound(service.connect(ctx.params.server));
+    return HttpApiSchema.NoContent.make();
+  })).handle("mcp.disconnect", Effect.fn(function* (ctx) {
+    const service = yield* Mcp.Service;
+    yield* notFound(service.disconnect(ctx.params.server));
+    return HttpApiSchema.NoContent.make();
+  })).handle("mcp.resource.catalog", Effect.fn(function* () {
+    const service = yield* Mcp.Service;
+    return yield* response2(service.resourceCatalog());
+  }));
+}));
+
+export { McpHandler2 };

package/dist/chunks/fetch-99sfd1j8.js

@@ -0,0 +1,83 @@
+import {
+  __export
+} from "./fetch-9rqn6x4v.js";
+
+// src/event-feed.ts
+var exports_event_feed = {};
+__export(exports_event_feed, {
+  EncodingError: () => EncodingError2,
+  EventFeed: () => exports_event_feed,
+  Service: () => Service4,
+  SubscriberCapacity: () => SubscriberCapacity2,
+  SubscriberOverflowError: () => SubscriberOverflowError2,
+  frame: () => frame2,
+  layer: () => layer5,
+  make: () => make4
+});
+import { Bus } from "@opencode/core/bus";
+import { Event } from "@opencode/schema/event";
+import { isOpenCodeEvent } from "@opencode/protocol/groups/event";
+import { Cause, Context, Effect, Layer, Queue, Schema, Stream } from "effect";
+var SubscriberCapacity2 = 4096;
+
+class SubscriberOverflowError2 extends Schema.TaggedError()("EventFeed.SubscriberOverflow", { capacity: Schema.Int }) {
+}
+
+class EncodingError2 extends Schema.TaggedError()("EventFeed.EncodingError", {
+  eventID: Event.ID,
+  eventType: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+
+class Service4 extends Context.Service()("@opencode/server/EventFeed") {
+}
+function frame2(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+var make4 = Effect.fn("EventFeed.make")(function* (observe, options) {
+  const capacity = options?.capacity ?? SubscriberCapacity2;
+  const render = options?.encode ?? frame2;
+  const subscribers = new Set;
+  const fail = (error) => Effect.sync(() => {
+    const current = Array.from(subscribers);
+    subscribers.clear();
+    for (const subscriber of current)
+      Queue.failCauseUnsafe(subscriber, Cause.fail(error));
+  });
+  const publish = Effect.fnUntraced(function* (event) {
+    if (!isOpenCodeEvent(event))
+      return;
+    if (subscribers.size === 0)
+      return;
+    const encoded = yield* Effect.try({
+      try: () => render(event),
+      catch: (cause) => new EncodingError2({ eventID: event.id, eventType: event.type, cause })
+    }).pipe(Effect.catch((error) => Effect.logError("Failed to encode public event", {
+      eventID: error.eventID,
+      eventType: error.eventType,
+      cause: error.cause
+    }).pipe(Effect.andThen(fail(error)), Effect.as(undefined))));
+    if (encoded === undefined)
+      return;
+    for (const subscriber of subscribers) {
+      if (Queue.offerUnsafe(subscriber, encoded))
+        continue;
+      subscribers.delete(subscriber);
+      Queue.failCauseUnsafe(subscriber, Cause.fail(new SubscriberOverflowError2({ capacity })));
+    }
+  });
+  const unsubscribe = yield* observe(publish);
+  yield* Effect.addFinalizer(() => unsubscribe);
+  return Service4.of({
+    subscribe: Effect.acquireRelease(Queue.dropping(capacity).pipe(Effect.tap((queue) => Effect.sync(() => subscribers.add(queue)))), (queue) => Effect.sync(() => subscribers.delete(queue)).pipe(Effect.andThen(Queue.shutdown(queue)), Effect.asVoid)).pipe(Effect.map(Stream.fromQueue))
+  });
+});
+var layer5 = Layer.effect(Service4, Effect.gen(function* () {
+  const bus = yield* Bus.Service;
+  return yield* make4(bus.listen);
+}));
+
+export { SubscriberCapacity2, SubscriberOverflowError2, EncodingError2, Service4, frame2, make4, layer5, exports_event_feed };

package/dist/chunks/fetch-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/fetch-a6yp8301.js

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

@@ -0,0 +1,77 @@
+import {
+  missingSession2
+} from "./fetch-smaf4a18.js";
+import {
+  response2,
+  sessionInfo2
+} from "./fetch-6gkz39ey.js";
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/permission.ts
+import { Instance } from "@opencode/core/instance/service";
+import { Location } from "@opencode/core/location";
+import { Permission } from "@opencode/core/permission";
+import { PermissionSaved } from "@opencode/core/permission/saved";
+import { Session } from "@opencode/core/session";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { PermissionNotFoundError } from "@opencode/protocol/errors";
+function missingRequest(id) {
+  return new PermissionNotFoundError({ requestID: id, message: `Permission request not found: ${id}` });
+}
+var PermissionHandler2 = HttpApiBuilder.group(Api2, "server.permission", (handlers) => Effect.gen(function* () {
+  const instances = yield* Instance.Service;
+  const sessions = yield* Session.Service;
+  const requireOwnedRequest = Effect.fnUntraced(function* (sessionID, requestID) {
+    const permission = yield* Permission.Service;
+    const request = yield* permission.get(requestID);
+    if (!request || request.sessionID !== sessionID)
+      return yield* missingRequest(requestID);
+    return { permission, request };
+  });
+  return handlers.handle("permission.request.list", Effect.fn(function* () {
+    const permission = yield* Permission.Service;
+    return yield* response2(permission.list());
+  })).handle("session.permission.create", Effect.fn(function* (ctx) {
+    const permission = yield* Permission.Service;
+    return {
+      data: yield* permission.ask({
+        id: ctx.payload.id,
+        sessionID: ctx.params.sessionID,
+        action: ctx.payload.action,
+        resources: ctx.payload.resources,
+        save: ctx.payload.save,
+        metadata: ctx.payload.metadata,
+        source: ctx.payload.source,
+        agent: ctx.payload.agent
+      }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2))
+    };
+  })).handle("session.permission.list", Effect.fn(function* (ctx) {
+    const session = yield* sessionInfo2(sessions, ctx.params.sessionID);
+    const requests = yield* Permission.Service.use((permission) => permission.forSession(ctx.params.sessionID)).pipe(instances.provide(session));
+    return { data: requests };
+  })).handle("session.permission.get", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID);
+    return { data: owned.request };
+  })).handle("session.permission.reply", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID);
+    yield* owned.permission.reply({ requestID: ctx.params.requestID, reply: ctx.payload.decision, message: ctx.payload.message }).pipe(Effect.catchTag("Permission.NotFoundError", () => missingRequest(ctx.params.requestID)));
+    return HttpApiSchema.NoContent.make();
+  })).handle("permission.saved.list", Effect.fn(function* (ctx) {
+    const location = yield* Location.Service;
+    const saved = yield* PermissionSaved.Service;
+    return {
+      data: yield* saved.list({
+        projectID: ctx.query.projectID ?? location.project.id
+      })
+    };
+  })).handle("permission.saved.remove", Effect.fn(function* (ctx) {
+    const saved = yield* PermissionSaved.Service;
+    yield* saved.remove(ctx.params.id);
+    return HttpApiSchema.NoContent.make();
+  }));
+}));
+
+export { PermissionHandler2 };

package/dist/chunks/fetch-b0b71rwa.js

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

package/dist/chunks/fetch-bjrwanme.js

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

@@ -0,0 +1,35 @@
+import {
+  response2
+} from "./fetch-6gkz39ey.js";
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/shell.ts
+import { Shell } from "@opencode/core/shell";
+import { Location } from "@opencode/core/location";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { ShellNotFoundError } from "@opencode/protocol/errors";
+var ShellHandler2 = HttpApiBuilder.group(Api2, "server.shell", (handlers) => Effect.gen(function* () {
+  return handlers.handle("shell.list", Effect.fn(function* () {
+    const shell = yield* Shell.Service;
+    return yield* response2(shell.list());
+  })).handle("shell.create", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    const location = yield* Location.Service;
+    return yield* response2(shell.create({ ...ctx.payload, cwd: ctx.payload.cwd || location.directory }).pipe(Effect.orDie));
+  })).handle("shell.get", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    return yield* response2(shell.get(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
+  })).handle("shell.output", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    return yield* response2(shell.output(ctx.params.id, { cursor: ctx.query.cursor, limit: ctx.query.limit }).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
+  })).handle("shell.remove", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    yield* shell.remove(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.void));
+    return HttpApiSchema.NoContent.make();
+  }));
+}));
+
+export { ShellHandler2 };