@opencode/server 2.0.7 → 2.0.9

package/dist/api.d.ts

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

package/dist/api.js

@@ -1,9 +1,10 @@
-import { makeDefaultApi } from "@opencode/protocol/api";
-import { LocationMiddleware } from "./location";
-import { FormLocationMiddleware } from "./middleware/form-location";
-import { SessionLocationMiddleware } from "./middleware/session-location";
-export const Api = makeDefaultApi({
-  locationMiddleware: LocationMiddleware,
-  formLocationMiddleware: FormLocationMiddleware,
-  sessionLocationMiddleware: SessionLocationMiddleware
-});
+import {
+  Api2
+} from "./chunks/fetch-z5shrcz9.js";
+import"./chunks/fetch-3kzx88w9.js";
+import"./chunks/fetch-5rwqcaw2.js";
+import"./chunks/fetch-6gkz39ey.js";
+import"./chunks/fetch-smaf4a18.js";
+export {
+  Api2 as Api
+};

package/dist/auth.js

@@ -1,17 +1,12 @@
-export * as ServerAuth from "./auth";
-import { Context, Layer, Option, Redacted } from "effect";
-
-export class Config extends Context.Service()("@opencode/ServerAuthConfig") {
-  static configLayer(input) {
-    return Layer.succeed(this, this.of({ ...input, username: "opencode" }));
-  }
-  static get layer() {
-    return this.configLayer({ password: Option.none() });
-  }
-}
-export function required(config) {
-  return Option.isSome(config.password) && config.password.value !== "";
-}
-export function authorized(credentials, config) {
-  return Option.isSome(config.password) && credentials.username === config.username && Redacted.value(credentials.password) === config.password.value;
-}
+import {
+  Config2,
+  required2,
+  authorized2,
+  exports_auth
+} from "./chunks/fetch-zyv89x5n.js";
+export {
+  Config2 as Config,
+  exports_auth as ServerAuth,
+  authorized2 as authorized,
+  required2 as required
+};

package/dist/chunks/fetch-00nn3k4b.js

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

@@ -0,0 +1,23 @@
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+
+// src/handlers/credential.ts
+import { Credential } from "@opencode/core/credential";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+var CredentialHandler2 = HttpApiBuilder.group(Api2, "server.credential", (handlers) => handlers.handle("credential.update", Effect.fn(function* (ctx) {
+  const credential = yield* Credential.Service;
+  yield* credential.update(ctx.params.credentialID, { label: ctx.payload.label });
+  return HttpApiSchema.NoContent.make();
+})).handle("credential.activate", Effect.fn(function* (ctx) {
+  const credential = yield* Credential.Service;
+  yield* credential.activate(ctx.params.credentialID);
+  return HttpApiSchema.NoContent.make();
+})).handle("credential.remove", Effect.fn(function* (ctx) {
+  const credential = yield* Credential.Service;
+  yield* credential.remove(ctx.params.credentialID);
+  return HttpApiSchema.NoContent.make();
+})));
+
+export { CredentialHandler2 };

package/dist/chunks/fetch-0d9kah4z.js

@@ -0,0 +1,23 @@
+import {
+  __export
+} from "./fetch-9rqn6x4v.js";
+
+// src/pty-environment.ts
+var exports_pty_environment = {};
+__export(exports_pty_environment, {
+  PtyEnvironment: () => exports_pty_environment,
+  Service: () => Service3,
+  layer: () => layer3,
+  node: () => node2
+});
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+
+class Service3 extends Context.Service()("@opencode/ServerPtyEnvironment") {
+}
+var layer3 = Layer.succeed(Service3, Service3.of({
+  get: () => Effect.succeed({})
+}));
+var node2 = makeGlobalNode({ service: Service3, layer: layer3, deps: [] });
+
+export { Service3, layer3, node2, exports_pty_environment };

package/dist/chunks/fetch-19c9ysa1.js

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

@@ -0,0 +1,346 @@
+import {
+  missingSession2,
+  missingMessage2,
+  failedMessageDecode2,
+  failedSnapshot2
+} from "./fetch-smaf4a18.js";
+import {
+  Api2
+} from "./fetch-z5shrcz9.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/fetch-254zvkj6.js

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

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

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

@@ -0,0 +1,21 @@
+import {
+  Api2
+} from "./fetch-z5shrcz9.js";
+import {
+  Service2
+} from "./fetch-s4aja1df.js";
+
+// src/handlers/server.ts
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var ServerHandler2 = HttpApiBuilder.group(Api2, "server.server", (handlers) => handlers.handle("server.info", () => Effect.gen(function* () {
+  const info = yield* Service2;
+  return {
+    version: info.app.version ?? "unknown",
+    pid: process.pid ?? 0,
+    urls: info.urls(),
+    paths: info.paths
+  };
+})));
+
+export { ServerHandler2 };