@reticlehq/server 3.8.2 → 3.10.0

package/dist/language/flows/flow-store-for-session.js

@@ -23,17 +23,21 @@
  * allocates nothing: when no resolver is wired, or it names the root already in use, `deps.flows` is
  * returned unchanged.
  */
+import { dirname } from 'node:path';
 import { FlowStore } from './flows.js';
-import { sessionTarget } from '../../memory/project/session-root.js';
+import { rootForTarget, sessionTarget } from '../../memory/project/session-root.js';
+import { isUnmatchedRoot } from '../../memory/project/dir/reticle-dir.js';
 export function flowsForSession(deps, target) {
-    const resolved = deps.artifactRootFor?.(target.projectId, target.origin);
-    if (resolved === undefined || resolved.root === deps.reticleRoot) {
+    // Through `rootForTarget`, so the root a lease claimed wins here as it does for runs. Without
+    // it a lease from one folder replayed the flows of the folder the daemon was started in.
+    const root = rootForTarget(deps, target);
+    if (root === deps.reticleRoot) {
         return { flows: deps.flows, root: deps.reticleRoot };
     }
     const onWrote = deps.onRunPersisted;
     return {
-        flows: new FlowStore(deps.fs, resolved.root, { now: deps.now }, onWrote === undefined ? {} : { onWrote }),
-        root: resolved.root,
+        flows: new FlowStore(deps.fs, root, { now: deps.now }, onWrote === undefined ? {} : { onWrote }),
+        root,
     };
 }
 /** `flowsForSession` for a session id, with the project id to scope the store by. Same refusals. */
@@ -41,3 +45,45 @@ export function flowsForSessionId(deps, sessionId) {
     const target = sessionTarget(deps, sessionId);
     return { ...flowsForSession(deps, target), projectId: target.projectId };
 }
+/** The {name, steps} of every flow in `store` that `projectId` can see. Unreadable flows are left out. */
+export async function namedFlowsIn(store, projectId) {
+    const flows = [];
+    for (const name of await store.list(projectId)) {
+        const loaded = await store.load(name, projectId);
+        if (loaded.ok) {
+            flows.push({ name: loaded.value.name, steps: loaded.value.steps });
+        }
+    }
+    return flows;
+}
+/**
+ * The saved flows of a session, from the store `flowsForSessionId` resolves, and the project
+ * directory that holds that store.
+ *
+ * `affected` and `change` read flows through here, and `flows` replays from the same store. They
+ * used to build their own store from `sessionRoot`, which skips the root a lease claimed when no
+ * resolver is wired and no session is named. Then `affected` named a flow that `flows` could not
+ * find (#1996). The directory is returned too, so `git diff` runs in the tree the flows belong to.
+ *
+ * `sessionTarget` declines when several projects are connected and none is named, because a caller
+ * that needs no session must still work. These callers answer about ONE project, and that fallback
+ * is the daemon's own, so its flows read as the driven tab's (#1550). Here the refusal stands:
+ * `resolve` names the connected projects and asks for a `sessionId`. It throws nothing for several
+ * tabs of one project, or for no session at all.
+ *
+ * `unmatchedRoot` is set when the project has no folder: the root is an evidence bucket, not a
+ * tree, so there is no `git` to ask and no flows to find.
+ */
+export async function namedFlowsForSession(deps, sessionId) {
+    // Older constructions of ToolDeps carry no session manager, as `sessionRoot` notes.
+    const sessions = deps.sessions;
+    if (sessionId === undefined && 1 < (sessions?.count?.() ?? 0)) {
+        deps.sessions.resolve(undefined);
+    }
+    const { flows: store, root, projectId } = flowsForSessionId(deps, sessionId);
+    return {
+        flows: await namedFlowsIn(store, projectId),
+        projectDir: dirname(root),
+        ...(isUnmatchedRoot(root) ? { unmatchedRoot: root } : {}),
+    };
+}

package/dist/language/flows/flow-tools.js

@@ -11,18 +11,17 @@ import { stillRecording, stillRecordingMessage } from './flow-result.js';
 import { resolveAnnotateTarget } from './annotate-notes/annotate-target.js';
 import { FlowErrorCode, RecordedSaveError, SuiteIsolation, } from '@reticlehq/core';
 import { recordSuiteFlakes } from './suite/suite-flakes.js';
-import { ReticleTool } from '@reticlehq/core';
-import { asNumber, asString } from '@reticlehq/core';
+import { ReticleTool, asNumber, asString } from '@reticlehq/core';
 import { log } from '../../log.js';
 import { cloudFetch, syncFlowToCloud, SyncOutcome } from '../../memory/cloud/cloud-sync.js';
 import { mapWithConcurrency, resolveConcurrency } from './suite/parallel-suite.js';
 import { acquireLeasedSession, suiteFixtureSeed } from '../../surface/tools/lease-tools.js';
 import { homedir } from 'node:os';
-import { withShotRun } from '../../judgement/runs/default-run-id.js';
-import { defaultRunId } from '../../judgement/runs/default-run-id.js';
+import { withShotRun, defaultRunId } from '../../judgement/runs/default-run-id.js';
 import { resolveProjectCloud } from '../../memory/cloud/cloud-config.js';
 import { buildSuiteVerdict } from './decision.js';
-import { classifyFlowAssertions, flattenSteps } from './flow-classify.js';
+import * as Bounded from './suite/sequential-run.js';
+import { FLOW_ASSERTIONS_OUTPUT, classifyFlowAssertions, flattenSteps } from './flow-classify.js';
 import { recordingBacktrackWarning } from './recording/recording-backtrack.js';
 import { isValidFlowName, flowPath } from '../../memory/project/dir/reticle-dir.js';
 import {} from './flows.js';
@@ -115,16 +114,7 @@ export const FLOW_TOOLS = [
             stepCount: z.number().optional(),
             degraded: z.number().optional(),
             empty: z.boolean().optional(),
-            assertions: z
-                .object({
-                grade: z.string().describe('asserted | presence-only | assertion-free'),
-                hasConsequenceAssertion: z.boolean(),
-                totalSteps: z.number(),
-                consequenceSteps: z.number(),
-                weakSteps: z.number(),
-                warning: z.string().optional(),
-            })
-                .optional(),
+            assertions: FLOW_ASSERTIONS_OUTPUT,
             intentGap: INTENT_GAP_FIELD,
             normalized: z.array(z.string()).optional(),
             warning: z
@@ -486,15 +476,21 @@ export const FLOW_TOOLS = [
             parallel: workerCountSchema
                 .optional()
                 .describe('Run this many flows at once, each in its own isolated leased browser context (needs the browser pool). Clamped to the pool capacity and the flow count. Omit for the sequential single-tab run.'),
+            ignoreHTTPSErrors: z
+                .boolean()
+                .optional()
+                .describe('Accept a self-signed or local-CA certificate for parallel flow leases. Omit to inherit the source lease setting; otherwise certificate checks stay on.'),
             confirmDangerous: confirmDangerousArg('this run of the suite'),
             skipWrites: SKIP_WRITES_ARG,
+            budgetMs: Bounded.BUDGET_MS_ARG,
             sessionId: z
                 .string()
                 .optional()
                 .describe('Active session ID from reticle_sessions. Omit when only one browser session is open.'),
         },
         outputSchema: {
-            status: z.string().describe('pass | fail'),
+            status: z.string().describe('pass | fail | unverifiable | partial'),
+            ...Bounded.PARTIAL_OUTPUT,
             runId: z.string().optional().describe('The run this suite was written down as.'),
             total: z.number(),
             passed: z.number(),
@@ -584,6 +580,9 @@ export const FLOW_TOOLS = [
                 appUrl !== undefined &&
                 requested.length > 0) {
                 const concurrency = resolveConcurrency(requested.length, pool.capacity(), parallelArg);
+                const ignoreHTTPSErrors = 'boolean' === typeof args['ignoreHTTPSErrors']
+                    ? args['ignoreHTTPSErrors']
+                    : pool.ignoresHTTPSErrors?.(deps.sessions.resolve(sessionId).id);
                 /*
                  * Captured ONCE, before any flow runs, from the page the agent is already driving.
                  *
@@ -603,7 +602,7 @@ export const FLOW_TOOLS = [
                 const seed = await suiteFixtureSeed(deps.realInput, sessionUrlOf(deps, sessionId) ?? appUrl);
                 const outcomes = await mapWithConcurrency(requested, concurrency, async (flowName) => {
                     const start = deps.now();
-                    const lease = await acquireLeasedSession(pool, deps.sessions, appUrl, projectId, seed);
+                    const lease = await acquireLeasedSession(pool, deps.sessions, appUrl, projectId, seed, ignoreHTTPSErrors);
                     try {
                         const replay = await replayAndLearn(deps, {
                             flowName,
@@ -646,22 +645,36 @@ export const FLOW_TOOLS = [
             const runs = [];
             const timed = [];
             // Sequential default: every flow replays against the same live session, so they must not overlap.
-            //
             // Each starts where the last left the app; a reset was built and reverted (see the ledger's 9.2).
-            for (const flowName of requested) {
-                const start = deps.now();
-                const replay = await replayAndLearn(deps, { flowName, sessionId, ...confirmed });
-                const loaded = await flowsForSession(deps, target)
-                    .flows.load(flowName, projectId)
-                    .catch(() => null);
-                const flow = loaded !== null && loaded.ok ? loaded.value : undefined;
-                runs.push(flow === undefined ? { replay } : { replay, flow });
-                timed.push({
-                    replay,
-                    durationMs: deps.now() - start,
-                    ...(flow === undefined ? {} : { flow }),
-                });
-            }
+            // Bounded by a time budget and the session staying up; `resolve` follows a reload to its successor.
+            let driven = sessionId;
+            const stoppedEarly = await Bounded.runSequentially(requested, {
+                now: deps.now,
+                budgetMs: asNumber(args['budgetMs']) ?? Bounded.DEFAULT_SUITE_BUDGET_MS,
+                sessionAlive: () => {
+                    try {
+                        driven = deps.sessions.resolve(driven).id;
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                run: async (flowName) => {
+                    const start = deps.now();
+                    const replay = await replayAndLearn(deps, { flowName, sessionId, ...confirmed });
+                    const loaded = await flowsForSession(deps, target)
+                        .flows.load(flowName, projectId)
+                        .catch(() => null);
+                    const flow = loaded !== null && loaded.ok ? loaded.value : undefined;
+                    runs.push(flow === undefined ? { replay } : { replay, flow });
+                    timed.push({
+                        replay,
+                        durationMs: deps.now() - start,
+                        ...(flow === undefined ? {} : { flow }),
+                    });
+                },
+            });
             // The flake ledger the CLI gate already keeps — see FlakeStore. It was only ever written by
             // `reticle flow` on the command line, so an AGENT running this tool a hundred times learned
             // nothing about which flows are intermittent. Same product, same ledger, two surfaces, and the
@@ -669,7 +682,7 @@ export const FLOW_TOOLS = [
             const flaky = await recordSuiteFlakes(deps.fs, rootForTarget(deps, target), runs);
             // Emit the consolidated run artifact (Runs tab) + best-effort cloud push. Never blocks the verdict.
             const runId = await persistAndSyncVerificationRun(deps, timed, target);
-            const verdict = buildSuiteVerdict(runs, selected.knownRoutes, SuiteIsolation.SHARED_SESSION);
+            const verdict = Bounded.withStop(buildSuiteVerdict(runs, selected.knownRoutes, SuiteIsolation.SHARED_SESSION), stoppedEarly.notRun, stoppedEarly.stopped);
             // A flow that has both passed and failed on UNCHANGED code is a different thing from a
             // regression, and an agent that cannot tell them apart either chases a ghost or ignores a real
             // break. Present only when the ledger has seen enough runs to say so.