claw-control-center 0.1.7 → 0.1.9

package/dist/index.cjs

@@ -5449,10 +5449,10 @@ function resolvePluginConfig(config) {
 function resolvePluginConfigWithHostDefaults(configPath, config) {
   const resolved = resolvePluginConfig(config);
   const hostConfig = readHostGatewayConfig(resolveHostConfigPath(configPath));
-  if (!resolved.gateway.baseUrl && hostConfig.baseUrl) {
+  if (hostConfig.baseUrl && (!resolved.gateway.baseUrl || shouldPreferHostGateway(resolved.gateway.baseUrl, hostConfig.baseUrl))) {
     resolved.gateway.baseUrl = hostConfig.baseUrl;
   }
-  if (!resolved.gateway.secret && hostConfig.secret) {
+  if (hostConfig.secret && (!resolved.gateway.secret || resolved.gateway.baseUrl === hostConfig.baseUrl)) {
     resolved.gateway.secret = hostConfig.secret;
   }
   if (!resolved.hub53ai.botId && hostConfig.hub53ai?.botId) {
@@ -5466,6 +5466,28 @@ function resolvePluginConfigWithHostDefaults(configPath, config) {
   }
   return resolved;
 }
+function shouldPreferHostGateway(configuredBaseUrl, hostBaseUrl) {
+  if (configuredBaseUrl === hostBaseUrl) {
+    return false;
+  }
+  const configured = parseGatewayUrl(configuredBaseUrl);
+  const host = parseGatewayUrl(hostBaseUrl);
+  if (!configured || !host) {
+    return false;
+  }
+  return configured.isLoopback && host.isLoopback;
+}
+function parseGatewayUrl(value) {
+  try {
+    const url = new URL(value);
+    const hostname = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    return {
+      isLoopback: hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1"
+    };
+  } catch {
+    return void 0;
+  }
+}
 function sanitizePluginConfig(config) {
   if (!config) {
     return {};
@@ -8859,32 +8881,84 @@ function toRecord3(value) {
 
 // src/install-qclaw.ts
 var import_node_crypto4 = require("crypto");
-var import_promises4 = require("fs/promises");
+var import_promises4 = require("readline/promises");
+var import_promises5 = require("fs/promises");
 var import_node_fs4 = require("fs");
+var import_node_os2 = require("os");
 var import_node_path6 = require("path");
+var import_yaml = require("yaml");
 var PLUGIN_ID = "claw-control-center";
 var LEGACY_PLUGIN_ID = "53ai-openclaw";
 var COPY_ITEMS = ["dist", "openclaw.plugin.json", "package.json", "bin", "web-dist"];
+var HERMES_PLATFORM_ID = "53aihub";
+var HERMES_PLUGIN_KEY = `platforms/${HERMES_PLATFORM_ID}`;
+var HERMES_ENV_KEYS = {
+  botId: "HUB53AI_BOT_ID",
+  secret: "HUB53AI_SECRET",
+  wsUrl: "HUB53AI_WS_URL"
+};
+var SUPPORTED_ARGS = /* @__PURE__ */ new Set([
+  "gateway",
+  "bot-id",
+  "secret",
+  "prefer-responses-api",
+  "gateway-model",
+  "hub-ws-url",
+  "hub-bot-id",
+  "hub-secret",
+  "hub-enabled",
+  "extensions-dir",
+  "config-path",
+  "console-host",
+  "console-port"
+]);
 async function installIntoQClaw(input) {
   return installIntoHost(input, "QClaw");
 }
 async function installIntoOpenClaw(input) {
   return installIntoHost(input, "OpenClaw");
 }
+async function installIntoHermes(input) {
+  const hubWsUrl = input.hubWsUrl?.trim();
+  const hubBotId = input.hubBotId?.trim();
+  const hubSecret = input.hubSecret?.trim();
+  if (!hubWsUrl || !hubBotId || !hubSecret) {
+    throw new Error("Hermes install requires --hub-ws-url, --hub-bot-id, and --hub-secret");
+  }
+  const platformsDir = normalizeHermesPlatformsDir(input.extensionsDir);
+  const destination = (0, import_node_path6.join)(platformsDir, HERMES_PLATFORM_ID);
+  await (0, import_promises5.mkdir)(destination, { recursive: true });
+  await copyHermesPlatformPackage(input.packageRoot, destination);
+  await updateHermesConfig(input.configPath);
+  await updateHermesEnv(input.configPath, {
+    botId: hubBotId,
+    secret: hubSecret,
+    wsUrl: hubWsUrl
+  });
+  return {
+    configPath: input.configPath,
+    extensionsDir: platformsDir,
+    destination,
+    hub53aiConfigured: true,
+    pluginBuild: await readHermesPluginBuildInfo(destination)
+  };
+}
 async function installIntoHost(input, hostLabel) {
-  await (0, import_promises4.mkdir)(input.extensionsDir, { recursive: true });
+  await (0, import_promises5.mkdir)(input.extensionsDir, { recursive: true });
   const destination = (0, import_node_path6.join)(input.extensionsDir, PLUGIN_ID);
-  await (0, import_promises4.mkdir)(destination, { recursive: true });
+  await (0, import_promises5.mkdir)(destination, { recursive: true });
   await copyPublishablePackage(input.packageRoot, destination);
-  await (0, import_promises4.mkdir)((0, import_node_path6.dirname)(input.configPath), { recursive: true });
+  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(input.configPath), { recursive: true });
   const config = await readOpenClawConfig(input.configPath);
   const inferredGateway = inferGatewaySettings(config);
   const inferredHub53AI = inferHub53AISettings(config);
-  const gatewayBaseUrl = input.gateway?.trim() || inferredGateway.baseUrl;
+  const explicitGatewayBaseUrl = input.gateway?.trim();
+  const explicitGatewaySecret = input.secret?.trim();
+  const gatewayBaseUrl = explicitGatewayBaseUrl || inferredGateway.baseUrl;
   if (!gatewayBaseUrl) {
     throw new Error(`missing gateway URL and no local ${hostLabel} gateway could be inferred`);
   }
-  const secret = input.secret?.trim() || inferredGateway.secret;
+  const secret = explicitGatewaySecret || inferredGateway.secret;
   if (!secret) {
     throw new Error(`missing gateway secret and no local ${hostLabel} gateway token could be inferred`);
   }
@@ -8919,8 +8993,16 @@ async function installIntoHost(input, hostLabel) {
   const previousEntry = ensureObject(entries, PLUGIN_ID);
   const previousConfig = ensureObject(previousEntry, "config");
   const previousGateway = ensureObject(previousConfig, "gateway");
-  previousGateway.baseUrl = gatewayBaseUrl;
-  previousGateway.secret = secret;
+  if (explicitGatewayBaseUrl) {
+    previousGateway.baseUrl = explicitGatewayBaseUrl;
+  } else {
+    delete previousGateway.baseUrl;
+  }
+  if (explicitGatewaySecret) {
+    previousGateway.secret = explicitGatewaySecret;
+  } else {
+    delete previousGateway.secret;
+  }
   previousGateway.preferResponsesApi = preferResponsesApi;
   if (botId) {
     previousGateway.botId = botId;
@@ -8961,7 +9043,7 @@ async function installIntoHost(input, hostLabel) {
     }
   }
   previousEntry.enabled = true;
-  await (0, import_promises4.writeFile)(input.configPath, `${JSON.stringify(config, null, 2)}
+  await (0, import_promises5.writeFile)(input.configPath, `${JSON.stringify(config, null, 2)}
 `);
   return {
     configPath: input.configPath,
@@ -8978,9 +9060,14 @@ async function runInstallCommand(input) {
     throw new Error("expected subcommand: install");
   }
   const args = parseArgs(argv.slice(1));
-  const destination = resolveInstallDestination(args);
-  const result = await installIntoHost(
-    {
+  const destinations = await resolveInstallDestinations(args, {
+    hostDefinitions: input.hostDefinitions,
+    selectHosts: input.selectHosts,
+    selectHost: input.selectHost,
+    ttyPath: input.ttyPath
+  });
+  for (const destination of destinations) {
+    const installInput = {
       packageRoot: input.packageRoot,
       extensionsDir: destination.extensionsDir,
       configPath: destination.configPath,
@@ -8995,35 +9082,186 @@ async function runInstallCommand(input) {
       hubEnabled: parseOptionalBoolean(args["hub-enabled"]),
       consoleHost: args["console-host"],
       consolePort: args["console-port"] ? Number(args["console-port"]) : void 0
-    },
-    "Claw"
-  );
-  process.stdout.write(
-    [
-      `Installed ${PLUGIN_ID} into Claw.`,
-      `Extensions: ${result.extensionsDir}`,
-      `Config: ${result.configPath}`,
-      `Gateway: ${result.gatewayBaseUrl}`,
-      `53AIHub: ${result.hub53aiConfigured ? "configured" : "not configured"}`,
-      `Plugin build: ${result.pluginBuild}`,
-      "Restart your Claw host to load the plugin."
-    ].join("\n") + "\n"
-  );
-}
-function resolveInstallDestination(args) {
-  if (args.target !== void 0) {
-    throw new Error("--target is no longer supported; pass --config-path and --extensions-dir from your Claw host");
+    };
+    const result = destination.installKind === "hermes" ? await installIntoHermes(installInput) : await installIntoHost(installInput, destination.label);
+    process.stdout.write(
+      [
+        `Installed ${PLUGIN_ID} into ${destination.label}.`,
+        `Extensions: ${result.extensionsDir}`,
+        `Config: ${result.configPath}`,
+        ...destination.installKind === "hermes" ? [] : [`Gateway: ${result.gatewayBaseUrl}`],
+        `53AIHub: ${result.hub53aiConfigured ? "configured" : "not configured"}`,
+        `Plugin build: ${result.pluginBuild}`,
+        `Restart ${destination.label} to load the plugin.`
+      ].join("\n") + "\n"
+    );
   }
+}
+async function resolveInstallDestinations(args, options = {}) {
   const explicitConfigPath = args["config-path"] ? (0, import_node_path6.resolve)(args["config-path"]) : void 0;
   const explicitExtensionsDir = args["extensions-dir"] ? (0, import_node_path6.resolve)(args["extensions-dir"]) : void 0;
-  if (!explicitConfigPath || !explicitExtensionsDir) {
-    throw new Error("missing --config-path and --extensions-dir; provide the paths generated by your Claw host");
+  if (explicitConfigPath && explicitExtensionsDir) {
+    const hermes = isHermesDestination(explicitConfigPath, explicitExtensionsDir);
+    return [{
+      configPath: explicitConfigPath,
+      extensionsDir: hermes ? normalizeHermesPlatformsDir(explicitExtensionsDir) : explicitExtensionsDir,
+      label: hermes ? "Hermes" : "Claw",
+      installKind: hermes ? "hermes" : "openclaw"
+    }];
+  }
+  if (explicitConfigPath || explicitExtensionsDir) {
+    throw new Error("pass --config-path and --extensions-dir together, or omit both to auto-detect Claw");
+  }
+  const detected = detectInstallHosts(options.hostDefinitions ?? getDefaultHostDefinitions());
+  const compatible = detected;
+  const incompatible = [];
+  if (compatible.length === 1) {
+    return [toInstallDestination(compatible[0])];
+  }
+  if (compatible.length > 1) {
+    const selected = options.selectHosts ? await options.selectHosts(compatible, incompatible) : options.selectHost ? [await options.selectHost(compatible)] : await promptForInstallHosts(compatible, incompatible, options.ttyPath ?? "/dev/tty");
+    return validateSelectedHosts(selected, compatible).map(toInstallDestination);
+  }
+  throw new Error(
+    [
+      "could not auto-detect an installed Claw host.",
+      "Pass --config-path and --extensions-dir to install into a specific Claw.",
+      "",
+      "Supported default locations:",
+      ...formatHostList(options.hostDefinitions ?? getDefaultHostDefinitions())
+    ].join("\n")
+  );
+}
+function getDefaultHostDefinitions() {
+  const home = (0, import_node_os2.homedir)();
+  const qclawHome = (0, import_node_path6.resolve)(home, ".qclaw");
+  const openClawHome = (0, import_node_path6.resolve)(home, ".openclaw");
+  const hermesHome = (0, import_node_path6.resolve)(home, ".hermes");
+  return [
+    {
+      id: "qclaw",
+      label: "QClaw",
+      configPath: (0, import_node_path6.join)(qclawHome, "openclaw.json"),
+      extensionsDir: (0, import_node_path6.resolve)(home, "Library/Application Support/QClaw/openclaw/config/extensions")
+    },
+    {
+      id: "openclaw",
+      label: "OpenClaw",
+      configPath: (0, import_node_path6.join)(openClawHome, "openclaw.json"),
+      extensionsDir: (0, import_node_path6.resolve)(openClawHome, "extensions")
+    },
+    {
+      id: "hermes",
+      label: "Hermes",
+      configPath: (0, import_node_path6.join)(hermesHome, "config.yaml"),
+      extensionsDir: (0, import_node_path6.resolve)(hermesHome, "plugins", "platforms"),
+      installKind: "hermes"
+    }
+  ];
+}
+function detectInstallHosts(hosts) {
+  const seen = /* @__PURE__ */ new Set();
+  return hosts.filter((host) => {
+    const key = `${(0, import_node_path6.resolve)(host.configPath)}\0${(0, import_node_path6.resolve)(host.extensionsDir)}`;
+    if (seen.has(key) || !(0, import_node_fs4.existsSync)(host.configPath)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+async function promptForInstallHosts(hosts, incompatibleHosts, ttyPath) {
+  let handle;
+  try {
+    handle = await (0, import_promises5.open)(ttyPath, "r+");
+    const input = handle.createReadStream();
+    const output = handle.createWriteStream();
+    const readline = (0, import_promises4.createInterface)({ input, output });
+    try {
+      output.write("Multiple Claw installations were detected.\n");
+      output.write("Choose one or more locations to install claw-control-center:\n");
+      hosts.forEach((host, index) => {
+        output.write(`${index + 1}. ${host.label}
+`);
+        output.write(`   Config: ${host.configPath}
+`);
+        output.write(`   Extensions: ${host.extensionsDir}
+`);
+      });
+      if (incompatibleHosts.length > 0) {
+        output.write("\nDetected but not installable by this OpenClaw plugin installer:\n");
+        for (const host of incompatibleHosts) {
+          output.write(`- ${host.label}: ${host.incompatibilityReason ?? "incompatible plugin format"}
+`);
+        }
+      }
+      const answer = await readline.question(`Install location(s) [1-${hosts.length}, comma-separated, or all]: `);
+      const selectedIndexes = parseInstallSelection(answer, hosts.length);
+      if (selectedIndexes.length === 0) {
+        throw new Error(`invalid install location: ${answer}`);
+      }
+      return selectedIndexes.map((index) => hosts[index - 1]);
+    } finally {
+      readline.close();
+      input.destroy();
+      output.end();
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("invalid install location:")) {
+      throw error;
+    }
+    throw new Error(
+      [
+        "multiple Claw installations were detected, but no interactive terminal was available.",
+        "Run the installer again with --config-path and --extensions-dir.",
+        "",
+        "Detected locations:",
+        ...formatHostList(hosts)
+      ].join("\n")
+    );
+  } finally {
+    await handle?.close().catch(() => void 0);
   }
+}
+function toInstallDestination(host) {
   return {
-    configPath: explicitConfigPath,
-    extensionsDir: explicitExtensionsDir
+    configPath: (0, import_node_path6.resolve)(host.configPath),
+    extensionsDir: (0, import_node_path6.resolve)(host.extensionsDir),
+    label: host.label,
+    installKind: host.installKind ?? "openclaw"
   };
 }
+function validateSelectedHosts(selected, compatible) {
+  const compatibleIds = new Set(compatible.map((host) => host.id));
+  const invalid = selected.find((host) => !compatibleIds.has(host.id));
+  if (invalid) {
+    throw new Error(`selected host is not installable: ${invalid.label}`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return selected.filter((host) => {
+    if (seen.has(host.id)) {
+      return false;
+    }
+    seen.add(host.id);
+    return true;
+  });
+}
+function parseInstallSelection(answer, hostCount) {
+  const trimmed = answer.trim().toLowerCase();
+  if (trimmed === "all" || trimmed === "*") {
+    return Array.from({ length: hostCount }, (_, index) => index + 1);
+  }
+  const indexes = trimmed.split(",").map((part) => Number(part.trim())).filter((index) => Number.isInteger(index) && index >= 1 && index <= hostCount);
+  return Array.from(new Set(indexes));
+}
+function formatHostList(hosts) {
+  return hosts.flatMap((host) => [
+    `- ${host.label}`,
+    `  Config: ${host.configPath}`,
+    `  Extensions: ${host.extensionsDir}`,
+    ...host.incompatibilityReason ? [`  Note: ${host.incompatibilityReason}`] : []
+  ]);
+}
 function parseArgs(argv) {
   const parsed = {};
   for (let index = 0; index < argv.length; index += 1) {
@@ -9031,12 +9269,19 @@ function parseArgs(argv) {
     if (!entry.startsWith("--")) {
       continue;
     }
+    const key = entry.slice(2);
+    if (key === "target") {
+      throw new Error("--target has been removed; omit it to auto-detect Claw or pass --config-path and --extensions-dir");
+    }
+    if (!SUPPORTED_ARGS.has(key)) {
+      throw new Error(`unknown option: --${key}`);
+    }
     const next = argv[index + 1];
     if (next && !next.startsWith("--")) {
-      parsed[entry.slice(2)] = next;
+      parsed[key] = next;
       index += 1;
     } else {
-      parsed[entry.slice(2)] = "true";
+      parsed[key] = "true";
     }
   }
   return parsed;
@@ -9051,16 +9296,25 @@ async function copyPublishablePackage(packageRoot, destination) {
       continue;
     }
     const target = (0, import_node_path6.join)(destination, relativePath);
-    await (0, import_promises4.rm)(target, { recursive: true, force: true });
-    await (0, import_promises4.cp)(source, target, { recursive: true, force: true });
+    await (0, import_promises5.rm)(target, { recursive: true, force: true });
+    await (0, import_promises5.cp)(source, target, { recursive: true, force: true });
   }
 }
+async function copyHermesPlatformPackage(packageRoot, destination) {
+  const source = (0, import_node_path6.join)(packageRoot, "hermes", "platforms", HERMES_PLATFORM_ID);
+  if (!(0, import_node_fs4.existsSync)(source)) {
+    throw new Error(`Hermes platform package does not exist: ${source}`);
+  }
+  await (0, import_promises5.rm)(destination, { recursive: true, force: true });
+  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(destination), { recursive: true });
+  await (0, import_promises5.cp)(source, destination, { recursive: true, force: true });
+}
 async function readPluginBuildInfo(destination) {
   const packagePath = (0, import_node_path6.join)(destination, "package.json");
   const entryPath = (0, import_node_path6.join)(destination, "dist", "index.cjs");
   let version = "unknown";
   try {
-    const packageJson = JSON.parse(await (0, import_promises4.readFile)(packagePath, "utf8"));
+    const packageJson = JSON.parse(await (0, import_promises5.readFile)(packagePath, "utf8"));
     if (typeof packageJson.version === "string" && packageJson.version.trim()) {
       version = packageJson.version.trim();
     }
@@ -9068,18 +9322,92 @@ async function readPluginBuildInfo(destination) {
     version = "unknown";
   }
   try {
-    const entry = await (0, import_promises4.readFile)(entryPath);
+    const entry = await (0, import_promises5.readFile)(entryPath);
     const digest = (0, import_node_crypto4.createHash)("sha256").update(entry).digest("hex").slice(0, 12);
     return `${PLUGIN_ID}@${version} sha256:${digest}`;
   } catch {
     return `${PLUGIN_ID}@${version} sha256:missing`;
   }
 }
+async function readHermesPluginBuildInfo(destination) {
+  const manifestPath = (0, import_node_path6.join)(destination, "plugin.yaml");
+  try {
+    const manifest = (0, import_yaml.parse)(await (0, import_promises5.readFile)(manifestPath, "utf8"));
+    const version = typeof manifest?.version === "string" || typeof manifest?.version === "number" ? String(manifest.version) : "unknown";
+    const adapter = await (0, import_promises5.readFile)((0, import_node_path6.join)(destination, "adapter.py"));
+    const digest = (0, import_node_crypto4.createHash)("sha256").update(adapter).digest("hex").slice(0, 12);
+    return `${PLUGIN_ID}/hermes@${version} sha256:${digest}`;
+  } catch {
+    return `${PLUGIN_ID}/hermes@unknown sha256:missing`;
+  }
+}
 async function readOpenClawConfig(configPath) {
   if (!(0, import_node_fs4.existsSync)(configPath)) {
     return {};
   }
-  return JSON.parse(await (0, import_promises4.readFile)(configPath, "utf8"));
+  return JSON.parse(await (0, import_promises5.readFile)(configPath, "utf8"));
+}
+async function updateHermesConfig(configPath) {
+  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(configPath), { recursive: true });
+  const config = await readHermesConfig(configPath);
+  const plugins = ensureObject(config, "plugins");
+  plugins.enabled = dedupeStrings([...Array.isArray(plugins.enabled) ? plugins.enabled : [], HERMES_PLUGIN_KEY, HERMES_PLATFORM_ID]);
+  const platforms = ensureObject(config, "platforms");
+  const platform = ensureObject(platforms, HERMES_PLATFORM_ID);
+  platform.enabled = true;
+  ensureObject(platform, "extra");
+  await (0, import_promises5.writeFile)(configPath, (0, import_yaml.stringify)(config));
+}
+async function readHermesConfig(configPath) {
+  if (!(0, import_node_fs4.existsSync)(configPath)) {
+    return {};
+  }
+  const parsed = (0, import_yaml.parse)(await (0, import_promises5.readFile)(configPath, "utf8"));
+  return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+}
+async function updateHermesEnv(configPath, values) {
+  const envPath = (0, import_node_path6.join)((0, import_node_path6.dirname)(configPath), ".env");
+  await (0, import_promises5.mkdir)((0, import_node_path6.dirname)(envPath), { recursive: true });
+  const existing = (0, import_node_fs4.existsSync)(envPath) ? await (0, import_promises5.readFile)(envPath, "utf8") : "";
+  const updates = /* @__PURE__ */ new Map([
+    [HERMES_ENV_KEYS.botId, values.botId],
+    [HERMES_ENV_KEYS.secret, values.secret],
+    [HERMES_ENV_KEYS.wsUrl, values.wsUrl]
+  ]);
+  const seen = /* @__PURE__ */ new Set();
+  const lines = existing.split(/\r?\n/).map((line) => {
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=/);
+    if (!match || !updates.has(match[1])) {
+      return line;
+    }
+    const key = match[1];
+    seen.add(key);
+    return `${key}=${quoteEnvValue(updates.get(key))}`;
+  });
+  for (const [key, value] of updates) {
+    if (!seen.has(key)) {
+      lines.push(`${key}=${quoteEnvValue(value)}`);
+    }
+  }
+  await (0, import_promises5.writeFile)(envPath, `${lines.filter((line, index, all) => line || index < all.length - 1).join("\n")}
+`);
+}
+function quoteEnvValue(value) {
+  return JSON.stringify(value);
+}
+function isHermesDestination(configPath, extensionsDir) {
+  const tail = extensionsDir.split(/[\\/]/).filter(Boolean).slice(-2).join("/");
+  return configPath.endsWith("config.yaml") && (tail === "plugins/platforms" || tail.endsWith("/plugins"));
+}
+function normalizeHermesPlatformsDir(extensionsDir) {
+  const parts = extensionsDir.split(/[\\/]/).filter(Boolean);
+  if (parts.at(-1) === "platforms" && parts.at(-2) === "plugins") {
+    return extensionsDir;
+  }
+  if (parts.at(-1) === "plugins") {
+    return (0, import_node_path6.join)(extensionsDir, "platforms");
+  }
+  return extensionsDir;
 }
 function inferGatewaySettings(config) {
   const gateway = config.gateway ?? {};