@cursor/july 0.1.1

package/dist/internal/server.js

@@ -0,0 +1,1374 @@
+/**
+ * The HTTP host: a plain node:http server that adapts requests to the Fetch
+ * API, resolves route auth, and dispatches to the built-in HTTP channel
+ * routes, custom channel routes (under `/v1/channels/<id>`), and the
+ * server-level health / info / dev-dispatch routes.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { Buffer } from "node:buffer";
+import { once } from "node:events";
+import { createServer, } from "node:http";
+import { join } from "node:path";
+import { findGitHubChannelTargets } from "../channels/github/forward.js";
+import { dispatchCursorSlackEnvelope, getSlackCursorAccountRuntime, } from "../channels/slack/cursor-account.js";
+import { allowAll, bearerAuth, localDevStrict } from "../channels.js";
+import { CursorAccountMcpBridge, collectCursorAccountConnections, cursorAccountMcpPath, } from "./cursor/account-mcp.js";
+import { CursorBackendClient } from "./cursor/backend-client.js";
+import { cursorBackendUrl, resolveApiKey, SIGN_IN_HINT, } from "./cursor/credentials.js";
+import { CursorEventRelay, formatCursorScmEventLog, scmMetadataToGitHubPayload, } from "./cursor-event-relay.js";
+import { CursorSlackRelay, createCursorSlackApiCaller, formatCursorSlackEventLog, } from "./cursor-slack-relay.js";
+import { formatDiagnostics, hasErrorDiagnostics, projectInfo, } from "./discovery.js";
+import { packageVersion } from "./distribution.js";
+import { docsSiteExists, ensureDocsSiteBundle, renderDocsFile, } from "./docs-site.js";
+import { EvalRunConflictError, EvalRunEmptyError, EvalRunStore, } from "./eval-run-store.js";
+import { collectGitHubTriggerTargets, handleAgentServeTrigger, } from "./handleAgentServeTrigger.js";
+import { warmupHostGitHubAuth } from "./host-platforms.js";
+import { buildHttpChannelRoutes, errorResponse, jsonResponse, readJsonObject, requireSessionOwner, } from "./http-channel.js";
+import { validateToolInput } from "./json-schema.js";
+import { createLogRing } from "./log-ring.js";
+import { createAgentMcpEndpoint, MCP_ENDPOINT_PATH } from "./mcp-endpoint.js";
+import { isLoopbackAddress } from "./net.js";
+import { collectPeerConnections } from "./peer-connections.js";
+import { renderAgentsIndexHtml, renderPlaygroundAsset, renderPlaygroundIndexHtml, } from "./playground/static.js";
+import { ensurePlaygroundBundle, playgroundDevBaseFromEnv, playgroundDevBasePath, startPlaygroundDevServer, } from "./playground/toolchain.js";
+import { ReminderRunner, ReminderValidationError, UnknownReminderError, } from "./reminder-runner.js";
+import { assertAccountConnectionsNotAnonymous, resolveMountConnections, validateMountConnectionsConfig, } from "./resolved-connections.js";
+import { Router } from "./router.js";
+import { ScheduleRunner, UnknownScheduleError } from "./schedule-runner.js";
+import { CursorSdkRunner } from "./sdk-runner.js";
+import { SessionAuthError, SessionBusyError, SessionEngine, ToolInputError, ToolNotDirectlyCallableError, UnknownToolError, } from "./session-engine.js";
+import { sessionUrlsForRequest } from "./session-urls.js";
+const MAX_BODY_BYTES = 32 * 1024 * 1024;
+/**
+ * Start an HTTP server hosting one or more agents. A single agent with an
+ * empty slug serves at `/v1/*` and `/playground`; multiple agents each serve
+ * under `/<slug>/v1/*` and `/<slug>/playground`, with an index at `/`.
+ */
+export function startServer(mounts_1) {
+    return __awaiter(this, arguments, void 0, function* (mounts, options = {}) {
+        var _a, _b;
+        var _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        var _q;
+        if (mounts.length === 0) {
+            throw new Error("startServer requires at least one agent mount");
+        }
+        const multi = mounts.length > 1 || ((_a = mounts[0]) === null || _a === void 0 ? void 0 : _a.slug) !== "";
+        for (const { slug, project } of mounts) {
+            if (hasErrorDiagnostics(project)) {
+                const label = slug === "" ? project.name : `${slug} (${project.name})`;
+                throw new Error(`Refusing to serve agent ${label} — it has errors:\n${formatDiagnostics(project.diagnostics.filter((d) => d.severity === "error"))}`);
+            }
+        }
+        const logRing = createLogRing({ capacity: 2000 });
+        const logger = logRing.wrap((_c = options.logger) !== null && _c !== void 0 ? _c : ((line) => console.log(line)));
+        const dev = (_d = options.dev) !== null && _d !== void 0 ? _d : false;
+        const playground = (_e = options.playground) !== null && _e !== void 0 ? _e : true;
+        const runSchedules = (_f = options.schedules) !== null && _f !== void 0 ? _f : !dev;
+        const runReminders = (_g = options.reminders) !== null && _g !== void 0 ? _g : !dev;
+        // Identify this process to the Cursor backend as agentkit (the SDK reads
+        // this when building its client-version header) so the internal-only
+        // agentkit_enabled gate applies to every turn.
+        (_h = (_q = process.env).CURSOR_AGENTKIT_VERSION) !== null && _h !== void 0 ? _h : (_q.CURSOR_AGENTKIT_VERSION = packageVersion());
+        // One resolution for every Cursor credential consumer (SDK runner, account
+        // MCP bridge, SCM event relay): explicit option → CURSOR_API_KEY → stored
+        // `agent-serve login`.
+        const accountKey = yield resolveApiKey(options.apiKey === undefined ? {} : { apiKey: options.apiKey });
+        // The SCM relay reads the event stream as the signed-in user, so
+        // `cursorEvents` cannot work signed out. Require the credential before any
+        // slow or stateful startup work (playground build, channel onStart, cron).
+        const cursorEventsAuth = options.cursorEvents === undefined
+            ? undefined
+            : requireCursorEventsAuth(options.cursorEvents, accountKey);
+        if (playground) {
+            // Auto-build dist/playground when missing (monorepo / source checkout).
+            // Published installs already ship the bundle; vite may be absent there.
+            yield ensurePlaygroundBundle(logger);
+        }
+        const docsSite = (_j = options.docs) !== null && _j !== void 0 ? _j : true;
+        if (docsSite) {
+            // Same pattern for the documentation site at /docs.
+            yield ensureDocsSiteBundle(logger);
+        }
+        if (options.allowAnonymous === true) {
+            logger("[agent-serve] warning: --allow-anonymous admits every HTTP caller as the same principal; use only on a trusted network (e.g. Tailscale) and prefer --bearer-token for shared hosts");
+        }
+        const runner = (_k = options.runner) !== null && _k !== void 0 ? _k : new CursorSdkRunner(accountKey === undefined ? {} : { apiKey: accountKey.apiKey });
+        const router = new Router();
+        const runtimes = [];
+        const channelStopHooks = [];
+        let githubAuthWarmed = false;
+        // Validate peer MCP connections (defineConnection({ agent })) against the
+        // mount set before anything starts: unknown slugs and self-references are
+        // authoring errors. URLs resolve after listen, once the port is known.
+        const peerRefsBySlug = collectPeerConnections(mounts);
+        // Cursor account MCP connections (defineConnection({ cursorAccount: true }))
+        // need a signed-in host: their tools execute on the Cursor backend with
+        // the account's stored OAuth credentials. Fail fast at serve start instead
+        // of at the first turn.
+        const accountRefsBySlug = collectCursorAccountConnections(mounts);
+        assertAccountConnectionsNotAnonymous({
+            allowAnonymous: options.allowAnonymous,
+            hasAccountConnections: accountRefsBySlug.size > 0,
+        });
+        let accountBridge;
+        if (accountRefsBySlug.size > 0) {
+            if (accountKey === undefined) {
+                throw new Error(`This project has Cursor account MCP connections (defineConnection({ cursorAccount: true })) but the host is not signed in to Cursor. ${SIGN_IN_HINT}`);
+            }
+            accountBridge = new CursorAccountMcpBridge({
+                client: new CursorBackendClient({
+                    backendUrl: accountKey.backendUrl,
+                    apiKey: accountKey.apiKey,
+                    logger,
+                }),
+                logger,
+                // Cloud turns reach the bridge through the serve publicUrl; without
+                // one, the bridge admits loopback callers only.
+                allowRemoteCallers: options.publicUrl !== undefined,
+            });
+        }
+        for (const { slug, project } of mounts) {
+            // Each agent gets an isolated state root so their sessions never mix.
+            const baseStateRoot = (_l = options.stateRoot) !== null && _l !== void 0 ? _l : join(project.rootDir, ".agent-serve");
+            const stateRoot = slug === "" ? baseStateRoot : join(baseStateRoot, slug);
+            const engine = new SessionEngine({ project, stateRoot, runner, logger });
+            if (!githubAuthWarmed) {
+                // Soft ambient GitHub auth check before channel onStart (which may call
+                // host.github). Missing auth is a warning only — serve still starts.
+                yield warmupHostGitHubAuth({ logger, github: engine.host.github });
+                githubAuthWarmed = true;
+            }
+            const scheduleRunner = new ScheduleRunner(engine, project, logger);
+            const reminderRunner = new ReminderRunner(engine, logger);
+            const evalRuns = new EvalRunStore(project.rootDir, logger);
+            engine.setReminders({
+                create: (input) => reminderRunner.create(input),
+                list: (filter) => reminderRunner.list(filter),
+                cancel: (id, reason) => reminderRunner.cancel(id, reason),
+                cancelForContinuation: (token, reason) => reminderRunner.cancelForContinuation(token, reason),
+                dispatch: (id) => reminderRunner.dispatch(id),
+            });
+            const runtime = {
+                slug,
+                project,
+                engine,
+                scheduleRunner,
+                reminderRunner,
+                evalRuns,
+            };
+            runtimes.push(runtime);
+            const accountRefs = accountRefsBySlug.get(slug);
+            mountAgentRoutes(router, runtime, Object.assign(Object.assign(Object.assign({ dev,
+                playground,
+                multi,
+                logger,
+                logRing }, (options.authToken === undefined
+                ? {}
+                : { authToken: options.authToken })), (options.allowAnonymous === true ? { allowAnonymous: true } : {})), (accountRefs !== undefined && accountBridge !== undefined
+                ? { accountBridge, accountRefs }
+                : {})));
+            for (const channel of project.channels) {
+                const definition = channel.definition;
+                if (definition.onStop !== undefined) {
+                    channelStopHooks.push(() => { var _a; return (_a = definition.onStop) === null || _a === void 0 ? void 0 : _a.call(definition); });
+                }
+                if (definition.onStart !== undefined) {
+                    const startArgs = {
+                        send: (message, sendOptions) => engine.send(channel.id, message, sendOptions),
+                        getSession: (sessionId) => engine.getChannelSession(channel.id, sessionId),
+                        receive: (target, input) => engine.receive(target, input),
+                        callTool: (toolName, input, callOptions) => engine.callTool(toolName, input, callOptions),
+                        emitAssistantMessage: (sessionId, text) => engine.emitAssistantMessage(sessionId, text),
+                        host: engine.host,
+                        waitUntil: (promise) => {
+                            engine.trackBackground(promise);
+                        },
+                        resolveApproval: (sessionId, callId, decision, auth) => engine.resolveApproval(sessionId, callId, decision, auth),
+                        logger,
+                    };
+                    try {
+                        yield definition.onStart(startArgs);
+                    }
+                    catch (error) {
+                        logger(`[agent-serve] channel "${channel.id}" onStart failed: ${error instanceof Error
+                            ? ((_m = error.stack) !== null && _m !== void 0 ? _m : error.message)
+                            : String(error)}`);
+                    }
+                }
+            }
+            if (runSchedules) {
+                scheduleRunner.start();
+            }
+            if (runReminders) {
+                yield reminderRunner.start();
+            }
+        }
+        if (docsSite) {
+            // The framework documentation site, mounted at /docs in both layouts
+            // ("docs" is a reserved slug). Static, no secrets; unauthenticated like
+            // the playground assets.
+            router.add({
+                method: "GET",
+                pattern: "/docs",
+                auth: "none",
+                handler: () => renderDocsFile(""),
+            });
+            router.add({
+                method: "GET",
+                pattern: "/docs/*path",
+                auth: "none",
+                handler: (_request, ctx) => { var _a; return renderDocsFile((_a = ctx.params.path) !== null && _a !== void 0 ? _a : ""); },
+            });
+        }
+        if (multi) {
+            // Host-level liveness for ALB / ECS health checks. Per-agent health stays
+            // at `/<slug>/v1/health`; without this, multi-mode has no `/v1/health`.
+            router.add({
+                method: "GET",
+                pattern: "/v1/health",
+                auth: "none",
+                handler: () => jsonResponse({
+                    ok: true,
+                    agents: runtimes.map(({ slug, project }) => ({
+                        slug,
+                        name: project.name,
+                    })),
+                }),
+            });
+            if (playground) {
+                const cursorSlackBySlug = new Map(collectCursorSlackTargets(runtimes).map((target) => [
+                    target.runtime.slug,
+                    target.agentName,
+                ]));
+                const entries = runtimes.map(({ slug, project }) => {
+                    var _a;
+                    var _b;
+                    const cursorName = cursorSlackBySlug.get(slug);
+                    const hasSocketSlack = project.channels.some((channel) => { var _a, _b; return ((_a = channel.definition.meta) === null || _a === void 0 ? void 0 : _a.kind) === "slack" &&
+                        ((_b = channel.definition.meta) === null || _b === void 0 ? void 0 : _b.slackCursorAccount) !== true; });
+                    const slack = cursorName !== undefined
+                        ? {
+                            kind: "cursor-account",
+                            handle: `@Cursor ${cursorName}`,
+                        }
+                        : hasSocketSlack
+                            ? { kind: "socket" }
+                            : undefined;
+                    return Object.assign({ slug, name: project.name, model: typeof project.agent.model === "string"
+                            ? project.agent.model
+                            : ((_b = (_a = project.agent.model) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : ""), tools: project.agent.tools.length, channels: project.channels.length + 1 }, (slack !== undefined ? { slack } : {}));
+                });
+                const indexHtml = renderAgentsIndexHtml(entries);
+                router.add({
+                    method: "GET",
+                    pattern: "/",
+                    auth: "none",
+                    handler: () => new Response(indexHtml, {
+                        headers: { "content-type": "text/html; charset=utf-8" },
+                    }),
+                });
+                router.add({
+                    method: "GET",
+                    pattern: "/v1/agents",
+                    auth: "none",
+                    handler: () => jsonResponse({ agents: entries }),
+                });
+            }
+        }
+        // Shared GitHub webhook ingress: one URL fans out to every mounted agent
+        // that declared a github channel. Signature verification is the caller's
+        // job (backend `/github_webhook` already verified); we only admit loopback
+        // so this route is not a public unsigned endpoint. Agents decide whether
+        // to run via their onPullRequest / onComment / … hooks.
+        const collectTriggerTargets = () => collectGitHubTriggerTargets({
+            mounts: runtimes.map((runtime) => ({
+                slug: runtime.slug,
+                channels: runtime.project.channels,
+                buildHandlerArgs: (channelId) => buildChannelHandlerArgs({ runtime, channelId }),
+            })),
+        });
+        router.add({
+            method: "POST",
+            pattern: "/v1/webhooks/github",
+            auth: [localDevStrict()],
+            handler: (request) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                var _b, _c;
+                const bodyText = yield request.text();
+                const result = yield handleAgentServeTrigger({
+                    type: "github",
+                    bodyText,
+                    eventName: request.headers.get("x-github-event"),
+                    deliveryId: (_b = request.headers.get("x-github-delivery")) !== null && _b !== void 0 ? _b : undefined,
+                    targets: collectTriggerTargets(),
+                });
+                const status = result.ok ? 202 : ((_c = (_a = result.targets[0]) === null || _a === void 0 ? void 0 : _a.status) !== null && _c !== void 0 ? _c : 500);
+                return jsonResponse(result, { status });
+            }),
+        });
+        for (const { slug, project } of mounts) {
+            validateMountConnectionsConfig(Object.assign({ slug,
+                project, accountRefs: accountRefsBySlug.get(slug) }, (options.publicUrl === undefined
+                ? {}
+                : { publicUrl: options.publicUrl })));
+        }
+        // Cursor SCM events relay (opt-in: serve({ cursorEvents }) / --cursor-events).
+        const cursorEventRelay = startCursorEventRelay({
+            options,
+            mounts,
+            auth: cursorEventsAuth,
+            logger,
+            collectTriggerTargets,
+        });
+        // Cursor Slack relay: automatic when a mounted agent authored
+        // `slackChannel({ cursorAccount: true })`. Inbound rides the account's
+        // Slack connection (`/v0/slack-events`); the classic Socket-Mode path is
+        // untouched for channels with their own Slack app tokens.
+        const cursorSlackRelay = yield startCursorSlackRelay({
+            options,
+            runtimes,
+            accountKey,
+            logger,
+        });
+        const server = createServer((req, res) => {
+            void handleRequest(router, req, res, logger);
+        });
+        const host = (_o = options.host) !== null && _o !== void 0 ? _o : "127.0.0.1";
+        const port = (_p = options.port) !== null && _p !== void 0 ? _p : 3000;
+        server.listen(port, host);
+        yield once(server, "listening");
+        const address = server.address();
+        const displayHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
+        const url = `http://${displayHost}:${address.port}`;
+        // Resolve peer + Cursor account MCP connections now that the listen port is
+        // known (see resolved-connections.ts for the URL/runtime rules).
+        for (const runtime of runtimes) {
+            const peerRefs = peerRefsBySlug.get(runtime.slug);
+            const accountRefs = accountRefsBySlug.get(runtime.slug);
+            const resolved = resolveMountConnections(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ slug: runtime.slug, project: runtime.project, serverUrl: url }, (peerRefs === undefined ? {} : { peerRefs })), (accountRefs !== undefined && accountBridge !== undefined
+                ? { accountRefs, accountBridge }
+                : {})), (options.publicUrl === undefined
+                ? {}
+                : { publicUrl: options.publicUrl })), (options.authToken === undefined
+                ? {}
+                : { authToken: options.authToken })), { logger }));
+            if (resolved.length > 0) {
+                runtime.engine.setResolvedConnections(resolved);
+            }
+        }
+        const agents = runtimes.map(({ slug, project }) => ({
+            slug,
+            project,
+            url: slug === "" ? url : `${url}/${slug}`,
+        }));
+        for (const runtime of runtimes) {
+            runtime.evalRuns.loopbackUrl =
+                runtime.slug === "" ? url : `${url}/${runtime.slug}`;
+        }
+        const runtimeBySlug = new Map(runtimes.map((r) => [r.slug, r]));
+        // --dev: spawn Vite HMR. Single-agent infers the slug base; multi-agent
+        // serves `/<slug>/playground` on the HMR origin (optional AGENT_SERVE_BASE
+        // pins one slug at the HMR root instead).
+        let playgroundDev;
+        if (playground && dev) {
+            const pinnedBase = mounts.length === 1
+                ? playgroundDevBasePath(mounts)
+                : playgroundDevBaseFromEnv();
+            const multiAgent = mounts.length > 1 && pinnedBase === undefined;
+            playgroundDev = startPlaygroundDevServer({
+                targetUrl: url,
+                basePath: pinnedBase,
+                multiAgent,
+                logger,
+            });
+        }
+        const handle = {
+            url,
+            port: address.port,
+            project: (_b = runtimes[0]) === null || _b === void 0 ? void 0 : _b.project,
+            agents,
+            dispatchSchedule: (name, slug) => {
+                var _a;
+                var _b;
+                if (slug === void 0) { slug = (_b = (_a = runtimes[0]) === null || _a === void 0 ? void 0 : _a.slug) !== null && _b !== void 0 ? _b : ""; }
+                const runtime = runtimeBySlug.get(slug);
+                if (runtime === undefined) {
+                    throw new Error(`Unknown agent slug "${slug}"`);
+                }
+                return runtime.scheduleRunner.dispatch(name);
+            },
+            createReminder: (input, slug) => {
+                var _a;
+                var _b;
+                if (slug === void 0) { slug = (_b = (_a = runtimes[0]) === null || _a === void 0 ? void 0 : _a.slug) !== null && _b !== void 0 ? _b : ""; }
+                const runtime = runtimeBySlug.get(slug);
+                if (runtime === undefined) {
+                    throw new Error(`Unknown agent slug "${slug}"`);
+                }
+                return runtime.reminderRunner.create(input);
+            },
+            listReminders: (filter, slug) => {
+                var _a;
+                var _b;
+                if (slug === void 0) { slug = (_b = (_a = runtimes[0]) === null || _a === void 0 ? void 0 : _a.slug) !== null && _b !== void 0 ? _b : ""; }
+                const runtime = runtimeBySlug.get(slug);
+                if (runtime === undefined) {
+                    throw new Error(`Unknown agent slug "${slug}"`);
+                }
+                return runtime.reminderRunner.list(filter);
+            },
+            cancelReminder: (id, options) => {
+                var _a;
+                var _b, _c;
+                const slug = (_c = (_b = options === null || options === void 0 ? void 0 : options.slug) !== null && _b !== void 0 ? _b : (_a = runtimes[0]) === null || _a === void 0 ? void 0 : _a.slug) !== null && _c !== void 0 ? _c : "";
+                const runtime = runtimeBySlug.get(slug);
+                if (runtime === undefined) {
+                    throw new Error(`Unknown agent slug "${slug}"`);
+                }
+                return runtime.reminderRunner.cancel(id, options === null || options === void 0 ? void 0 : options.reason);
+            },
+            dispatchReminder: (id, slug) => {
+                var _a;
+                var _b;
+                if (slug === void 0) { slug = (_b = (_a = runtimes[0]) === null || _a === void 0 ? void 0 : _a.slug) !== null && _b !== void 0 ? _b : ""; }
+                const runtime = runtimeBySlug.get(slug);
+                if (runtime === undefined) {
+                    throw new Error(`Unknown agent slug "${slug}"`);
+                }
+                return runtime.reminderRunner.dispatch(id);
+            },
+            callTool: (toolName, input, options) => {
+                var _a;
+                var _b;
+                const _c = options !== null && options !== void 0 ? options : {}, { slug } = _c, callOptions = __rest(_c, ["slug"]);
+                const runtime = runtimeBySlug.get((_b = slug !== null && slug !== void 0 ? slug : (_a = runtimes[0]) === null || _a === void 0 ? void 0 : _a.slug) !== null && _b !== void 0 ? _b : "");
+                if (runtime === undefined) {
+                    throw new Error(`Unknown agent slug "${slug}"`);
+                }
+                return runtime.engine.callTool(toolName, input, callOptions);
+            },
+            close: () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                playgroundDev === null || playgroundDev === void 0 ? void 0 : playgroundDev.stop();
+                yield cursorEventRelay === null || cursorEventRelay === void 0 ? void 0 : cursorEventRelay.stop();
+                yield cursorSlackRelay === null || cursorSlackRelay === void 0 ? void 0 : cursorSlackRelay.stop();
+                for (const runtime of runtimes) {
+                    runtime.scheduleRunner.stop();
+                    runtime.reminderRunner.stop();
+                }
+                for (const stop of channelStopHooks) {
+                    try {
+                        yield stop();
+                    }
+                    catch (error) {
+                        logger(`[agent-serve] channel onStop failed: ${error instanceof Error
+                            ? ((_a = error.stack) !== null && _a !== void 0 ? _a : error.message)
+                            : String(error)}`);
+                    }
+                }
+                server.close();
+                server.closeAllConnections();
+                yield Promise.all(runtimes.map((runtime) => runtime.engine.close()));
+            }),
+        };
+        if ((playgroundDev === null || playgroundDev === void 0 ? void 0 : playgroundDev.url) !== undefined) {
+            handle.playgroundDevUrl = playgroundDev.url;
+        }
+        if (docsSite && docsSiteExists()) {
+            handle.docsUrl = `${handle.url}/docs`;
+        }
+        return handle;
+    });
+}
+function mountAgentRoutes(router, runtime, args) {
+    var _a, _b, _c;
+    const { slug, project, engine, scheduleRunner, reminderRunner } = runtime;
+    const { dev, playground, multi, logger, logRing } = args;
+    // "" (single) -> "/v1/..."; "my-agent" (multi) -> "/my-agent/v1/...".
+    const base = slug === "" ? "" : `/${slug}`;
+    // The Cursor account MCP bridge for this mount's account MCP connections:
+    // loopback-only + per-boot bearer secret, never on the public auth chain.
+    if (args.accountBridge !== undefined && args.accountRefs !== undefined) {
+        const bridge = args.accountBridge;
+        const refByName = new Map(args.accountRefs.map((ref) => [ref.name, ref]));
+        router.add({
+            method: "POST",
+            pattern: `${base}${cursorAccountMcpPath(":connection")}`,
+            auth: [bridge.authPolicy()],
+            handler: (request, ctx) => {
+                var _a, _b;
+                const ref = refByName.get((_a = ctx.params.connection) !== null && _a !== void 0 ? _a : "");
+                if (ref === undefined) {
+                    return errorResponse(404, "not_found", `No Cursor account MCP connection named "${(_b = ctx.params.connection) !== null && _b !== void 0 ? _b : ""}" on this agent.`);
+                }
+                return bridge.handle(request, ref);
+            },
+        });
+    }
+    const defaultAuth = args.authToken !== undefined
+        ? [bearerAuth(args.authToken)]
+        : args.allowAnonymous === true
+            ? [allowAll()]
+            : [localDevStrict()];
+    const httpAuth = (_a = project.httpChannel.auth) !== null && _a !== void 0 ? _a : defaultAuth;
+    // Playground lists/opens Slack (and other channel) sessions across
+    // principals when `--dev` (loopback) or `--allow-anonymous` (trusted
+    // shared host, e.g. corp Okta ALB). Never when bearer / custom channel
+    // auth is set — those keep strict per-principal isolation.
+    const relaxSessionReadAuth = args.authToken === undefined &&
+        project.httpChannel.auth === undefined &&
+        (dev || args.allowAnonymous === true);
+    const relaxSessionReadAuthBeyondLoopback = args.allowAnonymous === true;
+    // Separate from read-relax: playground Approve/Deny on Slack-owned parked
+    // tools (Slack principals never match local/anonymous HTTP auth).
+    const relaxSessionApprovalAuth = relaxSessionReadAuth;
+    router.add({
+        method: "GET",
+        pattern: `${base}/v1/health`,
+        auth: "none",
+        handler: () => jsonResponse({ ok: true, name: project.name }),
+    });
+    // Bootstrap the SPA can't derive from its own URL (agent name, dev mode, and
+    // — in multi-agent mode — where the agents index lives).
+    router.add({
+        method: "GET",
+        pattern: `${base}/v1/meta`,
+        auth: "none",
+        handler: () => jsonResponse(Object.assign({ name: project.name, dev, basePath: base }, (multi ? { indexPath: "/" } : {}))),
+    });
+    router.add({
+        method: "GET",
+        pattern: `${base}/v1/info`,
+        auth: httpAuth,
+        handler: () => jsonResponse(projectInfo(project)),
+    });
+    // Playground Logs tab: recent ServeOptions.logger lines (channels, sessions,
+    // webhook capture). `after` is an exclusive index cursor for polling.
+    router.add({
+        method: "GET",
+        pattern: `${base}/v1/logs`,
+        auth: httpAuth,
+        handler: (request) => {
+            var _a;
+            var _b;
+            const url = new URL(request.url);
+            const afterRaw = url.searchParams.get("after");
+            const after = afterRaw === null || afterRaw === ""
+                ? -1
+                : Number.parseInt(afterRaw, 10);
+            const cursor = Number.isFinite(after) ? after : -1;
+            const entries = logRing.since(cursor);
+            return jsonResponse({
+                entries,
+                nextAfter: entries.length === 0
+                    ? cursor
+                    : ((_b = (_a = entries[entries.length - 1]) === null || _a === void 0 ? void 0 : _a.index) !== null && _b !== void 0 ? _b : cursor),
+            });
+        },
+    });
+    router.add({
+        method: "GET",
+        pattern: `${base}/v1/sessions`,
+        auth: httpAuth,
+        handler: (_request, ctx) => __awaiter(this, void 0, void 0, function* () {
+            // Same gate as requireSessionOwner / relaxSessionReadAuth: never with
+            // bearer or custom channel auth (strict per-principal isolation).
+            // `--allow-anonymous` alone is a shared-principal trust boundary (corp
+            // Okta ALB); `--dev` alone stays loopback-only.
+            const includeAll = relaxSessionReadAuth &&
+                (relaxSessionReadAuthBeyondLoopback ||
+                    (typeof ctx.requestIp === "string" &&
+                        isLoopbackAddress(ctx.requestIp)));
+            return jsonResponse({
+                sessions: yield engine.listSessions(ctx.auth, { includeAll }),
+            });
+        }),
+    });
+    // Playground A/Bs tab: fold durable event streams into per-session
+    // assignments and aggregate arm metrics (built-ins + derive).
+    router.add({
+        method: "GET",
+        pattern: `${base}/v1/abs`,
+        auth: httpAuth,
+        handler: (_request, ctx) => __awaiter(this, void 0, void 0, function* () {
+            const includeAll = dev === true &&
+                (args.allowAnonymous === true ||
+                    (typeof ctx.requestIp === "string" &&
+                        isLoopbackAddress(ctx.requestIp)));
+            return jsonResponse(yield engine.abSnapshot(ctx.auth, { includeAll }));
+        }),
+    });
+    // The agent's MCP surface: peers and external MCP clients delegate to
+    // this agent (ask / check / call_tool) over streamable HTTP. Stateless —
+    // POST only; GET/DELETE get a spec-compliant 405 from the endpoint.
+    const mcpEndpoint = createAgentMcpEndpoint({ engine, logger });
+    for (const method of ["POST", "GET", "DELETE"]) {
+        router.add({
+            method,
+            pattern: `${base}${MCP_ENDPOINT_PATH}`,
+            auth: httpAuth,
+            handler: (request, ctx) => mcpEndpoint.handle(request, ctx.auth),
+        });
+    }
+    // Deterministic tool invocation: run an authored server tool directly,
+    // without a model turn deciding to call it.
+    router.add({
+        method: "POST",
+        pattern: `${base}/v1/tools/:toolName`,
+        auth: httpAuth,
+        handler: (request, ctx) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const toolName = (_a = ctx.params.toolName) !== null && _a !== void 0 ? _a : "";
+            const body = yield readJsonObject(request);
+            if (body === undefined) {
+                return errorResponse(400, "invalid_request", 'Expected a JSON object body, e.g. {"input": {...}}.');
+            }
+            if (body.sessionId !== undefined && typeof body.sessionId !== "string") {
+                return errorResponse(400, "invalid_request", "`sessionId` must be a string when provided.");
+            }
+            const sessionId = body.sessionId;
+            if (sessionId !== undefined) {
+                const record = yield engine.sessions.get(sessionId);
+                if (record === undefined) {
+                    return errorResponse(404, "session_not_found", `Unknown session ${sessionId}.`);
+                }
+                const ownership = requireSessionOwner(record, ctx.auth, {
+                    relax: relaxSessionReadAuth,
+                    beyondLoopback: relaxSessionReadAuthBeyondLoopback,
+                    requestIp: ctx.requestIp,
+                });
+                if (ownership !== undefined) {
+                    return ownership;
+                }
+            }
+            try {
+                const outcome = yield engine.callTool(toolName, (_b = body.input) !== null && _b !== void 0 ? _b : {}, Object.assign({ auth: ctx.auth }, (sessionId === undefined ? {} : { sessionId })));
+                return jsonResponse(Object.assign({ ok: !outcome.isError }, outcome));
+            }
+            catch (error) {
+                if (error instanceof UnknownToolError) {
+                    return jsonResponse({
+                        ok: false,
+                        error: "unknown_tool",
+                        message: error.message,
+                        availableTools: error.availableToolNames,
+                    }, { status: 404 });
+                }
+                if (error instanceof ToolNotDirectlyCallableError) {
+                    return errorResponse(400, "tool_not_callable", error.message);
+                }
+                if (error instanceof ToolInputError) {
+                    return errorResponse(400, "invalid_tool_input", error.message);
+                }
+                throw error;
+            }
+        }),
+    });
+    if (playground) {
+        // Serve the built Vite SPA. `<base href>` is injected so the SPA's relative
+        // asset URLs resolve under this mount regardless of the trailing slash the
+        // browser lands on. Render per request so a mid-run `build:playground`
+        // is picked up without restarting. In dev, run `pnpm run dev:playground`
+        // (Vite + HMR) instead; it proxies `/v1` here.
+        router.add({
+            method: "GET",
+            pattern: `${base}/playground`,
+            auth: "none",
+            handler: () => new Response(renderPlaygroundIndexHtml(`${base}/playground/`), {
+                headers: { "content-type": "text/html; charset=utf-8" },
+            }),
+        });
+        router.add({
+            method: "GET",
+            pattern: `${base}/playground/assets/:file`,
+            auth: "none",
+            handler: (_request, ctx) => { var _a; return renderPlaygroundAsset((_a = ctx.params.file) !== null && _a !== void 0 ? _a : ""); },
+        });
+        if (!multi) {
+            router.add({
+                method: "GET",
+                pattern: "/",
+                auth: "none",
+                handler: () => new Response(null, {
+                    status: 302,
+                    headers: { location: "/playground" },
+                }),
+            });
+        }
+    }
+    for (const route of buildHttpChannelRoutes({
+        engine,
+        config: project.httpChannel,
+        auth: httpAuth,
+        basePath: base,
+        // Dev playground lists every session (`includeAll`); allow opening them
+        // (see relaxSessionReadAuth above).
+        relaxSessionReadAuth,
+        relaxSessionReadAuthBeyondLoopback,
+        relaxSessionApprovalAuth,
+    })) {
+        router.add(route);
+    }
+    // Playground eval list/run — available without `--dev` (corp / allow-anonymous).
+    // Schedule/reminder hand-dispatch stays `--dev` only below.
+    router.add({
+        method: "GET",
+        pattern: `${base}/v1/dev/evals`,
+        auth: httpAuth,
+        handler: () => __awaiter(this, void 0, void 0, function* () { return jsonResponse(yield runtime.evalRuns.list()); }),
+    });
+    router.add({
+        method: "GET",
+        pattern: `${base}/v1/dev/evals/runs`,
+        auth: httpAuth,
+        handler: () => __awaiter(this, void 0, void 0, function* () {
+            return jsonResponse(yield runtime.evalRuns.listRunsWithActive());
+        }),
+    });
+    router.add({
+        method: "POST",
+        pattern: `${base}/v1/dev/evals/runs`,
+        auth: httpAuth,
+        handler: (request) => __awaiter(this, void 0, void 0, function* () {
+            const body = yield readJsonObject(request);
+            const filterIds = asStringArray(body === null || body === void 0 ? void 0 : body.filterIds);
+            const tags = asStringArray(body === null || body === void 0 ? void 0 : body.tags);
+            const authHeader = request.headers.get("authorization");
+            const bearerToken = (authHeader === null || authHeader === void 0 ? void 0 : authHeader.toLowerCase().startsWith("bearer "))
+                ? authHeader.slice("bearer ".length).trim()
+                : undefined;
+            try {
+                const snap = yield runtime.evalRuns.start(Object.assign(Object.assign(Object.assign({}, (filterIds === undefined ? {} : { filterIds })), (tags === undefined ? {} : { tags })), (bearerToken === undefined || bearerToken === ""
+                    ? {}
+                    : { bearerToken })));
+                return jsonResponse(snap, { status: 202 });
+            }
+            catch (error) {
+                if (error instanceof EvalRunConflictError) {
+                    return jsonResponse({
+                        ok: false,
+                        error: "eval_run_in_progress",
+                        activeRunId: error.activeRunId,
+                    }, { status: 409 });
+                }
+                if (error instanceof EvalRunEmptyError) {
+                    return jsonResponse({ ok: false, error: "no_matching_evals" }, { status: 404 });
+                }
+                const message = error instanceof Error ? error.message : String(error);
+                return jsonResponse({ ok: false, error: "eval_start_failed", message }, { status: 400 });
+            }
+        }),
+    });
+    router.add({
+        method: "GET",
+        pattern: `${base}/v1/dev/evals/runs/:runId`,
+        auth: httpAuth,
+        handler: (_request, ctx) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const runId = (_a = ctx.params.runId) !== null && _a !== void 0 ? _a : "";
+            const snap = yield runtime.evalRuns.get(runId);
+            if (snap === undefined) {
+                return jsonResponse({ ok: false, error: "unknown_eval_run" }, { status: 404 });
+            }
+            return jsonResponse(snap);
+        }),
+    });
+    if (dev) {
+        router.add({
+            method: "POST",
+            pattern: `${base}/v1/dev/schedules/:scheduleId`,
+            auth: httpAuth,
+            handler: (_request, ctx) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const scheduleId = (_a = ctx.params.scheduleId) !== null && _a !== void 0 ? _a : "";
+                try {
+                    const { sessionIds } = yield scheduleRunner.dispatch(scheduleId);
+                    return jsonResponse({ scheduleId, sessionIds });
+                }
+                catch (error) {
+                    if (error instanceof UnknownScheduleError) {
+                        return jsonResponse({
+                            ok: false,
+                            error: "unknown_schedule",
+                            availableScheduleIds: error.availableScheduleIds,
+                        }, { status: 404 });
+                    }
+                    throw error;
+                }
+            }),
+        });
+        router.add({
+            method: "POST",
+            pattern: `${base}/v1/dev/reminders/:reminderId`,
+            auth: httpAuth,
+            handler: (_request, ctx) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const reminderId = (_a = ctx.params.reminderId) !== null && _a !== void 0 ? _a : "";
+                try {
+                    const listed = yield reminderRunner.list();
+                    const reminder = listed.find((r) => r.id === reminderId);
+                    if (reminder === undefined) {
+                        const ids = listed.map((r) => r.id);
+                        throw new UnknownReminderError(reminderId, ids);
+                    }
+                    const ownership = yield assertReminderReadable({
+                        engine,
+                        reminder,
+                        auth: ctx.auth,
+                        requestIp: ctx.requestIp,
+                        relax: relaxSessionReadAuth,
+                        beyondLoopback: relaxSessionReadAuthBeyondLoopback,
+                    });
+                    if (ownership !== undefined) {
+                        return ownership;
+                    }
+                    const result = yield reminderRunner.dispatch(reminderId);
+                    return jsonResponse(result);
+                }
+                catch (error) {
+                    if (error instanceof UnknownReminderError) {
+                        return jsonResponse({
+                            ok: false,
+                            error: "unknown_reminder",
+                            availableReminderIds: error.availableReminderIds,
+                        }, { status: 404 });
+                    }
+                    if (error instanceof ReminderValidationError) {
+                        return jsonResponse({ ok: false, error: "invalid_reminder", message: error.message }, { status: 400 });
+                    }
+                    throw error;
+                }
+            }),
+        });
+        router.add({
+            method: "GET",
+            pattern: `${base}/v1/dev/reminders`,
+            auth: httpAuth,
+            handler: (_request, ctx) => __awaiter(this, void 0, void 0, function* () {
+                const all = yield reminderRunner.list();
+                const reminders = [];
+                for (const reminder of all) {
+                    const denied = yield assertReminderReadable({
+                        engine,
+                        reminder,
+                        auth: ctx.auth,
+                        requestIp: ctx.requestIp,
+                        relax: relaxSessionReadAuth,
+                        beyondLoopback: relaxSessionReadAuthBeyondLoopback,
+                    });
+                    if (denied === undefined) {
+                        reminders.push(reminder);
+                    }
+                }
+                return jsonResponse({ reminders });
+            }),
+        });
+    }
+    for (const channel of project.channels) {
+        const channelAuth = (_b = channel.definition.auth) !== null && _b !== void 0 ? _b : defaultAuth;
+        for (const channelRoute of (_c = channel.definition.routes) !== null && _c !== void 0 ? _c : []) {
+            router.add({
+                method: channelRoute.method,
+                pattern: `${base}/v1/channels/${channel.id}${channelRoute.path}`,
+                auth: channelAuth,
+                handler: (request, ctx) => __awaiter(this, void 0, void 0, function* () {
+                    const handlerArgs = buildChannelHandlerArgs({
+                        runtime,
+                        channelId: channel.id,
+                        params: ctx.params,
+                        requestIp: ctx.requestIp,
+                        auth: ctx.auth,
+                    });
+                    if (channelRoute.querySchema !== undefined) {
+                        const rawQuery = Object.fromEntries(new URL(request.url).searchParams.entries());
+                        const queryValidation = validateToolInput(channelRoute.querySchema, rawQuery);
+                        if (!queryValidation.ok) {
+                            return jsonResponse({ error: queryValidation.message }, { status: 400 });
+                        }
+                        handlerArgs.query = queryValidation.value;
+                    }
+                    if (channelRoute.bodySchema !== undefined) {
+                        // Buffer once so handlers that need the raw body (e.g. GitHub
+                        // HMAC) can still read `request.text()` / `request.json()`.
+                        let bodyText;
+                        try {
+                            bodyText = yield request.text();
+                        }
+                        catch (_a) {
+                            return jsonResponse({ error: "Failed to read request body" }, { status: 400 });
+                        }
+                        let rawBody;
+                        try {
+                            rawBody = bodyText === "" ? {} : JSON.parse(bodyText);
+                        }
+                        catch (_b) {
+                            return jsonResponse({ error: "Request body must be valid JSON" }, { status: 400 });
+                        }
+                        const bodyValidation = validateToolInput(channelRoute.bodySchema, rawBody);
+                        if (!bodyValidation.ok) {
+                            return jsonResponse({ error: bodyValidation.message }, { status: 400 });
+                        }
+                        handlerArgs.body = bodyValidation.value;
+                        request = new Request(request.url, {
+                            method: request.method,
+                            headers: request.headers,
+                            body: bodyText === "" ? undefined : bodyText,
+                            // node: undici / fetch may require duplex for streamed bodies;
+                            // a string body does not.
+                        });
+                    }
+                    return channelRoute.handler(request, handlerArgs);
+                }),
+            });
+        }
+    }
+}
+/**
+ * `cursorEvents` (`--cursor-events`) long-polls `/v0/scm-events` as the host's
+ * Cursor user, so a signed-out host has no way to receive deliveries. Fail the
+ * serve instead of starting with a relay that could never run.
+ */
+function requireCursorEventsAuth(config, accountKey) {
+    var _a, _b, _c, _d;
+    const apiKey = ((_b = (_a = config.apiKey) !== null && _a !== void 0 ? _a : accountKey === null || accountKey === void 0 ? void 0 : accountKey.apiKey) !== null && _b !== void 0 ? _b : "").trim();
+    if (apiKey === "") {
+        throw new Error(`[agent-serve] --cursor-events (serve({ cursorEvents })) requires a signed-in Cursor account: the SCM event stream is read as the host's user. ${SIGN_IN_HINT}`);
+    }
+    return {
+        apiKey,
+        baseUrl: (_d = (_c = config.baseUrl) !== null && _c !== void 0 ? _c : accountKey === null || accountKey === void 0 ? void 0 : accountKey.backendUrl) !== null && _d !== void 0 ? _d : cursorBackendUrl(),
+    };
+}
+/**
+ * Opt-in Cursor SCM events relay. Credentials are already required by
+ * {@link requireCursorEventsAuth}; the remaining unusable configs (no repos,
+ * no github channel) warn and leave the relay off — serve still starts.
+ */
+function startCursorEventRelay(input) {
+    var _a;
+    var _b, _c;
+    const { options, mounts, auth, logger, collectTriggerTargets } = input;
+    const config = options.cursorEvents;
+    if (config === undefined || auth === undefined) {
+        return undefined;
+    }
+    const repos = [...new Set(config.repos.map((repo) => repo.trim()))].filter((repo) => repo.length > 0);
+    if (repos.length === 0) {
+        logger("[agent-serve] cursor-events: no repos configured (pass --repo owner/name); relay disabled");
+        return undefined;
+    }
+    const githubTargets = findGitHubChannelTargets(mounts);
+    const events = [...new Set(githubTargets.flatMap((target) => target.events))];
+    if (events.length === 0) {
+        logger("[agent-serve] cursor-events: no mounted agent declares a github channel; relay disabled");
+        return undefined;
+    }
+    const baseStateRoot = (_b = options.stateRoot) !== null && _b !== void 0 ? _b : join((_c = (_a = mounts[0]) === null || _a === void 0 ? void 0 : _a.project.rootDir) !== null && _c !== void 0 ? _c : process.cwd(), ".agent-serve");
+    const relay = new CursorEventRelay({
+        baseUrl: auth.baseUrl,
+        apiKey: auth.apiKey,
+        repos,
+        events,
+        stateDir: join(baseStateRoot, "cursor-events"),
+        logger,
+        // Stream is compact metadata (Sand-style); stub a GitHub body from the
+        // envelope — rich pullRequest meta when present for onPullRequest Zod.
+        dispatch: (event) => __awaiter(this, void 0, void 0, function* () {
+            if (event.provider !== "github")
+                return;
+            const result = yield handleAgentServeTrigger({
+                type: "github",
+                bodyText: JSON.stringify(scmMetadataToGitHubPayload(event)),
+                eventName: event.eventName,
+                deliveryId: event.deliveryId,
+                targets: collectTriggerTargets(),
+            });
+            const outcomes = result.targets
+                .map((target) => `${target.slug || "default"}:${target.status}`)
+                .join(", ");
+            logger(`[agent-serve] cursor-events: dispatched ${formatCursorScmEventLog(event)}${outcomes === "" ? "" : ` → ${outcomes}`}`);
+        }),
+    });
+    relay.start();
+    logger(`[agent-serve] cursor-events: relaying ${events.length} event kind(s) for ${repos.join(", ")} from ${auth.baseUrl}`);
+    return relay;
+}
+/** `weather-agent` → `Weather Agent` (Slack display name default). */
+function slackAgentNameFromSlug(slug) {
+    return slug
+        .split(/[-_\s]+/)
+        .filter((word) => word.length > 0)
+        .map((word) => word[0].toUpperCase() + word.slice(1))
+        .join(" ");
+}
+/**
+ * Mounted Slack channels riding the Cursor account connection
+ * (`slackChannel({ cursorAccount: true })`), with their registered names
+ * resolved. Duplicate names are a startup error — the backend routes
+ * `@Cursor <name> …` by name, so two mounts cannot share one.
+ */
+function collectCursorSlackTargets(runtimes) {
+    var _a;
+    const targets = [];
+    const byName = new Map();
+    for (const runtime of runtimes) {
+        for (const channel of runtime.project.channels) {
+            const accountRuntime = getSlackCursorAccountRuntime(channel.definition);
+            if (accountRuntime === undefined) {
+                continue;
+            }
+            const agentName = ((_a = accountRuntime.options.agentName) !== null && _a !== void 0 ? _a : slackAgentNameFromSlug(runtime.slug === "" ? runtime.project.name : runtime.slug)).trim();
+            if (agentName === "") {
+                throw new Error(`slackChannel({ cursorAccount: true }) on agent "${runtime.slug || runtime.project.name}" resolved an empty agent name; set agentName.`);
+            }
+            const nameKey = agentName.toLowerCase();
+            const existing = byName.get(nameKey);
+            if (existing !== undefined) {
+                throw new Error(`Two agents register the Slack name "${agentName}" (${existing} and ${runtime.slug || runtime.project.name}); set agentName to disambiguate.`);
+            }
+            byName.set(nameKey, runtime.slug || runtime.project.name);
+            targets.push({
+                runtime,
+                channelId: channel.id,
+                agentName,
+                accountRuntime,
+            });
+        }
+    }
+    return targets;
+}
+/**
+ * Automatic Cursor Slack relay for cursor-account Slack channels: registers
+ * the mounted agents with `/v0/slack-events`, binds each channel's outbound
+ * API transport to the backend proxy, and dispatches relayed envelopes into
+ * the pack's normal inbound path. Requires a signed-in host — fail serve
+ * fast rather than mounting channels that can never hear or speak.
+ */
+function startCursorSlackRelay(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const { options, runtimes, accountKey, logger } = input;
+        const targets = collectCursorSlackTargets(runtimes);
+        if (targets.length === 0) {
+            return undefined;
+        }
+        if (accountKey === undefined) {
+            throw new Error(`This project has Slack channels using the Cursor account connection (slackChannel({ cursorAccount: true })) but the host is not signed in to Cursor. ${SIGN_IN_HINT}`);
+        }
+        const baseUrl = (_a = accountKey.backendUrl) !== null && _a !== void 0 ? _a : cursorBackendUrl();
+        const baseStateRoot = (_b = options.stateRoot) !== null && _b !== void 0 ? _b : join(targets[0].runtime.project.rootDir, ".agent-serve");
+        const stateDir = join(baseStateRoot, "cursor-slack");
+        // Optional fields may be undefined — the relay JSON-serializes the
+        // registration body, which drops them.
+        const agents = targets.map((target) => { var _a, _b; return ({
+            name: target.agentName,
+            iconUrl: (_a = target.accountRuntime.options.agentIcon) === null || _a === void 0 ? void 0 : _a.url,
+            iconEmoji: (_b = target.accountRuntime.options.agentIcon) === null || _b === void 0 ? void 0 : _b.emoji,
+        }); });
+        const targetByName = new Map(targets.map((target) => [target.agentName.toLowerCase(), target]));
+        const relay = new CursorSlackRelay({
+            baseUrl,
+            apiKey: accountKey.apiKey,
+            agents,
+            stateDir,
+            logger,
+            dispatch: (envelope) => __awaiter(this, void 0, void 0, function* () {
+                const target = targetByName.get(envelope.agentName.toLowerCase());
+                if (target === undefined) {
+                    return;
+                }
+                const args = buildChannelHandlerArgs({
+                    runtime: target.runtime,
+                    channelId: target.channelId,
+                });
+                logger(`[agent-serve] cursor-slack: dispatching ${formatCursorSlackEventLog(envelope)} → ${target.runtime.slug || "default"}`);
+                yield dispatchCursorSlackEnvelope({
+                    runtime: target.accountRuntime,
+                    envelope,
+                    send: args.send,
+                    host: args.host,
+                });
+            }),
+        });
+        // Bind each channel's outbound transport before consumption starts so the
+        // first reply can post. The consumer id keys thread claims server-side.
+        const consumerId = yield relay.resolveConsumerId();
+        for (const target of targets) {
+            target.accountRuntime.transport.bind(createCursorSlackApiCaller({
+                baseUrl,
+                apiKey: accountKey.apiKey,
+                agentName: target.agentName,
+                consumerId,
+                logger,
+            }));
+        }
+        relay.start();
+        logger(`[agent-serve] cursor-slack: relaying Slack for ${targets
+            .map((target) => `${target.agentName} (${target.runtime.slug || "default"})`)
+            .join(", ")} from ${baseUrl} — mention "@Cursor <agent name> …" in the linked workspace`);
+        return relay;
+    });
+}
+function buildChannelHandlerArgs(input) {
+    var _a, _b, _c;
+    const { runtime, channelId } = input;
+    const base = runtime.slug === "" ? "" : `/${runtime.slug}`;
+    const auth = (_a = input.auth) !== null && _a !== void 0 ? _a : null;
+    return {
+        params: (_b = input.params) !== null && _b !== void 0 ? _b : {},
+        requestIp: (_c = input.requestIp) !== null && _c !== void 0 ? _c : null,
+        auth,
+        host: runtime.engine.host,
+        send: (message, sendOptions = {}) => runtime.engine.send(channelId, message, Object.assign(Object.assign({}, sendOptions), { auth: sendOptions.auth !== undefined ? sendOptions.auth : auth })),
+        getSession: (sessionId) => runtime.engine.getChannelSession(channelId, sessionId),
+        receive: (target, inputReceive) => runtime.engine.receive(target, inputReceive),
+        callTool: (toolName, toolInput, callOptions) => runtime.engine.callTool(toolName, toolInput, callOptions),
+        waitUntil: (promise) => {
+            runtime.engine.trackBackground(promise);
+        },
+        sessionUrls: (req, sessionId) => sessionUrlsForRequest(req, base, sessionId),
+    };
+}
+function handleRequest(router, req, res, logger) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        let response;
+        const method = (_a = req.method) !== null && _a !== void 0 ? _a : "GET";
+        try {
+            const request = yield toFetchRequest(req);
+            const url = new URL(request.url);
+            const match = router.match(request.method, url.pathname);
+            if (match === undefined) {
+                response = router.hasPath(url.pathname)
+                    ? errorResponse(405, "method_not_allowed", `${request.method} is not supported on ${url.pathname}.`)
+                    : errorResponse(404, "not_found", `No route for ${request.method} ${url.pathname}.`);
+            }
+            else {
+                const requestIp = (_b = req.socket.remoteAddress) !== null && _b !== void 0 ? _b : null;
+                let auth = null;
+                let unauthorized = false;
+                if (match.route.auth !== "none") {
+                    auth = yield resolveAuth(match.route.auth, request, requestIp);
+                    unauthorized = auth === null;
+                }
+                response = unauthorized
+                    ? errorResponse(401, "unauthorized", "No auth policy admitted this request. In production, configure channel auth (e.g. bearerAuth) — the default localDevStrict() policy only admits loopback callers with a loopback Host.")
+                    : yield match.route.handler(request, {
+                        params: match.params,
+                        requestIp,
+                        auth,
+                    });
+            }
+        }
+        catch (error) {
+            if (error instanceof SessionBusyError) {
+                response = errorResponse(409, "session_busy", error.message);
+            }
+            else if (error instanceof SessionAuthError) {
+                response = errorResponse(403, "forbidden", error.message);
+            }
+            else {
+                logger(`[agent-serve] request failed: ${error instanceof Error
+                    ? ((_c = error.stack) !== null && _c !== void 0 ? _c : error.message)
+                    : String(error)}`);
+                response = errorResponse(500, "internal_error", "Internal server error.");
+            }
+        }
+        try {
+            yield writeFetchResponse(response, res, method);
+        }
+        catch (error) {
+            logger(`[agent-serve] response write failed: ${error instanceof Error ? error.message : String(error)}`);
+            res.destroy();
+        }
+    });
+}
+function resolveAuth(policies, request, requestIp) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const policy of policies) {
+            const result = yield policy(request, { requestIp });
+            if (result !== null) {
+                return result;
+            }
+        }
+        return null;
+    });
+}
+function toFetchRequest(req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const method = (_a = req.method) !== null && _a !== void 0 ? _a : "GET";
+        const hostHeader = (_b = req.headers.host) !== null && _b !== void 0 ? _b : "127.0.0.1";
+        const url = new URL((_c = req.url) !== null && _c !== void 0 ? _c : "/", `http://${hostHeader}`);
+        const headers = new Headers();
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (value === undefined) {
+                continue;
+            }
+            if (Array.isArray(value)) {
+                for (const item of value) {
+                    headers.append(key, item);
+                }
+            }
+            else {
+                headers.set(key, value);
+            }
+        }
+        if (method === "GET" || method === "HEAD") {
+            return new Request(url, { method, headers });
+        }
+        const body = yield readBody(req);
+        // Buffer is a Uint8Array at runtime; TS's BodyInit wants ArrayBuffer-backed
+        // typed arrays, so re-view without copying.
+        return new Request(url, {
+            method,
+            headers,
+            body: new Uint8Array(body.buffer, body.byteOffset, body.byteLength),
+        });
+    });
+}
+function readBody(req) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, req_1, req_1_1;
+        var _b, e_1, _c, _d;
+        const chunks = [];
+        let total = 0;
+        try {
+            for (_a = true, req_1 = __asyncValues(req); req_1_1 = yield req_1.next(), _b = req_1_1.done, !_b; _a = true) {
+                _d = req_1_1.value;
+                _a = false;
+                const chunk = _d;
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+                total += buffer.length;
+                if (total > MAX_BODY_BYTES) {
+                    throw new Error("Request body too large");
+                }
+                chunks.push(buffer);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_a && !_b && (_c = req_1.return)) yield _c.call(req_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return Buffer.concat(chunks);
+    });
+}
+function writeFetchResponse(response_1, res_1) {
+    return __awaiter(this, arguments, void 0, function* (response, res, method = "GET") {
+        const headers = {};
+        response.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        res.writeHead(response.status, headers);
+        // HEAD responses must not include a body (RFC 9110 §9.3.2). Cancel any
+        // handler-produced stream so long-lived GET handlers (e.g. session SSE)
+        // still unsubscribe when served via the HEAD→GET fallback.
+        if (method === "HEAD" || response.body === null) {
+            if (response.body !== null) {
+                void response.body.cancel().catch(() => { });
+            }
+            res.end();
+            return;
+        }
+        const reader = response.body.getReader();
+        let clientGone = false;
+        const closed = new Promise((resolve) => {
+            res.once("close", () => {
+                if (!res.writableFinished) {
+                    clientGone = true;
+                    void reader.cancel().catch(() => { });
+                }
+                resolve();
+            });
+        });
+        try {
+            while (!clientGone) {
+                const { done, value } = yield reader.read();
+                if (done) {
+                    break;
+                }
+                if (value !== undefined && value.length > 0) {
+                    if (!res.write(value) && !clientGone) {
+                        // Race against close so a vanished client can't wedge the loop
+                        // waiting for a drain that will never come.
+                        yield Promise.race([once(res, "drain"), closed]);
+                    }
+                }
+            }
+        }
+        catch (_a) {
+            void reader.cancel().catch(() => { });
+        }
+        res.end();
+    });
+}
+/**
+ * Dev reminder routes may only inspect/fire reminders whose bound session
+ * belongs to the caller (same principal), matching session read routes.
+ * Loopback `--dev` (and `--allow-anonymous`) can relax ownership like
+ * `GET /v1/sessions`.
+ */
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const out = [];
+    for (const item of value) {
+        if (typeof item === "string" && item.trim() !== "") {
+            out.push(item);
+        }
+    }
+    return out.length === 0 ? undefined : out;
+}
+function assertReminderReadable(input) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const existing = yield input.engine.sessions.findByContinuation(input.reminder.channelId, input.reminder.continuationToken);
+        if (existing === undefined) {
+            // No live session — still gate on relax/loopback so a shared-dev caller
+            // cannot enumerate orphan reminder metadata across principals.
+            const relaxOwnership = input.relax === true &&
+                (input.beyondLoopback === true ||
+                    (typeof input.requestIp === "string" &&
+                        isLoopbackAddress(input.requestIp)));
+            if (relaxOwnership) {
+                return undefined;
+            }
+            // Without a session principal to compare, deny non-relaxed callers.
+            return errorResponse(403, "forbidden", "This reminder is bound to a session that is not visible to the caller.");
+        }
+        return requireSessionOwner(existing, input.auth, {
+            relax: input.relax,
+            beyondLoopback: input.beyondLoopback,
+            requestIp: input.requestIp,
+        });
+    });
+}