@cursor/july 0.1.93 → 0.1.94

package/src/internal/server.ts

@@ -38,12 +38,6 @@ import {
   parseCursorOriginRepoScope,
 } from "../channels/origin/cursor-account.js";
 import { findOriginChannelTargets } from "../channels/origin/origin-channel.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,
@@ -88,12 +82,6 @@ import {
   scmMetadataToOriginPayload,
 } from "./cursor-event-relay.js";
 import { AGENT_SERVE_GENERATION_ENV_VAR } from "./cursor-relay-core.js";
-import {
-  type CursorSlackAgentRegistration,
-  CursorSlackRelay,
-  createCursorSlackApiCaller,
-  formatCursorSlackEventLog,
-} from "./cursor-slack-relay.js";
 import { buildAgentDeployManifest } from "./deploy-manifest.js";
 import {
   formatDiagnostics,
@@ -178,19 +166,22 @@ import {
   resolveMountConnections,
   validateMountConnectionsConfig,
 } from "./resolved-connections.js";
-import { Router } from "./router.js";
+import { Router, type ServerRouteContext } from "./router.js";
 import { RuntimeDispatchingRunner } from "./runtime-dispatch-runner.js";
 import { ScheduleRunner, UnknownScheduleError } from "./schedule-runner.js";
 import { type AgentRunner, CursorSdkRunner } from "./sdk-runner.js";
 import {
+  InvalidContinuationTokenError,
   SessionAuthError,
   SessionBusyError,
   SessionEngine,
   ToolInputError,
   ToolNotDirectlyCallableError,
   UnknownToolError,
+  WorkspaceUnavailableError,
 } from "./session-engine.js";
 import { sessionUrlsForRequest } from "./session-urls.js";
+import { catalogDetailEntry, catalogListEntry } from "./tool-catalog.js";
 
 function memoryHealthFields(engines: readonly SessionEngine[]) {
   return collectMemoryHealthFields({
@@ -929,22 +920,7 @@ export async function startServer(
     });
   }
 
-  // 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 = await startCursorSlackRelay({
-    options,
-    runtimes,
-    accountKey,
-    logger,
-  });
-  try {
-    await cursorGithubCredentials?.start();
-  } catch (error) {
-    await cursorSlackRelay?.stop();
-    throw error;
-  }
+  await cursorGithubCredentials?.start();
 
   // Cursor SCM events: v1 stays on the engine poll. v2 ingest is local-CP
   // only — hosted `--no-control-plane` skips the July poll (hosted CP wakes).
@@ -1020,7 +996,6 @@ export async function startServer(
     await cursorDeploymentRelay?.stop();
     await cursorEventRelay?.stop();
     await controlPlaneScmRelay?.stop();
-    await cursorSlackRelay?.stop();
     cursorGithubCredentials?.stop();
     await shutdownOtelRuntime(otelRuntime);
     throw error;
@@ -1187,7 +1162,6 @@ export async function startServer(
       await cursorDeploymentRelay?.stop();
       await cursorEventRelay?.stop();
       await controlPlaneScmRelay?.stop();
-      await cursorSlackRelay?.stop();
       for (const runtime of runtimes) {
         runtime.controlPlane?.stop();
         runtime.scheduleRunner.stop();
@@ -1540,6 +1514,123 @@ function mountAgentRoutes(
     });
   }
 
+  // The live tool catalog: the session's tool namespace as a turn would
+  // assemble it — authored server tools plus advertised MCP passthroughs —
+  // under model-facing names. `/v1/info` stays the static authored
+  // manifest; this is the runtime view only the running deployment can
+  // answer. `session` / `continuationToken` query parameters bind the
+  // listing to a session identity (advertised inventories can be
+  // tenant-scoped and resolved per session).
+  const resolveCatalogBinding = async (
+    request: Request,
+    ctx: Pick<ServerRouteContext, "auth" | "requestIp">
+  ): Promise<
+    | { sessionId?: string; continuationToken?: string }
+    | { errorResponse: Response }
+  > => {
+    const url = new URL(request.url);
+    const sessionId = url.searchParams.get("session") ?? undefined;
+    const continuationToken =
+      url.searchParams.get("continuationToken") ?? undefined;
+    if (sessionId !== undefined) {
+      const record = await engine.sessions.get(sessionId);
+      if (record === undefined) {
+        return {
+          errorResponse: 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 { errorResponse: ownership };
+      }
+    }
+    return { sessionId, continuationToken };
+  };
+
+  router.add({
+    method: "GET",
+    pattern: `${base}/v1/tools`,
+    auth: httpAuth,
+    handler: async (request, ctx) => {
+      const binding = await resolveCatalogBinding(request, ctx);
+      if ("errorResponse" in binding) {
+        return binding.errorResponse;
+      }
+      try {
+        const catalog = await engine.listCatalogTools({
+          auth: ctx.auth,
+          ...binding,
+        });
+        return jsonResponse({
+          tools: catalog.tools.map(catalogListEntry),
+          // JSON.stringify drops the key when there is nothing to report.
+          connectionErrors:
+            catalog.connectionErrors.length === 0
+              ? undefined
+              : catalog.connectionErrors,
+        });
+      } catch (error) {
+        if (error instanceof InvalidContinuationTokenError) {
+          return errorResponse(
+            400,
+            "invalid_continuation_token",
+            error.message
+          );
+        }
+        throw error;
+      }
+    },
+  });
+
+  router.add({
+    method: "GET",
+    pattern: `${base}/v1/tools/:toolName`,
+    auth: httpAuth,
+    handler: async (request, ctx) => {
+      const toolName = ctx.params.toolName ?? "";
+      const binding = await resolveCatalogBinding(request, ctx);
+      if ("errorResponse" in binding) {
+        return binding.errorResponse;
+      }
+      try {
+        const catalog = await engine.listCatalogTools({
+          auth: ctx.auth,
+          ...binding,
+        });
+        const tool = catalog.tools.find((t) => t.name === toolName);
+        if (tool === undefined) {
+          return jsonResponse(
+            {
+              ok: false,
+              error: "unknown_tool",
+              message: `Unknown tool "${toolName}".`,
+              availableTools: catalog.tools.map((t) => t.name),
+            },
+            { status: 404 }
+          );
+        }
+        return jsonResponse(catalogDetailEntry(tool));
+      } catch (error) {
+        if (error instanceof InvalidContinuationTokenError) {
+          return errorResponse(
+            400,
+            "invalid_continuation_token",
+            error.message
+          );
+        }
+        throw error;
+      }
+    },
+  });
+
   // Deterministic tool invocation: run an authored server tool directly,
   // without a model turn deciding to call it.
   router.add({
@@ -1563,6 +1654,17 @@ function mountAgentRoutes(
           "`sessionId` must be a string when provided."
         );
       }
+      if (
+        body.continuationToken !== undefined &&
+        typeof body.continuationToken !== "string"
+      ) {
+        return errorResponse(
+          400,
+          "invalid_request",
+          "`continuationToken` must be a string when provided."
+        );
+      }
+      const continuationToken = body.continuationToken;
       const sessionId = body.sessionId;
       if (sessionId !== undefined) {
         const record = await engine.sessions.get(sessionId);
@@ -1585,7 +1687,8 @@ function mountAgentRoutes(
       try {
         const outcome = await engine.callTool(toolName, body.input ?? {}, {
           auth: ctx.auth,
-          ...(sessionId === undefined ? {} : { sessionId }),
+          sessionId,
+          continuationToken,
         });
         return jsonResponse({ ok: !outcome.isError, ...outcome });
       } catch (error) {
@@ -1606,6 +1709,16 @@ function mountAgentRoutes(
         if (error instanceof ToolInputError) {
           return errorResponse(400, "invalid_tool_input", error.message);
         }
+        if (error instanceof InvalidContinuationTokenError) {
+          return errorResponse(
+            400,
+            "invalid_continuation_token",
+            error.message
+          );
+        }
+        if (error instanceof WorkspaceUnavailableError) {
+          return errorResponse(500, "workspace_unavailable", error.message);
+        }
         throw error;
       }
     },
@@ -2410,54 +2523,11 @@ function resolveCursorOriginRepoScope(input: {
   return parseCursorOriginRepoScope(repos);
 }
 
-interface CursorSlackTarget {
-  runtime: MountedRuntime;
-  channelId: string;
-  agentName: string;
-  accountRuntime: SlackCursorAccountRuntime;
-}
-
-/**
- * `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("");
-}
-
-/**
- * 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 buildAgentIndexEntries(runtimes: MountedRuntime[]): AgentIndexEntry[] {
-  const cursorSlackBySlug = new Map(
-    collectCursorSlackTargets(runtimes).map((target) => [
-      target.runtime.slug,
-      target.agentName,
-    ])
-  );
   return runtimes.map(({ slug, project }) => {
-    const cursorName = cursorSlackBySlug.get(slug);
-    const hasSocketSlack = project.channels.some(
-      (channel) =>
-        channel.definition.meta?.kind === "slack" &&
-        channel.definition.meta?.slackCursorAccount !== true
+    const hasSlack = project.channels.some(
+      (channel) => channel.definition.meta?.kind === "slack"
     );
-    const slack =
-      cursorName !== undefined
-        ? {
-            kind: "cursor-account" as const,
-            handle: `@Cursor ${cursorName}`,
-          }
-        : hasSocketSlack
-          ? { kind: "socket" as const }
-          : undefined;
     return {
       slug,
       name: project.name,
@@ -2467,60 +2537,11 @@ function buildAgentIndexEntries(runtimes: MountedRuntime[]): AgentIndexEntry[] {
           : (project.agent.model?.id ?? ""),
       tools: project.agent.tools.length,
       channels: project.channels.length + 1,
-      slack,
+      slack: hasSlack ? { kind: "socket" as const } : undefined,
     };
   });
 }
 
-function collectCursorSlackTargets(
-  runtimes: MountedRuntime[]
-): CursorSlackTarget[] {
-  const targets: CursorSlackTarget[] = [];
-  const byName = new Map<string, string>();
-  for (const runtime of runtimes) {
-    for (const channel of runtime.project.channels) {
-      const accountRuntime = getSlackCursorAccountRuntime(channel.definition);
-      if (accountRuntime === undefined) {
-        continue;
-      }
-      const agentName = (
-        accountRuntime.options.agentName ??
-        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.`
-        );
-      }
-      assertSlackCursorAgentName(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.
- */
 interface CursorDeploymentTarget {
   runtime: MountedRuntime;
   channelId: string;
@@ -2558,7 +2579,7 @@ function collectCursorDeploymentTargets(
  * `deploymentsChannel({ ... })`. One relay per process reads
  * `/v0/deployment-events` for the union of every channel's deploy sources, and
  * each event is routed to the channels that asked for it — the same ownership
- * `startCursorSlackRelay` and `startCursorEventRelay` have.
+ * `startCursorEventRelay` has.
  */
 function startCursorDeploymentRelay(input: {
   options: ServeOptions;
@@ -2617,8 +2638,8 @@ function startCursorDeploymentRelay(input: {
             ];
     }
   }
-  // Same host split as scm-events and slack-events: `/v0/deployment-events/*`
-  // is on api.cursor.com, not api2.
+  // Same host split as scm-events: `/v0/deployment-events/*` is on
+  // api.cursor.com, not api2.
   const baseStateRoot =
     options.stateRoot ??
     join(targets[0].runtime.project.rootDir, ".agent-serve");
@@ -2654,127 +2675,6 @@ function startCursorDeploymentRelay(input: {
   return relay;
 }
 
-async function startCursorSlackRelay(input: {
-  options: ServeOptions;
-  runtimes: MountedRuntime[];
-  accountKey: ResolvedApiKey | undefined;
-  logger: (line: string) => void;
-}): Promise<CursorSlackRelay | undefined> {
-  const { options, runtimes, accountKey, logger } = input;
-  const targets = collectCursorSlackTargets(runtimes);
-  if (targets.length === 0) {
-    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,
-  // not api2 (accountKey.backendUrl 404s these routes).
-  const baseUrl = cursorExternalApiUrl();
-  const baseStateRoot =
-    options.stateRoot ??
-    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: CursorSlackAgentRegistration[] = targets.map((target) => {
-    const policy = target.accountRuntime.options.policy;
-    return {
-      name: target.agentName,
-      iconUrl: target.accountRuntime.options.agentIcon?.url,
-      iconEmoji: target.accountRuntime.options.agentIcon?.emoji,
-      blockExternals: policy?.blockExternals === false ? false : undefined,
-    };
-  });
-
-  const targetByName = new Map(
-    targets.map((target) => [target.agentName.toLowerCase(), target])
-  );
-  const relay = new CursorSlackRelay({
-    baseUrl,
-    apiKey: accountKey.apiKey,
-    agents,
-    stateDir,
-    logger,
-    dispatch: async (envelope) => {
-      const target = targetByName.get(envelope.agentName.toLowerCase());
-      if (target === undefined) {
-        return;
-      }
-      const args = buildChannelHandlerArgs({
-        runtime: target.runtime,
-        channelId: target.channelId,
-      });
-      logger(
-        `[agent-sdk] cursor-slack: dispatching ${formatCursorSlackEventLog(envelope)} → ${target.runtime.slug || "default"}`
-      );
-      await dispatchCursorSlackEnvelope({
-        runtime: target.accountRuntime,
-        envelope,
-        send: args.send,
-        host: args.host,
-        artifacts: args.artifacts,
-        hasContinuationSession: (continuationToken) =>
-          target.runtime.engine.hasContinuationSession(
-            target.channelId,
-            continuationToken
-          ),
-        isContinuationBusy: (continuationToken) =>
-          target.runtime.engine.isContinuationBusy(
-            target.channelId,
-            continuationToken
-          ),
-        getContinuationLastBotMessageTs: (continuationToken) =>
-          target.runtime.engine.getContinuationLastBotMessageTs(
-            target.channelId,
-            continuationToken
-          ),
-        interruptContinuation: (continuationToken) =>
-          target.runtime.engine.interruptContinuation(
-            target.channelId,
-            continuationToken
-          ),
-      });
-    },
-  });
-
-  // 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 = await 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-sdk] 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: {
   runtime: MountedRuntime;
   channelId: string;