@undefineds.co/xpod 0.4.18 → 0.4.19

package/dist/runtime/port-finder.js

@@ -6,12 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findGatewayIngressPort = findGatewayIngressPort;
 exports.getFreePort = getFreePort;
 exports.getEphemeralLoopbackPort = getEphemeralLoopbackPort;
-exports.isFreePortForWildcard = isFreePortForWildcard;
 exports.requireFreePortForWildcard = requireFreePortForWildcard;
 exports.getFreePortForWildcard = getFreePortForWildcard;
 const node_net_1 = __importDefault(require("node:net"));
 const node_os_1 = __importDefault(require("node:os"));
-const port_reservations_1 = require("./port-reservations");
 const HIGHEST_PORT = 65_535;
 const PORT_PROBE_TIMEOUT_MS = 1_000;
 const RETRYABLE_PORT_ERRORS = new Set([
@@ -109,10 +107,6 @@ async function canListen(port, host, timeoutMs = PORT_PROBE_TIMEOUT_MS) {
  * into a provider console and it survives restarts - while staying clear of the block a
  * neighbouring runtime plans for its own services. When the neighbourhood is busy the caller
  * gets an OS-assigned port instead of a stolen one; the runtime reports whichever it got.
- *
- * Reserved ports are skipped here too: a group that needs a fixed port has published a
- * reservation, and a dynamic entry that took it would break that group's tunnel instead of
- * merely moving its own listener.
  */
 async function findGatewayIngressPort(gatewayPort) {
     for (let offset = 3; offset < 10; offset += 1) {
@@ -123,20 +117,8 @@ async function findGatewayIngressPort(gatewayPort) {
     }
     return await getEphemeralLoopbackPort();
 }
-/**
- * The first free port at or above `basePort`.
- *
- * Reserved ports are skipped, not merely avoided by convention: a group that needs a fixed port
- * (the tunnel acceptance's console-owned 5737) publishes a reservation, and every allocator -
- * the runtime, the test helpers, the integration runners - goes around it instead of racing for
- * it. That is the difference between "usually fine" and "cannot collide".
- */
 async function getFreePort(basePort, host = '127.0.0.1', timeoutMs = PORT_PROBE_TIMEOUT_MS) {
-    const reserved = (0, port_reservations_1.reservedPorts)();
     for (let port = basePort; port <= HIGHEST_PORT; port++) {
-        if (reserved.has(port)) {
-            continue;
-        }
         if (await canListen(port, host, timeoutMs)) {
             return port;
         }
@@ -153,35 +135,30 @@ async function getFreePort(basePort, host = '127.0.0.1', timeoutMs = PORT_PROBE_
  * runtime's service.
  */
 async function getEphemeralLoopbackPort() {
-    // One retry rule for "the OS does not know about reservations", shared with the fixtures that
-    // bind their own server (`listenOnUnreservedPort`).
-    return await (0, port_reservations_1.getUnreservedEphemeralPort)('127.0.0.1');
+    return await new Promise((resolve, reject) => {
+        const server = node_net_1.default.createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            server.close((error) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(port);
+            });
+        });
+    });
 }
 function hasIpv6Address() {
     return Object.values(node_os_1.default.networkInterfaces()).some((entries) => entries?.some((entry) => entry.family === 'IPv6'));
 }
 /**
- * Whether this runtime could take the port as-is, on both address families.
- *
- * A tunnel origin is bound on the wildcard address, so a listener on `*:<port>` owns the
- * number even when IPv4 loopback alone still looks free.
- *
- * This is a probe, not an allocation: it answers about the socket, so a *reserved* port that is
- * genuinely free answers `true` (the group that reserved it still has to bind it). The
- * `getFreePort*` family is the allocating one, and it skips reserved ports.
+ * Allocates a port for child services that bind wildcard addresses.
+ * CSS may bind `::` while the API binds `0.0.0.0`, so probing only localhost
+ * can miss an occupied port on the other address family.
  */
-async function isFreePortForWildcard(port, timeoutMs = PORT_PROBE_TIMEOUT_MS) {
-    if (!Number.isInteger(port) || port <= 0 || port > 65535) {
-        return false;
-    }
-    if (!await canListen(port, '0.0.0.0', timeoutMs)) {
-        return false;
-    }
-    if (hasIpv6Address() && !await canListen(port, '::', timeoutMs)) {
-        return false;
-    }
-    return true;
-}
 /**
  * Takes exactly this port or fails.
  *
@@ -192,24 +169,17 @@ async function requireFreePortForWildcard(port, timeoutMs = PORT_PROBE_TIMEOUT_M
     if (!Number.isInteger(port) || port <= 0 || port > 65535) {
         throw new Error(`ingress port ${port} is not a valid port number`);
     }
-    if (!await isFreePortForWildcard(port, timeoutMs)) {
+    if (!await canListen(port, '0.0.0.0', timeoutMs)) {
         throw new Error(`ingress port ${port} is already in use; free it or point the tunnel at another port`);
     }
+    if (hasIpv6Address() && !await canListen(port, '::', timeoutMs)) {
+        throw new Error(`ingress port ${port} is already in use on IPv6; free it or point the tunnel at another port`);
+    }
     return port;
 }
-/**
- * Allocates a port for child services that bind wildcard addresses.
- *
- * CSS may bind `::` while the API binds `0.0.0.0`, so probing only localhost can miss an
- * occupied port on the other address family - and a reserved port is skipped either way.
- */
 async function getFreePortForWildcard(basePort, timeoutMs = PORT_PROBE_TIMEOUT_MS) {
     const probeIpv6 = hasIpv6Address();
-    const reserved = (0, port_reservations_1.reservedPorts)();
     for (let port = basePort; port <= HIGHEST_PORT; port++) {
-        if (reserved.has(port)) {
-            continue;
-        }
         if (!await canListen(port, '0.0.0.0', timeoutMs)) {
             continue;
         }

package/dist/runtime/safe-env.d.ts

@@ -4,7 +4,7 @@ export interface AiConnectionsRuntimeConfig {
     apiKey: string;
     model?: string;
 }
-export declare function sanitizeRuntimeEnv(source?: Record<string, string | undefined> | Record<string, string | undefined>): Record<string, string>;
+export declare function sanitizeRuntimeEnv(source?: NodeJS.ProcessEnv | Record<string, string | undefined>): Record<string, string>;
 export declare function requireAiConnectionsRuntimeConfig(input: {
     baseUrl?: string;
     apiKey?: string;

package/dist/runtime/user-env.d.ts

@@ -1,6 +1,6 @@
 export declare function defaultXpodEnvPath({ env, platform, homeDir, }?: {
-    env?: Record<string, string | undefined>;
+    env?: NodeJS.ProcessEnv;
     platform?: NodeJS.Platform;
     homeDir?: string;
 }): string;
-export declare function resolveXpodEnvPath(explicitPath: string | undefined, env?: Record<string, string | undefined>): string;
+export declare function resolveXpodEnvPath(explicitPath: string | undefined, env?: NodeJS.ProcessEnv): string;

package/dist/supervisor/Supervisor.d.ts

@@ -5,15 +5,6 @@ export interface SupervisorLog {
     source: string;
     message: string;
 }
-export interface SupervisorOptions {
-    handleProcessSignals?: boolean;
-    /** Consecutive failed runs tolerated before giving up. */
-    maxRestarts?: number;
-    /** First restart delay; doubles per consecutive failure up to 60s. */
-    restartBaseDelayMs?: number;
-    /** Uptime that counts as a healthy run and resets the failure streak. */
-    healthyUptimeMs?: number;
-}
 export declare class Supervisor {
     private processes;
     private managedStops;
@@ -22,13 +13,9 @@ export declare class Supervisor {
     private logs;
     private onStatusChange?;
     private isShuttingDown;
-    private childOutput;
-    private pendingRestarts;
-    private intentionalStops;
-    private readonly maxRestarts;
-    private readonly restartBaseDelayMs;
-    private readonly healthyUptimeMs;
-    constructor(options?: SupervisorOptions);
+    constructor(options?: {
+        handleProcessSignals?: boolean;
+    });
     private shutdown;
     private killAll;
     setStatusChangeHandler(handler: StatusChangeHandler): void;
@@ -44,16 +31,6 @@ export declare class Supervisor {
     startAll(): Promise<void>;
     stopAll(): Promise<void>;
     start(name: string): void;
-    /**
-     * Stop restarting a service and say why. The gateway must not keep advertising itself as
-     * healthy afterwards: readiness derives from supervised state, not from HTTP reachability.
-     */
-    private giveUp;
-    /**
-     * Readiness of the supervised set: every configured child must be running. Managed services
-     * (for example the gateway itself) are lifecycle-owned elsewhere and are not required here.
-     */
-    isReady(): boolean;
     stop(name: string): Promise<void>;
     restart(name: string): Promise<boolean>;
     getStatus(name: string): ServiceState | undefined;

package/dist/supervisor/Supervisor.js

@@ -8,29 +8,6 @@ const node_child_process_1 = require("node:child_process");
 const tree_kill_1 = __importDefault(require("tree-kill"));
 const MAX_RESTARTS = 5;
 const MAX_LOGS = 500;
-/** Restart backoff: 2s, 4s, 8s, 16s, 32s, capped at 60s. */
-const RESTART_BASE_DELAY_MS = 2_000;
-const RESTART_MAX_DELAY_MS = 60_000;
-/** A run that stays up this long counts as healthy and clears the failure streak. */
-const HEALTHY_UPTIME_MS = 60_000;
-/** Bounded tail of child output kept per service for crash diagnosis. */
-const MAX_CHILD_OUTPUT_LINES = 20;
-/**
- * Failures that cannot be fixed by retrying: the child's own runtime cannot resolve a module,
- * so every restart fails identically. Retrying only hides the breakage behind a healthy-looking
- * gateway, which is exactly how the audited instance stayed half-dead for hours (N20).
- */
-const NON_RETRYABLE_PATTERNS = [
-    { pattern: /Cannot find package ['"][^'"]+['"]/u, reason: 'missing dependency (Cannot find package)' },
-    { pattern: /Cannot find module ['"][^'"]+['"]/u, reason: 'missing module (Cannot find module)' },
-    { pattern: /\bMODULE_NOT_FOUND\b/u, reason: 'missing module (MODULE_NOT_FOUND)' },
-];
-/** Mask credentials before child output is stored in supervisor state or served over HTTP. */
-function redactSecrets(line) {
-    return line
-        .replace(/([A-Za-z0-9_]*(?:token|secret|password|passwd|api[_-]?key|credential)[A-Za-z0-9_]*)(\s*[:=]\s*)("[^"]*"|'[^']*'|\S+)/giu, (_match, key, separator) => `${key}${separator}***`)
-        .replace(/\b([Bb]earer)\s+[A-Za-z0-9\-._~+/=]{8,}/gu, '$1 ***');
-}
 class Supervisor {
     constructor(options = {}) {
         this.processes = new Map();
@@ -39,12 +16,6 @@ class Supervisor {
         this.configs = new Map();
         this.logs = [];
         this.isShuttingDown = false;
-        this.childOutput = new Map();
-        this.pendingRestarts = new Map();
-        this.intentionalStops = new Set();
-        this.maxRestarts = options.maxRestarts ?? MAX_RESTARTS;
-        this.restartBaseDelayMs = options.restartBaseDelayMs ?? RESTART_BASE_DELAY_MS;
-        this.healthyUptimeMs = options.healthyUptimeMs ?? HEALTHY_UPTIME_MS;
         if (options.handleProcessSignals === false) {
             return;
         }
@@ -140,10 +111,6 @@ class Supervisor {
     }
     async stopAll() {
         this.isShuttingDown = true;
-        for (const [name, timer] of this.pendingRestarts) {
-            clearTimeout(timer);
-            this.pendingRestarts.delete(name);
-        }
         const promises = [];
         for (const name of this.processes.keys()) {
             promises.push(this.stop(name));
@@ -162,16 +129,9 @@ class Supervisor {
             return;
         if (state.status === 'running' || state.status === 'starting')
             return;
-        const pendingRestart = this.pendingRestarts.get(name);
-        if (pendingRestart) {
-            clearTimeout(pendingRestart);
-            this.pendingRestarts.delete(name);
-        }
-        this.intentionalStops.delete(name);
-        this.childOutput.set(name, []);
         console.log(`[Supervisor] Starting ${name}...`);
         this.addLog(name, 'info', 'Service starting');
-        this.updateState(name, { status: 'starting', startTime: Date.now(), givenUpReason: undefined });
+        this.updateState(name, { status: 'starting', startTime: Date.now() });
         const env = config.env ?? process.env;
         const child = (0, node_child_process_1.spawn)(config.command, config.args, {
             stdio: ['ignore', 'pipe', 'pipe'],
@@ -181,16 +141,6 @@ class Supervisor {
         });
         this.processes.set(name, child);
         this.updateState(name, { status: 'running', pid: child.pid });
-        const recordOutput = (line) => {
-            const tail = this.childOutput.get(name);
-            if (!tail) {
-                return;
-            }
-            tail.push(line);
-            if (tail.length > MAX_CHILD_OUTPUT_LINES) {
-                tail.splice(0, tail.length - MAX_CHILD_OUTPUT_LINES);
-            }
-        };
         const prefixLog = (source, data, isError = false) => {
             const output = data.toString();
             const lines = output.split('\n');
@@ -199,18 +149,13 @@ class Supervisor {
                 if (!trimmed) {
                     continue;
                 }
-                // Redact once, at the single point where child output enters supervisor state:
-                // the console, the log ring buffer (served by /service/logs) and the retained
-                // crash tail must not disagree about what the child printed.
-                const text = redactSecrets(trimmed);
-                recordOutput(text);
                 if (isError) {
-                    console.error(`[${source}] ${text}`);
-                    this.addLog(source, 'error', text);
+                    console.error(`[${source}] ${trimmed}`);
+                    this.addLog(source, 'error', trimmed);
                 }
                 else {
-                    console.log(`[${source}] ${text}`);
-                    this.addLog(source, 'info', text);
+                    console.log(`[${source}] ${trimmed}`);
+                    this.addLog(source, 'info', trimmed);
                 }
             }
         };
@@ -223,94 +168,44 @@ class Supervisor {
         child.on('error', (err) => {
             console.error(`[Supervisor] Error spawning ${name}:`, err);
             this.addLog(name, 'error', `Spawn error: ${String(err)}`);
-            this.updateState(name, { status: 'crashed', givenUpReason: `Spawn error: ${String(err)}` });
+            this.updateState(name, { status: 'crashed' });
         });
         child.on('exit', (code, signal) => {
-            const exitedAt = Date.now();
-            const stateBeforeExit = this.states.get(name);
-            const uptimeMs = stateBeforeExit?.startTime ? exitedAt - stateBeforeExit.startTime : 0;
-            const wasManualStop = stateBeforeExit?.status === 'stopped' || this.intentionalStops.has(name);
-            const wasHealthy = uptimeMs >= this.healthyUptimeMs;
-            const consecutiveFailures = wasHealthy ? 0 : (stateBeforeExit?.consecutiveFailures ?? 0) + 1;
-            const outputTail = this.childOutput.get(name) ?? [];
-            const nonRetryable = NON_RETRYABLE_PATTERNS.find(({ pattern }) => outputTail.some((line) => pattern.test(line)));
             console.log(`[Supervisor] ${name} exited with code ${code} signal ${signal}`);
             this.addLog(name, code === 0 ? 'info' : 'error', `Exited with code ${code ?? 'null'} signal ${signal ?? 'null'}`);
-            this.processes.delete(name);
-            this.childOutput.delete(name);
-            this.intentionalStops.delete(name);
+            const currentState = this.states.get(name);
+            const wasManualStop = currentState?.status === 'stopped';
             this.updateState(name, {
                 status: 'stopped',
                 lastExitCode: code ?? undefined,
-                lastExitAt: exitedAt,
-                lastOutput: outputTail,
-                consecutiveFailures,
                 pid: undefined,
             });
-            // Auto-restart on crash (not on clean exit, manual stop or shutdown)
-            if (code === 0 || wasManualStop || this.isShuttingDown) {
-                return;
-            }
-            if (nonRetryable) {
-                this.giveUp(name, `Unrecoverable child failure: ${nonRetryable.reason}; restart suppressed`, consecutiveFailures);
-                return;
-            }
-            if (consecutiveFailures > this.maxRestarts) {
-                this.giveUp(name, `Exceeded max restarts (budget ${this.maxRestarts}, ${consecutiveFailures} consecutive failures)`, consecutiveFailures);
-                return;
+            this.processes.delete(name);
+            // Auto-restart on crash (not on manual stop or shutdown)
+            if (code !== 0 && !wasManualStop && !this.isShuttingDown) {
+                const newState = this.states.get(name);
+                const restartCount = (newState?.restartCount || 0) + 1;
+                if (restartCount <= MAX_RESTARTS) {
+                    this.updateState(name, { restartCount });
+                    console.log(`[Supervisor] Restarting ${name} in 2s... (attempt ${restartCount}/${MAX_RESTARTS})`);
+                    this.addLog(name, 'warn', `Restarting in 2s (attempt ${restartCount}/${MAX_RESTARTS})`);
+                    setTimeout(() => this.start(name), 2000);
+                }
+                else {
+                    console.error(`[Supervisor] ${name} exceeded max restarts (${MAX_RESTARTS}), giving up`);
+                    this.addLog(name, 'error', `Exceeded max restarts (${MAX_RESTARTS})`);
+                }
             }
-            const delay = Math.min(this.restartBaseDelayMs * 2 ** (consecutiveFailures - 1), RESTART_MAX_DELAY_MS);
-            this.updateState(name, { restartCount: (stateBeforeExit?.restartCount ?? 0) + 1 });
-            const attempt = `(${consecutiveFailures}/${this.maxRestarts} consecutive failures)`;
-            console.log(`[Supervisor] Restarting ${name} in ${delay}ms... ${attempt}`);
-            this.addLog(name, 'warn', `Restarting in ${Math.round(delay / 1000)}s ${attempt}`);
-            const timer = setTimeout(() => {
-                this.pendingRestarts.delete(name);
-                this.start(name);
-            }, delay);
-            this.pendingRestarts.set(name, timer);
         });
     }
-    /**
-     * Stop restarting a service and say why. The gateway must not keep advertising itself as
-     * healthy afterwards: readiness derives from supervised state, not from HTTP reachability.
-     */
-    giveUp(name, reason, consecutiveFailures) {
-        console.error(`[Supervisor] ${name}: ${reason}`);
-        this.addLog(name, 'error', `Giving up on ${name}: ${reason}`);
-        this.updateState(name, { status: 'given-up', givenUpReason: reason, consecutiveFailures });
-    }
-    /**
-     * Readiness of the supervised set: every configured child must be running. Managed services
-     * (for example the gateway itself) are lifecycle-owned elsewhere and are not required here.
-     */
-    isReady() {
-        for (const name of this.configs.keys()) {
-            if (this.states.get(name)?.status !== 'running') {
-                return false;
-            }
-        }
-        return true;
-    }
     stop(name) {
         return new Promise((resolve) => {
-            const pendingRestart = this.pendingRestarts.get(name);
-            if (pendingRestart) {
-                // A service waiting out its backoff is not running, but it is not stopped either:
-                // cancel the timer so a stop request cannot be undone by a scheduled restart.
-                clearTimeout(pendingRestart);
-                this.pendingRestarts.delete(name);
-            }
             const child = this.processes.get(name);
             if (!child || !child.pid) {
-                if (this.states.has(name)) {
-                    this.updateState(name, { status: 'stopped', pid: undefined, givenUpReason: undefined });
-                }
                 resolve();
                 return;
             }
             // Mark as stopped first to prevent auto-restart
-            this.intentionalStops.add(name);
             this.updateState(name, { status: 'stopped' });
             this.addLog(name, 'info', 'Stopping service');
             (0, tree_kill_1.default)(child.pid, 'SIGTERM', (err) => {
@@ -335,8 +230,6 @@ class Supervisor {
             this.addLog(name, 'error', 'Timed out waiting for service to stop before restart');
             return false;
         }
-        // An explicit restart follows a deliberate operator action: grant a fresh retry budget.
-        this.updateState(name, { consecutiveFailures: 0, givenUpReason: undefined });
         this.addLog(name, 'info', 'Service restart requested');
         this.start(name);
         return true;

package/dist/supervisor/types.d.ts

@@ -6,12 +6,7 @@ export interface ServiceConfig {
     cwd?: string;
     readyUrl?: string;
 }
-/**
- * `given-up` means the supervisor stopped restarting the child on purpose (unrecoverable
- * failure or exhausted retries). It is distinct from `stopped` (intentional stop) and
- * `crashed` (spawn failed) because a given-up child never returns without operator action.
- */
-export type ServiceStatus = 'stopped' | 'starting' | 'running' | 'crashed' | 'given-up';
+export type ServiceStatus = 'stopped' | 'starting' | 'running' | 'crashed';
 export interface ServiceState {
     name: string;
     status: ServiceStatus;
@@ -19,14 +14,6 @@ export interface ServiceState {
     startTime?: number;
     uptime?: number;
     lastExitCode?: number;
-    /** Epoch millis of the last child exit, so a stale crash can be told apart from a live one. */
-    lastExitAt?: number;
     restartCount: number;
-    /** Consecutive failed runs; a run that stayed up long enough clears it. */
-    consecutiveFailures?: number;
-    /** Bounded, redacted tail of the child's own output, for diagnosing a crash without shell access. */
-    lastOutput?: string[];
-    /** Why the supervisor stopped restarting this service (set while status is `given-up`). */
-    givenUpReason?: string;
 }
 export type StatusChangeHandler = (name: string, state: ServiceState) => void;

package/dist/test-utils/local-managed-client-p2p-e2e-smoke.js

@@ -66,24 +66,9 @@ async function runLocalManagedClientP2PE2ESmoke(options = {}) {
                 nodeId,
                 baseUrl: `https://${nodeId}.${baseStorageDomain}/`,
             });
-            // The node serves many sessions on one socket, so it resolves the per-session data plane
-            // secret from the signaling API on handshake (audit N03). A session without a secret is
-            // refused there, which is why the smoke client always creates one.
-            const dataPlaneSignaling = (0, reachability_1.createP2PSignalingClient)({
-                apiBaseUrl: signalApi.baseUrl,
-                nodeId,
-                token: nodeToken,
-            });
             const dataPlaneServer = (0, reachability_1.createTcpP2PDataPlaneServer)({
                 handler: (0, reachability_1.createP2PDataPlaneHandler)({ targetBaseUrl: target.baseUrl }),
                 host: p2pHost,
-                secure: {
-                    role: 'server',
-                    resolveSessionSecret: async (sessionId) => {
-                        const session = await dataPlaneSignaling.getP2PSession(sessionId);
-                        return session.dataPlaneSecret;
-                    },
-                },
             });
             await dataPlaneServer.listen(0);
             nodePlan = {

package/dist/tunnel/LocalTunnelProvider.d.ts

@@ -10,8 +10,6 @@ export interface LocalTunnelProviderOptions {
     publicUrl?: string;
     /** cloudflared 可执行文件路径 (默认 'cloudflared') */
     cloudflaredPath?: string;
-    /** Environment used to resolve the client binary; injectable for tests. */
-    env?: Record<string, string | undefined>;
     /** 等待代理发布的毫秒数；超时后状态为 failed，而不是"仍在连接" */
     connectTimeoutMs?: number;
 }
@@ -98,11 +96,6 @@ export declare class LocalTunnelProvider implements TunnelProvider {
  *
  * Both halves are reported: pointing the dashboard at `https://localhost:<port>` while this
  * runtime serves plain HTTP there fails the TLS handshake, and the edge shows only a 502.
- *
- * cloudflared logs the configuration it fetched as an escaped JSON string inside one log line
- * (`config="{\"ingress\":[{\"service\":\"http://localhost:5737\"}]}"`), so the quotes around
- * the JSON keys arrive backslash-escaped. Unescaping first is what makes this read-back work
- * against a real connector; a line where the JSON is not escaped is still accepted.
  */
 export declare function readDashboardOrigin(output: string): {
     scheme: string;

package/dist/tunnel/LocalTunnelProvider.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalTunnelProvider = void 0;
 exports.readDashboardOrigin = readDashboardOrigin;
-const TunnelClientResolver_1 = require("./TunnelClientResolver");
 const node_child_process_1 = require("node:child_process");
 const global_logger_factory_1 = require("global-logger-factory");
 const TunnelLifecycle_1 = require("./TunnelLifecycle");
@@ -33,8 +32,7 @@ class LocalTunnelProvider {
         this.managedByUs = false;
         this.tunnelToken = options.tunnelToken;
         this.publicUrl = normalizePublicEndpoint(options.publicUrl);
-        this.cloudflaredPath = options.cloudflaredPath
-            ?? (0, TunnelClientResolver_1.resolveTunnelClient)('cloudflare', { env: options.env }).command;
+        this.cloudflaredPath = options.cloudflaredPath ?? 'cloudflared';
         this.connectTimeoutMs = options.connectTimeoutMs ?? 30_000;
     }
     /**
@@ -347,16 +345,10 @@ function normalizePublicEndpoint(value) {
  *
  * Both halves are reported: pointing the dashboard at `https://localhost:<port>` while this
  * runtime serves plain HTTP there fails the TLS handshake, and the edge shows only a 502.
- *
- * cloudflared logs the configuration it fetched as an escaped JSON string inside one log line
- * (`config="{\"ingress\":[{\"service\":\"http://localhost:5737\"}]}"`), so the quotes around
- * the JSON keys arrive backslash-escaped. Unescaping first is what makes this read-back work
- * against a real connector; a line where the JSON is not escaped is still accepted.
  */
 function readDashboardOrigin(output) {
-    const unescaped = output.includes('\\"') ? output.replace(/\\"/gu, '"') : output;
-    const match = /"service"\s*:\s*"(https?):\/\/(?:localhost|127\.0\.0\.1):(\d+)/iu.exec(unescaped)
-        ?? /ingress[^\n]*service["']?\s*[:=]\s*["']?(https?):\/\/(?:localhost|127\.0\.0\.1):(\d+)/iu.exec(unescaped);
+    const match = /"service"\s*:\s*"(https?):\/\/(?:localhost|127\.0\.0\.1):(\d+)/iu.exec(output)
+        ?? /ingress[^\n]*service["']?\s*[:=]\s*["']?(https?):\/\/(?:localhost|127\.0\.0\.1):(\d+)/iu.exec(output);
     if (!match) {
         return undefined;
     }

package/dist/tunnel/LocalTunnelProvider.jsonld

@@ -44,30 +44,6 @@
           },
           "comment": "cloudflared 可执行文件路径 (默认 'cloudflared')"
         },
-        {
-          "@id": "undefineds:dist/tunnel/LocalTunnelProvider.jsonld#LocalTunnelProvider_options_env",
-          "range": {
-            "@type": "ParameterRangeCollectEntries",
-            "parameterRangeCollectEntriesParameters": [
-              {
-                "@id": "undefineds:dist/tunnel/LocalTunnelProvider.jsonld#LocalTunnelProvider_options_env_key"
-              },
-              {
-                "@id": "undefineds:dist/tunnel/LocalTunnelProvider.jsonld#LocalTunnelProvider_options_env_value",
-                "range": {
-                  "@type": "ParameterRangeUnion",
-                  "parameterRangeElements": [
-                    "xsd:string",
-                    {
-                      "@type": "ParameterRangeUndefined"
-                    }
-                  ]
-                }
-              }
-            ]
-          },
-          "comment": "Environment used to resolve the client binary; injectable for tests."
-        },
         {
           "@id": "undefineds:dist/tunnel/LocalTunnelProvider.jsonld#LocalTunnelProvider_options_connectTimeoutMs",
           "range": {
@@ -202,21 +178,6 @@
                 "@id": "undefineds:dist/tunnel/LocalTunnelProvider.jsonld#LocalTunnelProvider_options_cloudflaredPath"
               }
             },
-            {
-              "keyRaw": "env",
-              "value": {
-                "@id": "undefineds:dist/tunnel/LocalTunnelProvider.jsonld#LocalTunnelProvider_options_env__constructorArgument",
-                "fields": [
-                  {
-                    "collectEntries": "undefineds:dist/tunnel/LocalTunnelProvider.jsonld#LocalTunnelProvider_options_env",
-                    "key": "undefineds:dist/tunnel/LocalTunnelProvider.jsonld#LocalTunnelProvider_options_env_key",
-                    "value": {
-                      "@id": "undefineds:dist/tunnel/LocalTunnelProvider.jsonld#LocalTunnelProvider_options_env_value"
-                    }
-                  }
-                ]
-              }
-            },
             {
               "keyRaw": "connectTimeoutMs",
               "value": {

package/dist/tunnel/NgrokTunnelProvider.d.ts

@@ -6,8 +6,6 @@ export interface NgrokTunnelProviderOptions {
     url?: string;
     /** ngrok executable path. */
     ngrokPath?: string;
-    /** Environment used to resolve the client binary; injectable for tests. */
-    env?: Record<string, string | undefined>;
     /** ngrok local Agent API, used to discover generated dev domains. */
     agentApiUrl?: string;
     /** Startup wait timeout. */

package/dist/tunnel/NgrokTunnelProvider.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NgrokTunnelProvider = void 0;
 exports.isLocalAgentUrl = isLocalAgentUrl;
-const TunnelClientResolver_1 = require("./TunnelClientResolver");
 const node_child_process_1 = require("node:child_process");
 const global_logger_factory_1 = require("global-logger-factory");
 const TunnelLifecycle_1 = require("./TunnelLifecycle");
@@ -27,8 +26,7 @@ class NgrokTunnelProvider {
         this.managedByUs = false;
         this.authtoken = options.authtoken;
         this.configuredUrl = normalizeEndpointForCli(options.url);
-        this.ngrokPath = options.ngrokPath
-            ?? (0, TunnelClientResolver_1.resolveTunnelClient)('ngrok', { env: options.env }).command;
+        this.ngrokPath = options.ngrokPath ?? 'ngrok';
         this.agentApiUrl = options.agentApiUrl ?? 'http://127.0.0.1:4040';
         this.connectTimeoutMs = options.connectTimeoutMs ?? 30_000;
     }