@undefineds.co/xpod 0.4.17 → 0.4.19

package/dist/dns/cloudflare/CloudflareDnsProvider.js

@@ -27,34 +27,32 @@ class CloudflareDnsProvider {
         const zoneId = await this.getZoneId(options.domain);
         const fullName = this.buildFullName(options.subdomain, options.domain);
         const ttl = options.ttl ?? 1; // Cloudflare: 1 = auto
-        // 一次拉回该名字下的全部记录，再按类型判断（审计 N14）。
-        // 旧实现只取第一条、类型不同就删除——于是 `_acme-challenge` 的 TXT 或同一名字下的 MX
-        // 会被“为写 A 记录”误删。
-        const records = await this.findRecords(zoneId, fullName);
-        const existing = records.find((record) => record.type === options.type);
+        // 查找所有同名记录（不限类型），以处理 CNAME 与 A/AAAA 冲突
+        const existing = await this.findRecord(zoneId, fullName);
         if (existing) {
-            // 类型相同，检查内容是否需要更新
-            if (existing.content === options.value && (existing.ttl === ttl || ttl === 1)) {
-                this.logger.debug(`DNS 记录已存在且一致，跳过更新 ${fullName} ${options.type}`);
+            // 如果现有记录类型不同（如 CNAME vs AAAA），必须先删除旧记录
+            if (existing.type !== options.type) {
+                this.logger.info(`发现 DNS 类型冲突 (现有: ${existing.type}, 目标: ${options.type})，正在删除旧记录 ${fullName}...`);
+                await this.callApi(`zones/${zoneId}/dns_records/${existing.id}`, 'DELETE');
+                // 删除后继续执行创建逻辑
+            }
+            else {
+                // 类型相同，检查内容是否需要更新
+                if (existing.content === options.value && (existing.ttl === ttl || ttl === 1)) {
+                    this.logger.debug(`DNS 记录已存在且一致，跳过更新 ${fullName} ${options.type}`);
+                    return;
+                }
+                // 更新现有记录
+                await this.callApi(`zones/${zoneId}/dns_records/${existing.id}`, 'PATCH', {
+                    type: options.type,
+                    name: fullName,
+                    content: options.value,
+                    ttl,
+                    proxied: false, // DNS-01 验证需要关闭代理
+                });
+                this.logger.info(`已更新 DNS 记录 ${fullName} ${options.type}`);
                 return;
             }
-            // 更新现有记录
-            await this.callApi(`zones/${zoneId}/dns_records/${existing.id}`, 'PATCH', {
-                type: options.type,
-                name: fullName,
-                content: options.value,
-                ttl,
-                proxied: false, // DNS-01 验证需要关闭代理
-            });
-            this.logger.info(`已更新 DNS 记录 ${fullName} ${options.type}`);
-            return;
-        }
-        // 只有 CNAME 与其他记录类型互斥（RFC 1034）：写 A/AAAA 前要清掉同名 CNAME，写 CNAME 前
-        // 要清掉同名 A/AAAA。MX/TXT 等类型可以与 A/AAAA 共存，必须原样保留。
-        const conflicting = records.find((record) => CloudflareDnsProvider.isMutuallyExclusive(options.type, record.type));
-        if (conflicting) {
-            this.logger.info(`发现互斥 DNS 记录 (现有: ${conflicting.type}, 目标: ${options.type})，删除该记录 ${conflicting.id} (${fullName})...`);
-            await this.callApi(`zones/${zoneId}/dns_records/${conflicting.id}`, 'DELETE');
         }
         // 创建新记录
         await this.callApi(`zones/${zoneId}/dns_records`, 'POST', {
@@ -73,19 +71,12 @@ class CloudflareDnsProvider {
         }
         const zoneId = await this.getZoneId(options.domain);
         const fullName = this.buildFullName(options.subdomain, options.domain);
-        // 删除必须带类型（接口里 type 是必填）：按“同名 + 同类型（+ 同内容）”精确匹配，
-        // 绝不退化成“删这个名字下的第一条记录”。
-        const matches = await this.findRecords(zoneId, fullName, options.type, options.value);
-        const existing = matches[0];
+        // 删除时也要支持泛查找，以防类型传错，但通常 deleteRecord 会传 type
+        const existing = await this.findRecord(zoneId, fullName, options.type, options.value);
         if (!existing) {
             this.logger.debug(`DNS 记录不存在，跳过删除 ${fullName} ${options.type}`);
             return;
         }
-        if (existing.type !== options.type) {
-            // API 不该返回别的类型；真返回了就宁可不删，也不动别人的记录。
-            this.logger.warn(`拒绝删除类型不匹配的记录 ${fullName}：请求 ${options.type}，返回 ${existing.type}`);
-            return;
-        }
         await this.callApi(`zones/${zoneId}/dns_records/${existing.id}`, 'DELETE');
         this.logger.info(`已删除 DNS 记录 ${fullName} ${options.type}`);
     }
@@ -139,12 +130,9 @@ class CloudflareDnsProvider {
         throw new Error(`找不到域名 ${domain} 的任何所属 Zone，请检查域名是否正确或手动提供 zoneId`);
     }
     /**
-     * 查找现有 DNS 记录。
-     *
-     * `type` 与 `value` 都会下推到 API 查询里，返回**全部**匹配项而不是 `response[0]`：
-     * 调用方要按类型判断能不能动这条记录，靠“第一条”猜类型正是 N14 的成因。
+     * 查找现有 DNS 记录
      */
-    async findRecords(zoneId, fullName, type, value) {
+    async findRecord(zoneId, fullName, type, value) {
         const params = new URLSearchParams({
             name: fullName,
         });
@@ -155,26 +143,7 @@ class CloudflareDnsProvider {
             params.set('content', value);
         }
         const response = await this.callApi(`zones/${zoneId}/dns_records?${params.toString()}`, 'GET');
-        return Array.isArray(response) ? response : [];
-    }
-    async findRecord(zoneId, fullName, type, value) {
-        return (await this.findRecords(zoneId, fullName, type, value)).find((record) => type === undefined || record.type === type);
-    }
-    /**
-     * 是否与目标类型互斥：CNAME 不能与任何其他记录共存（RFC 1034），其余组合（含 TXT 与
-     * A/AAAA、MX 与 A/AAAA）都可以并存。
-     */
-    static isMutuallyExclusive(target, existing) {
-        if (existing === target) {
-            return false;
-        }
-        if (target === 'TXT') {
-            return false;
-        }
-        if (existing === 'CNAME') {
-            return true;
-        }
-        return target === 'CNAME' && (existing === 'A' || existing === 'AAAA');
+        return response[0];
     }
     /**
      * 调用 Cloudflare API

package/dist/edge/EdgeNodeAgent.d.ts

@@ -34,11 +34,6 @@ export interface EdgeNodeAgentOptions {
         certificatePath: string;
         fullChainPath?: string;
         renewBeforeDays?: number;
-        /** 后台续期检查间隔（默认 6 小时）；仅在本地 ACME 模式使用。 */
-        renewalCheckIntervalMs?: number;
-        /** 续期失败后的首次重试延迟（默认 60 秒，指数增长到上限）。 */
-        renewalRetryBaseDelayMs?: number;
-        renewalRetryMaxDelayMs?: number;
         propagationDelayMs?: number;
         postDeployCommand?: string[];
     };

package/dist/edge/EdgeNodeAgent.js

@@ -106,8 +106,6 @@ class EdgeNodeAgent {
         this.p2pAcceptRunning = false;
         void this.frpManager?.stop();
         this.clusterCertificate?.stop();
-        // 停止后不该再有后台续期：一个已停的 agent 不该继续向 CA 发请求。
-        this.localCertificate?.stopAutoRenewal();
         this.localCertificate = undefined;
         this.clusterCertificate = undefined;
     }
@@ -489,12 +487,6 @@ class EdgeNodeAgent {
             if (issued && acmeOptions.postDeployCommand && acmeOptions.postDeployCommand.length > 0) {
                 await this.runPostDeploy(acmeOptions.postDeployCommand);
             }
-            // 启动即检查只解决"开机时过期"，节点长期运行要靠后台续期（审计 N15）。
-            manager.startAutoRenewal({
-                intervalMs: acmeOptions.renewalCheckIntervalMs,
-                retryBaseDelayMs: acmeOptions.renewalRetryBaseDelayMs,
-                retryMaxDelayMs: acmeOptions.renewalRetryMaxDelayMs,
-            });
         }
         catch (error) {
             this.logger.error(`自动签发证书失败：${error.message}`);

package/dist/edge/acme/AcmeCertificateManager.d.ts

@@ -1,4 +1,3 @@
-import { type CertificateRenewalSchedulerStatus } from './CertificateRenewalScheduler';
 import type { DnsProvider } from '../../dns/DnsProvider';
 /**
  * DNS 验证处理器接口
@@ -61,29 +60,9 @@ export declare class AcmeCertificateManager {
     private readonly renewBeforeDays;
     private readonly propagationDelayMs;
     private issuing;
-    private renewalScheduler?;
     constructor(options: AcmeCertificateManagerOptions);
     ensureCertificate(): Promise<boolean>;
     readCertificateStatus(): Promise<RuntimeCertificateStatus>;
-    /**
-     * Starts the background renewal loop (audit N15).
-     *
-     * `ensureCertificate()` only looks at startup: a long-running node needed someone to call
-     * `renewCertificate()` by hand before the certificate expired. The scheduler checks on an
-     * interval, renews when the status is due, and backs off when the CA is unreachable.
-     */
-    startAutoRenewal(options?: {
-        intervalMs?: number;
-        retryBaseDelayMs?: number;
-        retryMaxDelayMs?: number;
-    }): void;
-    /**
-     * Stops the loop but keeps its final status readable: "why did it stop renewing" is exactly
-     * the question an operator asks after a failed renewal, and a discarded scheduler cannot
-     * answer it.
-     */
-    stopAutoRenewal(): void;
-    getRenewalSchedulerStatus(): CertificateRenewalSchedulerStatus | undefined;
     isAvailable(): boolean;
     renewCertificate(): Promise<RuntimeCertificateRenewalResult>;
     private extractDomainsFromCertificate;
@@ -92,9 +71,6 @@ export declare class AcmeCertificateManager {
     private issueCertificateFromCA;
     private ensureAccount;
     private loadOrCreateAccountKey;
-    /** 写私钥：创建时就用 0600，并对已存在的文件再 chmod 一次。 */
-    private writePrivateFile;
-    private restrictFileMode;
     private readOptionalFile;
     private ensureDirectory;
     private delay;

package/dist/edge/acme/AcmeCertificateManager.js

@@ -10,7 +10,6 @@ const promises_1 = require("node:fs/promises");
 const node_crypto_1 = require("node:crypto");
 const acme_client_1 = __importDefault(require("acme-client"));
 const global_logger_factory_1 = require("global-logger-factory");
-const CertificateRenewalScheduler_1 = require("./CertificateRenewalScheduler");
 const DnsChallengeClient_1 = require("./DnsChallengeClient");
 const utils_1 = require("./utils");
 /**
@@ -53,16 +52,10 @@ class LocalDnsChallengeHandler {
 }
 exports.LocalDnsChallengeHandler = LocalDnsChallengeHandler;
 const DEFAULT_DIRECTORY_URL = acme_client_1.default.directory.letsencrypt.production;
-// Staging is deliberately NOT in the default failover list: a staging certificate is not trusted
-// by any browser, so a production deployment that "succeeded" through it would be serving a
-// broken endpoint while reporting success (audit N15). ZeroSSL is a real alternative CA.
 const DEFAULT_FALLBACK_URLS = [
-    'https://acme.zerossl.com/v2/DV90',
+    acme_client_1.default.directory.letsencrypt.staging, // Staging as fallback for testing
+    'https://acme.zerossl.com/v2/DV90', // ZeroSSL as alternative CA
 ];
-/** A staging/test directory: certificates from here are not trusted by clients. */
-function isStagingDirectory(directoryUrl) {
-    return /staging|acme-staging/iu.test(directoryUrl);
-}
 class AcmeCertificateManager {
     constructor(options) {
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
@@ -90,8 +83,6 @@ class AcmeCertificateManager {
         this.email = options.email;
         this.domains = options.domains;
         this.directoryUrl = options.directoryUrl ?? DEFAULT_DIRECTORY_URL;
-        // A staging CA only ever appears here because the operator listed it explicitly; the
-        // defaults never add one (audit N15).
         this.fallbackDirectoryUrls = options.fallbackDirectoryUrls ?? DEFAULT_FALLBACK_URLS;
         this.accountKeyPath = options.accountKeyPath;
         this.certificateKeyPath = options.certificateKeyPath;
@@ -135,39 +126,6 @@ class AcmeCertificateManager {
             return { status: 'missing' };
         }
     }
-    /**
-     * Starts the background renewal loop (audit N15).
-     *
-     * `ensureCertificate()` only looks at startup: a long-running node needed someone to call
-     * `renewCertificate()` by hand before the certificate expired. The scheduler checks on an
-     * interval, renews when the status is due, and backs off when the CA is unreachable.
-     */
-    startAutoRenewal(options = {}) {
-        if (this.renewalScheduler) {
-            // Already created: start() is a no-op while running, and restarts it after a stop.
-            this.renewalScheduler.start();
-            return;
-        }
-        this.renewalScheduler = new CertificateRenewalScheduler_1.CertificateRenewalScheduler({
-            readStatus: async () => await this.readCertificateStatus(),
-            renew: async () => {
-                await this.renewCertificate();
-            },
-            ...options,
-        });
-        this.renewalScheduler.start();
-    }
-    /**
-     * Stops the loop but keeps its final status readable: "why did it stop renewing" is exactly
-     * the question an operator asks after a failed renewal, and a discarded scheduler cannot
-     * answer it.
-     */
-    stopAutoRenewal() {
-        this.renewalScheduler?.stop();
-    }
-    getRenewalSchedulerStatus() {
-        return this.renewalScheduler?.getStatus();
-    }
     isAvailable() {
         return this.domains.some((domain) => domain.trim().length > 0)
             && this.email.trim().length > 0
@@ -222,21 +180,12 @@ class AcmeCertificateManager {
         if (this.fullChainPath) {
             await this.ensureDirectory((0, node_path_1.dirname)(this.fullChainPath));
         }
-        // Try the primary CA first, then the failover chain. The chain is exactly what the operator
-        // configured: the defaults contain no staging CA, so a production deployment cannot silently
-        // end up serving a certificate no client trusts (audit N15).
+        // Try primary CA first, then fallback CAs
         const directoryUrls = [this.directoryUrl, ...this.fallbackDirectoryUrls];
-        const stagingInChain = directoryUrls.filter(isStagingDirectory);
-        if (stagingInChain.length > 0 && !isStagingDirectory(this.directoryUrl)) {
-            this.logger.warn(`ACME 失败切换链包含 staging CA（${stagingInChain.join(', ')}）：该 CA 签发的证书客户端不信任`);
-        }
         let lastError;
         for (const directoryUrl of directoryUrls) {
             try {
                 await this.issueCertificateFromCA(directoryUrl);
-                if (isStagingDirectory(directoryUrl)) {
-                    this.logger.warn(`证书由 staging CA 签发，客户端不会信任：${directoryUrl}`);
-                }
                 return; // Success!
             }
             catch (error) {
@@ -247,9 +196,8 @@ class AcmeCertificateManager {
                 }
             }
         }
-        // All CAs failed: name every CA that was tried, so the operator does not have to guess.
-        throw new Error(`所有 ACME CA 都失败（已尝试 ${directoryUrls.length} 个：${directoryUrls.join(', ')}）。`
-            + `最后错误: ${lastError?.message}`);
+        // All CAs failed
+        throw new Error(`所有 ACME CA 都失败。最后错误: ${lastError?.message}`);
     }
     async issueCertificateFromCA(directoryUrl) {
         this.logger.info(`使用 ACME CA: ${directoryUrl}`);
@@ -280,8 +228,7 @@ class AcmeCertificateManager {
                 await this.dnsHandler.removeChallenge(recordName);
             },
         });
-        // 私钥 0600（证书本身是公开材料，保持默认权限即可）：审计 N18。
-        await this.writePrivateFile(this.certificateKeyPath, privateKey.toString());
+        await node_fs_1.promises.writeFile(this.certificateKeyPath, privateKey.toString());
         await node_fs_1.promises.writeFile(this.certificatePath, certificate);
         if (this.fullChainPath) {
             await node_fs_1.promises.writeFile(this.fullChainPath, certificate);
@@ -308,28 +255,13 @@ class AcmeCertificateManager {
     async loadOrCreateAccountKey(path) {
         const existing = await this.readOptionalFile(path);
         if (existing) {
-            // 旧版本可能留下了 0644 的账户私钥，读到就顺手收紧。
-            await this.restrictFileMode(path);
             return existing.toString();
         }
         await this.ensureDirectory((0, node_path_1.dirname)(path));
         const key = await acme_client_1.default.crypto.createPrivateKey();
-        await this.writePrivateFile(path, key.toString());
+        await node_fs_1.promises.writeFile(path, key);
         return key.toString();
     }
-    /** 写私钥：创建时就用 0600，并对已存在的文件再 chmod 一次。 */
-    async writePrivateFile(path, contents) {
-        await node_fs_1.promises.writeFile(path, contents, { encoding: 'utf8', mode: 0o600 });
-        await this.restrictFileMode(path);
-    }
-    async restrictFileMode(path) {
-        try {
-            await node_fs_1.promises.chmod(path, 0o600);
-        }
-        catch (error) {
-            this.logger.warn(`无法收紧私钥文件权限 ${path}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
     async readOptionalFile(path) {
         try {
             return await node_fs_1.promises.readFile(path);

package/dist/edge/acme/AcmeCertificateManager.jsonld

@@ -224,10 +224,6 @@
           "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_issuing",
           "memberFieldName": "issuing"
         },
-        {
-          "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_renewalScheduler",
-          "memberFieldName": "renewalScheduler"
-        },
         {
           "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_constructor",
           "memberFieldName": "constructor"
@@ -240,18 +236,6 @@
           "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_readCertificateStatus",
           "memberFieldName": "readCertificateStatus"
         },
-        {
-          "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_startAutoRenewal",
-          "memberFieldName": "startAutoRenewal"
-        },
-        {
-          "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_stopAutoRenewal",
-          "memberFieldName": "stopAutoRenewal"
-        },
-        {
-          "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_getRenewalSchedulerStatus",
-          "memberFieldName": "getRenewalSchedulerStatus"
-        },
         {
           "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_isAvailable",
           "memberFieldName": "isAvailable"
@@ -284,14 +268,6 @@
           "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_loadOrCreateAccountKey",
           "memberFieldName": "loadOrCreateAccountKey"
         },
-        {
-          "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_writePrivateFile",
-          "memberFieldName": "writePrivateFile"
-        },
-        {
-          "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_restrictFileMode",
-          "memberFieldName": "restrictFileMode"
-        },
         {
           "@id": "undefineds:dist/edge/acme/AcmeCertificateManager.jsonld#AcmeCertificateManager__member_readOptionalFile",
           "memberFieldName": "readOptionalFile"

package/dist/edge/frp/FrpcProcessManager.d.ts

@@ -25,10 +25,6 @@ export interface FrpcRuntimeStatus {
     error?: string;
     entrypoint?: string;
     pid?: number;
-    /** Restarts since the last healthy run, so a crash loop is visible instead of implied. */
-    restartCount?: number;
-    /** Delay before the next automatic restart, when one is scheduled. */
-    nextRestartInMs?: number;
 }
 export declare class FrpcProcessManager {
     private readonly logger;
@@ -43,22 +39,10 @@ export declare class FrpcProcessManager {
     private restarting;
     private status;
     private desiredRunning;
-    private restartTimer?;
-    private consecutiveFailures;
-    private startedAt;
     constructor(options: FrpcProcessManagerOptions);
     applyConfig(config?: FrpTunnelRuntimeConfig, status?: string, entrypoint?: string): Promise<void>;
     stop(): Promise<void>;
-    /**
-     * 结束当前进程，但不碰重启计数与待重启定时器。
-     *
-     * 先把 `this.process` 置空：退出回调据此判断“这个进程已被替换”，不会为它再排一次重启，
-     * 也不会把它的退出写成当前状态。
-     */
-    private stopProcess;
     private restart;
-    private nextRestartDelayMs;
-    private cancelPendingRestart;
     private ensureDirectory;
     private writeConfigFile;
     getStatus(): FrpcRuntimeStatus;

package/dist/edge/frp/FrpcProcessManager.js

@@ -5,26 +5,12 @@ const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const global_logger_factory_1 = require("global-logger-factory");
-/**
- * frpc 崩溃后的重启退避（审计 N18）。
- *
- * 旧实现固定 1 秒重试：frpc 配置错误时会以每秒一次的节奏永远重启，日志与进程资源都被
- * 刷满，而且 `stop()` 不会取消已排定的那次重启——停掉的隧道会被自己排的重启复活。
- */
-const RESTART_BASE_DELAY_MS = 1_000;
-const RESTART_MAX_DELAY_MS = 60_000;
-/** 一次运行活过这个时长就算“健康”，重启计数清零。 */
-const HEALTHY_UPTIME_MS = 60_000;
-/** 隧道是兜底路径，退避到上限后继续重试，不放弃。 */
-const CONFIG_FILE_MODE = 0o600;
 class FrpcProcessManager {
     constructor(options) {
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
         this.restarting = false;
         this.status = { state: 'inactive' };
         this.desiredRunning = false;
-        this.consecutiveFailures = 0;
-        this.startedAt = 0;
         this.binaryPath = options.binaryPath;
         this.configPath = options.configPath;
         this.workingDirectory = options.workingDirectory;
@@ -52,28 +38,16 @@ class FrpcProcessManager {
         await this.restart(entrypoint ?? config.entrypoint);
     }
     async stop() {
-        // 取消已排定的自动重启：否则一次显式停止会被自己排的重启撤销（与 supervisor 同类缺陷）。
-        this.cancelPendingRestart();
-        // 显式停止才算“重新开始”，自动重启之间的失败计数必须保留，否则退避永远回到 1 秒。
-        this.consecutiveFailures = 0;
-        await this.stopProcess();
-        if (this.status.state !== 'inactive') {
-            this.setStatus({ state: 'inactive', lastUpdated: new Date().toISOString() });
-        }
-    }
-    /**
-     * 结束当前进程，但不碰重启计数与待重启定时器。
-     *
-     * 先把 `this.process` 置空：退出回调据此判断“这个进程已被替换”，不会为它再排一次重启，
-     * 也不会把它的退出写成当前状态。
-     */
-    async stopProcess() {
-        const proc = this.process;
-        if (!proc) {
+        if (!this.process) {
             return;
         }
-        this.process = undefined;
-        await new Promise((resolve) => {
+        return new Promise((resolve) => {
+            const proc = this.process;
+            this.process = undefined;
+            if (!proc) {
+                resolve();
+                return;
+            }
             proc.once('exit', () => resolve());
             proc.once('error', () => resolve());
             proc.kill();
@@ -86,7 +60,7 @@ class FrpcProcessManager {
         }
         this.restarting = true;
         try {
-            await this.stopProcess();
+            await this.stop();
             await this.ensureDirectory((0, node_path_1.dirname)(this.configPath));
             this.logger.info(`${this.logPrefix} 启动 frpc 进程`);
             const args = ['-c', this.configPath];
@@ -95,13 +69,11 @@ class FrpcProcessManager {
                 stdio: 'pipe',
             });
             this.process = proc;
-            this.startedAt = Date.now();
             this.setStatus({
                 state: 'running',
                 entrypoint,
                 lastUpdated: new Date().toISOString(),
                 pid: proc.pid ?? undefined,
-                restartCount: this.consecutiveFailures,
             });
             proc.stdout.on('data', (data) => {
                 this.logger.debug(`${this.logPrefix} ${data.toString().trim()}`);
@@ -111,24 +83,13 @@ class FrpcProcessManager {
             });
             proc.once('exit', (code, signal) => {
                 this.logger.info(`${this.logPrefix} 退出，code=${code ?? ''} signal=${signal ?? ''}`);
-                if (this.process !== proc) {
-                    // 已被显式停止或替换：这次退出既不代表当前状态，也不该排重启。
-                    return;
-                }
                 this.process = undefined;
-                // 一次活够久的运行说明配置没问题，重启计数清零；否则累加并指数退避。
-                const uptimeMs = this.startedAt > 0 ? Date.now() - this.startedAt : 0;
-                this.consecutiveFailures = uptimeMs >= HEALTHY_UPTIME_MS ? 0 : this.consecutiveFailures + 1;
-                const shouldRestart = this.autoRestart && Boolean(this.currentSignature) && this.desiredRunning;
-                const delayMs = shouldRestart ? this.nextRestartDelayMs() : undefined;
                 if (this.desiredRunning) {
                     this.setStatus({
                         state: 'error',
                         error: `exit:${code ?? 'unknown'}`,
                         lastUpdated: new Date().toISOString(),
                         entrypoint,
-                        restartCount: this.consecutiveFailures,
-                        ...(delayMs === undefined ? {} : { nextRestartInMs: delayMs }),
                     });
                 }
                 else {
@@ -137,14 +98,12 @@ class FrpcProcessManager {
                         lastUpdated: new Date().toISOString(),
                     });
                 }
-                if (shouldRestart && delayMs !== undefined) {
-                    this.logger.warn(`${this.logPrefix} ${delayMs}ms 后重启（连续失败 ${this.consecutiveFailures} 次，上限 ${RESTART_MAX_DELAY_MS}ms）`);
-                    this.restartTimer = setTimeout(() => {
-                        this.restartTimer = undefined;
+                if (this.autoRestart && this.currentSignature && this.desiredRunning) {
+                    setTimeout(() => {
                         void this.restart(entrypoint).catch((error) => {
                             this.logger.error(`${this.logPrefix} 重启失败: ${error instanceof Error ? error.message : String(error)}`);
                         });
-                    }, delayMs);
+                    }, 1_000);
                 }
             });
             proc.once('error', (error) => {
@@ -162,16 +121,6 @@ class FrpcProcessManager {
             this.restarting = false;
         }
     }
-    nextRestartDelayMs() {
-        const exponent = Math.max(0, this.consecutiveFailures - 1);
-        return Math.min(RESTART_BASE_DELAY_MS * 2 ** exponent, RESTART_MAX_DELAY_MS);
-    }
-    cancelPendingRestart() {
-        if (this.restartTimer) {
-            clearTimeout(this.restartTimer);
-            this.restartTimer = undefined;
-        }
-    }
     async ensureDirectory(path) {
         if (!path || path === '.') {
             return;
@@ -206,14 +155,7 @@ class FrpcProcessManager {
             lines.push(`# public_url = ${config.entrypoint}`);
         }
         await this.ensureDirectory((0, node_path_1.dirname)(this.configPath));
-        // frpc 配置里有隧道 token：写 0600，并对已存在的旧文件再 chmod 一次（审计 N18）。
-        await node_fs_1.promises.writeFile(this.configPath, `${lines.join('\n')}\n`, { encoding: 'utf8', mode: CONFIG_FILE_MODE });
-        try {
-            await node_fs_1.promises.chmod(this.configPath, CONFIG_FILE_MODE);
-        }
-        catch (error) {
-            this.logger.warn(`${this.logPrefix} 无法收紧配置文件权限: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        await node_fs_1.promises.writeFile(this.configPath, `${lines.join('\n')}\n`, 'utf8');
     }
     getStatus() {
         return { ...this.status };
@@ -225,8 +167,6 @@ class FrpcProcessManager {
             error: update.error,
             entrypoint: update.entrypoint,
             pid: update.pid,
-            ...(update.restartCount === undefined ? {} : { restartCount: update.restartCount }),
-            ...(update.nextRestartInMs === undefined ? {} : { nextRestartInMs: update.nextRestartInMs }),
         };
     }
 }

package/dist/edge/reachability/ManagedClientFetch.d.ts

@@ -9,8 +9,6 @@ export interface ManagedClientFetchOptions {
     probe?: (route: AccessRoute, signal: AbortSignal) => Promise<boolean> | boolean;
     probeTimeoutMs?: number;
     p2p?: ManagedClientP2POptions;
-    /** Injectable clock: route validity must be decided against a known time in tests. */
-    now?: () => Date;
 }
 export interface ManagedClientFetch {
     route: AccessRoute;