@opencode/server 0.0.0-reserved → 2.0.1

package/dist/handlers/session.js

@@ -0,0 +1,289 @@
+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 { DateTime, Effect, Stream } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { SessionsCursor } from "@opencode/protocol/groups/session";
+import {
+  ConflictError,
+  CommandExecutionError,
+  CommandNotFoundError,
+  InvalidRequestError,
+  InvalidCursorError,
+  MessageNotFoundError,
+  ServiceUnavailableError,
+  SessionBusyError,
+  SkillNotFoundError,
+  UnknownError
+} from "@opencode/protocol/errors";
+import { AbsolutePath } from "@opencode/core/schema";
+import { failedMessageDecode, missingSession } from "./session-error";
+const DefaultSessionsLimit = 50;
+export const SessionHandler = HttpApiBuilder.group(Api, "server.session", (handlers) => Effect.gen(function* () {
+  const session = yield* Session.Service, transfer = yield* SessionTransfer.Service, busySession = (error) => new SessionBusyError({
+    sessionID: error.sessionID,
+    message: `Session is busy: ${error.sessionID}`
+  }), pendingMutation = (effect, conflict) => effect.pipe(Effect.catchTag("Session.NotFoundError", missingSession), 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 !== void 0 ? yield* SessionsCursor.parse(ctx.query.cursor).pipe(Effect.mapError(() => new InvalidCursorError({ message: "Invalid cursor" }))) : ctx.query, sessions = (yield* session.list({
+      ...query,
+      workspaceID: query.workspace,
+      limit: ctx.query.limit ?? DefaultSessionsLimit
+    })).data, first = sessions[0], 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"
+          }
+        }) : void 0,
+        next: last ? SessionsCursor.make({
+          ...query,
+          anchor: {
+            id: last.id,
+            time: DateTime.toEpochMillis(last.time.updated),
+            direction: "next"
+          }
+        }) : void 0
+      }
+    };
+  })).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", missingSession), 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", missingSession), Effect.catchTag("Session.MessageDecodeError", failedMessageDecode))
+    };
+  })).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", missingSession))
+    };
+  })).handle("session.view", Effect.fn(function* (ctx) {
+    yield* session.view({ sessionID: ctx.params.sessionID, idle: ctx.payload.idle }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.remove", Effect.fn(function* (ctx) {
+    yield* session.remove(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+    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", missingSession));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.fork", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.fork({ sessionID: ctx.params.sessionID, boundary: ctx.payload.boundary }).pipe(Effect.catchTag("Session.NotFoundError", missingSession), Effect.catchTag("Session.MessageNotFoundError", (error) => new MessageNotFoundError({
+        sessionID: error.sessionID,
+        messageID: error.messageID,
+        message: `Message not found: ${error.messageID}`
+      })), 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", missingSession));
+    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", missingSession));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.rename", Effect.fn(function* (ctx) {
+    if (ctx.payload.title) {
+      yield* session.rename({ sessionID: ctx.params.sessionID, title: ctx.payload.title }).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+      return HttpApiSchema.NoContent.make();
+    }
+    yield* (yield* SessionTitle.Service).generate(ctx.params.sessionID);
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.move", Effect.fn(function* (ctx) {
+    yield* session.move({
+      sessionID: ctx.params.sessionID,
+      directory: ctx.payload.directory,
+      workspaceID: ctx.payload.workspaceID,
+      delivery: ctx.payload.delivery
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession), 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", missingSession), 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.command,
+      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", missingSession), 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,
+      id: ctx.payload.id,
+      skill: ctx.payload.skill,
+      resume: ctx.payload.resume
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession), 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) {
+    return { 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", missingSession), Effect.catchTag("Session.SyntheticConflictError", (error) => Effect.fail(new ConflictError({
+      message: `Synthetic input ID conflicts with an existing durable record: ${error.inputID}`,
+      resource: error.inputID
+    })))) };
+  })).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", missingSession));
+    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", missingSession), 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", missingSession));
+    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", missingSession), Effect.catchTag("Session.MessageNotFoundError", (error) => new MessageNotFoundError({
+        sessionID: error.sessionID,
+        messageID: error.messageID,
+        message: `Message not found: ${error.messageID}`
+      })), Effect.catchTag("Session.BusyError", busySession), Effect.catchTag("Snapshot.Error", (error) => {
+        const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+        return Effect.logError("failed to stage session revert", { cause: error }).pipe(Effect.andThen(Effect.fail(new UnknownError({
+          message: "Unexpected server error. Check server logs for details.",
+          ref
+        }))));
+      }))
+    };
+  })).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", missingSession), Effect.catchTag("Session.BusyError", busySession), Effect.catchTag("Snapshot.Error", (error) => {
+      const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+      return Effect.logError("failed to clear session revert", { cause: error }).pipe(Effect.andThen(Effect.fail(new UnknownError({
+        message: "Unexpected server error. Check server logs for details.",
+        ref
+      }))));
+    }));
+    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", missingSession), 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", missingSession), Effect.catchTag("Session.MessageDecodeError", failedMessageDecode))
+    };
+  })).handle("session.inbox.list", Effect.fn(function* (ctx) {
+    return {
+      data: yield* session.inbox(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession))
+    };
+  })).handle("session.inbox.cancel", Effect.fn(function* (ctx) {
+    return yield* pendingMutation(session.cancelInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }), "Pending input can no longer be cancelled");
+  })).handle("session.inbox.steer", Effect.fn(function* (ctx) {
+    return yield* pendingMutation(session.steerInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }), "Pending input is no longer queued");
+  })).handle("session.inbox.queue", Effect.fn(function* (ctx) {
+    return yield* pendingMutation(session.queueInbox({ sessionID: ctx.params.sessionID, inboxID: ctx.params.inboxID }), "Pending input is no longer a steer");
+  })).handle("session.instructions.entry.list", Effect.fn(function* (ctx) {
+    return { data: yield* (yield* InstructionEntry.Service).list(ctx.params.sessionID) };
+  })).handle("session.instructions.entry.put", Effect.fn(function* (ctx) {
+    yield* (yield* InstructionEntry.Service).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) {
+    yield* (yield* InstructionEntry.Service).remove({ sessionID: ctx.params.sessionID, key: ctx.params.key });
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.generate", Effect.fn(function* (ctx) {
+    return { data: { text: yield* session.generate({ sessionID: ctx.params.sessionID, prompt: ctx.payload.prompt }).pipe(Effect.mapError((error) => error._tag === "Session.NotFoundError" ? missingSession(error) : new ServiceUnavailableError({ message: error.message, service: "session generation" }))) } };
+  })).handle("session.log", Effect.fn(function* (ctx) {
+    yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+    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, { continue: ctx.query.continue }) };
+  })).handle("session.background", Effect.fn(function* (ctx) {
+    yield* session.background(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+    return HttpApiSchema.NoContent.make();
+  })).handle("session.message", Effect.fn(function* (ctx) {
+    yield* session.get(ctx.params.sessionID).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+    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}`
+    });
+  }));
+}));

package/dist/handlers/shell.d.ts

@@ -0,0 +1 @@
+export declare const ShellHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.shell">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/shell.js

@@ -0,0 +1,28 @@
+import { Shell } from "@opencode/core/shell";
+import { Location } from "@opencode/core/location";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { ShellNotFoundError } from "@opencode/protocol/errors";
+import { Api } from "../api";
+import { response } from "../location";
+export const ShellHandler = HttpApiBuilder.group(Api, "server.shell", (handlers) => Effect.gen(function* () {
+  return handlers.handle("shell.list", Effect.fn(function* () {
+    const shell = yield* Shell.Service;
+    return yield* response(shell.list());
+  })).handle("shell.create", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service, location = yield* Location.Service;
+    return yield* response(shell.create({ ...ctx.payload, cwd: ctx.payload.cwd || location.directory }).pipe(Effect.orDie));
+  })).handle("shell.get", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    return yield* response(shell.get(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
+  })).handle("shell.timeout", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    return yield* response(shell.timeout(ctx.params.id, ctx.payload.timeout).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
+  })).handle("shell.output", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    return yield* response(shell.output(ctx.params.id, { cursor: ctx.query.cursor, limit: ctx.query.limit }).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` }))));
+  })).handle("shell.remove", Effect.fn(function* (ctx) {
+    yield* (yield* Shell.Service).remove(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => new ShellNotFoundError({ id: ctx.params.id, message: `Shell command not found: ${ctx.params.id}` })));
+    return HttpApiSchema.NoContent.make();
+  }));
+}));

package/dist/handlers/skill.d.ts

@@ -0,0 +1 @@
+export declare const SkillHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.skill">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/skill.js

@@ -0,0 +1,5 @@
+import { Skill } from "@opencode/core/skill";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+export const SkillHandler = HttpApiBuilder.group(Api, "server.skill", (handlers) => handlers.handle("skill.list", () => response(Skill.Service.use((skill) => skill.list()))));

package/dist/handlers/vcs.d.ts

@@ -0,0 +1 @@
+export declare const VcsHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.vcs">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/vcs.js

@@ -0,0 +1,19 @@
+import { Vcs } from "@opencode/core/vcs";
+import { ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+export const VcsHandler = HttpApiBuilder.group(Api, "server.vcs", (handlers) => Effect.gen(function* () {
+  return handlers.handle("vcs.get", () => response(Effect.gen(function* () {
+    return yield* (yield* Vcs.Service).info();
+  }))).handle("vcs.base", () => response(Effect.gen(function* () {
+    return yield* (yield* Vcs.Service).base().pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));
+  }))).handle("vcs.status", () => response(Effect.gen(function* () {
+    return yield* (yield* Vcs.Service).status();
+  }))).handle("vcs.branches", (ctx) => response(Effect.gen(function* () {
+    return yield* (yield* Vcs.Service).branches({ search: ctx.query.search, limit: Math.min(ctx.query.limit ?? 50, 100) });
+  }))).handle("vcs.diff", (ctx) => response(Effect.gen(function* () {
+    return yield* (yield* Vcs.Service).diff(ctx.query.mode, { context: ctx.query.context, base: ctx.query.base }).pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));
+  })));
+}));

package/dist/handlers/websearch.d.ts

@@ -0,0 +1 @@
+export declare const WebSearchHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.websearch">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/websearch.js

@@ -0,0 +1,31 @@
+import { WebSearch } from "@opencode/core/websearch";
+import { InvalidRequestError, ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+export const WebSearchHandler = HttpApiBuilder.group(Api, "server.websearch", (handlers) => Effect.gen(function* () {
+  return handlers.handle("websearch.providers", Effect.fn("server.websearch.providers")(function* () {
+    const websearch = yield* WebSearch.Service;
+    return yield* response(websearch.providers());
+  })).handle("websearch.query", Effect.fn("server.websearch.query")(function* (request) {
+    const websearch = yield* WebSearch.Service;
+    return yield* response(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
+      })
+    })));
+  }));
+}));

package/dist/handlers/workspace.d.ts

@@ -0,0 +1,2 @@
+import { Workspace } from "@opencode/core/workspace";
+export declare const WorkspaceHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.workspace">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | Workspace.Service>;

package/dist/handlers/workspace.js

@@ -0,0 +1,20 @@
+import { Workspace } from "@opencode/core/workspace";
+import { ConflictError, ProviderNotFoundError, UnknownError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+export const WorkspaceHandler = HttpApiBuilder.group(Api, "server.workspace", (handlers) => Effect.gen(function* () {
+  const workspace = yield* Workspace.Service;
+  return handlers.handle("workspace.create", (ctx) => workspace.create(ctx.payload).pipe(Effect.map((workspaceID) => ({ data: workspaceID })), Effect.catchTags({
+    "Workspace.CreateConflict": (error) => new ConflictError({
+      resource: error.workspaceID,
+      message: `Workspace ${error.workspaceID} already uses provider ${error.existingProvider}, not ${error.provider}`
+    }),
+    "WorkspaceDriver.ProviderNotFound": (error) => new ProviderNotFoundError({
+      providerID: error.provider,
+      message: `Workspace provider not found: ${error.provider}`
+    })
+  }))).handle("workspace.destroy", (ctx) => workspace.destroy(ctx.params.workspaceID).pipe(Effect.mapError((error) => new UnknownError({
+    message: error._tag === "WorkspaceDriver.ProviderNotFound" ? `Workspace provider not found: ${error.provider}` : error.message ?? "Workspace provider failed to destroy the workspace"
+  }))));
+}));

package/dist/handlers/worktree.d.ts

@@ -0,0 +1 @@
+export declare const WorktreeHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.worktree">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware>;

package/dist/handlers/worktree.js

@@ -0,0 +1,39 @@
+import { Git } from "@opencode/core/git";
+import { Worktree } from "@opencode/core/worktree";
+import { Plugin } from "@opencode/core/plugin";
+import { WorktreeError } from "@opencode/protocol/groups/worktree";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { Api } from "../api";
+export const WorktreeHandler = HttpApiBuilder.group(Api, "server.worktree", (handlers) => handlers.handle("worktree.list", () => run((worktrees) => worktrees.list())).handle("worktree.create", (ctx) => run((worktrees) => worktrees.create(ctx.payload))).handle("worktree.remove", (ctx) => run((worktrees) => worktrees.remove(ctx.payload)).pipe(Effect.as(HttpApiSchema.NoContent.make()))).handle("worktree.refresh", () => run((worktrees) => worktrees.refresh()).pipe(Effect.as(HttpApiSchema.NoContent.make()))));
+function run(action) {
+  return Effect.gen(function* () {
+    const plugins = yield* Plugin.Service, worktrees = yield* Worktree.Service;
+    yield* plugins.awaitActivation;
+    return yield* action(worktrees);
+  }).pipe(badRequest);
+}
+function badRequest(effect) {
+  return effect.pipe(Effect.mapError((error) => new WorktreeError({
+    name: "WorktreeError",
+    data: {
+      message: message(error),
+      forceRequired: error instanceof Git.WorktreeError || error instanceof Worktree.OperationError ? error.forceRequired : void 0
+    }
+  })));
+}
+function message(error) {
+  if (error instanceof Worktree.SourceDirectoryNotFoundError)
+    return error.directory ? `Worktree source not found: ${error.directory}` : `Worktree source not found for project: ${error.projectID}`;
+  if (error instanceof Worktree.DestinationExistsError)
+    return `Worktree destination already exists: ${error.directory}`;
+  if (error instanceof Worktree.DirectoryUnavailableError)
+    return `Worktree directory unavailable: ${error.directory}`;
+  if (error instanceof Worktree.InvalidDirectoryError)
+    return `Invalid worktree directory: ${error.directory}`;
+  if (error instanceof Worktree.StrategyUnavailableError)
+    return `Worktree strategy unavailable: ${error.strategy}`;
+  if (error instanceof Worktree.UnsupportedLocationError)
+    return "Worktree operations only support local locations";
+  return error.message;
+}

package/dist/handlers.d.ts

@@ -0,0 +1,2 @@
+import { Layer } from "effect";
+export declare const handlers: Layer.Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.generate"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.message"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.model"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.provider"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.session"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.permission"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.fs"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.form"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.command"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.skill"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.rpc"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.event"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.agent"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.plugin"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.health"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.server"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.debug"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.pty"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.experimental"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.shell"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.reference"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.location"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.integration"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.websearch"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.mcp"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.credential"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.project"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.worktree"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.vcs"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.migration"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.config"> | import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.workspace">, never, import("@opencode/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode/protocol/middleware/authorization").Authorization | import("@opencode/util/global").Service | import("@opencode/core/bus").Service | import("@opencode/core/workspace").Service | import("@opencode/core/persistent-pty/index").Service | import("@opencode/core/location-service-map").Service | import("@opencode/core/session").Service | import("@opencode/core/instance").Service | import("./location").LocationMiddleware | import("./middleware/form-location").FormLocationMiddleware | import("./middleware/session-location").SessionLocationMiddleware | import("@opencode/core/pty/ticket").Service | import("@opencode/core/session/transfer").Service | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/database/database").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/permission/saved").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/plugin/update").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("./server-info").Service> | import("./pty-environment").Service | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/wellknown").Service> | import("effect/unstable/http/HttpRouter").Request<"Requires", import("@opencode/core/project").Service>>;

package/dist/handlers.js

@@ -0,0 +1,35 @@
+import { Layer } from "effect";
+import { GenerateHandler } from "./handlers/generate";
+import { MessageHandler } from "./handlers/message";
+import { ModelHandler } from "./handlers/model";
+import { ProviderHandler } from "./handlers/provider";
+import { SessionHandler } from "./handlers/session";
+import { PermissionHandler } from "./handlers/permission";
+import { FileSystemHandler } from "./handlers/fs";
+import { FormHandler } from "./handlers/form";
+import { CommandHandler } from "./handlers/command";
+import { SkillHandler } from "./handlers/skill";
+import { RpcHandler } from "./handlers/rpc";
+import { EventHandler } from "./handlers/event";
+import { AgentHandler } from "./handlers/agent";
+import { PluginHandler } from "./handlers/plugin";
+import { HealthHandler } from "./handlers/health";
+import { ServerHandler } from "./handlers/server";
+import { DebugHandler } from "./handlers/debug";
+import { PtyHandler } from "./handlers/pty";
+import { PersistentPtyHandler } from "./handlers/persistent-pty";
+import { ShellHandler } from "./handlers/shell";
+import { ReferenceHandler } from "./handlers/reference";
+import { LocationHandler } from "./handlers/location";
+import { IntegrationHandler } from "./handlers/integration";
+import { WebSearchHandler } from "./handlers/websearch";
+import { McpHandler } from "./handlers/mcp";
+import { CredentialHandler } from "./handlers/credential";
+import { ProjectHandler } from "./handlers/project";
+import { WorktreeHandler } from "./handlers/worktree";
+import { VcsHandler } from "./handlers/vcs";
+import { EventFeed } from "./event-feed";
+import { MigrationHandler } from "./handlers/migration";
+import { ConfigHandler } from "./handlers/config";
+import { WorkspaceHandler } from "./handlers/workspace";
+export const handlers = Layer.mergeAll(HealthHandler, ServerHandler, DebugHandler, MigrationHandler, LocationHandler, AgentHandler, PluginHandler, SessionHandler, MessageHandler, ModelHandler, GenerateHandler, ProviderHandler, IntegrationHandler, WebSearchHandler, McpHandler, CredentialHandler, ProjectHandler, FormHandler, PermissionHandler, FileSystemHandler, CommandHandler, SkillHandler, RpcHandler, EventHandler.pipe(Layer.provide(EventFeed.layer)), PtyHandler, PersistentPtyHandler, ShellHandler, ReferenceHandler, WorktreeHandler, WorkspaceHandler, VcsHandler, ConfigHandler);

package/dist/location.d.ts

@@ -0,0 +1,26 @@
+import { Location } from "@opencode/core/location";
+import { LocationServiceMap } from "@opencode/core/location-services";
+import { Session } from "@opencode/core/session";
+import { InvalidRequestError } from "@opencode/protocol/errors";
+import { Effect, Layer } from "effect";
+import { HttpServerRequest } from "effect/unstable/http";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+export type LocationServices = Layer.Success<ReturnType<(typeof LocationServiceMap.Service)["get"]>>;
+declare const LocationMiddleware_base: HttpApiMiddleware.ServiceClass<LocationMiddleware, "@opencode/HttpApiLocation", {
+    requires: never;
+    provides: import("@opencode/core/instance").Services;
+    error: never;
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<import("@opencode/core/instance").Services, never, never>>;
+export declare class LocationMiddleware extends LocationMiddleware_base {
+}
+export declare function response<A, E, R>(data: Effect.Effect<A, E, R>): Effect.Effect<{
+    location: Location.Info;
+    data: A;
+}, E, Location.Service | R>;
+export declare const sessionInfo: (sessions: Session.Interface, sessionID: unknown) => Effect.Effect<Session.SessionSchema.Info, InvalidRequestError | import("@opencode/protocol/errors").SessionNotFoundError, never>;
+export declare function requestRef(request: HttpServerRequest.HttpServerRequest): Location.Ref;
+export declare const layer: Layer.Layer<LocationMiddleware, never, LocationServiceMap.Service>;
+export {};

package/dist/location.js

@@ -0,0 +1,52 @@
+import { Location } from "@opencode/core/location";
+import { LocationServiceMap } from "@opencode/core/location-services";
+import { AbsolutePath } from "@opencode/core/schema";
+import { Session } from "@opencode/core/session";
+import { Workspace } from "@opencode/core/workspace";
+import { InvalidRequestError } from "@opencode/protocol/errors";
+import { Effect, Layer, Schema } from "effect";
+import { HttpServerRequest } from "effect/unstable/http";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { missingSession } from "./handlers/session-error";
+
+export class LocationMiddleware extends HttpApiMiddleware.Service()("@opencode/HttpApiLocation") {
+}
+export function response(data) {
+  return Effect.gen(function* () {
+    const location = yield* Location.Service;
+    return {
+      location: new Location.Info({
+        directory: location.directory,
+        workspaceID: location.workspaceID,
+        project: location.project
+      }),
+      data: yield* data
+    };
+  });
+}
+const decodeSessionID = Schema.decodeUnknownEffect(Session.ID);
+export const sessionInfo = Effect.fnUntraced(function* (sessions, sessionID) {
+  const id = yield* decodeSessionID(sessionID).pipe(Effect.mapError(() => new InvalidRequestError({ message: "Invalid session ID", field: "sessionID" })));
+  return yield* sessions.get(id).pipe(Effect.catchTag("Session.NotFoundError", missingSession));
+});
+export function requestRef(request) {
+  const query = new URL(request.url, "http://localhost").searchParams, workspaceID = query.get("location[workspace]") || request.headers["x-opencode-workspace"], directory = query.get("location[directory]") || (request.headers["x-opencode-directory"] ? decode(request.headers["x-opencode-directory"]) : process.cwd());
+  return Location.Ref.make({
+    directory: AbsolutePath.make(directory),
+    workspaceID: workspaceID ? Workspace.ID.make(workspaceID) : void 0
+  });
+}
+function decode(input) {
+  try {
+    return decodeURIComponent(input);
+  } catch {
+    return input;
+  }
+}
+export const layer = Layer.effect(LocationMiddleware, Effect.gen(function* () {
+  const locations = yield* LocationServiceMap.Service;
+  return LocationMiddleware.of((effect) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    return yield* effect.pipe(Effect.provide(locations.get(requestRef(request))));
+  }));
+}));

package/dist/middleware/authorization.d.ts

@@ -0,0 +1,7 @@
+import { ServerAuth } from "../auth";
+import { Authorization } from "@opencode/protocol/middleware/authorization";
+export { Authorization } from "@opencode/protocol/middleware/authorization";
+import { Effect, Layer } from "effect";
+import { HttpServerRequest } from "effect/unstable/http";
+export declare function authorizedRequest(request: HttpServerRequest.HttpServerRequest, config: ServerAuth.Info): Effect.Effect<boolean, never, never>;
+export declare const authorizationLayer: Layer.Layer<Authorization, never, ServerAuth.Config>;