@swimmingliu/autovpn 1.6.5 → 1.6.6

package/dist/doctor/checks.js

@@ -5,6 +5,7 @@ import { spawnSync } from 'node:child_process';
 import { parse } from '@iarna/toml';
 import { profileSummary } from '../config/profile.js';
 import { resolveArtifactsRoot, resolveProfilePath } from '../runtime/paths.js';
+import { resolveShareWorkerTemplatePath, resolveWorkerTemplatePath } from '../runtime/templates.js';
 import { normalizeManagedToolCommandForSpawn, resolveManagedNpmTool } from '../runtime/managed-tools.js';
 const JAVASCRIPT_OBFUSCATOR_VERSION = '5.4.3';
 const WRANGLER_VERSION = '4.106.0';
@@ -201,13 +202,27 @@ export async function runDoctor(projectRoot, argv, env = process.env, options =
     const configuredSources = sourceValues.filter((source) => source.enabled && source.url === 'set' && source.key === 'set');
     const nodeToolChecks = await checkNodeTools(projectRoot, env, options);
     const cloudflareChecks = await checkCloudflare(summary, deploy, env, projectRoot, options);
+    let workerTemplatePath = '';
+    let shareWorkerTemplatePath = '';
+    try {
+        workerTemplatePath = resolveWorkerTemplatePath(projectRoot);
+    }
+    catch {
+        workerTemplatePath = '';
+    }
+    try {
+        shareWorkerTemplatePath = resolveShareWorkerTemplatePath(projectRoot, env);
+    }
+    catch {
+        shareWorkerTemplatePath = '';
+    }
     const checks = [
         check('node_version', 'pass', `Node ${process.versions.node}`, { required: '>=20' }),
         check('project_root', 'pass', 'Project root resolved', { path: projectRoot }),
         check('profile_path', pathWritable(profilePath) ? 'pass' : 'fail', pathWritable(profilePath) ? 'Profile is readable and writable' : 'Profile path is not writable', { profile_path: profilePath, exists: fs.existsSync(profilePath) }),
         check('artifacts_root', pathWritable(artifactsRoot) ? 'pass' : 'fail', pathWritable(artifactsRoot) ? 'Artifacts root is writable' : 'Artifacts root is not writable', { path: artifactsRoot }),
-        check('worker_template', fs.existsSync(path.join(projectRoot, 'templates', 'vmess_node.js')) ? 'pass' : 'fail', fs.existsSync(path.join(projectRoot, 'templates', 'vmess_node.js')) ? 'Worker template exists' : 'Worker template is missing', { path: path.join(projectRoot, 'templates', 'vmess_node.js') }),
-        check('share_worker_template', fs.existsSync(path.join(projectRoot, 'templates', 'share-worker', 'vpn.js')) ? 'pass' : 'warn', fs.existsSync(path.join(projectRoot, 'templates', 'share-worker', 'vpn.js')) ? 'Share worker template exists' : 'Share worker template is missing', { path: path.join(projectRoot, 'templates', 'share-worker', 'vpn.js') }),
+        check('worker_template', workerTemplatePath ? 'pass' : 'fail', workerTemplatePath ? 'Worker template exists' : 'Worker template is missing', { path: workerTemplatePath || path.join(projectRoot, 'templates', 'vmess_node.js') }),
+        check('share_worker_template', shareWorkerTemplatePath ? 'pass' : 'warn', shareWorkerTemplatePath ? 'Share worker template exists' : 'Share worker template is missing', { path: shareWorkerTemplatePath || path.join(projectRoot, 'templates', 'share-worker', 'vpn.js') }),
         configuredSources.length
             ? check('sources', 'pass', 'At least one enabled source is configured', { configured_count: configuredSources.length })
             : check('sources', 'warn', 'No enabled source has both URL and key configured', { configured_count: 0, key_state: 'missing' }),

package/dist/pipeline/deploy.js

@@ -1,7 +1,8 @@
 import path from 'node:path';
 import { spawn as defaultSpawn } from 'node:child_process';
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { mergeProjectEnv } from '../runtime/env.js';
+import { resolveShareWorkerTemplatePath } from '../runtime/templates.js';
 import { normalizeManagedToolCommandForSpawn, resolveManagedNpmTool } from '../runtime/managed-tools.js';
 const PYTHON_DEPLOY_HELPER = `
 import json
@@ -47,6 +48,7 @@ json.dump(result, sys.stdout, ensure_ascii=False)
 sys.stdout.write("\\n")
 `;
 const PAGES_PRODUCTION_BRANCH = 'main';
+const CLOUDFLARE_API_MAX_ATTEMPTS = 3;
 const FALLBACK_SUFFIX_PATTERN = /^(?<prefix>.+)-(?<suffix>\d+)$/;
 const CLOUDFLARE_API_BASE_URL = 'https://api.cloudflare.com/client/v4';
 const NETWORK_ERROR_MARKERS = [
@@ -354,51 +356,11 @@ function buildShareProjectUpdatePayload(sourceProject, runtimeEnv, options) {
         deployment_configs: rewriteShareProjectSubValue(clonedConfigs, options)
     };
 }
-async function fileExists(candidate) {
-    try {
-        await access(candidate);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function expandHomePath(candidate) {
-    if (candidate === '~') {
-        return process.env.HOME || candidate;
-    }
-    if (candidate.startsWith('~/')) {
-        return process.env.HOME ? path.join(process.env.HOME, candidate.slice(2)) : candidate;
-    }
-    return candidate;
-}
-async function resolveShareProjectWorkerSourcePath(projectRoot, env) {
-    const candidates = [
-        clean(env.VPN_AUTOMATION_SHARE_WORKER_PATH),
-        path.join(projectRoot, 'electron', 'runtime', 'share-worker', 'vpn.js'),
-        path.join(projectRoot, 'templates', 'share-worker', 'vpn.js'),
-        path.join(path.dirname(projectRoot), 'cloudflarevpn', 'edgetunnel', 'vpn.js')
-    ].filter(Boolean).map((candidate) => path.resolve(expandHomePath(candidate)));
-    const seen = new Set();
-    const uniqueCandidates = candidates.filter((candidate) => {
-        if (seen.has(candidate)) {
-            return false;
-        }
-        seen.add(candidate);
-        return true;
-    });
-    for (const candidate of uniqueCandidates) {
-        if (await fileExists(candidate)) {
-            return candidate;
-        }
-    }
-    throw new Error(`share worker source not found; tried: ${uniqueCandidates.join(', ')}`);
-}
 function buildShareProjectBundleDir(projectRoot) {
     return path.join(projectRoot, 'electron', 'runtime', 'share-worker', 'share_pages_bundle');
 }
 async function stageShareProjectWorkerBundle(projectRoot, env) {
-    const sourcePath = await resolveShareProjectWorkerSourcePath(projectRoot, env);
+    const sourcePath = resolveShareWorkerTemplatePath(projectRoot, env);
     const bundleDir = buildShareProjectBundleDir(projectRoot);
     const workerEntry = path.join(bundleDir, '_worker.js');
     await mkdir(bundleDir, { recursive: true });
@@ -508,12 +470,30 @@ export class CloudflareHttpClient {
         this.headers = cloudflareHeaders(credentials);
         this.fetchImpl = options.fetch ?? fetch;
     }
+    async fetchWithTransientRetries(input, options, timeoutMs) {
+        for (let attempt = 1; attempt <= CLOUDFLARE_API_MAX_ATTEMPTS; attempt += 1) {
+            try {
+                return await this.fetchImpl(input, {
+                    ...options,
+                    signal: options.signal ?? AbortSignal.timeout(timeoutMs)
+                });
+            }
+            catch (error) {
+                const transientFailure = error instanceof TypeError
+                    || (error instanceof Error && error.name === 'TimeoutError');
+                const retryable = transientFailure && !options.signal?.aborted;
+                if (!retryable || attempt === CLOUDFLARE_API_MAX_ATTEMPTS) {
+                    throw error;
+                }
+            }
+        }
+        throw new Error('Cloudflare request failed');
+    }
     async apiRequest(pathname, options = {}) {
-        const response = await this.fetchImpl(`${CLOUDFLARE_API_BASE_URL}${pathname}`, {
+        const response = await this.fetchWithTransientRetries(`${CLOUDFLARE_API_BASE_URL}${pathname}`, {
             ...options,
-            headers: { ...this.headers, ...options.headers },
-            signal: options.signal ?? AbortSignal.timeout(20_000)
-        });
+            headers: { ...this.headers, ...options.headers }
+        }, 20_000);
         if (!response.ok) {
             const body = await responseBodyText(response);
             throw new Error(`Cloudflare API request failed (${response.status}): ${body || response.statusText}`);
@@ -665,10 +645,7 @@ export class CloudflareHttpClient {
         return this.apiRequest(`/accounts/${accountId}/pages/projects/${projectName}`, { method: 'DELETE' });
     }
     async verifyUrl(url, expectedFragment = '') {
-        const response = await this.fetchImpl(url, {
-            method: 'GET',
-            signal: AbortSignal.timeout(30_000)
-        });
+        const response = await this.fetchWithTransientRetries(url, { method: 'GET' }, 30_000);
         if (!response.ok) {
             const body = await responseBodyText(response);
             throw new Error(`URL verification failed (${response.status}): ${body || response.statusText}`);

package/dist/pipeline/orchestrator.js

@@ -5,6 +5,7 @@ import { parse } from '@iarna/toml';
 import { mergeProjectEnv } from '../runtime/env.js';
 import { resolveArtifactsRoot, resolveProfilePath } from '../runtime/paths.js';
 import { redactText } from '../runtime/redaction.js';
+import { resolveWorkerTemplatePath } from '../runtime/templates.js';
 import { fetchSourceLinksWithBackend } from './extract.js';
 import { canonicalVmessKey, dedupeVmessLinksWithBackend, parseVmessLink } from './dedupe.js';
 import { normalizeSpeedTestConfig, probeSpeedtestLinksInNode, selectSpeedtestCandidates, speedtestLinksWithBackend, testSpeedtestLinkInNode } from './speedtest.js';
@@ -650,7 +651,7 @@ export async function runNodePipeline(options, context = {}) {
         await writeLines(artifactDir, 'vpn_node_emoji.txt', postprocessed.links);
         await setStage('postprocess', 'success');
         await setStage('render', 'running');
-        const template = await readFile(path.join(projectRoot, 'templates', 'vmess_node.js'), 'utf8');
+        const template = await readFile(resolveWorkerTemplatePath(projectRoot), 'utf8');
         const rendered = await renderMainDataWithBackend({ template, links: postprocessed.links }, { cwd: projectRoot, env });
         await setStage('render', 'success');
         await setStage('obfuscate', 'running');
@@ -819,6 +820,8 @@ export async function retryNodePipelineStage(options, context = {}) {
                 await writeReport();
                 throw new Error('No links passed availability');
             }
+            const availableLinkSet = new Set(availableLinks);
+            availabilityResults = availabilityResults.filter((result) => availableLinkSet.has(result.link));
             await setStage('availability', 'success');
         }
         else if (isStageAtOrAfter(stage, 'postprocess')) {
@@ -861,7 +864,7 @@ export async function retryNodePipelineStage(options, context = {}) {
                 throw new Error('No postprocess output available to retry render');
             }
             await setStage('render', 'running');
-            const template = await readFile(path.join(projectRoot, 'templates', 'vmess_node.js'), 'utf8');
+            const template = await readFile(resolveWorkerTemplatePath(projectRoot), 'utf8');
             const rendered = await renderMainDataWithBackend({ template, links: finalLinks }, { cwd: projectRoot, env });
             await writeFile(path.join(retryArtifactDir, 'vmess_node.js'), rendered.rendered_source, 'utf8');
             await setStage('render', 'success');
@@ -1185,7 +1188,7 @@ export async function resumeNodePipeline(options, context = {}) {
         }
         await setStage('postprocess', 'success');
         await setStage('render', 'running');
-        const template = await readFile(path.join(projectRoot, 'templates', 'vmess_node.js'), 'utf8');
+        const template = await readFile(resolveWorkerTemplatePath(projectRoot), 'utf8');
         const rendered = await renderMainDataWithBackend({ template, links: postprocessed.links }, { cwd: projectRoot, env });
         await writeFile(path.join(artifactDir, 'vmess_node.js'), rendered.rendered_source, 'utf8');
         await setStage('render', 'success');

package/dist/runtime/templates.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const packagedWorkerTemplatePath = fileURLToPath(new URL('../templates/vmess_node.js', import.meta.url));
+const packagedShareWorkerTemplatePath = fileURLToPath(new URL('../templates/share-worker/vpn.js', import.meta.url));
+function expandHomePath(candidate, env) {
+    if (candidate === '~') {
+        return env.HOME || candidate;
+    }
+    if (candidate.startsWith('~/')) {
+        return env.HOME ? path.join(env.HOME, candidate.slice(2)) : candidate;
+    }
+    return candidate;
+}
+function firstExistingPath(candidates, message) {
+    const uniqueCandidates = [...new Set(candidates.filter(Boolean).map((candidate) => path.resolve(candidate)))];
+    const resolved = uniqueCandidates.find((candidate) => fs.existsSync(candidate));
+    if (resolved) {
+        return resolved;
+    }
+    throw new Error(`${message}; checked: ${uniqueCandidates.join(', ')}`);
+}
+export function resolveWorkerTemplatePath(projectRoot) {
+    return firstExistingPath([
+        path.join(projectRoot, 'templates', 'vmess_node.js'),
+        packagedWorkerTemplatePath
+    ], 'Worker template is missing');
+}
+export function resolveShareWorkerTemplatePath(projectRoot, env = process.env) {
+    return firstExistingPath([
+        expandHomePath(String(env.VPN_AUTOMATION_SHARE_WORKER_PATH ?? '').trim(), env),
+        path.join(projectRoot, 'electron', 'runtime', 'share-worker', 'vpn.js'),
+        path.join(projectRoot, 'templates', 'share-worker', 'vpn.js'),
+        packagedShareWorkerTemplatePath,
+        path.join(path.dirname(projectRoot), 'cloudflarevpn', 'edgetunnel', 'vpn.js')
+    ], 'Share Worker template is missing');
+}