verikun 0.29.0 → 0.30.0

package/dist/errors.js

@@ -6,7 +6,7 @@
 //   2  usage error, ambiguous selector, or a device another job is driving (caller must refine)
 //   3  environment error (adb/simctl missing, no usable device, dump failed)
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AmbiguousSelectorError = exports.DUMP_KILLED_MESSAGE = exports.dumpKilledMessage = exports.DumpKilledError = exports.NO_WINDOW_MESSAGE = exports.NoWindowError = exports.TransientReadError = exports.SelectorNotFoundError = exports.probeFailure = exports.envError = exports.usageError = exports.CliError = void 0;
+exports.AmbiguousSelectorError = exports.RunEvictedError = exports.NoFreeDeviceError = exports.DUMP_KILLED_MESSAGE = exports.dumpKilledMessage = exports.DumpKilledError = exports.NO_WINDOW_MESSAGE = exports.NoWindowError = exports.TransientReadError = exports.SelectorNotFoundError = exports.probeFailure = exports.envError = exports.usageError = exports.CliError = void 0;
 exports.isEnvError = isEnvError;
 class CliError extends Error {
     exitCode;
@@ -140,6 +140,44 @@ exports.dumpKilledMessage = dumpKilledMessage;
 exports.DUMP_KILLED_MESSAGE = 'The UI hierarchy dump was killed before it could answer — the device reclaiming memory ' +
     'while an app starts, or another tool holding the one UiAutomation connection. This ' +
     'normally clears within seconds.';
+// --- Remote leases: a run that never got a device, and one that lost its device --------
+//
+// Both are exit 3 like any other environment failure — the exit-code contract does not move
+// and `isEnvError` still holds. They are classes only so a PARALLEL suite can tell them apart
+// from a broken box across a process boundary (`errorKind` in a lane child's --json). Read as
+// ordinary environment failures they were issue #147: a pool that lost one phone recorded
+// failures for tests that never ran, and retired a lane the server would have fed again
+// minutes later.
+/**
+ * A `vk server` refused this run a device: every device is leased (409) or none is serving
+ * (503). Built ONLY for `/v1/lease`, the call a run makes before it does anything, so it
+ * always means the test never started. `vk suite` hands such a test back to its queue and
+ * waits for a device instead of recording a failure.
+ */
+class NoFreeDeviceError extends CliError {
+    constructor(message) {
+        super(message, 3);
+        this.name = 'NoFreeDeviceError';
+    }
+}
+exports.NoFreeDeviceError = NoFreeDeviceError;
+/**
+ * The server ended this run part-way: its device left the pool, was taken over while the run
+ * sat idle, or was power-cycled — and a run is never re-homed onto another phone, because its
+ * earlier steps ran on this one. Only the server knows, so it TAGS the 409 (`errorKind`); an
+ * older server's eviction stays an ordinary environment failure.
+ *
+ * Nothing in the `vk ai` engine may absorb it: every later call is refused the same way, so a
+ * catch that treats it as a transient read turns a lost phone into an "absent" guard or a
+ * failed repair. `vk suite` re-runs the test as a fresh run without spending a retry.
+ */
+class RunEvictedError extends CliError {
+    constructor(message) {
+        super(message, 3);
+        this.name = 'RunEvictedError';
+    }
+}
+exports.RunEvictedError = RunEvictedError;
 /** Selector matched >1 element. Exit 2. Carries the candidates so the agent runner
  *  can ask the model to disambiguate (a heal trigger) instead of aborting. */
 class AmbiguousSelectorError extends CliError {

package/dist/report.js

@@ -278,7 +278,8 @@ const SUITE_STYLE = `
 function suiteAttemptLinks(attempts, linkBase) {
     const links = attempts
         .map((a, i) => {
-        const label = `attempt ${i + 1}`;
+        // Said outright, so nobody goes looking for a flake in a test whose phone was unplugged.
+        const label = `attempt ${i + 1}${a.evicted ? ' (device left the pool)' : ''}`;
         if (!a.id)
             return htmlEsc(label);
         return `<a href="${htmlEsc(`${linkBase}runs/${encodeURIComponent(a.id)}/report.html`)}">${htmlEsc(label)}</a>`;

package/dist/rpc.js

@@ -34,6 +34,15 @@ function describeError(e) {
     if (e instanceof errors_1.NoWindowError) {
         return { kind: 'NoWindowError', name: e.name, message: e.message, exitCode: e.exitCode };
     }
+    // Also before the CliError arm, for a different reader: `mapError` puts this kind in a
+    // lane child's --json, and it is how a parallel suite tells "never got a device" and "lost
+    // its device" from a broken box (#147). The server only ever SENDS the eviction.
+    if (e instanceof errors_1.NoFreeDeviceError) {
+        return { kind: 'NoFreeDeviceError', name: e.name, message: e.message, exitCode: e.exitCode };
+    }
+    if (e instanceof errors_1.RunEvictedError) {
+        return { kind: 'RunEvictedError', name: e.name, message: e.message, exitCode: e.exitCode };
+    }
     if (e instanceof errors_1.CliError) {
         return { kind: 'CliError', name: e.name, message: e.message, exitCode: e.exitCode };
     }
@@ -51,6 +60,10 @@ function rebuildError(d) {
             return new errors_1.NoWindowError(d.message);
         case 'DumpKilledError':
             return new errors_1.DumpKilledError(d.message);
+        case 'NoFreeDeviceError':
+            return new errors_1.NoFreeDeviceError(d.message);
+        case 'RunEvictedError':
+            return new errors_1.RunEvictedError(d.message);
         case 'CliError':
             return new errors_1.CliError(d.message, d.exitCode);
         default: {

package/dist/server-http.js

@@ -15,6 +15,7 @@ class HttpError extends Error {
     exitCode;
     deviceChanged;
     errorKind;
+    evicted;
     constructor(status, message, exitCode = status === 400 || status === 404 || status === 413 ? 2 : 3, 
     /** Set when this request moved the server's device before failing — the client
      *  needs to know the ground shifted even though the answer is an error. */
@@ -23,12 +24,15 @@ class HttpError extends Error {
      *  HttpError is how the identity used to be lost: only `.message` and `.exitCode` were
      *  copied across, so a `NoWindowError` reached the client as a bare `CliError`. Carry it
      *  here and the outer catch can put it on the wire. */
-    errorKind) {
+    errorKind, 
+    /** This request's failure evicted the caller's run (see ExecResponse.evicted). */
+    evicted) {
         super(message);
         this.status = status;
         this.exitCode = exitCode;
         this.deviceChanged = deviceChanged;
         this.errorKind = errorKind;
+        this.evicted = evicted;
         this.name = 'HttpError';
     }
 }

package/dist/server.js

@@ -891,11 +891,14 @@ function buildServer(config) {
      * phone that is now gone, so continuing it elsewhere would produce a run whose steps
      * came from two devices while the report named one. A new run token (a rerun) is served
      * normally — this only closes the door on the run that was interrupted.
+     *
+     * Each keeps what it lost and why, because the run is TOLD: its 409 names the device, and a
+     * parallel suite's warning then names the phone that left rather than a lane slot (#147).
      */
-    const evicted = new Set();
+    const evicted = new Map();
     /**
      * Bounded, because on a long-lived CI server every interrupted run leaves an entry and
-     * only its own `/v1/release` ever removes one. A Set iterates in insertion order, so
+     * only its own `/v1/release` ever removes one. A Map iterates in insertion order, so
      * the front is the stalest — a client that died long ago and will never ask again.
      */
     const EVICTED_CAP = 512;
@@ -906,17 +909,17 @@ function buildServer(config) {
     function evict(token, why) {
         const had = leases.get(token);
         leases.delete(token);
-        evicted.add(token);
+        evicted.set(token, { serial: had?.serial, why });
         // Every eviction is announced. This is the direct cause of the 409 a client then reads
-        // as an environment failure — and of the lane a suite retires over it — and it used to
-        // be the one lease transition that happened in complete silence, so a degrading run
-        // showed a burst of unexplained 409s with nothing anywhere connecting them to the
-        // device that left.
+        // (a parallel suite re-runs the test as a fresh run; an older client read it as an
+        // environment failure and retired a lane over it), and it used to be the one lease
+        // transition that happened in complete silence, so a degrading run showed a burst of
+        // unexplained 409s with nothing anywhere connecting them to the device that left.
         if (had)
             (0, output_1.err)(`[server] lease: run ${token.slice(0, 8)}… evicted from ${had.serial} — ${why}`);
         // `if`, not `while`: this adds exactly one entry, so at most one can be over.
         if (evicted.size > EVICTED_CAP)
-            evicted.delete(evicted.values().next().value);
+            evicted.delete(evicted.keys().next().value);
     }
     function evictHoldersOf(serial, why) {
         for (const [token, lease] of leases)
@@ -1025,11 +1028,14 @@ function buildServer(config) {
      */
     let exclusive = null;
     function busyError(token) {
-        if (token !== undefined && evicted.has(token)) {
+        const lost = token === undefined ? undefined : evicted.get(token);
+        if (lost) {
             // Named plainly, because "device is busy" would send the operator looking for a
-            // racing job that does not exist.
-            return new server_http_1.HttpError(409, 'the device this run was using left the pool and nothing healthy replaced it — ' +
-                'start a fresh run; this one cannot continue on another device', 3);
+            // racing job that does not exist. TAGGED, because the client cannot tell an eviction
+            // from contention any other way: a parallel suite re-runs an evicted test as a fresh
+            // run without spending a retry, but must never do that for a busy pool (#147).
+            return new server_http_1.HttpError(409, `this run lost its device${lost.serial ? ` (${lost.serial})` : ''}: ${lost.why} — ` +
+                'start a fresh run; this one cannot continue on another device', 3, undefined, 'RunEvictedError');
         }
         // An empty pool never reaches here: the deviceless guard in the router answers 503 for
         // every route that takes a lease, and it names `lostDevice` while doing it. So `n` is
@@ -1119,7 +1125,7 @@ function buildServer(config) {
             evict(t, why);
         }
     }
-    async function handleExec(handle, req, res) {
+    async function handleExec(handle, req, res, token) {
         const body = await (0, server_http_1.readBody)(req, EXEC_BODY_CAP);
         let parsed;
         try {
@@ -1160,7 +1166,12 @@ function buildServer(config) {
         }
         catch (e) {
             const changed = await considerFailover(e, 'exec', handle);
-            throw changed ? new server_http_1.HttpError(500, e.message, e instanceof errors_1.CliError ? e.exitCode : 3, changed) : e;
+            // Evicted by the failover this very failure triggered: say so on the error itself (#147).
+            const lost = evicted.has(token);
+            if (lost && !changed) {
+                throw new server_http_1.HttpError(500, e.message, e instanceof errors_1.CliError ? e.exitCode : 3, undefined, (0, rpc_1.describeError)(e).kind, true);
+            }
+            throw changed ? new server_http_1.HttpError(500, e.message, e instanceof errors_1.CliError ? e.exitCode : 3, changed, undefined, lost || undefined) : e;
         }
         const { code, error, step, artifacts, logStart } = outcome;
         (0, output_1.err)(`[server] ${handle.serial} exec ${node.command} ${node.positionals.join(' ')} → exit ${code} (${Date.now() - t0}ms)`);
@@ -1177,13 +1188,17 @@ function buildServer(config) {
             code,
             ...(error ? { error } : {}),
             ...(deviceChanged ? { deviceChanged } : {}),
+            // The failover this failure triggered shed the device and evicted this run. MEASURED on
+            // hardware: this response is the only one that knows — the client's next request is
+            // usually its release, which clears the mark (#147).
+            ...(evicted.has(token) ? { evicted: true } : {}),
             ...(step ? { step } : {}),
             ...(artifacts && Object.keys(artifacts).length ? { artifacts: (0, server_http_1.encodeArtifacts)(artifacts) } : {}),
             ...(logStart ? { logStart } : {}),
         };
         (0, server_http_1.sendJson)(res, 200, payload);
     }
-    async function handleElements(handle, req, res) {
+    async function handleElements(handle, req, res, token) {
         await (0, server_http_1.readBody)(req, EXEC_BODY_CAP); // drain (the body is unused; keeps keep-alive sane)
         try {
             const elements = await handle.elements(); // CliError(3) on dump failure → 500 below
@@ -1198,12 +1213,13 @@ function buildServer(config) {
             // hierarchy from somewhere else is worse than an error. The client's connect probe
             // re-asks after a reported move — see remote.ts's preflight.
             const deviceChanged = await considerFailover(e, 'read', handle);
-            if (!deviceChanged)
+            const lost = evicted.has(token);
+            if (!deviceChanged && !lost)
                 throw e;
             // describeError, not just .message/.exitCode: this wrap is on the path a mid-launch
             // NoWindowError takes, and the engine's guard tells "still drawing" from "box broken"
             // by class alone (issue #80).
-            throw new server_http_1.HttpError(500, e.message, e instanceof errors_1.CliError ? e.exitCode : 3, deviceChanged, (0, rpc_1.describeError)(e).kind);
+            throw new server_http_1.HttpError(500, e.message, e instanceof errors_1.CliError ? e.exitCode : 3, deviceChanged, (0, rpc_1.describeError)(e).kind, lost || undefined);
         }
     }
     async function handleLogs(handle, req, res) {
@@ -1771,6 +1787,13 @@ function buildServer(config) {
             (0, server_http_1.sendJson)(res, 200, body);
             return;
         }
+        // A run that was EVICTED is told so first, however empty the pool has since become: it
+        // lost its phone part-way, which is not the same as a new run finding none, and a
+        // parallel suite re-runs only the former as a fresh run (#147). Shedding a pool's last
+        // device is exactly when both are true at once.
+        if (served.size === 0 && evicted.has(token) && (path === '/v1/exec' || path === '/v1/elements' || path === '/v1/logs')) {
+            throw busyError(token);
+        }
         // A deviceless server must not silently fail every command. In-memory check, so
         // the normal path is untouched. NOTE this fires only when the server NEVER
         // resolved a device — one that DIED mid-run still has a non-null binding and keeps
@@ -1811,9 +1834,9 @@ function buildServer(config) {
             return holdingLease(token, () => fn(h));
         };
         if (req.method === 'POST' && path === '/v1/exec')
-            return onLeasedDevice((h) => handleExec(h, req, res));
+            return onLeasedDevice((h) => handleExec(h, req, res, token));
         if (req.method === 'POST' && path === '/v1/elements')
-            return onLeasedDevice((h) => handleElements(h, req, res));
+            return onLeasedDevice((h) => handleElements(h, req, res, token));
         if (req.method === 'POST' && path === '/v1/logs')
             return onLeasedDevice((h) => handleLogs(h, req, res));
         if (req.method === 'POST' && path === '/v1/install') {
@@ -1891,6 +1914,7 @@ function buildServer(config) {
                     exitCode: mapped.exitCode,
                     ...(errorKind ? { errorKind } : {}),
                     ...(mapped.deviceChanged ? { deviceChanged: mapped.deviceChanged } : {}),
+                    ...(mapped.evicted ? { evicted: true } : {}),
                 };
                 (0, server_http_1.sendJson)(res, mapped.status, body);
             }