@opencode/server 2.0.8 → 2.0.10

package/dist/chunks/auth-fyjxk8m3.js

@@ -0,0 +1,22 @@
+import {
+  response2
+} from "./auth-0ar9gf7q.js";
+import {
+  Api2
+} from "./auth-z6kg9h7e.js";
+
+// src/handlers/model.ts
+import { Model } from "@opencode/core/model";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var ModelHandler2 = HttpApiBuilder.group(Api2, "server.model", (handlers) => Effect.gen(function* () {
+  return handlers.handle("model.list", Effect.fn(function* () {
+    const models = yield* Model.Service;
+    return yield* response2(models.available());
+  })).handle("model.default", Effect.fn(function* () {
+    const models = yield* Model.Service;
+    return yield* response2(models.default());
+  }));
+}));
+
+export { ModelHandler2 };

package/dist/chunks/auth-gsks0nj8.js

@@ -0,0 +1,149 @@
+import {
+  layer5
+} from "./auth-0ar9gf7q.js";
+import {
+  formLocationLayer2
+} from "./auth-frv6gfy7.js";
+import {
+  sessionLocationLayer2
+} from "./auth-23w8t84j.js";
+import {
+  Api2
+} from "./auth-z6kg9h7e.js";
+import {
+  Config2
+} from "./auth-zyv89x5n.js";
+import {
+  CorsConfig2
+} from "./auth-q4bn6dy8.js";
+import {
+  layer4
+} from "./auth-5p62ed52.js";
+import {
+  node2
+} from "./auth-bkk2wfbz.js";
+import {
+  handlers2
+} from "./auth-7bj707s9.js";
+import {
+  authorizationLayer2
+} from "./auth-m6wvgbfq.js";
+import {
+  schemaErrorLayer2
+} from "./auth-t8yzmczr.js";
+
+// src/routes.ts
+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 { 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 { Worktree } from "@opencode/core/worktree";
+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";
+var applicationServiceNodes = [
+  Global.node,
+  Database.node,
+  Bus.node,
+  EventLogger.node,
+  httpClient,
+  Job.node,
+  Project.node,
+  Worktree.node,
+  Session.node,
+  Instance.node,
+  SessionTransfer.node,
+  SdkPlugins.node,
+  PluginUpdate.node,
+  PermissionSaved.node,
+  PtyTicket.node,
+  PersistentPty.node,
+  Credential.node,
+  WellKnown.node,
+  node2,
+  LocationServiceMap.node,
+  LocationActivity.node,
+  SessionRestart.node,
+  Workspace.node
+];
+var applicationServices = LayerNode.group(applicationServiceNodes);
+function createRoutes2(options = {}, serviceURLs = () => [], overrides = []) {
+  return makeRoutes(options.password ? Config2.configLayer({ password: Option.some(options.password) }) : Config2.layer, options, serviceURLs, overrides);
+}
+function createEmbeddedRoutes2(options = {}, overrides = [], instances) {
+  return makeRoutes(Config2.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"
+      }
+    }))
+  ];
+  const build = (overrides) => {
+    const replacements = [
+      ...standard,
+      ...instances ? [Instance.node.replace(instances(() => replacements))] : [],
+      ...overrides
+    ];
+    return AppNodeBuilder.build(applicationServices, replacements);
+  };
+  const serviceLayer = options.simulation ? Layer.unwrap(Effect.gen(function* () {
+    const { simulationReplacements } = yield* Effect.promise(() => import("@opencode/simulation/backend"));
+    const simulation = yield* simulationReplacements({ version: App.make(options.app).version });
+    return build([...overrides, ...simulation]);
+  })) : build(overrides);
+  return serviceLayer.pipe(Layer.flatMap((context) => {
+    const services = Layer.succeedContext(context);
+    const requestServices = Layer.merge(Layer.succeedContext(Context.pick(Database.Service, Credential.Service, PermissionSaved.Service, PluginUpdate.Service, Project.Service, WellKnown.Service)(context)), layer4(serviceURLs, Context.get(context, Global.Service).tmp, options.app));
+    const api = HttpApiBuilder.layer(Api2, { openapiPath: "/openapi.json" }).pipe(Layer.provide(handlers2.pipe(Layer.provide(services), Layer.provide(Layer.succeed(CorsConfig2, options)))), Layer.provide(formLocationLayer2), Layer.provide(sessionLocationLayer2), Layer.provide(layer5), Layer.provide(authorizationLayer2), Layer.provide(schemaErrorLayer2), Layer.provide(auth), HttpRouter.provideRequest(requestServices), Layer.provideMerge(services), Layer.provideMerge(HttpRouter.layer));
+    return Layer.merge(api, V1Migration.layer.pipe(Layer.provide(services)));
+  }));
+}
+
+export { createRoutes2, createEmbeddedRoutes2 };

package/dist/chunks/auth-hezj1jdf.js

@@ -0,0 +1,7 @@
+// src/handlers/pty-socket.ts
+import { Effect } from "effect";
+function runPtySocket2(drain, socket, detach) {
+  return Effect.raceFirst(drain, socket).pipe(Effect.ensuring(Effect.sync(detach)));
+}
+
+export { runPtySocket2 };

package/dist/chunks/auth-kv6ycdgm.js

@@ -0,0 +1,77 @@
+import {
+  missingSession2
+} from "./auth-smaf4a18.js";
+import {
+  response2,
+  sessionInfo2
+} from "./auth-0ar9gf7q.js";
+import {
+  Api2
+} from "./auth-z6kg9h7e.js";
+
+// src/handlers/permission.ts
+import { Instance } from "@opencode/core/instance/service";
+import { Location } from "@opencode/core/location";
+import { Permission } from "@opencode/core/permission";
+import { PermissionSaved } from "@opencode/core/permission/saved";
+import { Session } from "@opencode/core/session";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import { PermissionNotFoundError } from "@opencode/protocol/errors";
+function missingRequest(id) {
+  return new PermissionNotFoundError({ requestID: id, message: `Permission request not found: ${id}` });
+}
+var PermissionHandler2 = HttpApiBuilder.group(Api2, "server.permission", (handlers) => Effect.gen(function* () {
+  const instances = yield* Instance.Service;
+  const sessions = yield* Session.Service;
+  const requireOwnedRequest = Effect.fnUntraced(function* (sessionID, requestID) {
+    const permission = yield* Permission.Service;
+    const request = yield* permission.get(requestID);
+    if (!request || request.sessionID !== sessionID)
+      return yield* missingRequest(requestID);
+    return { permission, request };
+  });
+  return handlers.handle("permission.request.list", Effect.fn(function* () {
+    const permission = yield* Permission.Service;
+    return yield* response2(permission.list());
+  })).handle("session.permission.create", Effect.fn(function* (ctx) {
+    const permission = yield* Permission.Service;
+    return {
+      data: yield* permission.ask({
+        id: ctx.payload.id,
+        sessionID: ctx.params.sessionID,
+        action: ctx.payload.action,
+        resources: ctx.payload.resources,
+        save: ctx.payload.save,
+        metadata: ctx.payload.metadata,
+        source: ctx.payload.source,
+        agent: ctx.payload.agent
+      }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2))
+    };
+  })).handle("session.permission.list", Effect.fn(function* (ctx) {
+    const session = yield* sessionInfo2(sessions, ctx.params.sessionID);
+    const requests = yield* Permission.Service.use((permission) => permission.forSession(ctx.params.sessionID)).pipe(instances.provide(session));
+    return { data: requests };
+  })).handle("session.permission.get", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID);
+    return { data: owned.request };
+  })).handle("session.permission.reply", Effect.fn(function* (ctx) {
+    const owned = yield* requireOwnedRequest(ctx.params.sessionID, ctx.params.requestID);
+    yield* owned.permission.reply({ requestID: ctx.params.requestID, reply: ctx.payload.decision, message: ctx.payload.message }).pipe(Effect.catchTag("Permission.NotFoundError", () => missingRequest(ctx.params.requestID)));
+    return HttpApiSchema.NoContent.make();
+  })).handle("permission.saved.list", Effect.fn(function* (ctx) {
+    const location = yield* Location.Service;
+    const saved = yield* PermissionSaved.Service;
+    return {
+      data: yield* saved.list({
+        projectID: ctx.query.projectID ?? location.project.id
+      })
+    };
+  })).handle("permission.saved.remove", Effect.fn(function* (ctx) {
+    const saved = yield* PermissionSaved.Service;
+    yield* saved.remove(ctx.params.id);
+    return HttpApiSchema.NoContent.make();
+  }));
+}));
+
+export { PermissionHandler2 };

package/dist/chunks/auth-m6wvgbfq.js

@@ -0,0 +1,60 @@
+import {
+  Config2,
+  required2,
+  authorized2
+} from "./auth-zyv89x5n.js";
+
+// src/middleware/authorization.ts
+import { UnauthorizedError } from "@opencode/protocol/errors";
+import { Authorization } from "@opencode/protocol/middleware/authorization";
+import { Authorization as Authorization2 } 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";
+var AUTH_TOKEN_QUERY = "auth_token";
+var 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 url = new URL(request.url, "http://localhost");
+  const token = url.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());
+}
+function authorizedRequest2(request, config) {
+  return credentialFromRequest(request).pipe(Effect.map((credential) => authorized2(credential, config)));
+}
+var authorizationLayer2 = Layer.effect(Authorization, Effect.gen(function* () {
+  const config = yield* Config2;
+  if (!required2(config))
+    return Authorization.of((effect) => effect);
+  return Authorization.of((effect) => Effect.gen(function* () {
+    const request = yield* HttpServerRequest.HttpServerRequest;
+    const url = new URL(request.url, "http://localhost");
+    if (hasPtyConnectTicketURL(url) || hasPersistentPtyConnectTicketURL(url))
+      return yield* effect;
+    if (yield* authorizedRequest2(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" });
+  }));
+}));
+
+export { authorizedRequest2, authorizationLayer2, Authorization2 };

package/dist/chunks/auth-p5hgn93y.js

@@ -0,0 +1,26 @@
+import {
+  isAllowedCorsOrigin2
+} from "./auth-q4bn6dy8.js";
+import {
+  createRoutes2
+} from "./auth-gsks0nj8.js";
+import {
+  __export
+} from "./auth-9rqn6x4v.js";
+
+// src/fetch.ts
+var exports_fetch = {};
+__export(exports_fetch, {
+  ServerFetch: () => exports_fetch,
+  make: () => make3
+});
+import { Context, Effect, Layer } from "effect";
+import { HttpEffect, HttpMiddleware, HttpRouter, HttpServer } from "effect/unstable/http";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+var make3 = Effect.fn("ServerFetch.make")(function* (options = {}, boot = {}) {
+  const context = yield* Layer.build(createRoutes2(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: (origin) => isAllowedCorsOrigin2(origin, options), maxAge: 86400 }), HttpEffect.toWebHandlerWith(context));
+});
+
+export { make3, exports_fetch };

package/dist/chunks/auth-pd1pbg0v.js

@@ -0,0 +1,17 @@
+import {
+  response2
+} from "./auth-0ar9gf7q.js";
+import {
+  Api2
+} from "./auth-z6kg9h7e.js";
+
+// src/handlers/form.ts
+import { Form } from "@opencode/core/form";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var FormHandler2 = HttpApiBuilder.group(Api2, "server.form", (handlers) => handlers.handle("form.list", Effect.fn(function* () {
+  const form = yield* Form.Service;
+  return yield* response2(form.list());
+})));
+
+export { FormHandler2 };

package/dist/chunks/auth-q4bn6dy8.js

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