@opencode/server 0.0.0-reserved → 2.0.1

package/dist/middleware/authorization.js

@@ -0,0 +1,49 @@
+import { ServerAuth } from "../auth";
+import { UnauthorizedError } from "@opencode/protocol/errors";
+import { Authorization } from "@opencode/protocol/middleware/authorization";
+export { Authorization } from "@opencode/protocol/middleware/authorization";
+import { hasPtyConnectTicketURL } from "@opencode/protocol/groups/pty";
+import { hasPersistentPtyConnectTicketURL } from "@opencode/protocol/groups/persistent-pty";
+import { Effect, Encoding, Layer, Redacted } from "effect";
+import { HttpEffect, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+const AUTH_TOKEN_QUERY = "auth_token", WWW_AUTHENTICATE = 'Basic realm="Secure Area"';
+function emptyCredential() {
+  return { username: "", password: Redacted.make("") };
+}
+function decodeCredential(input) {
+  return Effect.fromResult(Encoding.decodeBase64String(input)).pipe(Effect.match({
+    onFailure: emptyCredential,
+    onSuccess: (header) => {
+      const separator = header.indexOf(":");
+      if (separator === -1)
+        return emptyCredential();
+      return { username: header.slice(0, separator), password: Redacted.make(header.slice(separator + 1)) };
+    }
+  }));
+}
+function credentialFromRequest(request) {
+  const token = new URL(request.url, "http://localhost").searchParams.get(AUTH_TOKEN_QUERY);
+  if (token)
+    return decodeCredential(token);
+  const match = /^Basic\s+(.+)$/i.exec(request.headers.authorization ?? "");
+  if (match)
+    return decodeCredential(match[1]);
+  return Effect.succeed(emptyCredential());
+}
+export function authorizedRequest(request, config) {
+  return credentialFromRequest(request).pipe(Effect.map((credential) => ServerAuth.authorized(credential, config)));
+}
+export const authorizationLayer = Layer.effect(Authorization, Effect.gen(function* () {
+  const config = yield* ServerAuth.Config;
+  if (!ServerAuth.required(config))
+    return Authorization.of((effect) => effect);
+  return Authorization.of((effect) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest, url = new URL(request.url, "http://localhost");
+    if (hasPtyConnectTicketURL(url) || hasPersistentPtyConnectTicketURL(url))
+      return yield* effect;
+    if (yield* authorizedRequest(request, config))
+      return yield* effect;
+    yield* HttpEffect.appendPreResponseHandler((_request, response) => Effect.succeed(HttpServerResponse.setHeader(response, "www-authenticate", WWW_AUTHENTICATE)));
+    return yield* new UnauthorizedError({ message: "Authentication required" });
+  }));
+}));

package/dist/middleware/form-location.d.ts

@@ -0,0 +1,18 @@
+import { Instance } from "@opencode/core/instance/service";
+import { LocationServiceMap } from "@opencode/core/location-services";
+import { Session } from "@opencode/core/session";
+import { InvalidRequestError, SessionNotFoundError } from "@opencode/protocol/errors";
+import { Layer } from "effect";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+declare const FormLocationMiddleware_base: HttpApiMiddleware.ServiceClass<FormLocationMiddleware, "@opencode/HttpApiFormLocation", {
+    requires: never;
+    provides: Instance.Services;
+    error: readonly [typeof InvalidRequestError, typeof SessionNotFoundError];
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<Instance.Services, readonly [typeof InvalidRequestError, typeof SessionNotFoundError], never>>;
+export declare class FormLocationMiddleware extends FormLocationMiddleware_base {
+}
+export declare const formLocationLayer: Layer.Layer<FormLocationMiddleware, never, LocationServiceMap.Service | Session.Service | Instance.Service>;
+export {};

package/dist/middleware/form-location.js

@@ -0,0 +1,25 @@
+import { Instance } from "@opencode/core/instance/service";
+import { LocationServiceMap } from "@opencode/core/location-services";
+import { Session } from "@opencode/core/session";
+import { InvalidRequestError, SessionNotFoundError } from "@opencode/protocol/errors";
+import { Effect, Layer } from "effect";
+import { HttpRouter, HttpServerRequest } from "effect/unstable/http";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { requestRef, sessionInfo } from "../location";
+
+export class FormLocationMiddleware extends HttpApiMiddleware.Service()("@opencode/HttpApiFormLocation", {
+  error: [InvalidRequestError, SessionNotFoundError]
+}) {
+}
+export const formLocationLayer = Layer.effect(FormLocationMiddleware, Effect.gen(function* () {
+  const sessions = yield* Session.Service, instances = yield* Instance.Service, locations = yield* LocationServiceMap.Service;
+  return FormLocationMiddleware.of((effect) => Effect.gen(function* () {
+    const route = yield* HttpRouter.RouteContext;
+    if (route.params.sessionID === "global") {
+      const request = yield* HttpServerRequest.HttpServerRequest;
+      return yield* effect.pipe(Effect.provide(locations.get(requestRef(request))));
+    }
+    const session = yield* sessionInfo(sessions, route.params.sessionID);
+    return yield* effect.pipe(instances.provide(session));
+  }));
+}));

package/dist/middleware/schema-error.d.ts

@@ -0,0 +1,3 @@
+import { SchemaErrorMiddleware } from "@opencode/protocol/middleware/schema-error";
+export { SchemaErrorMiddleware } from "@opencode/protocol/middleware/schema-error";
+export declare const schemaErrorLayer: import("effect/Layer").Layer<SchemaErrorMiddleware, never, never>;

package/dist/middleware/schema-error.js

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

package/dist/middleware/session-location.d.ts

@@ -0,0 +1,17 @@
+import { Instance } from "@opencode/core/instance/service";
+import { Session } from "@opencode/core/session";
+import { Layer } from "effect";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { InvalidRequestError, SessionNotFoundError } from "@opencode/protocol/errors";
+declare const SessionLocationMiddleware_base: HttpApiMiddleware.ServiceClass<SessionLocationMiddleware, "@opencode/HttpApiSessionLocation", {
+    requires: never;
+    provides: Instance.Services;
+    error: readonly [typeof InvalidRequestError, typeof SessionNotFoundError];
+    clientError: never;
+    requiredForClient: false;
+    security: never;
+}, HttpApiMiddleware.HttpApiMiddleware<Instance.Services, readonly [typeof InvalidRequestError, typeof SessionNotFoundError], never>>;
+export declare class SessionLocationMiddleware extends SessionLocationMiddleware_base {
+}
+export declare const sessionLocationLayer: Layer.Layer<SessionLocationMiddleware, never, Session.Service | Instance.Service>;
+export {};

package/dist/middleware/session-location.js

@@ -0,0 +1,19 @@
+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";
+import { sessionInfo } from "../location";
+
+export class SessionLocationMiddleware extends HttpApiMiddleware.Service()("@opencode/HttpApiSessionLocation", {
+  error: [InvalidRequestError, SessionNotFoundError]
+}) {
+}
+export const sessionLocationLayer = Layer.effect(SessionLocationMiddleware, Effect.gen(function* () {
+  const sessions = yield* Session.Service, instances = yield* Instance.Service;
+  return SessionLocationMiddleware.of((effect) => Effect.gen(function* () {
+    const route = yield* HttpRouter.RouteContext, session = yield* sessionInfo(sessions, route.params.sessionID);
+    return yield* effect.pipe(instances.provide(session));
+  }));
+}));

package/dist/options.d.ts

@@ -0,0 +1,47 @@
+import { Schema } from "effect";
+export declare const ServerOptions: Schema.Struct<{
+    readonly app: Schema.optional<Schema.Struct<{
+        readonly name: Schema.optional<Schema.String>;
+        readonly version: Schema.optional<Schema.String>;
+        readonly channel: Schema.optional<Schema.String>;
+    }>>;
+    readonly hostname: Schema.optional<Schema.String>;
+    readonly port: Schema.optional<Schema.Int>;
+    readonly password: Schema.optional<Schema.String>;
+    readonly cors: Schema.optional<Schema.$Array<Schema.String>>;
+    readonly simulation: Schema.optional<Schema.Boolean>;
+    readonly database: Schema.optional<Schema.Struct<{
+        readonly path: Schema.optional<Schema.String>;
+    }>>;
+    readonly pty: Schema.optional<Schema.Struct<{
+        readonly handoff: Schema.optional<Schema.Struct<{
+            readonly directory: Schema.String;
+            readonly instanceID: Schema.String;
+            readonly ticket: Schema.String;
+            readonly expiresAt: Schema.Number;
+        }>>;
+    }>>;
+    readonly events: Schema.optional<Schema.Struct<{
+        readonly persist: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly models: Schema.optional<Schema.Struct<{
+        readonly url: Schema.optional<Schema.String>;
+        readonly file: Schema.optional<Schema.String>;
+        readonly fetch: Schema.optional<Schema.Boolean>;
+        readonly snapshot: Schema.optional<Schema.Boolean>;
+    }>>;
+    readonly config: Schema.optional<Schema.Struct<{
+        readonly directory: Schema.optional<Schema.String>;
+        readonly project: Schema.optional<Schema.Boolean>;
+        readonly file: Schema.optional<Schema.String>;
+        readonly content: Schema.optional<Schema.String>;
+    }>>;
+    readonly windows: Schema.optional<Schema.Struct<{
+        readonly gitbash: Schema.optional<Schema.String>;
+    }>>;
+    readonly fs: Schema.optional<Schema.Struct<{
+        readonly filewatcher: Schema.optional<Schema.Boolean>;
+        readonly fff: Schema.optional<Schema.Boolean>;
+    }>>;
+}>;
+export type ServerOptions = typeof ServerOptions.Type;

package/dist/options.js

@@ -0,0 +1,35 @@
+import { Database } from "@opencode/core/database/database";
+import { ModelsDev } from "@opencode/core/models-dev";
+import { PersistentPty } from "@opencode/core/persistent-pty";
+import { Schema } from "effect";
+export const ServerOptions = Schema.Struct({
+  app: Schema.optional(Schema.Struct({
+    name: Schema.optional(Schema.String),
+    version: Schema.optional(Schema.String),
+    channel: Schema.optional(Schema.String)
+  })),
+  hostname: Schema.optional(Schema.String),
+  port: Schema.optional(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(65535))),
+  password: Schema.optional(Schema.String),
+  cors: Schema.optional(Schema.Array(Schema.String)),
+  simulation: Schema.optional(Schema.Boolean),
+  database: Schema.optional(Database.Options),
+  pty: Schema.optional(PersistentPty.Options),
+  events: Schema.optional(Schema.Struct({
+    persist: Schema.optional(Schema.Boolean)
+  })),
+  models: Schema.optional(ModelsDev.Options),
+  config: Schema.optional(Schema.Struct({
+    directory: Schema.optional(Schema.String),
+    project: Schema.optional(Schema.Boolean),
+    file: Schema.optional(Schema.String),
+    content: Schema.optional(Schema.String)
+  })),
+  windows: Schema.optional(Schema.Struct({
+    gitbash: Schema.optional(Schema.String)
+  })),
+  fs: Schema.optional(Schema.Struct({
+    filewatcher: Schema.optional(Schema.Boolean),
+    fff: Schema.optional(Schema.Boolean)
+  }))
+});

package/dist/process.d.ts

@@ -0,0 +1,58 @@
+export * as ServerProcess from "./process";
+import { Effect, Scope } from "effect";
+import { HttpServer, HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
+export interface Lifecycle<E = never, R = never> {
+    readonly onListen: (address: HttpServer.Address, shutdown: Effect.Effect<void>) => Effect.Effect<Effect.Effect<void>, E, R>;
+}
+type App = Effect.Effect<HttpServerResponse.HttpServerResponse, unknown, HttpServerRequest.HttpServerRequest | Scope.Scope>;
+export type Transform = (app: App) => App;
+export declare const start: <E, R>(options: {
+    readonly models?: {
+        readonly url?: string | undefined;
+        readonly file?: string | undefined;
+        readonly snapshot?: boolean | undefined;
+        readonly fetch?: boolean | undefined;
+    } | undefined;
+    readonly events?: {
+        readonly persist?: boolean | undefined;
+    } | undefined;
+    readonly pty?: {
+        readonly handoff?: {
+            readonly directory: string;
+            readonly instanceID: string;
+            readonly ticket: string;
+            readonly expiresAt: number;
+        } | 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 cors?: readonly string[] | undefined;
+    readonly windows?: {
+        readonly gitbash?: string | undefined;
+    } | undefined;
+    readonly port?: number | undefined;
+    readonly password?: string | 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 simulation?: boolean | undefined;
+    readonly database?: {
+        readonly path?: string | undefined;
+    } | undefined;
+}, lifecycle?: Lifecycle<E, R> | undefined, transform?: Transform | undefined) => Effect.Effect<{
+    address: HttpServer.Address;
+    shutdown: Effect.Effect<void, never, never>;
+    updateAvailable: (version: string) => Effect.Effect<void, never, never>;
+    updated: (version: string) => Effect.Effect<void, never, never>;
+}, Error | E, Scope.Scope | R>;

package/dist/process.js

@@ -0,0 +1,131 @@
+export * as ServerProcess from "./process";
+import { NodeHttpServer } from "@effect/platform-node";
+import { Bus } from "@opencode/core/bus";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+import { InstallationEvent } from "@opencode/schema/installation-event";
+import { hasPtyConnectTicketURL } from "@opencode/protocol/groups/pty";
+import { hasPersistentPtyConnectTicketURL } from "@opencode/protocol/groups/persistent-pty";
+import { Cause, Context, Effect, Exit, Latch, Layer, Option, Ref, Scope } from "effect";
+import {
+  HttpMiddleware,
+  HttpPlatform,
+  HttpRouter,
+  HttpServer,
+  HttpServerRequest,
+  HttpServerResponse
+} from "effect/unstable/http";
+import { createServer } from "node:http";
+import { ServerAuth } from "./auth";
+import { isAllowedCorsOrigin } from "./cors";
+import { authorizedRequest } from "./middleware/authorization";
+import { withoutParentSpan } from "./request-tracing";
+import { createRoutes } from "./routes";
+import { ServerInfo } from "./server-info";
+import { Status } from "./service-status";
+const errorResponseLogger = HttpMiddleware.make((app) => HttpMiddleware.logger(Effect.tap(app, (response) => response.status < 400 ? HttpMiddleware.withLoggerDisabled(Effect.void) : Effect.void)));
+export const start = Effect.fn("ServerProcess.start")(function* (options, lifecycle, transform) {
+  const password = options.password;
+  if (!password)
+    return yield* Effect.fail(Error("Missing server password"));
+  const hostname = options.hostname ?? "127.0.0.1", port = Option.fromNullishOr(options.port), shutdown = yield* Latch.make(), status = yield* Status.make(), bound = yield* listen({ hostname, port }), application = yield* Ref.make(Option.none());
+  yield* bound.http.serve(dispatch(password, status, application, options.app?.version ?? "unknown").pipe(HttpMiddleware.cors({ allowedOrigins: (origin) => isAllowedCorsOrigin(origin, options), maxAge: 86400 })), errorResponseLogger).pipe(withoutParentSpan);
+  if (lifecycle)
+    yield* lifecycle.onListen(bound.http.address, shutdown.open.pipe(Effect.asVoid)).pipe(Effect.flatMap((cleanup) => Effect.addFinalizer(() => Scope.close(bound.scope, Exit.void).pipe(Effect.andThen(cleanup)))), Effect.uninterruptible);
+  const parentScope = yield* Scope.Scope, applicationScope = yield* Scope.fork(parentScope);
+  yield* Effect.addFinalizer(() => status.beginStopping.pipe(Effect.andThen(Ref.set(application, Option.none())), Effect.andThen(Effect.sync(() => bound.server.closeAllConnections()))));
+  const boot = Effect.gen(function* () {
+    const context = yield* Layer.buildWithScope(createRoutes({
+      ...options,
+      password
+    }, () => {
+      const address = bound.server.address();
+      if (address === null || typeof address === "string")
+        return [];
+      const host = address.family === "IPv6" ? `[${address.address}]` : address.address;
+      return ServerInfo.connectionURLs(`http://${host}:${address.port}`, hostname);
+    }).pipe(Layer.provideMerge(NodeHttpServer.layerHttpServices)), applicationScope);
+    if (lifecycle)
+      yield* installRestartContinuity(Context.get(context, SessionRestart.Service)).pipe(Effect.provideService(Scope.Scope, applicationScope));
+    const app = Context.get(context, HttpRouter.HttpRouter).asHttpEffect().pipe(HttpMiddleware.compression(), Effect.provideService(HttpPlatform.HttpPlatform, Context.get(context, HttpPlatform.HttpPlatform)));
+    yield* Ref.set(application, Option.some(transform ? transform(app) : app));
+    yield* status.ready;
+    const bus = Context.get(context, Bus.Service);
+    return {
+      address: bound.http.address,
+      shutdown: shutdown.await,
+      updateAvailable: (version) => bus.publish(InstallationEvent.UpdateAvailable, { version }).pipe(Effect.asVoid),
+      updated: (version) => bus.publish(InstallationEvent.Updated, { version }).pipe(Effect.asVoid)
+    };
+  }).pipe(Effect.catchCause((cause) => {
+    if (!lifecycle || Cause.hasInterruptsOnly(cause))
+      return Effect.failCause(cause);
+    return status.fail.pipe(Effect.andThen(Scope.close(applicationScope, Exit.failCause(cause)).pipe(Effect.catchCause((cleanupCause) => Effect.logError("failed to clean up background service boot", { cause: cleanupCause })))), Effect.andThen(Effect.logError("background service boot failed", { cause })), Effect.andThen(Effect.never));
+  }));
+  if (!lifecycle)
+    return yield* boot;
+  return yield* Effect.raceFirst(boot, shutdown.await.pipe(Effect.andThen(Effect.interrupt)));
+});
+function listen(options) {
+  if (Option.isSome(options.port))
+    return bind(options.hostname, options.port.value);
+  const next = (port) => bind(options.hostname, port).pipe(Effect.catch((error) => port < 65535 && addressInUse(error) ? next(port + 1) : Effect.fail(error)));
+  return next(4096);
+}
+function bind(hostname, port) {
+  return Effect.gen(function* () {
+    const parentScope = yield* Scope.Scope, serverScope = yield* Scope.fork(parentScope), server = createServer();
+    return yield* Effect.gen(function* () {
+      const http = yield* NodeHttpServer.make(() => server, { port, host: hostname });
+      yield* Effect.addFinalizer(() => Effect.sync(() => server.closeAllConnections()));
+      return { http, server, scope: serverScope };
+    }).pipe(Effect.provideService(Scope.Scope, serverScope), Effect.onError((cause) => Scope.close(serverScope, Exit.failCause(cause))));
+  });
+}
+function addressInUse(error) {
+  if (typeof error !== "object" || error === null || !("cause" in error))
+    return !1;
+  const cause = error.cause;
+  return typeof cause === "object" && cause !== null && "code" in cause && cause.code === "EADDRINUSE";
+}
+function dispatch(password, status, application, version) {
+  const auth = ServerAuth.Config.of({ password: Option.some(password), username: "opencode" });
+  return Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest, url = new URL(request.url, "http://localhost");
+    if (request.method === "GET" && url.pathname === "/api/health") {
+      if (!(yield* authorizedRequest(request, auth)))
+        return unauthorized();
+      return yield* healthResponse(status, version);
+    }
+    const state = yield* status.current, app = yield* Ref.get(application), ready = state.type === "ready" && Option.isSome(app);
+    if ((!ready || !hasPtyConnectTicketURL(url) && !hasPersistentPtyConnectTicketURL(url)) && !(yield* authorizedRequest(request, auth)))
+      return unauthorized();
+    if (ready)
+      return yield* app.value;
+    return unavailable(state);
+  });
+}
+function unauthorized() {
+  return HttpServerResponse.empty({
+    status: 401,
+    headers: { "www-authenticate": 'Basic realm="Secure Area"' }
+  });
+}
+const healthResponse = Effect.fnUntraced(function* (status, version) {
+  const state = yield* status.current;
+  return HttpServerResponse.jsonUnsafe({ healthy: !0, version, pid: process.pid }, {
+    status: state.type === "ready" ? 200 : state.type === "failed" ? 500 : 503,
+    headers: state.type === "starting" || state.type === "stopping" ? { "retry-after": "1" } : void 0
+  });
+});
+function unavailable(status) {
+  if (status.type === "failed")
+    return HttpServerResponse.jsonUnsafe({
+      code: "service_failed",
+      message: "The background service could not start.",
+      action: "Run `opencode service restart` after checking the service logs."
+    }, { status: 503 });
+  return HttpServerResponse.jsonUnsafe({ code: status.type === "stopping" ? "service_stopping" : "service_starting" }, { status: 503, headers: { "retry-after": "1" } });
+}
+const installRestartContinuity = Effect.fnUntraced(function* (restart) {
+  yield* Effect.forkScoped(restart.resumeSuspendedSessions);
+});

package/dist/pty-environment.d.ts

@@ -0,0 +1,13 @@
+export * as PtyEnvironment from "./pty-environment";
+import { Context, Effect, Layer } from "effect";
+export interface Interface {
+    readonly get: (input: {
+        directory: string;
+        cwd: string;
+    }) => Effect.Effect<Record<string, string>>;
+}
+declare const Service_base: Context.ServiceClass<Service, "@opencode/ServerPtyEnvironment", Interface>;
+export declare class Service extends Service_base {
+}
+export declare const layer: Layer.Layer<Service, never, never>;
+export declare const node: import("@opencode/util/effect/layer-node").Provider<Service, never, import("@opencode/util/effect/layer-node").Tag<"global">>;

package/dist/pty-environment.js

@@ -0,0 +1,9 @@
+export * as PtyEnvironment from "./pty-environment";
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+
+export class Service extends Context.Service()("@opencode/ServerPtyEnvironment") {
+}
+export const layer = Layer.succeed(Service, Service.of({
+  get: () => Effect.succeed({})
+})), node = makeGlobalNode({ service: Service, layer, deps: [] });

package/dist/request-tracing.d.ts

@@ -0,0 +1,2 @@
+import { Effect, Scope } from "effect";
+export declare const withoutParentSpan: <A, E>(effect: Effect.Effect<A, E, Scope.Scope>) => Effect.Effect<A, E, Scope.Scope>;

package/dist/request-tracing.js

@@ -0,0 +1,2 @@
+import { Context, Effect, Scope, Tracer } from "effect";
+export const withoutParentSpan = (effect) => effect.pipe(Effect.updateContext((context) => Context.omit(Tracer.ParentSpan)(context)));

package/dist/routes.d.ts

@@ -0,0 +1,29 @@
+import { Database } from "@opencode/core/database/database";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { Node } from "@opencode/util/effect/app-node";
+import { Bus } from "@opencode/core/bus";
+import { Credential } from "@opencode/core/credential";
+import { PermissionSaved } from "@opencode/core/permission/saved";
+import { PtyTicket } from "@opencode/core/pty/ticket";
+import { PersistentPty } from "@opencode/core/persistent-pty";
+import { Project } from "@opencode/core/project";
+import { Session } from "@opencode/core/session";
+import { Instance } from "@opencode/core/instance/service";
+import { SessionTransfer } from "@opencode/core/session/transfer";
+import { Job } from "@opencode/core/job";
+import { Global } from "@opencode/util/global";
+import { LocationServiceMap } from "@opencode/core/location-service-map";
+import { LocationActivity } from "@opencode/core/location-activity";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+import { PluginUpdate } from "@opencode/core/plugin/update";
+import { SdkPlugins } from "@opencode/core/plugin/sdk";
+import { WellKnown } from "@opencode/core/wellknown";
+import { Workspace } from "@opencode/core/workspace";
+import { HttpRouter } from "effect/unstable/http";
+import { Layer } from "effect";
+import { PtyEnvironment } from "./pty-environment";
+import type { ServerOptions } from "./options";
+export declare function createRoutes(options?: ServerOptions, serviceURLs?: () => ReadonlyArray<string>, overrides?: LayerNode.Replacements): Layer.Layer<Global.Service | Database.Service | Bus.Service | import("effect/unstable/http/HttpClient").HttpClient | Project.Service | Credential.Service | WellKnown.Service | Workspace.Service | PermissionSaved.Service | PersistentPty.Service | LocationServiceMap.Service | SdkPlugins.Service | PluginUpdate.Service | Session.Service | Job.Service | Instance.Service | SessionRestart.Service | PtyTicket.Service | SessionTransfer.Service | LocationActivity.Service | PtyEnvironment.Service | HttpRouter.HttpRouter, Error | PersistentPty.UnavailableError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/unstable/http/Etag").Generator | import("effect/unstable/http/HttpPlatform").HttpPlatform>;
+type InstanceNode = (replacements: () => LayerNode.Replacements) => LayerNode.Provider<Instance.Service, never, typeof Node.tags.values.global>;
+export declare function createEmbeddedRoutes(options?: ServerOptions, overrides?: LayerNode.Replacements, instances?: InstanceNode): Layer.Layer<Global.Service | Database.Service | Bus.Service | import("effect/unstable/http/HttpClient").HttpClient | Project.Service | Credential.Service | WellKnown.Service | Workspace.Service | PermissionSaved.Service | PersistentPty.Service | LocationServiceMap.Service | SdkPlugins.Service | PluginUpdate.Service | Session.Service | Job.Service | Instance.Service | SessionRestart.Service | PtyTicket.Service | SessionTransfer.Service | LocationActivity.Service | PtyEnvironment.Service | HttpRouter.HttpRouter, Error | PersistentPty.UnavailableError, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("effect/unstable/http/Etag").Generator | import("effect/unstable/http/HttpPlatform").HttpPlatform>;
+export {};

package/dist/routes.js

@@ -0,0 +1,116 @@
+import { Database } from "@opencode/core/database/database";
+import { V1Migration } from "@opencode/core/database/v1-migration";
+import { App } from "@opencode/core/app";
+import { LayerNode } from "@opencode/util/effect/layer-node";
+import { Node } from "@opencode/util/effect/app-node";
+import { httpClient } from "@opencode/util/effect/app-node-platform";
+import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder";
+import { Bus } from "@opencode/core/bus";
+import { EventLogger } from "@opencode/core/event-logger";
+import { FileSystemSearch } from "@opencode/core/filesystem/search";
+import { Credential } from "@opencode/core/credential";
+import { Config } from "@opencode/core/config";
+import { PermissionSaved } from "@opencode/core/permission/saved";
+import { PtyTicket } from "@opencode/core/pty/ticket";
+import { PersistentPty } from "@opencode/core/persistent-pty";
+import { Project } from "@opencode/core/project";
+import { Session } from "@opencode/core/session";
+import { Instance } from "@opencode/core/instance/service";
+import { SessionTransfer } from "@opencode/core/session/transfer";
+import { ShellSelect } from "@opencode/core/shell/select";
+import { Job } from "@opencode/core/job";
+import { Mcp } from "@opencode/core/mcp/index";
+import { Global } from "@opencode/util/global";
+import { InstructionDiscovery } from "@opencode/core/instruction-discovery";
+import { LocationServiceMap } from "@opencode/core/location-service-map";
+import { LocationActivity } from "@opencode/core/location-activity";
+import { ModelsDev } from "@opencode/core/models-dev";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+import { PluginUpdate } from "@opencode/core/plugin/update";
+import { SdkPlugins } from "@opencode/core/plugin/sdk";
+import { WellKnown } from "@opencode/core/wellknown";
+import { Workspace } from "@opencode/core/workspace";
+import { Watcher } from "@opencode/core/filesystem/watcher";
+import { HttpRouter } from "effect/unstable/http";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { Context, Effect, Layer, Option } from "effect";
+import { Api } from "./api";
+import { ServerAuth } from "./auth";
+import { CorsConfig } from "./cors";
+import { handlers } from "./handlers";
+import { authorizationLayer } from "./middleware/authorization";
+import { schemaErrorLayer } from "./middleware/schema-error";
+import { PtyEnvironment } from "./pty-environment";
+import { layer } from "./location";
+import { formLocationLayer } from "./middleware/form-location";
+import { sessionLocationLayer } from "./middleware/session-location";
+import { ServerInfo } from "./server-info";
+const applicationServiceNodes = [
+  Global.node,
+  Database.node,
+  Bus.node,
+  EventLogger.node,
+  httpClient,
+  Job.node,
+  Project.node,
+  Session.node,
+  Instance.node,
+  SessionTransfer.node,
+  SdkPlugins.node,
+  PluginUpdate.node,
+  PermissionSaved.node,
+  PtyTicket.node,
+  PersistentPty.node,
+  Credential.node,
+  WellKnown.node,
+  PtyEnvironment.node,
+  LocationServiceMap.node,
+  LocationActivity.node,
+  SessionRestart.node,
+  Workspace.node
+], applicationServices = LayerNode.group(applicationServiceNodes);
+export function createRoutes(options = {}, serviceURLs = () => [], overrides = []) {
+  return makeRoutes(options.password ? ServerAuth.Config.configLayer({ password: Option.some(options.password) }) : ServerAuth.Config.layer, options, serviceURLs, overrides);
+}
+export function createEmbeddedRoutes(options = {}, overrides = [], instances) {
+  return makeRoutes(ServerAuth.Config.configLayer({ password: Option.none() }), options, () => [], overrides, instances);
+}
+function makeRoutes(auth, options, serviceURLs, overrides, instances) {
+  const standard = [
+    Database.node.replace(Database.configured(options.database)),
+    PersistentPty.node.replace(PersistentPty.configured(options.pty)),
+    Bus.node.replace(Bus.configured({ persist: options.events?.persist })),
+    App.node.replace(App.configured(options.app)),
+    ModelsDev.node.replace(ModelsDev.configured(options.models)),
+    Watcher.node.replace(Watcher.configured({ enabled: options.fs?.filewatcher })),
+    FileSystemSearch.node.replace(FileSystemSearch.configured({ fff: options.fs?.fff })),
+    Global.node.replace(Global.layerWith(options.config?.directory ? { config: options.config.directory } : {})),
+    Config.node.replace(Config.configured({
+      project: options.config?.project,
+      file: options.config?.file,
+      content: options.config?.content
+    })),
+    InstructionDiscovery.node.replace(InstructionDiscovery.configured({ project: options.config?.project })),
+    ShellSelect.node.replace(ShellSelect.configured({ gitbash: options.windows?.gitbash })),
+    Mcp.node.replace(Mcp.configured({
+      clientInfo: {
+        name: options.app?.name ?? "opencode",
+        version: options.app?.version ?? "unknown"
+      }
+    }))
+  ], build = (overrides) => {
+    const replacements = [
+      ...standard,
+      ...instances ? [Instance.node.replace(instances(() => replacements))] : [],
+      ...overrides
+    ];
+    return AppNodeBuilder.build(applicationServices, replacements);
+  };
+  return (options.simulation ? Layer.unwrap(Effect.gen(function* () {
+    const { simulationReplacements } = yield* Effect.promise(() => import("@opencode/simulation/backend")), simulation = yield* simulationReplacements({ version: App.make(options.app).version });
+    return build([...overrides, ...simulation]);
+  })) : build(overrides)).pipe(Layer.flatMap((context) => {
+    const services = Layer.succeedContext(context), requestServices = Layer.merge(Layer.succeedContext(Context.pick(Database.Service, PermissionSaved.Service, PluginUpdate.Service, Project.Service, WellKnown.Service)(context)), ServerInfo.layer(serviceURLs, options.app)), api = HttpApiBuilder.layer(Api, { openapiPath: "/openapi.json" }).pipe(Layer.provide(handlers.pipe(Layer.provide(services), Layer.provide(Layer.succeed(CorsConfig, options)))), Layer.provide(formLocationLayer), Layer.provide(sessionLocationLayer), Layer.provide(layer), Layer.provide(authorizationLayer), Layer.provide(schemaErrorLayer), Layer.provide(auth), HttpRouter.provideRequest(requestServices), Layer.provideMerge(services), Layer.provideMerge(HttpRouter.layer));
+    return Layer.merge(api, V1Migration.layer.pipe(Layer.provide(services)));
+  }));
+}

package/dist/server-info.d.ts

@@ -0,0 +1,11 @@
+import { Context, Layer } from "effect";
+import type { ServerOptions } from "./options";
+declare const Service_base: Context.ServiceClass<Service, "@opencode/server/ServerInfo", {
+    readonly urls: () => ReadonlyArray<string>;
+    readonly app: NonNullable<ServerOptions["app"]>;
+}>;
+export declare class Service extends Service_base {
+}
+export declare function layer(urls: () => ReadonlyArray<string>, app?: ServerOptions["app"]): Layer.Layer<Service, never, never>;
+export declare function connectionURLs(value: string, requestedHostname?: string): string[];
+export * as ServerInfo from "./server-info";