@opencode-ai/server 0.0.0-dev-17880

package/dist/api.js

@@ -0,0 +1,9 @@
+import { makeDefaultApi } from "@opencode-ai/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
+});

package/dist/auth.d.ts

@@ -0,0 +1,17 @@
+export * as ServerAuth from "./auth";
+import { Context, Layer, Option, Redacted } from "effect";
+export type DecodedCredentials = {
+    readonly username: string;
+    readonly password: Redacted.Redacted;
+};
+export type Info = {
+    readonly password: Option.Option<string>;
+    readonly username: string;
+};
+declare const Config_base: Context.ServiceClass<Config, "@opencode/ServerAuthConfig", Info>;
+export declare class Config extends Config_base {
+    static configLayer(input: Pick<Info, "password">): Layer.Layer<Config, never, never>;
+    static get layer(): Layer.Layer<Config, never, never>;
+}
+export declare function required(config: Info): boolean;
+export declare function authorized(credentials: DecodedCredentials, config: Info): boolean;

package/dist/auth.js

@@ -0,0 +1,17 @@
+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;
+}

package/dist/cors.d.ts

@@ -0,0 +1,7 @@
+import { Context } from "effect";
+export type CorsOptions = {
+    readonly cors?: ReadonlyArray<string>;
+};
+export declare const CorsConfig: Context.Reference<CorsOptions | undefined>;
+export declare function isAllowedCorsOrigin(input: string | undefined, opts?: CorsOptions): boolean;
+export declare function isAllowedRequestOrigin(input: string | undefined, host: string | undefined, opts?: CorsOptions): boolean;

package/dist/cors.js

@@ -0,0 +1,36 @@
+import { Context } from "effect";
+const opencodeOrigin = /^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/;
+export const CorsConfig = Context.Reference("@opencode/ServerCorsConfig", {
+  defaultValue: () => {
+    return;
+  }
+});
+export function isAllowedCorsOrigin(input, opts) {
+  if (!input)
+    return !0;
+  if (input.startsWith("http://localhost:"))
+    return !0;
+  if (input.startsWith("http://127.0.0.1:"))
+    return !0;
+  if (input.startsWith("oc://renderer"))
+    return !0;
+  if (input === "tauri://localhost" || input === "http://tauri.localhost" || input === "https://tauri.localhost")
+    return !0;
+  if (opencodeOrigin.test(input))
+    return !0;
+  return opts?.cors?.includes(input) ?? !1;
+}
+export function isAllowedRequestOrigin(input, host, opts) {
+  if (!input)
+    return !0;
+  if (host && sameHost(input, host))
+    return !0;
+  return isAllowedCorsOrigin(input, opts);
+}
+function sameHost(origin, host) {
+  try {
+    return new URL(origin).host === host;
+  } catch {
+    return !1;
+  }
+}

package/dist/event-feed.d.ts

@@ -0,0 +1,32 @@
+export * as EventFeed from "./event-feed";
+import { Bus } from "@opencode-ai/core/bus";
+import { type OpenCodeEvent } from "@opencode-ai/protocol/groups/event";
+import { Cause, Context, Effect, Layer, Schema, Scope, Stream } from "effect";
+export declare const SubscriberCapacity = 4096;
+declare const SubscriberOverflowError_base: Schema.Class<SubscriberOverflowError, Schema.TaggedStruct<"EventFeed.SubscriberOverflow", {
+    readonly capacity: Schema.Int;
+}>, Cause.YieldableError>;
+export declare class SubscriberOverflowError extends SubscriberOverflowError_base {
+}
+declare const EncodingError_base: Schema.Class<EncodingError, Schema.TaggedStruct<"EventFeed.EncodingError", {
+    readonly eventID: Schema.brand<Schema.String, "Event.ID"> & {
+        create: () => string & import("effect/Brand").Brand<"Event.ID">;
+    };
+    readonly eventType: Schema.String;
+    readonly cause: Schema.Defect;
+}>, Cause.YieldableError>;
+export declare class EncodingError extends EncodingError_base {
+}
+export type Error = SubscriberOverflowError | EncodingError;
+export interface Interface {
+    readonly subscribe: Effect.Effect<Stream.Stream<string, Error>, never, Scope.Scope>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/server/EventFeed", Interface>;
+export declare class Service extends Service_base {
+}
+export declare function frame(event: OpenCodeEvent): string;
+export declare const make: (observe: (subscriber: Bus.Subscriber) => Effect.Effect<Bus.Unsubscribe>, options?: {
+    readonly capacity?: number;
+    readonly encode?: (event: OpenCodeEvent) => string;
+} | undefined) => Effect.Effect<Interface, never, Scope.Scope>;
+export declare const layer: Layer.Layer<Service, never, Bus.Service>;

package/dist/event-feed.js

@@ -0,0 +1,60 @@
+export * as EventFeed from "./event-feed";
+import { Bus } from "@opencode-ai/core/bus";
+import { Event } from "@opencode-ai/schema/event";
+import { isOpenCodeEvent } from "@opencode-ai/protocol/groups/event";
+import { Cause, Context, Effect, Layer, Queue, Schema, Scope, Stream } from "effect";
+export const SubscriberCapacity = 4096;
+
+export class SubscriberOverflowError extends Schema.TaggedError()("EventFeed.SubscriberOverflow", { capacity: Schema.Int }) {
+}
+
+export class EncodingError extends Schema.TaggedError()("EventFeed.EncodingError", {
+  eventID: Event.ID,
+  eventType: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+
+export class Service extends Context.Service()("@opencode/server/EventFeed") {
+}
+export function frame(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+export const make = Effect.fn("EventFeed.make")(function* (observe, options) {
+  const capacity = options?.capacity ?? SubscriberCapacity, render = options?.encode ?? frame, subscribers = new Set, fail = (error) => Effect.sync(() => {
+    const current = Array.from(subscribers);
+    subscribers.clear();
+    for (const subscriber of current)
+      Queue.failCauseUnsafe(subscriber, Cause.fail(error));
+  }), 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 EncodingError({ 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(void 0))));
+    if (encoded === void 0)
+      return;
+    for (const subscriber of subscribers) {
+      if (Queue.offerUnsafe(subscriber, encoded))
+        continue;
+      subscribers.delete(subscriber);
+      Queue.failCauseUnsafe(subscriber, Cause.fail(new SubscriberOverflowError({ capacity })));
+    }
+  }), unsubscribe = yield* observe(publish);
+  yield* Effect.addFinalizer(() => unsubscribe);
+  return Service.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))
+  });
+}), layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* Bus.Service;
+  return yield* make(bus.listen);
+}));

package/dist/fetch.d.ts

@@ -0,0 +1,68 @@
+export * as ServerFetch from "./fetch";
+import { Context, Effect } from "effect";
+import type { LayerNode } from "@opencode-ai/util/effect/layer-node";
+export interface BootOptions {
+    /**
+     * Runtime-profile service replacements, applied after the standard set so later entries
+     * win — swaps services the standard graph assumes are local. See `ServerWorkerd.replacements`.
+     */
+    readonly overrides?: LayerNode.Replacements;
+}
+/**
+ * Builds a web-standard fetch handler — `(request: Request) => Promise<Response>` — serving the
+ * same HttpApi routes as the Node server process without binding a port, owning a listener, or
+ * installing signal handlers. This is the entry for runtimes that hand requests to the embedder
+ * instead of letting it listen: workerd (Workers and Durable Objects), Deno.serve, Bun.serve, or
+ * a test harness.
+ *
+ * The application layer builds EAGERLY, inside the caller's `Scope`, before the handler is
+ * returned. Do not convert this to a lazy first-request build: on workerd, a first request that
+ * aborts mid-build interrupts the layer construction and wedges every subsequent request
+ * (Effect-TS/effect#6319 class). The embedder owns the lifecycle — closing the scope releases
+ * the application layer.
+ *
+ * Auth follows `createRoutes` semantics: `options.password` enforces Basic auth; omitting it
+ * serves unauthenticated, so an embedder without a password must front the handler with its own
+ * access control.
+ *
+ * Sessions whose execution claim was never released resume once the layer is built, exactly as
+ * the Node server process does: a runtime that dies without teardown — an evicted Durable
+ * Object leaves the same durable signature as a killed process — replays orphaned turns on the
+ * next boot, and the sweep is a no-op when nothing is suspended.
+ */
+export declare const make: (options?: {
+    readonly events?: {
+        readonly persist?: boolean | undefined;
+    } | undefined;
+    readonly models?: {
+        readonly url?: string | undefined;
+        readonly file?: string | undefined;
+        readonly snapshot?: boolean | undefined;
+        readonly fetch?: boolean | undefined;
+    } | undefined;
+    readonly config?: {
+        readonly directory?: string | undefined;
+        readonly project?: boolean | undefined;
+        readonly content?: string | undefined;
+        readonly file?: string | undefined;
+    } | undefined;
+    readonly hostname?: string | undefined;
+    readonly windows?: {
+        readonly gitbash?: string | undefined;
+    } | undefined;
+    readonly port?: number | undefined;
+    readonly app?: {
+        readonly version?: string | undefined;
+        readonly name?: string | undefined;
+        readonly channel?: string | undefined;
+    } | undefined;
+    readonly fs?: {
+        readonly fff?: boolean | undefined;
+        readonly filewatcher?: boolean | undefined;
+    } | undefined;
+    readonly password?: string | undefined;
+    readonly simulation?: boolean | undefined;
+    readonly database?: {
+        readonly path?: string | undefined;
+    } | undefined;
+} | undefined, boot?: BootOptions | undefined) => Effect.Effect<(request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response>, Error, import("effect/Scope").Scope>;

package/dist/fetch.js

@@ -0,0 +1,11 @@
+export * as ServerFetch from "./fetch";
+import { Context, Effect, Layer } from "effect";
+import { HttpEffect, HttpMiddleware, HttpRouter, HttpServer } from "effect/unstable/http";
+import { SessionRestart } from "@opencode-ai/core/session/execution/restart";
+import { isAllowedCorsOrigin } from "./cors";
+import { createRoutes } from "./routes";
+export const make = Effect.fn("ServerFetch.make")(function* (options = {}, boot = {}) {
+  const context = yield* Layer.build(createRoutes(options, () => [], boot.overrides ?? []).pipe(Layer.provide(HttpServer.layerServices)));
+  yield* Effect.forkDetach(Context.get(context, SessionRestart.Service).resumeSuspendedSessions);
+  return Context.get(context, HttpRouter.HttpRouter).asHttpEffect().pipe(HttpMiddleware.cors({ allowedOrigins: isAllowedCorsOrigin, maxAge: 86400 }), HttpEffect.toWebHandlerWith(context));
+});

package/dist/handlers/agent.d.ts

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

package/dist/handlers/agent.js

@@ -0,0 +1,17 @@
+import { Agent } from "@opencode-ai/core/agent";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+import { AgentNotFoundError } from "@opencode-ai/protocol/errors";
+export const AgentHandler = HttpApiBuilder.group(Api, "server.agent", (handlers) => handlers.handle("agent.list", () => Effect.gen(function* () {
+  return yield* response(Agent.Service.use((agent) => agent.list()));
+})).handle("agent.get", Effect.fn(function* (ctx) {
+  const agent = yield* Agent.Service.use((service) => service.get(ctx.params.agentID));
+  if (!agent)
+    return yield* new AgentNotFoundError({
+      agentID: ctx.params.agentID,
+      message: `Agent not found: ${ctx.params.agentID}`
+    });
+  return yield* response(Effect.succeed(agent));
+})));

package/dist/handlers/command.d.ts

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

package/dist/handlers/command.js

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

package/dist/handlers/config.d.ts

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

package/dist/handlers/config.js

@@ -0,0 +1,4 @@
+import { Config } from "@opencode-ai/core/config";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+export const ConfigHandler = HttpApiBuilder.group(Api, "server.config", (handlers) => handlers.handle("config.get", () => Config.Service.use((config) => config.entries())));

package/dist/handlers/credential.d.ts

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

package/dist/handlers/credential.js

@@ -0,0 +1,11 @@
+import { Integration } from "@opencode-ai/core/integration";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { Api } from "../api";
+export const CredentialHandler = HttpApiBuilder.group(Api, "server.credential", (handlers) => handlers.handle("credential.update", Effect.fn(function* (ctx) {
+  yield* (yield* Integration.Service).connection.update(ctx.params.credentialID, { label: ctx.payload.label });
+  return HttpApiSchema.NoContent.make();
+})).handle("credential.remove", Effect.fn(function* (ctx) {
+  yield* (yield* Integration.Service).connection.remove(ctx.params.credentialID);
+  return HttpApiSchema.NoContent.make();
+})));

package/dist/handlers/debug.d.ts

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

package/dist/handlers/debug.js

@@ -0,0 +1,11 @@
+import { LocationServiceMap } from "@opencode-ai/core/location-service-map";
+import { Effect, Option, RcMap } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { requestRef } from "../location";
+export const DebugHandler = HttpApiBuilder.group(Api, "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) {
+  yield* Option.getOrThrow(yield* Effect.serviceOption(LocationServiceMap.Service)).invalidate(requestRef(ctx.request));
+})));

package/dist/handlers/event.d.ts

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

package/dist/handlers/event.js

@@ -0,0 +1,27 @@
+import { Bus } from "@opencode-ai/core/bus";
+import { Event } from "@opencode-ai/schema/event";
+import { Effect, Stream } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { EventFeed } from "../event-feed";
+export const EventHandler = HttpApiBuilder.group(Api, "server.event", (handlers) => Effect.gen(function* () {
+  const feed = yield* EventFeed.Service;
+  return handlers.handleRaw("event.subscribe", () => Effect.gen(function* () {
+    const connected = {
+      id: Event.ID.create(),
+      type: "server.connected",
+      data: {}
+    }, output = Stream.unwrap(feed.subscribe.pipe(Effect.map((live) => Stream.make(EventFeed.frame(connected)).pipe(Stream.concat(live))))), heartbeat = Stream.tick("15 seconds").pipe(Stream.map(() => `: heartbeat
+
+`));
+    return HttpServerResponse.stream(output.pipe(Stream.merge(heartbeat, { haltStrategy: "left" }), Stream.encodeText), {
+      contentType: "text/event-stream",
+      headers: {
+        "Cache-Control": "no-cache, no-transform",
+        "X-Accel-Buffering": "no",
+        "X-Content-Type-Options": "nosniff"
+      }
+    });
+  }));
+}));

package/dist/handlers/form.d.ts

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

package/dist/handlers/form.js

@@ -0,0 +1,57 @@
+import { Form } from "@opencode-ai/core/form";
+import {
+  ConflictError,
+  FormAlreadySettledError,
+  FormInvalidAnswerError,
+  FormNotFoundError,
+  InvalidRequestError
+} from "@opencode-ai/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+function missingForm(id) {
+  return new FormNotFoundError({ id, message: `Form not found: ${id}` });
+}
+export const FormHandler = HttpApiBuilder.group(Api, "server.form", (handlers) => Effect.gen(function* () {
+  const requireOwnedForm = Effect.fnUntraced(function* (sessionID, formID) {
+    const form = yield* Form.Service, info = yield* form.get(formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(formID)));
+    if (info.sessionID !== sessionID)
+      return yield* missingForm(formID);
+    return { form, info };
+  });
+  return handlers.handle("form.request.list", Effect.fn(function* () {
+    const form = yield* Form.Service;
+    return yield* response(form.list());
+  })).handle("session.form.list", Effect.fn(function* (ctx) {
+    return { data: yield* (yield* Form.Service).list({ sessionID: ctx.params.sessionID }) };
+  })).handle("session.form.create", Effect.fn(function* (ctx) {
+    return { data: yield* (yield* Form.Service).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" })
+    })) };
+  })).handle("session.form.get", Effect.fn(function* (ctx) {
+    return { data: (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).info };
+  })).handle("session.form.state", Effect.fn(function* (ctx) {
+    return { data: yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).form.state(ctx.params.formID).pipe(Effect.catchTag("Form.NotFoundError", () => missingForm(ctx.params.formID))) };
+  })).handle("session.form.reply", Effect.fn(function* (ctx) {
+    yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).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) {
+    yield* (yield* requireOwnedForm(ctx.params.sessionID, ctx.params.formID)).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();
+  }));
+}));

package/dist/handlers/fs.d.ts

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

package/dist/handlers/fs.js

@@ -0,0 +1,19 @@
+import { FileSystem } from "@opencode-ai/core/filesystem";
+import { RelativePath } from "@opencode-ai/core/schema";
+import { Effect } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { response } from "../location";
+export const FileSystemHandler = HttpApiBuilder.group(Api, "server.fs", (handlers) => Effect.gen(function* () {
+  return handlers.handleRaw("fs.read", (ctx) => Effect.gen(function* () {
+    const file = yield* (yield* FileSystem.Service).read({
+      path: RelativePath.make(decodeURIComponent(new URL(ctx.request.url, "http://localhost").pathname.slice(13)))
+    });
+    return HttpServerResponse.uint8Array(file.content, { contentType: file.mime });
+  })).handle("fs.list", (ctx) => response(Effect.gen(function* () {
+    return yield* (yield* FileSystem.Service).list(ctx.query);
+  }))).handle("fs.find", (ctx) => response(Effect.gen(function* () {
+    return yield* (yield* FileSystem.Service).find(ctx.query);
+  })));
+}));

package/dist/handlers/generate.d.ts

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

package/dist/handlers/generate.js

@@ -0,0 +1,10 @@
+import { Generate } from "@opencode-ai/core/generate";
+import { InvalidRequestError, ServiceUnavailableError } from "@opencode-ai/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+export const GenerateHandler = HttpApiBuilder.group(Api, "server.generate", (handlers) => Effect.gen(function* () {
+  return handlers.handle("generate.text", Effect.fn("server.generate.text")(function* (request) {
+    return { data: { text: yield* (yield* Generate.Service).text(request.payload).pipe(Effect.mapError((error) => error._tag === "Generate.ModelSelectionError" ? new InvalidRequestError({ message: error.message }) : new ServiceUnavailableError({ message: error.message, service: error.service }))) } };
+  }));
+}));

package/dist/handlers/health.d.ts

@@ -0,0 +1,2 @@
+import { ServerInfo } from "../server-info";
+export declare const HealthHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.health">, never, import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("effect/unstable/http/HttpRouter").Request<"Requires", ServerInfo.Service>>;

package/dist/handlers/health.js

@@ -0,0 +1,11 @@
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { ServerInfo } from "../server-info";
+export const HealthHandler = HttpApiBuilder.group(Api, "server.health", (handlers) => handlers.handle("health.get", () => Effect.gen(function* () {
+  return {
+    healthy: !0,
+    version: (yield* ServerInfo.Service).app.version ?? "unknown",
+    pid: process.pid ?? 0
+  };
+})));

package/dist/handlers/integration.d.ts

@@ -0,0 +1,2 @@
+import { WellKnown } from "@opencode-ai/core/wellknown";
+export declare const IntegrationHandler: import("effect/Layer").Layer<import("effect/unstable/httpapi/HttpApiGroup").Service<"server", "server.integration">, never, import("effect/unstable/http/HttpRouter").Request<"Requires", WellKnown.Service> | (import("@opencode-ai/protocol/middleware/schema-error").SchemaErrorMiddleware | import("@opencode-ai/protocol/middleware/authorization").Authorization | import("../location").LocationMiddleware)>;

package/dist/handlers/integration.js

@@ -0,0 +1,83 @@
+import { Integration } from "@opencode-ai/core/integration";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { Api } from "../api";
+import { InvalidRequestError } from "@opencode-ai/protocol/errors";
+import { response } from "../location";
+import { WellKnown } from "@opencode-ai/core/wellknown";
+const authorize = (effect) => effect.pipe(Effect.mapError(() => new InvalidRequestError({
+  message: "Authentication failed",
+  kind: "integration_authorization"
+})));
+export const IntegrationHandler = HttpApiBuilder.group(Api, "server.integration", (handlers) => Effect.gen(function* () {
+  return handlers.handle("integration.list", Effect.fn(function* () {
+    const service = yield* Integration.Service;
+    return yield* response(service.list());
+  })).handle("integration.get", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    return yield* response(service.get(ctx.params.integrationID));
+  })).handle("integration.wellknown.add", Effect.fn(function* (ctx) {
+    const wellknown = yield* WellKnown.Service, integration = yield* Integration.Service;
+    yield* wellknown.add(ctx.payload.url).pipe(Effect.mapError((error) => new InvalidRequestError({ message: error.message, kind: "well_known_discovery" })));
+    yield* integration.reload();
+    return HttpApiSchema.NoContent.make();
+  })).handle("integration.connect.key", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    yield* authorize(service.connection.key({
+      integrationID: ctx.params.integrationID,
+      key: ctx.payload.key,
+      answer: ctx.payload.answer,
+      label: ctx.payload.label
+    }));
+    return HttpApiSchema.NoContent.make();
+  })).handle("integration.oauth.connect", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    return yield* response(authorize(service.oauth.connect({
+      integrationID: ctx.params.integrationID,
+      methodID: ctx.payload.methodID,
+      answer: ctx.payload.answer,
+      label: ctx.payload.label
+    })));
+  })).handle("integration.oauth.status", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    return yield* response(service.oauth.status({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID
+    }));
+  })).handle("integration.oauth.complete", Effect.fn(function* (ctx) {
+    yield* (yield* Integration.Service).oauth.complete({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID,
+      code: ctx.payload.code
+    }).pipe(Effect.mapError((error) => new InvalidRequestError({
+      message: error._tag === "Integration.CodeRequired" ? "Authorization code is required" : "Authentication failed",
+      kind: error._tag === "Integration.CodeRequired" ? "integration_code_required" : "integration_authorization"
+    })));
+    return HttpApiSchema.NoContent.make();
+  })).handle("integration.oauth.cancel", Effect.fn(function* (ctx) {
+    yield* (yield* Integration.Service).oauth.cancel({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID
+    });
+    return HttpApiSchema.NoContent.make();
+  })).handle("integration.command.connect", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    return yield* response(authorize(service.command.connect({
+      integrationID: ctx.params.integrationID,
+      methodID: ctx.payload.methodID,
+      label: ctx.payload.label
+    })));
+  })).handle("integration.command.status", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    return yield* response(service.command.status({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID
+    }));
+  })).handle("integration.command.cancel", Effect.fn(function* (ctx) {
+    yield* (yield* Integration.Service).command.cancel({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID
+    });
+    return HttpApiSchema.NoContent.make();
+  }));
+}));

package/dist/handlers/location.d.ts

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

package/dist/handlers/location.js

@@ -0,0 +1,12 @@
+import { Location } from "@opencode-ai/core/location";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Api } from "../api";
+export const LocationHandler = HttpApiBuilder.group(Api, "server.location", (handlers) => handlers.handle("location.get", Effect.fn(function* () {
+  const location = yield* Location.Service;
+  return new Location.Info({
+    directory: location.directory,
+    workspaceID: location.workspaceID,
+    project: location.project
+  });
+})));

package/dist/handlers/mcp.d.ts

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