Function makeSelfHostTestApp

apps/host-selfhost/src/testing/test-app.ts:206–269

(
  options: MakeSelfHostTestAppOptions,
)

}

export const makeSelfHostTestApp = async (
  options: MakeSelfHostTestAppOptions,
): Promise<SelfHostTestHandler> => {
  const config = loadConfig();

  const dbHandle = await createSelfHostDb({
    path: options.dbPath ?? config.dbPath,
    namespace: SELF_HOST_NAMESPACE,
    version: SELF_HOST_SCHEMA_VERSION,
  });

  const sessionStore = makeSelfHostMcpSessionStore(dbHandle);
  const pluginsProvider = options.pluginDeps
    ? Layer.succeed(PluginsProvider)({
        plugins: (context) =>
          executorConfig.plugins({
            ...options.pluginDeps,
            activeToolkitSlug:
              context?.mcpResource?.kind === "toolkit"
                ? context.mcpResource.slug
                : options.pluginDeps?.activeToolkitSlug,
            allowLocalNetwork:
              options.pluginDeps?.allowLocalNetwork ??
              process.env.EXECUTOR_ALLOW_LOCAL_NETWORK === "true",
          }),
      })
    : SelfHostPluginsProvider;

  const { toWebHandler } = ExecutorApp.make({
    plugins: selfHostPlugins,
    providers: {
      identity: options.identity,
      db: SelfHostDbProvider,
      engine: { codeExecutor: SelfHostCodeExecutorProvider },
      mcp: {
        auth: stubMcpAuth,
        sessions: selfHostMcpSessions(sessionStore),
        reporter: selfHostMcpReporter,
      },
      plugins: { provider: pluginsProvider, config: SelfHostHostConfig },
      errorCapture: ErrorCaptureLive,
    },
    extensions: {
      routes: [
        HttpApiSwagger.layer(composePluginApi(selfHostPlugins).prefix("/api"), { path: "/docs" }),
      ],
    },
    config: { mountPrefix: "/api", failure: textFailureStrategy },
    // The test identity is boot-scoped exactly as production's is: no
    // requestScoped layer, so the execution middleware leaves IdentityProvider
    // residual and `provideMerge(boot)` supplies it.
    boot: Layer.merge(Layer.succeed(SelfHostDb)(dbHandle), options.identity),
  });

  const web = toWebHandler();
  return {
    handler: web.handler,
    dispose: async () => {