@cursor/july 0.1.1 → 0.1.3

package/src/internal/server.ts

@@ -14,12 +14,21 @@ import {
 } from "node:http";
 import type { AddressInfo } from "node:net";
 import { join } from "node:path";
+import {
+  type CursorGithubRepoScope,
+  createCursorAccountGithubTokenResolver,
+  type GithubCursorAccountRuntime,
+  getGithubCursorAccountRuntime,
+  parseCursorGithubRepoScope,
+  resolveCursorGithubPermissions,
+} from "../channels/github/cursor-account.js";
 import { findGitHubChannelTargets } from "../channels/github/forward.js";
 import {
   dispatchCursorSlackEnvelope,
   getSlackCursorAccountRuntime,
   type SlackCursorAccountRuntime,
 } from "../channels/slack/cursor-account.js";
+import { assertSlackCursorAgentName } from "../channels/slack/types.js";
 import { allowAll, bearerAuth, localDevStrict } from "../channels.js";
 import type {
   AgentProject,
@@ -41,10 +50,12 @@ import {
 import { CursorBackendClient } from "./cursor/backend-client.js";
 import {
   cursorBackendUrl,
+  cursorExternalApiUrl,
   type ResolvedApiKey,
   resolveApiKey,
   SIGN_IN_HINT,
 } from "./cursor/credentials.js";
+import { CursorGithubCredentialProvider } from "./cursor/github-credentials.js";
 import {
   CursorEventRelay,
   formatCursorScmEventLog,
@@ -76,7 +87,7 @@ import {
   collectGitHubTriggerTargets,
   handleAgentServeTrigger,
 } from "./handleAgentServeTrigger.js";
-import { warmupHostGitHubAuth } from "./host-platforms.js";
+import { createHostPlatforms, warmupHostGitHubAuth } from "./host-platforms.js";
 import {
   buildHttpChannelRoutes,
   errorResponse,
@@ -187,9 +198,16 @@ export async function startServer(
   // agentkit_enabled gate applies to every turn.
   process.env.CURSOR_AGENTKIT_VERSION ??= packageVersion();
 
+  const cursorGithubTargets = collectCursorGithubTargets(mounts);
+  const cursorGithubConfig = resolveCursorGithubEventConfig({
+    configured: options.cursorEvents,
+    targets: cursorGithubTargets,
+  });
+  const effectiveCursorEvents = cursorGithubConfig.cursorEvents;
+
   // One resolution for every Cursor credential consumer (SDK runner, account
-  // MCP bridge, SCM event relay): explicit option → CURSOR_API_KEY → stored
-  // `agent-serve login`.
+  // MCP bridge, SCM event relay, GitHub credentials): explicit option →
+  // CURSOR_API_KEY → stored `agent-serve login`.
   const accountKey = await resolveApiKey(
     options.apiKey === undefined ? {} : { apiKey: options.apiKey }
   );
@@ -198,9 +216,58 @@ export async function startServer(
   // `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
+    effectiveCursorEvents === undefined
       ? undefined
-      : requireCursorEventsAuth(options.cursorEvents, accountKey);
+      : requireCursorEventsAuth(effectiveCursorEvents, accountKey);
+
+  let cursorGithubCredentials: CursorGithubCredentialProvider | undefined;
+  if (cursorGithubConfig.scope !== undefined) {
+    if (cursorEventsAuth === undefined) {
+      throw new Error(
+        "githubChannel({ cursorAccount: true }) could not resolve Cursor event authentication."
+      );
+    }
+    if (options.allowAnonymous === true) {
+      if (options.allowAnonymousCursorGithub !== true) {
+        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-serve] 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 (cursorGithubConfig.scope.permissions === "contents-write") {
+      logger(
+        '[agent-serve] 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 provider = new CursorGithubCredentialProvider({
+      client: new CursorBackendClient({
+        backendUrl: cursorEventsAuth.baseUrl,
+        apiKey: cursorEventsAuth.apiKey,
+        logger,
+      }),
+      scope: cursorGithubConfig.scope,
+      logger,
+    });
+    cursorGithubCredentials = provider;
+    for (const target of cursorGithubTargets) {
+      target.accountRuntime.credentials.bind(() => provider.getToken());
+    }
+  }
+  const resolvedCursorGithubCredentials = cursorGithubCredentials;
+  const hostPlatforms = createHostPlatforms(
+    resolvedCursorGithubCredentials === undefined
+      ? {}
+      : {
+          githubCredentials: {
+            token: createCursorAccountGithubTokenResolver(() =>
+              resolvedCursorGithubCredentials.getToken()
+            ),
+          },
+        }
+  );
 
   if (playground) {
     // Auto-build dist/playground when missing (monorepo / source checkout).
@@ -267,16 +334,42 @@ export async function startServer(
     const baseStateRoot =
       options.stateRoot ?? join(project.rootDir, ".agent-serve");
     const stateRoot = slug === "" ? baseStateRoot : join(baseStateRoot, slug);
-    const engine = new SessionEngine({ project, stateRoot, runner, logger });
+    const engine = new SessionEngine({
+      project,
+      stateRoot,
+      runner,
+      logger,
+      platforms: hostPlatforms,
+    });
+    // Rehydrate sessions from the authored storage sink before any
+    // channel or route can address them (continuation tokens must resolve).
+    await engine.restoreStoredSessions();
+
     if (!githubAuthWarmed) {
       // Soft ambient GitHub auth check before channel onStart (which may call
       // host.github). Missing auth is a warning only — serve still starts.
-      await warmupHostGitHubAuth({ logger, github: engine.host.github });
+      await warmupHostGitHubAuth({
+        logger,
+        github: engine.host.github,
+        ...(cursorGithubCredentials === undefined
+          ? {}
+          : { authSource: "cursor-account" }),
+      });
       githubAuthWarmed = true;
     }
     const scheduleRunner = new ScheduleRunner(engine, project, logger);
     const reminderRunner = new ReminderRunner(engine, logger);
-    const evalRuns = new EvalRunStore(project.rootDir, logger);
+    const evalRuns = new EvalRunStore(
+      project.rootDir,
+      logger,
+      // defineStorage fallback for playground eval history; explicit
+      // `evals.config.ts` persistRuns still wins inside the store.
+      engine.storage?.asEvalRunPersistence()
+    );
+    // Eval history restores with the same startup step as sessions (reads
+    // also hydrate lazily, but doing it here surfaces store problems at
+    // boot and makes /v1/dev/evals complete from the first request).
+    await evalRuns.hydrate();
     engine.setReminders({
       create: (input) => reminderRunner.create(input),
       list: (filter) => reminderRunner.list(filter),
@@ -486,15 +579,6 @@ export async function startServer(
     });
   }
 
-  // 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
@@ -505,6 +589,24 @@ export async function startServer(
     accountKey,
     logger,
   });
+  try {
+    await cursorGithubCredentials?.start();
+  } catch (error) {
+    await cursorSlackRelay?.stop();
+    throw error;
+  }
+
+  // Cursor SCM events relay (opt-in: serve({ cursorEvents }) / --cursor-events).
+  const cursorEventRelay = startCursorEventRelay({
+    config: effectiveCursorEvents,
+    stateRoot: options.stateRoot,
+    mounts,
+    auth: cursorEventsAuth,
+    logger,
+    collectTriggerTargets,
+    cursorAccountOnly:
+      options.cursorEvents === undefined && cursorGithubTargets.length > 0,
+  });
 
   const server = createServer((req, res) => {
     void handleRequest(router, req, res, logger);
@@ -512,8 +614,15 @@ export async function startServer(
 
   const host = options.host ?? "127.0.0.1";
   const port = options.port ?? 3000;
-  server.listen(port, host);
-  await once(server, "listening");
+  try {
+    server.listen(port, host);
+    await once(server, "listening");
+  } catch (error) {
+    await cursorEventRelay?.stop();
+    await cursorSlackRelay?.stop();
+    cursorGithubCredentials?.stop();
+    throw error;
+  }
   const address = server.address() as AddressInfo;
   const displayHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
   const url = `http://${displayHost}:${address.port}`;
@@ -645,7 +754,11 @@ export async function startServer(
       }
       server.close();
       server.closeAllConnections();
-      await Promise.all(runtimes.map((runtime) => runtime.engine.close()));
+      try {
+        await Promise.all(runtimes.map((runtime) => runtime.engine.close()));
+      } finally {
+        cursorGithubCredentials?.stop();
+      }
     },
   };
   if (playgroundDev?.url !== undefined) {
@@ -1223,7 +1336,10 @@ function requireCursorEventsAuth(
   }
   return {
     apiKey,
-    baseUrl: config.baseUrl ?? accountKey?.backendUrl ?? cursorBackendUrl(),
+    // `/v0/scm-events/*` lives on the external API (api.cursor.com), not
+    // api2. Prefer that default over the account key's backendUrl, which
+    // follows cursorBackendUrl() (api2) when CURSOR_API_KEY is set.
+    baseUrl: config.baseUrl ?? cursorExternalApiUrl(),
   };
 }
 
@@ -1233,14 +1349,16 @@ function requireCursorEventsAuth(
  * no github channel) warn and leave the relay off — serve still starts.
  */
 function startCursorEventRelay(input: {
-  options: ServeOptions;
+  config: ServeOptions["cursorEvents"];
+  stateRoot: string | undefined;
   mounts: AgentMount[];
   auth: CursorEventsAuth | undefined;
   logger: (line: string) => void;
   collectTriggerTargets: () => ReturnType<typeof collectGitHubTriggerTargets>;
+  cursorAccountOnly: boolean;
 }): CursorEventRelay | undefined {
-  const { options, mounts, auth, logger, collectTriggerTargets } = input;
-  const config = options.cursorEvents;
+  const { config, stateRoot, mounts, auth, logger, collectTriggerTargets } =
+    input;
   if (config === undefined || auth === undefined) {
     return undefined;
   }
@@ -1262,7 +1380,7 @@ function startCursorEventRelay(input: {
     return undefined;
   }
   const baseStateRoot =
-    options.stateRoot ??
+    stateRoot ??
     join(mounts[0]?.project.rootDir ?? process.cwd(), ".agent-serve");
   const relay = new CursorEventRelay({
     baseUrl: auth.baseUrl,
@@ -1275,12 +1393,27 @@ function startCursorEventRelay(input: {
     // envelope — rich pullRequest meta when present for onPullRequest Zod.
     dispatch: async (event) => {
       if (event.provider !== "github") return;
+      const targets = collectTriggerTargets().filter((target) => {
+        const cursorAccount = target.options.cursorAccount;
+        if (
+          input.cursorAccountOnly &&
+          cursorAccount !== true &&
+          typeof cursorAccount !== "object"
+        ) {
+          return false;
+        }
+        return typeof cursorAccount !== "object"
+          ? true
+          : cursorAccount.repos.some(
+              (repo) => repo.toLowerCase() === event.repo.toLowerCase()
+            );
+      });
       const result = await handleAgentServeTrigger({
         type: "github",
         bodyText: JSON.stringify(scmMetadataToGitHubPayload(event)),
         eventName: event.eventName,
         deliveryId: event.deliveryId,
-        targets: collectTriggerTargets(),
+        targets,
       });
       const outcomes = result.targets
         .map((target) => `${target.slug || "default"}:${target.status}`)
@@ -1297,6 +1430,64 @@ function startCursorEventRelay(input: {
   return relay;
 }
 
+interface CursorGithubTarget {
+  slug: string;
+  channelId: string;
+  accountRuntime: GithubCursorAccountRuntime;
+}
+
+function collectCursorGithubTargets(
+  mounts: AgentMount[]
+): CursorGithubTarget[] {
+  const targets: CursorGithubTarget[] = [];
+  for (const mount of mounts) {
+    for (const channel of mount.project.channels) {
+      const accountRuntime = getGithubCursorAccountRuntime(channel.definition);
+      if (accountRuntime !== undefined) {
+        targets.push({
+          slug: mount.slug,
+          channelId: channel.id,
+          accountRuntime,
+        });
+      }
+    }
+  }
+  return targets;
+}
+
+interface CursorGithubConfigResolution {
+  cursorEvents: ServeOptions["cursorEvents"];
+  scope: CursorGithubRepoScope | undefined;
+}
+
+function resolveCursorGithubEventConfig(input: {
+  configured: ServeOptions["cursorEvents"];
+  targets: CursorGithubTarget[];
+}): CursorGithubConfigResolution {
+  if (input.targets.length === 0) {
+    return { cursorEvents: input.configured, scope: undefined };
+  }
+  const repos = [
+    ...(input.configured?.repos ?? []),
+    ...input.targets.flatMap((target) => [
+      ...(target.accountRuntime.scope?.repos ?? []),
+    ]),
+  ];
+  const permissions = resolveCursorGithubPermissions(
+    input.targets.map(
+      (target) => target.accountRuntime.scope?.permissions ?? "pr-write"
+    )
+  );
+  const scope = parseCursorGithubRepoScope(repos, permissions);
+  return {
+    cursorEvents: {
+      ...input.configured,
+      repos: [...scope.repos],
+    },
+    scope,
+  };
+}
+
 interface CursorSlackTarget {
   runtime: MountedRuntime;
   channelId: string;
@@ -1304,13 +1495,16 @@ interface CursorSlackTarget {
   accountRuntime: SlackCursorAccountRuntime;
 }
 
-/** `weather-agent` → `Weather Agent` (Slack display name default). */
+/**
+ * `weather-agent` → `WeatherAgent` (single-token Cursor Slack handle).
+ * Must not contain whitespace — see {@link assertSlackCursorAgentName}.
+ */
 function slackAgentNameFromSlug(slug: string): string {
   return slug
     .split(/[-_\s]+/)
     .filter((word) => word.length > 0)
     .map((word) => word[0].toUpperCase() + word.slice(1))
-    .join(" ");
+    .join("");
 }
 
 /**
@@ -1341,6 +1535,7 @@ function collectCursorSlackTargets(
           `slackChannel({ cursorAccount: true }) on agent "${runtime.slug || runtime.project.name}" resolved an empty agent name; set agentName.`
         );
       }
+      assertSlackCursorAgentName(agentName);
       const nameKey = agentName.toLowerCase();
       const existing = byName.get(nameKey);
       if (existing !== undefined) {