@workclaw/openclaw-workclaw 1.0.30 → 1.0.33

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/provider-env-vars-DDfJbkrO.js

@@ -0,0 +1,150 @@
+import { o as normalizeOptionalLowercaseString } from "./string-coerce-BUSzWgUA.js";
+import { t as loadPluginManifestRegistry } from "./manifest-registry-CK0zNybm.js";
+import { r as normalizeProviderId } from "./provider-id-B3nZBDJJ.js";
+const PROVIDER_AUTH_ALIAS_ORIGIN_PRIORITY = {
+  config: 0,
+  bundled: 1,
+  global: 2,
+  workspace: 3
+};
+function resolveProviderAuthAliasOriginPriority(origin) {
+  if (!origin) return Number.MAX_SAFE_INTEGER;
+  return PROVIDER_AUTH_ALIAS_ORIGIN_PRIORITY[origin] ?? Number.MAX_SAFE_INTEGER;
+}
+function normalizePluginConfigId$1(id) {
+  return normalizeOptionalLowercaseString(id) ?? "";
+}
+function hasPluginId$1(list, pluginId) {
+  return Array.isArray(list) && list.some((entry) => normalizePluginConfigId$1(entry) === pluginId);
+}
+function findPluginEntry$1(entries, pluginId) {
+  return;
+}
+function isWorkspacePluginTrustedForAuthAliases(plugin, config) {
+  const pluginsConfig = config?.plugins;
+  const pluginId = normalizePluginConfigId$1(plugin.id);
+  if (!pluginId || hasPluginId$1(pluginsConfig?.deny, pluginId)) return false;
+  const entry = findPluginEntry$1();
+  if (entry?.enabled === false) return false;
+  if (entry?.enabled === true || hasPluginId$1(pluginsConfig?.allow, pluginId)) return true;
+  return normalizePluginConfigId$1(pluginsConfig?.slots?.contextEngine) === pluginId;
+}
+function shouldUsePluginAuthAliases(plugin, params) {
+  if (plugin.origin !== "workspace" || params?.includeUntrustedWorkspacePlugins === true) return true;
+  return isWorkspacePluginTrustedForAuthAliases(plugin, params?.config);
+}
+function resolveProviderAuthAliasMap(params) {
+  const registry = loadPluginManifestRegistry({
+    config: params?.config,
+    workspaceDir: params?.workspaceDir,
+    env: params?.env
+  });
+  const preferredAliases = /* @__PURE__ */ new Map();
+  const aliases = /* @__PURE__ */ Object.create(null);
+  for (const plugin of registry.plugins) {
+    if (!shouldUsePluginAuthAliases(plugin, params)) continue;
+    for (const [alias, target] of Object.entries(plugin.providerAuthAliases ?? {}).toSorted(([left], [right]) => left.localeCompare(right))) {
+      const normalizedAlias = normalizeProviderId(alias);
+      const normalizedTarget = normalizeProviderId(target);
+      if (normalizedAlias && normalizedTarget) {
+        const existing = preferredAliases.get(normalizedAlias);
+        if (!existing || resolveProviderAuthAliasOriginPriority(plugin.origin) < resolveProviderAuthAliasOriginPriority(existing.origin)) preferredAliases.set(normalizedAlias, {
+          origin: plugin.origin,
+          target: normalizedTarget
+        });
+      }
+    }
+  }
+  for (const [alias, candidate] of preferredAliases) aliases[alias] = candidate.target;
+  return aliases;
+}
+const CORE_PROVIDER_AUTH_ENV_VAR_CANDIDATES = {
+  anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
+  openai: ["OPENAI_API_KEY"],
+  voyage: ["VOYAGE_API_KEY"],
+  cerebras: ["CEREBRAS_API_KEY"],
+  "anthropic-openai": ["ANTHROPIC_API_KEY"],
+  "qwen-dashscope": ["DASHSCOPE_API_KEY"]
+};
+const CORE_PROVIDER_SETUP_ENV_VAR_OVERRIDES = { "minimax-cn": ["MINIMAX_API_KEY"] };
+function shouldUsePluginProviderEnvVars(plugin, params) {
+  if (plugin.origin !== "workspace" || params?.includeUntrustedWorkspacePlugins !== false) return true;
+}
+function appendUniqueEnvVarCandidates(target, providerId, keys) {
+  const normalizedProviderId = providerId.trim();
+  if (!normalizedProviderId || keys.length === 0) return;
+  const bucket = target[normalizedProviderId] ??= [];
+  const seen = new Set(bucket);
+  for (const key of keys) {
+    const normalizedKey = key.trim();
+    if (!normalizedKey || seen.has(normalizedKey)) continue;
+    seen.add(normalizedKey);
+    bucket.push(normalizedKey);
+  }
+}
+function resolveManifestProviderAuthEnvVarCandidates(params) {
+  const registry = loadPluginManifestRegistry({
+    config: params?.config,
+    workspaceDir: params?.workspaceDir,
+    env: params?.env
+  });
+  const candidates = {};
+  for (const plugin of registry.plugins) {
+    if (!shouldUsePluginProviderEnvVars(plugin, params)) continue;
+    if (!plugin.providerAuthEnvVars) continue;
+    for (const [providerId, keys] of Object.entries(plugin.providerAuthEnvVars).toSorted(([left], [right]) => left.localeCompare(right))) appendUniqueEnvVarCandidates(candidates, providerId, keys);
+  }
+  const aliases = resolveProviderAuthAliasMap(params);
+  for (const [alias, target] of Object.entries(aliases).toSorted(([left], [right]) => left.localeCompare(right))) {
+    const keys = candidates[target];
+    if (keys) appendUniqueEnvVarCandidates(candidates, alias, keys);
+  }
+  return candidates;
+}
+function resolveProviderAuthEnvVarCandidates(params) {
+  return {
+    ...resolveManifestProviderAuthEnvVarCandidates(params),
+    ...CORE_PROVIDER_AUTH_ENV_VAR_CANDIDATES
+  };
+}
+function resolveProviderEnvVars(params) {
+  return {
+    ...resolveProviderAuthEnvVarCandidates(params),
+    ...CORE_PROVIDER_SETUP_ENV_VAR_OVERRIDES
+  };
+}
+function createLazyReadonlyRecord(resolve) {
+  let cached;
+  const getResolved = () => {
+    cached ??= resolve();
+    return cached;
+  };
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop !== "string") return;
+      return getResolved()[prop];
+    },
+    has(_target, prop) {
+      return typeof prop === "string" && Object.hasOwn(getResolved(), prop);
+    },
+    ownKeys() {
+      return Reflect.ownKeys(getResolved());
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      if (typeof prop !== "string") return;
+      const value = getResolved()[prop];
+      if (value === void 0) return;
+      return {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: false
+      };
+    }
+  });
+}
+createLazyReadonlyRecord(() => resolveProviderAuthEnvVarCandidates());
+createLazyReadonlyRecord(() => resolveProviderEnvVars());
+export {
+  resolveProviderAuthEnvVarCandidates as a
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/provider-id-B3nZBDJJ.js

@@ -0,0 +1,15 @@
+import { i as normalizeLowercaseStringOrEmpty } from "./string-coerce-BUSzWgUA.js";
+function normalizeProviderId(provider) {
+  const normalized = normalizeLowercaseStringOrEmpty(provider);
+  if (normalized === "modelstudio" || normalized === "qwencloud") return "qwen";
+  if (normalized === "z.ai" || normalized === "z-ai") return "zai";
+  if (normalized === "opencode-zen") return "opencode";
+  if (normalized === "opencode-go-auth") return "opencode-go";
+  if (normalized === "kimi" || normalized === "kimi-code" || normalized === "kimi-coding") return "kimi";
+  if (normalized === "bedrock" || normalized === "aws-bedrock") return "amazon-bedrock";
+  if (normalized === "bytedance" || normalized === "doubao") return "volcengine";
+  return normalized;
+}
+export {
+  normalizeProviderId as r
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/provider-runtime-O-n0cjZo.js

@@ -0,0 +1,22 @@
+import "./utils-DGFSjtQF.js";
+import "node:fs";
+import "node:path";
+import "node:os";
+import "node:fs/promises";
+import "./bundled-dir-Cq5y_NKM.js";
+import "./io-DDkf_FUu.js";
+import "./bundled-Cuj8sKt6.js";
+import "./redact-D4nea1HF.js";
+import "./subsystem-BHv2zSx6.js";
+import "./ids-By7Nkc8R.js";
+import "./version-b06Uhxnq.js";
+import "node:process";
+import "./registry-DE4nHTjg.js";
+import "./paths-LCYGfrV7.js";
+import "./setup-registry-BPL6c_Zk.js";
+import "./loader-DYJR63Q1.js";
+import "./runtime-Clo2XF6T.js";
+import "./workspace-oVBetctb.js";
+import "./logger-BMuqDP66.js";
+import { createRequire } from "node:module";
+createRequire(import.meta.url);

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/public-surface-loader-CSDxBey4.js

@@ -0,0 +1,14 @@
+import "node:fs";
+import "node:path";
+import "node:os";
+import "node:fs/promises";
+import "./bundled-dir-Cq5y_NKM.js";
+import { l as resolveLoaderPackageRoot } from "./sdk-alias-Bo1huP7M.js";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import "../node_modules/jiti/dist/jiti.js";
+resolveLoaderPackageRoot({
+  modulePath: fileURLToPath(import.meta.url),
+  moduleUrl: import.meta.url
+}) ?? fileURLToPath(new URL("../..", import.meta.url));
+createRequire(import.meta.url);

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/redact-D4nea1HF.js

@@ -0,0 +1,2 @@
+import { t as resolveNodeRequireFromMeta } from "./node-require-DvwmVoHm.js";
+resolveNodeRequireFromMeta(import.meta.url);

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/ref-contract-B1q5N0Lz.js

@@ -0,0 +1,35 @@
+import "./utils-DGFSjtQF.js";
+const FILE_SECRET_REF_SEGMENT_PATTERN = /^(?:[^~]|~0|~1)*$/;
+const EXEC_SECRET_REF_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/;
+function isValidFileSecretRefId(value) {
+  if (value === "value") return true;
+  if (!value.startsWith("/")) return false;
+  return value.slice(1).split("/").every((segment) => FILE_SECRET_REF_SEGMENT_PATTERN.test(segment));
+}
+function validateExecSecretRefId(value) {
+  if (!EXEC_SECRET_REF_ID_PATTERN.test(value)) return {
+    ok: false,
+    reason: "pattern"
+  };
+  for (const segment of value.split("/")) if (segment === "." || segment === "..") return {
+    ok: false,
+    reason: "traversal-segment"
+  };
+  return { ok: true };
+}
+function isValidExecSecretRefId(value) {
+  return validateExecSecretRefId(value).ok;
+}
+function formatExecSecretRefIdValidationMessage() {
+  return [
+    "Exec secret reference id must match /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}$/",
+    'and must not include "." or ".." path segments',
+    '(example: "vault/openai/api-key").'
+  ].join(" ");
+}
+export {
+  formatExecSecretRefIdValidationMessage as a,
+  validateExecSecretRefId as d,
+  isValidExecSecretRefId as o,
+  isValidFileSecretRefId as s
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/registry-DE4nHTjg.js

@@ -0,0 +1,54 @@
+import { s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+import { n as CHAT_CHANNEL_ORDER, i as listBundledChannelCatalogEntries } from "./ids-By7Nkc8R.js";
+function resolveChannelExposure(meta) {
+  return {
+    configured: meta.exposure?.configured ?? meta.showConfigured ?? true,
+    setup: meta.exposure?.setup ?? meta.showInSetup ?? true,
+    docs: meta.exposure?.docs ?? true
+  };
+}
+const CHAT_CHANNEL_ID_SET = new Set(CHAT_CHANNEL_ORDER);
+function toChatChannelMeta(params) {
+  const label = normalizeOptionalString(params.channel.label);
+  if (!label) throw new Error(`Missing label for bundled chat channel "${params.id}"`);
+  const exposure = resolveChannelExposure(params.channel);
+  return {
+    id: params.id,
+    label,
+    selectionLabel: normalizeOptionalString(params.channel.selectionLabel) || label,
+    docsPath: normalizeOptionalString(params.channel.docsPath) || `/channels/${params.id}`,
+    docsLabel: normalizeOptionalString(params.channel.docsLabel),
+    blurb: normalizeOptionalString(params.channel.blurb) || "",
+    ...params.channel.aliases?.length ? { aliases: params.channel.aliases } : {},
+    ...params.channel.order !== void 0 ? { order: params.channel.order } : {},
+    ...params.channel.selectionDocsPrefix !== void 0 ? { selectionDocsPrefix: params.channel.selectionDocsPrefix } : {},
+    ...params.channel.selectionDocsOmitLabel !== void 0 ? { selectionDocsOmitLabel: params.channel.selectionDocsOmitLabel } : {},
+    ...params.channel.selectionExtras?.length ? { selectionExtras: params.channel.selectionExtras } : {},
+    ...normalizeOptionalString(params.channel.detailLabel) ? { detailLabel: normalizeOptionalString(params.channel.detailLabel) } : {},
+    ...normalizeOptionalString(params.channel.systemImage) ? { systemImage: normalizeOptionalString(params.channel.systemImage) } : {},
+    ...params.channel.markdownCapable !== void 0 ? { markdownCapable: params.channel.markdownCapable } : {},
+    exposure,
+    ...params.channel.quickstartAllowFrom !== void 0 ? { quickstartAllowFrom: params.channel.quickstartAllowFrom } : {},
+    ...params.channel.forceAccountBinding !== void 0 ? { forceAccountBinding: params.channel.forceAccountBinding } : {},
+    ...params.channel.preferSessionLookupForAnnounceTarget !== void 0 ? { preferSessionLookupForAnnounceTarget: params.channel.preferSessionLookupForAnnounceTarget } : {},
+    ...params.channel.preferOver?.length ? { preferOver: params.channel.preferOver } : {}
+  };
+}
+function buildChatChannelMetaById() {
+  const entries = /* @__PURE__ */ new Map();
+  for (const entry of listBundledChannelCatalogEntries()) {
+    const rawId = normalizeOptionalString(entry.id);
+    if (!rawId || !CHAT_CHANNEL_ID_SET.has(rawId)) continue;
+    const id = rawId;
+    entries.set(id, toChatChannelMeta({
+      id,
+      channel: entry.channel
+    }));
+  }
+  return Object.freeze(Object.fromEntries(entries));
+}
+buildChatChannelMetaById();
+export {
+  resolveChannelExposure as f,
+  buildChatChannelMetaById as l
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/registry-loaded-B8D6rQiJ.js

@@ -0,0 +1,62 @@
+import { s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+import { n as CHAT_CHANNEL_ORDER } from "./ids-By7Nkc8R.js";
+import { t as getActivePluginChannelRegistryFromState, n as getActivePluginChannelRegistryVersionFromState } from "./runtime-channel-state-Ck2VkX9T.js";
+import "./registry-DE4nHTjg.js";
+let cachedChannelPlugins = {
+  registryVersion: -1,
+  registryRef: null,
+  sorted: [],
+  byId: /* @__PURE__ */ new Map()
+};
+function coerceLoadedChannelPlugin(plugin) {
+  const id = normalizeOptionalString(plugin?.id) ?? "";
+  if (!plugin || !id) return null;
+  if (!plugin.meta || typeof plugin.meta !== "object") plugin.meta = {};
+  return plugin;
+}
+function dedupeChannels(channels) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const plugin of channels) {
+    const id = normalizeOptionalString(plugin.id) ?? "";
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    resolved.push(plugin);
+  }
+  return resolved;
+}
+function resolveCachedChannelPlugins() {
+  const registry = getActivePluginChannelRegistryFromState();
+  const registryVersion = getActivePluginChannelRegistryVersionFromState();
+  const cached = cachedChannelPlugins;
+  if (cached.registryVersion === registryVersion && cached.registryRef === registry) return cached;
+  const channelPlugins = [];
+  if (registry && Array.isArray(registry.channels)) for (const entry of registry.channels) {
+    const plugin = coerceLoadedChannelPlugin(entry?.plugin);
+    if (plugin) channelPlugins.push(plugin);
+  }
+  const sorted = dedupeChannels(channelPlugins).toSorted((a, b) => {
+    const indexA = CHAT_CHANNEL_ORDER.indexOf(a.id);
+    const indexB = CHAT_CHANNEL_ORDER.indexOf(b.id);
+    const orderA = a.meta.order ?? (indexA === -1 ? 999 : indexA);
+    const orderB = b.meta.order ?? (indexB === -1 ? 999 : indexB);
+    if (orderA !== orderB) return orderA - orderB;
+    return a.id.localeCompare(b.id);
+  });
+  const byId = /* @__PURE__ */ new Map();
+  for (const plugin of sorted) byId.set(plugin.id, plugin);
+  const next = {
+    registryVersion,
+    registryRef: registry,
+    sorted,
+    byId
+  };
+  cachedChannelPlugins = next;
+  return next;
+}
+function listLoadedChannelPlugins() {
+  return resolveCachedChannelPlugins().sorted.slice();
+}
+export {
+  listLoadedChannelPlugins as n
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/registry-nEl7QZ30.js

@@ -0,0 +1,3 @@
+import { n as resolveGlobalSingleton } from "./global-singleton-DhGoboiG.js";
+const CONTEXT_ENGINE_REGISTRY_STATE = Symbol.for("openclaw.contextEngineRegistryState");
+resolveGlobalSingleton(CONTEXT_ENGINE_REGISTRY_STATE, () => ({ engines: /* @__PURE__ */ new Map() }));

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/runtime-Clo2XF6T.js

@@ -0,0 +1,27 @@
+import { t as PLUGIN_REGISTRY_STATE } from "./runtime-state-Cd3jnHgw.js";
+(() => {
+  const globalState = globalThis;
+  let registryState = globalState[PLUGIN_REGISTRY_STATE];
+  if (!registryState) {
+    registryState = {
+      activeRegistry: null,
+      activeVersion: 0,
+      httpRoute: {
+        registry: null,
+        pinned: false,
+        version: 0
+      },
+      channel: {
+        registry: null,
+        pinned: false,
+        version: 0
+      },
+      key: null,
+      workspaceDir: null,
+      runtimeSubagentMode: "default",
+      importedPluginIds: /* @__PURE__ */ new Set()
+    };
+    globalState[PLUGIN_REGISTRY_STATE] = registryState;
+  }
+  return registryState;
+})();

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/runtime-channel-state-Ck2VkX9T.js

@@ -0,0 +1,20 @@
+const PLUGIN_REGISTRY_STATE = Symbol.for("openclaw.pluginRegistryState");
+function countChannels(registry) {
+  return registry?.channels?.length ?? 0;
+}
+function getActivePluginChannelRegistryFromState() {
+  const state = globalThis[PLUGIN_REGISTRY_STATE];
+  const pinnedRegistry = state?.channel?.registry ?? null;
+  if (countChannels(pinnedRegistry) > 0) return pinnedRegistry;
+  const activeRegistry = state?.activeRegistry ?? null;
+  if (countChannels(activeRegistry) > 0) return activeRegistry;
+  return pinnedRegistry ?? activeRegistry;
+}
+function getActivePluginChannelRegistryVersionFromState() {
+  const state = globalThis[PLUGIN_REGISTRY_STATE];
+  return state?.channel?.registry ? state.channel.version ?? 0 : state?.activeVersion ?? 0;
+}
+export {
+  getActivePluginChannelRegistryVersionFromState as n,
+  getActivePluginChannelRegistryFromState as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/runtime-guard-DqVOvWAZ.js

@@ -0,0 +1,23 @@
+import "node:process";
+const SEMVER_RE = /(\d+)\.(\d+)\.(\d+)/;
+function parseSemver(version) {
+  if (!version) return null;
+  const match = version.match(SEMVER_RE);
+  if (!match) return null;
+  const [, major, minor, patch] = match;
+  return {
+    major: Number.parseInt(major, 10),
+    minor: Number.parseInt(minor, 10),
+    patch: Number.parseInt(patch, 10)
+  };
+}
+function isAtLeast(version, minimum) {
+  if (!version) return false;
+  if (version.major !== minimum.major) return version.major > minimum.major;
+  if (version.minor !== minimum.minor) return version.minor > minimum.minor;
+  return version.patch >= minimum.patch;
+}
+export {
+  parseSemver as a,
+  isAtLeast as n
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/runtime-state-Cd3jnHgw.js

@@ -0,0 +1,4 @@
+const PLUGIN_REGISTRY_STATE = Symbol.for("openclaw.pluginRegistryState");
+export {
+  PLUGIN_REGISTRY_STATE as t
+};

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/schema-validator-Bo7NeV8w.js

@@ -0,0 +1,3 @@
+import "./utils-DGFSjtQF.js";
+import { createRequire } from "node:module";
+createRequire(import.meta.url);

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/scp-host-CiFVRWHy.js

@@ -0,0 +1,38 @@
+import { s as normalizeOptionalString } from "./string-coerce-BUSzWgUA.js";
+const SSH_TOKEN = /^[A-Za-z0-9._-]+$/;
+const BRACKETED_IPV6 = /^\[[0-9A-Fa-f:.%]+\]$/;
+const WHITESPACE = /\s/;
+function hasControlOrWhitespace(value) {
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (code <= 31 || code === 127 || WHITESPACE.test(char)) return true;
+  }
+  return false;
+}
+function normalizeScpRemoteHost(value) {
+  const trimmed = normalizeOptionalString(value);
+  if (!trimmed) return;
+  if (hasControlOrWhitespace(trimmed)) return;
+  if (trimmed.startsWith("-") || trimmed.includes("/") || trimmed.includes("\\")) return;
+  const firstAt = trimmed.indexOf("@");
+  const lastAt = trimmed.lastIndexOf("@");
+  let user;
+  let host = trimmed;
+  if (firstAt !== -1) {
+    if (firstAt !== lastAt || firstAt === 0 || firstAt === trimmed.length - 1) return;
+    user = trimmed.slice(0, firstAt);
+    host = trimmed.slice(firstAt + 1);
+    if (!SSH_TOKEN.test(user)) return;
+  }
+  if (!host || host.startsWith("-") || host.includes("@")) return;
+  if (host.includes(":") && !BRACKETED_IPV6.test(host)) return;
+  if (!SSH_TOKEN.test(host) && !BRACKETED_IPV6.test(host)) return;
+  return user ? `${user}@${host}` : host;
+}
+function isSafeScpRemoteHost(value) {
+  return normalizeScpRemoteHost(value) !== void 0;
+}
+export {
+  normalizeScpRemoteHost as r,
+  isSafeScpRemoteHost as t
+};