@swimmingliu/autovpn 1.8.0 → 2.0.2

package/dist/artifacts/list.js

@@ -2,11 +2,24 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { safeDeployment, redactText } from '../runtime/redaction.js';
 import { resolveArtifactsRoot } from '../runtime/paths.js';
+function isReport(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
 function loadJson(filePath) {
     if (!fs.existsSync(filePath)) {
         return {};
     }
-    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    // Reports are external, crash-interruptible files. Invalid metadata must
+    // stay unknown rather than preventing the whole workspace from loading.
+    try {
+        const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        if (isReport(value))
+            return value;
+    }
+    catch {
+        return { error: 'Artifact report is unreadable', metadata_unreadable: true };
+    }
+    return { error: 'Artifact report is invalid', metadata_unreadable: true };
 }
 function countNonEmptyLines(filePath) {
     if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
@@ -108,13 +121,13 @@ function isArtifactDir(artifactDir) {
 export function artifactList(projectRoot, env = process.env) {
     const artifactsRoot = resolveArtifactsRoot(projectRoot, env);
     if (!fs.existsSync(artifactsRoot)) {
-        return { ok: true, items: [] };
+        return { ok: true, items: [], activity: [] };
     }
-    const items = fs.readdirSync(artifactsRoot)
+    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)
-        .slice(0, 20)
+        .sort((left, right) => fs.statSync(right).mtimeMs - fs.statSync(left).mtimeMs);
+    const items = directories.slice(0, 20)
         .map((artifactDir) => {
         const report = loadJson(path.join(artifactDir, 'pipeline_report.json'));
         const stageStatus = (report.stage_status ?? {});
@@ -130,5 +143,34 @@ export function artifactList(projectRoot, env = process.env) {
             updated_at: new Date(fs.statSync(artifactDir).mtimeMs).toISOString().replace('Z', '')
         };
     });
-    return { ok: true, items };
+    // Retry choices stay bounded; the calendar aggregates every retained run,
+    // otherwise a busy day would silently erase most of the year's history.
+    const days = new Map();
+    let activityUnavailable = 0;
+    for (const directory of directories) {
+        try {
+            // Final output is authoritative. Availability is an intermediate stage
+            // and can contain nodes that postprocessing later removes or rejects.
+            const finalFileCount = countNonEmptyLines(path.join(directory, 'vpn_node_emoji.txt'));
+            const report = loadJson(path.join(directory, 'pipeline_report.json'));
+            const reported = isReport(report.counts) ? report.counts.final_links : undefined;
+            const value = finalFileCount ?? (typeof reported === 'number' && Number.isFinite(reported) && reported >= 0 ? reported : undefined);
+            if (value === undefined) {
+                activityUnavailable += 1;
+                continue;
+            }
+            const stamp = path.basename(directory).slice(0, 8);
+            const date = stamp.slice(0, 4) + '-' + stamp.slice(4, 6) + '-' + stamp.slice(6, 8);
+            const day = days.get(date) ?? { date, nodes: 0, runs: 0 };
+            day.nodes += Math.floor(value);
+            day.runs += 1;
+            days.set(date, day);
+        }
+        catch {
+            // One unreadable old report must not prevent profile/state loading.
+            // Preserve the missing-data count instead of claiming a zero output.
+            activityUnavailable += 1;
+        }
+    }
+    return { ok: true, items, activityUnavailable, activity: [...days.values()].sort((left, right) => left.date.localeCompare(right.date)) };
 }

package/dist/cli/accounts-commands.js

@@ -0,0 +1,304 @@
+/**
+ * `autovpn accounts …` — the pool's operator surface.
+ *
+ * Every listing is masked. Only `export` writes real credentials, and it says
+ * so on stderr, so a terminal scrollback or a pasted log never carries them by
+ * accident.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { AccountStore } from '../pool/account-store.js';
+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'];
+/** 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'
+]);
+export function accountsPositionals(argv) {
+    const out = [];
+    for (let index = 1; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (VALUE_OPTIONS.has(value)) {
+            index += 1;
+            continue;
+        }
+        if (value.startsWith('--'))
+            continue;
+        out.push(value);
+    }
+    // argv[1] is the subcommand itself.
+    return out.slice(1);
+}
+function jsonLine(payload) {
+    return `${JSON.stringify(payload)}\n`;
+}
+function wantsHuman(argv) {
+    return readOptionValue(argv, '--output') === 'human';
+}
+export function validateAccountsCommand(argv) {
+    const subcommand = argv[1] ?? '';
+    if (!ACCOUNTS_SUBCOMMANDS.includes(subcommand)) {
+        throw new CliUsageError(`accounts subcommand must be one of: ${ACCOUNTS_SUBCOMMANDS.join(', ')}`);
+    }
+    const format = readOptionValue(argv, '--format');
+    if (format !== undefined && !['auto', 'csv', 'legacy'].includes(format)) {
+        throw new CliUsageError('accounts import --format must be one of: auto, csv, legacy');
+    }
+    const output = readOptionValue(argv, '--output');
+    if (output !== undefined && !['human', 'jsonl', 'json'].includes(output)) {
+        throw new CliUsageError('accounts --output must be one of: human, jsonl');
+    }
+    const status = readOptionValue(argv, '--status');
+    if (status !== undefined && !['active', 'disabled', 'expired', 'invalid', 'all'].includes(status)) {
+        throw new CliUsageError('accounts --status must be one of: active, disabled, expired, invalid, all');
+    }
+    const brand = readOptionValue(argv, '--brand');
+    if (brand !== undefined && !normalizeBrand(brand)) {
+        throw new CliUsageError(`accounts --brand must be one of: ${BRANDS.map((item) => item.key).join(', ')}`);
+    }
+    const positionals = accountsPositionals(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 (['disable', 'enable', 'expire'].includes(subcommand)) {
+        const id = readOptionValue(argv, '--id');
+        if (id !== undefined) {
+            if (!/^\d+$/.test(id) || Number(id) < 1)
+                throw new CliUsageError('accounts --id must be a positive integer');
+            return;
+        }
+        if (!positionals[0] || !positionals[1]) {
+            throw new CliUsageError(`accounts ${subcommand} requires <brand> <account> or --id`);
+        }
+        if (!normalizeBrand(positionals[0])) {
+            throw new CliUsageError(`unknown brand: ${positionals[0]}`);
+        }
+    }
+}
+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}`
+    ];
+    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}`);
+    }
+    lines.push(`  db: ${stats.db_path}`);
+    return `${lines.join('\n')}\n`;
+}
+function renderListHuman(rows) {
+    if (rows.length === 0)
+        return '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}`);
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function accountsTemplate() {
+    const example = BRANDS.map((brand) => ({
+        brand: brand.key,
+        account: 'ACCOUNT',
+        password: 'PASSWORD',
+        official_site: brand.official_site,
+        expires_at: '',
+        status: 'active',
+        note: ''
+    }));
+    return stringifyCsv(example);
+}
+export async function runAccountsCommand(argv, context) {
+    const subcommand = argv[1];
+    // The template is a static document: it must work before the pool exists and
+    // on a host where the database path is not writable, so it never opens a store.
+    if (subcommand === 'template') {
+        context.io.writeStdout(accountsTemplate());
+        return 0;
+    }
+    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.
+    const store = context.store ?? new AccountStore({ env: context.env, now: context.now, readOnly: dryRun });
+    const ownsStore = !context.store;
+    try {
+        if (subcommand === 'stats') {
+            const stats = store.stats();
+            context.io.writeStdout(wantsHuman(argv) ? renderStatsHuman(stats) : jsonLine(stats));
+            return 0;
+        }
+        if (subcommand === 'snapshot') {
+            const accounts = store.list({ status: 'all', includeDeleted: true });
+            const payload = { ok: true, stats: store.stats(), accounts };
+            context.io.writeStdout(jsonLine(payload));
+            return 0;
+        }
+        if (subcommand === 'list') {
+            const limitRaw = readOptionValue(argv, '--limit');
+            let limit;
+            if (limitRaw !== undefined) {
+                const parsed = Number(limitRaw);
+                if (!Number.isFinite(parsed) || parsed < 1) {
+                    throw new CliUsageError('accounts list --limit must be a positive integer');
+                }
+                limit = Math.trunc(parsed);
+            }
+            const statusRaw = readOptionValue(argv, '--status');
+            // Every retired row is soft-deleted, so filtering by a retired status
+            // without including deleted rows would always answer with nothing.
+            const retiredFilter = statusRaw !== undefined && RETIRED_STATUSES.includes(statusRaw);
+            const includeDeleted = argv.includes('--all') || retiredFilter;
+            // `--all` means "including retired rows", so it must not be combined with
+            // the active-only default: that pair returned nothing at all.
+            const status = (statusRaw ?? (includeDeleted ? 'all' : 'active'));
+            const rows = store.list({
+                brand: readOptionValue(argv, '--brand'),
+                status,
+                includeDeleted,
+                query: readOptionValue(argv, '--query'),
+                limit
+            });
+            context.io.writeStdout(wantsHuman(argv) ? renderListHuman(rows) : jsonLine({ ok: true, count: rows.length, accounts: rows }));
+            return 0;
+        }
+        if (subcommand === 'import') {
+            const positionals = accountsPositionals(argv);
+            const target = readOptionValue(argv, '--file') ?? positionals[0];
+            let text;
+            let fileName;
+            if (argv.includes('--stdin')) {
+                if (!context.readStdin)
+                    throw new CliUsageError('accounts import --stdin is unavailable in this context');
+                text = await context.readStdin();
+                fileName = 'upload.csv';
+            }
+            else {
+                const filePath = path.resolve(context.cwd, target);
+                if (!fs.existsSync(filePath)) {
+                    throw new CliUsageError(`accounts import: file not found: ${filePath}`);
+                }
+                text = fs.readFileSync(filePath, 'utf8');
+                fileName = path.basename(filePath);
+            }
+            const format = (readOptionValue(argv, '--format') ?? 'auto');
+            const parsed = parseAccountFile(text, format);
+            if (parsed.records.length === 0) {
+                context.io.writeStdout(jsonLine({ ok: false, imported: 0, issues: parsed.issues }));
+                context.io.writeStderr(`accounts import: no usable rows in ${fileName}\n`);
+                return 1;
+            }
+            const outcome = dryRun
+                ? { ...store.importRecords(parsed.records), dry_run: true }
+                : store.importRecords(parsed.records);
+            const payload = {
+                ok: true,
+                dry_run: dryRun,
+                file: fileName,
+                parsed: parsed.records.length,
+                ...outcome,
+                issues: parsed.issues,
+                stats: store.stats()
+            };
+            if (wantsHuman(argv)) {
+                const lines = [
+                    `${dryRun ? 'would import' : 'imported'} ${parsed.records.length} rows from ${fileName}`,
+                    `  new=${outcome.inserted} updated=${outcome.updated} rotated=${outcome.rotated} revived=${outcome.revived} unchanged=${outcome.unchanged} skipped=${outcome.skipped}`
+                ];
+                for (const issue of parsed.issues)
+                    lines.push(`  line ${issue.line}: ${issue.message}`);
+                context.io.writeStdout(`${lines.join('\n')}\n`);
+            }
+            else {
+                context.io.writeStdout(jsonLine(payload));
+            }
+            return parsed.issues.length > 0 && !argv.includes('--allow-issues') ? 1 : 0;
+        }
+        if (subcommand === 'export') {
+            const includeDeleted = argv.includes('--all');
+            const records = store.exportRecords(includeDeleted);
+            const text = stringifyCsv(records);
+            const target = readOptionValue(argv, '--file') ?? accountsPositionals(argv)[0];
+            if (target) {
+                const filePath = path.resolve(context.cwd, target);
+                // `mode` only applies when the file is created. An existing backup.csv
+                // from an editor or `touch` stays world-readable unless it is tightened
+                // here, and this file is the one artifact that holds plaintext credentials.
+                const existed = fs.existsSync(filePath);
+                fs.writeFileSync(filePath, text, { mode: 0o600 });
+                if (existed) {
+                    try {
+                        fs.chmodSync(filePath, 0o600);
+                    }
+                    catch {
+                        // A filesystem without POSIX modes still gets the file written.
+                    }
+                }
+                context.io.writeStdout(jsonLine({ ok: true, file: filePath, rows: records.length }));
+            }
+            else {
+                context.io.writeStdout(text);
+            }
+            context.io.writeStderr('accounts export: output contains plaintext credentials\n');
+            return 0;
+        }
+        const [brandRaw, account] = accountsPositionals(argv);
+        const idRaw = readOptionValue(argv, '--id');
+        const id = idRaw === undefined ? null : Number(idRaw);
+        if (subcommand === 'disable') {
+            const ok = id === null
+                ? store.disable(brandRaw, account, readOptionValue(argv, '--reason') ?? 'disabled by operator')
+                : store.disableById(id, readOptionValue(argv, '--reason') ?? 'disabled by operator');
+            context.io.writeStdout(jsonLine({ ok, ...(id === null ? { brand: normalizeBrand(brandRaw) } : { id }), action: 'disabled' }));
+            return ok ? 0 : 1;
+        }
+        if (subcommand === 'enable') {
+            const ok = id === null ? store.enable(brandRaw, account) : store.enableById(id);
+            if (ok === null) {
+                // The row exists but its membership date has passed: reporting success
+                // would be undone by the next read, so say why and exit non-zero.
+                context.io.writeStdout(jsonLine({
+                    ok: false,
+                    error: 'membership_expired',
+                    ...(id === null ? { brand: normalizeBrand(brandRaw) } : { id }),
+                    action: 'enabled'
+                }));
+                context.io.writeStderr('accounts enable: the membership date has passed; set a new one with `accounts expire --date` first\n');
+                return 1;
+            }
+            context.io.writeStdout(jsonLine({ ok, ...(id === null ? { brand: normalizeBrand(brandRaw) } : { id }), action: 'enabled' }));
+            return ok ? 0 : 1;
+        }
+        if (subcommand === 'expire') {
+            const date = readOptionValue(argv, '--date');
+            // Without --date the old code wrote '' and reported success, which erased
+            // a known expiry and left the row permanently un-expirable. `--clear` is
+            // the explicit way to say "no date known".
+            if (date === undefined && !argv.includes('--clear')) {
+                throw new CliUsageError('accounts expire requires --date YYYY-MM-DD (or --clear)');
+            }
+            const target = argv.includes('--clear') ? '' : String(date);
+            const ok = id === null
+                ? store.setExpiry(brandRaw, account, target)
+                : store.setExpiryById(id, target);
+            if (ok === null) {
+                context.io.writeStdout(jsonLine({ ok: false, error: 'invalid_date', ...(id === null ? { brand: normalizeBrand(brandRaw) } : { id }), action: 'expiry_set' }));
+                context.io.writeStderr(`accounts expire: --date must be YYYY-MM-DD, got ${target}\n`);
+                return 1;
+            }
+            context.io.writeStdout(jsonLine({ ok, ...(id === null ? { brand: normalizeBrand(brandRaw) } : { id }), expires_at: target, action: 'expiry_set' }));
+            return ok ? 0 : 1;
+        }
+        throw new CliUsageError(`unknown accounts subcommand: ${subcommand}`);
+    }
+    finally {
+        if (ownsStore)
+            store.close();
+    }
+}
+export { CSV_COLUMNS };

package/dist/cli/commands/index.js

@@ -1,7 +1,9 @@
+import { validateAccountsCommand } from '../accounts-commands.js';
 import { CliUsageError } from '../errors.js';
 import { readOptionValue } from '../global-options.js';
 const TOP_LEVEL_COMMANDS = new Set([
     'profile',
+    'accounts',
     'doctor',
     'artifacts',
     'run',
@@ -90,6 +92,10 @@ export function validateCommand(argv) {
     if (command === 'serve') {
         return;
     }
+    if (command === 'accounts') {
+        validateAccountsCommand(argv);
+        return;
+    }
     if (command === 'profile') {
         const subcommand = argv[1] ?? '';
         if (!PROFILE_SUBCOMMANDS.has(subcommand)) {

package/dist/cli/native-commands.js

@@ -8,6 +8,7 @@ import { publicStartedPayload, startDetachedResume, startDetachedRetry, startDet
 import { followLog } from '../jobs/logs.js';
 import { latestJobId, listJobs, loadJob, publicJobPayload, singleActiveJobId, tailLog } from '../jobs/read.js';
 import { readOptionValue, resolveProjectRoot } from '../runtime/paths.js';
+import { runAccountsCommand } from './accounts-commands.js';
 function jsonLine(payload) {
     return `${JSON.stringify(payload)}\n`;
 }
@@ -94,6 +95,15 @@ export async function runNativeCommand(argv, context) {
             return 0;
         }
     }
+    if (command === 'accounts') {
+        return await runAccountsCommand(argv, {
+            cwd: context.cwd,
+            env: context.env,
+            io: context.io,
+            readStdin: context.readStdin,
+            now: context.now ? () => new Date(context.now()) : undefined
+        });
+    }
     if (command === 'artifacts') {
         const subcommand = argv[1];
         if (subcommand === 'latest') {

package/dist/cli/output.js

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

package/dist/config/profile.js

@@ -1,8 +1,113 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { parse, stringify } from '@iarna/toml';
+import { brandSite, normalizeBrand } from '../pool/brands.js';
 import { resolveArtifactsRoot, resolveProfilePath } from '../runtime/paths.js';
-const DEFAULT_SOURCE_ORDER = ['leiting', 'heidong', 'mifeng', 'xuanfeng-area', 'xuanfeng-all-area'];
+/**
+ * One entry per vendor.
+ *
+ * `xuanfeng-area` / `xuanfeng-all-area` were two profile rows for one brand's
+ * two route tables. The pipeline now fetches every table `/api/eversion`
+ * advertises and merges them, so a second row would only duplicate the work.
+ * Old profiles keep working: `normalizeBrand` maps both names to `xuanfeng`.
+ */
+const DEFAULT_SOURCE_ORDER = ['leiting', 'heidong', 'mifeng', 'xuanfeng'];
+/** Profile rows that name the same vendor twice, folded into one. */
+const LEGACY_SOURCE_ALIASES = {
+    'xuanfeng-area': 'xuanfeng',
+    'xuanfeng-all-area': 'xuanfeng',
+    xuanfeng1: 'xuanfeng',
+    xuanfeng2: 'xuanfeng'
+};
+/**
+ * Fold legacy split rows into their canonical name.
+ *
+ * A row spelled with the canonical name always wins: an alias
+ * (`xuanfeng-area`, `leiting_ios`) is the older shape, and letting it win would
+ * overwrite the configured site or round budget with a stale copy. Two aliases
+ * collapse to the first one listed. `enabled` is merged with OR either way, so
+ * a disabled duplicate can never switch off a live source.
+ */
+export function collapseLegacySources(sources) {
+    const out = {};
+    for (const [name, config] of Object.entries(sources ?? {})) {
+        const canonical = LEGACY_SOURCE_ALIASES[name] ?? name;
+        const existing = out[canonical];
+        if (!existing) {
+            out[canonical] = { ...config };
+            continue;
+        }
+        out[canonical] = {
+            ...existing,
+            ...(canonical === name ? config : {}),
+            enabled: Boolean(existing.enabled ?? true) || Boolean(config.enabled ?? true)
+        };
+    }
+    return out;
+}
+const OFFICIAL_SOURCE_KEYS = new Set(['leiting', 'heidong', 'mifeng', 'xuanfeng']);
+/**
+ * Fields the drawer no longer edits.
+ *
+ * `min_iterations` and `platforms` are deliberately absent: both are still read
+ * by the round policy and by `resolveCredentialPlatforms`, so a pinned debug
+ * profile that sets them must keep working. Dropping them here would silently
+ * change how many rounds run.
+ */
+const OBSOLETE_SOURCE_FIELDS = [
+    'url', 'key', 'account', 'password', 'platform',
+    'use_random_area', 'area_min', 'area_max',
+    'resume_from_iteration', 'failure_limit'
+];
+function positiveInteger(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 1 ? Math.trunc(parsed) : fallback;
+}
+/**
+ * Migrate the four vendor rows to the final input contract: official site only.
+ *
+ * Credentials live in the account pool and the control-plane key is discovered
+ * from the APK. Both client channels run for every row, so a stored `platform`
+ * is no longer a choice. URL-mode round counts are not carried over: 3000 URL
+ * iterations meant 3000 requests, while 3000 credential rounds would mean
+ * 3000 requests per route per platform.
+ */
+export function normalizeOfficialSources(sources) {
+    const collapsed = collapseLegacySources(sources);
+    const out = {};
+    for (const [name, config] of Object.entries(collapsed)) {
+        const brand = normalizeBrand(name);
+        if (!brand || !OFFICIAL_SOURCE_KEYS.has(brand) || !config || typeof config !== 'object') {
+            out[name] = config;
+            continue;
+        }
+        const wasCredential = config.mode === 'credential';
+        const normalized = {
+            ...config,
+            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
+        };
+        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
+            // carried over from URL mode is the same mismatch and is dropped with it.
+            normalized.max_iterations = 4;
+            normalized.plateau_limit = 2;
+            delete normalized.min_iterations;
+        }
+        for (const field of OBSOLETE_SOURCE_FIELDS)
+            delete normalized[field];
+        out[brand] = normalized;
+    }
+    return out;
+}
 function state(value) {
     return String(value ?? '').trim() ? 'set' : 'missing';
 }
@@ -16,19 +121,25 @@ export function profileSummary(projectRoot, env = process.env) {
     const profilePath = resolveProfilePath(projectRoot, env);
     const stateRoot = path.dirname(profilePath);
     const payload = readProfile(profilePath);
-    const rawSources = (payload.sources ?? {});
+    const rawSources = normalizeOfficialSources((payload.sources ?? {}));
     const sourceNames = [
         ...DEFAULT_SOURCE_ORDER,
         ...Object.keys(rawSources).filter((name) => !DEFAULT_SOURCE_ORDER.includes(name)).sort()
     ];
     const sources = Object.fromEntries(sourceNames.map((name) => {
         const config = rawSources[name] ?? {};
+        const mode = config?.mode === 'credential' ? 'credential' : 'url';
         return [
             name,
             {
                 enabled: Boolean(config?.enabled ?? true),
-                url: state(config?.url),
-                key: state(config?.key)
+                mode,
+                url: mode === 'url' ? state(config?.url) : state(config?.official_site ?? config?.apk_url),
+                // A credential source has no control-plane key in the profile; the key
+                // is discovered from the APK, so the check must not require one.
+                key: mode === 'url' ? state(config?.key) : state(config?.key ?? 'discovered'),
+                account: mode === 'credential' ? 'pool' : state(config?.account),
+                platform: mode === 'credential' ? 'android+ios' : String(config?.platform ?? 'android')
             }
         ];
     }));
@@ -63,8 +174,10 @@ export function profilePayload(projectRoot, env = process.env) {
         state_root: path.dirname(profilePath),
         profile_path: profilePath
     };
+    const raw = readProfile(profilePath);
     return {
-        ...readProfile(profilePath),
+        ...raw,
+        sources: normalizeOfficialSources((raw.sources ?? {})),
         paths,
         workspace: paths
     };
@@ -75,6 +188,7 @@ export function saveProfilePayload(projectRoot, payload, env = process.env) {
     const persisted = { ...payload };
     delete persisted.paths;
     delete persisted.workspace;
+    persisted.sources = normalizeOfficialSources((persisted.sources ?? {}));
     fs.writeFileSync(profilePath, stringify(persisted), 'utf8');
     return profilePayload(projectRoot, env);
 }

package/dist/events/schema.js

@@ -10,6 +10,8 @@ const KNOWN_EVENT_TYPES = new Set([
     'extract_iteration',
     'extract_source_completed',
     'extract_source_failed',
+    'extract_platform_started',
+    'extract_platform_completed',
     'speedtest_runtime',
     'speedtest_probe_result',
     'speedtest_selected',