@cursor/july 0.1.47 → 0.1.49

package/src/internal/cli-deploy.ts

@@ -1,5 +1,5 @@
 /**
- * `agent-sdk deploy | deployments | deployment | stop | rotate-token |
+ * `agent-sdk deploy | deployments | deployment | stop | delete | rotate-token |
  * rotate-pod-credential | secrets set|list|unset` — Heroku-style deploys
  * onto Cursor's managed agent-serve hosting.
  *
@@ -24,6 +24,7 @@ import {
 import { authorizeCursorAccountConnectors } from "./cursor-account-mcp-auth.js";
 import {
   AgentServeDeployClient,
+  type DeleteAccepted,
   type DeployAccepted,
   DeployApiError,
   type Deployment,
@@ -1117,6 +1118,54 @@ export async function cmdStop(
   return 0;
 }
 
+// ============================================================================
+// delete <slug>
+// ============================================================================
+
+export async function cmdDelete(
+  slug: string | undefined,
+  options: DeployCliOptions
+): Promise<number> {
+  if (slug === undefined || slug === "") {
+    (options.err ?? ((t: string) => void process.stderr.write(t)))(
+      `Usage: ${CLI} delete <slug> [--team <id>] [--json] [--no-wait]\n`
+    );
+    return 1;
+  }
+  const ctx = await prepare(options);
+  if (typeof ctx === "number") {
+    return ctx;
+  }
+  let accepted: DeleteAccepted;
+  try {
+    accepted = await ctx.client.deleteDeployment({
+      teamId: ctx.teamId,
+      slug,
+    });
+  } catch (error) {
+    return renderApiError(error, ctx.err);
+  }
+  if (ctx.noWait) {
+    if (ctx.json) {
+      ctx.out(`${JSON.stringify(accepted, null, 2)}\n`);
+    } else {
+      ctx.out(`Delete accepted for ${slug} (status: ${accepted.status}).\n`);
+    }
+    return 0;
+  }
+  try {
+    await pollUntilGone(ctx, slug);
+  } catch (error) {
+    return renderApiError(error, ctx.err);
+  }
+  if (ctx.json) {
+    ctx.out(`${JSON.stringify({ slug, status: "deleted" }, null, 2)}\n`);
+  } else {
+    ctx.out(`Deleted ${slug} (team ${ctx.teamId}).\n`);
+  }
+  return 0;
+}
+
 // ============================================================================
 // rotate-token <slug>
 // ============================================================================
@@ -1526,6 +1575,59 @@ async function pollUntil(
   }
 }
 
+/**
+ * Wait until GET 404s (the delete reconciler purged the record). Treats
+ * other errors as failures. Throws DeployApiError on timeout.
+ */
+async function pollUntilGone(
+  ctx: DeployCliContext,
+  slug: string
+): Promise<void> {
+  const startedAt = Date.now();
+  const tty = process.stderr.isTTY === true;
+  let sawProgress = false;
+  const report = (label: string): void => {
+    if (ctx.json) {
+      return;
+    }
+    const elapsed = Math.round((Date.now() - startedAt) / 1000);
+    if (tty) {
+      ctx.err(`\r\x1b[2K${slug}: ${label} (${elapsed}s)`);
+      sawProgress = true;
+    }
+  };
+  const finishProgressLine = (): void => {
+    if (tty && sawProgress) {
+      ctx.err("\n");
+    }
+  };
+
+  for (;;) {
+    try {
+      const detail = await ctx.client.getDeployment({
+        teamId: ctx.teamId,
+        slug,
+      });
+      report(deployProgressLabel(detail));
+    } catch (error: unknown) {
+      if (error instanceof DeployApiError && error.status === 404) {
+        finishProgressLine();
+        return;
+      }
+      finishProgressLine();
+      throw error;
+    }
+    if (Date.now() - startedAt >= ctx.timeoutMs) {
+      finishProgressLine();
+      throw new DeployApiError(
+        `Timed out after ${Math.round(ctx.timeoutMs / 1000)}s waiting for ${slug} to disappear. It may still be deleting — check \`${CLI} deployment ${slug} --team ${ctx.teamId}\`.`,
+        0
+      );
+    }
+    await sleep(ctx.pollIntervalMs);
+  }
+}
+
 function aliasTokenBlock(aliasToken: string): string {
   return (
     `\n  Alias token (shown ONCE — save it now, it cannot be retrieved again):\n\n` +

package/src/internal/cli-slack.ts

@@ -1126,11 +1126,6 @@ function renderCreateProvisionError(
         `${error.message}\nA concurrent \`${CLI} slack create\` for this agent won the race; re-run create to pick up that app.\n`
       );
       return 1;
-    case "app_cap_reached":
-      err(
-        `${error.message}\nDelete unused apps with \`${CLI} slack destroy\`, then re-run create.\n`
-      );
-      return 1;
     case "ratelimited":
       err(`${error.message}\nRe-run \`${CLI} slack create\` after the wait.\n`);
       return 1;

package/src/internal/deploy-client.ts

@@ -25,7 +25,8 @@ export type DeploymentStatus =
   | "degraded"
   | "failed"
   | "stopping"
-  | "stopped";
+  | "stopped"
+  | "deleting";
 
 /** Customer-safe deploy progress (no hosting phase / infra names). */
 export type DeploymentProgress =
@@ -39,6 +40,7 @@ export type DeploymentProgress =
   | "failed"
   | "stopping"
   | "stopped"
+  | "deleting"
   | "degraded";
 
 export const TERMINAL_DEPLOY_STATUSES: ReadonlySet<DeploymentStatus> = new Set([
@@ -211,6 +213,8 @@ export interface StopAccepted {
   status: string;
 }
 
+export type DeleteAccepted = StopAccepted;
+
 /** One secret's metadata from the list endpoint — names only, never values. */
 export interface SecretInfo {
   name: string;
@@ -276,6 +280,7 @@ const deploymentSchema = z.object({
     "failed",
     "stopping",
     "stopped",
+    "deleting",
   ]),
   progress: z
     .enum([
@@ -289,6 +294,7 @@ const deploymentSchema = z.object({
       "failed",
       "stopping",
       "stopped",
+      "deleting",
       "degraded",
     ])
     .optional(),
@@ -495,6 +501,18 @@ export class AgentServeDeployClient {
     return stopAcceptedSchema.parse(raw);
   }
 
+  async deleteDeployment(args: {
+    teamId: number;
+    slug: string;
+  }): Promise<DeleteAccepted> {
+    const raw = await this.request({
+      method: "DELETE",
+      path: `/internal/agent-serve/deployments/${encodeURIComponent(args.slug)}?teamId=${args.teamId}`,
+      context: { verb: "delete", slug: args.slug },
+    });
+    return stopAcceptedSchema.parse(raw);
+  }
+
   /** Returns the new alias token exactly once; the old one dies now. */
   async rotateAliasToken(args: {
     teamId: number;

package/src/internal/discovery.ts

@@ -16,7 +16,6 @@ import {
   relative,
   resolve,
 } from "node:path";
-import { pathToFileURL } from "node:url";
 import { type ABConfigFile, resolveABMaxPlaygroundSessions } from "../ab.js";
 import { resolveArtifactsMax } from "../artifacts.js";
 import { httpChannel } from "../channels.js";
@@ -61,7 +60,10 @@ import {
   type ToolDefinition,
   toPublicCloudInfo,
 } from "../types.js";
-import { registerAuthoredModuleLoaders } from "./authored-loaders.js";
+import {
+  importAuthoredModule,
+  registerAuthoredModuleLoaders,
+} from "./authored-loaders.js";
 import { normalizePositiveInt } from "./bounded-int.js";
 import { getDefinitionKind } from "./brand.js";
 import {
@@ -94,15 +96,6 @@ export interface LoadAgentProjectOptions {
 
 type ImportModule = (absolutePath: string) => Promise<Record<string, unknown>>;
 
-async function defaultImportModule(
-  absolutePath: string
-): Promise<Record<string, unknown>> {
-  return (await import(pathToFileURL(absolutePath).href)) as Record<
-    string,
-    unknown
-  >;
-}
-
 interface DiscoveryContext {
   rootDir: string;
   diagnostics: Diagnostic[];
@@ -282,7 +275,7 @@ export async function loadAgentProject(
   const ctx: DiscoveryContext = {
     rootDir,
     diagnostics,
-    importModule: options.importModule ?? defaultImportModule,
+    importModule: options.importModule ?? importAuthoredModule,
   };
 
   const name = (await readPackageName(rootDir)) ?? basename(rootDir);

package/src/internal/eval-runner.ts

@@ -11,7 +11,6 @@
 import type { Dirent } from "node:fs";
 import { readdir } from "node:fs/promises";
 import { join, relative, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
 import type {
   EvalAssertionHandle,
   EvalAssertions,
@@ -62,6 +61,7 @@ import {
   normalizeEvalMaxConcurrency,
 } from "../evals.js";
 import type { ModelSetting, SessionEvent } from "../types.js";
+import { importAuthoredModule } from "./authored-loaders.js";
 import { isDefinitionOfKind } from "./brand.js";
 import {
   callJudgeModel,
@@ -131,15 +131,6 @@ export interface RunEvalsOptions extends EvalSelectionOptions {
   signal?: AbortSignal;
 }
 
-async function defaultImport(
-  absolutePath: string
-): Promise<Record<string, unknown>> {
-  return (await import(pathToFileURL(absolutePath).href)) as Record<
-    string,
-    unknown
-  >;
-}
-
 async function listEvalFiles(dir: string): Promise<string[]> {
   const out: string[] = [];
   async function walk(current: string): Promise<void> {
@@ -172,7 +163,7 @@ export async function discoverEvals(
   projectRoot: string,
   importModule: (
     absolutePath: string
-  ) => Promise<Record<string, unknown>> = defaultImport
+  ) => Promise<Record<string, unknown>> = importAuthoredModule
 ): Promise<{
   evals: DiscoveredEval[];
   config: Partial<EvalConfigFile>;
@@ -291,7 +282,7 @@ export async function runDiscoveredEvals(
     selected = options.discovered.evals;
     config = options.discovered.config;
   } else {
-    const importModule = options.importModule ?? defaultImport;
+    const importModule = options.importModule ?? importAuthoredModule;
     const discovered = await discoverEvals(options.projectRoot, importModule);
     config = discovered.config;
     selected = filterDiscoveredEvals(discovered.evals, {

package/src/internal/event-log.ts

@@ -59,6 +59,17 @@ export class SessionEventLog {
     return this.events.length;
   }
 
+  /**
+   * In-process residency vs recorded length. Today those are the same
+   * (`events` is the cache). A later change can drop the cache and keep
+   * `eventsTotal` as the durable count while `eventsRetained` shrinks to
+   * the unflushed tail.
+   */
+  memoryStats(): { eventsRetained: number; eventsTotal: number } {
+    const n = this.events.length;
+    return { eventsRetained: n, eventsTotal: n };
+  }
+
   /**
    * Assign the next index, record the event, and fan out to live
    * subscribers. Ordering is synchronous; file persistence is chained in
@@ -154,9 +165,16 @@ export class SessionEventLog {
   }
 }
 
+export type EventLogMemoryStats = {
+  residentSessions: number;
+  eventsRetained: number;
+  eventsTotal: number;
+};
+
 /** Lazily opens one {@link SessionEventLog} per session. */
 export class EventLogStore {
   private readonly logs = new Map<string, Promise<SessionEventLog>>();
+  private readonly opened = new Map<string, SessionEventLog>();
 
   constructor(
     private readonly eventFilePathFor: (sessionId: string) => string,
@@ -170,18 +188,38 @@ export class EventLogStore {
     let log = this.logs.get(sessionId);
     if (log === undefined) {
       const filePath = this.eventFilePathFor(sessionId);
-      log = mkdir(dirname(filePath), { recursive: true }).then(() =>
-        SessionEventLog.open({
-          sessionId,
-          filePath,
-          onPersistError: (error) => this.onPersistError(sessionId, error),
-        })
-      );
+      log = mkdir(dirname(filePath), { recursive: true })
+        .then(() =>
+          SessionEventLog.open({
+            sessionId,
+            filePath,
+            onPersistError: (error) => this.onPersistError(sessionId, error),
+          })
+        )
+        .then((opened) => {
+          this.opened.set(sessionId, opened);
+          return opened;
+        });
       this.logs.set(sessionId, log);
     }
     return log;
   }
 
+  memoryStats(): EventLogMemoryStats {
+    let eventsRetained = 0;
+    let eventsTotal = 0;
+    for (const log of this.opened.values()) {
+      const stats = log.memoryStats();
+      eventsRetained += stats.eventsRetained;
+      eventsTotal += stats.eventsTotal;
+    }
+    return {
+      residentSessions: this.logs.size,
+      eventsRetained,
+      eventsTotal,
+    };
+  }
+
   async flushAll(): Promise<void> {
     await Promise.all(
       [...this.logs.values()].map((logPromise) =>

package/src/internal/logs-client.ts

@@ -43,6 +43,7 @@ export type LogsProgress =
   | "failed"
   | "stopping"
   | "stopped"
+  | "deleting"
   | "degraded";
 
 const PROGRESS_MESSAGES: Readonly<Record<LogsProgress, string>> = {
@@ -56,6 +57,7 @@ const PROGRESS_MESSAGES: Readonly<Record<LogsProgress, string>> = {
   failed: "Deploy failed",
   stopping: "Stopping deployment…",
   stopped: "Deployment stopped",
+  deleting: "Deleting deployment…",
   degraded: "Deployment degraded",
 };
 
@@ -385,6 +387,8 @@ function resolveProgress(detail: DeploymentDetail): LogsProgress {
       return "stopping";
     case "stopped":
       return "stopped";
+    case "deleting":
+      return "deleting";
     default:
       return "queued";
   }