@swimmingliu/autovpn 2.2.1 → 2.2.3

package/dist/artifacts/list.js

@@ -56,6 +56,38 @@ function restoreArtifactCounts(artifactDir, counts = {}) {
     }
     return restored;
 }
+/**
+ * When this artifact last did work, newest first.
+ *
+ * The directory's own mtime is not that: `run.db` is WAL-mode, and even a
+ * read-only open creates and removes `-wal`/`-shm` beside it, which touches the
+ * directory. The server reads every artifact's progress on each state load, so
+ * an abandoned run's directory looked newer than the run that actually finished
+ * after it — the page then showed the abandoned run's `running` stages forever.
+ *
+ * The run's own files carry the real timestamp. `run.db` is written throughout,
+ * the report at every stage transition; the directory mtime is only a fallback
+ * for an artifact that has neither.
+ */
+export function artifactWorkedAt(artifactDir) {
+    let newest = 0;
+    for (const name of ['run.db', 'pipeline_report.json', 'events.jsonl']) {
+        try {
+            newest = Math.max(newest, fs.statSync(path.join(artifactDir, name)).mtimeMs);
+        }
+        catch {
+            // Missing file: the others still date the run.
+        }
+    }
+    if (newest)
+        return newest;
+    try {
+        return fs.statSync(artifactDir).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
 function latestArtifactDir(artifactsRoot) {
     if (!fs.existsSync(artifactsRoot)) {
         return '';
@@ -63,11 +95,8 @@ function latestArtifactDir(artifactsRoot) {
     const candidates = fs.readdirSync(artifactsRoot)
         .map((name) => path.join(artifactsRoot, name))
         .filter((item) => fs.statSync(item).isDirectory())
-        .sort((left, right) => {
-        const leftStat = fs.statSync(left);
-        const rightStat = fs.statSync(right);
-        return rightStat.mtimeMs - leftStat.mtimeMs || path.basename(right).localeCompare(path.basename(left));
-    });
+        .sort((left, right) => (artifactWorkedAt(right) - artifactWorkedAt(left)
+        || path.basename(right).localeCompare(path.basename(left))));
     return candidates[0] ?? '';
 }
 export function artifactLatest(projectRoot, env = process.env) {
@@ -126,7 +155,8 @@ export function artifactList(projectRoot, env = process.env) {
     const directories = fs.readdirSync(artifactsRoot)
         .map((name) => path.join(artifactsRoot, name))
         .filter((item) => fs.statSync(item).isDirectory() && isArtifactDir(item))
-        .sort((left, right) => fs.statSync(right).mtimeMs - fs.statSync(left).mtimeMs);
+        .sort((left, right) => (artifactWorkedAt(right) - artifactWorkedAt(left)
+        || path.basename(right).localeCompare(path.basename(left))));
     const items = directories.slice(0, 20)
         .map((artifactDir) => {
         const report = loadJson(path.join(artifactDir, 'pipeline_report.json'));
@@ -140,7 +170,7 @@ export function artifactList(projectRoot, env = process.env) {
             source_counts: report.source_counts ?? {},
             retry_context: report.retry_context ?? {},
             retryable_stages: retryableStages(artifactDir, stageStatus),
-            updated_at: new Date(fs.statSync(artifactDir).mtimeMs).toISOString().replace('Z', '')
+            updated_at: new Date(artifactWorkedAt(artifactDir)).toISOString().replace('Z', '')
         };
     });
     // Retry choices stay bounded; the calendar aggregates every retained run,

package/dist/backend/node-backend.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { artifactWorkedAt } from '../artifacts/list.js';
 import { resumeNodePipeline, retryNodePipelineStage, runNodePipeline } from '../pipeline/orchestrator.js';
 import { resolveArtifactsRoot } from '../runtime/paths.js';
 import { readLatestStageStatuses, readRunStatus } from '../pipeline/run-store.js';
@@ -19,7 +20,9 @@ function latestIncompleteRunArtifact(projectRoot, env) {
         return { artifactDir, dbPath };
     })
         .filter((candidate) => fs.existsSync(candidate.dbPath))
-        .sort((left, right) => fs.statSync(right.artifactDir).mtimeMs - fs.statSync(left.artifactDir).mtimeMs);
+        // The run's own files date it; the directory mtime moves whenever a
+        // read-only progress query creates WAL sidecars beside `run.db`.
+        .sort((left, right) => artifactWorkedAt(right.artifactDir) - artifactWorkedAt(left.artifactDir));
     for (const candidate of candidates) {
         const runStatus = readRunStatus(candidate.dbPath);
         if (!runStatus || ['success', 'failed', 'stopped', 'cancelled'].includes(runStatus)) {
@@ -47,6 +50,66 @@ function pushEvent(queue, event) {
     const wake = queue.wake.shift();
     wake?.();
 }
+/**
+ * Mirror one run's events into its own artifact directory.
+ *
+ * A run started by cron or by a plain `autovpn run` has no job directory, so
+ * its event stream existed only on stdout and the served UI had nothing to
+ * follow: the logs page showed the last detached job's stale lines and never
+ * refreshed. Writing `<artifact>/events.jsonl` next to the artifact makes the
+ * run self-describing, so the server can tail it, a page reload can replay it,
+ * and log retention can prune it with the rest of the run's records.
+ *
+ * The file is opened lazily on `run_started`, the first event that names the
+ * artifact directory. When the caller already asked for that exact path via
+ * `--event-log`, the orchestrator is writing it and the mirror stays out of the
+ * way rather than appending every line twice.
+ */
+function createArtifactEventMirror(explicitEventLog, knownArtifactDir) {
+    let file = '';
+    let disabled = false;
+    const open = (artifactDir) => {
+        file = path.join(artifactDir, 'events.jsonl');
+        if (explicitEventLog && path.resolve(explicitEventLog) === path.resolve(file)) {
+            disabled = true;
+        }
+    };
+    if (knownArtifactDir)
+        open(knownArtifactDir);
+    return {
+        write(event) {
+            if (disabled)
+                return;
+            if (!file) {
+                const artifactDir = String(event.artifact_dir ?? '');
+                // A resumed run emits no `run_started`; its artifact is known up front.
+                if (!artifactDir || (event.type !== 'run_started' && event.type !== 'resume_latest_state'))
+                    return;
+                open(artifactDir);
+                if (disabled)
+                    return;
+            }
+            try {
+                // The stream carries request URLs and vendor messages, so the mirror
+                // gets the same owner-only mode the job logs use.
+                fs.appendFileSync(file, `${JSON.stringify(event)}\n`, { encoding: 'utf8', mode: 0o600 });
+            }
+            catch {
+                // The mirror is an observability aid; a full disk must not fail a run.
+            }
+        }
+    };
+}
+/** The artifact a resume session belongs to, or '' when it cannot be read. */
+function resumeArtifactDir(session) {
+    try {
+        const payload = JSON.parse(fs.readFileSync(path.join(session, 'session.json'), 'utf8'));
+        return String(payload.artifact_dir ?? '');
+    }
+    catch {
+        return '';
+    }
+}
 function finishQueue(queue, error) {
     queue.done = true;
     queue.error = error;
@@ -69,13 +132,17 @@ export class NodeBackend {
     }
     async *run(options) {
         const queue = { events: [], wake: [], done: false };
+        const mirror = createArtifactEventMirror(options.eventLog);
         const runner = options.resumeLatest
             ? async () => {
                 const artifactDir = latestIncompleteRunArtifact(options.projectRoot, this.env);
                 if (!artifactDir) {
                     throw new Error('No incomplete run.db found to resume');
                 }
-                pushEvent(queue, { type: 'resume_latest_state', artifact_dir: artifactDir });
+                const resumeMirror = createArtifactEventMirror(options.eventLog, artifactDir);
+                const stateEvent = { type: 'resume_latest_state', artifact_dir: artifactDir };
+                resumeMirror.write(stateEvent);
+                pushEvent(queue, stateEvent);
                 const session = writeResumeLatestSession(artifactDir, options);
                 return resumeNodePipeline({
                     projectRoot: options.projectRoot,
@@ -88,12 +155,18 @@ export class NodeBackend {
                     humanLog: options.humanLog
                 }, {
                     env: this.env,
-                    emit: (event) => pushEvent(queue, event)
+                    emit: (event) => {
+                        resumeMirror.write(event);
+                        pushEvent(queue, event);
+                    }
                 });
             }
             : async () => runNodePipeline(options, {
                 env: this.env,
-                emit: (event) => pushEvent(queue, event)
+                emit: (event) => {
+                    mirror.write(event);
+                    pushEvent(queue, event);
+                }
             });
         void runner()
             .then(() => finishQueue(queue))
@@ -111,6 +184,7 @@ export class NodeBackend {
     }
     async *retryStage(options) {
         const queue = { events: [], wake: [], done: false };
+        const mirror = createArtifactEventMirror(options.eventLog);
         void retryNodePipelineStage({
             projectRoot: options.projectRoot,
             artifactDir: options.artifactDir,
@@ -120,7 +194,10 @@ export class NodeBackend {
             humanLog: options.humanLog
         }, {
             env: this.env,
-            emit: (event) => pushEvent(queue, event)
+            emit: (event) => {
+                mirror.write(event);
+                pushEvent(queue, event);
+            }
         })
             .then(() => finishQueue(queue))
             .catch((error) => finishQueue(queue, error));
@@ -137,6 +214,10 @@ export class NodeBackend {
     }
     async *resume(options) {
         const queue = { events: [], wake: [], done: false };
+        // A resumed run emits no `run_started`, so the mirror is seeded from the
+        // session's artifact directory: without it the artifact log would keep the
+        // interrupted run's `running` stages forever.
+        const mirror = createArtifactEventMirror(options.eventLog, resumeArtifactDir(options.session));
         void resumeNodePipeline({
             projectRoot: options.projectRoot,
             mode: options.mode,
@@ -146,7 +227,10 @@ export class NodeBackend {
             humanLog: options.humanLog
         }, {
             env: this.env,
-            emit: (event) => pushEvent(queue, event)
+            emit: (event) => {
+                mirror.write(event);
+                pushEvent(queue, event);
+            }
         })
             .then(() => finishQueue(queue))
             .catch((error) => finishQueue(queue, error));

package/dist/cli/accounts-commands.js

@@ -144,7 +144,8 @@ function renderRefreshLine(event) {
 }
 function renderRefreshHuman(rows, result) {
     const lines = rows.map(renderRefreshLine);
-    lines.push(`checked=${result.checked} updated=${result.updated} expired=${result.expired} failed=${result.failed}`);
+    lines.push(`checked=${result.checked} updated=${result.updated} expired=${result.expired}` +
+        ` retired=${result.retired ?? 0} failed=${result.failed}`);
     return `${lines.join('\n')}\n`;
 }
 export function accountsTemplate() {

package/dist/config/profile.js

@@ -67,6 +67,19 @@ function positiveInteger(value, fallback) {
     const parsed = Number(value);
     return Number.isFinite(parsed) && parsed >= 1 ? Math.trunc(parsed) : fallback;
 }
+/**
+ * A lap count as stored, or null when the key is absent or unusable.
+ *
+ * Null is what keeps a legacy row legacy: the caller must be able to tell "no
+ * lap key" from "lap key of 0", because only the former leaves the round
+ * policy in charge. `min_laps` legitimately accepts 0.
+ */
+function positiveLapValue(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? Math.trunc(parsed) : null;
+}
 /**
  * Migrate the four vendor rows to the final input contract: official site only.
  *
@@ -86,6 +99,11 @@ export function normalizeOfficialSources(sources) {
             continue;
         }
         const wasCredential = config.mode === 'credential';
+        // A lap row is already expressed in the unit the operator chose. Rewriting
+        // its legacy caps to the round defaults would silently change the budget
+        // the drawer just displayed, so those keys pass through verbatim and only
+        // the lap keys are normalized.
+        const hasLapKey = ['max_laps', 'dry_laps', 'min_laps'].some((key) => positiveLapValue(config[key]) !== null);
         const normalized = {
             ...config,
             mode: 'credential',
@@ -94,8 +112,12 @@ export function normalizeOfficialSources(sources) {
             // A round is one cursor step over the fixed area list, not a full sweep
             // of every region. 200 rounds × the default 8 areas / 50 with no new
             // node matches the documented defaults.
-            max_iterations: wasCredential ? positiveInteger(config.max_iterations, 200) : 200,
-            plateau_limit: wasCredential ? positiveInteger(config.plateau_limit, 50) : 50,
+            max_iterations: hasLapKey
+                ? positiveInteger(config.max_iterations, 200)
+                : wasCredential ? positiveInteger(config.max_iterations, 200) : 200,
+            plateau_limit: hasLapKey
+                ? positiveInteger(config.plateau_limit, 50)
+                : wasCredential ? positiveInteger(config.plateau_limit, 50) : 50,
             areas_per_round: Math.min(64, positiveInteger(config.areas_per_round, 8)),
             area_concurrency: Math.min(16, positiveInteger(config.area_concurrency, 4))
         };
@@ -111,7 +133,19 @@ export function normalizeOfficialSources(sources) {
                 delete normalized.backend_brand;
             }
         }
-        if (!wasCredential) {
+        if (hasLapKey) {
+            const maxLaps = positiveLapValue(config.max_laps);
+            const dryLaps = positiveLapValue(config.dry_laps);
+            const minLaps = positiveLapValue(config.min_laps);
+            if (maxLaps !== null)
+                normalized.max_laps = maxLaps;
+            if (dryLaps !== null)
+                normalized.dry_laps = dryLaps;
+            // A floor of 0 is meaningful ("no guaranteed laps"), so it is kept.
+            if (minLaps !== null)
+                normalized.min_laps = minLaps;
+        }
+        if (!wasCredential && !hasLapKey) {
             // A legacy URL row's caps describe a different operation; start the
             // cursor flow at the documented scheduled-run default instead. A floor
             // carried over from URL mode is the same mismatch and is dropped with it.

package/dist/pipeline/brand-cache.js

@@ -98,6 +98,28 @@ export class FingerprintStore {
         }
         return payload;
     }
+    /**
+     * Stores an existing fingerprint under a different key.
+     *
+     * Used when a build changed how keys are derived: the entry was written under
+     * the old key and is still the only valid fingerprint on the machine. The
+     * original `verified_at` is preserved — stamping a new one would promote an
+     * entry that is genuinely past its trust window into a trusted one.
+     */
+    adopt(brand, payload) {
+        const adopted = { ...payload, brand };
+        try {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+            const target = cachePath(this.cacheDir, brand);
+            const temporary = `${target}.${process.pid}.${Date.now()}.tmp`;
+            fs.writeFileSync(temporary, `${JSON.stringify(adopted, null, 2)}\n`, 'utf8');
+            fs.renameSync(temporary, target);
+        }
+        catch {
+            // The cache is an optimisation; a copy failure must not fail the run.
+        }
+        return adopted;
+    }
     /** Records that a cached fingerprint still works, without re-reading the APK. */
     touch(brand) {
         const payload = this.read(brand);