@swimmingliu/autovpn 2.2.2 → 2.2.3

package/dist/pipeline/credential-source.js

@@ -8,6 +8,7 @@ import { AccountStore, maskAccount } from '../pool/account-store.js';
 import { BRANDS, brandFromSite, brandSite, normalizeBrand } from '../pool/brands.js';
 import { FingerprintStore, resolveFingerprintCacheDir } from './brand-cache.js';
 import { resolveUserRuntimeRoot } from '../runtime/paths.js';
+import { profilePayload } from '../config/profile.js';
 import { redactText } from '../runtime/redaction.js';
 /**
  * How many pooled accounts one source may try before it reports failure.
@@ -1986,12 +1987,17 @@ export function classifyMembershipRefresh(facts, today) {
         if (expires && expires < today)
             return { status: 'expired', reason: 'membership expired' };
         const level = facts.membership_level;
-        const produced = Number(facts.produced_links ?? 0) > 0 || Number(facts.route_count ?? 0) > 0;
+        // Links, not routes: the route table is filtered by flags, not by the
+        // account's grade, so a free row can list paid-looking areas and still get
+        // nothing but placeholders. The run path uses links for the same reason.
+        const produced = Number(facts.produced_links ?? 0) > 0;
         // A free-tier row (level 0/1) only ever yields placeholders. Retire it only
         // when it produced nothing, exactly as the run path does, so a paid row the
-        // vendor misreports as level 1 keeps its place.
-        if (level !== undefined && level < 2 && !produced)
+        // vendor misreports as level 1 keeps its place. A redirected row is exempt
+        // for the run path's reason: the level is the storefront's grading.
+        if (level !== undefined && level < 2 && !produced && !facts.redirected) {
             return { status: 'retired', reason: 'no paid membership' };
+        }
         return { status: 'updated', reason: '' };
     }
     if (facts.membership_expired)
@@ -2010,6 +2016,38 @@ export function classifyMembershipRefresh(facts, today) {
  * active rows deliberately, reusing the normal credential flow (cached
  * fingerprint, one node request) so the login path is the same one a run uses.
  */
+/**
+ * Where a membership sweep should log in for each brand.
+ *
+ * The sweep must reach the same host a run reaches, or its verdicts describe a
+ * different account than the one the pool rotates: on a redirected row the run
+ * rewrites `official_site` to the backend before any request, and the sweep
+ * used to probe the storefront the run never touches. Read from the profile so
+ * a redirected row is known here exactly as the run knows it.
+ */
+export function resolveExpiryProbeTargets(env, readSources) {
+    const targets = new Map();
+    let sources = {};
+    try {
+        // The profile path comes from the environment, so the project root argument
+        // is not consulted; `profilePayload` reads the same file a run does.
+        sources = readSources ? readSources() : (profilePayload(process.cwd(), env).sources ?? {});
+    }
+    catch {
+        // No readable profile: every brand falls back to its own storefront.
+    }
+    for (const [name, config] of Object.entries(sources)) {
+        const brand = normalizeBrand(name);
+        if (!brand)
+            continue;
+        const backend = normalizeBrand(String(config?.backend_brand ?? '').trim());
+        targets.set(brand, {
+            officialSite: String(config?.official_site ?? '').trim() || brandSite(brand),
+            ...(backend && backend !== brand ? { backendBrand: backend } : {})
+        });
+    }
+    return targets;
+}
 export async function refreshAccountExpiry(input = {}) {
     const env = input.env ?? process.env;
     const now = input.now ?? (() => new Date());
@@ -2026,6 +2064,15 @@ export async function refreshAccountExpiry(input = {}) {
     const requested = input.brand ? normalizeBrand(input.brand) : null;
     // Every brand the pool knows, from the registry rather than a second list.
     const brands = requested ? [requested] : BRANDS.map((brand) => brand.key);
+    // How a run would reach each brand. A redirected row is graded by its own
+    // storefront but logs in — and is graded again — against the backend it
+    // reads, with the backend's APK. Probing the storefront instead put the sweep
+    // on a host the run never touches (the deployment host cannot even resolve
+    // 黑洞's storefront) and graded the account by a backend it never uses, so its
+    // verdicts described a different account than the one the pool rotates.
+    const probeFor = resolveExpiryProbeTargets(env);
+    const probeSite = (brand) => probeFor.get(brand)?.officialSite ?? brandSite(brand);
+    const probeBackend = (brand) => probeFor.get(brand)?.backendBrand;
     try {
         for (const brand of brands) {
             let accounts = store.leaseAll(brand);
@@ -2034,10 +2081,13 @@ export async function refreshAccountExpiry(input = {}) {
             if (accounts.length === 0)
                 continue;
             // One memo per brand: the APK is inspected at most once for the whole
-            // sweep, not once per account. The cache key is the short brand key the
-            // normal run writes (`mf`, not `mifeng`); using the long name missed the
-            // cache on every sweep and re-downloaded the APK per account.
-            const brandKey = credentialBrandKey(brand, { official_site: brandSite(brand) });
+            // sweep, not once per account. The key comes from the same function a run
+            // uses, against the same probe source, so a redirected row is inspected
+            // under the backend's prefix and shares the entry the run just cached.
+            const brandKey = fingerprintKeyFor(brand, {
+                official_site: probeSite(brand),
+                ...(probeBackend(brand) ? { brand_override: probeBackend(brand) } : {})
+            });
             const memo = createFingerprintMemo(fingerprintStore, brandKey);
             await mapWithConcurrency(accounts, concurrency, async (leased) => {
                 const entry = {
@@ -2052,7 +2102,8 @@ export async function refreshAccountExpiry(input = {}) {
                         source_name: brand,
                         source: {
                             mode: 'credential',
-                            official_site: brandSite(brand),
+                            official_site: probeSite(brand),
+                            ...(probeBackend(brand) ? { backend_brand: probeBackend(brand) } : {}),
                             account: leased.account,
                             password: leased.password,
                             platforms: ['android'],
@@ -2065,7 +2116,8 @@ export async function refreshAccountExpiry(input = {}) {
                     entry.expires_at = expires;
                     const verdict = classifyMembershipRefresh({
                         ...result.diagnostics,
-                        produced_links: result.links.length
+                        produced_links: result.links.length,
+                        redirected: Boolean(probeBackend(brand))
                     }, todayText);
                     entry.status = verdict.status;
                     if (verdict.status === 'updated' || verdict.status === 'expired') {

package/dist/server/runtime.js

@@ -219,7 +219,18 @@ function artifactEventLog(artifactDir) {
     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');
+        // Only the LAST run in the file decides whether it is still going. A resume
+        // appends to the same artifact log, so an earlier run's terminal line would
+        // otherwise mark the live resume finished and the page would never follow it.
+        let finished = false;
+        for (const event of events) {
+            if (event.type === 'run_started' || event.type === 'resume_latest_state' || event.type === 'resume_pipeline_state') {
+                finished = false;
+            }
+            else if (event.type === 'summary' || event.type === 'run_failed' || event.type === 'finished') {
+                finished = true;
+            }
+        }
         let fresh = false;
         try {
             fresh = Date.now() - fs.statSync(filePath).mtimeMs < 2 * 60 * 1000;

package/dist/web/renderer/i18n.js

@@ -5,7 +5,7 @@ const ZH_MESSAGES = {
   locale: 'zh-CN',
   appTitle: 'AutoVPN',
   sidebarTitle: 'AutoVPN',
-  sidebarVersion: 'v.2.2.2',
+  sidebarVersion: 'v.2.2.3',
   brandSubtitle: '概览、运行、结果、订阅、日志、设置统一管理',
   languageLabel: '',
   saveButton: '保存配置',

package/dist/web/renderer/views.js

@@ -1252,7 +1252,10 @@ export function buildSourceIterationDraft(sources = {}, sourceCounts = {}) {
     const storedDry = hasStoredLapValue(source.dry_laps) ? coercePositiveInteger(source.dry_laps, SOURCE_LAP_DEFAULTS.dry_laps) : null;
     if (storedLaps !== null || storedDry !== null) {
       source.max_laps = storedLaps ?? SOURCE_LAP_DEFAULTS.max_laps;
-      source.dry_laps = storedDry ?? SOURCE_LAP_DEFAULTS.dry_laps;
+      // Same clamp as the conversion below: a profile written by an older
+      // build (or hand-edited) can already hold dry > max, and the drawer's
+      // validator refuses that pair — an untouched row must stay savable.
+      source.dry_laps = Math.min(source.max_laps, storedDry ?? SOURCE_LAP_DEFAULTS.dry_laps);
       continue;
     }
     // Only a row that actually stored a legacy budget is converted; a fresh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swimmingliu/autovpn",
-  "version": "2.2.2",
+  "version": "2.2.3",
   "description": "npm wrapper for the AutoVPN headless CLI",
   "type": "module",
   "repository": {