@workclaw/openclaw-workclaw 1.0.339 → 1.0.341

package/dist/message.gateway.runtime-DiohkxSb.js

@@ -0,0 +1,1705 @@
+import { F as normalizeOptionalString, r as resolveSecretInputRef, h as hasConfiguredSecretInput, G as secretRefKey, H as isValidExecSecretRefId, I as formatExecSecretRefIdValidationMessage, J as resolveDefaultSecretProviderAlias, S as SINGLE_VALUE_FILE_REF_ID, K as resolveUserPath, N as readSecureFile, z as isRecord, O as FsSafeError, o as isPathInside, P as inspectPathPermissions, Q as safeStat, g as normalizeSecretInputString } from "./plugin-load-profile-DOnG9jJ5-zOQuKNoi.js";
+import { bF as containsEnvVarReference, bG as resolveSafeTimeoutDelayMs, bH as resolveConnectChallengeTimeoutMs, O as resolveConfigPath, X as resolveGatewayPort, bI as redactSensitiveUrlLikeString, bJ as isSecureWebSocketUrl, bt as formatErrorMessage, bK as isDynamicOperatorGatewayMethod, bL as WRITE_SCOPE, bM as ADMIN_SCOPE, bN as READ_SCOPE, bO as APPROVALS_SCOPE, bP as PAIRING_SCOPE, bQ as TALK_SECRETS_SCOPE, bR as resolveCoreOperatorGatewayMethodScope, bS as resolveReservedGatewayMethodScope, bT as getPluginRegistryState, bU as resolvePreauthHandshakeTimeoutMs, bV as loadGatewayTlsRuntime, a4 as resolveStateDir, bW as loadOrCreateDeviceIdentity, i as getRuntimeConfig, bX as GatewayClient, bD as GATEWAY_CLIENT_MODES, bY as VERSION, bE as GATEWAY_CLIENT_NAMES, bZ as isGatewayConnectAssemblyError, b_ as isLoopbackIpAddress } from "./index-C_m6K5Z1.js";
+import "node:fs";
+import path__default from "node:path";
+import fs$1__default from "node:fs/promises";
+import "node:os";
+import { randomUUID } from "node:crypto";
+import "node:stream/promises";
+import "node:stream";
+import { spawn } from "node:child_process";
+const trimToUndefined = normalizeOptionalString;
+function trimCredentialToUndefined(value) {
+  const trimmed = trimToUndefined(value);
+  if (trimmed && containsEnvVarReference(trimmed)) return;
+  return trimmed;
+}
+function resolveConfiguredGatewayCredentialInput(params) {
+  const ref = resolveSecretInputRef({
+    value: params.value,
+    defaults: params.defaults
+  }).ref;
+  return {
+    path: params.path,
+    configured: hasConfiguredSecretInput(params.value, params.defaults),
+    value: ref ? void 0 : trimToUndefined(params.value),
+    refPath: ref ? params.path : void 0,
+    hasSecretRef: ref !== null
+  };
+}
+function createGatewayCredentialPlan(params) {
+  const env = params.env ?? process.env;
+  const gateway = params.config.gateway;
+  const remote = gateway?.remote;
+  const defaults = params.defaults ?? params.config.secrets?.defaults;
+  const authMode = gateway?.auth?.mode;
+  const envToken = trimToUndefined(env.OPENCLAW_GATEWAY_TOKEN);
+  const envPassword = trimToUndefined(env.OPENCLAW_GATEWAY_PASSWORD);
+  const localToken = resolveConfiguredGatewayCredentialInput({
+    value: gateway?.auth?.token,
+    defaults,
+    path: "gateway.auth.token"
+  });
+  const localPassword = resolveConfiguredGatewayCredentialInput({
+    value: gateway?.auth?.password,
+    defaults,
+    path: "gateway.auth.password"
+  });
+  const remoteToken = resolveConfiguredGatewayCredentialInput({
+    value: remote?.token,
+    defaults,
+    path: "gateway.remote.token"
+  });
+  const remotePassword = resolveConfiguredGatewayCredentialInput({
+    value: remote?.password,
+    defaults,
+    path: "gateway.remote.password"
+  });
+  const localTokenCanWin = authMode !== "password" && authMode !== "none" && authMode !== "trusted-proxy";
+  const tokenCanWin = Boolean(envToken || localToken.configured || remoteToken.configured);
+  const passwordCanWin = authMode === "password" || authMode === "trusted-proxy" || authMode !== "token" && authMode !== "none" && !tokenCanWin;
+  const localTokenSurfaceActive = localTokenCanWin && !envToken && (authMode === "token" || authMode === void 0 && !(envPassword || localPassword.configured));
+  const remoteMode = gateway?.mode === "remote";
+  const remoteUrlConfigured = Boolean(trimToUndefined(remote?.url));
+  const tailscaleRemoteExposure = gateway?.tailscale?.mode === "serve" || gateway?.tailscale?.mode === "funnel";
+  const remoteConfiguredSurface = remoteMode || remoteUrlConfigured || tailscaleRemoteExposure;
+  const remoteTokenFallbackActive = localTokenCanWin && !envToken && !localToken.configured;
+  const remotePasswordFallbackActive = authMode !== "trusted-proxy" && !envPassword && !localPassword.configured && passwordCanWin;
+  return {
+    configuredMode: gateway?.mode === "remote" ? "remote" : "local",
+    authMode,
+    envToken,
+    envPassword,
+    localToken,
+    localPassword,
+    remoteToken,
+    remotePassword,
+    localTokenCanWin,
+    localPasswordCanWin: passwordCanWin,
+    localTokenSurfaceActive,
+    tokenCanWin,
+    passwordCanWin,
+    remoteMode,
+    remoteUrlConfigured,
+    tailscaleRemoteExposure,
+    remoteConfiguredSurface,
+    remoteTokenFallbackActive,
+    remoteTokenActive: remoteConfiguredSurface || remoteTokenFallbackActive,
+    remotePasswordFallbackActive,
+    remotePasswordActive: remoteConfiguredSurface || remotePasswordFallbackActive
+  };
+}
+const GATEWAY_SECRET_REF_UNAVAILABLE_ERROR_CODE = "GATEWAY_SECRET_REF_UNAVAILABLE";
+var GatewaySecretRefUnavailableError = class extends Error {
+  constructor(path) {
+    super([
+      `${path} is configured as a secret reference but is unavailable in this command path.`,
+      "Fix: set OPENCLAW_GATEWAY_TOKEN/OPENCLAW_GATEWAY_PASSWORD, pass explicit --token/--password,",
+      "or run a gateway command path that resolves secret references before credential selection."
+    ].join("\n"));
+    this.code = GATEWAY_SECRET_REF_UNAVAILABLE_ERROR_CODE;
+    this.name = "GatewaySecretRefUnavailableError";
+    this.path = path;
+  }
+};
+function firstDefined(values) {
+  for (const value of values) if (value) return value;
+}
+function throwUnresolvedGatewaySecretInput(path) {
+  throw new GatewaySecretRefUnavailableError(path);
+}
+function resolveGatewayCredentialsFromValues(params) {
+  const env = params.env ?? process.env;
+  const envToken = trimToUndefined(env.OPENCLAW_GATEWAY_TOKEN);
+  const envPassword = trimToUndefined(env.OPENCLAW_GATEWAY_PASSWORD);
+  const configToken = trimCredentialToUndefined(params.configToken);
+  const configPassword = trimCredentialToUndefined(params.configPassword);
+  const tokenPrecedence = params.tokenPrecedence ?? "env-first";
+  const passwordPrecedence = params.passwordPrecedence ?? "env-first";
+  return {
+    token: tokenPrecedence === "config-first" ? firstDefined([configToken, envToken]) : firstDefined([envToken, configToken]),
+    password: passwordPrecedence === "config-first" ? firstDefined([configPassword, envPassword]) : firstDefined([envPassword, configPassword])
+  };
+}
+function resolveLocalGatewayCredentials(params) {
+  const localResolved = resolveGatewayCredentialsFromValues({
+    configToken: params.plan.localToken.configured ? params.plan.localToken.value : params.plan.remoteToken.value,
+    configPassword: params.plan.localPassword.configured ? params.plan.localPassword.value : params.plan.authMode === "trusted-proxy" ? void 0 : params.plan.remotePassword.value,
+    env: params.env,
+    tokenPrecedence: params.localTokenPrecedence,
+    passwordPrecedence: params.localPasswordPrecedence
+  });
+  const localPasswordCanWin = params.plan.authMode === "password" || params.plan.authMode === "trusted-proxy" || params.plan.authMode !== "token" && params.plan.authMode !== "none" && !localResolved.token;
+  const localTokenCanWin = params.plan.authMode === "token" || params.plan.authMode !== "password" && params.plan.authMode !== "none" && params.plan.authMode !== "trusted-proxy" && !localResolved.password;
+  if (params.plan.localToken.refPath && params.localTokenPrecedence === "config-first" && !params.plan.localToken.value && Boolean(params.plan.envToken) && localTokenCanWin) throwUnresolvedGatewaySecretInput(params.plan.localToken.refPath);
+  if (params.plan.localPassword.refPath && params.localPasswordPrecedence === "config-first" && !params.plan.localPassword.value && Boolean(params.plan.envPassword) && localPasswordCanWin) throwUnresolvedGatewaySecretInput(params.plan.localPassword.refPath);
+  if (params.plan.localToken.refPath && !localResolved.token && !params.plan.envToken && localTokenCanWin) throwUnresolvedGatewaySecretInput(params.plan.localToken.refPath);
+  if (params.plan.localPassword.refPath && !localResolved.password && !params.plan.envPassword && localPasswordCanWin) throwUnresolvedGatewaySecretInput(params.plan.localPassword.refPath);
+  return localResolved;
+}
+function resolveRemoteGatewayCredentials(params) {
+  const token = params.remoteTokenFallback === "remote-only" ? params.plan.remoteToken.value : params.remoteTokenPrecedence === "env-first" ? firstDefined([
+    params.plan.envToken,
+    params.plan.remoteToken.value,
+    params.plan.localToken.value
+  ]) : firstDefined([
+    params.plan.remoteToken.value,
+    params.plan.envToken,
+    params.plan.localToken.value
+  ]);
+  const password = params.remotePasswordFallback === "remote-only" ? params.plan.remotePassword.value : params.remotePasswordPrecedence === "env-first" ? firstDefined([
+    params.plan.envPassword,
+    params.plan.remotePassword.value,
+    params.plan.localPassword.value
+  ]) : firstDefined([
+    params.plan.remotePassword.value,
+    params.plan.envPassword,
+    params.plan.localPassword.value
+  ]);
+  const localTokenFallbackEnabled = params.remoteTokenFallback !== "remote-only";
+  const localTokenFallback = params.remoteTokenFallback === "remote-only" ? void 0 : params.plan.localToken.value;
+  const localPasswordFallback = params.remotePasswordFallback === "remote-only" ? void 0 : params.plan.localPassword.value;
+  if (params.plan.remoteToken.refPath && !token && !params.plan.envToken && !localTokenFallback && !password) throwUnresolvedGatewaySecretInput(params.plan.remoteToken.refPath);
+  if (params.plan.remotePassword.refPath && !password && !params.plan.envPassword && !localPasswordFallback && !token) throwUnresolvedGatewaySecretInput(params.plan.remotePassword.refPath);
+  if (params.plan.localToken.refPath && localTokenFallbackEnabled && !token && !password && !params.plan.envToken && !params.plan.remoteToken.value && params.plan.localTokenCanWin) throwUnresolvedGatewaySecretInput(params.plan.localToken.refPath);
+  return {
+    token,
+    password
+  };
+}
+function resolveGatewayCredentialsFromConfig(params) {
+  const env = params.env ?? process.env;
+  const explicitToken = trimToUndefined(params.explicitAuth?.token);
+  const explicitPassword = trimToUndefined(params.explicitAuth?.password);
+  if (explicitToken || explicitPassword) return {
+    token: explicitToken,
+    password: explicitPassword
+  };
+  if (trimToUndefined(params.urlOverride) && params.urlOverrideSource !== "env") return {};
+  if (trimToUndefined(params.urlOverride) && params.urlOverrideSource === "env") return resolveGatewayCredentialsFromValues({
+    configToken: void 0,
+    configPassword: void 0,
+    env,
+    tokenPrecedence: "env-first",
+    passwordPrecedence: "env-first"
+  });
+  const plan = createGatewayCredentialPlan({
+    config: params.cfg,
+    env
+  });
+  const mode = params.modeOverride ?? plan.configuredMode;
+  const localTokenPrecedence = params.localTokenPrecedence ?? (env.OPENCLAW_SERVICE_KIND === "gateway" ? "config-first" : "env-first");
+  const localPasswordPrecedence = params.localPasswordPrecedence ?? "env-first";
+  if (mode === "local") return resolveLocalGatewayCredentials({
+    plan,
+    env,
+    localTokenPrecedence,
+    localPasswordPrecedence
+  });
+  const remoteTokenFallback = params.remoteTokenFallback ?? "remote-env-local";
+  const remotePasswordFallback = params.remotePasswordFallback ?? "remote-env-local";
+  return resolveRemoteGatewayCredentials({
+    plan,
+    remoteTokenPrecedence: params.remoteTokenPrecedence ?? "remote-first",
+    remotePasswordPrecedence: params.remotePasswordPrecedence ?? "env-first",
+    remoteTokenFallback,
+    remotePasswordFallback
+  });
+}
+const DEFAULT_MAX_WAIT_MS = 1e4;
+const DEFAULT_INTERVAL_MS = 1;
+const DEFAULT_DRIFT_THRESHOLD_MS = 200;
+const DEFAULT_CONSECUTIVE_READY_CHECKS = 2;
+function resolvePositiveInteger(value, fallback) {
+  return Number.isFinite(value) && value !== void 0 ? Math.max(1, Math.floor(value)) : fallback;
+}
+async function waitForEventLoopReady(options = {}) {
+  const maxWaitMs = resolveSafeTimeoutDelayMs(options.maxWaitMs ?? DEFAULT_MAX_WAIT_MS);
+  const intervalMs = resolvePositiveInteger(options.intervalMs, DEFAULT_INTERVAL_MS);
+  const driftThresholdMs = resolvePositiveInteger(options.driftThresholdMs, DEFAULT_DRIFT_THRESHOLD_MS);
+  const consecutiveReadyChecks = resolvePositiveInteger(options.consecutiveReadyChecks, DEFAULT_CONSECUTIVE_READY_CHECKS);
+  const signal = options.signal;
+  const startedAt = Date.now();
+  let readyChecks = 0;
+  let checks = 0;
+  let maxDriftMs = 0;
+  return await new Promise((resolve) => {
+    let settled = false;
+    let timer = null;
+    const clearTimer = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    };
+    const finish = (ready, aborted = false) => {
+      if (settled) return;
+      settled = true;
+      clearTimer();
+      signal?.removeEventListener("abort", onAbort);
+      resolve({
+        ready,
+        elapsedMs: Math.max(0, Date.now() - startedAt),
+        maxDriftMs,
+        checks,
+        aborted
+      });
+    };
+    const onAbort = () => {
+      finish(false, true);
+    };
+    if (signal?.aborted) {
+      finish(false, true);
+      return;
+    }
+    signal?.addEventListener("abort", onAbort, { once: true });
+    const scheduleNext = () => {
+      if (signal?.aborted) {
+        finish(false, true);
+        return;
+      }
+      const remainingMs = maxWaitMs - Math.max(0, Date.now() - startedAt);
+      if (remainingMs <= 0) {
+        finish(false);
+        return;
+      }
+      const delayMs = Math.min(intervalMs, remainingMs);
+      const scheduledAt = Date.now();
+      timer = setTimeout(() => {
+        timer = null;
+        checks += 1;
+        const driftMs = Math.max(0, Date.now() - scheduledAt - delayMs);
+        maxDriftMs = Math.max(maxDriftMs, driftMs);
+        if (driftMs > driftThresholdMs) readyChecks = 0;
+        else readyChecks += 1;
+        if (readyChecks >= consecutiveReadyChecks) {
+          finish(true);
+          return;
+        }
+        scheduleNext();
+      }, delayMs);
+    };
+    scheduleNext();
+  });
+}
+function resolveGatewayClientStartReadinessTimeoutMs(options = {}) {
+  if (typeof options.timeoutMs === "number" && Number.isFinite(options.timeoutMs)) return options.timeoutMs;
+  const clientOptions = options.clientOptions ?? {};
+  return resolveConnectChallengeTimeoutMs(typeof clientOptions.connectChallengeTimeoutMs === "number" && Number.isFinite(clientOptions.connectChallengeTimeoutMs) ? clientOptions.connectChallengeTimeoutMs : typeof clientOptions.connectDelayMs === "number" && Number.isFinite(clientOptions.connectDelayMs) ? clientOptions.connectDelayMs : void 0, { configuredTimeoutMs: clientOptions.preauthHandshakeTimeoutMs });
+}
+async function startGatewayClientWhenEventLoopReady(client, options = {}) {
+  const readiness = await waitForEventLoopReady({
+    maxWaitMs: resolveGatewayClientStartReadinessTimeoutMs(options),
+    signal: options.signal
+  });
+  if (readiness.ready && !readiness.aborted && options.signal?.aborted !== true) client.start();
+  return readiness;
+}
+function buildGatewayConnectionDetailsWithResolvers(options = {}, resolvers = {}) {
+  const config = options.config ?? resolvers.getRuntimeConfig?.() ?? {};
+  const configPath = options.configPath ?? resolvers.resolveConfigPath?.(process.env) ?? resolveConfigPath(process.env);
+  const isRemoteMode = config.gateway?.mode === "remote";
+  const remote = isRemoteMode ? config.gateway?.remote : void 0;
+  const tlsEnabled = config.gateway?.tls?.enabled === true;
+  const localPort = resolvers.resolveGatewayPort?.(config, process.env) ?? resolveGatewayPort(config);
+  const bindMode = config.gateway?.bind ?? "loopback";
+  const localUrl = `${tlsEnabled ? "wss" : "ws"}://127.0.0.1:${localPort}`;
+  const cliUrlOverride = normalizeOptionalString(options.url);
+  const envUrlOverride = cliUrlOverride || options.ignoreEnvUrlOverride ? void 0 : normalizeOptionalString(process.env.OPENCLAW_GATEWAY_URL);
+  const urlOverride = cliUrlOverride ?? envUrlOverride;
+  const remoteUrl = normalizeOptionalString(remote?.url);
+  const remoteMisconfigured = isRemoteMode && !urlOverride && !remoteUrl;
+  const urlSourceHint = options.urlSource ?? (cliUrlOverride ? "cli" : envUrlOverride ? "env" : void 0);
+  const url = urlOverride || remoteUrl || localUrl;
+  const displayUrl = redactSensitiveUrlLikeString(url);
+  const urlSource = urlOverride ? urlSourceHint === "env" ? "env OPENCLAW_GATEWAY_URL" : "cli --url" : remoteUrl ? "config gateway.remote.url" : remoteMisconfigured ? "missing gateway.remote.url (fallback local)" : "local loopback";
+  const bindDetail = !urlOverride && !remoteUrl ? `Bind: ${bindMode}` : void 0;
+  const remoteFallbackNote = remoteMisconfigured ? "Warn: gateway.mode=remote but gateway.remote.url is missing; set gateway.remote.url or switch gateway.mode=local." : void 0;
+  const allowPrivateWs = process.env.OPENCLAW_ALLOW_INSECURE_PRIVATE_WS === "1";
+  if (!isSecureWebSocketUrl(url, { allowPrivateWs })) throw new Error([
+    `SECURITY ERROR: Gateway URL "${displayUrl}" uses plaintext ws:// to a non-loopback address.`,
+    "Both credentials and chat data would be exposed to network interception.",
+    `Source: ${urlSource}`,
+    `Config: ${configPath}`,
+    "Fix: Use wss:// for remote gateway URLs.",
+    "Safe remote access defaults:",
+    "- keep gateway.bind=loopback and use an SSH tunnel (ssh -N -L 18789:127.0.0.1:18789 user@gateway-host)",
+    "- or use Tailscale Serve/Funnel for HTTPS remote access",
+    allowPrivateWs ? void 0 : "Break-glass (trusted private networks only): set OPENCLAW_ALLOW_INSECURE_PRIVATE_WS=1",
+    "Doctor: openclaw doctor --fix",
+    "Docs: https://docs.openclaw.ai/gateway/remote"
+  ].join("\n"));
+  return {
+    url,
+    urlSource,
+    bindDetail,
+    remoteFallbackNote,
+    message: [
+      `Gateway target: ${displayUrl}`,
+      `Source: ${urlSource}`,
+      `Config: ${configPath}`,
+      bindDetail,
+      remoteFallbackNote
+    ].filter(Boolean).join("\n")
+  };
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function normalizePositiveInt(value, fallback) {
+  if (typeof value === "number" && Number.isFinite(value)) return Math.max(1, Math.floor(value));
+  return Math.max(1, Math.floor(fallback));
+}
+async function runTasksWithConcurrency(params) {
+  const { tasks, limit, onTaskError } = params;
+  if (tasks.length === 0) return {
+    results: [],
+    firstError: void 0,
+    hasError: false
+  };
+  const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
+  const results = Array.from({ length: tasks.length });
+  let next = 0;
+  let firstError = void 0;
+  let hasError = false;
+  const workers = Array.from({ length: resolvedLimit }, async () => {
+    while (true) {
+      if (hasError) return;
+      const index = next;
+      next += 1;
+      if (index >= tasks.length) return;
+      try {
+        results[index] = await tasks[index]();
+      } catch (error) {
+        if (!hasError) {
+          firstError = error;
+          hasError = true;
+        }
+        onTaskError?.(error, index);
+        return;
+      }
+    }
+  });
+  await Promise.allSettled(workers);
+  return {
+    results,
+    firstError,
+    hasError
+  };
+}
+function failOrUndefined(params) {
+  if (params.onMissing === "throw") throw new Error(params.message);
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function decodeJsonPointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function readJsonPointer(root, pointer, options = {}) {
+  const onMissing = options.onMissing ?? "throw";
+  if (!pointer.startsWith("/")) return failOrUndefined({
+    onMissing,
+    message: 'File-backed secret ids must be absolute JSON pointers (for example: "/providers/openai/apiKey").'
+  });
+  const tokens = pointer.slice(1).split("/").map((token) => decodeJsonPointerToken(token));
+  let current = root;
+  for (const token of tokens) {
+    if (Array.isArray(current)) {
+      const index = Number.parseInt(token, 10);
+      if (!Number.isFinite(index) || index < 0 || index >= current.length) return failOrUndefined({
+        onMissing,
+        message: `JSON pointer segment "${token}" is out of bounds.`
+      });
+      current = current[index];
+      continue;
+    }
+    if (!isJsonObject(current)) return failOrUndefined({
+      onMissing,
+      message: `JSON pointer segment "${token}" does not exist.`
+    });
+    if (!Object.hasOwn(current, token)) return failOrUndefined({
+      onMissing,
+      message: `JSON pointer segment "${token}" does not exist.`
+    });
+    current = current[token];
+  }
+  return current;
+}
+const DEFAULT_PROVIDER_CONCURRENCY = 4;
+const DEFAULT_MAX_REFS_PER_PROVIDER = 512;
+const DEFAULT_MAX_BATCH_BYTES = 256 * 1024;
+const DEFAULT_FILE_MAX_BYTES = 1024 * 1024;
+const DEFAULT_FILE_TIMEOUT_MS = 5e3;
+const DEFAULT_EXEC_TIMEOUT_MS = 5e3;
+const DEFAULT_EXEC_MAX_OUTPUT_BYTES = 1024 * 1024;
+const WINDOWS_ABS_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
+const WINDOWS_UNC_PATH_PATTERN = /^\\\\[^\\]+\\[^\\]+/;
+var SecretProviderResolutionError = class extends Error {
+  constructor(params) {
+    super(params.message, params.cause !== void 0 ? { cause: params.cause } : void 0);
+    this.scope = "provider";
+    this.name = "SecretProviderResolutionError";
+    this.source = params.source;
+    this.provider = params.provider;
+  }
+};
+var SecretRefResolutionError = class extends Error {
+  constructor(params) {
+    super(params.message, params.cause !== void 0 ? { cause: params.cause } : void 0);
+    this.scope = "ref";
+    this.name = "SecretRefResolutionError";
+    this.source = params.source;
+    this.provider = params.provider;
+    this.refId = params.refId;
+  }
+};
+function isSecretResolutionError(value) {
+  return value instanceof SecretProviderResolutionError || value instanceof SecretRefResolutionError;
+}
+function providerResolutionError(params) {
+  return new SecretProviderResolutionError(params);
+}
+function refResolutionError(params) {
+  return new SecretRefResolutionError(params);
+}
+function throwUnknownProviderResolutionError(params) {
+  if (isSecretResolutionError(params.err)) throw params.err;
+  throw providerResolutionError({
+    source: params.source,
+    provider: params.provider,
+    message: formatErrorMessage(params.err),
+    cause: params.err
+  });
+}
+async function readFileStatOrThrow(pathname, label) {
+  const stat = await safeStat(pathname);
+  if (!stat.ok) throw new Error(`${label} is not readable: ${pathname}`);
+  if (stat.isDir) throw new Error(`${label} must be a file: ${pathname}`);
+  return stat;
+}
+function isAbsolutePathname(value) {
+  return path__default.isAbsolute(value) || WINDOWS_ABS_PATH_PATTERN.test(value) || WINDOWS_UNC_PATH_PATTERN.test(value);
+}
+function resolveResolutionLimits(config) {
+  const resolution = config.secrets?.resolution;
+  return {
+    maxProviderConcurrency: normalizePositiveInt(resolution?.maxProviderConcurrency, DEFAULT_PROVIDER_CONCURRENCY),
+    maxRefsPerProvider: normalizePositiveInt(resolution?.maxRefsPerProvider, DEFAULT_MAX_REFS_PER_PROVIDER),
+    maxBatchBytes: normalizePositiveInt(resolution?.maxBatchBytes, DEFAULT_MAX_BATCH_BYTES)
+  };
+}
+function toProviderKey(source, provider) {
+  return `${source}:${provider}`;
+}
+function resolveConfiguredProvider(ref, config) {
+  const providerConfig = config.secrets?.providers?.[ref.provider];
+  if (!providerConfig) {
+    if (ref.source === "env" && ref.provider === resolveDefaultSecretProviderAlias(config)) return { source: "env" };
+    throw providerResolutionError({
+      source: ref.source,
+      provider: ref.provider,
+      message: `Secret provider "${ref.provider}" is not configured (ref: ${ref.source}:${ref.provider}:${ref.id}).`
+    });
+  }
+  if (providerConfig.source !== ref.source) throw providerResolutionError({
+    source: ref.source,
+    provider: ref.provider,
+    message: `Secret provider "${ref.provider}" has source "${providerConfig.source}" but ref requests "${ref.source}".`
+  });
+  return providerConfig;
+}
+async function assertSecurePath(params) {
+  if (!isAbsolutePathname(params.targetPath)) throw new Error(`${params.label} must be an absolute path.`);
+  let effectivePath = params.targetPath;
+  let stat = await readFileStatOrThrow(effectivePath, params.label);
+  if (stat.isSymlink) {
+    if (!params.allowSymlinkPath) throw new Error(`${params.label} must not be a symlink: ${effectivePath}`);
+    try {
+      effectivePath = await fs$1__default.realpath(effectivePath);
+    } catch {
+      throw new Error(`${params.label} symlink target is not readable: ${params.targetPath}`);
+    }
+    if (!isAbsolutePathname(effectivePath)) throw new Error(`${params.label} resolved symlink target must be an absolute path.`);
+    stat = await readFileStatOrThrow(effectivePath, params.label);
+    if (stat.isSymlink) throw new Error(`${params.label} symlink target must not be a symlink: ${effectivePath}`);
+  }
+  if (params.trustedDirs && params.trustedDirs.length > 0) {
+    if (!params.trustedDirs.map((entry) => resolveUserPath(entry)).some((dir) => isPathInside(dir, effectivePath))) throw new Error(`${params.label} is outside trustedDirs: ${effectivePath}`);
+  }
+  if (params.allowInsecurePath) return effectivePath;
+  const perms = await inspectPathPermissions(effectivePath);
+  if (!perms.ok) throw new Error(`${params.label} permissions could not be verified: ${effectivePath}`);
+  const writableByOthers = perms.worldWritable || perms.groupWritable;
+  const readableByOthers = perms.worldReadable || perms.groupReadable;
+  if (writableByOthers || !params.allowReadableByOthers && readableByOthers) throw new Error(`${params.label} permissions are too open: ${effectivePath}`);
+  if (process.platform === "win32" && perms.source === "unknown") throw new Error(`${params.label} ACL verification unavailable on Windows for ${effectivePath}. Set allowInsecurePath=true for this provider to bypass this check when the path is trusted.`);
+  if (process.platform !== "win32" && typeof process.getuid === "function" && stat.uid != null) {
+    const uid = process.getuid();
+    if (stat.uid !== uid) throw new Error(`${params.label} must be owned by the current user (uid=${uid}): ${effectivePath}`);
+  }
+  return effectivePath;
+}
+async function readFileProviderPayload(params) {
+  const cacheKey = params.providerName;
+  const cache = params.cache;
+  const cachedFilePayload = cache?.filePayloadByProvider?.get(cacheKey);
+  if (cachedFilePayload) return await cachedFilePayload;
+  const filePath = resolveUserPath(params.providerConfig.path);
+  const readPromise = (async () => {
+    const timeoutMs = normalizePositiveInt(params.providerConfig.timeoutMs, DEFAULT_FILE_TIMEOUT_MS);
+    const maxBytes = normalizePositiveInt(params.providerConfig.maxBytes, DEFAULT_FILE_MAX_BYTES);
+    try {
+      const { buffer: payload } = await readSecureFile({
+        filePath,
+        label: `secrets.providers.${params.providerName}.path`,
+        io: {
+          maxBytes,
+          timeoutMs
+        },
+        permissions: { allowInsecure: params.providerConfig.allowInsecurePath }
+      });
+      const text = payload.toString("utf8").replace(/^\uFEFF/, "");
+      if (params.providerConfig.mode === "singleValue") return text.replace(/\r?\n$/, "");
+      const parsed = JSON.parse(text);
+      if (!isRecord(parsed)) throw new Error(`File provider "${params.providerName}" payload is not a JSON object.`);
+      return parsed;
+    } catch (error) {
+      if (error instanceof FsSafeError && error.code === "timeout") throw new Error(`File provider "${params.providerName}" timed out after ${timeoutMs}ms.`, { cause: error });
+      throw error;
+    }
+  })();
+  if (cache) {
+    cache.filePayloadByProvider ??= /* @__PURE__ */ new Map();
+    cache.filePayloadByProvider.set(cacheKey, readPromise);
+  }
+  return await readPromise;
+}
+async function resolveEnvRefs(params) {
+  const resolved = /* @__PURE__ */ new Map();
+  const allowlist = params.providerConfig.allowlist ? new Set(params.providerConfig.allowlist) : null;
+  for (const ref of params.refs) {
+    if (allowlist && !allowlist.has(ref.id)) throw refResolutionError({
+      source: "env",
+      provider: params.providerName,
+      refId: ref.id,
+      message: `Environment variable "${ref.id}" is not allowlisted in secrets.providers.${params.providerName}.allowlist.`
+    });
+    const envValue = params.env[ref.id];
+    if (!isNonEmptyString(envValue)) throw refResolutionError({
+      source: "env",
+      provider: params.providerName,
+      refId: ref.id,
+      message: `Environment variable "${ref.id}" is missing or empty.`
+    });
+    resolved.set(ref.id, envValue);
+  }
+  return resolved;
+}
+async function resolveFileRefs(params) {
+  let payload;
+  try {
+    payload = await readFileProviderPayload({
+      providerName: params.providerName,
+      providerConfig: params.providerConfig,
+      cache: params.cache
+    });
+  } catch (err) {
+    throwUnknownProviderResolutionError({
+      source: "file",
+      provider: params.providerName,
+      err
+    });
+  }
+  const mode = params.providerConfig.mode ?? "json";
+  const resolved = /* @__PURE__ */ new Map();
+  if (mode === "singleValue") {
+    for (const ref of params.refs) {
+      if (ref.id !== "value") throw refResolutionError({
+        source: "file",
+        provider: params.providerName,
+        refId: ref.id,
+        message: `singleValue file provider "${params.providerName}" expects ref id "${SINGLE_VALUE_FILE_REF_ID}".`
+      });
+      resolved.set(ref.id, payload);
+    }
+    return resolved;
+  }
+  for (const ref of params.refs) try {
+    resolved.set(ref.id, readJsonPointer(payload, ref.id, { onMissing: "throw" }));
+  } catch (err) {
+    throw refResolutionError({
+      source: "file",
+      provider: params.providerName,
+      refId: ref.id,
+      message: formatErrorMessage(err),
+      cause: err
+    });
+  }
+  return resolved;
+}
+function isIgnorableStdinWriteError(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) return false;
+  const code = String(error.code);
+  return code === "EPIPE" || code === "ERR_STREAM_DESTROYED";
+}
+async function runExecResolver(params) {
+  return await new Promise((resolve, reject) => {
+    const child = spawn(params.command, params.args, {
+      cwd: params.cwd,
+      env: params.env,
+      stdio: [
+        "pipe",
+        "pipe",
+        "pipe"
+      ],
+      shell: false,
+      windowsHide: true
+    });
+    let settled = false;
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let noOutputTimedOut = false;
+    let outputBytes = 0;
+    let noOutputTimer = null;
+    const timeoutTimer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGKILL");
+    }, params.timeoutMs);
+    const clearTimers = () => {
+      clearTimeout(timeoutTimer);
+      if (noOutputTimer) {
+        clearTimeout(noOutputTimer);
+        noOutputTimer = null;
+      }
+    };
+    const armNoOutputTimer = () => {
+      if (noOutputTimer) clearTimeout(noOutputTimer);
+      noOutputTimer = setTimeout(() => {
+        noOutputTimedOut = true;
+        child.kill("SIGKILL");
+      }, params.noOutputTimeoutMs);
+    };
+    const append = (chunk, target) => {
+      const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      outputBytes += Buffer.byteLength(text, "utf8");
+      if (outputBytes > params.maxOutputBytes) {
+        child.kill("SIGKILL");
+        if (!settled) {
+          settled = true;
+          clearTimers();
+          reject(/* @__PURE__ */ new Error(`Exec provider output exceeded maxOutputBytes (${params.maxOutputBytes}).`));
+        }
+        return;
+      }
+      if (target === "stdout") stdout += text;
+      else stderr += text;
+      armNoOutputTimer();
+    };
+    armNoOutputTimer();
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      reject(error);
+    });
+    child.stdout?.on("data", (chunk) => append(chunk, "stdout"));
+    child.stderr?.on("data", (chunk) => append(chunk, "stderr"));
+    child.on("close", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      clearTimers();
+      resolve({
+        stdout,
+        stderr,
+        code,
+        signal,
+        termination: noOutputTimedOut ? "no-output-timeout" : timedOut ? "timeout" : "exit"
+      });
+    });
+    const handleStdinError = (error) => {
+      if (isIgnorableStdinWriteError(error) || settled) return;
+      settled = true;
+      clearTimers();
+      reject(error instanceof Error ? error : new Error(String(error)));
+    };
+    child.stdin?.on("error", handleStdinError);
+    try {
+      child.stdin?.end(params.input);
+    } catch (error) {
+      handleStdinError(error);
+    }
+  });
+}
+function parseExecValues(params) {
+  const trimmed = params.stdout.trim();
+  if (!trimmed) throw providerResolutionError({
+    source: "exec",
+    provider: params.providerName,
+    message: `Exec provider "${params.providerName}" returned empty stdout.`
+  });
+  let parsed;
+  if (!params.jsonOnly && params.ids.length === 1) try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return { [params.ids[0]]: trimmed };
+  }
+  else try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    throw providerResolutionError({
+      source: "exec",
+      provider: params.providerName,
+      message: `Exec provider "${params.providerName}" returned invalid JSON.`
+    });
+  }
+  if (!isRecord(parsed)) {
+    if (!params.jsonOnly && params.ids.length === 1 && typeof parsed === "string") return { [params.ids[0]]: parsed };
+    throw providerResolutionError({
+      source: "exec",
+      provider: params.providerName,
+      message: `Exec provider "${params.providerName}" response must be an object.`
+    });
+  }
+  if (parsed.protocolVersion !== 1) throw providerResolutionError({
+    source: "exec",
+    provider: params.providerName,
+    message: `Exec provider "${params.providerName}" protocolVersion must be 1.`
+  });
+  const responseValues = parsed.values;
+  if (!isRecord(responseValues)) throw providerResolutionError({
+    source: "exec",
+    provider: params.providerName,
+    message: `Exec provider "${params.providerName}" response missing "values".`
+  });
+  const responseErrors = isRecord(parsed.errors) ? parsed.errors : null;
+  const out = {};
+  for (const id of params.ids) {
+    if (responseErrors && id in responseErrors) {
+      const entry = responseErrors[id];
+      if (isRecord(entry) && typeof entry.message === "string" && entry.message.trim()) throw refResolutionError({
+        source: "exec",
+        provider: params.providerName,
+        refId: id,
+        message: `Exec provider "${params.providerName}" failed for id "${id}" (${entry.message.trim()}).`
+      });
+      throw refResolutionError({
+        source: "exec",
+        provider: params.providerName,
+        refId: id,
+        message: `Exec provider "${params.providerName}" failed for id "${id}".`
+      });
+    }
+    if (!(id in responseValues)) throw refResolutionError({
+      source: "exec",
+      provider: params.providerName,
+      refId: id,
+      message: `Exec provider "${params.providerName}" response missing id "${id}".`
+    });
+    out[id] = responseValues[id];
+  }
+  return out;
+}
+async function resolveExecRefs(params) {
+  const ids = [...new Set(params.refs.map((ref) => ref.id))];
+  if (ids.length > params.limits.maxRefsPerProvider) throw providerResolutionError({
+    source: "exec",
+    provider: params.providerName,
+    message: `Exec provider "${params.providerName}" exceeded maxRefsPerProvider (${params.limits.maxRefsPerProvider}).`
+  });
+  const commandPath = resolveUserPath(params.providerConfig.command);
+  let secureCommandPath;
+  try {
+    secureCommandPath = await assertSecurePath({
+      targetPath: commandPath,
+      label: `secrets.providers.${params.providerName}.command`,
+      trustedDirs: params.providerConfig.trustedDirs,
+      allowInsecurePath: params.providerConfig.allowInsecurePath,
+      allowReadableByOthers: true,
+      allowSymlinkPath: params.providerConfig.allowSymlinkCommand
+    });
+  } catch (err) {
+    throwUnknownProviderResolutionError({
+      source: "exec",
+      provider: params.providerName,
+      err
+    });
+  }
+  const requestPayload = {
+    protocolVersion: 1,
+    provider: params.providerName,
+    ids
+  };
+  const input = JSON.stringify(requestPayload);
+  if (Buffer.byteLength(input, "utf8") > params.limits.maxBatchBytes) throw providerResolutionError({
+    source: "exec",
+    provider: params.providerName,
+    message: `Exec provider "${params.providerName}" request exceeded maxBatchBytes (${params.limits.maxBatchBytes}).`
+  });
+  const childEnv = {};
+  for (const key of params.providerConfig.passEnv ?? []) {
+    const value = params.env[key];
+    if (value !== void 0) childEnv[key] = value;
+  }
+  for (const [key, value] of Object.entries(params.providerConfig.env ?? {})) childEnv[key] = value;
+  const timeoutMs = normalizePositiveInt(params.providerConfig.timeoutMs, DEFAULT_EXEC_TIMEOUT_MS);
+  const noOutputTimeoutMs = normalizePositiveInt(params.providerConfig.noOutputTimeoutMs, timeoutMs);
+  const maxOutputBytes = normalizePositiveInt(params.providerConfig.maxOutputBytes, DEFAULT_EXEC_MAX_OUTPUT_BYTES);
+  const jsonOnly = params.providerConfig.jsonOnly ?? true;
+  let result;
+  try {
+    result = await runExecResolver({
+      command: secureCommandPath,
+      args: params.providerConfig.args ?? [],
+      cwd: path__default.dirname(secureCommandPath),
+      env: childEnv,
+      input,
+      timeoutMs,
+      noOutputTimeoutMs,
+      maxOutputBytes
+    });
+  } catch (err) {
+    throwUnknownProviderResolutionError({
+      source: "exec",
+      provider: params.providerName,
+      err
+    });
+  }
+  if (result.termination === "timeout") throw providerResolutionError({
+    source: "exec",
+    provider: params.providerName,
+    message: `Exec provider "${params.providerName}" timed out after ${timeoutMs}ms.`
+  });
+  if (result.termination === "no-output-timeout") throw providerResolutionError({
+    source: "exec",
+    provider: params.providerName,
+    message: `Exec provider "${params.providerName}" produced no output for ${noOutputTimeoutMs}ms.`
+  });
+  if (result.code !== 0) throw providerResolutionError({
+    source: "exec",
+    provider: params.providerName,
+    message: `Exec provider "${params.providerName}" exited with code ${String(result.code)}.`
+  });
+  let values;
+  try {
+    values = parseExecValues({
+      providerName: params.providerName,
+      ids,
+      stdout: result.stdout,
+      jsonOnly
+    });
+  } catch (err) {
+    throwUnknownProviderResolutionError({
+      source: "exec",
+      provider: params.providerName,
+      err
+    });
+  }
+  const resolved = /* @__PURE__ */ new Map();
+  for (const id of ids) resolved.set(id, values[id]);
+  return resolved;
+}
+async function resolveProviderRefs(params) {
+  try {
+    if (params.providerConfig.source === "env") return await resolveEnvRefs({
+      refs: params.refs,
+      providerName: params.providerName,
+      providerConfig: params.providerConfig,
+      env: params.options.env ?? process.env
+    });
+    if (params.providerConfig.source === "file") return await resolveFileRefs({
+      refs: params.refs,
+      providerName: params.providerName,
+      providerConfig: params.providerConfig,
+      cache: params.options.cache
+    });
+    if (params.providerConfig.source === "exec") return await resolveExecRefs({
+      refs: params.refs,
+      providerName: params.providerName,
+      providerConfig: params.providerConfig,
+      env: params.options.env ?? process.env,
+      limits: params.limits
+    });
+    throw providerResolutionError({
+      source: params.source,
+      provider: params.providerName,
+      message: `Unsupported secret provider source "${String(params.providerConfig.source)}".`
+    });
+  } catch (err) {
+    return throwUnknownProviderResolutionError({
+      source: params.source,
+      provider: params.providerName,
+      err
+    });
+  }
+}
+async function resolveSecretRefValues(refs, options) {
+  if (refs.length === 0) return /* @__PURE__ */ new Map();
+  const limits = resolveResolutionLimits(options.config);
+  const uniqueRefs = /* @__PURE__ */ new Map();
+  for (const ref of refs) {
+    const id = ref.id.trim();
+    if (!id) throw new Error("Secret reference id is empty.");
+    if (ref.source === "exec" && !isValidExecSecretRefId(id)) throw new Error(`${formatExecSecretRefIdValidationMessage()} (ref: ${ref.source}:${ref.provider}:${id}).`);
+    uniqueRefs.set(secretRefKey(ref), {
+      ...ref,
+      id
+    });
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const ref of uniqueRefs.values()) {
+    const key = toProviderKey(ref.source, ref.provider);
+    const existing = grouped.get(key);
+    if (existing) {
+      existing.refs.push(ref);
+      continue;
+    }
+    grouped.set(key, {
+      source: ref.source,
+      providerName: ref.provider,
+      refs: [ref]
+    });
+  }
+  const taskResults = await runTasksWithConcurrency({
+    tasks: [...grouped.values()].map((group) => async () => {
+      if (group.refs.length > limits.maxRefsPerProvider) throw providerResolutionError({
+        source: group.source,
+        provider: group.providerName,
+        message: `Secret provider "${group.providerName}" exceeded maxRefsPerProvider (${limits.maxRefsPerProvider}).`
+      });
+      const providerConfig = resolveConfiguredProvider(group.refs[0], options.config);
+      return {
+        group,
+        values: await resolveProviderRefs({
+          refs: group.refs,
+          source: group.source,
+          providerName: group.providerName,
+          providerConfig,
+          options,
+          limits
+        })
+      };
+    }),
+    limit: limits.maxProviderConcurrency
+  });
+  if (taskResults.hasError) throw taskResults.firstError;
+  const resolved = /* @__PURE__ */ new Map();
+  for (const result of taskResults.results) for (const ref of result.group.refs) {
+    if (!result.values.has(ref.id)) throw refResolutionError({
+      source: result.group.source,
+      provider: result.group.providerName,
+      refId: ref.id,
+      message: `Secret provider "${result.group.providerName}" did not return id "${ref.id}".`
+    });
+    resolved.set(secretRefKey(ref), result.values.get(ref.id));
+  }
+  return resolved;
+}
+async function resolveSecretRefValue(ref, options) {
+  const cache = options.cache;
+  const key = secretRefKey(ref);
+  const cachedResolvedValue = cache?.resolvedByRefKey?.get(key);
+  if (cachedResolvedValue) return await cachedResolvedValue;
+  const promise = (async () => {
+    const resolved = await resolveSecretRefValues([ref], options);
+    if (!resolved.has(key)) throw refResolutionError({
+      source: ref.source,
+      provider: ref.provider,
+      refId: ref.id,
+      message: `Secret reference "${key}" resolved to no value.`
+    });
+    return resolved.get(key);
+  })();
+  if (cache) {
+    cache.resolvedByRefKey ??= /* @__PURE__ */ new Map();
+    cache.resolvedByRefKey.set(key, promise);
+  }
+  return await promise;
+}
+async function resolveSecretRefString(ref, options) {
+  const resolved = await resolveSecretRefValue(ref, options);
+  if (!isNonEmptyString(resolved)) throw new Error(`Secret reference "${ref.source}:${ref.provider}:${ref.id}" resolved to a non-string or empty value.`);
+  return resolved;
+}
+const ALL_GATEWAY_SECRET_INPUT_PATHS = [
+  "gateway.auth.token",
+  "gateway.auth.password",
+  "gateway.remote.token",
+  "gateway.remote.password"
+];
+function isSupportedGatewaySecretInputPath(path) {
+  return ALL_GATEWAY_SECRET_INPUT_PATHS.includes(path);
+}
+function readGatewaySecretInputValue(config, path) {
+  if (path === "gateway.auth.token") return config.gateway?.auth?.token;
+  if (path === "gateway.auth.password") return config.gateway?.auth?.password;
+  if (path === "gateway.remote.token") return config.gateway?.remote?.token;
+  return config.gateway?.remote?.password;
+}
+function assignResolvedGatewaySecretInput(params) {
+  const { config, path, value } = params;
+  if (path === "gateway.auth.token") {
+    if (config.gateway?.auth) config.gateway.auth.token = value;
+    return;
+  }
+  if (path === "gateway.auth.password") {
+    if (config.gateway?.auth) config.gateway.auth.password = value;
+    return;
+  }
+  if (path === "gateway.remote.token") {
+    if (config.gateway?.remote) config.gateway.remote.token = value;
+    return;
+  }
+  if (config.gateway?.remote) config.gateway.remote.password = value;
+}
+function isTokenGatewaySecretInputPath(path) {
+  return path === "gateway.auth.token" || path === "gateway.remote.token";
+}
+async function resolveSecretInputString(params) {
+  const normalize = params.normalize ?? normalizeSecretInputString;
+  const { ref } = resolveSecretInputRef({
+    value: params.value,
+    defaults: params.defaults ?? params.config.secrets?.defaults
+  });
+  if (!ref) return normalize(params.value);
+  let resolved;
+  try {
+    resolved = await resolveSecretRefString(ref, {
+      config: params.config,
+      env: params.env
+    });
+  } catch (error) {
+    if (params.onResolveRefError) return params.onResolveRefError(error, ref);
+    throw error;
+  }
+  return normalize(resolved);
+}
+function resolveExplicitGatewayAuth$1(opts) {
+  return {
+    token: typeof opts?.token === "string" && opts.token.trim().length > 0 ? opts.token.trim() : void 0,
+    password: typeof opts?.password === "string" && opts.password.trim().length > 0 ? opts.password.trim() : void 0
+  };
+}
+async function resolveGatewaySecretInputString(params) {
+  const value = await resolveSecretInputString({
+    config: params.config,
+    value: params.value,
+    env: params.env,
+    normalize: trimToUndefined,
+    onResolveRefError: () => {
+      throw new GatewaySecretRefUnavailableError(params.path);
+    }
+  });
+  if (!value) throw new Error(`${params.path} resolved to an empty or non-string value.`);
+  return value;
+}
+function hasConfiguredGatewaySecretRef(config, path) {
+  return Boolean(resolveSecretInputRef({
+    value: readGatewaySecretInputValue(config, path),
+    defaults: config.secrets?.defaults
+  }).ref);
+}
+function resolveGatewayCredentialsFromConfigOptions(params) {
+  const { cfg, env, options } = params;
+  return {
+    cfg,
+    env,
+    explicitAuth: options.explicitAuth,
+    urlOverride: options.urlOverride,
+    urlOverrideSource: options.urlOverrideSource,
+    modeOverride: options.modeOverride,
+    localTokenPrecedence: options.localTokenPrecedence,
+    localPasswordPrecedence: options.localPasswordPrecedence,
+    remoteTokenPrecedence: options.remoteTokenPrecedence,
+    remotePasswordPrecedence: options.remotePasswordPrecedence ?? "env-first",
+    remoteTokenFallback: options.remoteTokenFallback,
+    remotePasswordFallback: options.remotePasswordFallback
+  };
+}
+function localAuthModeAllowsGatewaySecretInputPath(params) {
+  const { authMode, path } = params;
+  if (authMode === "none") return false;
+  if (authMode === "trusted-proxy") return !isTokenGatewaySecretInputPath(path);
+  if (authMode === "token") return isTokenGatewaySecretInputPath(path);
+  if (authMode === "password") return !isTokenGatewaySecretInputPath(path);
+  return true;
+}
+function gatewaySecretInputPathCanWin(params) {
+  if (!hasConfiguredGatewaySecretRef(params.config, params.path)) return false;
+  if ((params.options.modeOverride ?? (params.config.gateway?.mode === "remote" ? "remote" : "local")) === "local" && !localAuthModeAllowsGatewaySecretInputPath({
+    authMode: params.config.gateway?.auth?.mode,
+    path: params.path
+  })) return false;
+  const sentinel = `__OPENCLAW_GATEWAY_SECRET_REF_PROBE_${params.path.replaceAll(".", "_")}__`;
+  const probeConfig = structuredClone(params.config);
+  for (const candidatePath of ALL_GATEWAY_SECRET_INPUT_PATHS) {
+    if (!hasConfiguredGatewaySecretRef(probeConfig, candidatePath)) continue;
+    assignResolvedGatewaySecretInput({
+      config: probeConfig,
+      path: candidatePath,
+      value: void 0
+    });
+  }
+  assignResolvedGatewaySecretInput({
+    config: probeConfig,
+    path: params.path,
+    value: sentinel
+  });
+  try {
+    const resolved = resolveGatewayCredentialsFromConfig(resolveGatewayCredentialsFromConfigOptions({
+      cfg: probeConfig,
+      env: params.env,
+      options: params.options
+    }));
+    const tokenCanWin = resolved.token === sentinel && !resolved.password;
+    const passwordCanWin = resolved.password === sentinel && !resolved.token;
+    return tokenCanWin || passwordCanWin;
+  } catch {
+    return false;
+  }
+}
+async function resolveConfiguredGatewaySecretInput(params) {
+  return resolveGatewaySecretInputString({
+    config: params.config,
+    value: readGatewaySecretInputValue(params.config, params.path),
+    path: params.path,
+    env: params.env
+  });
+}
+async function resolvePreferredGatewaySecretInputs(params) {
+  let nextConfig = params.config;
+  for (const path of ALL_GATEWAY_SECRET_INPUT_PATHS) {
+    if (!gatewaySecretInputPathCanWin({
+      options: params.options,
+      env: params.env,
+      config: nextConfig,
+      path
+    })) continue;
+    if (nextConfig === params.config) nextConfig = structuredClone(params.config);
+    try {
+      const resolvedValue = await resolveConfiguredGatewaySecretInput({
+        config: nextConfig,
+        path,
+        env: params.env
+      });
+      assignResolvedGatewaySecretInput({
+        config: nextConfig,
+        path,
+        value: resolvedValue
+      });
+    } catch {
+      continue;
+    }
+  }
+  return nextConfig;
+}
+async function resolveGatewayCredentialsFromConfigWithSecretInputs(params) {
+  let resolvedConfig = await resolvePreferredGatewaySecretInputs({
+    options: params.options,
+    env: params.env,
+    config: params.options.config
+  });
+  const resolvedPaths = /* @__PURE__ */ new Set();
+  for (; ; ) try {
+    return resolveGatewayCredentialsFromConfig(resolveGatewayCredentialsFromConfigOptions({
+      cfg: resolvedConfig,
+      env: params.env,
+      options: params.options
+    }));
+  } catch (error) {
+    if (!(error instanceof GatewaySecretRefUnavailableError)) throw error;
+    const path = error.path;
+    if (!isSupportedGatewaySecretInputPath(path) || resolvedPaths.has(path)) throw error;
+    if (resolvedConfig === params.options.config) resolvedConfig = structuredClone(params.options.config);
+    const resolvedValue = await resolveConfiguredGatewaySecretInput({
+      config: resolvedConfig,
+      path,
+      env: params.env
+    });
+    assignResolvedGatewaySecretInput({
+      config: resolvedConfig,
+      path,
+      value: resolvedValue
+    });
+    resolvedPaths.add(path);
+  }
+}
+async function resolveGatewayCredentialsWithSecretInputs(params) {
+  const options = {
+    ...params,
+    explicitAuth: resolveExplicitGatewayAuth$1(params.explicitAuth)
+  };
+  if (options.explicitAuth.token || options.explicitAuth.password) return {
+    token: options.explicitAuth.token,
+    password: options.explicitAuth.password
+  };
+  return await resolveGatewayCredentialsFromConfigWithSecretInputs({
+    options,
+    env: params.env ?? process.env
+  });
+}
+function hasExplicitGatewayConnectionAuth(auth) {
+  return Boolean(trimToUndefined(auth?.token) || trimToUndefined(auth?.password));
+}
+function canSkipGatewayConfigLoad(params) {
+  return !params.config && Boolean(trimToUndefined(params.urlOverride)) && hasExplicitGatewayConnectionAuth(params.explicitAuth);
+}
+const CLI_DEFAULT_OPERATOR_SCOPES = [
+  ADMIN_SCOPE,
+  READ_SCOPE,
+  WRITE_SCOPE,
+  APPROVALS_SCOPE,
+  PAIRING_SCOPE,
+  TALK_SECRETS_SCOPE
+];
+function resolveScopedMethod(method) {
+  const explicitScope = resolveCoreOperatorGatewayMethodScope(method);
+  if (explicitScope) return explicitScope;
+  const reservedScope = resolveReservedGatewayMethodScope(method);
+  if (reservedScope) return reservedScope;
+  const pluginScope = getPluginRegistryState()?.activeRegistry?.gatewayMethodDescriptors?.find((descriptor) => descriptor.name === method)?.scope;
+  return pluginScope === "node" || pluginScope === "dynamic" ? void 0 : pluginScope;
+}
+function resolveRequiredOperatorScopeForMethod(method) {
+  return resolveScopedMethod(method);
+}
+function normalizeSessionActionParam(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function resolveSessionActionRegisteredScopes(params) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) return;
+  const pluginId = normalizeSessionActionParam(params.pluginId);
+  const actionId = normalizeSessionActionParam(params.actionId);
+  if (!pluginId || !actionId) return;
+  const registration = getPluginRegistryState()?.activeRegistry?.sessionActions?.find((entry) => entry.pluginId === pluginId && entry.action.id === actionId);
+  if (!registration) return;
+  const requiredScopes = registration.action.requiredScopes;
+  return requiredScopes && requiredScopes.length > 0 ? [...requiredScopes] : [WRITE_SCOPE];
+}
+function resolveSessionActionLeastPrivilegeScopes(params) {
+  const registeredScopes = resolveSessionActionRegisteredScopes(params);
+  if (registeredScopes) return registeredScopes;
+  if (params && typeof params === "object" && !Array.isArray(params)) {
+    const pluginId = normalizeSessionActionParam(params.pluginId);
+    const actionId = normalizeSessionActionParam(params.actionId);
+    if (pluginId && actionId) return [...CLI_DEFAULT_OPERATOR_SCOPES];
+  }
+  return [WRITE_SCOPE];
+}
+function resolveDynamicLeastPrivilegeOperatorScopesForMethod(method, params) {
+  if (method === "plugins.sessionAction") return resolveSessionActionLeastPrivilegeScopes(params);
+  return [WRITE_SCOPE];
+}
+function resolveLeastPrivilegeOperatorScopesForMethod(method, params) {
+  if (isDynamicOperatorGatewayMethod(method)) return resolveDynamicLeastPrivilegeOperatorScopesForMethod(method, params);
+  const requiredScope = resolveRequiredOperatorScopeForMethod(method);
+  if (requiredScope) return [requiredScope];
+  return [];
+}
+var GatewayTransportError = class extends Error {
+  constructor(params) {
+    super(params.message);
+    this.name = "GatewayTransportError";
+    this.kind = params.kind;
+    this.connectionDetails = params.connectionDetails;
+    if (params.code !== void 0) this.code = params.code;
+    if (params.reason !== void 0) this.reason = params.reason;
+    if (params.timeoutMs !== void 0) this.timeoutMs = params.timeoutMs;
+  }
+};
+const defaultCreateGatewayClient = (opts) => new GatewayClient(opts);
+const defaultGatewayCallDeps = {
+  createGatewayClient: defaultCreateGatewayClient,
+  getRuntimeConfig,
+  loadOrCreateDeviceIdentity,
+  resolveGatewayPort,
+  resolveConfigPath,
+  resolveStateDir,
+  loadGatewayTlsRuntime
+};
+const gatewayCallDeps = { ...defaultGatewayCallDeps };
+async function stopGatewayClient(client) {
+  try {
+    await client.stopAndWait({ timeoutMs: 1e3 });
+  } catch {
+    client.stop();
+  }
+}
+function resolveGatewayClientDisplayName(opts) {
+  if (opts.clientDisplayName) return opts.clientDisplayName;
+  const clientName = opts.clientName ?? GATEWAY_CLIENT_NAMES.CLI;
+  if ((opts.mode ?? GATEWAY_CLIENT_MODES.CLI) !== GATEWAY_CLIENT_MODES.BACKEND && clientName !== GATEWAY_CLIENT_NAMES.GATEWAY_CLIENT) return;
+  const method = opts.method.trim();
+  return method ? `gateway:${method}` : "gateway:request";
+}
+function loadGatewayConfig() {
+  return (typeof gatewayCallDeps.getRuntimeConfig === "function" ? gatewayCallDeps.getRuntimeConfig : typeof defaultGatewayCallDeps.getRuntimeConfig === "function" ? defaultGatewayCallDeps.getRuntimeConfig : getRuntimeConfig)();
+}
+function resolveGatewayStateDir(env) {
+  return (typeof gatewayCallDeps.resolveStateDir === "function" ? gatewayCallDeps.resolveStateDir : resolveStateDir)(env);
+}
+function resolveGatewayConfigPath(env) {
+  return (typeof gatewayCallDeps.resolveConfigPath === "function" ? gatewayCallDeps.resolveConfigPath : resolveConfigPath)(env, resolveGatewayStateDir(env));
+}
+function resolveGatewayPortValue(config, env) {
+  return (typeof gatewayCallDeps.resolveGatewayPort === "function" ? gatewayCallDeps.resolveGatewayPort : resolveGatewayPort)(config, env);
+}
+function buildGatewayConnectionDetails(options = {}) {
+  return buildGatewayConnectionDetailsWithResolvers(options, {
+    getRuntimeConfig: () => loadGatewayConfig(),
+    resolveConfigPath: (env) => resolveGatewayConfigPath(env),
+    resolveGatewayPort: (config, env) => resolveGatewayPortValue(config, env)
+  });
+}
+function isLoopbackGatewayUrl(rawUrl) {
+  try {
+    const hostname = new URL(rawUrl).hostname.toLowerCase();
+    const unbracketed = hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+    return unbracketed === "localhost" || isLoopbackIpAddress(unbracketed);
+  } catch {
+    return false;
+  }
+}
+function shouldOmitDeviceIdentityForGatewayCall(params) {
+  const mode = params.opts.mode ?? GATEWAY_CLIENT_MODES.CLI;
+  const clientName = params.opts.clientName ?? GATEWAY_CLIENT_NAMES.CLI;
+  const hasSharedAuth = Boolean(params.token || params.password);
+  return mode === GATEWAY_CLIENT_MODES.BACKEND && clientName === GATEWAY_CLIENT_NAMES.GATEWAY_CLIENT && hasSharedAuth && isLoopbackGatewayUrl(params.url);
+}
+function resolveDeviceIdentityForGatewayCall(params) {
+  if (shouldOmitDeviceIdentityForGatewayCall(params)) return null;
+  try {
+    return gatewayCallDeps.loadOrCreateDeviceIdentity();
+  } catch {
+    return null;
+  }
+}
+function resolveExplicitGatewayAuth(opts) {
+  return {
+    token: typeof opts?.token === "string" && opts.token.trim().length > 0 ? opts.token.trim() : void 0,
+    password: typeof opts?.password === "string" && opts.password.trim().length > 0 ? opts.password.trim() : void 0
+  };
+}
+function ensureExplicitGatewayAuth(params) {
+  if (!params.urlOverride) return;
+  const explicitToken = params.explicitAuth?.token;
+  const explicitPassword = params.explicitAuth?.password;
+  if (params.urlOverrideSource === "cli" && (explicitToken || explicitPassword)) return;
+  const hasResolvedAuth = params.resolvedAuth?.token || params.resolvedAuth?.password || explicitToken || explicitPassword;
+  if (params.urlOverrideSource === "env" && hasResolvedAuth) return;
+  const message = [
+    "gateway url override requires explicit credentials",
+    params.errorHint,
+    params.configPath ? `Config: ${params.configPath}` : void 0
+  ].filter(Boolean).join("\n");
+  throw new Error(message);
+}
+function resolveGatewayCallTimeout(timeoutValue, configuredHandshakeTimeoutMs) {
+  const hasConfiguredHandshakeTimeout = typeof configuredHandshakeTimeoutMs === "number" && Number.isFinite(configuredHandshakeTimeoutMs) && configuredHandshakeTimeoutMs > 0;
+  const hasEnvHandshakeTimeout = Boolean(process.env.OPENCLAW_HANDSHAKE_TIMEOUT_MS) || Boolean(process.env.VITEST && process.env.OPENCLAW_TEST_HANDSHAKE_TIMEOUT_MS);
+  const resolvedHandshakeTimeoutMs = hasConfiguredHandshakeTimeout || hasEnvHandshakeTimeout ? resolvePreauthHandshakeTimeoutMs({ configuredTimeoutMs: configuredHandshakeTimeoutMs }) : void 0;
+  const timeoutMs = typeof timeoutValue === "number" && Number.isFinite(timeoutValue) ? timeoutValue : typeof resolvedHandshakeTimeoutMs === "number" && resolvedHandshakeTimeoutMs > 1e4 ? resolvedHandshakeTimeoutMs : 1e4;
+  return {
+    timeoutMs,
+    safeTimerTimeoutMs: resolveSafeTimeoutDelayMs(timeoutMs)
+  };
+}
+function resolveGatewayCallContext(opts) {
+  const cliUrlOverride = trimToUndefined(opts.url);
+  const explicitAuth = resolveExplicitGatewayAuth({
+    token: opts.token,
+    password: opts.password
+  });
+  const envUrlOverride = cliUrlOverride ? void 0 : trimToUndefined(process.env.OPENCLAW_GATEWAY_URL);
+  const urlOverride = cliUrlOverride ?? envUrlOverride;
+  const urlOverrideSource = cliUrlOverride ? "cli" : envUrlOverride ? "env" : void 0;
+  const canSkipConfigLoad = canSkipGatewayConfigLoad({
+    config: opts.config,
+    urlOverride,
+    explicitAuth
+  });
+  const config = opts.config ?? (canSkipConfigLoad ? {} : loadGatewayConfig());
+  const configPath = opts.configPath ?? resolveGatewayConfigPath(process.env);
+  const isRemoteMode = config.gateway?.mode === "remote";
+  const remote = isRemoteMode ? config.gateway?.remote : void 0;
+  return {
+    config,
+    configPath,
+    isRemoteMode,
+    remote,
+    urlOverride,
+    urlOverrideSource,
+    remoteUrl: trimToUndefined(remote?.url),
+    explicitAuth
+  };
+}
+function ensureRemoteModeUrlConfigured(context) {
+  if (!context.isRemoteMode || context.urlOverride || context.remoteUrl) return;
+  throw new Error([
+    "gateway remote mode misconfigured: gateway.remote.url missing",
+    `Config: ${context.configPath}`,
+    "Fix: set gateway.remote.url, or set gateway.mode=local."
+  ].join("\n"));
+}
+async function resolveGatewayCredentials(context) {
+  return resolveGatewayCredentialsWithEnv(context, process.env);
+}
+async function resolveGatewayCredentialsWithEnv(context, env) {
+  if (context.explicitAuth.token || context.explicitAuth.password) return {
+    token: context.explicitAuth.token,
+    password: context.explicitAuth.password
+  };
+  return resolveGatewayCredentialsWithSecretInputs({
+    config: context.config,
+    explicitAuth: context.explicitAuth,
+    urlOverride: context.urlOverride,
+    urlOverrideSource: context.urlOverrideSource,
+    env,
+    modeOverride: context.modeOverride,
+    localTokenPrecedence: context.localTokenPrecedence,
+    localPasswordPrecedence: context.localPasswordPrecedence,
+    remoteTokenPrecedence: context.remoteTokenPrecedence,
+    remotePasswordPrecedence: context.remotePasswordPrecedence,
+    remoteTokenFallback: context.remoteTokenFallback,
+    remotePasswordFallback: context.remotePasswordFallback
+  });
+}
+async function resolveGatewayTlsFingerprint(params) {
+  const { opts, context, url } = params;
+  const tlsRuntime = context.config.gateway?.tls?.enabled === true && !context.urlOverrideSource && !context.remoteUrl && url.startsWith("wss://") ? await gatewayCallDeps.loadGatewayTlsRuntime(context.config.gateway?.tls) : void 0;
+  const overrideTlsFingerprint = trimToUndefined(opts.tlsFingerprint);
+  const remoteTlsFingerprint = context.isRemoteMode && context.urlOverrideSource !== "cli" ? trimToUndefined(context.remote?.tlsFingerprint) : void 0;
+  return overrideTlsFingerprint || remoteTlsFingerprint || (tlsRuntime?.enabled ? tlsRuntime.fingerprintSha256 : void 0);
+}
+function formatGatewayCloseError(code, reason, connectionDetails) {
+  const reasonText = normalizeOptionalString(reason) || "no close reason";
+  const hint = code === 1006 ? "abnormal closure (no close frame)" : code === 1e3 ? "normal closure" : "";
+  let message = `gateway closed (${code}${hint ? ` ${hint}` : ""}): ${reasonText}
+${connectionDetails.message}`;
+  if (code === 1006) message += "\n\nPossible causes:\n- Gateway not yet ready to accept connections (retry after a moment)\n- TLS mismatch (connecting with ws:// to a wss:// gateway, or vice versa)\n- Gateway crashed or was terminated unexpectedly\nRun `openclaw doctor` for diagnostics.";
+  return message;
+}
+function formatGatewayTimeoutError(timeoutMs, connectionDetails) {
+  return `gateway timeout after ${timeoutMs}ms
+${connectionDetails.message}`;
+}
+function createGatewayCloseTransportError(params) {
+  const reasonText = normalizeOptionalString(params.reason) || "no close reason";
+  return new GatewayTransportError({
+    kind: "closed",
+    code: params.code,
+    reason: reasonText,
+    connectionDetails: params.connectionDetails,
+    message: formatGatewayCloseError(params.code, params.reason, params.connectionDetails)
+  });
+}
+function createGatewayTimeoutTransportError(params) {
+  return new GatewayTransportError({
+    kind: "timeout",
+    timeoutMs: params.timeoutMs,
+    connectionDetails: params.connectionDetails,
+    message: formatGatewayTimeoutError(params.timeoutMs, params.connectionDetails)
+  });
+}
+function createGatewayRequestAbortError(method) {
+  const err = /* @__PURE__ */ new Error(`gateway request aborted for ${method}`);
+  err.name = "AbortError";
+  return err;
+}
+function ensureGatewaySupportsRequiredMethods(params) {
+  const requiredMethods = Array.isArray(params.requiredMethods) ? params.requiredMethods.map((entry) => entry.trim()).filter((entry) => entry.length > 0) : [];
+  if (requiredMethods.length === 0) return;
+  const supportedMethods = new Set((Array.isArray(params.methods) ? params.methods : []).map((entry) => entry.trim()).filter((entry) => entry.length > 0));
+  for (const method of requiredMethods) {
+    if (supportedMethods.has(method)) continue;
+    throw new Error([`active gateway does not support required method "${method}" for "${params.attemptedMethod}".`, "Update the gateway or run without SecretRefs."].join(" "));
+  }
+}
+async function executeGatewayRequestWithScopes(params) {
+  const { opts, scopes, url, token, password, tlsFingerprint, preauthHandshakeTimeoutMs, timeoutMs, safeTimerTimeoutMs } = params;
+  return await new Promise((resolve, reject) => {
+    if (opts.signal?.aborted) {
+      reject(createGatewayRequestAbortError(opts.method));
+      return;
+    }
+    let settled = false;
+    let ignoreClose = false;
+    const startAbort = new AbortController();
+    let abortHandler;
+    let client;
+    let timer;
+    let primaryRequestStarted = false;
+    const cleanup = () => {
+      startAbort.abort();
+      if (abortHandler) opts.signal?.removeEventListener("abort", abortHandler);
+      if (timer) clearTimeout(timer);
+    };
+    const stopClientThenSettle = (activeClient, err, value) => {
+      const complete = () => {
+        if (err) reject(err);
+        else resolve(value);
+      };
+      if (!activeClient) {
+        complete();
+        return;
+      }
+      stopGatewayClient(activeClient).finally(complete);
+    };
+    const stop = (err, value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      stopClientThenSettle(client, err, value);
+    };
+    abortHandler = () => {
+      if (settled) return;
+      ignoreClose = true;
+      settled = true;
+      cleanup();
+      const err = createGatewayRequestAbortError(opts.method);
+      const activeClient = client;
+      const stopAfterAbortHook = () => stopClientThenSettle(activeClient, err);
+      if (!activeClient || !opts.onSignalAbort || !primaryRequestStarted) {
+        stopAfterAbortHook();
+        return;
+      }
+      const request = activeClient.request.bind(activeClient);
+      Promise.resolve().then(() => opts.onSignalAbort?.(request)).catch(() => {
+      }).finally(stopAfterAbortHook);
+    };
+    opts.signal?.addEventListener("abort", abortHandler, { once: true });
+    client = gatewayCallDeps.createGatewayClient({
+      url,
+      token,
+      password,
+      tlsFingerprint,
+      preauthHandshakeTimeoutMs,
+      instanceId: opts.instanceId ?? randomUUID(),
+      clientName: opts.clientName ?? GATEWAY_CLIENT_NAMES.CLI,
+      clientDisplayName: resolveGatewayClientDisplayName(opts),
+      clientVersion: opts.clientVersion ?? VERSION,
+      platform: opts.platform,
+      mode: opts.mode ?? GATEWAY_CLIENT_MODES.CLI,
+      ...opts.approvalRuntimeToken ? { approvalRuntimeToken: opts.approvalRuntimeToken } : {},
+      role: "operator",
+      scopes,
+      deviceIdentity: opts.deviceIdentity === void 0 ? resolveDeviceIdentityForGatewayCall({
+        opts,
+        url,
+        token,
+        password
+      }) : opts.deviceIdentity,
+      minProtocol: opts.minProtocol ?? 4,
+      maxProtocol: opts.maxProtocol ?? 4,
+      onHelloOk: async (hello) => {
+        try {
+          ensureGatewaySupportsRequiredMethods({
+            requiredMethods: opts.requiredMethods,
+            methods: hello.features?.methods,
+            attemptedMethod: opts.method
+          });
+          const activeClient = client;
+          if (!activeClient) throw new Error("gateway client not initialized");
+          primaryRequestStarted = true;
+          const result = await activeClient.request(opts.method, opts.params, {
+            expectFinal: opts.expectFinal,
+            timeoutMs: opts.timeoutMs,
+            signal: opts.signal,
+            onAccepted: opts.onAccepted
+          });
+          ignoreClose = true;
+          stop(void 0, result);
+        } catch (err) {
+          ignoreClose = true;
+          stop(err);
+        }
+      },
+      onClose: (code, reason) => {
+        if (settled || ignoreClose) return;
+        ignoreClose = true;
+        stop(createGatewayCloseTransportError({
+          code,
+          reason,
+          connectionDetails: params.connectionDetails
+        }));
+      },
+      onConnectError: (err) => {
+        if (settled || !isGatewayConnectAssemblyError(err)) return;
+        ignoreClose = true;
+        stop(err);
+      }
+    });
+    timer = setTimeout(() => {
+      ignoreClose = true;
+      stop(createGatewayTimeoutTransportError({
+        timeoutMs,
+        connectionDetails: params.connectionDetails
+      }));
+    }, safeTimerTimeoutMs);
+    startGatewayClientWhenEventLoopReady(client, {
+      timeoutMs: safeTimerTimeoutMs,
+      signal: startAbort.signal
+    }).then((readiness) => {
+      if (settled || readiness.ready || readiness.aborted) return;
+      ignoreClose = true;
+      stop(createGatewayTimeoutTransportError({
+        timeoutMs,
+        connectionDetails: params.connectionDetails
+      }));
+    }).catch((err) => {
+      if (settled) return;
+      ignoreClose = true;
+      stop(err instanceof Error ? err : new Error(String(err)));
+    });
+  });
+}
+async function callGatewayWithScopes(opts, scopes) {
+  const context = resolveGatewayCallContext(opts);
+  const { timeoutMs, safeTimerTimeoutMs } = resolveGatewayCallTimeout(opts.timeoutMs, context.config.gateway?.handshakeTimeoutMs);
+  const resolvedCredentials = await resolveGatewayCredentials(context);
+  ensureExplicitGatewayAuth({
+    urlOverride: context.urlOverride,
+    urlOverrideSource: context.urlOverrideSource,
+    explicitAuth: context.explicitAuth,
+    resolvedAuth: resolvedCredentials,
+    errorHint: "Fix: pass --token or --password (or gatewayToken in tools).",
+    configPath: context.configPath
+  });
+  ensureRemoteModeUrlConfigured(context);
+  const connectionDetails = buildGatewayConnectionDetails({
+    config: context.config,
+    url: context.urlOverride,
+    urlSource: context.urlOverrideSource,
+    ...opts.configPath ? { configPath: opts.configPath } : {}
+  });
+  const url = connectionDetails.url;
+  const tlsFingerprint = await resolveGatewayTlsFingerprint({
+    opts,
+    context,
+    url
+  });
+  const { token, password } = resolvedCredentials;
+  return await executeGatewayRequestWithScopes({
+    opts,
+    scopes,
+    url,
+    token,
+    password,
+    tlsFingerprint,
+    preauthHandshakeTimeoutMs: context.config.gateway?.handshakeTimeoutMs,
+    timeoutMs,
+    safeTimerTimeoutMs,
+    connectionDetails
+  });
+}
+async function callGatewayLeastPrivilege(opts) {
+  return await callGatewayWithScopes(opts, resolveLeastPrivilegeOperatorScopesForMethod(opts.method, opts.params));
+}
+function randomIdempotencyKey() {
+  return randomUUID();
+}
+export {
+  callGatewayLeastPrivilege,
+  randomIdempotencyKey
+};