@opencode/server 0.0.0-dev-19795 → 0.0.0-dev-19812

package/dist/chunks/process-mx2h5aqn.js

@@ -0,0 +1,59 @@
+import {
+  missingSession2,
+  failedMessageDecode2
+} from "./process-smaf4a18.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/message.ts
+import { SessionMessage } from "@opencode/core/session/message";
+import { Session } from "@opencode/core/session";
+import { Effect, Schema } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+import { InvalidCursorError } from "@opencode/protocol/errors";
+var DefaultMessagesLimit = 50;
+var Cursor = Schema.Struct({
+  id: SessionMessage.ID,
+  order: Schema.Union([Schema.Literal("asc"), Schema.Literal("desc")]),
+  direction: Schema.Union([Schema.Literal("previous"), Schema.Literal("next")])
+});
+var decodeCursor = Schema.decodeUnknownSync(Cursor);
+var cursor = {
+  encode(message, order, direction) {
+    return Buffer.from(JSON.stringify({ id: message.id, order, direction })).toString("base64url");
+  },
+  decode(input) {
+    return decodeCursor(JSON.parse(Buffer.from(input, "base64url").toString("utf8")));
+  }
+};
+var MessageHandler2 = HttpApiBuilder.group(Api2, "server.message", (handlers) => Effect.gen(function* () {
+  const session = yield* Session.Service;
+  return handlers.handle("session.messages", Effect.fn(function* (ctx) {
+    if (ctx.query.cursor && ctx.query.order !== undefined)
+      return yield* new InvalidCursorError({ message: "Cursor cannot be combined with order" });
+    const decoded = yield* Effect.try({
+      try: () => ctx.query.cursor ? cursor.decode(ctx.query.cursor) : undefined,
+      catch: () => new InvalidCursorError({ message: "Invalid cursor" })
+    });
+    const order = decoded?.order ?? ctx.query.order ?? "desc";
+    const messages = yield* session.messages({
+      sessionID: ctx.params.sessionID,
+      limit: ctx.query.limit ?? DefaultMessagesLimit,
+      order,
+      type: ctx.query.type,
+      cursor: decoded ? { id: decoded.id, direction: decoded.direction } : undefined
+    }).pipe(Effect.catchTag("Session.NotFoundError", missingSession2), Effect.catchTag("Session.MessageDecodeError", failedMessageDecode2));
+    const first = messages[0];
+    const last = messages.at(-1);
+    return {
+      data: messages,
+      cursor: {
+        previous: first ? cursor.encode(first, order, "previous") : undefined,
+        next: last ? cursor.encode(last, order, "next") : undefined
+      }
+    };
+  }));
+}));
+
+export { MessageHandler2 };

package/dist/chunks/process-prrj1pgd.js

@@ -0,0 +1,42 @@
+import {
+  Api2
+} from "./process-ks9pc2xc.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/process-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 };

package/dist/chunks/process-qc2xtz00.js

@@ -0,0 +1,34 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.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/process-qswqf30g.js

@@ -0,0 +1,25 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.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/process-rkdaz036.js

@@ -0,0 +1,32 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/vcs.ts
+import { Vcs } from "@opencode/core/vcs";
+import { ServiceUnavailableError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var VcsHandler2 = HttpApiBuilder.group(Api2, "server.vcs", (handlers) => Effect.gen(function* () {
+  return handlers.handle("vcs.get", () => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.info();
+  }))).handle("vcs.base", () => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.base().pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));
+  }))).handle("vcs.status", () => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.status();
+  }))).handle("vcs.branch.list", (ctx) => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.branches({ search: ctx.query.search, limit: Math.min(ctx.query.limit ?? 50, 100) });
+  }))).handle("vcs.diff", (ctx) => response2(Effect.gen(function* () {
+    const vcs = yield* Vcs.Service;
+    return yield* vcs.diff(ctx.query.mode, { context: ctx.query.context, base: ctx.query.base }).pipe(Effect.mapError((error) => new ServiceUnavailableError({ service: "vcs", message: error.message })));
+  })));
+}));
+
+export { VcsHandler2 };

package/dist/chunks/process-smaf4a18.js

@@ -0,0 +1,28 @@
+// src/handlers/session-error.ts
+import { MessageNotFoundError, SessionNotFoundError, UnknownError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+function missingSession2(error) {
+  return new SessionNotFoundError({
+    sessionID: error.sessionID,
+    message: `Session not found: ${error.sessionID}`
+  });
+}
+function missingMessage2(error) {
+  return new MessageNotFoundError({
+    sessionID: error.sessionID,
+    messageID: error.messageID,
+    message: `Message not found: ${error.messageID}`
+  });
+}
+function failedMessageDecode2(error) {
+  const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+  return Effect.logError("failed to decode session message").pipe(Effect.annotateLogs({ ref, sessionID: error.sessionID, messageID: error.messageID }), Effect.andThen(Effect.fail(new UnknownError({ message: "Unexpected server error. Check server logs for details.", ref }))));
+}
+function failedSnapshot2(operation, sessionID) {
+  return (error) => {
+    const ref = `err_${crypto.randomUUID().slice(0, 8)}`;
+    return Effect.logError(`failed to ${operation}`, { cause: error }).pipe(Effect.annotateLogs({ ref, sessionID }), Effect.andThen(Effect.fail(new UnknownError({ message: "Unexpected server error. Check server logs for details.", ref }))));
+  };
+}
+
+export { missingSession2, missingMessage2, failedMessageDecode2, failedSnapshot2 };

package/dist/chunks/process-t7k3q1ah.js

@@ -0,0 +1,23 @@
+import {
+  __export
+} from "./process-9rqn6x4v.js";
+
+// src/pty-environment.ts
+var exports_pty_environment = {};
+__export(exports_pty_environment, {
+  PtyEnvironment: () => exports_pty_environment,
+  Service: () => Service2,
+  layer: () => layer3,
+  node: () => node2
+});
+import { Context, Effect, Layer } from "effect";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+
+class Service2 extends Context.Service()("@opencode/ServerPtyEnvironment") {
+}
+var layer3 = Layer.succeed(Service2, Service2.of({
+  get: () => Effect.succeed({})
+}));
+var node2 = makeGlobalNode({ service: Service2, layer: layer3, deps: [] });
+
+export { Service2, layer3, node2, exports_pty_environment };

package/dist/chunks/process-t8yzmczr.js

@@ -0,0 +1,18 @@
+// src/middleware/schema-error.ts
+import { Effect } from "effect";
+import { HttpApiMiddleware } from "effect/unstable/httpapi";
+import { InvalidRequestError } from "@opencode/protocol/errors";
+import { SchemaErrorMiddleware } from "@opencode/protocol/middleware/schema-error";
+import { SchemaErrorMiddleware as SchemaErrorMiddleware2 } from "@opencode/protocol/middleware/schema-error";
+var 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)`;
+}
+var schemaErrorLayer2 = 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 }))));
+});
+
+export { schemaErrorLayer2, SchemaErrorMiddleware2 };

package/dist/chunks/process-tp6dn9dc.js

@@ -0,0 +1,99 @@
+import {
+  GenerateHandler2
+} from "./process-h965rd83.js";
+import {
+  MessageHandler2
+} from "./process-mx2h5aqn.js";
+import {
+  ModelHandler2
+} from "./process-d5nhwenp.js";
+import {
+  ProviderHandler2
+} from "./process-xn1y01ws.js";
+import {
+  SessionHandler2
+} from "./process-m8y6333k.js";
+import {
+  PermissionHandler2
+} from "./process-kadtbwy3.js";
+import {
+  FileSystemHandler2
+} from "./process-qc2xtz00.js";
+import {
+  FormHandler2
+} from "./process-c23ng5tp.js";
+import {
+  CommandHandler2
+} from "./process-1crq7hen.js";
+import {
+  SkillHandler2
+} from "./process-wt4btb09.js";
+import {
+  RpcHandler2
+} from "./process-xettb16v.js";
+import {
+  layer4
+} from "./process-d0efjmp3.js";
+import {
+  EventHandler2
+} from "./process-910kejdj.js";
+import {
+  AgentHandler2
+} from "./process-qswqf30g.js";
+import {
+  PluginHandler2
+} from "./process-k8tgqrb7.js";
+import {
+  ServerHandler2
+} from "./process-m5dqr0xs.js";
+import {
+  DebugHandler2
+} from "./process-gw2hwgqh.js";
+import {
+  PtyHandler2
+} from "./process-172x6jgf.js";
+import {
+  PersistentPtyHandler2
+} from "./process-dhcrxjg3.js";
+import {
+  ShellHandler2
+} from "./process-kheky2r0.js";
+import {
+  ReferenceHandler2
+} from "./process-b0dj656z.js";
+import {
+  LocationHandler2
+} from "./process-ja6yvede.js";
+import {
+  IntegrationHandler2
+} from "./process-3esm6t0a.js";
+import {
+  WebSearchHandler2
+} from "./process-k319q0y1.js";
+import {
+  McpHandler2
+} from "./process-j26nh0zz.js";
+import {
+  CredentialHandler2
+} from "./process-b4s3wxap.js";
+import {
+  ProjectHandler2
+} from "./process-fa3dg36p.js";
+import {
+  WorktreeHandler2
+} from "./process-prrj1pgd.js";
+import {
+  VcsHandler2
+} from "./process-rkdaz036.js";
+import {
+  MigrationHandler2
+} from "./process-knez9aqv.js";
+import {
+  ConfigHandler2
+} from "./process-w0mvbrhx.js";
+
+// src/handlers.ts
+import { Layer } from "effect";
+var handlers2 = Layer.mergeAll(ServerHandler2, DebugHandler2, MigrationHandler2, LocationHandler2, AgentHandler2, PluginHandler2, SessionHandler2, MessageHandler2, ModelHandler2, GenerateHandler2, ProviderHandler2, IntegrationHandler2, WebSearchHandler2, McpHandler2, CredentialHandler2, ProjectHandler2, FormHandler2, PermissionHandler2, FileSystemHandler2, CommandHandler2, SkillHandler2, RpcHandler2, EventHandler2.pipe(Layer.provide(layer4)), PtyHandler2, PersistentPtyHandler2, ShellHandler2, ReferenceHandler2, WorktreeHandler2, VcsHandler2, ConfigHandler2);
+
+export { handlers2 };

package/dist/chunks/process-w0mvbrhx.js

@@ -0,0 +1,22 @@
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/config.ts
+import { Config } from "@opencode/core/config";
+import { ShellSelect } from "@opencode/core/shell/select";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var ConfigHandler2 = HttpApiBuilder.group(Api2, "server.config", (handlers) => handlers.handle("config.get", () => Config.Service.use((config) => config.entries())).handle("config.update", Effect.fn(function* (ctx) {
+  const config = yield* Config.Service;
+  if (!config.update)
+    return yield* Effect.die(new Error("Config updates are unavailable"));
+  return yield* config.update(ctx.payload).pipe(Effect.orDie);
+})).handle("config.shells", Effect.fn(function* () {
+  const shell = yield* ShellSelect.Service;
+  if (!shell.list)
+    return yield* Effect.die(new Error("Shell discovery is unavailable"));
+  return yield* shell.list();
+})));
+
+export { ConfigHandler2 };

package/dist/chunks/process-wt4btb09.js

@@ -0,0 +1,13 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/skill.ts
+import { Skill } from "@opencode/core/skill";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var SkillHandler2 = HttpApiBuilder.group(Api2, "server.skill", (handlers) => handlers.handle("skill.list", () => response2(Skill.Service.use((skill) => skill.list()))));
+
+export { SkillHandler2 };

package/dist/chunks/process-xettb16v.js

@@ -0,0 +1,22 @@
+import {
+  Api2
+} from "./process-ks9pc2xc.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/process-xn1y01ws.js

@@ -0,0 +1,29 @@
+import {
+  response2
+} from "./process-8j6eh3dh.js";
+import {
+  Api2
+} from "./process-ks9pc2xc.js";
+
+// src/handlers/provider.ts
+import { Provider } from "@opencode/core/provider";
+import { ProviderNotFoundError } from "@opencode/protocol/errors";
+import { Effect } from "effect";
+import { HttpApiBuilder } from "effect/unstable/httpapi";
+var ProviderHandler2 = HttpApiBuilder.group(Api2, "server.provider", (handlers) => Effect.gen(function* () {
+  return handlers.handle("provider.list", Effect.fn(function* () {
+    const providers = yield* Provider.Service;
+    return yield* response2(providers.available());
+  })).handle("provider.get", Effect.fn(function* (ctx) {
+    const providers = yield* Provider.Service;
+    const provider = yield* providers.get(ctx.params.providerID);
+    if (!provider)
+      return yield* new ProviderNotFoundError({
+        providerID: ctx.params.providerID,
+        message: `Provider not found: ${ctx.params.providerID}`
+      });
+    return yield* response2(Effect.succeed(provider));
+  }));
+}));
+
+export { ProviderHandler2 };

package/dist/chunks/process-xsrtpxyd.js

@@ -0,0 +1,23 @@
+import {
+  __export
+} from "./process-9rqn6x4v.js";
+
+// src/service-status.ts
+var exports_service_status = {};
+__export(exports_service_status, {
+  Status: () => exports_service_status,
+  make: () => make2
+});
+import { Effect, Ref } from "effect";
+var make2 = Effect.fnUntraced(function* (options = {}) {
+  const current = yield* Ref.make(options.initial ?? { type: "starting" });
+  const beginStopping = Ref.update(current, (status) => status.type === "stopping" ? status : { type: "stopping" });
+  return {
+    current: Ref.get(current),
+    ready: Ref.update(current, (status) => status.type === "starting" ? { type: "ready" } : status),
+    fail: Ref.update(current, (status) => status.type === "starting" ? { type: "failed" } : status),
+    beginStopping
+  };
+});
+
+export { make2, exports_service_status };

package/dist/chunks/process-yc7nft6q.js

@@ -0,0 +1,5 @@
+// src/request-tracing.ts
+import { Context, Effect, Tracer } from "effect";
+var withoutParentSpan2 = (effect) => effect.pipe(Effect.updateContext((context) => Context.omit(Tracer.ParentSpan)(context)));
+
+export { withoutParentSpan2 };

package/dist/chunks/process-zyv89x5n.js

@@ -0,0 +1,30 @@
+import {
+  __export
+} from "./process-9rqn6x4v.js";
+
+// src/auth.ts
+var exports_auth = {};
+__export(exports_auth, {
+  Config: () => Config2,
+  ServerAuth: () => exports_auth,
+  authorized: () => authorized2,
+  required: () => required2
+});
+import { Context, Layer, Option, Redacted } from "effect";
+
+class Config2 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() });
+  }
+}
+function required2(config) {
+  return Option.isSome(config.password) && config.password.value !== "";
+}
+function authorized2(credentials, config) {
+  return Option.isSome(config.password) && credentials.username === config.username && Redacted.value(credentials.password) === config.password.value;
+}
+
+export { Config2, required2, authorized2, exports_auth };

package/dist/cors.js

@@ -1,36 +1,10 @@
-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;
-  }
-}
+import {
+  CorsConfig2,
+  isAllowedCorsOrigin2,
+  isAllowedRequestOrigin2
+} from "./chunks/process-q4bn6dy8.js";
+export {
+  CorsConfig2 as CorsConfig,
+  isAllowedCorsOrigin2 as isAllowedCorsOrigin,
+  isAllowedRequestOrigin2 as isAllowedRequestOrigin
+};