@shadowob/connector 1.1.3-dev.271 → 1.1.4

package/dist/cli.js

@@ -1,11 +1,469 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { spawnSync } from "child_process";
-import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { spawnSync as spawnSync2 } from "child_process";
+import { cpSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/cc-connect-installer.ts
+import { execFileSync, spawnSync } from "child_process";
+import { createHash } from "crypto";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { get as httpGet } from "http";
+import { get as httpsGet } from "https";
 import { homedir } from "os";
 import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
+
+// src/cc-connect-fork.ts
+var CC_CONNECT_FORK_REPO = "buggyblues/cc-connect";
+var CC_CONNECT_FORK_REF = "63b5d59127b3004bc7002f2d51892b1f2a91ea83";
+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_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"
+};
+var PLATFORM_MAP = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows"
+};
+var ARCH_MAP = {
+  x64: "amd64",
+  arm64: "arm64"
+};
+function log(options, message) {
+  options.log?.(message);
+}
+function quoteArg(value) {
+  return /^[A-Za-z0-9_./:@=-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function expandHome(value) {
+  return value.startsWith("~/") ? resolve(homedir(), value.slice(2)) : resolve(value);
+}
+function installRoot() {
+  const override = process.env.SHADOW_CC_CONNECT_HOME?.trim();
+  return override ? expandHome(override) : resolve(homedir(), ".shadowob/connector/cc-connect");
+}
+function binaryName() {
+  return process.platform === "win32" ? `${NAME}.exe` : NAME;
+}
+function cachedBinaryPath() {
+  return resolve(installRoot(), CC_CONNECT_FORK_SHORT_REF, "bin", binaryName());
+}
+function runCommand(command, args, options) {
+  const rendered = [command, ...args].map(quoteArg).join(" ");
+  if (options.dryRun) {
+    console.log(`[dry-run] ${rendered}`);
+    return;
+  }
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: "inherit"
+  });
+  if (result.status !== 0) {
+    throw new Error(`Command failed with exit code ${result.status ?? "unknown"}: ${rendered}`);
+  }
+}
+function platformInfo() {
+  const platform = PLATFORM_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+  if (!platform || !arch) {
+    throw new Error(
+      `Unsupported cc-connect platform: ${process.platform}/${process.arch}. Supported: linux/darwin/windows x64/arm64`
+    );
+  }
+  return { platform, arch, ext: platform === "windows" ? ".zip" : ".tar.gz" };
+}
+function fetchBuffer(url, redirects = 5) {
+  return new Promise((resolvePromise, reject) => {
+    if (redirects <= 0) {
+      reject(new Error(`Too many redirects for ${url}`));
+      return;
+    }
+    const client = url.startsWith("https:") ? httpsGet : httpGet;
+    const request = client(url, { headers: { "User-Agent": "shadowob-connector" } }, (response) => {
+      const location = response.headers.location;
+      if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && location) {
+        response.resume();
+        const next = new URL(location, url).toString();
+        resolvePromise(fetchBuffer(next, redirects - 1));
+        return;
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`HTTP ${response.statusCode ?? "unknown"} for ${url}`));
+        return;
+      }
+      const chunks = [];
+      response.on("data", (chunk) => chunks.push(chunk));
+      response.on("end", () => resolvePromise(Buffer.concat(chunks)));
+      response.on("error", reject);
+    });
+    request.on("error", reject);
+  });
+}
+function findExtractedBinary(dir) {
+  const expected = binaryName();
+  const entries = readdirSync(dir);
+  if (entries.includes(expected)) return resolve(dir, expected);
+  return entries.filter((entry) => entry.startsWith(NAME)).map((entry) => resolve(dir, entry)).find(
+    (entry) => process.platform === "win32" ? entry.endsWith(".exe") : !entry.endsWith(".gz")
+  );
+}
+function extractReleaseArchive(archivePath, binDir, ext) {
+  if (ext === ".tar.gz") {
+    runCommand("tar", ["xzf", archivePath, "-C", binDir], { dryRun: false });
+  } else {
+    const unzip = spawnSync("unzip", ["-o", archivePath, "-d", binDir], { stdio: "inherit" });
+    if (unzip.status !== 0) {
+      runCommand("powershell", ["-Command", `Expand-Archive -Force '${archivePath}' '${binDir}'`], {
+        dryRun: false
+      });
+    }
+  }
+  const extracted = findExtractedBinary(binDir);
+  const target = resolve(binDir, binaryName());
+  if (!extracted) throw new Error("cc-connect release archive did not contain a binary");
+  if (extracted !== target) renameSync(extracted, target);
+}
+function verifyReleaseChecksum(filename, data) {
+  const expected = RELEASE_ARCHIVE_SHA256[filename];
+  if (!expected) throw new Error(`No pinned SHA-256 for ${filename}`);
+  const actual = createHash("sha256").update(data).digest("hex");
+  if (actual !== expected) {
+    throw new Error(`SHA-256 mismatch for ${filename}: expected ${expected}, got ${actual}`);
+  }
+}
+async function installFromRelease(binaryPath, options) {
+  const { platform, arch, ext } = platformInfo();
+  const version = `v${CC_CONNECT_FORK_PACKAGE_VERSION}`;
+  const filename = `${NAME}-${version}-${platform}-${arch}${ext}`;
+  const url = `https://github.com/${CC_CONNECT_FORK_REPO}/releases/download/${version}/${filename}`;
+  const binDir = dirname(binaryPath);
+  const archivePath = resolve(binDir, `_release${ext}`);
+  log(options, `[cc-connect] Trying fork release asset ${url}`);
+  try {
+    const data = await fetchBuffer(url);
+    verifyReleaseChecksum(filename, data);
+    mkdirSync(binDir, { recursive: true });
+    writeFileSync(archivePath, data);
+    extractReleaseArchive(archivePath, binDir, ext);
+    rmSync(archivePath, { force: true });
+    if (process.platform !== "win32") chmodSync(binaryPath, 493);
+    return true;
+  } catch (error) {
+    rmSync(archivePath, { force: true });
+    log(
+      options,
+      `[cc-connect] Fork release asset unavailable (${error instanceof Error ? error.message : String(error)}); building from source`
+    );
+    return false;
+  }
+}
+async function ensureSourceArchive(options) {
+  const sourceDir = resolve(installRoot(), CC_CONNECT_FORK_SHORT_REF, "source");
+  if (existsSync(resolve(sourceDir, "go.mod"))) return sourceDir;
+  if (existsSync(sourceDir)) rmSync(sourceDir, { recursive: true, force: true });
+  const parent = dirname(sourceDir);
+  const extractDir = resolve(parent, `_source-${process.pid}-${Date.now()}`);
+  const archivePath = resolve(parent, `${CC_CONNECT_FORK_SHORT_REF}.tar.gz`);
+  const sourceUrl = `https://github.com/${CC_CONNECT_FORK_REPO}/archive/${CC_CONNECT_FORK_REF}.tar.gz`;
+  log(options, `[cc-connect] Pulling fork source ${sourceUrl}`);
+  mkdirSync(parent, { recursive: true });
+  const data = await fetchBuffer(sourceUrl);
+  writeFileSync(archivePath, data);
+  mkdirSync(extractDir, { recursive: true });
+  try {
+    runCommand("tar", ["xzf", archivePath, "-C", extractDir], { dryRun: false });
+    const extracted = readdirSync(extractDir, { withFileTypes: true }).find(
+      (entry) => entry.isDirectory()
+    );
+    if (!extracted) throw new Error("cc-connect source archive did not contain a directory");
+    mkdirSync(dirname(sourceDir), { recursive: true });
+    renameSync(resolve(extractDir, extracted.name), sourceDir);
+  } finally {
+    rmSync(archivePath, { force: true });
+    rmSync(extractDir, { recursive: true, force: true });
+  }
+  return sourceDir;
+}
+async function buildFromSource(binaryPath, options) {
+  const sourceDir = await ensureSourceArchive(options);
+  const buildTime = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const ldflags = [
+    "-s",
+    "-w",
+    "-X",
+    "main.version=dev",
+    "-X",
+    `main.commit=${CC_CONNECT_FORK_SHORT_REF}`,
+    "-X",
+    `main.buildTime=${buildTime}`
+  ].join(" ");
+  mkdirSync(dirname(binaryPath), { recursive: true });
+  runCommand(
+    "go",
+    ["build", "-tags", "no_web", "-ldflags", ldflags, "-o", binaryPath, "./cmd/cc-connect"],
+    {
+      cwd: sourceDir,
+      dryRun: false,
+      env: goBuildEnv()
+    }
+  );
+  if (process.platform !== "win32") chmodSync(binaryPath, 493);
+}
+function goBuildEnv() {
+  return {
+    ...process.env,
+    CGO_ENABLED: "0",
+    GOPROXY: process.env.SHADOW_CC_CONNECT_GOPROXY?.trim() || "https://proxy.golang.org,direct",
+    GOSUMDB: process.env.SHADOW_CC_CONNECT_GOSUMDB?.trim() || process.env.GOSUMDB || "sum.golang.org"
+  };
+}
+function binaryLooksUsable(path) {
+  if (!existsSync(path)) return false;
+  try {
+    const out = execFileSync(path, ["--version"], { encoding: "utf8", timeout: 5e3 });
+    return out.includes(CC_CONNECT_FORK_SHORT_REF) || out.includes(CC_CONNECT_FORK_PACKAGE_VERSION);
+  } catch {
+    return false;
+  }
+}
+async function ensureCcConnectFork(options) {
+  const override = process.env.SHADOW_CC_CONNECT_BIN?.trim();
+  if (override) {
+    const binaryPath2 = expandHome(override);
+    if (!existsSync(binaryPath2))
+      throw new Error(`SHADOW_CC_CONNECT_BIN does not exist: ${binaryPath2}`);
+    return { binaryPath: binaryPath2, source: "env" };
+  }
+  const binaryPath = cachedBinaryPath();
+  if (binaryLooksUsable(binaryPath)) {
+    return { binaryPath, source: "cache" };
+  }
+  if (options.dryRun) {
+    console.log(
+      `[dry-run] install ${CC_CONNECT_FORK_REPO}@${CC_CONNECT_FORK_SHORT_REF} -> ${binaryPath}`
+    );
+    return { binaryPath, source: "source" };
+  }
+  mkdirSync(dirname(binaryPath), { recursive: true });
+  const fromRelease = await installFromRelease(binaryPath, options);
+  if (!fromRelease) await buildFromSource(binaryPath, options);
+  if (!binaryLooksUsable(binaryPath)) {
+    throw new Error(`Installed cc-connect binary did not pass version verification: ${binaryPath}`);
+  }
+  return { binaryPath, source: fromRelease ? "release" : "source" };
+}
+
+// src/config-writers.ts
+import { parse as parseDotenv } from "dotenv";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+var SHADOW_ENV_VALUES = {
+  SHADOW_ALLOW_ALL_USERS: "true",
+  SHADOW_HEARTBEAT_INTERVAL_SECONDS: "30",
+  SHADOW_SLASH_COMMANDS_JSON: "[]"
+};
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? { ...value } : {};
+}
+function uniqueStrings(values, required) {
+  return [
+    .../* @__PURE__ */ new Set([...values.filter((value) => typeof value === "string"), required])
+  ];
+}
+function ensureTrailingNewline(value) {
+  return value.endsWith("\n") ? value : `${value}
+`;
+}
+function quoteEnv(value) {
+  return /^[A-Za-z0-9_./:@-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function normalizeJsonRoot(existing, label) {
+  if (!existing.trim()) return {};
+  const parsed = JSON.parse(existing);
+  if (!isRecord(parsed)) {
+    throw new Error(`${label} config must be a JSON object`);
+  }
+  return { ...parsed };
+}
+function parseYamlRoot(existing, label) {
+  if (!existing.trim()) return {};
+  const parsed = parseYaml(existing);
+  if (parsed == null) return {};
+  if (!isRecord(parsed)) {
+    throw new Error(`${label} config must be a YAML object`);
+  }
+  return { ...parsed };
+}
+function parseTomlRoot(existing, label) {
+  if (!existing.trim()) return {};
+  const parsed = parseToml(existing);
+  if (!isRecord(parsed)) {
+    throw new Error(`${label} config must be a TOML table`);
+  }
+  return parsed;
+}
+function mergeEnvContent(existing, values) {
+  parseDotenv(existing);
+  const updates = {
+    SHADOW_BASE_URL: values.serverUrl,
+    SHADOW_TOKEN: values.token,
+    ...SHADOW_ENV_VALUES
+  };
+  const seen = /* @__PURE__ */ new Set();
+  const lines = existing.length > 0 ? existing.split(/\r?\n/) : [];
+  const next = [];
+  for (const line of lines) {
+    const match = line.match(/^(\s*(?:export\s+)?)((?:[A-Za-z_][A-Za-z0-9_]*))\s*=/);
+    const key = match?.[2];
+    if (!key || !(key in updates)) {
+      next.push(line);
+      continue;
+    }
+    if (seen.has(key)) continue;
+    seen.add(key);
+    next.push(`${match[1] ?? ""}${key}=${quoteEnv(updates[key] ?? "")}`);
+  }
+  for (const [key, value] of Object.entries(updates)) {
+    if (!seen.has(key)) next.push(`${key}=${quoteEnv(value)}`);
+  }
+  while (next.length > 0 && next[next.length - 1] === "") next.pop();
+  return ensureTrailingNewline(next.join("\n"));
+}
+function mergeOpenClawConfigContent(existing, values) {
+  const root = normalizeJsonRoot(existing, "OpenClaw");
+  const channels = asRecord(root.channels);
+  const legacyShadow = asRecord(channels["openclaw-shadowob"]);
+  const shadow = asRecord(channels.shadowob);
+  channels.shadowob = {
+    ...legacyShadow,
+    ...shadow,
+    token: values.token,
+    serverUrl: values.serverUrl
+  };
+  delete channels["openclaw-shadowob"];
+  root.channels = channels;
+  const plugins = asRecord(root.plugins);
+  plugins.enabled = plugins.enabled ?? true;
+  plugins.allow = uniqueStrings(
+    Array.isArray(plugins.allow) ? plugins.allow : [],
+    "openclaw-shadowob"
+  );
+  const entries = asRecord(plugins.entries);
+  entries["openclaw-shadowob"] = {
+    ...asRecord(entries["openclaw-shadowob"]),
+    enabled: true
+  };
+  plugins.entries = entries;
+  root.plugins = plugins;
+  return ensureTrailingNewline(JSON.stringify(root, null, 2));
+}
+function mergeHermesConfigContent(existing, values) {
+  const root = parseYamlRoot(existing, "Hermes");
+  const plugins = asRecord(root.plugins);
+  plugins.enabled = uniqueStrings(Array.isArray(plugins.enabled) ? plugins.enabled : [], "shadowob");
+  root.plugins = plugins;
+  const platforms = asRecord(root.platforms);
+  const shadowob = asRecord(platforms.shadowob);
+  const extra = asRecord(shadowob.extra);
+  platforms.shadowob = {
+    ...shadowob,
+    enabled: true,
+    token: values.token,
+    extra: {
+      mention_only: false,
+      rest_only: false,
+      catchup_minutes: 0,
+      download_media: true,
+      slash_commands: [],
+      ...extra,
+      base_url: values.serverUrl
+    }
+  };
+  root.platforms = platforms;
+  return ensureTrailingNewline(stringifyYaml(root));
+}
+function asTomlTable(value) {
+  return isRecord(value) && !Array.isArray(value) ? { ...value } : {};
+}
+function tomlArray(value) {
+  if (!Array.isArray(value)) return [];
+  const tables = [];
+  for (const item of value) {
+    if (isRecord(item)) tables.push({ ...item });
+  }
+  return tables;
+}
+function ccConnectProjectWorkDir(project) {
+  const agent = asTomlTable(project.agent);
+  const options = asTomlTable(agent.options);
+  return typeof options.work_dir === "string" ? options.work_dir : typeof project.work_dir === "string" ? project.work_dir : void 0;
+}
+function mergeCcConnectConfigContent(existing, values) {
+  const root = parseTomlRoot(existing, "cc-connect");
+  const projects = tomlArray(root.projects);
+  let project = projects.find((item) => item.name === values.projectName) ?? projects.find((item) => ccConnectProjectWorkDir(item) === values.workDir);
+  if (!project) {
+    project = {};
+    projects.push(project);
+  }
+  project.name = values.projectName;
+  delete project.work_dir;
+  delete project.agent_type;
+  const agent = asTomlTable(project.agent);
+  const agentOptions = asTomlTable(agent.options);
+  agent.type = values.agentType;
+  agent.options = {
+    ...agentOptions,
+    work_dir: values.workDir
+  };
+  project.agent = agent;
+  const platforms = tomlArray(project.platforms);
+  let shadowPlatform = platforms.find((item) => item.type === "shadowob");
+  if (!shadowPlatform) {
+    shadowPlatform = {};
+    platforms.push(shadowPlatform);
+  }
+  const options = asTomlTable(shadowPlatform.options);
+  shadowPlatform.type = "shadowob";
+  shadowPlatform.options = {
+    allow_from: "*",
+    listen_dms: true,
+    share_session_in_channel: false,
+    progress_style: "compact",
+    ...options,
+    token: values.token,
+    server_url: values.serverUrl
+  };
+  project.platforms = platforms;
+  root.projects = projects;
+  return ensureTrailingNewline(stringifyToml(root));
+}
 
 // src/index.ts
 var DEFAULT_SERVER_URL = "https://shadowob.com";
@@ -94,7 +552,14 @@ function buildOpenClawPlan(input) {
       "typing",
       "activityStatus",
       "reactions",
-      "editDelete"
+      "editDelete",
+      "statusChecks",
+      "usageCosts",
+      "multiAgentBinding",
+      "shadowCliLogin",
+      "notifications",
+      "officialSkills",
+      "cronTasks"
     ]
   };
 }
@@ -180,7 +645,12 @@ function buildHermesPlan(input) {
       "onlineStatus",
       "typing",
       "activityStatus",
-      "cronDelivery"
+      "cronDelivery",
+      "statusChecks",
+      "usageCosts",
+      "shadowCliLogin",
+      "notifications",
+      "officialSkills"
     ]
   };
 }
@@ -195,8 +665,12 @@ function buildCcConnectPlan(input) {
     "",
     "[[projects]]",
     `name = "${projectName}"`,
+    "",
+    "[projects.agent]",
+    `type = "${agentType}"`,
+    "",
+    "[projects.agent.options]",
     `work_dir = "${workDir}"`,
-    `agent_type = "${agentType}"`,
     "",
     "[[projects.platforms]]",
     'type = "shadowob"',
@@ -209,15 +683,6 @@ function buildCcConnectPlan(input) {
     "share_session_in_channel = false",
     'progress_style = "compact"'
   ].join("\n");
-  const commands = [
-    { label: "Install cc-connect", command: "npm install -g cc-connect" },
-    { label: "Create config directory", command: "mkdir -p ~/.cc-connect" },
-    {
-      label: "Edit config",
-      command: "$EDITOR ~/.cc-connect/config.toml"
-    },
-    { label: "Start cc-connect", command: "cc-connect" }
-  ];
   const connectCommand = [
     "npx @shadowob/connector@latest connect",
     "--target cc-connect",
@@ -227,12 +692,26 @@ function buildCcConnectPlan(input) {
     `--project-name ${shellQuote(projectName)}`,
     `--agent-type ${shellQuote(agentType)}`
   ].join(" ");
+  const installCommand = `${connectCommand} --install`;
+  const startCommand = `${connectCommand} --install --start`;
+  const commands = [
+    {
+      label: "Install ShadowOB cc-connect fork",
+      command: installCommand
+    },
+    { label: "Create config directory", command: "mkdir -p ~/.cc-connect" },
+    {
+      label: "Edit config",
+      command: "$EDITOR ~/.cc-connect/config.toml"
+    },
+    { label: "Start ShadowOB cc-connect fork", command: startCommand }
+  ];
   return {
     target: "cc-connect",
     title: "cc-connect",
-    summary: "Use cc-connect ShadowOB Socket.IO platform support with this Buddy token.",
-    connectCommand,
-    quickCommand: commands.map((item) => item.command).join(" && "),
+    summary: `Use ${CC_CONNECT_FORK_REPO}@${CC_CONNECT_FORK_SHORT_REF} with ShadowOB Socket.IO platform support for this Buddy token.`,
+    connectCommand: startCommand,
+    quickCommand: startCommand,
     commands,
     configBlocks: [{ label: "~/.cc-connect/config.toml", language: "toml", content: tomlConfig }],
     aiPrompt: [
@@ -243,9 +722,9 @@ function buildCcConnectPlan(input) {
       `Project work_dir: ${workDir}`,
       `Agent type: ${agentType}`,
       "",
-      "Install cc-connect, add the TOML platform block, and start cc-connect."
+      `Install ${CC_CONNECT_FORK_REPO}@${CC_CONNECT_FORK_SHORT_REF}, add the TOML platform block, and start cc-connect.`
     ].join("\n"),
-    docsUrl: "https://github.com/buggyblues/cc-connect/blob/main/docs/shadowob.md",
+    docsUrl: CC_CONNECT_FORK_DOCS_URL,
     capabilities: [
       "channelMessages",
       "dms",
@@ -255,7 +734,12 @@ function buildCcConnectPlan(input) {
       "slashCommands",
       "typing",
       "streamingPreviews",
-      "forms"
+      "forms",
+      "statusChecks",
+      "usageCosts",
+      "multiAgentBinding",
+      "shadowCliLogin",
+      "notifications"
     ]
   };
 }
@@ -286,13 +770,14 @@ function usage() {
     "  shadowob-connector connect --target <openclaw|hermes|cc-connect> --server-url <url> --token <token>",
     "",
     "Options:",
+    "  --openclaw-config <path> OpenClaw JSON config, default $OPENCLAW_CONFIG or ~/.shadowob/openclaw.json",
     "  --hermes-home <path>    Hermes config directory, default $HERMES_HOME or ~/.hermes",
     "  --work-dir <path>       cc-connect project work directory",
     "  --project-name <name>   cc-connect project name",
     "  --agent-type <type>     cc-connect agent type, default codex",
     "  --json                  Print the full plan as JSON",
     "  --force                 Overwrite target config files when needed",
-    "  --install               Install cc-connect when target is cc-connect",
+    "  --install               Install the ShadowOB cc-connect fork when target is cc-connect",
     "  --no-install            Skip Hermes dependency install and plugin enablement",
     "  --start                 Start Hermes gateway or cc-connect after setup",
     "  --dry-run               Show what would be applied without changing files"
@@ -316,6 +801,7 @@ function parseArgs(args) {
     target,
     serverUrl: readOption(optionArgs, "--server-url") ?? "https://shadowob.com",
     token: readOption(optionArgs, "--token") ?? "",
+    openclawConfig: readOption(optionArgs, "--openclaw-config"),
     hermesHome: readOption(optionArgs, "--hermes-home"),
     workDir: readOption(optionArgs, "--work-dir"),
     projectName: readOption(optionArgs, "--project-name"),
@@ -349,81 +835,99 @@ function runShell(command, dryRun) {
     console.log(`[dry-run] ${command}`);
     return;
   }
-  const result = spawnSync(command, { shell: true, stdio: "inherit" });
+  const result = spawnSync2(command, { shell: true, stdio: "inherit" });
   if (result.status !== 0) {
     throw new Error(`Command failed with exit code ${result.status ?? "unknown"}: ${command}`);
   }
 }
+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" });
+  if (result.status !== 0) {
+    throw new Error(`Command failed with exit code ${result.status ?? "unknown"}: ${rendered}`);
+  }
+}
 function writeFile(path, content, dryRun) {
   if (dryRun) {
     console.log(`[dry-run] write ${path}`);
     return;
   }
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, content.endsWith("\n") ? content : `${content}
+  mkdirSync2(dirname2(path), { recursive: true });
+  writeFileSync2(path, content.endsWith("\n") ? content : `${content}
 `);
 }
-function upsertManagedBlock(path, name, content, dryRun) {
-  const begin = `# BEGIN ShadowOB ${name}`;
-  const end = `# END ShadowOB ${name}`;
-  const block = `${begin}
-${content}
-${end}`;
-  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
-  const pattern = new RegExp(
-    `${begin.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`
-  );
-  const next = existing.match(pattern) ? existing.replace(pattern, block) : [existing.trimEnd(), block].filter(Boolean).join("\n\n");
-  writeFile(path, next, dryRun);
-}
 function packageRoot() {
-  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+  return resolve2(dirname2(fileURLToPath(import.meta.url)), "..");
 }
-function expandHome(value) {
-  return value.startsWith("~/") ? resolve(homedir(), value.slice(2)) : resolve(value);
+function expandHome2(value) {
+  return value.startsWith("~/") ? resolve2(homedir2(), value.slice(2)) : resolve2(value);
+}
+function readExisting(path) {
+  return existsSync2(path) ? readFileSync(path, "utf8") : "";
+}
+function normalizeServerUrl2(value) {
+  const trimmed = value.trim() || "https://shadowob.com";
+  return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed.replace(/\/$/, "");
 }
 function hermesPluginSource() {
   const candidates = [
-    resolve(packageRoot(), "hermes-shadowob-plugin"),
-    resolve(process.cwd(), "packages/connector/hermes-shadowob-plugin")
+    resolve2(packageRoot(), "hermes-shadowob-plugin"),
+    resolve2(process.cwd(), "packages/connector/hermes-shadowob-plugin")
   ];
-  const found = candidates.find((candidate) => existsSync(candidate));
+  const found = candidates.find((candidate) => existsSync2(candidate));
   if (!found) throw new Error("Cannot find bundled hermes-shadowob-plugin directory");
   return found;
 }
 function applyOpenClaw(options) {
   const plan = createConnectorPlan(options);
-  for (const step of plan.commands) {
-    console.log(`Applying: ${step.label}`);
-    runShell(step.command, options.dryRun);
+  const configPath = expandHome2(
+    options.openclawConfig ?? process.env.OPENCLAW_CONFIG ?? "~/.shadowob/openclaw.json"
+  );
+  console.log("Applying: Install plugin");
+  runShell("openclaw plugins install @shadowob/openclaw-shadowob", options.dryRun);
+  console.log(`Applying: Merge OpenClaw config ${configPath}`);
+  const next = mergeOpenClawConfigContent(readExisting(configPath), {
+    token: options.token,
+    serverUrl: normalizeServerUrl2(options.serverUrl)
+  });
+  writeFile(configPath, next, options.dryRun);
+  const restart = plan.commands.find((step) => step.label === "Restart gateway");
+  if (restart) {
+    console.log(`Applying: ${restart.label}`);
+    runShell(restart.command, options.dryRun);
   }
 }
 function applyHermes(options) {
   const plan = createConnectorPlan(options);
-  const hermesDir = expandHome(options.hermesHome ?? process.env.HERMES_HOME ?? "~/.hermes");
-  const pluginTarget = resolve(hermesDir, "plugins/shadowob");
-  const envPath = resolve(hermesDir, ".env");
-  const configPath = resolve(hermesDir, "config.yaml");
-  const generatedConfigPath = resolve(hermesDir, "config.shadowob.yaml");
+  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 envBlock = plan.configBlocks.find((block) => block.label === "~/.hermes/.env");
-  const yamlBlock = plan.configBlocks.find((block) => block.label === "~/.hermes/config.yaml");
-  if (!envBlock || !yamlBlock) throw new Error("Hermes plan is missing config blocks");
+  if (!envBlock) throw new Error("Hermes plan is missing config blocks");
   if (options.dryRun) {
     console.log(`[dry-run] copy ${hermesPluginSource()} -> ${pluginTarget}`);
   } else {
-    mkdirSync(resolve(hermesDir, "plugins"), { recursive: true });
+    mkdirSync2(resolve2(hermesDir, "plugins"), { recursive: true });
     cpSync(hermesPluginSource(), pluginTarget, { recursive: true, force: true });
   }
-  upsertManagedBlock(envPath, "Hermes ShadowOB", envBlock.content, options.dryRun);
-  if (!existsSync(configPath) || options.force) {
-    writeFile(configPath, yamlBlock.content, options.dryRun);
-  } else {
-    writeFile(generatedConfigPath, yamlBlock.content, options.dryRun);
-    console.log(`Existing Hermes config kept. Generated ShadowOB config: ${generatedConfigPath}`);
-  }
+  const nextEnv = options.force ? envBlock.content : mergeEnvContent(readExisting(envPath), {
+    token: options.token,
+    serverUrl: normalizeServerUrl2(options.serverUrl)
+  });
+  writeFile(envPath, nextEnv, options.dryRun);
+  const nextConfig = mergeHermesConfigContent(options.force ? "" : readExisting(configPath), {
+    token: options.token,
+    serverUrl: normalizeServerUrl2(options.serverUrl)
+  });
+  writeFile(configPath, nextConfig, options.dryRun);
   if (options.install) {
     runShell(
-      `python -m pip install -r "${resolve(pluginTarget, "requirements.txt")}"`,
+      `python -m pip install -r "${resolve2(pluginTarget, "requirements.txt")}"`,
       options.dryRun
     );
     runShell("hermes plugins enable shadowob", options.dryRun);
@@ -432,26 +936,33 @@ function applyHermes(options) {
     runShell("hermes gateway", options.dryRun);
   }
 }
-function applyCcConnect(options) {
+async function applyCcConnect(options) {
   const plan = createConnectorPlan(options);
   const configBlock = plan.configBlocks.find((block) => block.label === "~/.cc-connect/config.toml");
   if (!configBlock) throw new Error("cc-connect plan is missing config block");
-  const configPath = resolve(homedir(), ".cc-connect/config.toml");
-  const generatedPath = resolve(homedir(), ".cc-connect/config.shadowob.toml");
-  if (!existsSync(configPath) || options.force) {
-    writeFile(configPath, configBlock.content, options.dryRun);
-  } else {
-    writeFile(generatedPath, configBlock.content, options.dryRun);
-    console.log(`Existing cc-connect config kept. Generated ShadowOB config: ${generatedPath}`);
-  }
-  if (options.install) {
-    runShell("npm install -g cc-connect", options.dryRun);
+  const configPath = resolve2(homedir2(), ".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"
+  });
+  writeFile(configPath, nextConfig, options.dryRun);
+  let binaryPath;
+  if (options.install || options.start) {
+    const installed = await ensureCcConnectFork({
+      dryRun: options.dryRun,
+      log: (message) => console.log(message)
+    });
+    binaryPath = installed.binaryPath;
+    console.log(`cc-connect binary: ${binaryPath}`);
   }
   if (options.start) {
-    runShell("cc-connect", options.dryRun);
+    runBinary(binaryPath ?? "cc-connect", [], options.dryRun);
   }
 }
-function connect(options) {
+async function connect(options) {
   if (options.target === "openclaw") {
     applyOpenClaw(options);
     return;
@@ -460,18 +971,19 @@ function connect(options) {
     applyHermes(options);
     return;
   }
-  applyCcConnect(options);
+  await applyCcConnect(options);
 }
-try {
+async function main() {
   const options = parseArgs(process.argv.slice(2));
   if (options.command === "connect") {
-    connect(options);
+    await connect(options);
   } else {
     printPlan(options);
   }
-} catch (error) {
+}
+main().catch((error) => {
   console.error(error instanceof Error ? error.message : String(error));
   console.error("");
   console.error(usage());
   process.exit(1);
-}
+});