@cursor/july 0.1.100 → 0.1.101

package/src/internal/cli-deploy.ts

@@ -329,6 +329,14 @@ export async function cmdDeploy(options: DeployCliOptions): Promise<number> {
   if (manifests.every((manifest) => manifest.architecture === "v2")) {
     return deployAgentsdkApplication(ctx, options, targets, {
       hasScmChannels: manifests.some((manifest) => manifest.hasScmChannels),
+      declaredSecretNames: [
+        ...new Set(
+          manifests.flatMap((manifest) => manifest.hosting?.secretNames ?? [])
+        ),
+      ],
+      hasDeploymentsChannels: manifests.some(
+        (manifest) => manifest.hasDeploymentsChannels
+      ),
     });
   }
   if (
@@ -741,6 +749,8 @@ async function deployOne(
       agentPath,
       repositories: options.cursorEventsRepos,
       hasScmChannels: manifest.hasScmChannels,
+      declaredSecretNames: hosting?.secretNames,
+      hasDeploymentsChannels: manifest.hasDeploymentsChannels,
       multiTenant: options.multiTenant === true,
     });
   }
@@ -871,7 +881,11 @@ async function deployAgentsdkApplication(
   ctx: DeployCliContext,
   options: DeployCliOptions,
   targets: readonly DeployTarget[],
-  declarations: { hasScmChannels: boolean }
+  declarations: {
+    hasScmChannels: boolean;
+    declaredSecretNames: string[];
+    hasDeploymentsChannels: boolean;
+  }
 ): Promise<number> {
   const parentDir = resolve(options.dir ?? ".");
   const slug = slugFromDirectoryName(basename(parentDir));
@@ -936,16 +950,7 @@ async function deployAgentsdkApplication(
     );
   }
 
-  // Components bake sequentially on the control plane, so the default wait
-  // budget is per component; otherwise a 2+ component deploy routinely hits
-  // the client-side timeout while the server-side deploy is still fine. An
-  // explicitly passed timeout always wins.
-  const waitCtx =
-    options.timeoutMs === undefined
-      ? { ...ctx, timeoutMs: ctx.timeoutMs * targets.length }
-      : ctx;
-
-  return deployOneAgentsdk(waitCtx, undefined, {
+  return deployOneAgentsdk(ctx, undefined, {
     slug,
     gitRepoUrl,
     gitRef,
@@ -953,6 +958,8 @@ async function deployAgentsdkApplication(
     components,
     repositories: options.cursorEventsRepos,
     hasScmChannels: declarations.hasScmChannels,
+    declaredSecretNames: declarations.declaredSecretNames,
+    hasDeploymentsChannels: declarations.hasDeploymentsChannels,
     multiTenant: options.multiTenant === true,
   });
 }
@@ -974,6 +981,10 @@ async function deployOneAgentsdk(
     repositories: string[] | undefined;
     /** Any component declares a GitHub/Origin channel. */
     hasScmChannels: boolean;
+    /** Union of application component secret declarations. */
+    declaredSecretNames?: string[];
+    /** Any component declares a deployments channel (same repo scope). */
+    hasDeploymentsChannels?: boolean;
     /** Redeploy an existing Cursor-managed product. */
     multiTenant: boolean;
   }
@@ -1048,6 +1059,9 @@ async function deployOneAgentsdk(
     );
     return 1;
   }
+  warnMissingSecrets(ctx, slug, args.declaredSecretNames, detail.secretNames);
+  const watchesRepositories =
+    args.hasScmChannels || args.hasDeploymentsChannels === true;
   ctx.out(
     `Deployed ${slug} (team ${ctx.teamId})\n` +
       `  status:       running\n` +
@@ -1059,15 +1073,16 @@ async function deployOneAgentsdk(
         : `  components:   ${args.components
             .map((component) => component.componentKey)
             .join(", ")}\n`) +
-      (detail.repositories === undefined || !args.hasScmChannels
+      (detail.repositories === undefined || !watchesRepositories
         ? ""
         : `  watching:     ${detail.repositories.length === 0 ? "(nothing)" : detail.repositories.join(", ")}\n`)
   );
-  // An agent with GitHub/Origin channels bound to no repository scope gets
-  // no deliveries at all, which is otherwise invisible in this output.
-  if (args.hasScmChannels && detail.repositories?.length === 0) {
+  // An agent with GitHub/Origin/deployments channels bound to no repository
+  // scope gets no deliveries at all (deployments channels receive the
+  // watched repos' deployment events), which is otherwise invisible here.
+  if (watchesRepositories && detail.repositories?.length === 0) {
     ctx.err(
-      `warning: ${slug} watches no repositories, so its GitHub/Origin channels receive no events.\n` +
+      `warning: ${slug} watches no repositories, so its GitHub/Origin/deployments channels receive no events.\n` +
         `  Redeploy with --cursor-events-repo <owner>/<name> to set the scope.\n`
     );
   }
@@ -1185,6 +1200,12 @@ interface DeployManifest {
    * while the deployment is bound to at least one `owner/name` scope.
    */
   hasScmChannels: boolean;
+  /**
+   * The agent has deployments channels; deploy-source edges derive from
+   * the same watched-repo set as GitHub/Origin, so it too receives
+   * nothing while the deployment watches no repositories.
+   */
+  hasDeploymentsChannels: boolean;
 }
 
 /**
@@ -1224,6 +1245,9 @@ async function readDeployManifest(dir: string): Promise<DeployManifest> {
       const kind = channel.definition.meta?.kind;
       return kind === "github" || kind === "origin";
     }),
+    hasDeploymentsChannels: project.channels.some(
+      (channel) => channel.definition.meta?.kind === "deployments"
+    ),
   };
 }
 
@@ -1450,6 +1474,9 @@ function renderAgentkitDeploymentStatus(
       }`
     );
   }
+  if (detail.secretNames !== undefined && detail.secretNames.length > 0) {
+    lines.push(`  secrets:      ${detail.secretNames.join(", ")}`);
+  }
   if (detail.lastError !== null && detail.lastError !== undefined) {
     lines.push(`  last error:   ${sanitizeCustomerError(detail.lastError)}`);
   }
@@ -1650,6 +1677,21 @@ export async function cmdRotatePodCredential(
 // secrets set|list|unset
 // ============================================================================
 
+async function secretDeploymentArchitecture(
+  ctx: DeployCliContext,
+  slug: string
+): Promise<"v1" | "v2"> {
+  try {
+    await ctx.client.getAgentkitDeploy({ teamId: ctx.teamId, slug });
+    return "v2";
+  } catch (error) {
+    if (error instanceof DeployApiError && error.status === 404) {
+      return "v1";
+    }
+    throw error;
+  }
+}
+
 export async function cmdSecretsSet(
   slug: string | undefined,
   specs: string[],
@@ -1712,11 +1754,19 @@ export async function cmdSecretsSet(
 
   let secretNames: string[];
   try {
-    secretNames = await ctx.client.setSecrets({
-      teamId: ctx.teamId,
-      slug,
-      secrets,
-    });
+    const architecture = await secretDeploymentArchitecture(ctx, slug);
+    secretNames =
+      architecture === "v2"
+        ? await ctx.client.setAgentkitSecrets({
+            teamId: ctx.teamId,
+            slug,
+            secrets,
+          })
+        : await ctx.client.setSecrets({
+            teamId: ctx.teamId,
+            slug,
+            secrets,
+          });
   } catch (error) {
     return renderApiError(error, ctx.err);
   }
@@ -1748,7 +1798,11 @@ export async function cmdSecretsList(
   }
   let secrets: SecretInfo[];
   try {
-    secrets = await ctx.client.listSecrets({ teamId: ctx.teamId, slug });
+    const architecture = await secretDeploymentArchitecture(ctx, slug);
+    secrets =
+      architecture === "v2"
+        ? await ctx.client.listAgentkitSecrets({ teamId: ctx.teamId, slug })
+        : await ctx.client.listSecrets({ teamId: ctx.teamId, slug });
   } catch (error) {
     return renderApiError(error, ctx.err);
   }
@@ -1787,7 +1841,16 @@ export async function cmdSecretsUnset(
     return ctx;
   }
   try {
-    await ctx.client.deleteSecret({ teamId: ctx.teamId, slug, name });
+    const architecture = await secretDeploymentArchitecture(ctx, slug);
+    if (architecture === "v2") {
+      await ctx.client.deleteAgentkitSecret({
+        teamId: ctx.teamId,
+        slug,
+        name,
+      });
+    } else {
+      await ctx.client.deleteSecret({ teamId: ctx.teamId, slug, name });
+    }
   } catch (error) {
     if (error instanceof DeployApiError && error.status === 404) {
       ctx.err(

package/src/internal/continuation-identity.ts

@@ -119,7 +119,9 @@ export const BUILTINS: readonly ContinuationBuiltin[] = [
   {
     type: "deployment",
     kind: "deployments",
-    events: ["deployment.created", "deployment.succeeded"],
+    // All three factory stream events carry `deploymentId`; keep in
+    // lockstep with the control plane's `conversation/deployments.ts`.
+    events: ["deployment.created", "deployment.succeeded", "deployment.failed"],
     format: "deployments:{deploymentId}",
   },
 ] as const;

package/src/internal/cursor/hosted-deployment-secrets.ts

@@ -0,0 +1,72 @@
+/**
+ * Task-time application secrets for hosted v2 freeze restores.
+ *
+ * The deployment host rewrites this tmpfs document before each admission and
+ * execution request. July reloads it synchronously because the process was
+ * already running in the frozen snapshot when the task-specific values
+ * arrived.
+ */
+
+import { readFileSync } from "node:fs";
+
+export const DEFAULT_AGENT_SERVE_DEPLOYMENT_SECRETS_FILE =
+  "/run/cursor/secrets/AGENT_SERVE_DEPLOYMENT_SECRETS.json";
+
+const SECRET_NAME_PATTERN = /^[A-Z][A-Z0-9_]{0,63}$/;
+const appliedSecretNames = new Set<string>();
+
+function parseBoundSecrets(path: string): Record<string, string> | undefined {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+  if (parsed === null || typeof parsed !== "object") {
+    return undefined;
+  }
+  const envelope = parsed as { v?: unknown; secrets?: unknown };
+  if (
+    envelope.v !== 1 ||
+    envelope.secrets === null ||
+    typeof envelope.secrets !== "object" ||
+    Array.isArray(envelope.secrets)
+  ) {
+    return undefined;
+  }
+  const secrets: Record<string, string> = {};
+  for (const [name, value] of Object.entries(envelope.secrets)) {
+    if (
+      SECRET_NAME_PATTERN.test(name) &&
+      !name.startsWith("CURSOR_") &&
+      typeof value === "string"
+    ) {
+      secrets[name] = value;
+    }
+  }
+  return secrets;
+}
+
+/**
+ * Refresh `process.env` from the latest bound document. A missing or malformed
+ * file is a no-op; an empty valid document removes values loaded by an earlier
+ * bind after the deployment secret was unset.
+ */
+export function refreshBoundDeploymentSecrets(
+  path: string = DEFAULT_AGENT_SERVE_DEPLOYMENT_SECRETS_FILE
+): void {
+  const secrets = parseBoundSecrets(path);
+  if (secrets === undefined) {
+    return;
+  }
+  for (const name of appliedSecretNames) {
+    if (!(name in secrets)) {
+      delete process.env[name];
+    }
+  }
+  appliedSecretNames.clear();
+  for (const [name, value] of Object.entries(secrets)) {
+    process.env[name] = value;
+    appliedSecretNames.add(name);
+  }
+}

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

@@ -33,17 +33,33 @@ interface SubscriptionStatus {
   detail?: string;
 }
 
+export type DeploymentSubscriptionSource =
+  | readonly ResolvedSubscription[]
+  | (() => readonly ResolvedSubscription[]);
+
 export interface DeploymentEventRelayOptions {
   baseUrl: string;
   apiKey: string;
   stateDir: string;
-  subscriptions: readonly ResolvedSubscription[];
+  /**
+   * Snapshot or a getter. A getter is re-read on every registration
+   * heartbeat so a channel that refreshes `deploySourceUris` after start
+   * can add sources without restarting the relay.
+   */
+  subscriptions: DeploymentSubscriptionSource;
   dispatch: (event: DeploymentEvent) => Promise<void>;
   logger: (line: string) => void;
   fetchImpl?: typeof fetch;
   pollWaitMs?: number;
 }
 
+/** Current subscriptions: a live getter, otherwise the snapshot. */
+export function currentDeploymentSubscriptions(
+  subscriptions: DeploymentSubscriptionSource
+): readonly ResolvedSubscription[] {
+  return typeof subscriptions === "function" ? subscriptions() : subscriptions;
+}
+
 /** Normalize the channel's `deploySourceUris` option into concrete subscriptions. */
 export function resolveDeploymentSubscriptions(options: {
   deploySourceUris: readonly (string | DeploymentSubscription)[];
@@ -90,10 +106,46 @@ export function resolveDeploymentSubscriptions(options: {
         ? []
         : [...new Set([...existing.environments, ...environments])];
   }
-  // Empty is legal here and means "this channel wants nothing", which is how
-  // an env-configured channel stays inert without a deploy-source list. The
-  // wire-level empty list means deregister, so the host simply never
-  // registers it.
+  // Empty is legal here and means "this channel wants nothing". The
+  // wire-level empty list means deregister. The host re-resolves on each
+  // heartbeat, so a channel that later fills `deploySourceUris` can
+  // register without a restart.
+  return [...bySource.values()];
+}
+
+/**
+ * Union per-channel subscriptions, widening events and environments when
+ * the same deploy source appears more than once. An empty environment
+ * list means every environment and absorbs a narrower list.
+ */
+export function mergeResolvedSubscriptions(
+  groups: readonly (readonly ResolvedSubscription[])[]
+): ResolvedSubscription[] {
+  const bySource = new Map<string, ResolvedSubscription>();
+  for (const group of groups) {
+    for (const subscription of group) {
+      const existing = bySource.get(subscription.deploySourceUri);
+      if (existing === undefined) {
+        bySource.set(subscription.deploySourceUri, {
+          deploySourceUri: subscription.deploySourceUri,
+          environments: [...subscription.environments],
+          events: new Set(subscription.events),
+        });
+        continue;
+      }
+      for (const event of subscription.events) existing.events.add(event);
+      existing.environments =
+        existing.environments.length === 0 ||
+        subscription.environments.length === 0
+          ? []
+          : [
+              ...new Set([
+                ...existing.environments,
+                ...subscription.environments,
+              ]),
+            ];
+    }
+  }
   return [...bySource.values()];
 }
 
@@ -176,7 +228,9 @@ export class DeploymentEventRelay {
       pollPath: "/v0/deployment-events",
       buildRegistrationBody: (consumerId) => ({
         consumerId,
-        subscriptions: options.subscriptions.map((subscription) => ({
+        subscriptions: currentDeploymentSubscriptions(
+          options.subscriptions
+        ).map((subscription) => ({
           deploySourceUri: subscription.deploySourceUri,
           environments: subscription.environments,
           events: [...subscription.events],
@@ -190,12 +244,15 @@ export class DeploymentEventRelay {
       }),
       applyRegistrationResponse: (json) => {
         const result = json as { deploySourceUris?: SubscriptionStatus[] };
+        const wantedSubscriptions = currentDeploymentSubscriptions(
+          options.subscriptions
+        );
         this.subscribed = new Map();
         this.loggedSkippedSources.clear();
         const lines: string[] = [];
         const confirmed: string[] = [];
         for (const status of result.deploySourceUris ?? []) {
-          const wanted = options.subscriptions.find(
+          const wanted = wantedSubscriptions.find(
             (subscription) =>
               subscription.deploySourceUri === status.deploySourceUri
           );
@@ -210,7 +267,7 @@ export class DeploymentEventRelay {
         }
         if (confirmed.length > 0) {
           const kinds = [
-            ...new Set(options.subscriptions.flatMap((s) => [...s.events])),
+            ...new Set(wantedSubscriptions.flatMap((s) => [...s.events])),
           ];
           lines.push(
             `subscribed to ${confirmed.join(", ")} for events: ${kinds.join(", ")}`

package/src/internal/deploy-client.ts

@@ -267,6 +267,8 @@ export interface AgentkitDeployStatus {
    * Absent on control planes that predate the field.
    */
   repositories?: string[];
+  /** Names of application-scoped secrets (values are never returned). */
+  secretNames?: string[];
 }
 
 export const TERMINAL_AGENTKIT_DEPLOY_STATUSES: ReadonlySet<AgentkitCustomerStatus> =
@@ -359,6 +361,7 @@ const agentkitDeployStatusSchema = z
     statusMessage: z.string().nullable(),
     // Optional: backends that predate the v2 bake-failure column omit it.
     lastError: z.string().nullable().optional(),
+    secretNames: z.array(z.string()).optional(),
   })
   .passthrough();
 
@@ -740,24 +743,7 @@ export class AgentServeDeployClient {
     slug: string;
     secrets: Array<{ name: string; value: string }>;
   }): Promise<string[]> {
-    for (const { name, value } of args.secrets) {
-      const nameError = validateSettableSecretName(name);
-      if (nameError !== undefined) {
-        throw new DeployApiError(nameError, 400);
-      }
-      if (Buffer.byteLength(value, "utf8") > MAX_SECRET_VALUE_BYTES) {
-        throw new DeployApiError(
-          `The value for ${name} is too large (max ${MAX_SECRET_VALUE_BYTES} bytes).`,
-          400
-        );
-      }
-    }
-    if (args.secrets.length > MAX_SECRETS) {
-      throw new DeployApiError(
-        `Too many secrets in one request (${args.secrets.length}); deployments hold at most ${MAX_SECRETS}.`,
-        400
-      );
-    }
+    this.validateSecrets(args.secrets);
     const raw = await this.request({
       method: "PUT",
       path: `/internal/agent-serve/deployments/${encodeURIComponent(args.slug)}/secrets`,
@@ -767,6 +753,22 @@ export class AgentServeDeployClient {
     return setSecretsResponseSchema.parse(raw).secretNames;
   }
 
+  /** Upsert application-scoped secrets on an AgentSDK v2 deployment. */
+  async setAgentkitSecrets(args: {
+    teamId: number;
+    slug: string;
+    secrets: Array<{ name: string; value: string }>;
+  }): Promise<string[]> {
+    this.validateSecrets(args.secrets);
+    const raw = await this.request({
+      method: "PUT",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/secrets`,
+      body: { teamId: args.teamId, secrets: args.secrets },
+      context: { verb: "set secrets", slug: args.slug },
+    });
+    return setSecretsResponseSchema.parse(raw).secretNames;
+  }
+
   /** Secret names + creation times; values are never returned. */
   async listSecrets(args: {
     teamId: number;
@@ -780,6 +782,19 @@ export class AgentServeDeployClient {
     return listSecretsResponseSchema.parse(raw).secrets;
   }
 
+  /** Secret names + creation times for an AgentSDK v2 application. */
+  async listAgentkitSecrets(args: {
+    teamId: number;
+    slug: string;
+  }): Promise<SecretInfo[]> {
+    const raw = await this.request({
+      method: "GET",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/secrets?teamId=${args.teamId}`,
+      context: { verb: "list secrets", slug: args.slug },
+    });
+    return listSecretsResponseSchema.parse(raw).secrets;
+  }
+
   /** Remove one secret by name; 404 when it is not set. */
   async deleteSecret(args: {
     teamId: number;
@@ -797,6 +812,46 @@ export class AgentServeDeployClient {
     });
   }
 
+  /** Remove one application-scoped secret from an AgentSDK v2 deployment. */
+  async deleteAgentkitSecret(args: {
+    teamId: number;
+    slug: string;
+    name: string;
+  }): Promise<void> {
+    const nameError = validateSettableSecretName(args.name);
+    if (nameError !== undefined) {
+      throw new DeployApiError(nameError, 400);
+    }
+    await this.request({
+      method: "DELETE",
+      path: `/internal/agentsdk/deployments/${encodeURIComponent(args.slug)}/secrets/${encodeURIComponent(args.name)}?teamId=${args.teamId}`,
+      context: { verb: "unset secret", slug: args.slug },
+    });
+  }
+
+  private validateSecrets(
+    secrets: Array<{ name: string; value: string }>
+  ): void {
+    for (const { name, value } of secrets) {
+      const nameError = validateSettableSecretName(name);
+      if (nameError !== undefined) {
+        throw new DeployApiError(nameError, 400);
+      }
+      if (Buffer.byteLength(value, "utf8") > MAX_SECRET_VALUE_BYTES) {
+        throw new DeployApiError(
+          `The value for ${name} is too large (max ${MAX_SECRET_VALUE_BYTES} bytes).`,
+          400
+        );
+      }
+    }
+    if (secrets.length > MAX_SECRETS) {
+      throw new DeployApiError(
+        `Too many secrets in one request (${secrets.length}); deployments hold at most ${MAX_SECRETS}.`,
+        400
+      );
+    }
+  }
+
   /**
    * Rotate the deployment's pod credential. Returns the masked new key —
    * the raw key is injected into the pod on the next deploy, never