import { Effect, Layer } from "effect"; import { McpErrorReporter, type Principal } from "@executor-js/host-mcp";import {  McpEngineBuildError,  type McpBuildServer,  type McpBuildServerOptions,} from "@executor-js/host-mcp/in-memory-session-store";import { createExecutorMcpServer } from "@executor-js/host-mcp/tool-server";import {  artifactUrlFor,  type ArtifactSmokeRenderResult,} from "@executor-js/host-mcp/create-artifact"; import { ErrorCapture } from "../observability";import { CodeExecutorProvider, EngineDecorator, makeExecutionStack } from "./execution-stack";import { DbProvider } from "./executor-fuma-db";import { HostConfig, PluginsProvider, RequestOrgSlug } from "./scoped-executor"; // ---------------------------------------------------------------------------// Shared in-process MCP host helpers.//// Every host that serves MCP from one isolate (self-host, the Cloudflare QuickJS// host) builds its per-session McpServer the same way — assemble the scoped// engine via `makeExecutionStack`, wrap it with `createExecutorMcpServer` — and// reports orchestration defects through the same console `ErrorCapture` seam.// These two factories are the single home for that logic; a host supplies ONLY// its fully-provided execution-stack layer and its `ErrorCapture` layer. The// cross-isolate variant (cloud's Durable Object store) is the exception that// builds its engine inside the DO.// --------------------------------------------------------------------------- /** The five execution-stack seams a host fully provides (no residual). */export type McpExecutionStackLayer = Layer.Layer<  DbProvider | PluginsProvider | HostConfig | CodeExecutorProvider | EngineDecorator>; /** * Build the per-session MCP server factory over a host's execution stack: * `makeExecutionStack` → engine → `createExecutorMcpServer`. Hosts differ only * in the injected stack layer (libSQL vs D1, etc.). */export const makeMcpBuildServer =  (executionStack: McpExecutionStackLayer, hostOptions?: McpBuildHostOptions): McpBuildServer =>  (principal: Principal, options?: McpBuildServerOptions) =>    Effect.gen(function* () {      const { engine, executor } = yield* makeExecutionStack(        principal.accountId,        principal.organizationId,        principal.organizationName,        { mcpResource: options?.resource },      ).pipe(Effect.withSpan("mcp.execution_stack.build"));      // Read inside the provided boundary: `webBaseUrl` is a host seam, and      // hosts that can't know their public URL at boot leave it unset — in      // which case artifacts still persist but carry no deep link.      const hostConfig = yield* HostConfig;      return { engine, executor, webBaseUrl: hostConfig.webBaseUrl };    }).pipe(      // Pin browser-handoff URLs to the principal's org slug when present;      // absent slug leaves the service unprovided and the URL stays bare.      principal.organizationSlug !== undefined        ? Effect.provideService(RequestOrgSlug, { slug: principal.organizationSlug })        : (effect) => effect,      Effect.provide(executionStack),      Effect.mapError((cause) => new McpEngineBuildError({ cause })),      Effect.flatMap(({ engine, executor, webBaseUrl }) =>        createExecutorMcpServer({          engine,          artifacts: executor.artifacts,          connections: executor.connections,          ...(hostOptions?.loadAppShellHtml            ? { loadAppShellHtml: hostOptions.loadAppShellHtml }            : {}),          ...(hostOptions?.smokeRenderArtifact            ? { smokeRenderArtifact: hostOptions.smokeRenderArtifact }            : {}),          ...(hostOptions?.onArtifactUsage ? { onArtifactUsage: hostOptions.onArtifactUsage } : {}),          // Same org pinning as `RequestOrgSlug` above: self-host serves its          // console under `/<org-slug>` (`default` when unconfigured), so the          // deep link carries the principal's slug rather than relying on the          // browser's active org to canonicalize a bare path after landing.          ...(webBaseUrl            ? { artifactUrl: artifactUrlFor(webBaseUrl, principal.organizationSlug) }            : {}),          ...(options ?? {}),        }).pipe(          Effect.withSpan("mcp.server.create"),          Effect.map((mcpServer) => ({ mcpServer, engine })),        ),      ),    ); /** Per-host (not per-session) MCP wiring. Kept separate from *  `McpBuildServerOptions`, which the session store fills in per request. */export interface McpBuildHostOptions {  /** Serves the MCP-Apps shell resource. Hosts that can render generative UI   *  pass `loadMcpAppsShellHtml` from `@executor-js/mcp-apps-shell`; omitting it   *  leaves the ui-bearing tools unregistered. */  readonly loadAppShellHtml?: () => Promise<string>;  /** Trial-renders an artifact before it is saved, so a component that throws   *  on first render is refused at create time. Hosts that can afford React on   *  the server pass `smokeRenderArtifact` from `@executor-js/mcp-apps-shell`,   *  which loads it behind a dynamic import; omitting it skips the check. */  readonly smokeRenderArtifact?: (code: string) => Promise<ArtifactSmokeRenderResult>;  /** Forwarded to the tool server's `onArtifactUsage`: best-effort observation   *  of agent-driven artifact operations, for hosts recording product   *  analytics. */  readonly onArtifactUsage?: (action: "created" | "viewed" | "updated") => Effect.Effect<void>;} /** * The standard console `McpErrorReporter` seam: route an orchestration defect * the MCP envelope would otherwise swallow into a 500 through the host's * `ErrorCapture`, so operators still see it. Hosts differ only in the capture * layer (self-host/Cloudflare console; cloud overrides with Sentry separately). */export const makeConsoleMcpErrorReporter = (  errorCapture: Layer.Layer<ErrorCapture>,): Layer.Layer<McpErrorReporter> =>  Layer.effect(    McpErrorReporter,    Effect.gen(function* () {      const capture = yield* ErrorCapture;      return { report: (cause) => Effect.asVoid(capture.captureException(cause)) };    }),  ).pipe(Layer.provide(errorCapture));