@cursor/july 0.1.100 → 0.1.102

package/src/files.ts

@@ -23,7 +23,7 @@
  * know the write did not land.
  */
 
-import { STORAGE_KEY_ROOT } from "./storage.js";
+import { AGENTSDK_STORAGE_KEY_ROOT, STORAGE_KEY_ROOT } from "./storage.js";
 
 // ============================================================================
 // Sink interface
@@ -163,39 +163,48 @@ export const AGENT_SERVE_USER_STORE_KEY_PREFIX = "agent-serve";
  * `--agent-store-skills-dir` walk finds them the same way it finds user-store
  * skills. Memory and artifacts stay under {@link STORAGE_KEY_ROOT}.
  */
-export const agentStoreKeys = {
-  artifactRow: (agent: string, id: string): string =>
-    `${STORAGE_KEY_ROOT}/${agent}/artifacts/rows/${encodeURIComponent(id)}.json`,
-  artifactRowPrefix: (agent: string): string =>
-    `${STORAGE_KEY_ROOT}/${agent}/artifacts/rows/`,
-  artifactContent: (agent: string, id: string): string =>
-    `${STORAGE_KEY_ROOT}/${agent}/artifacts/content/${encodeURIComponent(id)}`,
-  skillFile: (
-    skillName: string,
-    relPath: string,
-    skillsPrefix: string = "skills/"
-  ): string => `${skillsPrefix}${skillName}/${relPath}`,
-  skillsPrefix: (): string => "skills/",
-  /** Personal-key cloud agents: namespaced so they cannot collide with the user's own `skills/`. */
-  userSkillsPrefix: (agent: string): string =>
-    `${AGENT_SERVE_USER_STORE_KEY_PREFIX}/${agent}/skills/`,
-  memoryDir: (agent: string): string => `${STORAGE_KEY_ROOT}/${agent}/memory`,
-  memoryJournal: (agent: string): string =>
-    `${STORAGE_KEY_ROOT}/${agent}/memory/journal.jsonl`,
-  memoryJournalRotated: (agent: string, stamp: string): string =>
-    `${STORAGE_KEY_ROOT}/${agent}/memory/journal-${stamp}.jsonl`,
-  // SDK conversation mirror (the runner's SQLite store, exported through the
-  // store APIs): one manifest per SDK agent id plus its content-addressed
-  // checkpoint blobs. See internal/conversation-mirror.ts.
-  conversationManifest: (agent: string, sdkAgentId: string): string =>
-    `${STORAGE_KEY_ROOT}/${agent}/conversations/${encodeURIComponent(sdkAgentId)}/manifest.json`,
-  conversationBlob: (
-    agent: string,
-    sdkAgentId: string,
-    blobId: string
-  ): string =>
-    `${STORAGE_KEY_ROOT}/${agent}/conversations/${encodeURIComponent(sdkAgentId)}/blobs/${encodeURIComponent(blobId)}`,
-} as const;
+function createAgentStoreKeys(root: string) {
+  return {
+    artifactRow: (agent: string, id: string): string =>
+      `${root}/${agent}/artifacts/rows/${encodeURIComponent(id)}.json`,
+    artifactRowPrefix: (agent: string): string =>
+      `${root}/${agent}/artifacts/rows/`,
+    artifactContent: (agent: string, id: string): string =>
+      `${root}/${agent}/artifacts/content/${encodeURIComponent(id)}`,
+    skillFile: (
+      skillName: string,
+      relPath: string,
+      skillsPrefix: string = "skills/"
+    ): string => `${skillsPrefix}${skillName}/${relPath}`,
+    skillsPrefix: (): string => "skills/",
+    /** Personal-key cloud agents: namespaced so they cannot collide with the user's own `skills/`. */
+    userSkillsPrefix: (agent: string): string =>
+      `${AGENT_SERVE_USER_STORE_KEY_PREFIX}/${agent}/skills/`,
+    memoryDir: (agent: string): string => `${root}/${agent}/memory`,
+    memoryJournal: (agent: string): string =>
+      `${root}/${agent}/memory/journal.jsonl`,
+    memoryJournalRotated: (agent: string, stamp: string): string =>
+      `${root}/${agent}/memory/journal-${stamp}.jsonl`,
+    // SDK conversation mirror (the runner's SQLite store, exported through the
+    // store APIs): one manifest per SDK agent id plus its content-addressed
+    // checkpoint blobs. See internal/conversation-mirror.ts.
+    conversationManifest: (agent: string, sdkAgentId: string): string =>
+      `${root}/${agent}/conversations/${encodeURIComponent(sdkAgentId)}/manifest.json`,
+    conversationBlob: (
+      agent: string,
+      sdkAgentId: string,
+      blobId: string
+    ): string =>
+      `${root}/${agent}/conversations/${encodeURIComponent(sdkAgentId)}/blobs/${encodeURIComponent(blobId)}`,
+  } as const;
+}
+
+export type AgentStoreKeys = ReturnType<typeof createAgentStoreKeys>;
+export const agentStoreKeys: AgentStoreKeys =
+  createAgentStoreKeys(STORAGE_KEY_ROOT);
+export const agentSdkAgentStoreKeys: AgentStoreKeys = createAgentStoreKeys(
+  AGENTSDK_STORAGE_KEY_ROOT
+);
 
 /**
  * Deployment store FUSE mount on cloud-runtime VMs. Mirrors

package/src/index.ts

@@ -78,6 +78,12 @@ export {
   stampMailboxContinuation,
   V2EngineError,
 } from "./continuation.js";
+export {
+  cursorPlugin,
+  defineExtension,
+  disableConnection,
+  disableTool,
+} from "./extensions.js";
 export { defineHook } from "./hooks.js";
 export {
   InvalidAsOfError,
@@ -166,15 +172,19 @@ export type {
   StorageDefinition,
   StorageEntry,
   StorageEvalsTable,
+  StorageKeys,
   StoragePolicy,
   StorageRestorePolicy,
 } from "./storage.js";
 export {
+  AGENTSDK_STORAGE_KEY_ROOT,
+  agentSdkStorageKeys,
   defineStorage,
   isDurableSessionRecordKey,
   parseDurableSessionRecord,
   STORAGE_KEY_ROOT,
   storageKeys,
+  storageKeysForArchitecture,
   summarizeDurableSessionRecord,
 } from "./storage.js";
 export { defineTool } from "./tools.js";
@@ -189,6 +199,7 @@ export {
   isToolEffect,
   MAX_RUNNING_TURNS_LIMIT,
   normalizeConnectionEffects,
+  normalizeConnectionTools,
   normalizeCursorAccountServers,
   supportsKvCas,
 } from "./types.js";

package/src/internal/advertise-tools.ts

@@ -27,21 +27,25 @@
  * `defineConnection({ effects })` filters the listing before names are
  * assigned: only tools whose MCP annotations classify as an intended
  * effect are advertised. Unclassified tools are omitted, not guessed.
+ * `defineConnection({ tools: [...] })` keeps only the named tools.
+ * `disallowedTools` drops names. A name filter that matches nothing on
+ * the server fails the turn.
  * Tools whose `annotations.title` is `do-not-call` are dropped as well
  * (vendor host-UI / MCP Apps helpers that still carry `readOnlyHint`).
  */
 
-import type {
-  DiscoveredConnection,
-  DiscoveredTool,
-  HostMcpCallResult,
-  HostMcpToolInfo,
-  JsonSchemaObject,
-  McpToolAnnotations,
-  ResolvedAgent,
-  SessionInfo,
-  ToolDefinition,
-  ToolEffect,
+import {
+  connectionAllowsTool,
+  type DiscoveredConnection,
+  type DiscoveredTool,
+  type HostMcpCallResult,
+  type HostMcpToolInfo,
+  type JsonSchemaObject,
+  type McpToolAnnotations,
+  type ResolvedAgent,
+  type SessionInfo,
+  type ToolDefinition,
+  type ToolEffect,
 } from "../types.js";
 import { brandDefinition } from "./brand.js";
 import type { HostMcpOneOff } from "./mcp-host.js";
@@ -136,7 +140,14 @@ export async function resolveAdvertisedTools(args: {
       try {
         const source = await sourceFor(connection, args.session, args.hostMcp);
         const listed = await source.listTools();
-        return { connection, ok: true, source, listed };
+        return {
+          connection,
+          ok: true,
+          source,
+          listed: listed.filter((info) =>
+            connectionAllowsTool(connection, info.name)
+          ),
+        };
       } catch (error) {
         return { connection, ok: false, error };
       }
@@ -157,6 +168,20 @@ export async function resolveAdvertisedTools(args: {
       );
     }
     const { source, listed } = listing;
+    if (
+      (connection.tools !== undefined ||
+        connection.disallowedTools !== undefined) &&
+      listed.length === 0
+    ) {
+      const error = new Error(
+        `Advertised connection "${connection.name}" tool filter matched no tools on the server.`
+      );
+      if (args.onConnectionError !== undefined) {
+        args.onConnectionError(connection.name, error);
+        continue;
+      }
+      throw error;
+    }
     const intended = listed.filter(
       (info) =>
         !isDoNotCallTool(info.annotations) &&

package/src/internal/as-of.ts

@@ -105,3 +105,166 @@ export function timeArgViolation(
   }
   return undefined;
 }
+
+// Whole-string only: a query that merely contains "now" is not a bound.
+// Duration-only strings (`30m`, `2h`) and last/this plus a non-window word
+// (`last modified`) are not time bounds. Calendar-aligned `now/d` is.
+const TIME_UNIT =
+  "(?:s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days|w|week|weeks|mo|month|months|y|yr|yrs|year|years)";
+const WINDOW_WORD =
+  "(?:second|seconds|minute|minutes|hour|hours|day|days|week|weeks|month|months|year|years|quarter|quarters|weekend|monday|tuesday|wednesday|thursday|friday|saturday|sunday|morning|afternoon|evening|night)";
+const RELATIVE_TIME_EXPRESSION = new RegExp(
+  `^(?:now(?:\\s*[+-]\\s*\\d+\\s*${TIME_UNIT}\\b.*|/[a-zA-Z]+.*)?|[+-]\\d+\\s*${TIME_UNIT}|today|yesterday|tomorrow|(?:last|this)\\s+${WINDOW_WORD})$`,
+  "i"
+);
+
+function forwardTimeReason(
+  value: unknown,
+  asOf: string,
+  frozenMs: number
+): string | undefined {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  if (trimmed === "") {
+    return undefined;
+  }
+  if (RELATIVE_TIME_EXPRESSION.test(trimmed)) {
+    return (
+      `Argument ${JSON.stringify(value)} is a relative time expression, ` +
+      `which reads against the real present. This session reads the world ` +
+      `as of ${asOf}; supply an absolute ISO-8601 instant with a timezone ` +
+      `at or before that instant and retry.`
+    );
+  }
+  const instant = parseInstant(trimmed);
+  if (instant !== undefined && instant.getTime() > frozenMs) {
+    return (
+      `Argument ${JSON.stringify(value)} is later than the instant this ` +
+      `session reads the world as of (${asOf}). Supply a bound at or before ` +
+      `that instant and retry.`
+    );
+  }
+  return undefined;
+}
+
+/** Relative expressions or instants after `asOf`. Numeric epochs need `timeArgs`. */
+export function forwardTimeArgument(
+  input: unknown,
+  asOf: string
+): string | undefined {
+  const frozenMs = new Date(asOf).getTime();
+  const seen = new Set<unknown>();
+  const walk = (value: unknown, depth: number): string | undefined => {
+    if (depth > 8) {
+      return undefined;
+    }
+    const reason = forwardTimeReason(value, asOf, frozenMs);
+    if (reason !== undefined) {
+      return reason;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const found = walk(item, depth + 1);
+        if (found !== undefined) {
+          return found;
+        }
+      }
+      return undefined;
+    }
+    if (typeof value === "object" && value !== null) {
+      if (seen.has(value)) {
+        return undefined;
+      }
+      seen.add(value);
+      for (const item of Object.values(value as Record<string, unknown>)) {
+        const found = walk(item, depth + 1);
+        if (found !== undefined) {
+          return found;
+        }
+      }
+    }
+    return undefined;
+  };
+  return walk(input, 0);
+}
+
+/**
+ * Property names that carry a query's time window when a vendor schema
+ * declares them. Deliberately narrower than the embedded-filter key list:
+ * these must be safe to *require*, so only unambiguous window names — never
+ * `timestamp`/`date`, which name data fields more often than bounds.
+ */
+const TIME_WINDOW_KEYS = new Set([
+  "from",
+  "to",
+  "since",
+  "until",
+  "start",
+  "end",
+  "start_time",
+  "end_time",
+  "starttime",
+  "endtime",
+]);
+
+/**
+ * The string-typed time-window properties a tool's input schema declares.
+ * String-typed only: a numeric `from` is a pagination offset more often than
+ * an instant, and requiring an ISO value there would break the call.
+ */
+export function schemaTimeWindowKeys(
+  inputSchema: { properties?: Record<string, unknown> } | undefined
+): string[] {
+  const properties = inputSchema?.properties;
+  if (properties === undefined) {
+    return [];
+  }
+  const keys: string[] = [];
+  for (const [name, spec] of Object.entries(properties)) {
+    if (!TIME_WINDOW_KEYS.has(name.toLowerCase())) {
+      continue;
+    }
+    const type =
+      typeof spec === "object" && spec !== null
+        ? (spec as { type?: unknown }).type
+        : undefined;
+    const types = Array.isArray(type) ? type : [type];
+    if (types.includes("string")) {
+      keys.push(name);
+    }
+  }
+  return keys;
+}
+
+/**
+ * An omitted time window on a vendor tool is not "no window" — the vendor
+ * fills it with a live default (Datadog: `now-1h`..`now`), which the walker
+ * cannot see because the value is never present. In a frozen session a call
+ * that omits a schema-declared window key is refused so the model supplies
+ * the bound explicitly, where {@link forwardTimeArgument} then checks it.
+ */
+export function missingTimeWindow(
+  input: unknown,
+  windowKeys: readonly string[],
+  asOf: string
+): string | undefined {
+  if (windowKeys.length === 0) {
+    return undefined;
+  }
+  const record =
+    typeof input === "object" && input !== null
+      ? (input as Record<string, unknown>)
+      : {};
+  const missing = windowKeys.filter((key) => record[key] === undefined);
+  if (missing.length === 0) {
+    return undefined;
+  }
+  return (
+    `This tool fills omitted time bounds (${missing.join(", ")}) with a ` +
+    `live default window, which reads the real present. This session reads ` +
+    `the world as of ${asOf}; supply each bound explicitly as an absolute ` +
+    `ISO-8601 instant with a timezone at or before that instant and retry.`
+  );
+}

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;