@swimmingliu/autovpn 2.0.2 → 2.1.0

package/dist/cli/accounts-commands.js

@@ -12,11 +12,29 @@ import { BRANDS, brandLabel, normalizeBrand } from '../pool/brands.js';
 import { CSV_COLUMNS, RETIRED_STATUSES, parseAccountFile, stringifyCsv } from '../pool/csv.js';
 import { CliUsageError } from './errors.js';
 import { readOptionValue } from './global-options.js';
-export const ACCOUNTS_SUBCOMMANDS = ['import', 'list', 'stats', 'snapshot', 'disable', 'enable', 'expire', 'export', 'template'];
+export const ACCOUNTS_SUBCOMMANDS = ['import', 'list', 'stats', 'snapshot', 'disable', 'enable', 'expire', 'export', 'template', 'refresh-expiry'];
 /** Options that consume the next argv slot, so positionals can be found. */
 const VALUE_OPTIONS = new Set([
-    '--project-root', '--format', '--output', '--brand', '--status', '--reason', '--date', '--file', '--limit', '--query', '--id'
+    '--project-root', '--format', '--output', '--brand', '--status', '--reason', '--date', '--file', '--limit', '--query', '--id',
+    '--concurrency'
 ]);
+/**
+ * Resolve the pipeline worker lazily.
+ *
+ * The worker is owned by the pipeline module; a build that predates it (or a
+ * stripped install) must still let the rest of `accounts` work, so the command
+ * reports `refresh_expiry_unavailable` instead of failing at import time.
+ */
+async function loadRefreshAccountExpiry() {
+    try {
+        const module = await import('../pipeline/credential-source.js');
+        const worker = module.refreshAccountExpiry;
+        return typeof worker === 'function' ? worker : null;
+    }
+    catch {
+        return null;
+    }
+}
 export function accountsPositionals(argv) {
     const out = [];
     for (let index = 1; index < argv.length; index += 1) {
@@ -63,6 +81,19 @@ export function validateAccountsCommand(argv) {
     if (subcommand === 'import' && !positionals[0] && readOptionValue(argv, '--file') === undefined && !argv.includes('--stdin')) {
         throw new CliUsageError('accounts import requires a file path or --stdin');
     }
+    if (subcommand === 'refresh-expiry') {
+        for (const option of ['--limit', '--concurrency']) {
+            const value = readOptionValue(argv, option);
+            if (value === undefined)
+                continue;
+            if (!/^\d+$/.test(value)) {
+                throw new CliUsageError(`accounts refresh-expiry ${option} must be a non-negative integer`);
+            }
+        }
+        if (Number(readOptionValue(argv, '--concurrency') ?? 3) < 1) {
+            throw new CliUsageError('accounts refresh-expiry --concurrency must be a positive integer');
+        }
+    }
     if (['disable', 'enable', 'expire'].includes(subcommand)) {
         const id = readOptionValue(argv, '--id');
         if (id !== undefined) {
@@ -82,24 +113,38 @@ function renderStatsHuman(stats) {
     const lines = [
         `account pool: ${stats.total} total, ${stats.active} active`,
         `  retired: ${stats.disabled} disabled, ${stats.expired} expired, ${stats.invalid} invalid`,
-        `  expiring within 7 days: ${stats.expiring_soon}`
+        `  expiring within 7 days: ${stats.expiring_soon}`,
+        `  expiry unknown: ${stats.expiry_unknown}`
     ];
     for (const brand of stats.by_brand) {
         lines.push(`  ${brandLabel(brand.brand).padEnd(8)} total=${String(brand.total).padStart(3)} active=${String(brand.active).padStart(3)}` +
-            ` disabled=${brand.disabled} expired=${brand.expired} invalid=${brand.invalid}`);
+            ` disabled=${brand.disabled} expired=${brand.expired} invalid=${brand.invalid} unknown=${brand.expiry_unknown}`);
     }
     lines.push(`  db: ${stats.db_path}`);
     return `${lines.join('\n')}\n`;
 }
-function renderListHuman(rows) {
+function renderListHuman(rows, hiddenRetired = 0) {
+    const footer = hiddenRetired > 0 ? `${hiddenRetired} retired row(s) hidden; use --all to show them\n` : '';
     if (rows.length === 0)
-        return 'account pool: no matching accounts\n';
+        return footer || 'account pool: no matching accounts\n';
     const lines = ['brand     account        status    expires     uses  ok/fail  note'];
     for (const row of rows) {
         lines.push(`${row.brand.padEnd(9)} ${row.account_masked.padEnd(14)} ${row.status.padEnd(9)} ` +
             `${(row.expires_at || '-').padEnd(11)} ${String(row.use_count).padStart(4)}  ` +
             `${row.success_count}/${row.fail_count}`.padEnd(8) + `  ${row.status_reason || row.note}`);
     }
+    // A sweep that retires an expired row hides it from the default view without
+    // a trace, which reads as "the pool lost accounts". Say how many are hidden
+    // and how to see them. English, like the rest of this table and the command's
+    // operator messages.
+    return `${lines.join('\n')}\n${footer}`;
+}
+function renderRefreshLine(event) {
+    return `${event.brand.padEnd(9)} ${event.account_masked.padEnd(14)} ${(event.expires_at || '-').padEnd(11)} ${event.status}${event.error ? `  ${event.error}` : ''}`;
+}
+function renderRefreshHuman(rows, result) {
+    const lines = rows.map(renderRefreshLine);
+    lines.push(`checked=${result.checked} updated=${result.updated} expired=${result.expired} failed=${result.failed}`);
     return `${lines.join('\n')}\n`;
 }
 export function accountsTemplate() {
@@ -114,6 +159,58 @@ export function accountsTemplate() {
     }));
     return stringifyCsv(example);
 }
+/**
+ * `accounts refresh-expiry`: log in to pool accounts to learn their real
+ * membership date.
+ *
+ * The worker (brand-specific login, membership-date parsing, retries) lives in
+ * the pipeline; this function parses the flags, supplies the store and renders
+ * the result. Without the worker — an install whose dist predates it — the
+ * command refuses instead of pretending it checked anything.
+ */
+async function runRefreshExpiry(argv, context) {
+    const worker = context.refreshExpiry === null
+        ? null
+        : context.refreshExpiry ?? await loadRefreshAccountExpiry();
+    if (!worker) {
+        context.io.writeStdout(jsonLine({ ok: false, error: 'refresh_expiry_unavailable' }));
+        context.io.writeStderr('accounts refresh-expiry: the installed build has no expiry refresh worker\n');
+        return 1;
+    }
+    const limit = Number(readOptionValue(argv, '--limit') ?? 0);
+    const concurrency = Number(readOptionValue(argv, '--concurrency') ?? 3);
+    const store = context.store ?? new AccountStore({ env: context.env, now: context.now });
+    const ownsStore = !context.store;
+    try {
+        let streamed = 0;
+        const result = await worker({
+            brand: readOptionValue(argv, '--brand'),
+            limit: Number.isFinite(limit) ? Math.max(0, Math.trunc(limit)) : 0,
+            concurrency: Number.isFinite(concurrency) ? Math.max(1, Math.trunc(concurrency)) : 3,
+            env: context.env,
+            store,
+            now: context.now,
+            // A refresh logs in to every account, which takes minutes per brand; the
+            // human view prints each outcome as it lands instead of going silent.
+            onProgress: wantsHuman(argv)
+                ? (event) => {
+                    context.io.writeStdout(`${renderRefreshLine(event)}\n`);
+                    streamed += 1;
+                }
+                : undefined
+        });
+        // Any result the worker did not stream (or a worker version that never
+        // calls onProgress) is still printed once, so human and JSON output cover
+        // exactly the same accounts.
+        const remaining = result.results.slice(streamed);
+        context.io.writeStdout(wantsHuman(argv) ? renderRefreshHuman(remaining, result) : jsonLine(result));
+        return result.failed > 0 ? 1 : 0;
+    }
+    finally {
+        if (ownsStore)
+            store.close();
+    }
+}
 export async function runAccountsCommand(argv, context) {
     const subcommand = argv[1];
     // The template is a static document: it must work before the pool exists and
@@ -122,6 +219,9 @@ export async function runAccountsCommand(argv, context) {
         context.io.writeStdout(accountsTemplate());
         return 0;
     }
+    if (subcommand === 'refresh-expiry') {
+        return await runRefreshExpiry(argv, context);
+    }
     const dryRun = subcommand === 'import' && argv.includes('--dry-run');
     // A preview must not write: the store's getters sweep expired rows, so even
     // opening it read-write would mutate the pool before showing the plan.
@@ -164,7 +264,23 @@ export async function runAccountsCommand(argv, context) {
                 query: readOptionValue(argv, '--query'),
                 limit
             });
-            context.io.writeStdout(wantsHuman(argv) ? renderListHuman(rows) : jsonLine({ ok: true, count: rows.length, accounts: rows }));
+            if (wantsHuman(argv)) {
+                // The default view hides every soft-deleted row, so an expiry retirement
+                // would look like an account that vanished. Count what the filter hid;
+                // `--all` and a retired-status filter already show those rows.
+                const hiddenRetired = includeDeleted
+                    ? 0
+                    : store.list({
+                        brand: readOptionValue(argv, '--brand'),
+                        status: 'all',
+                        includeDeleted: true,
+                        query: readOptionValue(argv, '--query')
+                    }).filter((row) => row.deleted).length;
+                context.io.writeStdout(renderListHuman(rows, hiddenRetired));
+            }
+            else {
+                context.io.writeStdout(jsonLine({ ok: true, count: rows.length, accounts: rows }));
+            }
             return 0;
         }
         if (subcommand === 'import') {

package/dist/cli/output.js

@@ -18,7 +18,7 @@ Usage:
 
 Commands:
   profile show|save|summary
-  accounts import|list|stats|snapshot|disable|enable|expire|export|template
+  accounts import|list|stats|snapshot|disable|enable|expire|refresh-expiry|export|template
   doctor
   artifacts latest|list|preview
   run

package/dist/config/profile.js

@@ -87,19 +87,21 @@ export function normalizeOfficialSources(sources) {
             mode: 'credential',
             official_site: String(config.official_site ?? '').trim() || brandSite(brand),
             enabled: config.enabled !== false,
-            // 4 / 2 is the documented scheduled-run default for every row, so a
-            // credential row that never set rounds behaves like the shipped one.
-            max_iterations: wasCredential ? positiveInteger(config.max_iterations, 4) : 4,
-            plateau_limit: wasCredential ? positiveInteger(config.plateau_limit, 2) : 2
+            // A round is now one cursor step over the fixed area list (one region by
+            // default), not a full sweep of every region. 200 / 50 preserves roughly
+            // the work the old 4 full sweeps did and matches the early-stop rule:
+            // 50 consecutive rounds with no genuinely new node.
+            max_iterations: wasCredential ? positiveInteger(config.max_iterations, 200) : 200,
+            plateau_limit: 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))
         };
         if (!wasCredential) {
             // A legacy URL row's caps describe a different operation; start the
-            // route-loop flow at the documented scheduled-run default instead.
-            // 20 dry rounds meant 20 URL fetches; here each round is one request per
-            // route per platform, so the stored value would idle for minutes. A floor
+            // 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.
-            normalized.max_iterations = 4;
-            normalized.plateau_limit = 2;
+            normalized.max_iterations = 200;
+            normalized.plateau_limit = 50;
             delete normalized.min_iterations;
         }
         for (const field of OBSOLETE_SOURCE_FIELDS)
@@ -111,6 +113,33 @@ export function normalizeOfficialSources(sources) {
 function state(value) {
     return String(value ?? '').trim() ? 'set' : 'missing';
 }
+/**
+ * Crawl egress defaults, surfaced so the settings drawer can render them.
+ *
+ * `proxy` is the product default: the crawl goes through the upstream proxy and
+ * drops to direct only when the proxy is not listening. `auto` starts direct
+ * and pins the proxy on the first blocked response; `direct` never proxies.
+ * The pipeline reads the same values from the environment, which the
+ * orchestrator and the Electron backend env build from this section.
+ */
+export function normalizeNetworkSection(value) {
+    const raw = (value && typeof value === 'object' ? value : {});
+    const mode = String(raw.proxy_mode ?? 'proxy').trim().toLowerCase();
+    return {
+        ...raw,
+        proxy_mode: ['proxy', 'direct', 'auto'].includes(mode) ? mode : 'proxy',
+        proxy_url: String(raw.proxy_url ?? 'http://127.0.0.1:7897').trim() || 'http://127.0.0.1:7897'
+    };
+}
+/** Map the profile's [network] section onto the env the pipeline reads. */
+export function networkEnv(section, base = {}) {
+    const network = normalizeNetworkSection(section);
+    return {
+        ...base,
+        VPN_AUTOMATION_PROXY_MODE: network.proxy_mode,
+        VPN_AUTOMATION_UPSTREAM_PROXY: network.proxy_url
+    };
+}
 function readProfile(profilePath) {
     if (!fs.existsSync(profilePath)) {
         return {};
@@ -178,6 +207,7 @@ export function profilePayload(projectRoot, env = process.env) {
     return {
         ...raw,
         sources: normalizeOfficialSources((raw.sources ?? {})),
+        network: normalizeNetworkSection(raw.network),
         paths,
         workspace: paths
     };
@@ -189,6 +219,7 @@ export function saveProfilePayload(projectRoot, payload, env = process.env) {
     delete persisted.paths;
     delete persisted.workspace;
     persisted.sources = normalizeOfficialSources((persisted.sources ?? {}));
+    persisted.network = normalizeNetworkSection(persisted.network);
     fs.writeFileSync(profilePath, stringify(persisted), 'utf8');
     return profilePayload(projectRoot, env);
 }