@cursor/july 0.1.92 → 0.1.94

package/src/internal/cursor-slack-relay.ts

@@ -1,249 +0,0 @@
-/**
- * Pulls `/v0/slack-events` into agent-serve: register the mounted
- * cursor-account Slack agents (name + icon) with the Cursor backend, then
- * long-poll routed events with a durable offset under
- * `<stateDir>/offset.json` and dispatch each to the agent it addresses.
- * Outbound Slack Web API calls are proxied through `POST /v0/slack-events/api`
- * via a per-agent {@link SlackApiTransport} binding.
- *
- * Same lifecycle rules as the SCM relay (`cursor-event-relay.ts`):
- * registration-gated consumption, heartbeat re-registration, durable
- * consumer id, at-least-once dispatch with client-owned offsets.
- */
-
-import type { CursorSlackEnvelope } from "../channels/slack/cursor-account.js";
-import {
-  CursorRelayCore,
-  describeRelayError,
-  type RelayAdapter,
-} from "./cursor-relay-core.js";
-
-/** One agent this host registers over the Cursor Slack connection. */
-export interface CursorSlackAgentRegistration {
-  name: string;
-  iconUrl?: string;
-  iconEmoji?: string;
-  /** Opt out of the default external-sender block. */
-  blockExternals?: boolean;
-}
-
-interface RegistrationResponse {
-  workspaces?: Array<{
-    slackTeamId: string;
-    isSubscribed: boolean;
-    detail?: string;
-  }>;
-  agents?: Array<{ name: string; isSubscribed: boolean; detail?: string }>;
-  expiresAt?: string;
-}
-
-/** One relayed event as delivered to {@link CursorSlackRelayOptions.dispatch}. */
-export type CursorSlackRelayEvent = CursorSlackEnvelope & { offset: string };
-
-export interface CursorSlackRelayOptions {
-  baseUrl: string;
-  apiKey: string;
-  agents: readonly CursorSlackAgentRegistration[];
-  stateDir: string;
-  /**
-   * Called for each event addressed to this consumer's agents; failures
-   * retry a bounded number of times, then log and skip.
-   */
-  dispatch: (envelope: CursorSlackRelayEvent) => Promise<void>;
-  logger: (line: string) => void;
-  /** Test seam. Defaults to global fetch. */
-  fetchImpl?: typeof fetch;
-  /** Test seam: override long-poll wait (default 25s). */
-  pollWaitMs?: number;
-}
-
-/** Human-readable log fragment for one relayed Slack event. */
-export function formatCursorSlackEventLog(envelope: {
-  eventName: string;
-  agentName: string;
-  matchedBy: string;
-  channelId: string;
-  threadTs: string;
-  receivedAtMs: number;
-  eventId?: string;
-}): string {
-  const received = new Date(envelope.receivedAtMs).toISOString();
-  return `${envelope.eventName} → ${envelope.agentName} (${envelope.matchedBy}) in ${envelope.channelId}/${envelope.threadTs} received=${received} (${envelope.eventId ?? "no event id"})`;
-}
-
-/**
- * Build the backend proxy caller one agent's {@link SlackApiTransport}
- * binds to. Returns Slack-shaped `{ ok: false, error }` bodies on transport
- * failures so channel soft-fail paths behave exactly like direct Web API
- * callers.
- */
-export function createCursorSlackApiCaller(args: {
-  baseUrl: string;
-  apiKey: string;
-  agentName: string;
-  consumerId: string;
-  fetchImpl?: typeof fetch;
-  logger?: (line: string) => void;
-}): (
-  method: string,
-  callArgs: Record<string, unknown>
-) => Promise<Record<string, unknown>> {
-  const fetchImpl = args.fetchImpl ?? fetch;
-  const url = `${args.baseUrl.replace(/\/+$/, "")}/v0/slack-events/api`;
-  return async (method, callArgs) => {
-    try {
-      const response = await fetchImpl(url, {
-        method: "POST",
-        headers: {
-          authorization: `Bearer ${args.apiKey}`,
-          "content-type": "application/json",
-        },
-        body: JSON.stringify({
-          method,
-          arguments: callArgs,
-          agentName: args.agentName,
-          consumerId: args.consumerId,
-        }),
-      });
-      const body = (await response.json().catch(() => undefined)) as
-        | Record<string, unknown>
-        | undefined;
-      if (body !== undefined && typeof body === "object") {
-        if (!response.ok && body.ok === undefined) {
-          const error =
-            typeof body.error === "string"
-              ? body.error
-              : `cursor_backend_http_${response.status}`;
-          return { ok: false, error };
-        }
-        return body;
-      }
-      return {
-        ok: false,
-        error: `cursor_backend_http_${response.status}`,
-      };
-    } catch (error) {
-      args.logger?.(
-        `[agent-sdk] cursor-slack: ${method} proxy call failed: ${describeRelayError(error)}`
-      );
-      return { ok: false, error: "cursor_backend_unreachable" };
-    }
-  };
-}
-
-/**
- * Cursor Slack relay: a thin {@link CursorRelayCore} adapter. Keeps the same
- * `new CursorSlackRelay(options)` surface with `.resolveConsumerId()`,
- * `.start()`, and `.stop()` (the server binds outbound transports with the
- * resolved consumer id before starting).
- */
-export class CursorSlackRelay {
-  private readonly core: CursorRelayCore<CursorSlackRelayEvent>;
-  /**
-   * Agent names (lowercased) the server confirmed for THIS consumer. The
-   * stream is shared with sibling consumers of the same principal, so only
-   * events for these agents (and this consumer id) may dispatch.
-   */
-  private subscribedAgents = new Set<string>();
-  private consumerId = "";
-
-  constructor(private readonly options: CursorSlackRelayOptions) {
-    const adapter: RelayAdapter<CursorSlackRelayEvent> = {
-      logPrefix: "cursor-slack",
-      subscribePath: "/v0/slack-events/subscriptions",
-      pollPath: "/v0/slack-events",
-      buildRegistrationBody: (consumerId) => {
-        this.consumerId = consumerId;
-        return {
-          consumerId,
-          // Optional fields may be undefined — JSON.stringify drops them
-          // from the registration body.
-          agents: this.options.agents.map((agent) => ({
-            name: agent.name,
-            iconUrl: agent.iconUrl,
-            iconEmoji: agent.iconEmoji,
-            blockExternals: agent.blockExternals === false ? false : undefined,
-          })),
-        };
-      },
-      // Empty agents drop this consumer's registration on clean stop, so a
-      // redeployed sibling's identical agent names never tie with this
-      // host's ghost until the server-side TTL lapses.
-      buildDeregistrationBody: (consumerId) => ({ consumerId, agents: [] }),
-      applyRegistrationResponse: (json) => {
-        const result = json as RegistrationResponse;
-        const agentStatuses = result.agents ?? [];
-        this.subscribedAgents = new Set(
-          agentStatuses
-            .filter((status) => status.isSubscribed)
-            .map((status) => status.name.toLowerCase())
-        );
-        const failures = [
-          ...(result.workspaces ?? [])
-            .filter((workspace) => !workspace.isSubscribed)
-            .map(
-              (workspace) =>
-                `workspace ${workspace.slackTeamId}: ${workspace.detail ?? "not subscribed"}`
-            ),
-          ...agentStatuses
-            .filter((status) => !status.isSubscribed)
-            .map(
-              (status) => `agent ${status.name}: ${status.detail ?? "rejected"}`
-            ),
-        ];
-        if (failures.length > 0) {
-          return failures;
-        }
-        const workspaceIds = (result.workspaces ?? [])
-          .filter((workspace) => workspace.isSubscribed)
-          .map((workspace) => workspace.slackTeamId);
-        return [
-          `registered ${[...this.subscribedAgents].join(", ")} on Slack workspace ${workspaceIds.join(", ")}`,
-        ];
-      },
-      shouldDispatch: (event) => this.shouldDispatch(event),
-      dispatch: (event) => this.options.dispatch(event),
-    };
-    this.core = new CursorRelayCore<CursorSlackRelayEvent>({
-      baseUrl: options.baseUrl,
-      apiKey: options.apiKey,
-      stateDir: options.stateDir,
-      adapter,
-      logger: options.logger,
-      ...(options.fetchImpl === undefined
-        ? {}
-        : { fetchImpl: options.fetchImpl }),
-      ...(options.pollWaitMs === undefined
-        ? {}
-        : { pollWaitMs: options.pollWaitMs }),
-    });
-  }
-
-  /**
-   * Resolve the durable consumer id before starting, so transports can bind
-   * with it. Also used by tests.
-   */
-  async resolveConsumerId(): Promise<string> {
-    this.consumerId = await this.core.resolveConsumerId();
-    return this.consumerId;
-  }
-
-  /**
-   * Whether a relayed event belongs to THIS consumer: the backend stamps
-   * each envelope with the registering consumer id and agent.
-   */
-  private shouldDispatch(event: CursorSlackRelayEvent): boolean {
-    if (event.consumerId !== this.consumerId) {
-      return false;
-    }
-    return this.subscribedAgents.has(event.agentName.toLowerCase());
-  }
-
-  start(): void {
-    this.core.start();
-  }
-
-  async stop(): Promise<void> {
-    await this.core.stop();
-  }
-}