Function createServerHandlers

apps/local/src/main.ts:70–128

(token: string)

};

export const createServerHandlers = async (token: string): Promise<ServerHandlers> => {
  let apiHandler: ServerHandlers["api"] | null = null;
  let mcp: McpRequestHandler | null = null;

  // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: handler boot owns the shared executor; partial startup failure must release it before rethrowing
  try {
    // The typed `/api` web-handler comes from `ExecutorApp.make` (./app.ts). The
    // boot bearer token is the authoritative `/api` gate (see `identity.ts`).
    apiHandler = await makeLocalApiHandler(token);

    // The in-process MCP server runs over the SAME boot executor, with its own
    // engine instance (the browser-approval + stdio surface is local-only and not
    // part of the shared API). Reuse the shared boot bundle so the MCP executor is
    // byte-identical to the one the API serves.
    const { executor } = await getExecutorBundle();
    const engine = createExecutionEngine({
      executor,
      codeExecutor: makeQuickJsExecutor(),
    });
    mcp = createMcpRequestHandler({
      defaultConfig: { engine },
      createConfigForResource: async (resource) => {
        if (resource.kind === "default") return { config: { engine } };
        const handle = await createExecutorHandle({
          activeToolkitSlug: resource.slug,
        });
        const toolkitEngine = createExecutionEngine({
          executor: handle.executor,
          codeExecutor: makeQuickJsExecutor(),
        });
        return {
          config: { engine: toolkitEngine },
          close: handle.dispose,
        };
      },
    });

    return { api: apiHandler, mcp };
  } catch (cause) {
    const partialApiHandler = apiHandler;
    const partialMcp = mcp;
    await Effect.runPromise(
      Effect.gen(function* () {
        yield* Effect.all(
          [
            partialApiHandler
              ? ignoreDisposeFailure("api.dispose", () => partialApiHandler.dispose())
              : Effect.void,
            partialMcp ? ignoreDisposeFailure("mcp.close", () => partialMcp.close()) : Effect.void,
          ],
          { concurrency: "unbounded" },
        );
        yield* ignoreDisposeFailure("disposeExecutor", () => disposeExecutor());
      }),
    );
    // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: async factory must reject with the original handler boot failure after cleanup
    throw cause;
  }