@cursor/july 0.1.5 → 0.1.7

package/dist/internal/cli-ax.js

@@ -25,12 +25,13 @@ import { resolveDeployAuth } from "./cli-deploy.js";
 import { resolveApiKey } from "./cursor/credentials.js";
 import { CLI_COMMAND_NAME } from "./distribution.js";
 import { discoverEvals, filterDiscoveredEvals, runDiscoveredEvals, } from "./eval-runner.js";
+import { getRemoteEvalRun, listRemoteEvalRuns, listRemoteEvals, RemoteEvalError, runRemoteEvals, startRemoteEvalRun, } from "./evals-client.js";
 import { formatInitNextSteps, formatInitScaffoldSummary, initNextCommands, initProject, installScaffoldDependencies, printInitGuide, } from "./init-project.js";
 import { offerInstallCursorSkills } from "./install-cursor-skills.js";
 import { runLogsTail, sanitizeCustomerError } from "./logs-client.js";
 import { openBrowser } from "./open-browser.js";
 import { startPlaygroundProxy } from "./playground-proxy.js";
-import { resolveProdSlug, resolveProdTarget } from "./resolve-prod-target.js";
+import { ProdTargetError, resolveProdAliasPlaygroundUrl, resolveProdSlug, resolveProdTarget, } from "./resolve-prod-target.js";
 import { runSession } from "./run-client.js";
 import { fetchSessionEvents, formatSessionsTable, listSessions, resolvePreviousSessionId, } from "./sessions-client.js";
 import { createStreamProgress } from "./stream-progress.js";
@@ -475,82 +476,451 @@ export function cmdTrajectory(options) {
         return trajectory.ok ? 0 : 1;
     });
 }
+/**
+ * Which surface `eval` should target. Local (ephemeral) is the default;
+ * `--prod` uses the hosted deployment, `--url` a running server.
+ * Exported for tests.
+ */
+export function resolveEvalTargetMode(options) {
+    const flags = [
+        options.prod === true ? "--prod" : undefined,
+        options.url !== undefined ? "--url" : undefined,
+    ].filter((flag) => flag !== undefined);
+    if (flags.length > 1) {
+        return { error: `${flags.join(" and ")} are mutually exclusive` };
+    }
+    if (options.url !== undefined) {
+        return "url";
+    }
+    if (options.prod === true) {
+        return "deployment";
+    }
+    return "local";
+}
+/** Resolve the eval target; prints a CLI-ready error and returns an exit code on failure. */
+function resolveEvalTarget(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mode = resolveEvalTargetMode(options);
+        if (typeof mode === "object") {
+            process.stderr.write(`${mode.error}\n`);
+            return 2;
+        }
+        if (mode === "url") {
+            return { agentUrl: options.url.replace(/\/$/, "") };
+        }
+        if (mode === "local") {
+            return startEphemeral(options);
+        }
+        try {
+            const prod = yield resolveProdTarget({
+                dir: options.dir,
+                cwd: options.cwd,
+                slug: options.slug,
+                team: options.team,
+                apiKey: options.apiKey,
+                fetchImpl: options.fetchImpl,
+            });
+            return { agentUrl: prod.agentUrl, headers: prod.headers };
+        }
+        catch (error) {
+            if (error instanceof ProdTargetError && error.notFound) {
+                // Keep the API error text: a 404 can also mean a wrong API host or a
+                // disabled feature gate, and the message distinguishes those from a
+                // genuinely missing deployment.
+                process.stderr.write(`${sanitizeCustomerError(error.message)}\n` +
+                    `  deploy it first:  ${CLI_COMMAND_NAME} deploy --slug ${error.slug}\n` +
+                    `  or omit --prod:   ${CLI_COMMAND_NAME} eval --dir ${options.dir}\n`);
+                return 1;
+            }
+            process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n` +
+                `Pass --prod for the hosted deployment, or omit it to run on an ephemeral local server.\n`);
+            return 1;
+        }
+    });
+}
 export function cmdEval(options) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
         const projectRoot = resolve((_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd(), options.dir);
+        const mode = resolveEvalTargetMode(options);
+        if (typeof mode === "object") {
+            process.stderr.write(`${mode.error}\n`);
+            return 2;
+        }
+        if (options.noWait === true) {
+            if (options.list === true) {
+                process.stderr.write("--no-wait and --list are mutually exclusive\n");
+                return 2;
+            }
+            if (mode === "local") {
+                process.stderr.write("--no-wait requires --prod or --url (not the default local target)\n");
+                return 2;
+            }
+        }
+        const filterIds = options.evalIds === undefined || options.evalIds.length === 0
+            ? undefined
+            : options.evalIds;
+        const tags = options.tags === undefined || options.tags.length === 0
+            ? undefined
+            : options.tags;
         if (options.list) {
-            const { evals } = yield discoverEvals(projectRoot);
-            const listed = filterDiscoveredEvals(evals, {
-                filterIds: options.evalIds,
-                tags: options.tags,
-            });
-            if (options.json) {
-                console.log(JSON.stringify(listed.map((e) => { var _a; return ({
+            // List the same surface a run will execute: local filesystem by default,
+            // GET /v1/dev/evals on --prod / --url.
+            if (mode === "local") {
+                return listLocalEvals(projectRoot, options, filterIds, tags);
+            }
+            const target = yield resolveEvalTarget(options);
+            if (typeof target === "number") {
+                return target;
+            }
+            try {
+                const listed = yield listRemoteEvals({
+                    baseUrl: target.agentUrl,
+                    auth: {
+                        bearerToken: options.bearerToken,
+                        headers: target.headers,
+                    },
+                    fetchImpl: options.fetchImpl,
+                    filterIds,
+                    tags,
+                });
+                return printListedEvals(listed.map((e) => { var _a; return ({
                     id: e.id,
                     fileId: e.fileId,
-                    path: e.path,
-                    description: e.definition.description,
-                    tags: (_a = e.definition.tags) !== null && _a !== void 0 ? _a : [],
-                }); }), null, 2));
+                    description: e.description,
+                    tags: (_a = e.tags) !== null && _a !== void 0 ? _a : [],
+                }); }), options, `No evals on ${target.agentUrl}`);
             }
-            else if (listed.length === 0) {
-                process.stdout.write(`No evals under ${projectRoot}/evals\n`);
+            catch (error) {
+                process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
+                return 1;
             }
-            else {
-                for (const e of listed) {
-                    const tags = e.definition.tags && e.definition.tags.length > 0
-                        ? `  [${e.definition.tags.join(", ")}]`
-                        : "";
-                    const desc = e.definition.description !== undefined
-                        ? ` — ${e.definition.description}`
-                        : "";
-                    process.stdout.write(`${e.id}${tags}${desc}\n`);
+            finally {
+                if (target.close !== undefined) {
+                    yield target.close();
                 }
             }
-            return 0;
         }
-        const target = yield resolveTarget(options);
+        const target = yield resolveEvalTarget(options);
+        if (typeof target === "number") {
+            return target;
+        }
         const stream = shouldStreamProgress(options);
-        const progress = stream ? createStreamProgress() : undefined;
         try {
             if (options.verbose || stream) {
                 process.stderr.write(`eval target: ${target.agentUrl}\n`);
             }
-            const results = yield runDiscoveredEvals({
-                projectRoot,
+            // Default local: ephemeral in-process harness against local eval sources.
+            // --prod / --url: run on the serve process via /v1/dev/evals/runs so the
+            // batch lands in playground history and defineStorage evals (when set).
+            if (mode === "local") {
+                const progress = stream ? createStreamProgress() : undefined;
+                try {
+                    const results = yield runDiscoveredEvals({
+                        projectRoot,
+                        baseUrl: target.agentUrl,
+                        filterIds,
+                        tags,
+                        timeoutMs: options.timeoutMs,
+                        bearerToken: options.bearerToken,
+                        headers: target.headers,
+                        verbose: Boolean(options.verbose) || stream,
+                        onEvent: progress === undefined ? undefined : (e) => progress.onEvent(e),
+                    });
+                    if (results.length === 0) {
+                        process.stderr.write("No matching evals found.\n");
+                        return 2;
+                    }
+                    return printEvalResults(results, options);
+                }
+                finally {
+                    progress === null || progress === void 0 ? void 0 : progress.close();
+                }
+            }
+            try {
+                if (options.noWait === true) {
+                    const started = yield startRemoteEvalRun({
+                        baseUrl: target.agentUrl,
+                        filterIds,
+                        tags,
+                        timeoutMs: options.timeoutMs,
+                        verbose: Boolean(options.verbose),
+                        auth: {
+                            bearerToken: options.bearerToken,
+                            headers: target.headers,
+                        },
+                        fetchImpl: options.fetchImpl,
+                    });
+                    return printEvalAccepted(started, options, target.agentUrl);
+                }
+                const progress = createRemoteEvalProgress(options.verbose === true || stream);
+                const { snapshot, results } = yield runRemoteEvals({
+                    baseUrl: target.agentUrl,
+                    filterIds,
+                    tags,
+                    timeoutMs: options.timeoutMs,
+                    verbose: Boolean(options.verbose) || stream,
+                    bearerToken: options.bearerToken,
+                    headers: target.headers,
+                    fetchImpl: options.fetchImpl,
+                    onSnapshot: progress === undefined ? undefined : progress.onSnapshot,
+                });
+                if (results.length === 0 && snapshot.status !== "failed") {
+                    process.stderr.write("No matching evals found.\n");
+                    return 2;
+                }
+                return printEvalResults(results, options, {
+                    runId: snapshot.runId,
+                    status: snapshot.status,
+                    error: snapshot.error,
+                });
+            }
+            catch (error) {
+                if (error instanceof RemoteEvalError &&
+                    error.code === "no_matching_evals") {
+                    process.stderr.write(`${error.message}\n`);
+                    return 2;
+                }
+                process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
+                return 1;
+            }
+        }
+        finally {
+            if (target.close !== undefined) {
+                yield target.close();
+            }
+        }
+    });
+}
+/**
+ * Flags to re-target the same surface from an `eval --no-wait` hint.
+ * Exported for tests.
+ */
+export function formatEvalStatusFlags(options) {
+    const parts = [];
+    if (options.url !== undefined) {
+        parts.push(`--url ${options.url.replace(/\/$/, "")}`);
+    }
+    else {
+        parts.push("--prod");
+        if (options.slug !== undefined && options.slug !== "") {
+            parts.push(`--slug ${options.slug}`);
+        }
+    }
+    if (options.team !== undefined && options.team !== "") {
+        parts.push(`--team ${options.team}`);
+    }
+    return parts.length === 0 ? "" : ` ${parts.join(" ")}`;
+}
+/** `--no-wait`: print the accepted batch id (and how to poll) then exit. */
+function printEvalAccepted(started, options, agentUrl) {
+    const pollPath = `${agentUrl.replace(/\/$/, "")}/v1/dev/evals/runs/${started.runId}`;
+    const statusFlags = formatEvalStatusFlags(options);
+    if (options.json) {
+        console.log(JSON.stringify({
+            ok: true,
+            accepted: true,
+            runId: started.runId,
+            status: started.status,
+            summary: started.summary,
+            pollUrl: pollPath,
+            durableRuns: started.config.durableRuns === true,
+        }, null, 2));
+    }
+    else {
+        const durable = started.config.durableRuns === true ? " (persisted)" : "";
+        process.stdout.write(`Accepted eval run ${started.runId}${durable} — ${started.summary.total} case(s)\n`);
+        process.stdout.write(`Status: ${CLI_COMMAND_NAME} eval status ${started.runId}${statusFlags}\n`);
+        process.stdout.write(`Poll: ${pollPath}\n`);
+    }
+    return 0;
+}
+/**
+ * `eval status [runId]` — fetch one batch (or list recent) on the deployment /
+ * `--url` target. Exit `0` when the batch is completed with all cases passing,
+ * `1` when failed / any case failed / unknown, `2` for usage errors, `3` when
+ * the batch is still running (for poll loops after `--no-wait`).
+ */
+export function cmdEvalStatus(runId, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const mode = resolveEvalTargetMode(options);
+        if (typeof mode === "object") {
+            process.stderr.write(`${mode.error}\n`);
+            return 2;
+        }
+        if (mode === "local") {
+            process.stderr.write("eval status requires --prod or --url (not the default local target)\n");
+            return 2;
+        }
+        if (options.list === true || options.noWait === true) {
+            process.stderr.write("eval status does not accept --list or --no-wait\n");
+            return 2;
+        }
+        const target = yield resolveEvalTarget(options);
+        if (typeof target === "number") {
+            return target;
+        }
+        const auth = {
+            bearerToken: options.bearerToken,
+            headers: target.headers,
+        };
+        try {
+            if (runId === undefined || runId === "") {
+                const { runs, activeRunId } = yield listRemoteEvalRuns({
+                    baseUrl: target.agentUrl,
+                    auth,
+                    fetchImpl: options.fetchImpl,
+                });
+                if (options.json) {
+                    console.log(JSON.stringify({ runs, activeRunId }, null, 2));
+                }
+                else if (runs.length === 0) {
+                    process.stdout.write("No eval runs on this agent.\n");
+                }
+                else {
+                    if (activeRunId !== undefined) {
+                        process.stdout.write(`active: ${activeRunId}\n`);
+                    }
+                    for (const run of runs) {
+                        process.stdout.write(`${formatEvalRunSummaryLine(run)}\n`);
+                    }
+                }
+                return 0;
+            }
+            const snap = yield getRemoteEvalRun({
                 baseUrl: target.agentUrl,
-                filterIds: options.evalIds === undefined || options.evalIds.length === 0
-                    ? undefined
-                    : options.evalIds,
-                tags: options.tags === undefined || options.tags.length === 0
-                    ? undefined
-                    : options.tags,
-                timeoutMs: options.timeoutMs,
-                bearerToken: options.bearerToken,
-                headers: target.headers,
-                verbose: Boolean(options.verbose) || stream,
-                onEvent: progress === undefined ? undefined : (e) => progress.onEvent(e),
+                runId,
+                auth,
+                fetchImpl: options.fetchImpl,
             });
-            if (results.length === 0) {
-                process.stderr.write("No matching evals found.\n");
-                return 2;
+            if (options.json) {
+                console.log(JSON.stringify(snap, null, 2));
+            }
+            else {
+                process.stdout.write(`${formatEvalRunSummaryLine(snap)}\n`);
+                if (snap.error !== undefined && snap.error !== "") {
+                    process.stdout.write(`error: ${snap.error}\n`);
+                }
+                for (const c of snap.cases) {
+                    const mark = c.status !== "done" ? c.status : c.ok === true ? "PASS" : "FAIL";
+                    const dur = c.durationMs === undefined
+                        ? ""
+                        : ` (${(c.durationMs / 1000).toFixed(1)}s)`;
+                    process.stdout.write(`  ${mark}  ${c.id}${dur}\n`);
+                    if (c.error !== undefined && c.error !== "") {
+                        process.stdout.write(`    error: ${c.error}\n`);
+                    }
+                }
+            }
+            if (snap.status === "running") {
+                return 3;
             }
-            return printEvalResults(results, options);
+            const failed = snap.status === "failed" || snap.cases.some((c) => c.ok !== true);
+            return failed ? 1 : 0;
+        }
+        catch (error) {
+            process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
+            return 1;
         }
         finally {
-            progress === null || progress === void 0 ? void 0 : progress.close();
             if (target.close !== undefined) {
                 yield target.close();
             }
         }
     });
 }
-function printEvalResults(results, options) {
+function formatEvalRunSummaryLine(run) {
+    const { passed, failed, total, done } = run.summary;
+    const durable = run.config.durableRuns === true ? " persisted" : "";
+    return `${run.runId}  ${run.status}  ${done}/${total} done (${passed} passed, ${failed} failed)${durable}`;
+}
+function listLocalEvals(projectRoot, options, filterIds, tags) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { evals } = yield discoverEvals(projectRoot);
+        const listed = filterDiscoveredEvals(evals, { filterIds, tags });
+        return printListedEvals(listed.map((e) => { var _a; return ({
+            id: e.id,
+            fileId: e.fileId,
+            path: e.path,
+            description: e.definition.description,
+            tags: (_a = e.definition.tags) !== null && _a !== void 0 ? _a : [],
+        }); }), options, `No evals under ${projectRoot}/evals`);
+    });
+}
+function printListedEvals(listed, options, emptyMessage) {
+    if (options.json) {
+        console.log(JSON.stringify(listed, null, 2));
+    }
+    else if (listed.length === 0) {
+        process.stdout.write(`${emptyMessage}\n`);
+    }
+    else {
+        for (const e of listed) {
+            const tagSuffix = e.tags.length > 0 ? `  [${e.tags.join(", ")}]` : "";
+            const desc = e.description !== undefined ? ` — ${e.description}` : "";
+            process.stdout.write(`${e.id}${tagSuffix}${desc}\n`);
+        }
+    }
+    return 0;
+}
+/**
+ * Remote batches don't stream turn events to the CLI; print run/case progress
+ * (and case logs once they appear on the snapshot) instead.
+ */
+function createRemoteEvalProgress(enabled) {
+    if (!enabled) {
+        return undefined;
+    }
+    let announced = false;
+    let lastSummaryKey = "";
+    const seenCaseKeys = new Set();
+    return {
+        onSnapshot(snap) {
+            var _a, _b;
+            if (!announced) {
+                announced = true;
+                const durable = snap.config.durableRuns === true ? " (persisted)" : "";
+                process.stderr.write(`eval run: ${snap.runId}${durable}\n`);
+            }
+            const summaryKey = `${snap.status}:${snap.summary.done}:${snap.summary.passed}:${snap.summary.failed}`;
+            if (summaryKey !== lastSummaryKey) {
+                lastSummaryKey = summaryKey;
+                const { done, total, passed, failed } = snap.summary;
+                process.stderr.write(`eval progress: ${done}/${total} done (${passed} passed, ${failed} failed) [${snap.status}]\n`);
+            }
+            for (const c of snap.cases) {
+                if (c.status !== "done") {
+                    continue;
+                }
+                const caseKey = `${c.id}:${c.ok === true ? "pass" : "fail"}:${(_a = c.durationMs) !== null && _a !== void 0 ? _a : 0}`;
+                if (seenCaseKeys.has(caseKey)) {
+                    continue;
+                }
+                seenCaseKeys.add(caseKey);
+                process.stderr.write(`  eval ${c.id}: ${c.ok === true ? "PASS" : "FAIL"}${c.error !== undefined ? ` — ${c.error}` : ""}\n`);
+                for (const line of (_b = c.logs) !== null && _b !== void 0 ? _b : []) {
+                    process.stderr.write(`    ${line}\n`);
+                }
+            }
+        },
+    };
+}
+function printEvalResults(results, options, batch) {
     const passed = results.filter((r) => r.ok).length;
     const failed = results.length - passed;
+    const batchFailed = (batch === null || batch === void 0 ? void 0 : batch.status) === "failed";
+    const ok = failed === 0 && !batchFailed;
+    if ((batch === null || batch === void 0 ? void 0 : batch.error) !== undefined && batch.error !== "" && !options.json) {
+        // Always surface harness-level failures (not only --verbose).
+        process.stderr.write(`eval run error: ${batch.error}\n`);
+    }
     if (options.json) {
-        console.log(JSON.stringify({ ok: failed === 0, passed, failed, results }, null, 2));
+        console.log(JSON.stringify(Object.assign(Object.assign(Object.assign({ ok,
+            passed,
+            failed,
+            results }, ((batch === null || batch === void 0 ? void 0 : batch.runId) === undefined ? {} : { runId: batch.runId })), ((batch === null || batch === void 0 ? void 0 : batch.status) === undefined ? {} : { status: batch.status })), ((batch === null || batch === void 0 ? void 0 : batch.error) === undefined || batch.error === ""
+            ? {}
+            : { error: batch.error })), null, 2));
     }
     else {
         for (const r of results) {
@@ -571,7 +941,7 @@ function printEvalResults(results, options) {
         }
         process.stdout.write(`\n${passed} passed, ${failed} failed, ${results.length} total\n`);
     }
-    return failed === 0 ? 0 : 1;
+    return ok ? 0 : 1;
 }
 /**
  * `logs` — follow deploy progress (`--prod`) then runtime agent logs.
@@ -770,9 +1140,9 @@ export function cmdSession(sessionId, options) {
 /**
  * `playground` — open the web UI against local / `--url` / `--prod`.
  *
- * Hosted engines need short-lived access headers a browser cannot set, so
- * `--prod` (and `--bearer-token`) run a loopback reverse proxy that injects
- * them. Ctrl-C stops the proxy.
+ * `--prod` opens the stable hosted alias playground URL; the SPA collects
+ * the alias token. `--bearer-token` (and other injected headers) still run a
+ * loopback reverse proxy — Ctrl-C stops that proxy.
  */
 export function cmdPlayground(options) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -783,58 +1153,29 @@ export function cmdPlayground(options) {
         const sessionId = options.sessionId !== undefined && options.sessionId.trim() !== ""
             ? options.sessionId.trim()
             : undefined;
-        // Hosted: mint engineAccess and refresh it for the life of the proxy.
+        // Hosted: open the alias playground; SPA owns alias-token sign-in.
         if (options.prod === true) {
-            let initial;
+            let resolved;
             try {
-                initial = yield resolveProdTarget({
+                resolved = yield resolveProdAliasPlaygroundUrl({
                     dir: options.dir,
                     cwd: options.cwd,
                     slug: options.slug,
                     team: options.team,
                     apiKey: options.apiKey,
                     fetchImpl: options.fetchImpl,
+                    sessionId,
                 });
             }
             catch (error) {
                 process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
                 return 1;
             }
-            let proxy;
-            try {
-                proxy = yield startPlaygroundProxy({
-                    upstreamUrl: initial.agentUrl,
-                    headers: initial.headers,
-                    expiresAt: initial.expiresAt,
-                    refreshUpstream: () => __awaiter(this, void 0, void 0, function* () {
-                        var _a;
-                        const next = yield resolveProdTarget({
-                            dir: options.dir,
-                            cwd: options.cwd,
-                            slug: (_a = options.slug) !== null && _a !== void 0 ? _a : initial.slug,
-                            team: options.team,
-                            apiKey: options.apiKey,
-                            fetchImpl: options.fetchImpl,
-                            err: () => { },
-                        });
-                        return {
-                            upstreamUrl: next.agentUrl,
-                            headers: next.headers,
-                            expiresAt: next.expiresAt,
-                        };
-                    }),
-                });
-            }
-            catch (error) {
-                process.stderr.write(`${sanitizeCustomerError(error instanceof Error ? error.message : String(error))}\n`);
-                return 1;
+            process.stdout.write(`${resolved.playgroundUrl}\n`);
+            if (options.print !== true) {
+                openBrowser(resolved.playgroundUrl);
             }
-            return yield runPlaygroundProxySession({
-                proxy,
-                sessionId,
-                print: options.print === true,
-                signal: options.signal,
-            });
+            return 0;
         }
         const target = yield resolveSessionTarget(options);
         if (typeof target === "number") {

package/dist/internal/cli-deploy.js

@@ -464,7 +464,7 @@ function deployOne(ctx, options, target, extras) {
             `  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/dist/internal/discovery.js

@@ -1226,7 +1226,7 @@ function loadSeedFiles(ctx, agentDir) {
 // Info projection
 // ============================================================================
 export function projectInfo(project) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const agent = project.agent;
     const httpRoutes = [
         { method: "POST", path: "/v1/session", url: "/v1/session" },
@@ -1324,8 +1324,8 @@ export function projectInfo(project) {
         : {
             abConfig: {
                 maxPlaygroundSessions: resolveABMaxPlaygroundSessions((_a = project.abConfig) === null || _a === void 0 ? void 0 : _a.maxPlaygroundSessions),
-                durableSamples: ((_b = project.abConfig) === null || _b === void 0 ? void 0 : _b.persistSamples) !== undefined,
-                durableSnapshots: ((_c = project.abConfig) === null || _c === void 0 ? void 0 : _c.persistSnapshots) !== undefined,
+                durableSamples: ((_b = project.storage) === null || _b === void 0 ? void 0 : _b.abs) !== undefined,
+                durableSnapshots: ((_d = (_c = project.storage) === null || _c === void 0 ? void 0 : _c.abs) === null || _d === void 0 ? void 0 : _d.putSnapshot) !== undefined,
             },
         })), { storage: project.storage === undefined
             ? undefined