claw-control-center 0.1.8 → 0.1.9

package/dist/index.cjs

@@ -8886,9 +8886,17 @@ 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",
@@ -8910,6 +8918,31 @@ async function installIntoQClaw(input) {
 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_promises5.mkdir)(input.extensionsDir, { recursive: true });
   const destination = (0, import_node_path6.join)(input.extensionsDir, PLUGIN_ID);
@@ -9027,13 +9060,14 @@ async function runInstallCommand(input) {
     throw new Error("expected subcommand: install");
   }
   const args = parseArgs(argv.slice(1));
-  const destination = await resolveInstallDestination(args, {
+  const destinations = await resolveInstallDestinations(args, {
     hostDefinitions: input.hostDefinitions,
+    selectHosts: input.selectHosts,
     selectHost: input.selectHost,
     ttyPath: input.ttyPath
   });
-  const result = await installIntoHost(
-    {
+  for (const destination of destinations) {
+    const installInput = {
       packageRoot: input.packageRoot,
       extensionsDir: destination.extensionsDir,
       configPath: destination.configPath,
@@ -9048,41 +9082,45 @@ async function runInstallCommand(input) {
       hubEnabled: parseOptionalBoolean(args["hub-enabled"]),
       consoleHost: args["console-host"],
       consolePort: args["console-port"] ? Number(args["console-port"]) : void 0
-    },
-    destination.label
-  );
-  process.stdout.write(
-    [
-      `Installed ${PLUGIN_ID} into ${destination.label}.`,
-      `Extensions: ${result.extensionsDir}`,
-      `Config: ${result.configPath}`,
-      `Gateway: ${result.gatewayBaseUrl}`,
-      `53AIHub: ${result.hub53aiConfigured ? "configured" : "not configured"}`,
-      `Plugin build: ${result.pluginBuild}`,
-      `Restart ${destination.label} to load the plugin.`
-    ].join("\n") + "\n"
-  );
+    };
+    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 resolveInstallDestination(args, options = {}) {
+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) {
-    return {
+    const hermes = isHermesDestination(explicitConfigPath, explicitExtensionsDir);
+    return [{
       configPath: explicitConfigPath,
-      extensionsDir: explicitExtensionsDir,
-      label: "Claw"
-    };
+      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());
-  if (detected.length === 1) {
-    return toInstallDestination(detected[0]);
+  const compatible = detected;
+  const incompatible = [];
+  if (compatible.length === 1) {
+    return [toInstallDestination(compatible[0])];
   }
-  if (detected.length > 1) {
-    const selected = options.selectHost ? await options.selectHost(detected) : await promptForInstallHost(detected, options.ttyPath ?? "/dev/tty");
-    return toInstallDestination(selected);
+  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(
     [
@@ -9098,6 +9136,7 @@ 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",
@@ -9110,6 +9149,13 @@ function getDefaultHostDefinitions() {
       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"
     }
   ];
 }
@@ -9124,7 +9170,7 @@ function detectInstallHosts(hosts) {
     return true;
   });
 }
-async function promptForInstallHost(hosts, ttyPath) {
+async function promptForInstallHosts(hosts, incompatibleHosts, ttyPath) {
   let handle;
   try {
     handle = await (0, import_promises5.open)(ttyPath, "r+");
@@ -9133,7 +9179,7 @@ async function promptForInstallHost(hosts, ttyPath) {
     const readline = (0, import_promises4.createInterface)({ input, output });
     try {
       output.write("Multiple Claw installations were detected.\n");
-      output.write("Choose where to install claw-control-center:\n");
+      output.write("Choose one or more locations to install claw-control-center:\n");
       hosts.forEach((host, index) => {
         output.write(`${index + 1}. ${host.label}
 `);
@@ -9142,12 +9188,19 @@ async function promptForInstallHost(hosts, ttyPath) {
         output.write(`   Extensions: ${host.extensionsDir}
 `);
       });
-      const answer = await readline.question(`Install location [1-${hosts.length}]: `);
-      const selectedIndex = Number(answer.trim());
-      if (!Number.isInteger(selectedIndex) || selectedIndex < 1 || selectedIndex > hosts.length) {
+      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 hosts[selectedIndex - 1];
+      return selectedIndexes.map((index) => hosts[index - 1]);
     } finally {
       readline.close();
       input.destroy();
@@ -9174,14 +9227,39 @@ function toInstallDestination(host) {
   return {
     configPath: (0, import_node_path6.resolve)(host.configPath),
     extensionsDir: (0, import_node_path6.resolve)(host.extensionsDir),
-    label: host.label
+    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}`
+    `  Extensions: ${host.extensionsDir}`,
+    ...host.incompatibilityReason ? [`  Note: ${host.incompatibilityReason}`] : []
   ]);
 }
 function parseArgs(argv) {
@@ -9222,6 +9300,15 @@ async function copyPublishablePackage(packageRoot, destination) {
     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");
@@ -9242,12 +9329,86 @@ async function readPluginBuildInfo(destination) {
     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_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 ?? {};
   const host = typeof gateway.host === "string" && gateway.host.trim() ? gateway.host.trim() : "127.0.0.1";