@swimmingliu/autovpn 2.2.1 → 2.2.2

package/dist/server/runtime.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { artifactLatest, artifactList } from '../artifacts/list.js';
+import { artifactLatest, artifactList, artifactWorkedAt } from '../artifacts/list.js';
 import { previewArtifact } from '../artifacts/preview.js';
 import { profilePayload, saveProfilePayload } from '../config/profile.js';
 import { startDetachedRetry as defaultStartDetachedRetry, startDetachedRun as defaultStartDetachedRun, stopManagedJob as defaultStopManagedJob } from '../jobs/commands.js';
@@ -155,6 +155,42 @@ function latestJob(projectRoot, env) {
         return undefined;
     }
 }
+/**
+ * Fold stage and substep transitions down to their latest state.
+ *
+ * The terminal guard is what keeps a finished run from reading as 运行中: the
+ * tail of a long log is mostly `extract_iteration`, so a fold that only looked
+ * at older lines dropped the final `success` of extract/dedupe/speedtest/
+ * availability. Folding the whole stream means the last transition always
+ * wins unless it would demote a terminal state back to `running`.
+ */
+function foldStageEvents(events) {
+    const folded = new Map();
+    for (const event of events) {
+        if (event.type === 'extract_substage' && typeof event.source_name === 'string'
+            && typeof event.platform === 'string' && typeof event.substage === 'string') {
+            folded.set(['substage', event.source_name, event.platform, event.substage].join(':'), event);
+        }
+        if (event.type === 'stage' && typeof event.stage === 'string') {
+            folded.set(`stage:${event.stage}`, event);
+        }
+    }
+    return [...folded.values()];
+}
+/**
+ * Replay history for a page load: folded states first, then the recent tail.
+ *
+ * Stage and substep transitions are dropped from the tail because their folded
+ * copy already carries the final state; keeping both would replay `running`
+ * after `success` and undo the fold.
+ */
+function foldEventHistory(events, maxEvents = 1000) {
+    const folded = foldStageEvents(events);
+    const tail = events
+        .slice(-maxEvents)
+        .filter((event) => event.type !== 'stage' && event.type !== 'extract_substage');
+    return [...folded, ...tail];
+}
 function latestJobEvents(job, maxEvents = 1000) {
     const eventLog = String(job?.event_log ?? '');
     if (!eventLog || !fs.existsSync(eventLog))
@@ -162,25 +198,41 @@ function latestJobEvents(job, maxEvents = 1000) {
     try {
         const lines = fs.readFileSync(eventLog, 'utf8').split(/\r?\n/).filter(Boolean);
         const events = lines.map((line) => parseJsonLine(line)).filter(Boolean);
-        const priorSteps = new Map();
-        // APK/domain steps occur early. Preserve their latest states even when
-        // subsequent node logs exceed the bounded text-history window.
-        for (const event of events.slice(0, -maxEvents)) {
-            if (!event || typeof event !== 'object' || !('type' in event))
-                continue;
-            if (event.type === 'extract_substage' && 'source_name' in event && typeof event.source_name === 'string'
-                && 'platform' in event && typeof event.platform === 'string' && 'substage' in event && typeof event.substage === 'string') {
-                priorSteps.set([event.source_name, event.platform, event.substage].join(':'), event);
-            }
-            if (event.type === 'stage' && 'stage' in event && typeof event.stage === 'string')
-                priorSteps.set(`stage:${event.stage}`, event);
-        }
-        return [...priorSteps.values(), ...events.slice(-maxEvents)];
+        return foldEventHistory(events, maxEvents);
     }
     catch {
         return [];
     }
 }
+/**
+ * Stage/substep states and log lines for the latest artifact.
+ *
+ * A cron run has no job directory, so its only record is the mirror the CLI
+ * writes beside the artifact. Its log is the authoritative one when present:
+ * it covers every run path (foreground, detached, nightly) with one file.
+ */
+function artifactEventLog(artifactDir) {
+    const filePath = path.join(artifactDir, 'events.jsonl');
+    if (!artifactDir || !fs.existsSync(filePath)) {
+        return { events: [], active: false };
+    }
+    try {
+        const lines = fs.readFileSync(filePath, 'utf8').split(/\r?\n/).filter(Boolean);
+        const events = lines.map((line) => parseJsonLine(line)).filter(Boolean);
+        const finished = events.some((event) => event.type === 'summary' || event.type === 'run_failed' || event.type === 'finished');
+        let fresh = false;
+        try {
+            fresh = Date.now() - fs.statSync(filePath).mtimeMs < 2 * 60 * 1000;
+        }
+        catch {
+            fresh = false;
+        }
+        return { events: foldEventHistory(events), active: !finished && fresh };
+    }
+    catch {
+        return { events: [], active: false };
+    }
+}
 function terminalRunStateFromLatestJob(job, nowMs, ttlMs) {
     const status = String(job?.status ?? '');
     if (status === 'running' || status === 'stopping')
@@ -197,13 +249,10 @@ function terminalRunStateFromArtifact(artifact, nowMs, ttlMs) {
     if (!['success', 'failed'].includes(status))
         return undefined;
     const artifactDir = String(artifact?.artifact_dir ?? '');
-    let updatedAt = 0;
-    try {
-        updatedAt = artifactDir ? fs.statSync(artifactDir).mtimeMs : 0;
-    }
-    catch {
-        updatedAt = 0;
-    }
+    // The run's own files, not the directory: a read-only progress query creates
+    // WAL sidecars and touches the directory, which would keep a terminal state
+    // alive indefinitely on a host whose page is simply left open.
+    const updatedAt = artifactDir ? artifactWorkedAt(artifactDir) : 0;
     if (!updatedAt || nowMs - updatedAt > ttlMs)
         return undefined;
     return status;
@@ -229,6 +278,30 @@ function safeRmDir(dirPath) {
         // Cleanup is best-effort; serve startup and state loading must continue.
     }
 }
+/**
+ * Delete run records whose day is older than the retention window.
+ *
+ * T+1 is the default: the vendor's nightly run books its results after
+ * midnight, so a same-day prune would delete the run the operator is about to
+ * open. The window is calendar-day based rather than mtime based, so a file
+ * touched by a copy or a backup does not survive forever.
+ *
+ * `AUTOVPN_SERVER_HISTORY_RETENTION_DAYS` keeps its meaning (0 disables), and
+ * `AUTOVPN_SERVER_LOG_RETENTION_DAYS` overrides it for the log files alone.
+ */
+function retentionCutoffMs(env, days, now) {
+    const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    return start.getTime() - days * 24 * 60 * 60 * 1000;
+}
+function logRetentionMs(env) {
+    const raw = String(env.AUTOVPN_SERVER_LOG_RETENTION_DAYS ?? '').trim();
+    if (!raw)
+        return historyRetentionMs(env);
+    const parsed = Number.parseFloat(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return 0;
+    return parsed * 24 * 60 * 60 * 1000;
+}
 function pruneArtifacts(projectRoot, env, cutoffMs, activeArtifactDirs) {
     const root = resolveArtifactsRoot(projectRoot, env);
     if (!fs.existsSync(root))
@@ -249,6 +322,53 @@ function pruneArtifacts(projectRoot, env, cutoffMs, activeArtifactDirs) {
         }
     }
 }
+/**
+ * Age out daily-run logs and results on the same schedule.
+ *
+ * `scripts/server/daily-run.sh` appends one log and one result file per tick
+ * and never deletes either, so a host that runs nightly accumulates a year of
+ * them. The serve process owns both directories and prunes them here rather
+ * than adding a second cron entry that can drift.
+ */
+function pruneDailyRunRecords(env, cutoffMs) {
+    const runtimeRoot = path.dirname(resolveProfilePath('', env));
+    // Only the records this job writes. `logs/` also holds the serve unit's own
+    // stdout file, which systemd keeps open: unlinking it would leave the daemon
+    // writing to a deleted inode and silently lose every later log line.
+    const owned = [/^daily-run-.*\.log$/, /^\d{8}-\d{6}\.json$/];
+    for (const dirName of ['logs', 'daily-run-results']) {
+        const dir = path.join(runtimeRoot, dirName);
+        if (!fs.existsSync(dir))
+            continue;
+        let names;
+        try {
+            names = fs.readdirSync(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const name of names) {
+            if (!owned.some((pattern) => pattern.test(name)))
+                continue;
+            const file = path.join(dir, name);
+            let stat;
+            try {
+                stat = fs.statSync(file);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isFile() || stat.mtimeMs >= cutoffMs)
+                continue;
+            try {
+                fs.rmSync(file, { force: true });
+            }
+            catch {
+                // Best effort: an open log handle on another platform is not fatal.
+            }
+        }
+    }
+}
 function pruneJobs(projectRoot, env, cutoffMs) {
     const root = jobsRoot(projectRoot, env);
     const activeArtifactDirs = new Set();
@@ -307,32 +427,126 @@ function createHistoryPruner(options) {
     let lastPrunedAt = 0;
     return () => {
         const env = options.env ?? process.env;
-        const retention = historyRetentionMs(env);
-        if (retention <= 0)
-            return;
-        const nowMs = (options.now ?? (() => new Date()))().getTime();
+        const now = (options.now ?? (() => new Date()))();
+        const nowMs = now.getTime();
+        // At most once a day, at the first state load after a day has passed. The
+        // cutoff is the start of the day N days back, so everything older than
+        // today (T+1) goes and a run that finished late yesterday stays.
         if (lastPrunedAt && nowMs - lastPrunedAt < 24 * 60 * 60 * 1000)
             return;
         lastPrunedAt = nowMs;
-        const cutoffMs = nowMs - retention;
-        const activeArtifactDirs = pruneJobs(options.projectRoot, env, cutoffMs);
-        pruneArtifacts(options.projectRoot, env, cutoffMs, activeArtifactDirs);
+        const retentionDays = historyRetentionMs(env) / (24 * 60 * 60 * 1000);
+        if (retentionDays > 0) {
+            const cutoffMs = retentionCutoffMs(env, retentionDays, now);
+            const activeArtifactDirs = pruneJobs(options.projectRoot, env, cutoffMs);
+            pruneArtifacts(options.projectRoot, env, cutoffMs, activeArtifactDirs);
+        }
+        // Logs carry their own window, so a host can keep a month of run records
+        // and only a day of stdout without a second cleanup entry to drift.
+        const logDays = logRetentionMs(env) / (24 * 60 * 60 * 1000);
+        if (logDays > 0) {
+            pruneDailyRunRecords(env, retentionCutoffMs(env, logDays, now));
+        }
     };
 }
 export function createServerRuntime(options) {
     let runState = 'idle';
     let activeJobId = '';
     let unsubscribeLogs;
+    let unsubscribeArtifactLogs;
+    let followedArtifactDir = '';
+    let expiryRefreshInFlight = false;
     const pruneHistory = createHistoryPruner(options);
     const subscribers = new Set();
     const startDetachedRun = options.startDetachedRun ?? defaultStartDetachedRun;
     const startDetachedRetry = options.startDetachedRetry ?? defaultStartDetachedRetry;
     const stopManagedJob = options.stopManagedJob ?? defaultStopManagedJob;
     const followLog = options.followLog ?? defaultFollowLog;
-    function publish(event) {
+    const publish = (event) => {
         for (const subscriber of subscribers) {
             subscriber(event);
         }
+    };
+    /**
+     * Follow a plain event log that no job directory owns.
+     *
+     * A nightly cron run writes `<artifact>/events.jsonl` (the CLI mirrors its
+     * stream there), but nothing tells the server to tail it: without this the
+     * page stays on whatever the last detached job left and the logs never move.
+     * Polling a file is enough here — the writer appends a line at a time and the
+     * page needs sub-second freshness, not inotify precision.
+     */
+    function followArtifactEvents(artifactDir) {
+        if (followedArtifactDir === artifactDir && unsubscribeArtifactLogs) {
+            return;
+        }
+        unsubscribeArtifactLogs?.();
+        followedArtifactDir = artifactDir;
+        const filePath = path.join(artifactDir, 'events.jsonl');
+        let cancelled = false;
+        let offset = 0;
+        let pending = '';
+        const timer = setInterval(() => {
+            if (cancelled)
+                return;
+            let chunk = '';
+            try {
+                const stat = fs.statSync(filePath);
+                if (stat.size <= offset) {
+                    if (stat.size < offset)
+                        offset = 0;
+                    return;
+                }
+                const length = stat.size - offset;
+                const buffer = Buffer.alloc(length);
+                const fd = fs.openSync(filePath, 'r');
+                try {
+                    fs.readSync(fd, buffer, 0, length, offset);
+                }
+                finally {
+                    fs.closeSync(fd);
+                }
+                offset = stat.size;
+                chunk = pending + buffer.toString('utf8');
+            }
+            catch {
+                return;
+            }
+            const lines = chunk.split(/\r?\n/);
+            pending = lines.pop() ?? '';
+            let terminal = false;
+            for (const line of lines) {
+                const event = parseJsonLine(line);
+                if (!event)
+                    continue;
+                const nextRunState = eventRunState(event);
+                if (nextRunState) {
+                    runState = nextRunState;
+                    terminal = true;
+                }
+                // Same contract as the job follower: a result line replayed after a
+                // page load must carry absolute database totals, or the renderer adds
+                // it on top of the snapshot it already hydrated and doubles the count.
+                const record = event;
+                const metricEvent = ['extract_iteration', 'extract_source_completed', 'speedtest_result', 'availability_link_result'].includes(String(record.type));
+                const progress = metricEvent ? readRunProgress(path.join(artifactDir, 'run.db')) : undefined;
+                publish(progress ? { ...record, progress_snapshot: { ...progress, artifact_dir: artifactDir } } : event);
+                if (nextRunState)
+                    publish({ type: 'server_state', run_state: runState });
+            }
+            // The run is over: stop polling instead of stat-ing a finished file every
+            // 800ms for the life of the server. A later run follows its own artifact.
+            if (terminal) {
+                unsubscribeArtifactLogs?.();
+                unsubscribeArtifactLogs = undefined;
+                followedArtifactDir = '';
+            }
+        }, 800);
+        timer.unref?.();
+        unsubscribeArtifactLogs = () => {
+            cancelled = true;
+            clearInterval(timer);
+        };
     }
     function followJob(jobId) {
         let cancelled = false;
@@ -383,10 +597,23 @@ export function createServerRuntime(options) {
         });
     }
     function restoreRunState(artifact) {
-        if (runState !== 'idle') {
+        const env = options.env ?? process.env;
+        // A terminal state is a report about the *previous* run, not a latch. A new
+        // artifact whose log is still growing is a new run, and it must be followed
+        // even though the last one ended in success — otherwise the page stays
+        // frozen on yesterday's outcome until the server restarts.
+        const artifactDir = String(artifact?.artifact_dir ?? '');
+        const liveArtifact = artifactDir && artifactEventLog(artifactDir).active ? artifactDir : '';
+        if (runState !== 'idle' && !liveArtifact) {
+            return;
+        }
+        if (liveArtifact && runState !== 'running' && runState !== 'stopping') {
+            unsubscribeLogs?.();
+            activeJobId = '';
+            runState = 'running';
+            followArtifactEvents(liveArtifact);
             return;
         }
-        const env = options.env ?? process.env;
         const job = latestJob(options.projectRoot, env);
         if (job && ['running', 'stopping'].includes(String(job.status ?? ''))) {
             runState = String(job.status);
@@ -403,6 +630,14 @@ export function createServerRuntime(options) {
             ?? 'idle';
         if (runState !== 'running' && runState !== 'stopping') {
             activeJobId = '';
+            // A scheduled run has no job to follow, but its artifact log may still
+            // be growing. Restoring that follow is what makes the page live again
+            // after the server restarts mid-run.
+            const artifactDir = String(artifact?.artifact_dir ?? '');
+            if (artifactDir && artifactEventLog(artifactDir).active) {
+                runState = 'running';
+                followArtifactEvents(artifactDir);
+            }
         }
     }
     return {
@@ -412,6 +647,12 @@ export function createServerRuntime(options) {
             restoreRunState(artifact);
             const retries = artifactList(options.projectRoot, options.env ?? process.env);
             const job = latestJob(options.projectRoot, options.env ?? process.env);
+            // The artifact's own mirror wins when it exists: a scheduled run has no
+            // job, and replaying an older job's log put four finished stages back to
+            // 运行中 on the results page. A stale artifact log is still the right
+            // history — it is this artifact's, not another run's — so only its
+            // `active` flag (which drives live following) is time-bounded.
+            const artifactLog = artifactEventLog(String(artifact?.artifact_dir ?? ''));
             return {
                 profile: sanitizeProfileForServer(profilePayload(options.projectRoot, options.env)),
                 runState,
@@ -420,7 +661,7 @@ export function createServerRuntime(options) {
                 activity: Array.isArray(retries.activity) ? retries.activity : [],
                 activityUnavailable: Number(retries.activityUnavailable ?? 0),
                 deployment: (artifact?.deployment ?? {}),
-                logEvents: latestJobEvents(job)
+                logEvents: artifactLog.events.length ? artifactLog.events : latestJobEvents(job)
             };
         },
         async saveProfile(profile) {
@@ -504,6 +745,51 @@ export function createServerRuntime(options) {
                 store.close();
             }
         },
+        /**
+         * Learn every pooled account's membership date, then retire the lapsed and
+         * non-member rows.
+         *
+         * The worker is imported lazily: it pulls in the whole credential pipeline,
+         * and `serve` must start on an install whose dist predates it.
+         */
+        async refreshAccountExpiry(input = {}) {
+            let worker;
+            try {
+                const module = await import('../pipeline/credential-source.js');
+                worker = typeof module.refreshAccountExpiry === 'function'
+                    ? module.refreshAccountExpiry
+                    : undefined;
+            }
+            catch {
+                worker = undefined;
+            }
+            if (!worker)
+                return { ok: false, error: 'refresh_expiry_unavailable' };
+            // One sweep at a time: it logs in to every active row, and two overlapping
+            // sweeps would double the vendor load and race on the same rows.
+            if (expiryRefreshInFlight)
+                return { ok: false, error: 'refresh_expiry_in_progress' };
+            expiryRefreshInFlight = true;
+            const store = new AccountStore({ env: options.env, now: options.now });
+            try {
+                const outcome = await worker({
+                    brand: String(input.brand ?? '').trim() || undefined,
+                    limit: Math.max(0, Math.trunc(Number(input.limit ?? 0)) || 0),
+                    concurrency: Math.max(1, Math.trunc(Number(input.concurrency ?? 3)) || 3),
+                    env: options.env,
+                    store,
+                    now: options.now
+                });
+                return { ok: true, ...outcome, stats: store.stats() };
+            }
+            catch (error) {
+                return { ok: false, error: error instanceof Error ? error.message : String(error) };
+            }
+            finally {
+                expiryRefreshInFlight = false;
+                store.close();
+            }
+        },
         async startRun(runOptions = {}) {
             if (runState === 'running' || runState === 'stopping') {
                 return { ok: false, error: 'run_already_active' };
@@ -529,6 +815,7 @@ export function createServerRuntime(options) {
                 throw error;
             }
             activeJobId = String(job.job_id ?? '');
+            unsubscribeArtifactLogs?.();
             followJob(activeJobId);
             return { ok: true, runId: activeJobId, job_id: activeJobId, status: job.status ?? 'running' };
         },
@@ -552,11 +839,17 @@ export function createServerRuntime(options) {
                 cwd: options.projectRoot
             });
             activeJobId = String(job.job_id ?? '');
+            unsubscribeArtifactLogs?.();
             followJob(activeJobId);
             return { ok: true, runId: activeJobId, job_id: activeJobId, status: job.status ?? 'running' };
         },
         async stopRun() {
             if (runState !== 'running' || !activeJobId) {
+                // A scheduled run has no managed job to signal; stop following its log
+                // so the page does not keep reporting a run the operator ended.
+                unsubscribeArtifactLogs?.();
+                unsubscribeArtifactLogs = undefined;
+                followedArtifactDir = '';
                 return { ok: true, requested: false, run_state: runState };
             }
             runState = 'stopping';
@@ -583,6 +876,7 @@ export function createServerRuntime(options) {
         },
         async close() {
             unsubscribeLogs?.();
+            unsubscribeArtifactLogs?.();
             if (!activeJobId) {
                 const artifact = normalizeLatestArtifact(options.projectRoot, options.env ?? process.env);
                 restoreRunState(artifact);

package/dist/server/web-adapter.js

@@ -185,6 +185,10 @@ export function renderWebAdapterScript(options = {}) {
       )
     }),
     accountsTemplate: async () => ({ ok: true, content: ${JSON.stringify(accountsTemplate())} }),
+    refreshAccountExpiry: async (payload = {}) => request('/api/accounts/refresh-expiry', {
+      method: 'POST',
+      body: JSON.stringify(payload || {})
+    }),
     runPipeline: async (options = {}) => request('/api/runs', {
       method: 'POST',
       body: JSON.stringify({