@opencode/server 0.0.0-dev-19794 → 0.0.0-dev-19808

package/dist/chunks/workerd-a6yp8301.js

@@ -0,0 +1,156 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/integration.ts
+import { Integration } from "@opencode/core/integration";
+import { Plugin } from "@opencode/core/plugin";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+import {
+  IntegrationAttemptNotFoundError,
+  IntegrationMethodNotFoundError,
+  IntegrationNotFoundError,
+  InvalidRequestError
+} from "@opencode/protocol/errors";
+import { WellKnown } from "@opencode/core/wellknown";
+var authorize = (effect) => effect.pipe(Effect.mapError((error) => new InvalidRequestError({
+  message: error.cause instanceof Error && error.cause.message.trim() ? error.cause.message : "Authentication failed",
+  kind: "integration_authorization"
+})));
+var IntegrationHandler2 = HttpApiBuilder.group(Api2, "server.integration", (handlers) => Effect.gen(function* () {
+  return handlers.handle("integration.list", Effect.fn(function* () {
+    yield* Plugin.awaitActivation;
+    const service = yield* Integration.Service;
+    return yield* response2(service.list());
+  })).handle("integration.get", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    const integration = yield* service.get(ctx.params.integrationID);
+    if (!integration)
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    return yield* response2(Effect.succeed(integration));
+  })).handle("integration.wellknown.add", Effect.fn(function* (ctx) {
+    const wellknown = yield* WellKnown.Service;
+    const 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;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    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* response2(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;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    return yield* response2(service.oauth.status({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID
+    }).pipe(Effect.mapError((error) => new IntegrationAttemptNotFoundError({
+      integrationID: error.integrationID,
+      attemptID: error.attemptID,
+      message: `OAuth attempt not found: ${error.attemptID}`
+    }))));
+  })).handle("integration.oauth.complete", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    yield* service.oauth.complete({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID,
+      code: ctx.payload.code
+    }).pipe(Effect.mapError((error) => {
+      if (error._tag === "Integration.AttemptNotFound")
+        return new IntegrationAttemptNotFoundError({
+          integrationID: error.integrationID,
+          attemptID: error.attemptID,
+          message: `OAuth attempt not found: ${error.attemptID}`
+        });
+      return 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) {
+    const service = yield* Integration.Service;
+    yield* 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;
+    const integration = yield* service.get(ctx.params.integrationID);
+    if (!integration)
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    if (!integration.methods.some((method) => method.type === "command" && method.id === ctx.payload.methodID))
+      return yield* new IntegrationMethodNotFoundError({
+        integrationID: ctx.params.integrationID,
+        methodID: ctx.payload.methodID,
+        message: `Integration method not found: ${ctx.payload.methodID}`
+      });
+    return yield* response2(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;
+    if (!(yield* service.get(ctx.params.integrationID)))
+      return yield* new IntegrationNotFoundError({
+        integrationID: ctx.params.integrationID,
+        message: `Integration not found: ${ctx.params.integrationID}`
+      });
+    return yield* response2(service.command.status({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID
+    }).pipe(Effect.mapError((error) => new IntegrationAttemptNotFoundError({
+      integrationID: error.integrationID,
+      attemptID: error.attemptID,
+      message: `Command attempt not found: ${error.attemptID}`
+    }))));
+  })).handle("integration.command.cancel", Effect.fn(function* (ctx) {
+    const service = yield* Integration.Service;
+    yield* service.command.cancel({
+      integrationID: ctx.params.integrationID,
+      attemptID: ctx.params.attemptID
+    });
+    return HttpApiSchema.NoContent.make();
+  }));
+}));
+
+export { IntegrationHandler2 };

package/dist/chunks/workerd-arj41x43.js

@@ -0,0 +1,77 @@
+import {
+  missingSession2
+} from "./workerd-smaf4a18.js";
+import {
+  response2,
+  sessionInfo2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.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/workerd-b0b71rwa.js

@@ -0,0 +1,39 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/websearch.ts
+import { WebSearch } from "@opencode/core/websearch";
+import { InvalidRequestError, ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var WebSearchHandler2 = HttpApiBuilder.group(Api2, "server.websearch", (handlers) => Effect.gen(function* () {
+  return handlers.handle("websearch.providers", Effect.fn("server.websearch.providers")(function* () {
+    const websearch = yield* WebSearch.Service;
+    return yield* response2(websearch.providers());
+  })).handle("websearch.query", Effect.fn("server.websearch.query")(function* (request) {
+    const websearch = yield* WebSearch.Service;
+    return yield* response2(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
+      })
+    })));
+  }));
+}));
+
+export { WebSearchHandler2 };

package/dist/chunks/workerd-bjrwanme.js

@@ -0,0 +1,22 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/rpc.ts
+import { Rpc } from "@opencode/core/rpc";
+import { Plugin } from "@opencode/core/plugin";
+import { RpcError, RpcInternalError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var RpcHandler2 = HttpApiBuilder.group(Api2, "server.rpc", (handlers) => handlers.handle("rpc.call", ({ params, payload }) => Effect.gen(function* () {
+  yield* Plugin.awaitActivation;
+  const rpc = yield* Rpc.Service;
+  const output = yield* rpc.call(params.rpcID, params.method, payload.input);
+  return output === undefined ? {} : { output };
+}).pipe(Effect.mapError((error) => error.type === "rpc.invalid_output" || error.type === "rpc.internal" ? new RpcInternalError({ type: error.type, message: error.message }) : new RpcError({
+  type: error.type,
+  message: error.message,
+  ...error.data === undefined ? {} : { data: error.data }
+})), Effect.catchDefect((defect) => Effect.logError("rpc call failed", { rpc: params.rpcID, method: params.method, defect }).pipe(Effect.andThen(Effect.fail(new RpcInternalError({ type: "rpc.internal", message: "RPC call failed" }))))))));
+
+export { RpcHandler2 };

package/dist/chunks/workerd-bkqymx4n.js

@@ -0,0 +1,26 @@
+import {
+  isAllowedCorsOrigin2
+} from "./workerd-q4bn6dy8.js";
+import {
+  createRoutes2
+} from "./workerd-6ptwb1q1.js";
+import {
+  __export
+} from "./workerd-9rqn6x4v.js";
+
+// src/fetch.ts
+var exports_fetch = {};
+__export(exports_fetch, {
+  ServerFetch: () => exports_fetch,
+  make: () => make2
+});
+import { Context, Effect, Layer } from "effect";
+import { HttpEffect, HttpMiddleware, HttpRouter, HttpServer } from "effect/unstable/http";
+import { SessionRestart } from "@opencode/core/session/execution/restart";
+var make2 = 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 { make2, exports_fetch };

package/dist/chunks/workerd-br99j6q1.js

@@ -0,0 +1,35 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/shell.ts
+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";
+var ShellHandler2 = HttpApiBuilder.group(Api2, "server.shell", (handlers) => Effect.gen(function* () {
+  return handlers.handle("shell.list", Effect.fn(function* () {
+    const shell = yield* Shell.Service;
+    return yield* response2(shell.list());
+  })).handle("shell.create", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    const location = yield* Location.Service;
+    return yield* response2(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* response2(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.output", Effect.fn(function* (ctx) {
+    const shell = yield* Shell.Service;
+    return yield* response2(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) {
+    const shell = yield* Shell.Service;
+    yield* shell.remove(ctx.params.id).pipe(Effect.catchTag("Shell.NotFoundError", () => Effect.void));
+    return HttpApiSchema.NoContent.make();
+  }));
+}));
+
+export { ShellHandler2 };

package/dist/chunks/workerd-ceh2h0m9.js

@@ -0,0 +1,25 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/agent.ts
+import { Agent } from "@opencode/core/agent";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { AgentNotFoundError } from "@opencode/protocol/errors";
+var AgentHandler2 = HttpApiBuilder.group(Api2, "server.agent", (handlers) => handlers.handle("agent.list", () => Effect.gen(function* () {
+  return yield* response2(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* response2(Effect.succeed(agent));
+})));
+
+export { AgentHandler2 };

package/dist/chunks/workerd-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/workerd-hjnxtxmk.js

@@ -0,0 +1,34 @@
+import {
+  response2
+} from "./workerd-6gkz39ey.js";
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/fs.ts
+import { FileSystem } from "@opencode/core/filesystem";
+import { RelativePath } from "@opencode/core/schema";
+import { FileNotFoundError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpServerResponse } from "effect/unstable/http";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var FileSystemHandler2 = HttpApiBuilder.group(Api2, "server.fs", (handlers) => Effect.gen(function* () {
+  return handlers.handleRaw("fs.read", (ctx) => Effect.gen(function* () {
+    const fs = yield* FileSystem.Service;
+    const file = yield* fs.read({
+      path: RelativePath.make(decodeURIComponent(new URL(ctx.request.url, "http://localhost").pathname.slice(13)))
+    }).pipe(Effect.mapError((error) => new FileNotFoundError({ path: error.path, message: `File not found: ${error.path}` })));
+    return HttpServerResponse.uint8Array(file.content, { contentType: file.mime });
+  })).handle("fs.list", (ctx) => response2(Effect.gen(function* () {
+    const fs = yield* FileSystem.Service;
+    return yield* fs.list(ctx.query);
+  }))).handle("fs.find", (ctx) => response2(Effect.gen(function* () {
+    const fs = yield* FileSystem.Service;
+    return yield* fs.find(ctx.query);
+  }))).handle("fs.write", (ctx) => response2(Effect.gen(function* () {
+    const fs = yield* FileSystem.Service;
+    return yield* fs.write({ path: ctx.query.path, data: ctx.payload });
+  })));
+}));
+
+export { FileSystemHandler2 };

package/dist/chunks/workerd-j2pfq4q6.js

@@ -0,0 +1,42 @@
+import {
+  Api2
+} from "./workerd-z5shrcz9.js";
+
+// src/handlers/worktree.ts
+import { Git } from "@opencode/core/git";
+import { Worktree } from "@opencode/core/worktree";
+import { ProjectNotFoundError } from "@opencode/protocol/errors";
+import { WorktreeError } from "@opencode/protocol/groups/worktree";
+import { Effect } from "effect";
+import { HttpApiBuilder, HttpApiSchema } from "effect/unstable/httpapi";
+var WorktreeHandler2 = HttpApiBuilder.group(Api2, "server.worktree", (handlers) => Effect.gen(function* () {
+  const worktrees = yield* Worktree.Service;
+  return handlers.handle("worktree.list", (ctx) => worktrees.list(ctx.query).pipe(Effect.catchTag("Project.NotFoundError", missingProject))).handle("worktree.create", (ctx) => worktrees.create(ctx.payload).pipe(badRequest)).handle("worktree.remove", (ctx) => worktrees.remove(ctx.payload).pipe(badRequest, Effect.as(HttpApiSchema.NoContent.make()))).handle("worktree.refresh", (ctx) => worktrees.refresh(ctx.payload).pipe(badRequest, Effect.as(HttpApiSchema.NoContent.make())));
+}));
+function badRequest(effect) {
+  return effect.pipe(Effect.catchTag("Project.NotFoundError", missingProject), Effect.mapError((error) => error instanceof ProjectNotFoundError ? error : new WorktreeError({
+    name: "WorktreeError",
+    data: {
+      message: message(error),
+      forceRequired: error instanceof Git.WorktreeError || error instanceof Worktree.OperationError ? error.forceRequired : undefined
+    }
+  })));
+}
+function missingProject(error) {
+  return Effect.fail(new ProjectNotFoundError({ projectID: error.projectID, message: `Project not found: ${error.projectID}` }));
+}
+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}`;
+  return error.message;
+}
+
+export { WorktreeHandler2 };

package/dist/chunks/workerd-m6wvgbfq.js

@@ -0,0 +1,60 @@
+import {
+  Config2,
+  required2,
+  authorized2
+} from "./workerd-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/workerd-mzr9gftb.js

@@ -0,0 +1,36 @@
+import {
+  __export
+} from "./workerd-9rqn6x4v.js";
+
+// src/server-info.ts
+var exports_server_info = {};
+__export(exports_server_info, {
+  ServerInfo: () => exports_server_info,
+  Service: () => Service3,
+  connectionURLs: () => connectionURLs2,
+  layer: () => layer3
+});
+import { Context, Layer } from "effect";
+import { networkInterfaces } from "node:os";
+
+class Service3 extends Context.Service()("@opencode/server/ServerInfo") {
+}
+function layer3(urls, tmp, app = {}) {
+  return Layer.succeed(Service3, Service3.of({ urls, app, paths: { tmp } }));
+}
+function connectionURLs2(value, requestedHostname) {
+  const url = new URL(value);
+  const hostname = requestedHostname ?? url.hostname;
+  const family = hostname === "0.0.0.0" ? "IPv4" : hostname === "::" || hostname === "[::]" ? "IPv6" : undefined;
+  if (family === undefined)
+    return [value];
+  return [
+    ...new Set(Object.values(networkInterfaces()).flatMap((entries) => entries ?? []).filter((entry) => !entry.internal && entry.family === family).map((entry) => {
+      const result = new URL(value);
+      result.hostname = family === "IPv6" ? `[${entry.address}]` : entry.address;
+      return result.toString().replace(/\/$/, "");
+    }))
+  ];
+}
+
+export { Service3, layer3, connectionURLs2, exports_server_info };