@shadowob/connector 1.1.16 → 1.1.18

package/dist/cli.js

@@ -7662,10 +7662,10 @@ var require_main = __commonJS({
 });
 
 // src/cli.ts
-import { spawn, spawnSync as spawnSync2 } from "child_process";
-import { chmodSync as chmodSync2, cpSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
-import { arch, homedir as homedir2, hostname, platform } from "os";
-import { dirname as dirname2, resolve as resolve2 } from "path";
+import { spawn, spawnSync as spawnSync3 } from "child_process";
+import { chmodSync as chmodSync3, cpSync, existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync, writeFileSync as writeFileSync3 } from "fs";
+import { arch, homedir as homedir3, hostname, platform as platform2 } from "os";
+import { dirname as dirname3, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 
 // ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
@@ -8521,20 +8521,20 @@ import { dirname, resolve } from "path";
 
 // src/cc-connect-fork.ts
 var CC_CONNECT_FORK_REPO = "buggyblues/cc-connect";
-var CC_CONNECT_FORK_REF = "63b5d59127b3004bc7002f2d51892b1f2a91ea83";
+var CC_CONNECT_FORK_REF = "f382563cfebaef36c5d257461dfaf318161fe3ea";
 var CC_CONNECT_FORK_SHORT_REF = CC_CONNECT_FORK_REF.slice(0, 7);
-var CC_CONNECT_FORK_PACKAGE_VERSION = "1.3.3-beta.5";
+var CC_CONNECT_FORK_PACKAGE_VERSION = "1.3.3-beta.7";
 var CC_CONNECT_FORK_DOCS_URL = `https://github.com/${CC_CONNECT_FORK_REPO}/blob/main/docs/shadowob.md`;
 
 // src/cc-connect-installer.ts
 var NAME = "cc-connect";
 var RELEASE_ARCHIVE_SHA256 = {
-  "cc-connect-v1.3.3-beta.5-darwin-amd64.tar.gz": "71677cd565f6ea79e186ffc1b842e4548faa3baeb2e3dd2ced25ab2e95c416a3",
-  "cc-connect-v1.3.3-beta.5-darwin-arm64.tar.gz": "c1fc5a3d4cfe6db97a5d864ea844dbfd86345b89cea3d89871330568e6eb43cf",
-  "cc-connect-v1.3.3-beta.5-linux-amd64.tar.gz": "812484d19733044c8c5d67d997a921e351e2ae4e9a200ce5ae258ab338400bc1",
-  "cc-connect-v1.3.3-beta.5-linux-arm64.tar.gz": "290110a60e905f5e25f6133f52c1b3988ab6aeff1b1199318398cfef06f81e9a",
-  "cc-connect-v1.3.3-beta.5-windows-amd64.zip": "a90f8a669a48412fc5896613173b5e9b3dc5fdebdee731b6f6b9d4625a200952",
-  "cc-connect-v1.3.3-beta.5-windows-arm64.zip": "3c5ff24769d95c42b95a717949dc6369169c029e1110ab4bdd76d12e0043d283"
+  "cc-connect-v1.3.3-beta.7-darwin-amd64.tar.gz": "e5215b202924eea6d98c8dda79318e7ab5ff663e4b7a4091f316e625b87d763f",
+  "cc-connect-v1.3.3-beta.7-darwin-arm64.tar.gz": "633927197755ae14f8987aaf078b9b20003aa69abfd3f7d99dd657c36812f288",
+  "cc-connect-v1.3.3-beta.7-linux-amd64.tar.gz": "ad290a15ba6de0686e18f54221ab83e093bc22513dd1fb29f51c2ce2d26d003d",
+  "cc-connect-v1.3.3-beta.7-linux-arm64.tar.gz": "cb4473e7c128be83c5965dc7e6ef8c4bafd3b7dce1cb2e8adb72064818b85acb",
+  "cc-connect-v1.3.3-beta.7-windows-amd64.zip": "174b53ca30f3667caef640b403b442521b9b37bf45f7e1bfad3c19d07b84c581",
+  "cc-connect-v1.3.3-beta.7-windows-arm64.zip": "ce32a00d2ec4f8deeefe134ba23d4bd6587651c32772773c81772739fe335713"
 };
 var PLATFORM_MAP = {
   darwin: "darwin",
@@ -8580,14 +8580,14 @@ function runCommand(command, args, options) {
   }
 }
 function platformInfo() {
-  const platform2 = PLATFORM_MAP[process.platform];
+  const platform3 = PLATFORM_MAP[process.platform];
   const arch2 = ARCH_MAP[process.arch];
-  if (!platform2 || !arch2) {
+  if (!platform3 || !arch2) {
     throw new Error(
       `Unsupported cc-connect platform: ${process.platform}/${process.arch}. Supported: linux/darwin/windows x64/arm64`
     );
   }
-  return { platform: platform2, arch: arch2, ext: platform2 === "windows" ? ".zip" : ".tar.gz" };
+  return { platform: platform3, arch: arch2, ext: platform3 === "windows" ? ".zip" : ".tar.gz" };
 }
 function fetchBuffer(url, redirects = 5) {
   return new Promise((resolvePromise, reject) => {
@@ -8650,9 +8650,9 @@ function verifyReleaseChecksum(filename, data) {
   }
 }
 async function installFromRelease(binaryPath, options) {
-  const { platform: platform2, arch: arch2, ext } = platformInfo();
+  const { platform: platform3, arch: arch2, ext } = platformInfo();
   const version = `v${CC_CONNECT_FORK_PACKAGE_VERSION}`;
-  const filename = `${NAME}-${version}-${platform2}-${arch2}${ext}`;
+  const filename = `${NAME}-${version}-${platform3}-${arch2}${ext}`;
   const url = `https://github.com/${CC_CONNECT_FORK_REPO}/releases/download/${version}/${filename}`;
   const binDir = dirname(binaryPath);
   const archivePath = resolve(binDir, `_release${ext}`);
@@ -8806,6 +8806,19 @@ function ensureTrailingNewline(value) {
 function quoteEnv(value) {
   return /^[A-Za-z0-9_./:@-]+$/.test(value) ? value : JSON.stringify(value);
 }
+function normalizeModelProvider(provider) {
+  const baseUrl = provider?.baseUrl.trim();
+  const apiKey = provider?.apiKey.trim();
+  const model = provider?.model.trim();
+  if (!baseUrl || !apiKey || !model) return null;
+  return {
+    id: provider?.id?.trim() || "shadow-official",
+    label: provider?.label?.trim() || "Shadow official LLM proxy",
+    baseUrl,
+    apiKey,
+    model
+  };
+}
 function normalizeJsonRoot(existing, label) {
   if (!existing.trim()) return {};
   const parsed = JSON.parse(existing);
@@ -8833,11 +8846,18 @@ function parseTomlRoot(existing, label) {
 }
 function mergeEnvContent(existing, values) {
   (0, import_dotenv.parse)(existing);
+  const modelProvider = normalizeModelProvider(values.modelProvider);
   const updates = {
     SHADOW_BASE_URL: values.serverUrl,
     SHADOW_TOKEN: values.token,
     ...SHADOW_ENV_VALUES
   };
+  if (modelProvider) {
+    updates.OPENAI_COMPATIBLE_BASE_URL = modelProvider.baseUrl;
+    updates.OPENAI_COMPATIBLE_API_KEY = modelProvider.apiKey;
+    updates.OPENAI_COMPATIBLE_MODEL_ID = modelProvider.model;
+    updates.SHADOW_MODEL_PROVIDER_ID = modelProvider.id ?? "shadow-official";
+  }
   const seen = /* @__PURE__ */ new Set();
   const lines = existing.length > 0 ? existing.split(/\r?\n/) : [];
   const next = [];
@@ -8860,6 +8880,7 @@ function mergeEnvContent(existing, values) {
 }
 function mergeOpenClawConfigContent(existing, values) {
   const root = normalizeJsonRoot(existing, "OpenClaw");
+  const modelProvider = normalizeModelProvider(values.modelProvider);
   const channels = asRecord(root.channels);
   const legacyShadow = asRecord(channels["openclaw-shadowob"]);
   const shadow = asRecord(channels.shadowob);
@@ -8884,10 +8905,27 @@ function mergeOpenClawConfigContent(existing, values) {
   };
   plugins.entries = entries;
   root.plugins = plugins;
+  if (modelProvider) {
+    const models = asRecord(root.models);
+    const providers = asRecord(models.providers);
+    const providerId = modelProvider.id ?? "shadow-official";
+    providers[providerId] = {
+      ...asRecord(providers[providerId]),
+      api: "openai-completions",
+      apiKey: "${env:OPENAI_COMPATIBLE_API_KEY}",
+      baseUrl: modelProvider.baseUrl,
+      request: { allowPrivateNetwork: true },
+      models: [{ id: modelProvider.model, name: modelProvider.model }]
+    };
+    models.mode = models.mode ?? "merge";
+    models.providers = providers;
+    root.models = models;
+  }
   return ensureTrailingNewline(JSON.stringify(root, null, 2));
 }
 function mergeHermesConfigContent(existing, values) {
   const root = parseYamlRoot(existing, "Hermes");
+  const modelProvider = normalizeModelProvider(values.modelProvider);
   const plugins = asRecord(root.plugins);
   plugins.enabled = uniqueStrings(Array.isArray(plugins.enabled) ? plugins.enabled : [], "shadowob");
   root.plugins = plugins;
@@ -8909,6 +8947,15 @@ function mergeHermesConfigContent(existing, values) {
     }
   };
   root.platforms = platforms;
+  if (modelProvider) {
+    const model = asRecord(root.model);
+    root.model = {
+      ...model,
+      default: model.model ?? model.default ?? modelProvider.model,
+      provider: model.provider ?? "custom",
+      base_url: model.base_url ?? modelProvider.baseUrl
+    };
+  }
   return ensureTrailingNewline((0, import_yaml.stringify)(root));
 }
 function asTomlTable(value) {
@@ -8945,6 +8992,27 @@ function mergeCcConnectConfigContent(existing, values) {
     ...agentOptions,
     work_dir: values.workDir
   };
+  const modelProvider = normalizeModelProvider(values.modelProvider);
+  if (modelProvider) {
+    agent.options = {
+      ...asTomlTable(agent.options),
+      provider: modelProvider.id ?? "shadow-official",
+      model: modelProvider.model
+    };
+    const providers = tomlArray(agent.providers);
+    const providerId = modelProvider.id ?? "shadow-official";
+    let provider = providers.find((item) => item.name === providerId);
+    if (!provider) {
+      provider = {};
+      providers.push(provider);
+    }
+    provider.name = providerId;
+    provider.api_key = modelProvider.apiKey;
+    provider.base_url = modelProvider.baseUrl;
+    provider.model = modelProvider.model;
+    provider.models = [{ model: modelProvider.model }];
+    agent.providers = providers;
+  }
   project.agent = agent;
   const platforms = tomlArray(project.platforms);
   let shadowPlatform = platforms.find((item) => item.type === "shadowob");
@@ -9154,9 +9222,35 @@ var normalizeServerUrl = (value) => {
   return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed.replace(/\/$/, "");
 };
 var tokenOrPlaceholder = (token) => token.trim() || "<BUDDY_TOKEN>";
+function normalizeModelProvider2(input) {
+  const baseUrl = input.modelProvider?.baseUrl.trim();
+  const apiKey = input.modelProvider?.apiKey.trim();
+  const model = input.modelProvider?.model.trim();
+  if (!baseUrl || !apiKey || !model) return null;
+  return {
+    id: input.modelProvider?.id?.trim() || "shadow-official",
+    label: input.modelProvider?.label?.trim() || "Shadow official LLM proxy",
+    baseUrl,
+    apiKey,
+    model
+  };
+}
+function modelProviderEnvLines(provider) {
+  if (!provider) return [];
+  return [
+    `OPENAI_COMPATIBLE_BASE_URL=${shellQuote(provider.baseUrl)}`,
+    `OPENAI_COMPATIBLE_API_KEY=${shellQuote(provider.apiKey)}`,
+    `OPENAI_COMPATIBLE_MODEL_ID=${shellQuote(provider.model)}`,
+    `SHADOW_MODEL_PROVIDER_ID=${shellQuote(provider.id ?? "shadow-official")}`
+  ];
+}
+function modelProviderCapabilities(provider, capabilities) {
+  return provider ? [...capabilities, "officialModelProvider"] : capabilities;
+}
 function buildOpenClawPlan(input) {
   const token = tokenOrPlaceholder(input.token);
   const serverUrl = normalizeServerUrl(input.serverUrl);
+  const modelProvider = normalizeModelProvider2(input);
   const jsonConfig = JSON.stringify(
     {
       channels: {
@@ -9164,7 +9258,21 @@ function buildOpenClawPlan(input) {
           token,
           serverUrl
         }
-      }
+      },
+      ...modelProvider ? {
+        models: {
+          mode: "merge",
+          providers: {
+            [modelProvider.id ?? "shadow-official"]: {
+              api: "openai-completions",
+              apiKey: "${env:OPENAI_COMPATIBLE_API_KEY}",
+              baseUrl: modelProvider.baseUrl,
+              request: { allowPrivateNetwork: true },
+              models: [{ id: modelProvider.model, name: modelProvider.model }]
+            }
+          }
+        }
+      } : {}
     },
     null,
     2
@@ -9210,6 +9318,7 @@ function buildOpenClawPlan(input) {
       "",
       `Preferred one-line setup: ${connectCommand}`,
       "The connector installs/configures the Shadow CLI, official Shadow skill files, and the Buddy profile before applying the OpenClaw channel config.",
+      modelProvider ? `It also configures ${modelProvider.label ?? "Shadow official LLM proxy"} as an OpenAI-compatible model provider (${modelProvider.model}).` : "",
       "",
       "Run these steps in order:",
       ...commands.map((item, index) => `${index + 1}. ${item.command}`),
@@ -9217,7 +9326,7 @@ function buildOpenClawPlan(input) {
       "Confirm each step and then verify the gateway is running."
     ].join("\n"),
     docsUrl: "/product/index.html",
-    capabilities: [
+    capabilities: modelProviderCapabilities(modelProvider, [
       "channelMessages",
       "dms",
       "threads",
@@ -9238,18 +9347,20 @@ function buildOpenClawPlan(input) {
       "notifications",
       "officialSkills",
       "cronTasks"
-    ]
+    ])
   };
 }
 function buildHermesPlan(input) {
   const token = tokenOrPlaceholder(input.token);
   const serverUrl = normalizeServerUrl(input.serverUrl);
+  const modelProvider = normalizeModelProvider2(input);
   const envBlock = [
     `SHADOW_BASE_URL=${shellQuote(serverUrl)}`,
     `SHADOW_TOKEN=${shellQuote(token)}`,
     "SHADOW_ALLOW_ALL_USERS=true",
     "SHADOW_HEARTBEAT_INTERVAL_SECONDS=30",
-    `SHADOW_SLASH_COMMANDS_JSON=${shellQuote("[]")}`
+    `SHADOW_SLASH_COMMANDS_JSON=${shellQuote("[]")}`,
+    ...modelProviderEnvLines(modelProvider)
   ].join("\n");
   const yamlConfig = [
     "plugins:",
@@ -9266,7 +9377,14 @@ function buildHermesPlan(input) {
     "      rest_only: false",
     "      catchup_minutes: 0",
     "      download_media: true",
-    "      slash_commands: []"
+    "      slash_commands: []",
+    ...modelProvider ? [
+      "",
+      "model:",
+      `  default: "${modelProvider.model}"`,
+      "  provider: custom",
+      `  base_url: "${modelProvider.baseUrl}"`
+    ] : []
   ].join("\n");
   const commands = [
     {
@@ -9310,10 +9428,11 @@ function buildHermesPlan(input) {
       `Buddy token: ${token}`,
       "",
       `Preferred one-line setup: ${connectCommand}`,
-      "The connector installs/configures the Shadow CLI, official Shadow skill files, and the Buddy profile before writing Hermes config. The plugin resolves the Buddy agent id and channel policy from Shadow at runtime."
+      "The connector installs/configures the Shadow CLI, official Shadow skill files, and the Buddy profile before writing Hermes config. The plugin resolves the Buddy agent id and channel policy from Shadow at runtime.",
+      modelProvider ? `It also configures Hermes custom model endpoint ${modelProvider.baseUrl} with model ${modelProvider.model}.` : ""
     ].join("\n"),
     docsUrl: "https://hermes-agent.nousresearch.com/docs/user-guide/messaging",
-    capabilities: [
+    capabilities: modelProviderCapabilities(modelProvider, [
       "channelMessages",
       "dms",
       "threads",
@@ -9330,7 +9449,7 @@ function buildHermesPlan(input) {
       "shadowCliLogin",
       "notifications",
       "officialSkills"
-    ]
+    ])
   };
 }
 function buildCcConnectPlan(input) {
@@ -9339,6 +9458,7 @@ function buildCcConnectPlan(input) {
   const projectName = input.projectName?.trim() || DEFAULT_PROJECT_NAME;
   const workDir = input.workDir?.trim() || DEFAULT_WORK_DIR;
   const agentType = input.agentType?.trim() || DEFAULT_CC_AGENT;
+  const modelProvider = normalizeModelProvider2(input);
   const tomlConfig = [
     'language = "zh"',
     "",
@@ -9350,6 +9470,19 @@ function buildCcConnectPlan(input) {
     "",
     "[projects.agent.options]",
     `work_dir = "${workDir}"`,
+    ...modelProvider ? [
+      `provider = "${modelProvider.id ?? "shadow-official"}"`,
+      `model = "${modelProvider.model}"`,
+      "",
+      "[[projects.agent.providers]]",
+      `name = "${modelProvider.id ?? "shadow-official"}"`,
+      `api_key = "${modelProvider.apiKey}"`,
+      `base_url = "${modelProvider.baseUrl}"`,
+      `model = "${modelProvider.model}"`,
+      "",
+      "[[projects.agent.providers.models]]",
+      `model = "${modelProvider.model}"`
+    ] : [],
     "",
     "[[projects.platforms]]",
     'type = "shadowob"',
@@ -9402,10 +9535,11 @@ function buildCcConnectPlan(input) {
       `Agent type: ${agentType}`,
       "",
       `Preferred one-line setup: ${startCommand}`,
-      `Install ${CC_CONNECT_FORK_REPO}@${CC_CONNECT_FORK_SHORT_REF}, install/configure the Shadow CLI and official Shadow skill files, add the TOML platform block, and start cc-connect.`
+      `Install ${CC_CONNECT_FORK_REPO}@${CC_CONNECT_FORK_SHORT_REF}, install/configure the Shadow CLI and official Shadow skill files, add the TOML platform block, and start cc-connect.`,
+      modelProvider ? `Configure ${modelProvider.label ?? "Shadow official LLM proxy"} as provider ${modelProvider.id ?? "shadow-official"} for ${agentType}.` : ""
     ].join("\n"),
     docsUrl: CC_CONNECT_FORK_DOCS_URL,
-    capabilities: [
+    capabilities: modelProviderCapabilities(modelProvider, [
       "channelMessages",
       "dms",
       "attachments",
@@ -9420,7 +9554,7 @@ function buildCcConnectPlan(input) {
       "multiAgentBinding",
       "shadowCliLogin",
       "notifications"
-    ]
+    ])
   };
 }
 function createConnectorPlan(input) {
@@ -9430,6 +9564,287 @@ function createConnectorPlan(input) {
   throw new Error(`Unsupported connector target: ${String(input.target)}`);
 }
 
+// src/toolchain.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import {
+  chmodSync as chmodSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { get as httpsGet2 } from "https";
+import { homedir as homedir2, platform } from "os";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+var CONNECTOR_MANAGED_NODE_VERSION = process.env.SHADOW_CONNECTOR_NODE_VERSION?.trim() || "22.16.0";
+var PATH_KEY = process.platform === "win32" ? "Path" : "PATH";
+var NODE_PLATFORM = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "win"
+};
+var NODE_ARCH = {
+  x64: "x64",
+  arm64: "arm64"
+};
+var loginShellPath;
+var cachedNvmBinDirs;
+var cachedConnectorPath;
+function expandHome2(value) {
+  return value.startsWith("~/") ? resolve2(homedir2(), value.slice(2)) : resolve2(value);
+}
+function connectorHome() {
+  const override = process.env.SHADOW_CONNECTOR_HOME?.trim();
+  return override ? expandHome2(override) : resolve2(homedir2(), ".shadowob/connector");
+}
+function managedNodeRoot() {
+  return resolve2(connectorHome(), "node", `v${CONNECTOR_MANAGED_NODE_VERSION}`);
+}
+function managedNodeBinDir() {
+  return process.platform === "win32" ? managedNodeRoot() : resolve2(managedNodeRoot(), "bin");
+}
+function nodeGlobalRoot() {
+  return resolve2(connectorHome(), "node-global");
+}
+function nodeGlobalBinDir() {
+  return process.platform === "win32" ? nodeGlobalRoot() : resolve2(nodeGlobalRoot(), "bin");
+}
+function splitPath(value) {
+  return (value ?? "").split(process.platform === "win32" ? ";" : ":").filter(Boolean);
+}
+function dedupePaths(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const raw of paths) {
+    const item = raw.trim();
+    if (!item || seen.has(item)) continue;
+    seen.add(item);
+    result.push(item);
+  }
+  return result;
+}
+function readLoginShellPath() {
+  if (process.env.SHADOW_CONNECTOR_SKIP_LOGIN_SHELL === "1") return [];
+  if (loginShellPath !== void 0) return splitPath(loginShellPath ?? "");
+  const shells = dedupePaths(
+    [process.env.SHELL, "/bin/zsh", "/bin/bash"].filter(
+      (item) => Boolean(item?.trim())
+    )
+  );
+  for (const shell of shells) {
+    const result = spawnSync2(shell, ["-lc", 'printf %s "$PATH"'], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1800
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+      loginShellPath = result.stdout.trim();
+      return splitPath(loginShellPath);
+    }
+  }
+  loginShellPath = null;
+  return [];
+}
+function nvmBinDirs() {
+  if (cachedNvmBinDirs) return cachedNvmBinDirs;
+  const roots = dedupePaths(
+    [process.env.NVM_DIR, resolve2(homedir2(), ".nvm")].filter((item) => Boolean(item?.trim())).map(expandHome2)
+  );
+  const bins = [];
+  if (process.env.NVM_BIN?.trim()) bins.push(process.env.NVM_BIN.trim());
+  for (const root of roots) {
+    const versionsDir = resolve2(root, "versions/node");
+    if (!existsSync2(versionsDir)) continue;
+    try {
+      const versions = readdirSync2(versionsDir).filter((entry) => /^v?\d+\.\d+\.\d+/.test(entry)).sort((a, b) => b.localeCompare(a, void 0, { numeric: true }));
+      for (const version of versions) bins.push(resolve2(versionsDir, version, "bin"));
+    } catch {
+    }
+  }
+  cachedNvmBinDirs = bins;
+  return bins;
+}
+function commonBinDirs() {
+  return [
+    resolve2(homedir2(), ".local/bin"),
+    nodeGlobalBinDir(),
+    managedNodeBinDir(),
+    resolve2(homedir2(), ".npm-global/bin"),
+    resolve2(homedir2(), ".npm/bin"),
+    resolve2(homedir2(), ".volta/bin"),
+    resolve2(homedir2(), ".bun/bin"),
+    resolve2(homedir2(), ".deno/bin"),
+    resolve2(homedir2(), ".cargo/bin"),
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin",
+    "/usr/local/bin",
+    "/usr/local/sbin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin"
+  ];
+}
+function connectorPath(env = process.env) {
+  if (env === process.env && cachedConnectorPath) return cachedConnectorPath;
+  const value = dedupePaths([
+    ...commonBinDirs(),
+    ...nvmBinDirs(),
+    ...readLoginShellPath(),
+    ...splitPath(env.PATH ?? env.Path)
+  ]).join(process.platform === "win32" ? ";" : ":");
+  if (env === process.env) cachedConnectorPath = value;
+  return value;
+}
+function connectorProcessEnv(env = process.env) {
+  const next = {
+    ...env,
+    SHADOW_CONNECTOR_HOME: connectorHome(),
+    NPM_CONFIG_PREFIX: nodeGlobalRoot(),
+    npm_config_prefix: nodeGlobalRoot()
+  };
+  next[PATH_KEY] = connectorPath(env);
+  next.PATH = next[PATH_KEY];
+  return next;
+}
+function findCommandOnConnectorPath(command, env = process.env) {
+  if (command.includes("/") || process.platform === "win32" && command.includes("\\")) {
+    return existsSync2(command) ? command : null;
+  }
+  const extensions = process.platform === "win32" ? splitPath(env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").map((item) => item.toLowerCase()) : [""];
+  for (const dir of splitPath(connectorPath(env))) {
+    for (const ext of extensions) {
+      const candidate = resolve2(dir, process.platform === "win32" ? `${command}${ext}` : command);
+      if (existsSync2(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function commandExistsOnConnectorPath(command, _args = ["--version"]) {
+  return Boolean(findCommandOnConnectorPath(command));
+}
+function nodeAssetInfo() {
+  const nodePlatform = NODE_PLATFORM[process.platform];
+  const nodeArch = NODE_ARCH[process.arch];
+  if (!nodePlatform || !nodeArch) {
+    throw new Error(`Unsupported managed Node platform: ${platform()}/${process.arch}`);
+  }
+  const ext = nodePlatform === "win" ? ".zip" : ".tar.xz";
+  const filename = `node-v${CONNECTOR_MANAGED_NODE_VERSION}-${nodePlatform}-${nodeArch}${ext}`;
+  const baseUrl = `https://nodejs.org/dist/v${CONNECTOR_MANAGED_NODE_VERSION}`;
+  return {
+    filename,
+    url: `${baseUrl}/${filename}`,
+    shasumsUrl: `${baseUrl}/SHASUMS256.txt`,
+    ext
+  };
+}
+function fetchBuffer2(url, redirects = 5) {
+  return new Promise((resolvePromise, reject) => {
+    if (redirects <= 0) {
+      reject(new Error(`Too many redirects for ${url}`));
+      return;
+    }
+    const request = httpsGet2(url, { headers: { "User-Agent": "shadowob-connector" } }, (res) => {
+      const location = res.headers.location;
+      if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && location) {
+        res.resume();
+        resolvePromise(fetchBuffer2(new URL(location, url).toString(), redirects - 1));
+        return;
+      }
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(`HTTP ${res.statusCode ?? "unknown"} for ${url}`));
+        return;
+      }
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolvePromise(Buffer.concat(chunks)));
+      res.on("error", reject);
+    });
+    request.on("error", reject);
+  });
+}
+function verifyNodeArchive(filename, archive, shasums) {
+  const line = shasums.split(/\r?\n/).find(
+    (entry) => entry.trim().endsWith(`  ${filename}`) || entry.trim().endsWith(` ${filename}`)
+  );
+  const expected = line?.trim().split(/\s+/)[0];
+  if (!expected) throw new Error(`No Node.js SHA-256 found for ${filename}`);
+  const actual = createHash2("sha256").update(archive).digest("hex");
+  if (actual !== expected) {
+    throw new Error(`Node.js SHA-256 mismatch for ${filename}: expected ${expected}, got ${actual}`);
+  }
+}
+function runExtract(command, args) {
+  const result = spawnSync2(command, args, { stdio: "ignore" });
+  if (result.status !== 0) {
+    throw new Error(`Failed to extract managed Node.js archive with ${command}`);
+  }
+}
+function extractNodeArchive(archivePath, outputDir, ext) {
+  if (ext === ".tar.xz") {
+    runExtract("tar", ["-xJf", archivePath, "-C", outputDir]);
+    return;
+  }
+  const result = spawnSync2(
+    "powershell",
+    ["-NoProfile", "-Command", `Expand-Archive -Force '${archivePath}' '${outputDir}'`],
+    {
+      stdio: "ignore"
+    }
+  );
+  if (result.status !== 0) runExtract("unzip", ["-q", archivePath, "-d", outputDir]);
+}
+async function ensureManagedNodeRuntime(options) {
+  const root = managedNodeRoot();
+  const binDir = managedNodeBinDir();
+  const nodeBinary = resolve2(binDir, process.platform === "win32" ? "node.exe" : "node");
+  const npmBinary = resolve2(binDir, process.platform === "win32" ? "npm.cmd" : "npm");
+  if (existsSync2(nodeBinary) && existsSync2(npmBinary)) return { binDir, root };
+  if (options.dryRun) {
+    options.log?.(`[dry-run] install Node.js v${CONNECTOR_MANAGED_NODE_VERSION} -> ${root}`);
+    return { binDir, root };
+  }
+  const asset = nodeAssetInfo();
+  const parent = dirname2(root);
+  const tmpDir = resolve2(parent, `_node-${process.pid}-${Date.now()}`);
+  const archivePath = resolve2(parent, asset.filename);
+  options.log?.(`[toolchain] Installing managed Node.js v${CONNECTOR_MANAGED_NODE_VERSION}`);
+  mkdirSync2(parent, { recursive: true });
+  const [archive, shasums] = await Promise.all([
+    fetchBuffer2(asset.url),
+    fetchBuffer2(asset.shasumsUrl).then((buffer) => buffer.toString("utf8"))
+  ]);
+  verifyNodeArchive(asset.filename, archive, shasums);
+  rmSync2(tmpDir, { recursive: true, force: true });
+  mkdirSync2(tmpDir, { recursive: true });
+  writeFileSync2(archivePath, archive);
+  try {
+    extractNodeArchive(archivePath, tmpDir, asset.ext);
+    const extracted = readdirSync2(tmpDir, { withFileTypes: true }).find(
+      (entry) => entry.isDirectory()
+    );
+    if (!extracted) throw new Error("Managed Node.js archive did not contain a directory");
+    rmSync2(root, { recursive: true, force: true });
+    renameSync2(resolve2(tmpDir, extracted.name), root);
+    if (process.platform !== "win32") {
+      chmodSync2(nodeBinary, 493);
+      chmodSync2(npmBinary, 493);
+    }
+  } finally {
+    rmSync2(archivePath, { force: true });
+    rmSync2(tmpDir, { recursive: true, force: true });
+  }
+  return { binDir, root };
+}
+function shellCommandNeedsNpm(command) {
+  return /(^|[;&|()\s])(?:npm|npx)(?:\.cmd)?(?:\s|$)/.test(command);
+}
+
 // src/cli.ts
 var TARGETS = /* @__PURE__ */ new Set(["openclaw", "hermes", "cc-connect"]);
 var COMMANDS = /* @__PURE__ */ new Set([
@@ -9486,6 +9901,10 @@ function usage() {
     "  --work-dir-map-file <path> Daemon-local JSON map for Buddy/runtime work directories",
     "  --project-name <name>   cc-connect project name",
     "  --agent-type <type>     cc-connect agent type, default codex",
+    "  --model-provider-base-url <url> OpenAI-compatible model provider base URL",
+    "  --model-provider-api-key <key> OpenAI-compatible model provider API key",
+    "  --model-provider-model <model> OpenAI-compatible model id",
+    "  --model-provider-id <id> Model provider id, default shadow-official",
     "  --json                  Print the full plan as JSON",
     "  --force                 Overwrite target config files when needed",
     "  --install               Install connector runtime dependencies",
@@ -9530,6 +9949,11 @@ function parseArgs(args) {
     workDirMapFile: readOption(optionArgs, "--work-dir-map-file"),
     projectName: readOption(optionArgs, "--project-name"),
     agentType: readOption(optionArgs, "--agent-type"),
+    modelProviderId: readOption(optionArgs, "--model-provider-id"),
+    modelProviderLabel: readOption(optionArgs, "--model-provider-label"),
+    modelProviderBaseUrl: readOption(optionArgs, "--model-provider-base-url"),
+    modelProviderApiKey: readOption(optionArgs, "--model-provider-api-key"),
+    modelProviderModel: readOption(optionArgs, "--model-provider-model"),
     json: hasFlag(optionArgs, "--json"),
     force: hasFlag(optionArgs, "--force"),
     install,
@@ -9541,7 +9965,11 @@ function parseArgs(args) {
 }
 function printPlan(options) {
   const target = requireTarget(options);
-  const plan = createConnectorPlan({ ...options, target });
+  const plan = createConnectorPlan({
+    ...options,
+    target,
+    modelProvider: modelProviderFromOptions(options)
+  });
   if (options.json) {
     console.log(JSON.stringify(plan, null, 2));
     return;
@@ -9557,19 +9985,19 @@ function printPlan(options) {
     console.log(block.content);
   }
 }
-function runShell(command, dryRun) {
+function runShell(command, dryRun, env = connectorProcessEnv()) {
   if (dryRun) {
     console.log(`[dry-run] ${command}`);
     return;
   }
-  const result = spawnSync2(command, { shell: true, stdio: "inherit" });
+  const result = spawnSync3(command, { shell: true, stdio: "inherit", env });
   if (result.status !== 0) {
     throw new Error(`Command failed with exit code ${result.status ?? "unknown"}: ${command}`);
   }
 }
-function runShellQuiet(command, dryRun) {
+function runShellQuiet(command, dryRun, env = connectorProcessEnv()) {
   if (dryRun) return;
-  const result = spawnSync2(command, { shell: true, encoding: "utf8" });
+  const result = spawnSync3(command, { shell: true, encoding: "utf8", env });
   if (result.status !== 0) {
     const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
     throw new Error(
@@ -9577,13 +10005,19 @@ function runShellQuiet(command, dryRun) {
     );
   }
 }
+async function envForShellCommand(command, dryRun) {
+  if (shellCommandNeedsNpm(command) && !commandExists("npm")) {
+    await ensureManagedNodeRuntime({ dryRun, log: (message) => console.log(message) });
+  }
+  return connectorProcessEnv();
+}
 function runBinary(binaryPath, args, dryRun) {
   const rendered = [binaryPath, ...args].map((arg) => /^[A-Za-z0-9_./:@=-]+$/.test(arg) ? arg : JSON.stringify(arg)).join(" ");
   if (dryRun) {
     console.log(`[dry-run] ${rendered}`);
     return;
   }
-  const result = spawnSync2(binaryPath, args, { stdio: "inherit" });
+  const result = spawnSync3(binaryPath, args, { stdio: "inherit", env: connectorProcessEnv() });
   if (result.status !== 0) {
     throw new Error(`Command failed with exit code ${result.status ?? "unknown"}: ${rendered}`);
   }
@@ -9593,21 +10027,21 @@ function writeFile(path, content, dryRun) {
     console.log(`[dry-run] write ${path}`);
     return;
   }
-  mkdirSync2(dirname2(path), { recursive: true });
-  writeFileSync2(path, content.endsWith("\n") ? content : `${content}
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, content.endsWith("\n") ? content : `${content}
 `);
 }
 function packageRoot() {
-  return resolve2(dirname2(fileURLToPath(import.meta.url)), "..");
+  return resolve3(dirname3(fileURLToPath(import.meta.url)), "..");
 }
-function expandHome2(value) {
-  return value.startsWith("~/") ? resolve2(homedir2(), value.slice(2)) : resolve2(value);
+function expandHome3(value) {
+  return value.startsWith("~/") ? resolve3(homedir3(), value.slice(2)) : resolve3(value);
 }
 function readExisting(path) {
-  return existsSync2(path) ? readFileSync(path, "utf8") : "";
+  return existsSync3(path) ? readFileSync(path, "utf8") : "";
 }
 function resolveOpenClawConfigPath(options) {
-  return expandHome2(
+  return expandHome3(
     options.openclawConfig ?? process.env.OPENCLAW_CONFIG ?? process.env.OPENCLAW_CONFIG_PATH ?? DEFAULT_OPENCLAW_CONFIG
   );
 }
@@ -9623,6 +10057,19 @@ function shellQuote2(value) {
 function tokenForCommand(options) {
   return options.token.trim() || "<BUDDY_TOKEN>";
 }
+function modelProviderFromOptions(options) {
+  const baseUrl = options.modelProviderBaseUrl?.trim();
+  const apiKey = options.modelProviderApiKey?.trim();
+  const model = options.modelProviderModel?.trim();
+  if (!baseUrl || !apiKey || !model) return void 0;
+  return {
+    id: options.modelProviderId?.trim() || "shadow-official",
+    label: options.modelProviderLabel?.trim() || "Shadow official LLM proxy",
+    baseUrl,
+    apiKey,
+    model
+  };
+}
 function connectorCommand(command, target, options, extras = []) {
   const parts = ["shadowob-connector", command, "--target", target];
   if (command !== "doctor" && command !== "status") {
@@ -9637,20 +10084,26 @@ function connectorCommand(command, target, options, extras = []) {
   return parts.map(shellQuote2).join(" ");
 }
 function commandExists(command) {
-  const result = spawnSync2(command, ["--version"], { stdio: "ignore" });
-  return result.status === 0;
+  return commandExistsOnConnectorPath(command);
 }
 function writeExecutable(path, content, dryRun) {
   writeFile(path, content, dryRun);
   if (dryRun) return;
-  chmodSync2(path, 493);
+  chmodSync3(path, 493);
 }
 function ensureNpxShim(options) {
-  if (commandExists(options.command)) return;
-  const localBin = resolve2(homedir2(), ".local/bin");
-  const target = resolve2(localBin, options.command);
+  const localBin = resolve3(homedir3(), ".local/bin");
+  const target = resolve3(localBin, options.command);
+  if (commandExists(options.command) && existsSync3(target)) return;
+  const pathPrefix = [localBin, nodeGlobalBinDir(), managedNodeBinDir()].map(shellQuote2).join(":");
   const content = [
     "#!/usr/bin/env sh",
+    `PATH=${pathPrefix}:$PATH`,
+    "export PATH",
+    `if command -v ${options.binaryName} >/dev/null 2>&1; then`,
+    `  resolved="$(command -v ${options.binaryName})"`,
+    '  if [ "$resolved" != "$0" ]; then exec "$resolved" "$@"; fi',
+    "fi",
     `exec npx -y ${options.packageSpec} ${options.binaryName === options.command ? "" : options.binaryName} "$@"`,
     ""
   ].join("\n").replace('  "$@"', ' "$@"');
@@ -9661,11 +10114,26 @@ function ensureNpxShim(options) {
     console.log(`Note: add ${localBin} to PATH so agents can run ${options.command}`);
   }
 }
+async function installShadowNpmPackages(options) {
+  if (commandExists("shadowob") && commandExists("shadowob-connector")) return;
+  if (!commandExists("npm")) {
+    await ensureManagedNodeRuntime({
+      dryRun: options.dryRun,
+      log: (message) => console.log(message)
+    });
+  }
+  console.log("Applying: Install Shadow CLI packages");
+  runShellQuiet(
+    `npm install -g ${SHADOW_CLI_PACKAGE} ${SHADOW_CONNECTOR_PACKAGE}`,
+    options.dryRun,
+    connectorProcessEnv()
+  );
+}
 function shadowCliProfileName(options) {
   return options.projectName?.trim() || "shadow-buddy";
 }
 function writeShadowCliProfile(options) {
-  const configPath = resolve2(homedir2(), ".shadowob/shadowob.config.json");
+  const configPath = resolve3(homedir3(), ".shadowob/shadowob.config.json");
   const current = (() => {
     try {
       return JSON.parse(readExisting(configPath));
@@ -9690,37 +10158,38 @@ function writeShadowCliProfile(options) {
 }
 function shadowobSkillMarkdown() {
   const candidates = [
-    resolve2(packageRoot(), "skills/shadowob/SKILL.md"),
-    resolve2(process.cwd(), "skills/shadowob-cli/SKILL.md"),
-    resolve2(process.cwd(), "packages/openclaw-shadowob/skills/shadowob/SKILL.md")
+    resolve3(packageRoot(), "skills/shadowob/SKILL.md"),
+    resolve3(process.cwd(), "skills/shadowob-cli/SKILL.md"),
+    resolve3(process.cwd(), "packages/openclaw-shadowob/skills/shadowob/SKILL.md")
   ];
   let currentDir = packageRoot();
   while (true) {
-    candidates.push(resolve2(currentDir, "skills/shadowob-cli/SKILL.md"));
-    const parentDir = dirname2(currentDir);
+    candidates.push(resolve3(currentDir, "skills/shadowob-cli/SKILL.md"));
+    const parentDir = dirname3(currentDir);
     if (parentDir === currentDir) break;
     currentDir = parentDir;
   }
-  const found = candidates.find((candidate) => existsSync2(candidate));
+  const found = candidates.find((candidate) => existsSync3(candidate));
   if (!found) throw new Error("Cannot find bundled Shadow CLI skill");
   return readFileSync(found, "utf8");
 }
 function shadowobSkillTargets(options) {
-  const hermesDir = expandHome2(options.hermesHome ?? process.env.HERMES_HOME ?? "~/.hermes");
+  const hermesDir = expandHome3(options.hermesHome ?? process.env.HERMES_HOME ?? "~/.hermes");
   return Array.from(
     /* @__PURE__ */ new Set([
-      resolve2(homedir2(), ".shadowob/skills/shadowob/SKILL.md"),
-      resolve2(homedir2(), ".agents/skills/shadowob/SKILL.md"),
-      resolve2(homedir2(), ".codex/skills/shadowob/SKILL.md"),
-      resolve2(homedir2(), ".claude/skills/shadowob/SKILL.md"),
-      resolve2(homedir2(), ".gemini/skills/shadowob/SKILL.md"),
-      resolve2(homedir2(), ".opencode/skills/shadowob/SKILL.md"),
-      resolve2(homedir2(), ".openclaw/skills/shadowob/SKILL.md"),
-      resolve2(hermesDir, "skills/shadowob/SKILL.md")
+      resolve3(homedir3(), ".shadowob/skills/shadowob/SKILL.md"),
+      resolve3(homedir3(), ".agents/skills/shadowob/SKILL.md"),
+      resolve3(homedir3(), ".codex/skills/shadowob/SKILL.md"),
+      resolve3(homedir3(), ".claude/skills/shadowob/SKILL.md"),
+      resolve3(homedir3(), ".gemini/skills/shadowob/SKILL.md"),
+      resolve3(homedir3(), ".opencode/skills/shadowob/SKILL.md"),
+      resolve3(homedir3(), ".openclaw/skills/shadowob/SKILL.md"),
+      resolve3(hermesDir, "skills/shadowob/SKILL.md")
     ])
   );
 }
-function installShadowCliAndSkills(options) {
+async function installShadowCliAndSkills(options) {
+  await installShadowNpmPackages(options);
   ensureNpxShim({
     command: "shadowob",
     packageSpec: SHADOW_CLI_PACKAGE,
@@ -9779,8 +10248,8 @@ function diagnoseCommon(options) {
       "Run fix/update to install the ~/.local/bin/shadowob-connector shim."
     )
   ];
-  const profilePath = resolve2(homedir2(), ".shadowob/shadowob.config.json");
-  if (!existsSync2(profilePath)) {
+  const profilePath = resolve3(homedir3(), ".shadowob/shadowob.config.json");
+  if (!existsSync3(profilePath)) {
     checks.push(
       check(
         "common",
@@ -9805,7 +10274,7 @@ function diagnoseCommon(options) {
     );
   }
   const skillTargets = shadowobSkillTargets(options);
-  const installed = skillTargets.filter((target) => existsSync2(target)).length;
+  const installed = skillTargets.filter((target) => existsSync3(target)).length;
   checks.push(
     check(
       "common",
@@ -9828,7 +10297,7 @@ function diagnoseOpenClaw(options) {
       "Install OpenClaw before starting the gateway."
     )
   ];
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     checks.push(
       check(
         "openclaw",
@@ -9884,10 +10353,10 @@ function diagnoseOpenClaw(options) {
   return checks;
 }
 function diagnoseHermes(options) {
-  const hermesDir = expandHome2(options.hermesHome ?? process.env.HERMES_HOME ?? "~/.hermes");
-  const pluginTarget = resolve2(hermesDir, "plugins/shadowob");
-  const envPath = resolve2(hermesDir, ".env");
-  const configPath = resolve2(hermesDir, "config.yaml");
+  const hermesDir = expandHome3(options.hermesHome ?? process.env.HERMES_HOME ?? "~/.hermes");
+  const pluginTarget = resolve3(hermesDir, "plugins/shadowob");
+  const envPath = resolve3(hermesDir, ".env");
+  const configPath = resolve3(hermesDir, "config.yaml");
   const checks = [
     check(
       "hermes",
@@ -9898,9 +10367,9 @@ function diagnoseHermes(options) {
     ),
     check(
       "hermes",
-      existsSync2(pluginTarget) ? "ok" : "fail",
+      existsSync3(pluginTarget) ? "ok" : "fail",
       "Hermes Shadow plugin",
-      existsSync2(pluginTarget) ? `${pluginTarget} exists` : `${pluginTarget} is missing`,
+      existsSync3(pluginTarget) ? `${pluginTarget} exists` : `${pluginTarget} is missing`,
       "Run fix/update."
     )
   ];
@@ -9910,11 +10379,11 @@ function diagnoseHermes(options) {
       "hermes",
       env.includes("SHADOW_TOKEN=") && env.includes("SHADOW_BASE_URL=") ? "ok" : "fail",
       "Hermes environment",
-      existsSync2(envPath) ? "SHADOW_TOKEN and SHADOW_BASE_URL are present" : `${envPath} does not exist`,
+      existsSync3(envPath) ? "SHADOW_TOKEN and SHADOW_BASE_URL are present" : `${envPath} does not exist`,
       "Run fix/update with --token and --server-url."
     )
   );
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     checks.push(
       check("hermes", "fail", "Hermes config", `${configPath} does not exist`, "Run fix/update.")
     );
@@ -9947,7 +10416,7 @@ function diagnoseHermes(options) {
   return checks;
 }
 function diagnoseCcConnect(options) {
-  const configPath = resolve2(homedir2(), ".cc-connect/config.toml");
+  const configPath = resolve3(homedir3(), ".cc-connect/config.toml");
   const binary = getCcConnectBinaryStatus();
   const checks = [
     check(
@@ -9958,7 +10427,7 @@ function diagnoseCcConnect(options) {
       "Run fix/update with --install."
     )
   ];
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     checks.push(
       check(
         "cc-connect",
@@ -10039,7 +10508,7 @@ function printDiagnostics(options, mode) {
   return !checks.some((item) => item.status === "fail");
 }
 function firstExistingPath(paths) {
-  return paths.find((path) => existsSync2(path));
+  return paths.find((path) => existsSync3(path));
 }
 function openClawConfigCandidates(options) {
   return Array.from(
@@ -10050,12 +10519,12 @@ function openClawConfigCandidates(options) {
         process.env.OPENCLAW_CONFIG_PATH,
         DEFAULT_OPENCLAW_CONFIG,
         LEGACY_OPENCLAW_CONFIG
-      ].filter((value) => !!value?.trim()).map(expandHome2)
+      ].filter((value) => !!value?.trim()).map(expandHome3)
     )
   );
 }
 function ccConnectScanExtras(options) {
-  const configPath = resolve2(homedir2(), ".cc-connect/config.toml");
+  const configPath = resolve3(homedir3(), ".cc-connect/config.toml");
   const fallback = [
     "--work-dir",
     options.workDir?.trim() || ".",
@@ -10064,14 +10533,14 @@ function ccConnectScanExtras(options) {
     "--agent-type",
     options.agentType?.trim() || "codex"
   ];
-  if (!existsSync2(configPath)) return fallback;
+  if (!existsSync3(configPath)) return fallback;
   try {
     const root = parse(readExisting(configPath));
     const projects = Array.isArray(root.projects) ? root.projects : [];
     const configuredProject = projects.find((project2) => {
       const platformsValue = asObject(project2).platforms;
       const platforms = Array.isArray(platformsValue) ? platformsValue : [];
-      return platforms.some((platform2) => asObject(platform2).type === "shadowob");
+      return platforms.some((platform3) => asObject(platform3).type === "shadowob");
     }) ?? projects[0];
     const project = asObject(configuredProject);
     const agent = asObject(project.agent);
@@ -10106,19 +10575,19 @@ function scanOpenClaw(options) {
   };
 }
 function scanHermes(options) {
-  const hermesDir = expandHome2(options.hermesHome ?? process.env.HERMES_HOME ?? "~/.hermes");
-  const configPath = resolve2(hermesDir, "config.yaml");
+  const hermesDir = expandHome3(options.hermesHome ?? process.env.HERMES_HOME ?? "~/.hermes");
+  const configPath = resolve3(hermesDir, "config.yaml");
   const evidence = [];
   if (commandExists("hermes")) evidence.push("hermes command is on PATH");
-  if (existsSync2(configPath)) evidence.push(`config found at ${configPath}`);
-  if (existsSync2(resolve2(hermesDir, "plugins/shadowob"))) {
-    evidence.push(`shadowob plugin found under ${resolve2(hermesDir, "plugins/shadowob")}`);
+  if (existsSync3(configPath)) evidence.push(`config found at ${configPath}`);
+  if (existsSync3(resolve3(hermesDir, "plugins/shadowob"))) {
+    evidence.push(`shadowob plugin found under ${resolve3(hermesDir, "plugins/shadowob")}`);
   }
   return {
     target: "hermes",
     detected: evidence.length > 0,
     evidence,
-    configPath: existsSync2(configPath) ? configPath : void 0,
+    configPath: existsSync3(configPath) ? configPath : void 0,
     connectCommand: connectorCommand("connect", "hermes", options),
     updateCommand: connectorCommand("update", "hermes", options),
     doctorCommand: connectorCommand("doctor", "hermes", options),
@@ -10126,18 +10595,18 @@ function scanHermes(options) {
   };
 }
 function scanCcConnect(options) {
-  const configPath = resolve2(homedir2(), ".cc-connect/config.toml");
+  const configPath = resolve3(homedir3(), ".cc-connect/config.toml");
   const binary = getCcConnectBinaryStatus();
   const evidence = [];
   if (commandExists("cc-connect")) evidence.push("cc-connect command is on PATH");
   if (binary.usable) evidence.push(`Shadow fork binary found at ${binary.binaryPath}`);
-  if (existsSync2(configPath)) evidence.push(`config found at ${configPath}`);
+  if (existsSync3(configPath)) evidence.push(`config found at ${configPath}`);
   const extras = ccConnectScanExtras(options);
   return {
     target: "cc-connect",
     detected: evidence.length > 0,
     evidence,
-    configPath: existsSync2(configPath) ? configPath : void 0,
+    configPath: existsSync3(configPath) ? configPath : void 0,
     connectCommand: connectorCommand("connect", "cc-connect", options, extras),
     updateCommand: connectorCommand("update", "cc-connect", options, extras),
     doctorCommand: connectorCommand("doctor", "cc-connect", options),
@@ -10190,7 +10659,7 @@ function readDaemonWorkDirMap(options) {
     return { buddies: {}, runtimes: {}, defaultWorkDir: "" };
   }
   try {
-    const filePath = expandHome2(options.workDirMapFile);
+    const filePath = expandHome3(options.workDirMapFile);
     const root = JSON.parse(readFileSync(filePath, "utf8"));
     return {
       buddies: stringRecord(root.buddies),
@@ -10218,14 +10687,14 @@ function resolveDaemonWorkDir(job, options) {
 }
 function packageVersion() {
   try {
-    const json = JSON.parse(readFileSync(resolve2(packageRoot(), "package.json"), "utf8"));
+    const json = JSON.parse(readFileSync(resolve3(packageRoot(), "package.json"), "utf8"));
     return json.version ?? "dev";
   } catch {
     return "dev";
   }
 }
 function commandVersionWithArgs(command, args = ["--version"]) {
-  const result = spawnSync2(command, args, { encoding: "utf8" });
+  const result = spawnSync3(command, args, { encoding: "utf8", env: connectorProcessEnv() });
   if (result.status !== 0) return { ok: false };
   const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();
   return { ok: true, version: output.split(/\r?\n/)[0]?.slice(0, 120) || null };
@@ -10310,7 +10779,7 @@ function printRuntimeScan(options) {
     }
   }
 }
-function installRuntime(options) {
+async function installRuntime(options) {
   const runtime = connectorRuntimeById(options.runtimeId);
   if (!runtime) {
     throw new Error(
@@ -10323,10 +10792,12 @@ function installRuntime(options) {
       `No install command is available for ${runtime.label}. See ${runtime.install.helpUrl}`
     );
   }
+  const command = commands[0];
+  const env = await envForShellCommand(command, options.dryRun);
   if (options.json) {
-    runShellQuiet(commands[0], options.dryRun);
+    runShellQuiet(command, options.dryRun, env);
   } else {
-    runShell(commands[0], options.dryRun);
+    runShell(command, options.dryRun, env);
   }
   const detected = detectCatalogRuntime(runtime);
   if (options.json) {
@@ -10379,7 +10850,7 @@ async function heartbeat(options) {
     method: "POST",
     body: JSON.stringify({
       hostname: hostname(),
-      os: platform(),
+      os: platform2(),
       arch: arch(),
       daemonVersion: packageVersion(),
       runtimes
@@ -10407,6 +10878,7 @@ function startDetached(binaryPath, args, dryRun) {
   }
   const child = spawn(binaryPath, args, {
     detached: true,
+    env: connectorProcessEnv(),
     stdio: "ignore"
   });
   child.unref();
@@ -10420,7 +10892,7 @@ async function applyDaemonJob(job, baseOptions) {
   const projectName = payload.projectName?.trim() || payload.buddy?.username || "shadow-buddy";
   const workDir = resolveDaemonWorkDir(job, baseOptions);
   if (runtimeId === "openclaw") {
-    applyOpenClaw(
+    await applyOpenClaw(
       {
         ...baseOptions,
         target: "openclaw",
@@ -10428,6 +10900,11 @@ async function applyDaemonJob(job, baseOptions) {
         token: payload.token,
         projectName,
         workDir,
+        modelProviderId: payload.modelProvider?.id,
+        modelProviderLabel: payload.modelProvider?.label,
+        modelProviderBaseUrl: payload.modelProvider?.baseUrl,
+        modelProviderApiKey: payload.modelProvider?.apiKey,
+        modelProviderModel: payload.modelProvider?.model,
         install: true
       },
       { restart: true }
@@ -10435,13 +10912,18 @@ async function applyDaemonJob(job, baseOptions) {
     return { runtimeId, target: "openclaw" };
   }
   if (runtimeId === "hermes") {
-    applyHermes({
+    await applyHermes({
       ...baseOptions,
       target: "hermes",
       serverUrl: payload.serverUrl,
       token: payload.token,
       projectName,
       workDir,
+      modelProviderId: payload.modelProvider?.id,
+      modelProviderLabel: payload.modelProvider?.label,
+      modelProviderBaseUrl: payload.modelProvider?.baseUrl,
+      modelProviderApiKey: payload.modelProvider?.apiKey,
+      modelProviderModel: payload.modelProvider?.model,
       install: true,
       start: false
     });
@@ -10456,6 +10938,11 @@ async function applyDaemonJob(job, baseOptions) {
     projectName,
     workDir,
     agentType: ccAgentTypeForRuntime(runtimeId),
+    modelProviderId: payload.modelProvider?.id,
+    modelProviderLabel: payload.modelProvider?.label,
+    modelProviderBaseUrl: payload.modelProvider?.baseUrl,
+    modelProviderApiKey: payload.modelProvider?.apiKey,
+    modelProviderModel: payload.modelProvider?.model,
     install: true,
     start: false
   });
@@ -10511,22 +10998,24 @@ async function runDaemon(options) {
 }
 function hermesPluginSource() {
   const candidates = [
-    resolve2(packageRoot(), "hermes-shadowob-plugin"),
-    resolve2(process.cwd(), "packages/connector/hermes-shadowob-plugin")
+    resolve3(packageRoot(), "hermes-shadowob-plugin"),
+    resolve3(process.cwd(), "packages/connector/hermes-shadowob-plugin")
   ];
-  const found = candidates.find((candidate) => existsSync2(candidate));
+  const found = candidates.find((candidate) => existsSync3(candidate));
   if (!found) throw new Error("Cannot find bundled hermes-shadowob-plugin directory");
   return found;
 }
-function applyOpenClaw(options, behavior = { restart: true }) {
+async function applyOpenClaw(options, behavior = { restart: true }) {
   const target = requireTarget(options);
-  const plan = createConnectorPlan({ ...options, target });
+  const modelProvider = modelProviderFromOptions(options);
+  const plan = createConnectorPlan({ ...options, target, modelProvider });
   const configPath = resolveOpenClawConfigPath(options);
-  installShadowCliAndSkills(options);
+  await installShadowCliAndSkills(options);
   console.log(`Applying: Merge OpenClaw config ${configPath}`);
   const next = mergeOpenClawConfigContent(readExisting(configPath), {
     token: options.token,
-    serverUrl: normalizeServerUrl2(options.serverUrl)
+    serverUrl: normalizeServerUrl2(options.serverUrl),
+    modelProvider
   });
   writeFile(configPath, next, options.dryRun);
   if (options.install) {
@@ -10539,35 +11028,38 @@ function applyOpenClaw(options, behavior = { restart: true }) {
     runShell(restart.command, options.dryRun);
   }
 }
-function applyHermes(options) {
+async function applyHermes(options) {
   const target = requireTarget(options);
-  const plan = createConnectorPlan({ ...options, target });
-  const hermesDir = expandHome2(options.hermesHome ?? process.env.HERMES_HOME ?? "~/.hermes");
-  const pluginTarget = resolve2(hermesDir, "plugins/shadowob");
-  const envPath = resolve2(hermesDir, ".env");
-  const configPath = resolve2(hermesDir, "config.yaml");
+  const modelProvider = modelProviderFromOptions(options);
+  const plan = createConnectorPlan({ ...options, target, modelProvider });
+  const hermesDir = expandHome3(options.hermesHome ?? process.env.HERMES_HOME ?? "~/.hermes");
+  const pluginTarget = resolve3(hermesDir, "plugins/shadowob");
+  const envPath = resolve3(hermesDir, ".env");
+  const configPath = resolve3(hermesDir, "config.yaml");
   const envBlock = plan.configBlocks.find((block) => block.label === "~/.hermes/.env");
   if (!envBlock) throw new Error("Hermes plan is missing config blocks");
-  installShadowCliAndSkills(options);
+  await installShadowCliAndSkills(options);
   if (options.dryRun) {
     console.log(`[dry-run] copy ${hermesPluginSource()} -> ${pluginTarget}`);
   } else {
-    mkdirSync2(resolve2(hermesDir, "plugins"), { recursive: true });
+    mkdirSync3(resolve3(hermesDir, "plugins"), { recursive: true });
     cpSync(hermesPluginSource(), pluginTarget, { recursive: true, force: true });
   }
   const nextEnv = options.force ? envBlock.content : mergeEnvContent(readExisting(envPath), {
     token: options.token,
-    serverUrl: normalizeServerUrl2(options.serverUrl)
+    serverUrl: normalizeServerUrl2(options.serverUrl),
+    modelProvider
   });
   writeFile(envPath, nextEnv, options.dryRun);
   const nextConfig = mergeHermesConfigContent(options.force ? "" : readExisting(configPath), {
     token: options.token,
-    serverUrl: normalizeServerUrl2(options.serverUrl)
+    serverUrl: normalizeServerUrl2(options.serverUrl),
+    modelProvider
   });
   writeFile(configPath, nextConfig, options.dryRun);
   if (options.install) {
     runShell(
-      `python -m pip install -r "${resolve2(pluginTarget, "requirements.txt")}"`,
+      `python -m pip install -r "${resolve3(pluginTarget, "requirements.txt")}"`,
       options.dryRun
     );
     runShell("hermes plugins enable shadowob", options.dryRun);
@@ -10578,17 +11070,19 @@ function applyHermes(options) {
 }
 async function applyCcConnect(options) {
   const target = requireTarget(options);
-  const plan = createConnectorPlan({ ...options, target });
+  const modelProvider = modelProviderFromOptions(options);
+  const plan = createConnectorPlan({ ...options, target, modelProvider });
   const configBlock = plan.configBlocks.find((block) => block.label === "~/.cc-connect/config.toml");
   if (!configBlock) throw new Error("cc-connect plan is missing config block");
-  installShadowCliAndSkills(options);
-  const configPath = resolve2(homedir2(), ".cc-connect/config.toml");
+  await installShadowCliAndSkills(options);
+  const configPath = resolve3(homedir3(), ".cc-connect/config.toml");
   const nextConfig = options.force ? configBlock.content : mergeCcConnectConfigContent(readExisting(configPath), {
     token: options.token,
     serverUrl: normalizeServerUrl2(options.serverUrl),
     projectName: options.projectName?.trim() || "shadow-buddy",
     workDir: options.workDir?.trim() || ".",
-    agentType: options.agentType?.trim() || "codex"
+    agentType: options.agentType?.trim() || "codex",
+    modelProvider
   });
   writeFile(configPath, nextConfig, options.dryRun);
   let binaryPath;
@@ -10607,11 +11101,11 @@ async function applyCcConnect(options) {
 async function connect(options) {
   const target = requireTarget(options);
   if (target === "openclaw") {
-    applyOpenClaw(options);
+    await applyOpenClaw(options);
     return;
   }
   if (target === "hermes") {
-    applyHermes(options);
+    await applyHermes(options);
     return;
   }
   await applyCcConnect(options);
@@ -10620,11 +11114,11 @@ async function repair(options, mode) {
   const target = requireTarget(options);
   console.log(`Applying: ${mode} ${target} connector`);
   if (target === "openclaw") {
-    applyOpenClaw(options, { restart: options.start });
+    await applyOpenClaw(options, { restart: options.start });
     return;
   }
   if (target === "hermes") {
-    applyHermes({ ...options, start: options.start });
+    await applyHermes({ ...options, start: options.start });
     return;
   }
   await applyCcConnect({ ...options, start: options.start });
@@ -10645,7 +11139,7 @@ async function main() {
   } else if (options.command === "runtime-scan") {
     printRuntimeScan(options);
   } else if (options.command === "runtime-install") {
-    installRuntime(options);
+    await installRuntime(options);
   } else {
     printPlan(options);
   }