@cursor/july 0.1.89 → 0.1.90

package/dist/internal/server.js

@@ -45,7 +45,7 @@ import { assertSlackCursorAgentName } from "../channels/slack/types.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 { cursorExternalApiUrl, resolveApiKey, SIGN_IN_HINT, } from "./cursor/credentials.js";
+import { cursorBackendUrl, cursorExternalApiUrl, resolveApiKey, resolveApiKeySync, SIGN_IN_HINT, } from "./cursor/credentials.js";
 import { CursorGithubCredentialProvider } from "./cursor/github-credentials.js";
 import { DeploymentEventRelay, fanOutDeploymentEvent, resolveDeploymentSubscriptions, } from "./cursor-deployment-relay.js";
 import { CursorEventRelay, formatCursorScmDispatchOutcome, formatCursorScmEventLog, scmEventToGitHubPayload, scmMetadataToOriginPayload, } from "./cursor-event-relay.js";
@@ -115,8 +115,8 @@ function isV2Project(project) {
 export function startServer(mounts_1) {
     return __awaiter(this, arguments, void 0, function* (mounts, options = {}) {
         var _a, _b, _c, _d, _e, _f;
-        var _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0;
-        var _1;
+        var _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _0, _1, _2;
+        var _3;
         if (mounts.length === 0) {
             throw new Error("startServer requires at least one agent mount");
         }
@@ -134,10 +134,10 @@ export function startServer(mounts_1) {
         const noControlPlane = options.noControlPlane === true;
         const runSchedules = (_k = options.schedules) !== null && _k !== void 0 ? _k : !dev;
         const runReminders = (_l = options.reminders) !== null && _l !== void 0 ? _l : !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.
-        (_m = (_1 = process.env).CURSOR_AGENTKIT_VERSION) !== null && _m !== void 0 ? _m : (_1.CURSOR_AGENTKIT_VERSION = packageVersion());
+        // CURSOR_AGENTKIT_VERSION is still the env the SDK reads when building
+        // its client-version header (wire prefix remains `agentkit-`). Setting it
+        // here makes the internal-only agentkit_enabled gate apply to every turn.
+        (_m = (_3 = process.env).CURSOR_AGENTKIT_VERSION) !== null && _m !== void 0 ? _m : (_3.CURSOR_AGENTKIT_VERSION = packageVersion());
         const authoredOtel = pickAuthoredOtel(mounts.map((m) => ({
             slug: m.slug,
             name: m.project.name,
@@ -167,8 +167,13 @@ export function startServer(mounts_1) {
             : { repos: [...cursorOriginScope.repos] });
         // One resolution for every Cursor credential consumer (SDK runner, account
         // MCP bridge, SCM event relay, GitHub credentials): explicit option →
-        // CURSOR_API_KEY → stored `agent-serve login`.
+        // CURSOR_API_KEY → CURSOR_API_KEY_FILE (or the hosted default path) →
+        // stored `agent-serve login`. SDK / GitHub / account MCP re-read later;
+        // Slack and deployment-event relays capture the key at start.
         const accountKey = yield resolveApiKey(options.apiKey === undefined ? {} : { apiKey: options.apiKey });
+        // First present source wins (we define the order): option → env → file →
+        // stored login. Re-read so bind can drop env or file onto a listening process.
+        const liveCursorApiKey = () => { var _a; return (_a = resolveApiKeySync(options.apiKey === undefined ? {} : { apiKey: options.apiKey })) === null || _a === void 0 ? void 0 : _a.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).
@@ -197,13 +202,15 @@ export function startServer(mounts_1) {
             const githubProxyRequested = options.cursorGithubProxy === true;
             const needsGithubAuth = cursorGithubConfig.scope !== undefined || githubProxyRequested;
             if (needsGithubAuth) {
-                const cursorGithubAuth = cursorEventsAuth !== null && cursorEventsAuth !== void 0 ? cursorEventsAuth : ((accountKey === null || accountKey === void 0 ? void 0 : accountKey.apiKey) !== undefined && accountKey.apiKey.trim() !== ""
-                    ? {
-                        apiKey: accountKey.apiKey.trim(),
-                        baseUrl: cursorExternalApiUrl(),
+                const currentGithubApiKey = () => {
+                    const fromEvents = cursorEventsAuth === null || cursorEventsAuth === void 0 ? void 0 : cursorEventsAuth.apiKey.trim();
+                    if (fromEvents !== undefined && fromEvents !== "") {
+                        return fromEvents;
                     }
-                    : undefined);
-                if (cursorGithubAuth === undefined) {
+                    return liveCursorApiKey();
+                };
+                const githubApiKeyNow = currentGithubApiKey();
+                if (githubApiKeyNow === undefined && options.allowAnonymous !== true) {
                     throw new Error("githubChannel({ cursorAccount: true }) could not resolve Cursor event authentication.");
                 }
                 if (options.allowAnonymous === true) {
@@ -211,18 +218,31 @@ export function startServer(mounts_1) {
                         throw new Error("githubChannel({ cursorAccount: true }) cannot be served with --allow-anonymous because admitted callers could use the signed-in account's GitHub access. If every admitted caller is trusted (e.g. behind an SSO proxy), opt in with --allow-anonymous-cursor-github.");
                     }
                     logger("[agent-sdk] warning: --allow-anonymous-cursor-github — every admitted HTTP caller can drive sessions holding the signed-in account's repo-scoped GitHub credential; serve this only behind a trusted boundary (e.g. an SSO proxy)");
+                    if (githubApiKeyNow === undefined) {
+                        logger("[agent-sdk] GitHub auth: listening unsigned; credentials bind at task via CURSOR_API_KEY or CURSOR_API_KEY_FILE");
+                    }
                 }
                 if (cursorGithubConfig.permissions === "contents-write") {
                     logger('[agent-sdk] warning: Cursor GitHub credentials include contents:write — the host holds a push-capable token shared with model-driven tools and untrusted webhook content; prefer permissions: "pr-write" unless this agent must push code');
                 }
+                const githubAuthBaseUrl = cursorExternalApiUrl();
+                const requireGithubApiKey = () => __awaiter(this, void 0, void 0, function* () {
+                    const apiKey = currentGithubApiKey();
+                    if (apiKey === undefined) {
+                        throw new Error(`githubChannel({ cursorAccount: true }) has no Cursor credential yet. ${SIGN_IN_HINT}`);
+                    }
+                    return apiKey;
+                });
                 const githubProxyUrl = githubProxyRequested
-                    ? resolveCursorGithubProxyUrl(cursorGithubAuth.baseUrl)
+                    ? resolveCursorGithubProxyUrl(githubAuthBaseUrl)
                     : undefined;
-                if (cursorGithubConfig.scope !== undefined) {
+                if (cursorGithubConfig.scope !== undefined &&
+                    githubApiKeyNow !== undefined) {
                     const provider = new CursorGithubCredentialProvider({
                         client: new CursorBackendClient({
-                            backendUrl: cursorGithubAuth.baseUrl,
-                            apiKey: cursorGithubAuth.apiKey,
+                            backendUrl: githubAuthBaseUrl,
+                            apiKey: githubApiKeyNow,
+                            getApiKey: () => { var _a; return (_a = currentGithubApiKey()) !== null && _a !== void 0 ? _a : ""; },
                             logger,
                         }),
                         scope: cursorGithubConfig.scope,
@@ -242,7 +262,7 @@ export function startServer(mounts_1) {
                             },
                         };
                         for (const target of cursorGithubTargets) {
-                            target.accountRuntime.credentials.bind(() => __awaiter(this, void 0, void 0, function* () { return cursorGithubAuth.apiKey; }));
+                            target.accountRuntime.credentials.bind(requireGithubApiKey);
                             target.accountRuntime.credentials.bindProxyTransport(proxyTransport);
                         }
                         logger(`[agent-sdk] GitHub auth: channel API calls route through ${githubProxyUrl}`);
@@ -256,8 +276,8 @@ export function startServer(mounts_1) {
                 else if (githubProxyUrl !== undefined) {
                     // `cursorAccount: true` with no `--repo`: skip the startup token mint
                     // (it requires a repo list) and let github-proxy take the repo from
-                    // each Octokit call. Hosted multi-tenant uses this with the
-                    // deployment event stream.
+                    // each Octokit call. Hosted freeze bakes this flag into the template
+                    // so restore is GitHub-ready once Bind drops the key.
                     const proxyTransport = {
                         apiBaseUrl: githubProxyUrl,
                         headers: {
@@ -265,14 +285,14 @@ export function startServer(mounts_1) {
                         },
                     };
                     for (const target of cursorGithubTargets) {
-                        target.accountRuntime.credentials.bind(() => __awaiter(this, void 0, void 0, function* () { return cursorGithubAuth.apiKey; }));
+                        target.accountRuntime.credentials.bind(requireGithubApiKey);
                         target.accountRuntime.credentials.bindProxyTransport(proxyTransport);
                     }
                     // `ctx.host.github` gets the same proxy transport; without this it
                     // would fall back to ambient auth (env token / `gh`) or an
                     // unauthenticated Octokit, and every host GitHub call would 404.
                     hostGithubProxyResolver = createCursorGithubProxyHostResolver({
-                        getApiKey: () => __awaiter(this, void 0, void 0, function* () { return cursorGithubAuth.apiKey; }),
+                        getApiKey: requireGithubApiKey,
                         transport: proxyTransport,
                     });
                     logger(`[agent-sdk] GitHub auth: channel and host API calls route through ${githubProxyUrl} (repo scope per request)`);
@@ -299,7 +319,9 @@ export function startServer(mounts_1) {
         if (options.allowAnonymous === true) {
             logger("[agent-sdk] 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 sdkRunner = (_t = options.runner) !== null && _t !== void 0 ? _t : new CursorSdkRunner({ apiKey: accountKey === null || accountKey === void 0 ? void 0 : accountKey.apiKey, logger });
+        const sdkRunner = (_t = options.runner) !== null && _t !== void 0 ? _t : new CursorSdkRunner(Object.assign(Object.assign({}, (options.apiKey === undefined || options.apiKey.trim() === ""
+            ? {}
+            : { apiKey: options.apiKey })), { logger }));
         // Grok Bot turns run on Cursor's hosted Grok Bot (Sand) harness through
         // the /v0/grokbot session API; the SDK side is a thin remote client. The
         // dispatching runner is only interposed when a mount needs it. An
@@ -318,7 +340,14 @@ export function startServer(mounts_1) {
         if (hasGrokBotMounts && options.runner === undefined) {
             runner = new RuntimeDispatchingRunner({
                 sdkRunner,
-                grokbot: { apiKey: accountKey === null || accountKey === void 0 ? void 0 : accountKey.apiKey },
+                grokbot: Object.assign(Object.assign({}, (options.apiKey === undefined || options.apiKey.trim() === ""
+                    ? {}
+                    : { apiKey: options.apiKey })), { 
+                    // `/v0/grokbot` lives on the external API (api.cursor.com), not
+                    // api2. Prefer that default over the account key's backendUrl.
+                    // Do not pass stored login as apiKey: that would pin it as an
+                    // option and beat a later CURSOR_API_KEY_FILE bind.
+                    backendUrl: cursorExternalApiUrl() }),
             });
             logger("[agent-sdk] grokbot runtime: remote client (turns run on the hosted Grok Bot harness)");
         }
@@ -347,13 +376,17 @@ export function startServer(mounts_1) {
         }
         let accountBridge;
         if (accountRefsBySlug.size > 0) {
-            if (accountKey === undefined) {
+            if (accountKey === undefined && options.allowAnonymous !== true) {
                 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}`);
             }
+            if (accountKey === undefined) {
+                logger("[agent-sdk] Cursor account MCP: listening unsigned; credentials bind at task via CURSOR_API_KEY or CURSOR_API_KEY_FILE");
+            }
             accountBridge = new CursorAccountMcpBridge({
                 client: new CursorBackendClient({
-                    backendUrl: accountKey.backendUrl,
-                    apiKey: accountKey.apiKey,
+                    backendUrl: (_u = accountKey === null || accountKey === void 0 ? void 0 : accountKey.backendUrl) !== null && _u !== void 0 ? _u : cursorBackendUrl(),
+                    apiKey: (_v = accountKey === null || accountKey === void 0 ? void 0 : accountKey.apiKey) !== null && _v !== void 0 ? _v : "",
+                    getApiKey: () => { var _a; return (_a = liveCursorApiKey()) !== null && _a !== void 0 ? _a : ""; },
                     logger,
                 }),
                 logger,
@@ -364,7 +397,7 @@ export function startServer(mounts_1) {
         }
         for (const { slug, project } of mounts) {
             // Each agent gets an isolated state root so their sessions never mix.
-            const baseStateRoot = (_u = options.stateRoot) !== null && _u !== void 0 ? _u : join(project.rootDir, ".agent-serve");
+            const baseStateRoot = (_w = options.stateRoot) !== null && _w !== void 0 ? _w : join(project.rootDir, ".agent-serve");
             const stateRoot = slug === "" ? baseStateRoot : join(baseStateRoot, slug);
             const otelCollector = otelRuntime === undefined
                 ? undefined
@@ -480,7 +513,7 @@ export function startServer(mounts_1) {
                     }
                     catch (error) {
                         logger(`[agent-sdk] channel "${channel.id}" onStart failed: ${error instanceof Error
-                            ? ((_v = error.stack) !== null && _v !== void 0 ? _v : error.message)
+                            ? ((_x = error.stack) !== null && _x !== void 0 ? _x : error.message)
                             : String(error)}`);
                     }
                 }
@@ -620,8 +653,8 @@ export function startServer(mounts_1) {
         const routeContinuation = localControlPlaneRoute(runtimes);
         const cursorEventsCommon = {
             config: effectiveCursorEvents,
-            githubRepos: (_w = (_e = cursorGithubConfig.cursorEvents) === null || _e === void 0 ? void 0 : _e.repos) !== null && _w !== void 0 ? _w : [],
-            originRepos: (_x = cursorOriginScope === null || cursorOriginScope === void 0 ? void 0 : cursorOriginScope.repos) !== null && _x !== void 0 ? _x : [],
+            githubRepos: (_y = (_e = cursorGithubConfig.cursorEvents) === null || _e === void 0 ? void 0 : _e.repos) !== null && _y !== void 0 ? _y : [],
+            originRepos: (_z = cursorOriginScope === null || cursorOriginScope === void 0 ? void 0 : cursorOriginScope.repos) !== null && _z !== void 0 ? _z : [],
             stateRoot: options.stateRoot,
             auth: cursorEventsAuth,
             logger,
@@ -650,9 +683,9 @@ export function startServer(mounts_1) {
         const server = createServer((req, res) => {
             void instrumentHttp(otelRuntime, req, res, () => handleRequest(router, req, res, logger));
         });
-        const host = (_y = options.host) !== null && _y !== void 0 ? _y : "127.0.0.1";
+        const host = (_0 = options.host) !== null && _0 !== void 0 ? _0 : "127.0.0.1";
         const portWasExplicit = options.port !== undefined;
-        const requestedPort = (_z = options.port) !== null && _z !== void 0 ? _z : DEFAULT_SERVE_PORT;
+        const requestedPort = (_1 = options.port) !== null && _1 !== void 0 ? _1 : DEFAULT_SERVE_PORT;
         let boundPort;
         try {
             boundPort = yield listenHttpServer({
@@ -698,7 +731,7 @@ export function startServer(mounts_1) {
                 runtime.project.agent.cloud !== undefined;
             if ((hasServerTools || bridgeableNames.length > 0) && cloudCapable) {
                 const basePath = runtime.slug === "" ? "" : `/${runtime.slug}`;
-                const publicToolsUrl = (_0 = options.cloudToolsUrl) !== null && _0 !== void 0 ? _0 : (options.publicUrl === undefined
+                const publicToolsUrl = (_2 = options.cloudToolsUrl) !== null && _2 !== void 0 ? _2 : (options.publicUrl === undefined
                     ? undefined
                     : `${options.publicUrl.replace(/\/$/, "")}${basePath}${TOOL_MCP_ENDPOINT_PATH}`);
                 if (publicToolsUrl === undefined) {
@@ -715,7 +748,10 @@ export function startServer(mounts_1) {
                             ? undefined
                             : { authorization: `Bearer ${options.authToken}` };
                     if (options.cloudToolsUrl !== undefined && headers === undefined) {
-                        throw new Error(`Agent "${runtime.project.name}" needs a Cursor API key to authenticate --cloud-tools-url. ${SIGN_IN_HINT}`);
+                        if (options.allowAnonymous !== true) {
+                            throw new Error(`Agent "${runtime.project.name}" needs a Cursor API key to authenticate --cloud-tools-url. ${SIGN_IN_HINT}`);
+                        }
+                        logger(`[agent-sdk] --cloud-tools-url: listening unsigned; Bearer is taken from the key present at start`);
                     }
                     runtime.engine.setCloudServerToolsConnection(Object.assign({ type: "http", url: publicToolsUrl }, (headers === undefined ? {} : { headers })));
                 }
@@ -1873,6 +1909,10 @@ function startCursorDeploymentRelay(input) {
         return undefined;
     }
     if (accountKey === undefined) {
+        if (input.options.allowAnonymous === true) {
+            logger("[agent-sdk] deployment-events: skipped while unsigned; long-poll relays need a key at start");
+            return undefined;
+        }
         throw new Error(`This project has channels subscribed to deployment events (deploymentsChannel({ deploySourceUris })) but the host is not signed in to Cursor. ${SIGN_IN_HINT}`);
     }
     // Union across channels: one registration per deploy source for the whole
@@ -1946,6 +1986,10 @@ function startCursorSlackRelay(input) {
             return undefined;
         }
         if (accountKey === undefined) {
+            if (options.allowAnonymous === true) {
+                logger("[agent-sdk] cursor-slack: skipped while unsigned; long-poll relays need a key at start");
+                return 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}`);
         }
         // Same host split as scm-events: `/v0/slack-events/*` is on api.cursor.com,