@opencode/server 2.0.8 → 2.0.10

package/dist/chunks/auth-r4dhhtgz.js

@@ -0,0 +1,346 @@
+import {
+  missingSession2,
+  missingMessage2,
+  failedMessageDecode2,
+  failedSnapshot2
+} from "./auth-smaf4a18.js";
+import {
+  Api2
+} from "./auth-z6kg9h7e.js";
+
+// src/handlers/session.ts
+import { Session } from "@opencode/core/session";
+import { SessionStats } from "@opencode/core/session/stats";
+import { SessionTitle } from "@opencode/core/session/title";
+import { SessionTransfer } from "@opencode/core/session/transfer";
+import { InstructionEntry } from "@opencode/core/session/instruction-entry";
+import { Form } from "@opencode/core/form";
+import { DateTime, Effect, Stream } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { SessionsCursor } from "@opencode/protocol/groups/session";
+import {
+  ConflictError,
+  CommandExecutionError,
+  CommandNotFoundError,
+  FormAlreadySettledError,
+  FormInvalidAnswerError,
+  FormNotFoundError,
+  InvalidRequestError,
+  InvalidCursorError,
+  MessageNotFoundError,
+  ServiceUnavailableError,
+  SessionBusyError,
+  SkillNotFoundError
+} from "@opencode/protocol/errors";
+import { AbsolutePath } from "@opencode/core/schema";
+var DefaultSessionsLimit = 50;
+function missingForm(id) {
+  return new FormNotFoundError({ id, message: `Form not found: ${id}` });
+}
+var SessionHandler2 = HttpApiBuilder.group(Api2, "server.session", (handlers) => Effect.gen(function* () {
+  const session = yield* Session.Service;
+  const transfer = yield* SessionTransfer.Service;
+  const requireOwnedForm = Effect.fnUntraced(function* (sessionID, formID) {
+    const form = yield* Form.Service;
+    const info = yield* form.get(formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(formID)));
+    if (info.sessionID !== sessionID)
+      return yield* missingForm(formID);
+    return { form, info };
+  });
+  const busySession = (error) => new SessionBusyError({
+    sessionID: error.sessionID,
+    message: `Session is busy: ${error.sessionID}`
+  });
+  const pendingMutation = (effect, conflict) => effect.pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.InboxConflictError", (error) => new ConflictError({ resource: error.inboxID, message: `${conflict}: ${error.inboxID}` })), Effect.as(HttpApiSchema.NoContent.make()));
+  return handlers.handle("session.list", Effect.fn(function* (ctx) {
+    const query = ctx.query.cursor !== undefined ? yield* SessionsCursor.parse(ctx.query.cursor).pipe(Effect.mapError(() => new InvalidCursorError({ message: "Invalid cursor" }))) : ctx.query;
+    const page = yield* session.list({
+      ...query,
+      limit: ctx.query.limit ?? DefaultSessionsLimit
+    });
+    const sessions = page.data;
+    const first = sessions[0];
+    const last = sessions.at(-1);
+    return {
+      data: sessions,
+      cursor: {
+        previous: first ? SessionsCursor.make({
+          ...query,
+          anchor: {
+            id: first.id,
+            time: DateTime.toEpochMillis(first.time.updated),
+            direction: "previous"
+          }
+        }) : undefined,
+        next: last ? SessionsCursor.make({
+          ...query,
+          anchor: {
+            id: last.id,
+            time: DateTime.toEpochMillis(last.time.updated),
+            direction: "next"
+          }
+        }) : undefined
+      }
+    };
+  })).handle("session.stats", Effect.fn(function* (ctx) {
+    const timezone = ctx.query.timezone ?? "UTC";
+    yield* Effect.try({
+      try: () => new Intl.DateTimeFormat("en-US", { timeZone: timezone }),
+      catch: () => new InvalidRequestError({ message: `Invalid time zone: ${timezone}` })
+    });
+    return {
+      data: yield* SessionStats.get({
+        from: ctx.query.from,
+        to: ctx.query.to,
+        projectID: ctx.query.project,
+        timezone,
+        tools: ctx.query.tools
+      }).pipe(Effect.mapError(() => new InvalidRequestError({ message: "Stats range must end after it starts" })))
+    };
+  })).handle("session.create", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.create({
+        id: ctx.payload.id,
+        title: ctx.payload.title,
+        agent: ctx.payload.agent,
+        model: ctx.payload.model,
+        metadata: ctx.payload.metadata,
+        permissions: ctx.payload.permissions,
+        location: ctx.payload.location ?? { directory: AbsolutePath.make(process.cwd()) }
+      }).pipe(Effect.orDie)
+    };
+  })).handle("session.import", Effect.fn(function* (ctx) {
+    return {
+      data: yield* transfer.import({
+        data: { info: ctx.payload.info, messages: ctx.payload.messages },
+        location: ctx.payload.location ?? { directory: AbsolutePath.make(process.cwd()) }
+      }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("SessionTransfer.ImportConflictError", (error) => new ConflictError({
+        message: `Session already exists: ${error.sessionID}`,
+        resource: error.sessionID
+      })))
+    };
+  })).handle("session.export", Effect.fn(function* (ctx) {
+    return {
+      data: yield* transfer.export({ sessionID: ctx.params.sessionID, sanitize: ctx.query.sanitize }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageDecodeError", failedMessageDecode2))
+    };
+  })).handle("session.active", Effect.fn(function* () {
+    const active = yield* session.active;
+    return {
+      data: Object.fromEntries(Array.from(active, (sessionID) => [sessionID, { type: "running" }]))
+    };
+  })).handle("session.get", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2))
+    };
+  })).handle("session.view", Effect.fn(function* (ctx) {
+    yield* session.view({ sessionID: ctx.params.sessionID, idle: DateTime.toEpochMillis(ctx.payload.idle) }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.remove", Effect.fn(function* (ctx) {
+    yield* session.remove(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.environment", Effect.fn(function* (ctx) {
+    yield* session.environment({ sessionID: ctx.params.sessionID, variables: ctx.payload.variables }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.fork", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.fork({ sessionID: ctx.params.sessionID, before: ctx.payload.before }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageNotFoundError", missingMessage2), Effect.catchTag("Session.ForkEmptyError", (error) => new InvalidRequestError({ message: error.message, kind: "empty_session" })))
+    };
+  })).handle("session.switchAgent", Effect.fn(function* (ctx) {
+    yield* session.switchAgent({ sessionID: ctx.params.sessionID, agent: ctx.payload.agent }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.switchModel", Effect.fn(function* (ctx) {
+    yield* session.switchModel({ sessionID: ctx.params.sessionID, model: ctx.payload.model }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.update", Effect.fn(function* (ctx) {
+    yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    if (ctx.payload.title !== undefined) {
+      if (ctx.payload.title) {
+        yield* session.rename({ sessionID: ctx.params.sessionID, title: ctx.payload.title }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+      } else {
+        const title = yield* SessionTitle.Service;
+        yield* title.generate(ctx.params.sessionID);
+      }
+    }
+    if (ctx.payload.permissions !== undefined)
+      yield* session.setPermissions({ sessionID: ctx.params.sessionID, permissions: ctx.payload.permissions }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.move", Effect.fn(function* (ctx) {
+    yield* session.move({
+      sessionID: ctx.params.sessionID,
+      directory: ctx.payload.directory,
+      delivery: ctx.payload.delivery
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.DestinationNotFoundError", (error) => Effect.fail(new InvalidRequestError({ message: `Directory does not exist: ${error.directory}` }))), Effect.catchTag("Session.DestinationNotDirectoryError", (error) => Effect.fail(new InvalidRequestError({ message: `Not a directory: ${error.directory}` }))), Effect.catchTag("Session.DestinationUnavailableError", (error) => Effect.fail(new InvalidRequestError({ message: `Directory is unavailable: ${error.directory}` }))));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.prompt", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.prompt({
+        sessionID: ctx.params.sessionID,
+        id: ctx.payload.id,
+        text: ctx.payload.text,
+        files: ctx.payload.files,
+        agents: ctx.payload.agents,
+        skills: ctx.payload.skills,
+        metadata: ctx.payload.metadata,
+        delivery: ctx.payload.delivery,
+        resume: ctx.payload.resume
+      }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.PromptConflictError", (error) => Effect.fail(new ConflictError({
+        message: `Prompt message ID conflicts with an existing durable record: ${error.messageID}`,
+        resource: error.messageID
+      }))), Effect.catchTag("Session.AttachmentError", (error) => Effect.fail(new InvalidRequestError({ message: error.message, field: "files" }))), Effect.catchTag("Session.SkillNotFoundError", (error) => Effect.fail(new InvalidRequestError({ message: `Skill not found: ${error.skill}`, field: "skills" }))))
+    };
+  })).handle("session.command", Effect.fn(function* (ctx) {
+    yield* session.command({
+      sessionID: ctx.params.sessionID,
+      command: ctx.payload.name,
+      text: ctx.payload.text,
+      files: ctx.payload.files,
+      agents: ctx.payload.agents,
+      skills: ctx.payload.skills,
+      delivery: ctx.payload.delivery
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Command.NotFoundError", (error) => Effect.fail(new CommandNotFoundError({
+      command: error.command,
+      message: error.message
+    }))), Effect.catchTag("Command.ExecutionError", (error) => Effect.fail(new CommandExecutionError({
+      command: error.command,
+      message: error.message
+    }))));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.skill", Effect.fn(function* (ctx) {
+    yield* session.skill({
+      sessionID: ctx.params.sessionID,
+      skill: ctx.payload.id,
+      resume: ctx.payload.resume
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.SkillNotFoundError", (error) => Effect.fail(new SkillNotFoundError({ skill: error.skill, message: `Skill not found: ${error.skill}` }))));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.synthetic", Effect.fn(function* (ctx) {
+    const data = yield* session.synthetic({
+      id: ctx.payload.id,
+      sessionID: ctx.params.sessionID,
+      text: ctx.payload.text,
+      description: ctx.payload.description,
+      metadata: ctx.payload.metadata,
+      delivery: ctx.payload.delivery,
+      resume: ctx.payload.resume
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.SyntheticConflictError", (error) => Effect.fail(new ConflictError({
+      message: `Synthetic input ID conflicts with an existing durable record: ${error.inputID}`,
+      resource: error.inputID
+    }))));
+    return { data };
+  })).handle("session.shell", Effect.fn(function* (ctx) {
+    yield* session.shell({ sessionID: ctx.params.sessionID, id: ctx.payload.id, command: ctx.payload.command }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.compact", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.compact({ sessionID: ctx.params.sessionID, id: ctx.payload.id, delivery: ctx.payload.delivery }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.CompactionConflictError", (error) => Effect.fail(new ConflictError({
+        message: `Compaction input ID conflicts with an existing durable record: ${error.inputID}`,
+        resource: error.inputID
+      }))))
+    };
+  })).handle("session.wait", Effect.fn(function* (ctx) {
+    yield* session.wait(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.revert.stage", Effect.fn(function* (ctx) {
+    yield* Effect.log("session.revert.stage", {
+      sessionID: ctx.params.sessionID,
+      messageID: ctx.payload.messageID,
+      files: ctx.payload.files
+    });
+    return {
+      data: yield* session.revert.stage({ ...ctx.params, ...ctx.payload }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageNotFoundError", missingMessage2), Effect.catchTag("Session.BusyError", busySession), Effect.catchTag("Snapshot.Error", failedSnapshot2("stage session revert", ctx.params.sessionID)))
+    };
+  })).handle("session.revert.clear", Effect.fn(function* (ctx) {
+    yield* Effect.log("session.revert.clear", { sessionID: ctx.params.sessionID });
+    yield* session.revert.clear(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.BusyError", busySession), Effect.catchTag("Snapshot.Error", failedSnapshot2("clear session revert", ctx.params.sessionID)));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.revert.commit", Effect.fn(function* (ctx) {
+    yield* Effect.log("session.revert.commit", { sessionID: ctx.params.sessionID });
+    yield* session.revert.commit(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.BusyError", busySession));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.context", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.context(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageDecodeError", failedMessageDecode2))
+    };
+  })).handle("session.diff", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.diff({ sessionID: ctx.params.sessionID, ...ctx.query }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageNotFoundError", missingMessage2), Effect.catchTag("Session.TurnRangeError", (error) => new InvalidRequestError({ message: error.message, field: error.field })), Effect.catchTag("Snapshot.Error", failedSnapshot2("diff session turn", ctx.params.sessionID)))
+    };
+  })).handle("session.inbox.list", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.inbox(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2))
+    };
+  })).handle("session.inbox.cancel", Effect.fn(function* (ctx) {
+    yield* session.cancelInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.InboxConflictError", () => Effect.void));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.inbox.update", Effect.fn(function* (ctx) {
+    return yield* pendingMutation(ctx.payload.delivery === "steer" ? session.steerInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }) : session.queueInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }), `Pending input cannot change to ${ctx.payload.delivery}`);
+  })).handle("session.instructions.entry.list", Effect.fn(function* (ctx) {
+    const instructions = yield* InstructionEntry.Service;
+    return { data: yield* instructions.list(ctx.params.sessionID) };
+  })).handle("session.instructions.entry.put", Effect.fn(function* (ctx) {
+    const instructions = yield* InstructionEntry.Service;
+    yield* instructions.put({ sessionID: ctx.params.sessionID, key: ctx.params.key, value: ctx.payload.value });
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.instructions.entry.remove", Effect.fn(function* (ctx) {
+    const instructions = yield* InstructionEntry.Service;
+    yield* instructions.remove({ sessionID: ctx.params.sessionID, key: ctx.params.key });
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.generate", Effect.fn(function* (ctx) {
+    const text = yield* session.generate({ sessionID: ctx.params.sessionID, prompt: ctx.payload.prompt }).pipe(Effect.mapError((error) => error._tag === "Session.NotFoundError" ? missingSession2(error) : new ServiceUnavailableError({ message: error.message, service: "session generation" })));
+    return { data: { text } };
+  })).handle("session.log", Effect.fn(function* (ctx) {
+    yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return session.log({ sessionID: ctx.params.sessionID, after: ctx.query.after, follow: ctx.query.follow }).pipe(Stream.orDie);
+  })).handle("session.interrupt", Effect.fn(function* (ctx) {
+    return { interrupted: yield* session.interrupt(ctx.params.sessionID, { resume: ctx.query.resume }) };
+  })).handle("session.background", Effect.fn(function* (ctx) {
+    yield* session.background(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.message", Effect.fn(function* (ctx) {
+    yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession2));
+    const message = yield* session.message(ctx.params);
+    if (message)
+      return { data: message };
+    return yield* new MessageNotFoundError({
+      sessionID: ctx.params.sessionID,
+      messageID: ctx.params.messageID,
+      message: `Message not found: ${ctx.params.messageID}`
+    });
+  })).handle("session.form.list", Effect.fn(function* (ctx) {
+    const form = yield* Form.Service;
+    return { data: yield* form.list({ sessionID: ctx.params.sessionID }) };
+  })).handle("session.form.create", Effect.fn(function* (ctx) {
+    const form = yield* Form.Service;
+    const created = yield* form.create({
+      id: ctx.payload.id,
+      sessionID: ctx.params.sessionID,
+      title: ctx.payload.title,
+      metadata: ctx.payload.metadata,
+      fields: ctx.payload.fields
+    }).pipe(Effect.catchTags({
+      "Form.AlreadyExistsError": (error) => new ConflictError({ resource: error.id, message: error.message }),
+      "Form.InvalidFormError": (error) => new InvalidRequestError({ message: error.message, field: "fields" })
+    }));
+    return { data: created };
+  })).handle("session.form.get", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID);
+    const state = yield* owned.form.state(ctx.params.formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(ctx.params.formID)));
+    return { data: { ...owned.info, state } };
+  })).handle("session.form.reply", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID);
+    yield* owned.form.reply({ id: ctx.params.formID, answer: ctx.payload.answer }).pipe(Effect.catchTags({
+      "Form.AlreadySettledError": (error) => new FormAlreadySettledError({ id: error.id, message: error.message }),
+      "Form.InvalidAnswerError": (error) => new FormInvalidAnswerError({ id: error.id, message: error.message }),
+      "Form.NotFoundError": () => missingForm(ctx.params.formID)
+    }));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.form.cancel", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID);
+    yield* owned.form.cancel(ctx.params.formID).pipe(Effect.catchTags({
+      "Form.AlreadySettledError": (error) => new FormAlreadySettledError({ id: error.id, message: error.message }),
+      "Form.NotFoundError": () => missingForm(ctx.params.formID)
+    }));
+    return HttpApiSchema.NoContent.make();
+  }));
+}));
+
+export { SessionHandler2 };

package/dist/chunks/auth-rjpqaa8h.js

@@ -0,0 +1,83 @@
+import {
+  __export
+} from "./auth-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: () => layer3,
+  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 layer3 = Layer.effect(Service3, Effect.gen(function* () {
+  const bus = yield* Bus.Service;
+  return yield* make4(bus.listen);
+}));
+
+export { SubscriberCapacity2, SubscriberOverflowError2, EncodingError2, Service3, frame2, make4, layer3, exports_event_feed };

package/dist/chunks/auth-smaf4a18.js

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

package/dist/chunks/auth-t8yzmczr.js

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

package/dist/chunks/auth-tk6nqkmh.js

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

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

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

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

@@ -0,0 +1,23 @@
+import {
+  __export
+} from "./auth-9rqn6x4v.js";
+
+// src/service-status.ts
+var exports_service_status = {};
+__export(exports_service_status, {
+  Status: () => exports_service_status,
+  make: () => make2
+});
+import { Effect, Ref } from "effect";
+var make2 = Effect.fnUntraced(function* (options = {}) {
+  const current = yield* Ref.make(options.initial ?? { type: "starting" });
+  const beginStopping = Ref.update(current, (status) => status.type === "stopping" ? status : { type: "stopping" });
+  return {
+    current: Ref.get(current),
+    ready: Ref.update(current, (status) => status.type === "starting" ? { type: "ready" } : status),
+    fail: Ref.update(current, (status) => status.type === "starting" ? { type: "failed" } : status),
+    beginStopping
+  };
+});
+
+export { make2, exports_service_status };

package/dist/chunks/auth-yc7nft6q.js

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