@cursor/july 0.1.5 → 0.1.7

package/src/internal/cli-deploy.ts

@@ -675,7 +675,7 @@ async function deployOne(
       `  kind:        ${detail.deploymentKind}\n` +
       `  alias:       ${aliasUrl}\n` +
       `  playground:  ${aliasUrl}/playground (sign in with the alias token)\n` +
-      `               or: ${CLI} playground --prod --slug ${slug} --team ${ctx.teamId}\n`
+      `               open: ${CLI} playground --prod --slug ${slug} --team ${ctx.teamId}\n`
   );
   return 0;
 }

package/src/internal/discovery.ts

@@ -1611,8 +1611,8 @@ export function projectInfo(project: AgentProject): AgentProjectInfo {
             maxPlaygroundSessions: resolveABMaxPlaygroundSessions(
               project.abConfig?.maxPlaygroundSessions
             ),
-            durableSamples: project.abConfig?.persistSamples !== undefined,
-            durableSnapshots: project.abConfig?.persistSnapshots !== undefined,
+            durableSamples: project.storage?.abs !== undefined,
+            durableSnapshots: project.storage?.abs?.putSnapshot !== undefined,
           },
         }),
     storage:

package/src/internal/eval-run-store.ts

@@ -1,8 +1,9 @@
 /**
  * Store for playground-triggered eval batches.
  *
- * Default: process memory only, capped by `maxPlaygroundRuns` (see `defineEvalConfig`).
- * Optional durable `persistRuns` from `evals/evals.config.ts` survives restart.
+ * Default: process memory only, capped by `maxPlaygroundRuns` (see
+ * `defineEvalConfig`). When `agent/storage.ts` (`defineStorage`) declares an
+ * `evals` table, runs are mirrored there and survive restart.
  * Runs against the live mount's loopback URL so case sessions appear in
  * the playground session list.
  */
@@ -11,7 +12,6 @@ import { randomUUID } from "node:crypto";
 import {
   type EvalCaseSnapshot,
   type EvalConfigFile,
-  type EvalRunPersistence,
   type EvalRunSnapshot,
   resolveEvalMaxPlaygroundRuns,
 } from "../evals.js";
@@ -30,18 +30,32 @@ export type {
   EvalRunSnapshot,
 } from "../evals.js";
 
+/**
+ * Durable mirror for playground eval batches — the `StorageCoordinator`
+ * adapter over the `defineStorage` `evals` table. Writes are
+ * fire-and-forget (the coordinator serializes and isolates failures);
+ * `list` is the serve-start hydrate read.
+ */
+export interface EvalRunStorage {
+  save(run: EvalRunSnapshot): void;
+  delete(runId: string): void;
+  list(): Promise<EvalRunSnapshot[]>;
+}
+
 export interface StartEvalRunInput {
   filterIds?: string[];
   tags?: string[];
   bearerToken?: string;
   verbose?: boolean;
+  /** Per-case timeout override (same semantics as CLI `--timeout-ms`). */
+  timeoutMs?: number;
 }
 
 export type EvalListConfig = {
   maxConcurrency?: number;
   timeoutMs?: number;
   maxPlaygroundRuns: number;
-  /** True when `evals.config.ts` set `persistRuns`. */
+  /** True when `agent/storage.ts` declares an `evals` table. */
   durableRuns: boolean;
 };
 
@@ -55,28 +69,16 @@ export class EvalRunStore {
   private activeRunId: string | undefined;
   private hydratePromise: Promise<void> | undefined;
   private hydrated = false;
-  /** Per-run persist chain so intermediate saves cannot overwrite a later final write. */
-  private readonly persistChains = new Map<string, Promise<void>>();
   /** Filled after listen — e.g. `http://127.0.0.1:3000/weather-agent`. */
   loopbackUrl: string | undefined;
 
   constructor(
     private readonly projectRoot: string,
     private readonly logger: (line: string) => void,
-    /**
-     * Project-wide sink from `agent/storage.ts` (`defineStorage`),
-     * used when `evals.config.ts` sets no `persistRuns` of its own.
-     */
-    private readonly fallbackPersistence?: EvalRunPersistence
+    /** `defineStorage` evals-table adapter; undefined ⇒ memory only. */
+    private readonly storage?: EvalRunStorage | undefined
   ) {}
 
-  /** `evals.config.ts` `persistRuns` wins; `defineStorage` is fallback. */
-  private resolvePersist(
-    config: Partial<EvalConfigFile>
-  ): EvalRunPersistence | undefined {
-    return config.persistRuns ?? this.fallbackPersistence;
-  }
-
   async list(): Promise<{
     evals: Array<{
       id: string;
@@ -97,10 +99,7 @@ export class EvalRunStore {
           : { description: e.definition.description }),
         ...(e.definition.tags === undefined ? {} : { tags: e.definition.tags }),
       })),
-      config: snapshotListConfig(
-        config,
-        this.resolvePersist(config) !== undefined
-      ),
+      config: snapshotListConfig(config, this.storage !== undefined),
     };
   }
 
@@ -175,15 +174,12 @@ export class EvalRunStore {
         done: 0,
       },
       cases,
-      config: snapshotRunConfig(
-        config,
-        this.resolvePersist(config) !== undefined
-      ),
+      config: snapshotRunConfig(config, this.storage !== undefined),
     };
     this.runs.set(runId, snapshot);
     this.activeRunId = runId;
-    await this.pruneOldRuns(config);
-    await this.enqueuePersist(snapshot, this.resolvePersist(config));
+    this.pruneOldRuns(config);
+    this.persist(snapshot);
     this.logger(
       `[agentkit] eval run ${runId}: starting ${cases.length} case(s)`
     );
@@ -196,6 +192,7 @@ export class EvalRunStore {
         ? {}
         : { bearerToken: input.bearerToken }),
       ...(input.verbose === undefined ? {} : { verbose: input.verbose }),
+      ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
     });
 
     return snapshot;
@@ -208,39 +205,28 @@ export class EvalRunStore {
   }
 
   /**
-   * Hydrate playground eval history from durable persistence
-   * (`evals.config.ts` `persistRuns`, else the `defineStorage`
-   * fallback). Called eagerly from the serve startup restore step —
-   * alongside session restore — and lazily as a safety net by every read.
-   * Idempotent; concurrent callers share one pass.
+   * Hydrate playground eval history from the `defineStorage` evals table.
+   * Called eagerly from the serve startup restore step — alongside session
+   * restore — and lazily as a safety net by every read. Idempotent;
+   * concurrent callers share one pass.
    */
   async hydrate(): Promise<void> {
     if (this.hydrated) {
       return;
     }
     if (this.hydratePromise === undefined) {
-      this.hydratePromise = this.hydrateFromPersistence();
+      this.hydratePromise = this.hydrateFromStorage();
     }
     await this.hydratePromise;
   }
 
-  private async hydrateFromPersistence(): Promise<void> {
+  private async hydrateFromStorage(): Promise<void> {
     try {
-      const { config } = await discoverEvals(this.projectRoot);
-      const persist = this.resolvePersist(config);
-      if (persist === undefined) {
+      if (this.storage === undefined) {
         this.hydrated = true;
         return;
       }
-      const loaded = await persist.load({ projectRoot: this.projectRoot });
-      if (!Array.isArray(loaded)) {
-        this.logger(
-          "[agentkit] eval persistRuns.load() did not return an array; ignoring"
-        );
-        this.hydrated = true;
-        return;
-      }
-      const repaired: EvalRunSnapshot[] = [];
+      const loaded = await this.storage.list();
       for (const run of loaded) {
         if (
           run === null ||
@@ -253,16 +239,26 @@ export class EvalRunStore {
         // Incomplete batches from a killed process should not block a new run.
         if (run.status === "running") {
           markInterruptedRun(run);
-          repaired.push(run);
+          this.persist(run);
         }
         this.runs.set(run.runId, run);
       }
-      for (const run of repaired) {
-        await this.enqueuePersist(run, persist);
+      // Prune with the defaults even when eval discovery fails — loaded
+      // history must not stay unpruned for the process lifetime just
+      // because an eval file has a syntax error at boot.
+      let config: Partial<EvalConfigFile> = {};
+      try {
+        config = (await discoverEvals(this.projectRoot)).config;
+      } catch (error) {
+        this.logger(
+          `[agentkit] eval discovery failed during hydrate (pruning with defaults): ${
+            error instanceof Error ? error.message : String(error)
+          }`
+        );
       }
-      await this.pruneOldRuns(config);
+      this.pruneOldRuns(config);
       this.logger(
-        `[agentkit] hydrated ${this.runs.size} playground eval run(s) from persistRuns`
+        `[agentkit] hydrated ${this.runs.size} playground eval run(s) from storage`
       );
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -274,7 +270,7 @@ export class EvalRunStore {
     }
   }
 
-  private async pruneOldRuns(config: Partial<EvalConfigFile>): Promise<void> {
+  private pruneOldRuns(config: Partial<EvalConfigFile>): void {
     const limit = resolveEvalMaxPlaygroundRuns(config.maxPlaygroundRuns);
     const ordered = this.sortedRuns();
     if (ordered.length <= limit) {
@@ -285,58 +281,34 @@ export class EvalRunStore {
         continue;
       }
       this.runs.delete(stale.runId);
-      await this.persistDelete(stale.runId, this.resolvePersist(config));
+      this.storage?.delete(stale.runId);
     }
   }
 
-  /**
-   * Queue a durable save for `run`. Snapshots are cloned at enqueue time and
-   * writes for the same runId run strictly in order so an intermediate
-   * fire-and-forget save cannot finish after (and overwrite) a later final save.
-   */
-  private enqueuePersist(
-    run: EvalRunSnapshot,
-    persist: EvalRunPersistence | undefined
-  ): Promise<void> {
-    if (persist === undefined) {
-      return Promise.resolve();
-    }
-    const snapshot = structuredClone(run);
-    const prev = this.persistChains.get(run.runId) ?? Promise.resolve();
-    const next = prev
-      .catch(() => undefined)
-      .then(() => this.persistSave(snapshot, persist));
-    this.persistChains.set(run.runId, next);
-    return next;
+  /** Mirror the run onto durable storage (coordinator clones + serializes). */
+  private persist(run: EvalRunSnapshot): void {
+    this.storage?.save(run);
   }
 
-  private async persistSave(
-    run: EvalRunSnapshot,
-    persist: EvalRunPersistence
-  ): Promise<void> {
-    try {
-      await persist.save(run, { projectRoot: this.projectRoot });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger(
-        `[agentkit] persistRuns.save(${run.runId}) failed: ${message}`
-      );
-    }
-  }
-
-  private async persistDelete(
-    runId: string,
-    persist: EvalRunPersistence | undefined
-  ): Promise<void> {
-    if (persist === undefined) {
+  /**
+   * Serve is draining: durably mark any in-flight batch as interrupted
+   * while the storage queue can still deliver. Late `execute` writes are
+   * dropped by the closed coordinator, so without this a batch that was
+   * running at shutdown would look "running" (or silently lose its final
+   * completion write) until the next hydrate repairs it.
+   */
+  close(): void {
+    const activeRunId = this.activeRunId;
+    if (activeRunId === undefined) {
       return;
     }
-    try {
-      await persist.delete(runId, { projectRoot: this.projectRoot });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.logger(`[agentkit] persistRuns.delete(${runId}) failed: ${message}`);
+    const run = this.runs.get(activeRunId);
+    if (run === undefined || run.status !== "running") {
+      return;
     }
+    markInterruptedRun(run);
+    this.persist(run);
+    this.activeRunId = undefined;
   }
 
   private async execute(
@@ -347,6 +319,7 @@ export class EvalRunStore {
       config: Partial<EvalConfigFile>;
       bearerToken?: string;
       verbose?: boolean;
+      timeoutMs?: number;
     }
   ): Promise<void> {
     if (this.runs.get(runId) === undefined) {
@@ -361,6 +334,7 @@ export class EvalRunStore {
           ? {}
           : { bearerToken: opts.bearerToken }),
         ...(opts.verbose === undefined ? {} : { verbose: opts.verbose }),
+        ...(opts.timeoutMs === undefined ? {} : { timeoutMs: opts.timeoutMs }),
         onCaseStart: (id) => {
           const run = this.runs.get(runId);
           if (run === undefined) {
@@ -408,7 +382,7 @@ export class EvalRunStore {
           this.applyCaseResult(runId, result);
           const run = this.runs.get(runId);
           if (run !== undefined) {
-            void this.enqueuePersist(run, this.resolvePersist(opts.config));
+            this.persist(run);
           }
         },
       });
@@ -418,7 +392,7 @@ export class EvalRunStore {
       }
       run.status = "completed";
       run.finishedAt = new Date().toISOString();
-      await this.enqueuePersist(run, this.resolvePersist(opts.config));
+      this.persist(run);
       this.logger(
         `[agentkit] eval run ${runId}: done — ${run.summary.passed} passed, ${run.summary.failed} failed`
       );
@@ -430,7 +404,7 @@ export class EvalRunStore {
       run.status = "failed";
       run.finishedAt = new Date().toISOString();
       run.error = error instanceof Error ? error.message : String(error);
-      await this.enqueuePersist(run, this.resolvePersist(opts.config));
+      this.persist(run);
       this.logger(`[agentkit] eval run ${runId}: failed — ${run.error}`);
     } finally {
       if (this.activeRunId === runId) {
@@ -489,6 +463,23 @@ function markInterruptedRun(run: EvalRunSnapshot): void {
       c.error = c.error ?? INTERRUPTED_CASE_ERROR;
     }
   }
+  // Reconcile the summary with the repaired case rows so a persisted
+  // interrupted batch never claims pre-interruption pass counts.
+  let passed = 0;
+  let failed = 0;
+  for (const c of run.cases) {
+    if (c.ok === true) {
+      passed += 1;
+    } else {
+      failed += 1;
+    }
+  }
+  run.summary = {
+    passed,
+    failed,
+    total: run.cases.length,
+    done: run.cases.length,
+  };
 }
 
 function snapshotListConfig(