@swimmingliu/autovpn 1.4.0

package/README.md

@@ -0,0 +1,102 @@
+# AutoVPN CLI
+
+Node-first npm CLI for AutoVPN headless and Agent workflows.
+
+## Usage
+
+```bash
+npx -y @swimmingliu/autovpn@1.4.0 doctor --project-root . --output json
+npm install -g @swimmingliu/autovpn@1.4.0
+autovpn run --project-root . --skip-deploy --skip-verify --output jsonl
+```
+
+GitHub Release tarballs remain available for pinned/offline installs:
+
+```bash
+npm install -g https://github.com/SwimmingLiu/auto-vpn/releases/download/v<version>/swimmingliu-autovpn-<version>.tgz
+```
+
+For Agent-friendly JSONL output, prefer foreground runs:
+
+```bash
+autovpn doctor --project-root . --output json
+autovpn run --project-root . --skip-deploy --skip-verify --output jsonl
+autovpn artifacts latest --project-root .
+```
+
+## Runtime Shape
+
+The CLI is currently Node-first with explicit Python rollback:
+
+- Node.js handles `--help`, `--version`, argument validation, `doctor --output json`, `profile summary --json`, `artifacts latest/list/preview`, `status --json`, `logs`, read-only `jobs` commands, and detached job management.
+- Node is the default backend for pipeline actions. Detached run/resume/retry workers spawn the Node CLI worker.
+- Plain Cloudflare Pages deploy, primary blocked-project fallback, share-project `SUB` sync, share-project fallback, custom-domain binding, custom-domain DNS upsert, and verify are Node-native. Python backend and stage fallback remain available for rollback.
+
+Node-orchestrated foreground run:
+
+```bash
+autovpn run --project-root . --output jsonl
+```
+
+Current Node backend notes:
+
+- Detached job management runs in Node for `run --detach`, `jobs resume --detach`, and `jobs retry --detach`; detached run/resume/retry workers also use the Node CLI worker.
+- Non-detached `retry-stage` runs through the Node backend for retryable artifact stages from `speedtest` through `verify`; non-detached `resume pipeline`, `resume speedtest`, and `run --resume-latest` continue existing sessions through the Node backend.
+- Add `--skip-deploy --skip-verify` when you want an offline Node pipeline check.
+- Plain Node foreground deploy/verify runs use Node for Wrangler deploy, primary blocked-project fallback, share-project sync/fallback, custom-domain binding, custom-domain DNS upsert, and verify.
+- Deploy and verify can be rolled back with `AUTOVPN_STAGE_BACKEND_DEPLOY=python` and `AUTOVPN_STAGE_BACKEND_VERIFY=python`.
+- `AUTOVPN_NO_PYTHON=1` disables implicit Python backend resolution and default Python runtime stage fallback. Use it as a v3 readiness gate. Empty offline runs now complete in Node, and Node has direct HTTP speedtest and availability runtimes. Node also has opt-in Mihomo-backed paths: set `AUTOVPN_SPEEDTEST_RUNTIME=mihomo` for controller delay probing and candidate downloads through the local Mihomo proxy, and set `AUTOVPN_AVAILABILITY_RUNTIME=mihomo` to check provider availability through the same per-node proxy runtime.
+- Project `.env` is loaded before resolving profile and artifact paths. Explicit process environment values still win over `.env`.
+
+Fallback flags for migrated commands:
+
+```bash
+AUTOVPN_CLI_SHELL=python autovpn <args>
+AUTOVPN_BACKEND=python autovpn run --project-root . --output jsonl
+AUTOVPN_DOCTOR_BACKEND=python autovpn doctor --output json
+AUTOVPN_PROFILE_BACKEND=python autovpn profile summary --json
+AUTOVPN_ARTIFACTS_BACKEND=python autovpn artifacts latest
+```
+
+Job state, logs, stop, detached run, detached resume, and detached retry commands are Node-owned in v3 and intentionally ignore the old `AUTOVPN_JOBS_BACKEND` rollback flag.
+
+## Python Backend Resolution
+
+When a command still needs Python, the wrapper resolves the backend in this order:
+
+1. `AUTOVPN_PYTHON_CLI`
+2. PATH `autovpn`, accepted only when `autovpn --version` matches this npm package version
+3. wrapper-managed Python virtual environment under `AUTOVPN_CACHE_DIR` or the user cache
+
+For Python-backed commands, the wrapper forwards argv, stdin, stdout, stderr, and exit code.
+
+## Environment
+
+- `AUTOVPN_CACHE_DIR`
+- `AUTOVPN_WHEEL_URL`
+- `AUTOVPN_PYTHON_PACKAGE`
+- `AUTOVPN_PIP_INDEX_URL`
+- `AUTOVPN_PIP_EXTRA_INDEX_URL`
+- `AUTOVPN_NO_INSTALL`
+- `AUTOVPN_FORCE_INSTALL`
+- `AUTOVPN_ALLOW_VERSION_MISMATCH`
+- `AUTOVPN_PYTHON_CLI`
+- `AUTOVPN_CLI_SHELL`
+- `AUTOVPN_BACKEND`
+- `AUTOVPN_PIPELINE_BACKEND`
+- `AUTOVPN_STAGE_BACKEND_EXTRACT`
+- `AUTOVPN_STAGE_BACKEND_DEDUPE`
+- `AUTOVPN_STAGE_BACKEND_SPEEDTEST`
+- `AUTOVPN_STAGE_BACKEND_AVAILABILITY`
+- `AUTOVPN_STAGE_BACKEND_POSTPROCESS`
+- `AUTOVPN_STAGE_BACKEND_RENDER`
+- `AUTOVPN_STAGE_BACKEND_OBFUSCATE`
+- `AUTOVPN_STAGE_BACKEND_DEPLOY`
+- `AUTOVPN_STAGE_BACKEND_VERIFY`
+- `AUTOVPN_DOCTOR_BACKEND`
+- `AUTOVPN_PROFILE_BACKEND`
+- `AUTOVPN_ARTIFACTS_BACKEND`
+- `VPN_AUTOMATION_RUNTIME_ROOT`
+- `VPN_AUTOMATION_PROFILE_PATH`
+- `VPN_AUTOMATION_ARTIFACTS_ROOT`
+- `VPN_AUTOMATION_UPSTREAM_PROXY`

package/bin/autovpn.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import { runCliShell } from '../dist/cli/main.js';
+
+const code = await runCliShell(process.argv.slice(2));
+process.exitCode = code;

package/dist/artifacts/list.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { safeDeployment, redactText } from '../runtime/redaction.js';
+import { resolveArtifactsRoot } from '../runtime/paths.js';
+function loadJson(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+function latestArtifactDir(artifactsRoot) {
+    if (!fs.existsSync(artifactsRoot)) {
+        return '';
+    }
+    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));
+    });
+    return candidates[0] ?? '';
+}
+export function artifactLatest(projectRoot, env = process.env) {
+    const latest = latestArtifactDir(resolveArtifactsRoot(projectRoot, env));
+    if (!latest) {
+        return { ok: false, artifact_dir: '' };
+    }
+    const reportPath = path.join(latest, 'pipeline_report.json');
+    const payload = { ok: true, artifact_dir: latest };
+    if (!fs.existsSync(reportPath)) {
+        return { ...payload, run_status: '', stage_status: {}, counts: {}, source_counts: {}, deployment: {}, error: '' };
+    }
+    const report = loadJson(reportPath);
+    return {
+        ...payload,
+        run_status: report.run_status ?? '',
+        stage_status: report.stage_status ?? {},
+        counts: report.counts ?? {},
+        source_counts: report.source_counts ?? {},
+        deployment: safeDeployment((report.deployment ?? {})),
+        error: redactText(String(report.error ?? ''))
+    };
+}
+function hasNonEmptyFile(filePath) {
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile() && fs.statSync(filePath).size > 0;
+}
+function retryableStages(artifactDir, stageStatus) {
+    const stages = [];
+    if (hasNonEmptyFile(path.join(artifactDir, 'vpn_node_deduped.txt')))
+        stages.push('speedtest');
+    if (hasNonEmptyFile(path.join(artifactDir, 'vpn_node_speedtest.txt')))
+        stages.push('availability');
+    if (hasNonEmptyFile(path.join(artifactDir, 'vpn_node_availability.txt')))
+        stages.push('postprocess');
+    if (hasNonEmptyFile(path.join(artifactDir, 'vpn_node_emoji.txt')))
+        stages.push('render');
+    if (fs.existsSync(path.join(artifactDir, 'vmess_node.js')))
+        stages.push('obfuscate');
+    if (fs.existsSync(path.join(artifactDir, '_worker.js')))
+        stages.push('deploy');
+    if (stageStatus.deploy === 'success')
+        stages.push('verify');
+    return stages;
+}
+function isArtifactDir(artifactDir) {
+    if (!/^\d{8}-\d{6}$/.test(path.basename(artifactDir))) {
+        return false;
+    }
+    return fs.existsSync(path.join(artifactDir, 'pipeline_report.json')) || fs.existsSync(path.join(artifactDir, 'run.db'));
+}
+export function artifactList(projectRoot, env = process.env) {
+    const artifactsRoot = resolveArtifactsRoot(projectRoot, env);
+    if (!fs.existsSync(artifactsRoot)) {
+        return { ok: true, items: [] };
+    }
+    const items = 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)
+        .map((artifactDir) => {
+        const report = loadJson(path.join(artifactDir, 'pipeline_report.json'));
+        const stageStatus = (report.stage_status ?? {});
+        return {
+            artifact_dir: artifactDir,
+            artifact_name: path.basename(artifactDir),
+            run_status: report.run_status ?? '',
+            stage_status: stageStatus,
+            counts: report.counts ?? {},
+            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', '')
+        };
+    });
+    return { ok: true, items };
+}

package/dist/artifacts/preview.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { redactText, safeDeployment } from '../runtime/redaction.js';
+const FINAL_NODE_FILES = ['vpn_node_emoji.txt', 'vpn_node_availability.txt', 'vpn_node_speedtest.txt'];
+function formatBytes(size) {
+    if (size >= 1024 * 1024) {
+        return `${(size / 1024 / 1024).toFixed(1)} MB`;
+    }
+    if (size >= 1024) {
+        return `${Math.ceil(size / 1024)} KB`;
+    }
+    return `${size} B`;
+}
+function loadJson(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    }
+    catch {
+        return { error: `invalid ${path.basename(filePath)}` };
+    }
+}
+function fileInventory(artifactDir) {
+    return fs.readdirSync(artifactDir)
+        .map((name) => path.join(artifactDir, name))
+        .filter((item) => fs.statSync(item).isFile())
+        .map((item) => ({ name: path.basename(item), size: formatBytes(fs.statSync(item).size) }))
+        .sort((left, right) => String(left.name).localeCompare(String(right.name)));
+}
+function decodeVmessRegion(link) {
+    const value = link.trim();
+    if (!value.startsWith('vmess://')) {
+        return 'OTHER';
+    }
+    let encoded = value.slice('vmess://'.length);
+    encoded += '='.repeat((4 - (encoded.length % 4)) % 4);
+    try {
+        const payload = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
+        const match = String(payload.ps ?? '').toUpperCase().match(/\b([A-Z]{2})\b/);
+        return match ? match[1] : 'OTHER';
+    }
+    catch {
+        return 'OTHER';
+    }
+}
+function safeNodeCounts(artifactDir) {
+    const nodeSource = FINAL_NODE_FILES.find((name) => fs.existsSync(path.join(artifactDir, name))) ?? '';
+    if (!nodeSource) {
+        return { node_source: '', final_node_count: 0, regions: [] };
+    }
+    const lines = fs.readFileSync(path.join(artifactDir, nodeSource), 'utf8').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const counts = new Map();
+    for (const line of lines) {
+        const region = decodeVmessRegion(line);
+        counts.set(region, (counts.get(region) ?? 0) + 1);
+    }
+    return {
+        node_source: nodeSource,
+        final_node_count: lines.length,
+        regions: [...counts.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([region_code, count]) => ({ region_code, count }))
+    };
+}
+export function previewArtifact(artifactDir) {
+    const absolute = path.resolve(artifactDir);
+    const resolved = fs.existsSync(absolute) ? fs.realpathSync(absolute) : absolute;
+    if (!fs.existsSync(resolved) || !fs.statSync(resolved).isDirectory()) {
+        return { ok: false, artifact_dir: resolved };
+    }
+    const report = loadJson(path.join(resolved, 'pipeline_report.json'));
+    return {
+        ok: true,
+        artifact_dir: resolved,
+        run_status: report.run_status ?? '',
+        stage_status: report.stage_status ?? {},
+        counts: report.counts ?? {},
+        source_counts: report.source_counts ?? {},
+        deployment: safeDeployment((report.deployment ?? {})),
+        retry_context: report.retry_context ?? {},
+        error: redactText(String(report.error ?? '')),
+        files: fileInventory(resolved),
+        safe_node_counts: safeNodeCounts(resolved)
+    };
+}

package/dist/backend/node-backend.js

@@ -0,0 +1,194 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+import { resumeNodePipeline, retryNodePipelineStage, runNodePipeline } from '../pipeline/orchestrator.js';
+import { resolveArtifactsRoot } from '../runtime/paths.js';
+const require = createRequire(import.meta.url);
+function unsupported(method) {
+    return new Error(`Node backend ${method} is not available yet; use AUTOVPN_BACKEND=python`);
+}
+function latestIncompleteRunArtifact(projectRoot, env) {
+    const artifactsRoot = resolveArtifactsRoot(projectRoot, env);
+    if (!fs.existsSync(artifactsRoot)) {
+        return undefined;
+    }
+    const { DatabaseSync } = require('node:sqlite');
+    const candidates = fs.readdirSync(artifactsRoot, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => {
+        const artifactDir = path.join(artifactsRoot, entry.name);
+        const dbPath = path.join(artifactDir, 'run.db');
+        return { artifactDir, dbPath };
+    })
+        .filter((candidate) => fs.existsSync(candidate.dbPath))
+        .sort((left, right) => fs.statSync(right.artifactDir).mtimeMs - fs.statSync(left.artifactDir).mtimeMs);
+    for (const candidate of candidates) {
+        let db;
+        try {
+            db = new DatabaseSync(candidate.dbPath);
+            const runRow = db.prepare('SELECT status FROM runs ORDER BY run_id DESC LIMIT 1').get();
+            const runStatus = String(runRow?.status ?? '').trim();
+            if (['success', 'failed', 'stopped'].includes(runStatus)) {
+                continue;
+            }
+            const stageRows = db.prepare('SELECT stage_name, status FROM stage_events ORDER BY rowid ASC').all();
+            const stageStatus = new Map(stageRows.map((row) => [String(row.stage_name ?? ''), String(row.status ?? '')]));
+            if (stageStatus.get('verify') === 'success') {
+                continue;
+            }
+            return candidate.artifactDir;
+        }
+        catch {
+            continue;
+        }
+        finally {
+            db?.close();
+        }
+    }
+    return undefined;
+}
+function writeResumeLatestSession(artifactDir, options) {
+    const sessionDir = path.join(artifactDir, '.node-resume-latest');
+    fs.mkdirSync(sessionDir, { recursive: true });
+    fs.writeFileSync(path.join(sessionDir, 'session.json'), JSON.stringify({
+        artifact_dir: artifactDir,
+        event_log: options.eventLog ?? path.join(sessionDir, 'events.jsonl'),
+        human_log: options.humanLog ?? path.join(sessionDir, 'human.log')
+    }), 'utf8');
+    return sessionDir;
+}
+function pushEvent(queue, event) {
+    queue.events.push(event);
+    const wake = queue.wake.shift();
+    wake?.();
+}
+function finishQueue(queue, error) {
+    queue.done = true;
+    queue.error = error;
+    for (const wake of queue.wake.splice(0)) {
+        wake();
+    }
+}
+function waitForEvent(queue) {
+    return new Promise((resolve) => {
+        queue.wake.push(resolve);
+    });
+}
+export class NodeBackend {
+    kind = 'node';
+    env;
+    cwd;
+    constructor(options = {}) {
+        this.env = options.env ?? process.env;
+        this.cwd = options.cwd ?? process.cwd();
+    }
+    async *run(options) {
+        const queue = { events: [], wake: [], done: false };
+        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 session = writeResumeLatestSession(artifactDir, options);
+                return resumeNodePipeline({
+                    projectRoot: options.projectRoot,
+                    mode: 'pipeline',
+                    session,
+                    skipDeploy: options.skipDeploy,
+                    skipVerify: options.skipVerify,
+                    output: options.output,
+                    eventLog: options.eventLog,
+                    humanLog: options.humanLog
+                }, {
+                    env: this.env,
+                    emit: (event) => pushEvent(queue, event)
+                });
+            }
+            : async () => runNodePipeline(options, {
+                env: this.env,
+                emit: (event) => pushEvent(queue, event)
+            });
+        void runner()
+            .then(() => finishQueue(queue))
+            .catch((error) => finishQueue(queue, error));
+        while (!queue.done || queue.events.length > 0) {
+            if (queue.events.length === 0) {
+                await waitForEvent(queue);
+                continue;
+            }
+            yield queue.events.shift();
+        }
+        if (queue.error) {
+            throw queue.error;
+        }
+    }
+    async *retryStage(options) {
+        const queue = { events: [], wake: [], done: false };
+        void retryNodePipelineStage({
+            projectRoot: options.projectRoot,
+            artifactDir: options.artifactDir,
+            stage: options.stage,
+            output: options.output,
+            eventLog: options.eventLog,
+            humanLog: options.humanLog
+        }, {
+            env: this.env,
+            emit: (event) => pushEvent(queue, event)
+        })
+            .then(() => finishQueue(queue))
+            .catch((error) => finishQueue(queue, error));
+        while (!queue.done || queue.events.length > 0) {
+            if (queue.events.length === 0) {
+                await waitForEvent(queue);
+                continue;
+            }
+            yield queue.events.shift();
+        }
+        if (queue.error) {
+            throw queue.error;
+        }
+    }
+    async *resume(options) {
+        const queue = { events: [], wake: [], done: false };
+        void resumeNodePipeline({
+            projectRoot: options.projectRoot,
+            mode: options.mode,
+            session: options.session,
+            output: options.output,
+            eventLog: options.eventLog,
+            humanLog: options.humanLog
+        }, {
+            env: this.env,
+            emit: (event) => pushEvent(queue, event)
+        })
+            .then(() => finishQueue(queue))
+            .catch((error) => finishQueue(queue, error));
+        while (!queue.done || queue.events.length > 0) {
+            if (queue.events.length === 0) {
+                await waitForEvent(queue);
+                continue;
+            }
+            yield queue.events.shift();
+        }
+        if (queue.error) {
+            throw queue.error;
+        }
+    }
+    async startDetached(_options) {
+        throw unsupported('startDetached');
+    }
+    async stopJob(_jobId) {
+        throw unsupported('stopJob');
+    }
+    async readJob(_jobId) {
+        throw unsupported('readJob');
+    }
+    async *readLogs(_options) {
+        throw unsupported('readLogs');
+    }
+    async executeCli(_argv) {
+        throw unsupported('executeCli');
+    }
+}