@cursor/july 0.1.80 → 0.1.83

package/src/internal/continuation-channel.ts

@@ -0,0 +1,129 @@
+import { getGitHubChannelOptions } from "../channels/github/github-channel.js";
+import { getOriginChannelOptions } from "../channels/origin/origin-channel.js";
+import { getSlackChannelOptions } from "../channels/slack/slack-channel.js";
+import type {
+  AgentArchitecture,
+  ChannelDefinition,
+  HttpChannelDefinition,
+} from "../types.js";
+import {
+  type ContinuationIdentity,
+  type ContinuationProtocolVersion,
+  defaultContinuationSelector,
+  handshakeContinuation,
+  normalizeIdentity,
+} from "./continuation-identity.js";
+
+export function channelContinuationIdentity(
+  definition: object | undefined
+): ContinuationIdentity {
+  if (definition === undefined) {
+    return defaultContinuationSelector();
+  }
+  const github = getGitHubChannelOptions(definition);
+  if (github !== undefined) {
+    return normalizeIdentity(github.continuation, "github");
+  }
+  const slack = getSlackChannelOptions(definition);
+  if (slack !== undefined) {
+    return normalizeIdentity(slack.continuation, "slack");
+  }
+  const origin = getOriginChannelOptions(definition);
+  if (origin !== undefined) {
+    return normalizeIdentity(origin.continuation, "origin");
+  }
+  return defaultContinuationSelector();
+}
+
+export function httpContinuationIdentity(
+  httpChannel: HttpChannelDefinition | undefined
+): ContinuationIdentity {
+  return normalizeIdentity(httpChannel?.continuation, "http");
+}
+
+/**
+ * Stamp `/v2` continuation defaults onto channel constructors that omitted
+ * `continuation` when the agent deploys onto v2 architecture. GitHub/Origin
+ * type (`pr` / `issue` / `none`) follows declared webhook events. Explicit
+ * per-channel selectors are left alone. Idempotent.
+ */
+export function applyAgentContinuationDefaults(project: {
+  agent: { architecture?: AgentArchitecture };
+  channels: ReadonlyArray<{ definition: object }>;
+  httpChannel: HttpChannelDefinition;
+}): void {
+  if (project.agent.architecture !== "v2") {
+    return;
+  }
+  for (const channel of project.channels) {
+    stampOmittedChannelContinuation(channel.definition, "v2");
+  }
+  if (project.httpChannel.continuation === undefined) {
+    project.httpChannel.continuation = defaultContinuationSelector(
+      "http",
+      "v2"
+    );
+  }
+}
+
+function stampOmittedChannelContinuation(
+  definition: object,
+  version: ContinuationProtocolVersion
+): void {
+  const events = declaredChannelEventTypes(definition);
+  const github = getGitHubChannelOptions(definition);
+  if (github !== undefined) {
+    if (github.continuation === undefined) {
+      github.continuation = defaultContinuationSelector(
+        "github",
+        version,
+        events
+      );
+    }
+    return;
+  }
+  const slack = getSlackChannelOptions(definition);
+  if (slack !== undefined) {
+    if (slack.continuation === undefined) {
+      slack.continuation = defaultContinuationSelector("slack", version);
+    }
+    return;
+  }
+  const origin = getOriginChannelOptions(definition);
+  if (origin !== undefined) {
+    if (origin.continuation === undefined) {
+      origin.continuation = defaultContinuationSelector(
+        "origin",
+        version,
+        events
+      );
+    }
+  }
+}
+
+function declaredChannelEventTypes(
+  definition: object
+): readonly string[] | undefined {
+  const meta = (definition as ChannelDefinition).meta;
+  return meta?.githubWebhookEvents ?? meta?.originWebhookEvents;
+}
+
+export function handshakeChannelContinuation(input: {
+  id: string;
+  definition: ChannelDefinition;
+}): { ok: true } | { ok: false; error: string } {
+  const kind = input.definition.meta?.kind;
+  const eventTypes = [
+    ...(input.definition.meta?.githubWebhookEvents ?? []),
+    ...(input.definition.meta?.originWebhookEvents ?? []),
+  ];
+  const result = handshakeContinuation({
+    kind,
+    eventTypes,
+    identity: channelContinuationIdentity(input.definition),
+  });
+  if (!result.ok) {
+    return { ok: false, error: `channel ${input.id}: ${result.error}` };
+  }
+  return result;
+}