@cursor/july 0.1.92 → 0.1.93

package/src/internal/hosted-delivery.ts

@@ -0,0 +1,327 @@
+import { randomBytes } from "node:crypto";
+import {
+  dispatchGitHubWebhook,
+  getGitHubChannelOptions,
+  getGitHubDispatchOutcome,
+  withPropagatingGitHubBackgroundErrors,
+} from "../channels/github/github-channel.js";
+import type {
+  AuthPolicy,
+  ChannelHandlerArgs,
+  SendMessageOptions,
+} from "../types.js";
+import {
+  HOSTED_ADMISSION_PATH,
+  HOSTED_DELIVERY_HEADER,
+  HOSTED_DELIVERY_PROTOCOL_VERSION,
+  HOSTED_EXECUTION_PATH,
+  type HostedAdmission,
+  parseHostedAdmission,
+  parseHostedExecution,
+} from "./hosted-delivery-protocol.js";
+import { errorResponse, readJsonObject } from "./http-channel.js";
+import type { Router } from "./router.js";
+
+type DispatchInput = {
+  delivery: HostedAdmission;
+  definition: object;
+  args: ChannelHandlerArgs;
+};
+
+type PendingSend = {
+  channelId: string;
+  message: string;
+  options: SendMessageOptions;
+  mailboxContinuationKey: string;
+};
+
+type AdmissionDispatch = {
+  response: Response;
+  pendingSend?: PendingSend;
+};
+
+type ExecutionReply = {
+  status: number;
+  body: Record<string, unknown>;
+};
+
+class HostedSendAdmitted extends Error {
+  constructor(
+    readonly prompt: string,
+    readonly options: SendMessageOptions
+  ) {
+    super("hosted channel admitted a send");
+  }
+}
+
+/**
+ * Run authored admission without creating a framework session. V1 GitHub
+ * `task` callbacks execute as sessionless work; `send` is captured and
+ * resumed only after the control plane allocates `ses_…`.
+ */
+export async function dispatchHostedAdmission(
+  input: DispatchInput
+): Promise<AdmissionDispatch> {
+  const github = getGitHubChannelOptions(input.definition);
+  if (github === undefined) {
+    return {
+      response: Response.json(
+        { ok: false, error: "channel_kind_mismatch" },
+        { status: 422 }
+      ),
+    };
+  }
+
+  const background: Promise<unknown>[] = [];
+  let deferredSend: HostedSendAdmitted | undefined;
+  const args = withPropagatingGitHubBackgroundErrors({
+    ...input.args,
+    send: async (message, options = {}) => {
+      throw new HostedSendAdmitted(message, options);
+    },
+    waitUntil: (promise) => {
+      background.push(
+        promise.catch((error: unknown) => {
+          if (error instanceof HostedSendAdmitted) {
+            deferredSend = error;
+            return;
+          }
+          throw error;
+        })
+      );
+    },
+  });
+  let dispatched: Response;
+  try {
+    dispatched = await dispatchGitHubWebhook({
+      options: github,
+      eventName: input.delivery.eventType,
+      payload: input.delivery.payload,
+      deliveryId: input.delivery.deliveryId,
+      args,
+    });
+  } catch (error) {
+    if (error instanceof HostedSendAdmitted) {
+      return {
+        response: Response.json({
+          ok: true,
+          v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+          outcome: "send",
+        }),
+        pendingSend: {
+          channelId: input.delivery.channelId,
+          message: error.prompt,
+          options: error.options,
+          mailboxContinuationKey: input.delivery.mailboxContinuationKey,
+        },
+      };
+    }
+    throw error;
+  }
+  if (!dispatched.ok) {
+    return {
+      response: Response.json(
+        { ok: false, error: "channel_dispatch_failed" },
+        { status: dispatched.status >= 400 ? dispatched.status : 502 }
+      ),
+    };
+  }
+
+  try {
+    await Promise.all(background);
+  } catch {
+    return {
+      response: Response.json(
+        { ok: false, error: "background_dispatch_failed" },
+        { status: 503 }
+      ),
+    };
+  }
+  if (deferredSend !== undefined) {
+    return {
+      response: Response.json({
+        ok: true,
+        v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+        outcome: "send",
+      }),
+      pendingSend: {
+        channelId: input.delivery.channelId,
+        message: deferredSend.prompt,
+        options: deferredSend.options,
+        mailboxContinuationKey: input.delivery.mailboxContinuationKey,
+      },
+    };
+  }
+  const outcome = getGitHubDispatchOutcome(dispatched);
+  if (outcome === undefined) {
+    return {
+      response: Response.json(
+        { ok: false, error: "channel_outcome_missing" },
+        { status: 502 }
+      ),
+    };
+  }
+  return {
+    response: Response.json({
+      ok: true,
+      v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+      outcome,
+    }),
+  };
+}
+
+export function registerHostedDeliveryRoute(input: {
+  router: Router;
+  base: string;
+  channels: Array<{ id: string; definition: object }>;
+  buildHandlerArgs(
+    channelId: string,
+    sessionPublicId?: string
+  ): ChannelHandlerArgs;
+}): void {
+  const pending = new Map<
+    string,
+    {
+      send: PendingSend;
+      expiresAt: number;
+      sessionPublicId?: string;
+      execution?: Promise<ExecutionReply>;
+    }
+  >();
+  const pendingTtlMs = 10 * 60_000;
+  const pruneExpired = () => {
+    const now = Date.now();
+    for (const [token, item] of pending) {
+      if (item.expiresAt <= now) {
+        pending.delete(token);
+      }
+    }
+  };
+
+  // Hosted callers reach this only through AnyRun's signed pod-port URL.
+  // The marker is a second, route-specific fence distinct from channel auth.
+  const auth: AuthPolicy = (request) => {
+    if (request.headers.get(HOSTED_DELIVERY_HEADER) !== "1") {
+      return null;
+    }
+    return {
+      authenticator: "app",
+      principalId: "agent-sdk:hosted-delivery",
+      principalType: "runtime",
+    };
+  };
+  input.router.add({
+    method: "POST",
+    pattern: `${input.base}${HOSTED_ADMISSION_PATH}`,
+    auth: [auth],
+    handler: async (request) => {
+      const delivery = parseHostedAdmission(await readJsonObject(request));
+      if (delivery === undefined) {
+        return errorResponse(
+          400,
+          "invalid_hosted_admission",
+          "Expected a supported Agent SDK hosted-admission envelope."
+        );
+      }
+      const channel = input.channels.find(
+        (candidate) => candidate.id === delivery.channelId
+      );
+      if (channel === undefined) {
+        return errorResponse(
+          404,
+          "channel_not_found",
+          `No channel named "${delivery.channelId}" is mounted.`
+        );
+      }
+      const admitted = await dispatchHostedAdmission({
+        delivery,
+        definition: channel.definition,
+        args: input.buildHandlerArgs(delivery.channelId),
+      });
+      if (admitted.pendingSend === undefined) {
+        return admitted.response;
+      }
+      pruneExpired();
+      const admissionToken = randomBytes(24).toString("hex");
+      pending.set(admissionToken, {
+        send: admitted.pendingSend,
+        expiresAt: Date.now() + pendingTtlMs,
+      });
+      return Response.json({
+        ok: true,
+        v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+        outcome: "send",
+        admissionToken,
+      });
+    },
+  });
+  input.router.add({
+    method: "POST",
+    pattern: `${input.base}${HOSTED_EXECUTION_PATH}`,
+    auth: [auth],
+    handler: async (request) => {
+      const execution = parseHostedExecution(await readJsonObject(request));
+      if (execution === undefined) {
+        return errorResponse(
+          400,
+          "invalid_hosted_execution",
+          "Expected a supported Agent SDK hosted-execution envelope."
+        );
+      }
+      pruneExpired();
+      const admitted = pending.get(execution.admissionToken);
+      if (admitted === undefined) {
+        return errorResponse(
+          409,
+          "hosted_admission_unavailable",
+          "The hosted admission token is missing or expired."
+        );
+      }
+      if (
+        admitted.sessionPublicId !== undefined &&
+        admitted.sessionPublicId !== execution.sessionPublicId
+      ) {
+        return errorResponse(
+          409,
+          "hosted_admission_session_mismatch",
+          "The hosted admission token is already bound to another session."
+        );
+      }
+      admitted.sessionPublicId = execution.sessionPublicId;
+      admitted.execution ??= (async (): Promise<ExecutionReply> => {
+        const args = input.buildHandlerArgs(
+          admitted.send.channelId,
+          execution.sessionPublicId
+        );
+        const session = await args.send(admitted.send.message, {
+          ...admitted.send.options,
+          mailboxContinuation: {
+            key: admitted.send.mailboxContinuationKey,
+          },
+        });
+        const outcome = await session.waitForCompletion();
+        if (outcome.status !== "finished") {
+          return {
+            status: 503,
+            body: {
+              ok: false,
+              error: "turn_failed",
+              turnStatus: outcome.status,
+              message: outcome.errorMessage,
+            },
+          };
+        }
+        return {
+          status: 200,
+          body: {
+            ok: true,
+            v: HOSTED_DELIVERY_PROTOCOL_VERSION,
+            outcome: "send",
+          },
+        };
+      })();
+      const reply = await admitted.execution;
+      return Response.json(reply.body, { status: reply.status });
+    },
+  });
+}

package/src/internal/http-channel.ts

@@ -16,7 +16,6 @@ import type {
   AuthContext,
   AuthPolicy,
   HttpChannelDefinition,
-  JsonValue,
   SessionRecord,
 } from "../types.js";
 import { samePrincipal } from "./auth.js";
@@ -101,7 +100,6 @@ export function buildHttpChannelRoutes(args: {
       const cloud = readCloudOptions(body.cloud);
       const session = await engine.send(HTTP_CHANNEL_ID, message, {
         auth: ctx.auth,
-        ...(body.state === undefined ? {} : { state: body.state as JsonValue }),
         ...(typeof body.title === "string" ? { title: body.title } : {}),
         ...(body.purpose === "eval" ? { purpose: "eval" as const } : {}),
         ...(body.dryRun === true ? { dryRun: true } : {}),