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

package/dist/chunks/process-d0efjmp3.js

@@ -0,0 +1,83 @@
+import {
+  __export
+} from "./process-9rqn6x4v.js";
+
+// src/event-feed.ts
+var exports_event_feed = {};
+__export(exports_event_feed, {
+  EncodingError: () => EncodingError2,
+  EventFeed: () => exports_event_feed,
+  Service: () => Service3,
+  SubscriberCapacity: () => SubscriberCapacity2,
+  SubscriberOverflowError: () => SubscriberOverflowError2,
+  frame: () => frame2,
+  layer: () => layer4,
+  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 Service3 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 Service3.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 layer4 = Layer.effect(Service3, Effect.gen(function* () {
+  const bus = yield* Bus.Service;
+  return yield* make4(bus.listen);
+}));
+
+export { SubscriberCapacity2, SubscriberOverflowError2, EncodingError2, Service3, frame2, make4, layer4, exports_event_feed };

package/dist/chunks/process-d5nhwenp.js

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

package/dist/chunks/process-dhcrxjg3.js

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

@@ -0,0 +1,15 @@
+import {
+  Api2
+} from "./process-ks9pc2xc.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 };

package/dist/chunks/process-gw2hwgqh.js

@@ -0,0 +1,20 @@
+import {
+  requestRef2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/debug.ts
+import { LocationServiceMap } from "@opencode/core/location-service-map";
+import { Effect, Option, RcMap } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var DebugHandler2 = HttpApiBuilder.group(Api2, "server.debug", (handlers) => handlers.handle("debug.location", Effect.fn(function* () {
+  const locations = Option.getOrThrow(yield* Effect.serviceOption(LocationServiceMap.Service));
+  return Array.from(yield* RcMap.keys(locations.rcMap));
+})).handle("debug.location.evict", Effect.fn(function* (ctx) {
+  const locations = Option.getOrThrow(yield* Effect.serviceOption(LocationServiceMap.Service));
+  yield* locations.invalidate(requestRef2(ctx.request));
+})));
+
+export { DebugHandler2 };

package/dist/chunks/process-h965rd83.js

@@ -0,0 +1,25 @@
+import {
+  Api2
+} from "./process-ks9pc2xc.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/process-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/process-j26nh0zz.js

@@ -0,0 +1,40 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.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/process-ja6yvede.js

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

@@ -0,0 +1,39 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.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/process-k8tgqrb7.js

@@ -0,0 +1,61 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/plugin.ts
+import { Plugin } from "@opencode/core/plugin";
+import { PluginUpdate } from "@opencode/core/plugin/update";
+import { InvalidRequestError, ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Cause, Effect, Exit } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var PluginHandler2 = HttpApiBuilder.group(Api2, "server.plugin", (handlers) => handlers.handle("plugin.list", () => Effect.gen(function* () {
+  return yield* response2(Plugin.Service.use((plugin) => plugin.list()));
+})).handle("plugin.check", (ctx) => Effect.gen(function* () {
+  const plugins = yield* Plugin.Service;
+  const inventory = yield* plugins.list();
+  const targets = [
+    ...new Set(inventory.flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : []))
+  ].filter((target) => ctx.payload.target === undefined || target === ctx.payload.target);
+  if (ctx.payload.target !== undefined && !targets.length)
+    return yield* new InvalidRequestError({
+      message: `Plugin package is not in the current server inventory: ${ctx.payload.target}`,
+      field: "target"
+    });
+  const updates = yield* PluginUpdate.Service;
+  const outdated = new Map(yield* Effect.forEach(targets, (target) => updates.check(target, { refresh: true }).pipe(Effect.map((value) => [target, value])), { concurrency: "unbounded" }));
+  return yield* response2(Effect.succeed(inventory.map((plugin) => {
+    if (plugin.source.type !== "package" || !outdated.has(plugin.source.target))
+      return plugin;
+    return {
+      ...plugin,
+      source: {
+        type: "package",
+        target: plugin.source.target,
+        ...plugin.source.version ? { version: plugin.source.version } : {},
+        ...outdated.get(plugin.source.target) ? { outdated: true } : {},
+        ...plugin.source.updating ? { updating: true } : {}
+      }
+    };
+  })));
+})).handle("plugin.update", (ctx) => Effect.gen(function* () {
+  const plugins = yield* Plugin.Service;
+  const inventory = new Set((yield* plugins.list()).flatMap((plugin) => plugin.source.type === "package" ? [plugin.source.target] : []));
+  const unknown = ctx.payload.targets.filter((target) => !inventory.has(target));
+  if (unknown.length)
+    return yield* new InvalidRequestError({
+      message: `Plugin packages are not in the current server inventory: ${unknown.join(", ")}`,
+      field: "targets"
+    });
+  const updates = yield* PluginUpdate.Service;
+  const failures = yield* Effect.forEach(ctx.payload.targets, (target) => updates.update(target).pipe(Effect.exit, Effect.map((exit) => Exit.isFailure(exit) ? [`${target}: ${Cause.pretty(exit.cause)}`] : [])), { concurrency: "unbounded" }).pipe(Effect.map((results) => results.flat()));
+  if (failures.length)
+    return yield* new ServiceUnavailableError({
+      message: `Failed to update plugin packages: ${failures.join("; ")}`,
+      service: "plugin"
+    });
+})));
+
+export { PluginHandler2 };

package/dist/chunks/process-kadtbwy3.js

@@ -0,0 +1,77 @@
+import {
+  missingSession2
+} from "./process-smaf4a18.js";
+import {
+  response2,
+  sessionInfo2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.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/process-kb9735wh.js

@@ -0,0 +1,26 @@
+import {
+  sessionInfo2
+} from "./process-8j6eh3dh.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 };