soulhubcli 1.0.0

package/dist/index.js

@@ -0,0 +1,1245 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command8 } from "commander";
+
+// src/commands/search.ts
+import { Command } from "commander";
+import chalk from "chalk";
+
+// src/utils.ts
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import yaml from "js-yaml";
+var DEFAULT_REGISTRY_URL = "http://soulhub.store";
+function getRegistryUrl() {
+  return process.env.SOULHUB_REGISTRY_URL || DEFAULT_REGISTRY_URL;
+}
+async function fetchIndex() {
+  const url = `${getRegistryUrl()}/index.json`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch registry index: ${response.statusText}`);
+  }
+  return await response.json();
+}
+async function fetchAgentFile(agentName, fileName) {
+  const url = `${getRegistryUrl()}/agents/${agentName}/${fileName}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch ${fileName} for ${agentName}: ${response.statusText}`
+    );
+  }
+  return await response.text();
+}
+async function fetchRecipeFile(recipeName, fileName) {
+  const url = `${getRegistryUrl()}/recipes/${recipeName}/${fileName}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch ${fileName} for recipe ${recipeName}: ${response.statusText}`
+    );
+  }
+  return await response.text();
+}
+function findOpenClawDir(customDir) {
+  if (customDir) {
+    const resolved = path.resolve(customDir);
+    if (fs.existsSync(resolved)) {
+      return resolved;
+    }
+    return resolved;
+  }
+  const envHome = process.env.OPENCLAW_HOME;
+  if (envHome) {
+    const resolved = path.resolve(envHome);
+    if (fs.existsSync(resolved)) {
+      return resolved;
+    }
+    return resolved;
+  }
+  const candidates = [
+    path.join(process.env.HOME || "~", ".openclaw"),
+    path.join(process.cwd(), ".openclaw")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function getConfigPath() {
+  const home = process.env.HOME || "~";
+  return path.join(home, ".soulhub", "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (fs.existsSync(configPath)) {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  }
+  return {
+    installed: [],
+    registryUrl: DEFAULT_REGISTRY_URL
+  };
+}
+function saveConfig(config) {
+  const configPath = getConfigPath();
+  const configDir = path.dirname(configPath);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function recordInstall(name, version, workspace) {
+  const config = loadConfig();
+  config.installed = config.installed.filter((a) => a.name !== name);
+  config.installed.push({
+    name,
+    version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    workspace
+  });
+  saveConfig(config);
+}
+function removeInstallRecord(name) {
+  const config = loadConfig();
+  config.installed = config.installed.filter((a) => a.name !== name);
+  saveConfig(config);
+}
+function getWorkspaceDir(clawDir, agentName) {
+  return path.join(clawDir, `workspace-${agentName}`);
+}
+function getMainWorkspaceDir(clawDir) {
+  return path.join(clawDir, "workspace");
+}
+function checkMainAgentExists(clawDir) {
+  const workspaceDir = getMainWorkspaceDir(clawDir);
+  if (!fs.existsSync(workspaceDir)) {
+    return { exists: false, hasContent: false, workspaceDir };
+  }
+  const entries = fs.readdirSync(workspaceDir);
+  const hasIdentity = entries.includes("IDENTITY.md");
+  const hasSoul = entries.includes("SOUL.md");
+  return {
+    exists: true,
+    hasContent: hasIdentity || hasSoul,
+    workspaceDir
+  };
+}
+function getOpenClawConfigPath(clawDir) {
+  return path.join(clawDir, "openclaw.json");
+}
+function readOpenClawConfig(clawDir) {
+  const configPath = getOpenClawConfigPath(clawDir);
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeOpenClawConfig(clawDir, config) {
+  const configPath = getOpenClawConfigPath(clawDir);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function updateOpenClawConfig(clawDir, updater) {
+  const config = readOpenClawConfig(clawDir);
+  if (!config) {
+    return false;
+  }
+  const updated = updater(config);
+  writeOpenClawConfig(clawDir, updated);
+  return true;
+}
+function configureMultiAgentCommunication(clawDir, dispatcherId, workerIds) {
+  return updateOpenClawConfig(clawDir, (config) => {
+    if (!config.agents) config.agents = {};
+    if (!config.agents.list) config.agents.list = [];
+    const dispatcherAgent = config.agents.list.find((a) => a.id === dispatcherId);
+    if (dispatcherAgent) {
+      dispatcherAgent.subagents = {
+        ...dispatcherAgent.subagents,
+        allowAgents: workerIds
+      };
+    }
+    if (!config.tools) config.tools = {};
+    config.tools.sessions = {
+      ...config.tools.sessions,
+      visibility: "all"
+    };
+    const allAgentIds = [dispatcherId, ...workerIds];
+    config.tools.agentToAgent = {
+      enabled: true,
+      allow: allAgentIds
+    };
+    return config;
+  });
+}
+function addAgentToOpenClawConfig(clawDir, agentId, agentName, isMain) {
+  return updateOpenClawConfig(clawDir, (config) => {
+    if (!config.agents) config.agents = {};
+    if (!config.agents.list) config.agents.list = [];
+    const existing = config.agents.list.find((a) => a.id === agentId);
+    if (existing) {
+      existing.name = agentName;
+      return config;
+    }
+    if (isMain) {
+      config.agents.list.push({
+        id: agentId,
+        name: agentName
+      });
+    } else {
+      config.agents.list.push({
+        id: agentId,
+        name: agentName,
+        workspace: path.join(clawDir, `workspace-${agentId}`),
+        agentDir: path.join(clawDir, `agents/${agentId}/agent`)
+      });
+    }
+    return config;
+  });
+}
+function readSoulHubPackage(dir) {
+  const yamlPath = path.join(dir, "soulhub.yaml");
+  if (!fs.existsSync(yamlPath)) {
+    return null;
+  }
+  try {
+    return yaml.load(fs.readFileSync(yamlPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function detectPackageKind(dir) {
+  const pkg = readSoulHubPackage(dir);
+  if (pkg) {
+    return pkg.kind;
+  }
+  if (fs.existsSync(path.join(dir, "IDENTITY.md"))) {
+    return "agent";
+  }
+  return "unknown";
+}
+function checkOpenClawInstalled(customDir) {
+  const clawDir = findOpenClawDir(customDir);
+  if (clawDir) {
+    return {
+      installed: true,
+      clawDir,
+      message: `OpenClaw detected at: ${clawDir}`
+    };
+  }
+  try {
+    execSync("which openclaw 2>/dev/null || where openclaw 2>nul", {
+      stdio: "pipe"
+    });
+    return {
+      installed: true,
+      clawDir: null,
+      message: "OpenClaw command found in PATH, but workspace directory not detected."
+    };
+  } catch {
+  }
+  return {
+    installed: false,
+    clawDir: null,
+    message: "OpenClaw is not installed. Please install OpenClaw first, use --claw-dir to specify OpenClaw directory, or set OPENCLAW_HOME environment variable."
+  };
+}
+function backupAgentWorkspace(workspaceDir) {
+  if (!fs.existsSync(workspaceDir)) {
+    return null;
+  }
+  const entries = fs.readdirSync(workspaceDir);
+  if (entries.length === 0) {
+    return null;
+  }
+  const clawDir = path.dirname(workspaceDir);
+  const backupBaseDir = path.join(clawDir, "agentbackup");
+  if (!fs.existsSync(backupBaseDir)) {
+    fs.mkdirSync(backupBaseDir, { recursive: true });
+  }
+  const dirName = path.basename(workspaceDir);
+  let backupDir = path.join(backupBaseDir, dirName);
+  if (fs.existsSync(backupDir)) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    backupDir = path.join(backupBaseDir, `${dirName}-${timestamp}`);
+  }
+  fs.cpSync(workspaceDir, backupDir, { recursive: true });
+  return backupDir;
+}
+var CATEGORY_LABELS = {
+  "self-media": "Self Media",
+  development: "Development",
+  operations: "Operations",
+  support: "Support",
+  education: "Education",
+  dispatcher: "Dispatcher"
+};
+function registerAgentToOpenClaw(agentName, workspaceDir, _clawDir) {
+  const agentId = agentName.toLowerCase().replace(/[\s_]+/g, "-");
+  try {
+    execSync(
+      `openclaw agents add "${agentId}" --workspace "${workspaceDir}" --non-interactive --json`,
+      { stdio: "pipe", timeout: 15e3 }
+    );
+    return {
+      success: true,
+      message: `Agent "${agentId}" registered via OpenClaw CLI.`
+    };
+  } catch (cliError) {
+    const stderr = cliError && typeof cliError === "object" && "stderr" in cliError ? String(cliError.stderr) : "";
+    if (stderr.includes("already exists")) {
+      return {
+        success: true,
+        message: `Agent "${agentId}" already registered in OpenClaw.`
+      };
+    }
+    const isCommandNotFound = cliError && typeof cliError === "object" && "code" in cliError && cliError.code === "ENOENT" || stderr.includes("not found") || stderr.includes("not recognized");
+    if (isCommandNotFound) {
+      return {
+        success: false,
+        message: "OpenClaw CLI not found. Please install OpenClaw first: https://github.com/anthropics/openclaw"
+      };
+    }
+    const errMsg = cliError instanceof Error ? cliError.message : String(cliError);
+    return {
+      success: false,
+      message: `openclaw agents add failed: ${stderr || errMsg}`
+    };
+  }
+}
+function restartOpenClawGateway() {
+  try {
+    execSync("openclaw gateway restart", {
+      stdio: "pipe",
+      timeout: 3e4
+      // 30 秒超时
+    });
+    return {
+      success: true,
+      message: "OpenClaw Gateway restarted successfully."
+    };
+  } catch (error) {
+    const stderr = error && typeof error === "object" && "stderr" in error ? String(error.stderr).trim() : "";
+    const errMsg = stderr || (error instanceof Error ? error.message : String(error));
+    return {
+      success: false,
+      message: errMsg
+    };
+  }
+}
+
+// src/commands/search.ts
+var searchCommand = new Command("search").description("Search for agent templates in the SoulHub registry").argument("[query]", "Search query (matches name, description, tags)").option("-c, --category <category>", "Filter by category").option("-l, --limit <number>", "Max results to show", "20").action(async (query, options) => {
+  try {
+    const index = await fetchIndex();
+    let agents = index.agents;
+    if (options.category) {
+      agents = agents.filter(
+        (a) => a.category === options.category
+      );
+    }
+    if (query) {
+      const q = query.toLowerCase();
+      agents = agents.filter(
+        (a) => a.name.toLowerCase().includes(q) || a.displayName.toLowerCase().includes(q) || a.description.toLowerCase().includes(q) || a.tags.some((t) => t.toLowerCase().includes(q))
+      );
+    }
+    const limit = parseInt(options.limit, 10);
+    const shown = agents.slice(0, limit);
+    if (shown.length === 0) {
+      console.log(chalk.yellow("No agents found matching your query."));
+      if (query) {
+        console.log(
+          chalk.dim(`  Try: soulhub search (without query to list all)`)
+        );
+      }
+      return;
+    }
+    console.log(
+      chalk.bold(`
+  Found ${agents.length} agent(s):
+`)
+    );
+    for (const agent of shown) {
+      const category = CATEGORY_LABELS[agent.category] || agent.category;
+      console.log(
+        `  ${chalk.cyan.bold(agent.name)} ${chalk.dim(`v${agent.version}`)}`
+      );
+      console.log(
+        `  ${agent.displayName} - ${agent.description}`
+      );
+      console.log(
+        `  ${chalk.dim(`[${category}]`)} ${chalk.dim(agent.tags.join(", "))}`
+      );
+      console.log();
+    }
+    if (agents.length > limit) {
+      console.log(
+        chalk.dim(
+          `  ... and ${agents.length - limit} more. Use --limit to show more.`
+        )
+      );
+    }
+    console.log(
+      chalk.dim(`  Install: soulhub install <name>`)
+    );
+    console.log();
+  } catch (error) {
+    console.error(
+      chalk.red(`Error: ${error instanceof Error ? error.message : error}`)
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/info.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+var infoCommand = new Command2("info").description("View detailed information about an agent template").argument("<name>", "Agent name").option("--identity", "Show IDENTITY.md content").option("--soul", "Show SOUL.md content").action(async (name, options) => {
+  try {
+    const index = await fetchIndex();
+    const agent = index.agents.find((a) => a.name === name);
+    if (!agent) {
+      console.error(chalk2.red(`Agent "${name}" not found.`));
+      console.log(
+        chalk2.dim(`  Use 'soulhub search' to find available agents.`)
+      );
+      process.exit(1);
+    }
+    const category = CATEGORY_LABELS[agent.category] || agent.category;
+    console.log();
+    console.log(chalk2.bold.cyan(`  ${agent.displayName}`));
+    console.log(chalk2.dim(`  ${agent.name} v${agent.version}`));
+    console.log();
+    console.log(`  ${agent.description}`);
+    console.log();
+    console.log(
+      `  ${chalk2.dim("Category:")}  ${category}`
+    );
+    console.log(
+      `  ${chalk2.dim("Author:")}    ${agent.author}`
+    );
+    console.log(
+      `  ${chalk2.dim("Tags:")}      ${agent.tags.join(", ")}`
+    );
+    console.log(
+      `  ${chalk2.dim("Min Claw:")}  ${agent.minClawVersion}`
+    );
+    console.log(
+      `  ${chalk2.dim("Downloads:")} ${agent.downloads}`
+    );
+    console.log();
+    console.log(chalk2.dim("  Files:"));
+    for (const [fileName, size] of Object.entries(agent.files)) {
+      const sizeStr = size > 1024 ? `${(size / 1024).toFixed(1)} KB` : `${size} B`;
+      console.log(`    ${fileName} ${chalk2.dim(`(${sizeStr})`)}`);
+    }
+    if (options.identity) {
+      console.log();
+      console.log(chalk2.bold("  \u2500\u2500 IDENTITY.md \u2500\u2500"));
+      console.log();
+      const content = await fetchAgentFile(name, "IDENTITY.md");
+      console.log(
+        content.split("\n").map((l) => `  ${l}`).join("\n")
+      );
+    }
+    if (options.soul) {
+      console.log();
+      console.log(chalk2.bold("  \u2500\u2500 SOUL.md \u2500\u2500"));
+      console.log();
+      const content = await fetchAgentFile(name, "SOUL.md");
+      console.log(
+        content.split("\n").map((l) => `  ${l}`).join("\n")
+      );
+    }
+    console.log();
+    console.log(
+      chalk2.dim(`  Install: soulhub install ${name}`)
+    );
+    console.log();
+  } catch (error) {
+    console.error(
+      chalk2.red(`Error: ${error instanceof Error ? error.message : error}`)
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/install.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+import ora from "ora";
+import fs2 from "fs";
+import path2 from "path";
+import yaml2 from "js-yaml";
+var installCommand = new Command3("install").description("Install an agent or team from the SoulHub registry").argument("[name]", "Agent or team name to install").option("--from <source>", "Install from a local directory, ZIP file, or URL").option(
+  "--dir <path>",
+  "Target directory (defaults to OpenClaw workspace)"
+).option(
+  "--claw-dir <path>",
+  "OpenClaw installation directory (overrides OPENCLAW_HOME env var, defaults to ~/.openclaw)"
+).action(async (name, options) => {
+  try {
+    if (options.from) {
+      await installFromSource(options.from, options.dir, options.clawDir);
+    } else if (name) {
+      await installFromRegistry(name, options.dir, options.clawDir);
+    } else {
+      console.error(chalk3.red("Please specify an agent or team name, or use --from to install from a local source."));
+      console.log(chalk3.dim("  Examples:"));
+      console.log(chalk3.dim("    soulhub install writer-wechat          # \u4ECE registry \u5B89\u88C5\u5355 agent"));
+      console.log(chalk3.dim("    soulhub install dev-squad              # \u4ECE registry \u5B89\u88C5\u56E2\u961F"));
+      console.log(chalk3.dim("    soulhub install --from ./agent-team/   # \u4ECE\u672C\u5730\u76EE\u5F55\u5B89\u88C5"));
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(
+      chalk3.red(`Error: ${error instanceof Error ? error.message : error}`)
+    );
+    process.exit(1);
+  }
+});
+async function installFromRegistry(name, targetDir, clawDir) {
+  const spinner = ora(`Checking registry for ${chalk3.cyan(name)}...`).start();
+  const index = await fetchIndex();
+  const agent = index.agents.find((a) => a.name === name);
+  const recipe = index.recipes.find((r) => r.name === name);
+  if (agent && !recipe) {
+    spinner.stop();
+    await installSingleAgent(name, targetDir, clawDir);
+  } else if (recipe) {
+    spinner.stop();
+    await installRecipeFromRegistry(name, recipe, targetDir, clawDir);
+  } else {
+    spinner.fail(`"${name}" not found in registry.`);
+    console.log(chalk3.dim("  Use 'soulhub search' to find available agents and teams."));
+  }
+}
+async function installSingleAgent(name, targetDir, clawDir) {
+  const spinner = ora(`Checking environment...`).start();
+  if (!targetDir) {
+    const clawCheck = checkOpenClawInstalled(clawDir);
+    if (!clawCheck.installed) {
+      spinner.fail("OpenClaw is not installed.");
+      printOpenClawInstallHelp();
+      return;
+    }
+    spinner.text = chalk3.dim(`OpenClaw detected: ${clawCheck.clawDir || "via PATH"}`);
+  }
+  spinner.text = `Fetching agent ${chalk3.cyan(name)}...`;
+  const index = await fetchIndex();
+  const agent = index.agents.find((a) => a.name === name);
+  if (!agent) {
+    spinner.fail(`Agent "${name}" not found in registry.`);
+    console.log(chalk3.dim("  Use 'soulhub search' to find available agents."));
+    return;
+  }
+  let workspaceDir;
+  if (targetDir) {
+    workspaceDir = path2.resolve(targetDir);
+  } else {
+    const resolvedClawDir = findOpenClawDir(clawDir);
+    if (!resolvedClawDir) {
+      spinner.fail("OpenClaw workspace directory not found.");
+      printOpenClawInstallHelp();
+      return;
+    }
+    workspaceDir = getMainWorkspaceDir(resolvedClawDir);
+  }
+  if (!targetDir) {
+    const resolvedClawDir = findOpenClawDir(clawDir);
+    const mainCheck = checkMainAgentExists(resolvedClawDir);
+    if (mainCheck.hasContent) {
+      spinner.warn(
+        `Existing main agent detected. Backing up workspace...`
+      );
+      const backupDir = backupAgentWorkspace(workspaceDir);
+      if (backupDir) {
+        console.log(chalk3.yellow(`  \u26A0 Existing main agent backed up to: ${backupDir}`));
+      }
+    }
+  } else {
+    const backupDir = backupAgentWorkspace(workspaceDir);
+    if (backupDir) {
+      console.log(chalk3.yellow(`  \u26A0 Existing agent backed up to: ${backupDir}`));
+    }
+  }
+  if (!fs2.existsSync(workspaceDir)) {
+    fs2.mkdirSync(workspaceDir, { recursive: true });
+  }
+  if (!targetDir) {
+    spinner.text = `Registering ${chalk3.cyan(agent.displayName)} as main agent...`;
+    const resolvedClawDir = findOpenClawDir(clawDir);
+    addAgentToOpenClawConfig(resolvedClawDir, "main", name, true);
+    spinner.text = chalk3.dim(`Main agent registered in openclaw.json`);
+  }
+  spinner.text = `Downloading ${chalk3.cyan(agent.displayName)} soul files...`;
+  await downloadAgentFiles(name, workspaceDir, spinner);
+  await saveAgentManifest(name, agent, workspaceDir);
+  recordInstall(name, agent.version, workspaceDir);
+  spinner.succeed(
+    `${chalk3.cyan.bold(agent.displayName)} installed as main agent!`
+  );
+  console.log();
+  console.log(`  ${chalk3.dim("Location:")} ${workspaceDir}`);
+  console.log(`  ${chalk3.dim("Version:")}  ${agent.version}`);
+  console.log(`  ${chalk3.dim("Type:")}     ${chalk3.blue("Single Agent (Main)")}`);
+  if (!targetDir) {
+    await tryRestartGateway();
+  }
+  console.log();
+}
+async function installRecipeFromRegistry(name, recipe, targetDir, clawDir) {
+  const spinner = ora(`Installing team ${chalk3.cyan(recipe.displayName)}...`).start();
+  if (!targetDir) {
+    const clawCheck = checkOpenClawInstalled(clawDir);
+    if (!clawCheck.installed) {
+      spinner.fail("OpenClaw is not installed.");
+      printOpenClawInstallHelp();
+      return;
+    }
+  }
+  const resolvedClawDir = targetDir ? path2.resolve(targetDir) : findOpenClawDir(clawDir);
+  if (!resolvedClawDir) {
+    spinner.fail("OpenClaw workspace directory not found.");
+    printOpenClawInstallHelp();
+    return;
+  }
+  spinner.text = `Fetching team configuration...`;
+  let pkg;
+  try {
+    const soulhubYamlContent = await fetchRecipeFile(name, "soulhub.yaml");
+    pkg = yaml2.load(soulhubYamlContent);
+  } catch {
+    spinner.fail(`Failed to fetch soulhub.yaml for recipe "${name}". Recipe packages must include a soulhub.yaml file.`);
+    return;
+  }
+  if (pkg.dispatcher) {
+    spinner.text = `Installing dispatcher ${chalk3.blue(pkg.dispatcher.name)}...`;
+    await installDispatcher(pkg.dispatcher, resolvedClawDir, clawDir, targetDir, spinner);
+  }
+  const index = await fetchIndex();
+  const workerIds = [];
+  for (const worker of pkg.agents || []) {
+    spinner.text = `Installing worker ${chalk3.cyan(worker.name)}...`;
+    const agentName = worker.dir || worker.name;
+    const agentId = worker.name;
+    const workerDir = targetDir ? path2.join(resolvedClawDir, `workspace-${agentId}`) : getWorkspaceDir(resolvedClawDir, agentId);
+    const backupDir = backupAgentWorkspace(workerDir);
+    if (backupDir) {
+      console.log(chalk3.yellow(`  \u26A0 Existing ${agentId} backed up to: ${backupDir}`));
+    }
+    if (!targetDir) {
+      const regResult = registerAgentToOpenClaw(agentId, workerDir, clawDir);
+      if (!regResult.success) {
+        console.log(chalk3.yellow(`  \u26A0 Failed to register ${agentId}: ${regResult.message}`));
+        continue;
+      }
+    } else {
+      fs2.mkdirSync(workerDir, { recursive: true });
+    }
+    await downloadAgentFiles(agentName, workerDir, spinner);
+    const agentInfo = index.agents.find((a) => a.name === agentName);
+    if (agentInfo) {
+      await saveAgentManifest(agentName, agentInfo, workerDir);
+    }
+    recordInstall(agentId, recipe.version || "1.0.0", workerDir);
+    workerIds.push(agentId);
+  }
+  if (!targetDir) {
+    spinner.text = "Configuring multi-agent communication...";
+    const dispatcherId = "main";
+    configureMultiAgentCommunication(resolvedClawDir, dispatcherId, workerIds);
+  }
+  spinner.succeed(
+    `Team ${chalk3.cyan.bold(recipe.displayName)} installed! (1 dispatcher + ${workerIds.length} workers)`
+  );
+  printTeamSummary(pkg, workerIds);
+  if (!targetDir) {
+    await tryRestartGateway();
+  }
+}
+async function installFromSource(source, targetDir, clawDir) {
+  const spinner = ora("Analyzing package...").start();
+  let packageDir;
+  let tempDir = null;
+  if (source.startsWith("http://") || source.startsWith("https://")) {
+    spinner.text = "Downloading package...";
+    const response = await fetch(source);
+    if (!response.ok) {
+      spinner.fail(`Failed to download: ${response.statusText}`);
+      return;
+    }
+    const contentType = response.headers.get("content-type") || "";
+    if (contentType.includes("zip") || source.endsWith(".zip")) {
+      const JSZip = (await import("jszip")).default;
+      const arrayBuffer = await response.arrayBuffer();
+      const zip = await JSZip.loadAsync(arrayBuffer);
+      tempDir = path2.join(process.env.HOME || "/tmp", ".soulhub", "tmp", `pkg-${Date.now()}`);
+      fs2.mkdirSync(tempDir, { recursive: true });
+      await extractZipToDir(zip, tempDir);
+      packageDir = tempDir;
+    } else {
+      spinner.fail("Unsupported URL content type. Expected ZIP file.");
+      return;
+    }
+  } else if (source.endsWith(".zip")) {
+    spinner.text = "Extracting ZIP file...";
+    const JSZip = (await import("jszip")).default;
+    const zipData = fs2.readFileSync(path2.resolve(source));
+    const zip = await JSZip.loadAsync(zipData);
+    tempDir = path2.join(process.env.HOME || "/tmp", ".soulhub", "tmp", `pkg-${Date.now()}`);
+    fs2.mkdirSync(tempDir, { recursive: true });
+    await extractZipToDir(zip, tempDir);
+    packageDir = tempDir;
+  } else {
+    packageDir = path2.resolve(source);
+    if (!fs2.existsSync(packageDir)) {
+      spinner.fail(`Directory not found: ${packageDir}`);
+      return;
+    }
+  }
+  const kind = detectPackageKind(packageDir);
+  spinner.text = `Detected package type: ${chalk3.blue(kind)}`;
+  if (kind === "agent") {
+    spinner.stop();
+    await installSingleAgentFromDir(packageDir, targetDir, clawDir);
+  } else if (kind === "team") {
+    spinner.stop();
+    await installTeamFromDir(packageDir, targetDir, clawDir);
+  } else {
+    spinner.fail("Cannot determine package type. Expected soulhub.yaml or IDENTITY.md.");
+  }
+  if (tempDir && fs2.existsSync(tempDir)) {
+    fs2.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+async function installSingleAgentFromDir(packageDir, targetDir, clawDir) {
+  const spinner = ora("Installing single agent...").start();
+  const pkg = readSoulHubPackage(packageDir);
+  const agentName = pkg?.name || path2.basename(packageDir);
+  if (!targetDir) {
+    const clawCheck = checkOpenClawInstalled(clawDir);
+    if (!clawCheck.installed) {
+      spinner.fail("OpenClaw is not installed.");
+      printOpenClawInstallHelp();
+      return;
+    }
+  }
+  let workspaceDir;
+  if (targetDir) {
+    workspaceDir = path2.resolve(targetDir);
+  } else {
+    const resolvedClawDir = findOpenClawDir(clawDir);
+    if (!resolvedClawDir) {
+      spinner.fail("OpenClaw workspace directory not found.");
+      return;
+    }
+    workspaceDir = getMainWorkspaceDir(resolvedClawDir);
+  }
+  if (!targetDir) {
+    const resolvedClawDir = findOpenClawDir(clawDir);
+    const mainCheck = checkMainAgentExists(resolvedClawDir);
+    if (mainCheck.hasContent) {
+      spinner.warn("Existing main agent detected. Backing up...");
+      const backupDir = backupAgentWorkspace(workspaceDir);
+      if (backupDir) {
+        console.log(chalk3.yellow(`  \u26A0 Existing main agent backed up to: ${backupDir}`));
+      }
+    }
+  }
+  if (!fs2.existsSync(workspaceDir)) {
+    fs2.mkdirSync(workspaceDir, { recursive: true });
+  }
+  if (!targetDir) {
+    spinner.text = `Registering ${chalk3.cyan(agentName)} as main agent...`;
+    const resolvedClawDir = findOpenClawDir(clawDir);
+    addAgentToOpenClawConfig(resolvedClawDir, "main", agentName, true);
+  }
+  spinner.text = `Copying soul files...`;
+  copyAgentFilesFromDir(packageDir, workspaceDir);
+  recordInstall(agentName, pkg?.version || "local", workspaceDir);
+  spinner.succeed(`${chalk3.cyan.bold(agentName)} installed as main agent!`);
+  console.log();
+  console.log(`  ${chalk3.dim("Location:")} ${workspaceDir}`);
+  console.log(`  ${chalk3.dim("Source:")}   ${packageDir}`);
+  console.log(`  ${chalk3.dim("Type:")}     ${chalk3.blue("Single Agent (Main)")}`);
+  if (!targetDir) {
+    await tryRestartGateway();
+  }
+  console.log();
+}
+async function installTeamFromDir(packageDir, targetDir, clawDir) {
+  const spinner = ora("Installing team...").start();
+  const pkg = readSoulHubPackage(packageDir);
+  if (!pkg || pkg.kind !== "team") {
+    spinner.fail("Invalid team package. Missing soulhub.yaml.");
+    return;
+  }
+  if (!targetDir) {
+    const clawCheck = checkOpenClawInstalled(clawDir);
+    if (!clawCheck.installed) {
+      spinner.fail("OpenClaw is not installed.");
+      printOpenClawInstallHelp();
+      return;
+    }
+  }
+  const resolvedClawDir = targetDir ? path2.resolve(targetDir) : findOpenClawDir(clawDir);
+  if (!resolvedClawDir) {
+    spinner.fail("OpenClaw workspace directory not found.");
+    return;
+  }
+  if (pkg.dispatcher) {
+    spinner.text = `Installing dispatcher ${chalk3.blue(pkg.dispatcher.name)}...`;
+    const mainWorkspace = targetDir ? path2.join(resolvedClawDir, "workspace") : getMainWorkspaceDir(resolvedClawDir);
+    if (!targetDir) {
+      const mainCheck = checkMainAgentExists(resolvedClawDir);
+      if (mainCheck.hasContent) {
+        spinner.warn("Existing main agent detected. Backing up...");
+        const backupDir = backupAgentWorkspace(mainWorkspace);
+        if (backupDir) {
+          console.log(chalk3.yellow(`  \u26A0 Existing main agent backed up to: ${backupDir}`));
+        }
+      }
+    }
+    if (!fs2.existsSync(mainWorkspace)) {
+      fs2.mkdirSync(mainWorkspace, { recursive: true });
+    }
+    if (!targetDir) {
+      addAgentToOpenClawConfig(resolvedClawDir, "main", pkg.dispatcher.name, true);
+    }
+    const dispatcherSourceDir = path2.join(packageDir, pkg.dispatcher.dir);
+    if (fs2.existsSync(dispatcherSourceDir)) {
+      copyAgentFilesFromDir(dispatcherSourceDir, mainWorkspace);
+    }
+    recordInstall("dispatcher", pkg.version || "local", mainWorkspace);
+  }
+  const workerIds = [];
+  for (const worker of pkg.agents || []) {
+    const agentId = worker.name;
+    const agentDir = worker.dir || worker.name;
+    spinner.text = `Installing worker ${chalk3.cyan(agentId)}...`;
+    const workerWorkspace = targetDir ? path2.join(resolvedClawDir, `workspace-${agentId}`) : getWorkspaceDir(resolvedClawDir, agentId);
+    const backupDir = backupAgentWorkspace(workerWorkspace);
+    if (backupDir) {
+      console.log(chalk3.yellow(`  \u26A0 Existing ${agentId} backed up to: ${backupDir}`));
+    }
+    if (!targetDir) {
+      const regResult = registerAgentToOpenClaw(agentId, workerWorkspace, clawDir);
+      if (!regResult.success) {
+        console.log(chalk3.yellow(`  \u26A0 Failed to register ${agentId}: ${regResult.message}`));
+        continue;
+      }
+    } else {
+      fs2.mkdirSync(workerWorkspace, { recursive: true });
+    }
+    const workerSourceDir = path2.join(packageDir, agentDir);
+    if (fs2.existsSync(workerSourceDir)) {
+      copyAgentFilesFromDir(workerSourceDir, workerWorkspace);
+    }
+    recordInstall(agentId, pkg.version || "local", workerWorkspace);
+    workerIds.push(agentId);
+  }
+  if (!targetDir && workerIds.length > 0) {
+    spinner.text = "Configuring multi-agent communication...";
+    configureMultiAgentCommunication(resolvedClawDir, "main", workerIds);
+  }
+  spinner.succeed(
+    `Team ${chalk3.cyan.bold(pkg.name)} installed! (${pkg.dispatcher ? "1 dispatcher + " : ""}${workerIds.length} workers)`
+  );
+  printTeamSummary(pkg, workerIds);
+  if (!targetDir) {
+    await tryRestartGateway();
+  }
+}
+async function downloadAgentFiles(agentName, workspaceDir, spinner) {
+  fs2.mkdirSync(workspaceDir, { recursive: true });
+  const coreFiles = ["IDENTITY.md", "SOUL.md"];
+  for (const fileName of coreFiles) {
+    const content = await fetchAgentFile(agentName, fileName);
+    fs2.writeFileSync(path2.join(workspaceDir, fileName), content);
+    spinner.text = `Downloaded ${fileName}`;
+  }
+  const optionalFiles = ["USER.md.template", "TOOLS.md.template"];
+  for (const fileName of optionalFiles) {
+    try {
+      const content = await fetchAgentFile(agentName, fileName);
+      const actualName = fileName.replace(".template", "");
+      fs2.writeFileSync(path2.join(workspaceDir, actualName), content);
+    } catch {
+    }
+  }
+}
+async function saveAgentManifest(agentName, agent, workspaceDir) {
+  try {
+    const manifestContent = await fetchAgentFile(agentName, "manifest.yaml");
+    fs2.writeFileSync(path2.join(workspaceDir, "manifest.yaml"), manifestContent);
+  } catch {
+    const manifest = {
+      name: agent.name,
+      displayName: agent.displayName,
+      description: agent.description,
+      category: agent.category,
+      tags: agent.tags,
+      version: agent.version,
+      author: agent.author
+    };
+    fs2.writeFileSync(path2.join(workspaceDir, "manifest.yaml"), yaml2.dump(manifest));
+  }
+}
+function copyAgentFilesFromDir(sourceDir, targetDir) {
+  const filesToCopy = ["IDENTITY.md", "SOUL.md", "USER.md", "TOOLS.md", "AGENTS.md", "HEARTBEAT.md"];
+  for (const fileName of filesToCopy) {
+    const sourcePath = path2.join(sourceDir, fileName);
+    if (fs2.existsSync(sourcePath)) {
+      fs2.mkdirSync(targetDir, { recursive: true });
+      fs2.copyFileSync(sourcePath, path2.join(targetDir, fileName));
+    }
+  }
+}
+async function installDispatcher(dispatcher, resolvedClawDir, clawDir, targetDir, spinner) {
+  const mainWorkspace = targetDir ? path2.join(resolvedClawDir, "workspace") : getMainWorkspaceDir(resolvedClawDir);
+  if (!targetDir) {
+    const mainCheck = checkMainAgentExists(resolvedClawDir);
+    if (mainCheck.hasContent) {
+      if (spinner) spinner.warn("Existing main agent detected. Backing up...");
+      const backupDir = backupAgentWorkspace(mainWorkspace);
+      if (backupDir) {
+        console.log(chalk3.yellow(`  \u26A0 Existing main agent backed up to: ${backupDir}`));
+      }
+    }
+  }
+  if (!fs2.existsSync(mainWorkspace)) {
+    fs2.mkdirSync(mainWorkspace, { recursive: true });
+  }
+  if (!targetDir) {
+    addAgentToOpenClawConfig(resolvedClawDir, "main", dispatcher.name, true);
+  }
+  const templateName = dispatcher.dir || dispatcher.name;
+  if (spinner) spinner.text = `Downloading dispatcher files...`;
+  await downloadAgentFiles(templateName, mainWorkspace, spinner || ora());
+  recordInstall("dispatcher", "1.0.0", mainWorkspace);
+}
+async function extractZipToDir(zip, targetDir) {
+  const entries = Object.entries(zip.files);
+  for (const [relativePath, file] of entries) {
+    const fullPath = path2.join(targetDir, relativePath);
+    if (file.dir) {
+      fs2.mkdirSync(fullPath, { recursive: true });
+    } else {
+      fs2.mkdirSync(path2.dirname(fullPath), { recursive: true });
+      const content = await file.async("nodebuffer");
+      fs2.writeFileSync(fullPath, content);
+    }
+  }
+}
+function printOpenClawInstallHelp() {
+  console.log(chalk3.dim("  Please install OpenClaw first, or use one of the following options:"));
+  console.log(chalk3.dim("  --claw-dir <path>    Specify OpenClaw installation directory"));
+  console.log(chalk3.dim("  --dir <path>         Specify agent target directory directly"));
+  console.log(chalk3.dim("  OPENCLAW_HOME=<path> Set environment variable"));
+  console.log(chalk3.dim("  Visit: https://github.com/anthropics/openclaw for installation instructions."));
+}
+function printTeamSummary(pkg, workerIds) {
+  console.log();
+  if (pkg.dispatcher) {
+    console.log(`  ${chalk3.blue("\u26A1 [Dispatcher]")} ${chalk3.cyan(pkg.dispatcher.name)} \u2192 ${chalk3.dim("workspace/")}`);
+  }
+  for (const id of workerIds) {
+    console.log(`  ${chalk3.dim("  \u2713 [Worker]")}    ${chalk3.cyan(id)} \u2192 ${chalk3.dim(`workspace-${id}/`)}`);
+  }
+  console.log();
+  console.log(`  ${chalk3.dim("Type:")}     ${chalk3.blue("Multi-Agent Team")}`);
+  if (pkg.routing && pkg.routing.length > 0) {
+    console.log(`  ${chalk3.dim("Routing:")}  ${pkg.routing.length} rules configured`);
+  }
+  console.log();
+}
+async function tryRestartGateway() {
+  const restartSpinner = ora("Restarting OpenClaw Gateway...").start();
+  const result = restartOpenClawGateway();
+  if (result.success) {
+    restartSpinner.succeed("OpenClaw Gateway restarted successfully.");
+  } else {
+    restartSpinner.warn("Failed to restart OpenClaw Gateway.");
+    console.log(chalk3.yellow(`  Reason: ${result.message}`));
+    console.log(chalk3.dim("  Please restart manually:"));
+    console.log(chalk3.dim("    openclaw gateway restart"));
+  }
+}
+
+// src/commands/list.ts
+import { Command as Command4 } from "commander";
+import chalk4 from "chalk";
+var listCommand = new Command4("list").description("List installed agent templates").alias("ls").action(async () => {
+  try {
+    const config = loadConfig();
+    if (config.installed.length === 0) {
+      console.log(chalk4.yellow("\n  No agents installed yet.\n"));
+      console.log(
+        chalk4.dim("  Install one: soulhub install <name>")
+      );
+      console.log(
+        chalk4.dim("  Browse all:  soulhub search\n")
+      );
+      return;
+    }
+    console.log(
+      chalk4.bold(`
+  Installed agents (${config.installed.length}):
+`)
+    );
+    for (const agent of config.installed) {
+      const date = new Date(agent.installedAt).toLocaleDateString();
+      console.log(
+        `  ${chalk4.cyan.bold(agent.name)} ${chalk4.dim(`v${agent.version}`)}`
+      );
+      console.log(
+        `  ${chalk4.dim("Installed:")} ${date}  ${chalk4.dim("Location:")} ${agent.workspace}`
+      );
+      console.log();
+    }
+  } catch (error) {
+    console.error(
+      chalk4.red(`Error: ${error instanceof Error ? error.message : error}`)
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/update.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+import ora2 from "ora";
+import fs3 from "fs";
+import path3 from "path";
+var updateCommand = new Command5("update").description("Update installed agent templates to latest versions").argument("[name]", "Agent name to update (updates all if omitted)").action(async (name) => {
+  try {
+    const config = loadConfig();
+    if (config.installed.length === 0) {
+      console.log(chalk5.yellow("\n  No agents installed.\n"));
+      return;
+    }
+    const spinner = ora2("Checking for updates...").start();
+    const index = await fetchIndex();
+    const toUpdate = name ? config.installed.filter((a) => a.name === name) : config.installed;
+    if (toUpdate.length === 0) {
+      spinner.fail(`Agent "${name}" is not installed.`);
+      return;
+    }
+    let updated = 0;
+    for (const installed of toUpdate) {
+      const remote = index.agents.find(
+        (a) => a.name === installed.name
+      );
+      if (!remote) {
+        spinner.text = `${installed.name}: not found in registry, skipping`;
+        continue;
+      }
+      if (remote.version === installed.version) {
+        continue;
+      }
+      spinner.text = `Updating ${chalk5.cyan(installed.name)} (${installed.version} \u2192 ${remote.version})...`;
+      const workspaceDir = installed.workspace;
+      if (!fs3.existsSync(workspaceDir)) {
+        fs3.mkdirSync(workspaceDir, { recursive: true });
+      }
+      for (const fileName of ["IDENTITY.md", "SOUL.md", "manifest.yaml"]) {
+        try {
+          const content = await fetchAgentFile(
+            installed.name,
+            fileName
+          );
+          fs3.writeFileSync(
+            path3.join(workspaceDir, fileName),
+            content
+          );
+        } catch {
+        }
+      }
+      installed.version = remote.version;
+      installed.installedAt = (/* @__PURE__ */ new Date()).toISOString();
+      updated++;
+    }
+    saveConfig(config);
+    if (updated === 0) {
+      spinner.succeed("All agents are up to date.");
+    } else {
+      spinner.succeed(`Updated ${updated} agent(s).`);
+    }
+    console.log();
+  } catch (error) {
+    console.error(
+      chalk5.red(`Error: ${error instanceof Error ? error.message : error}`)
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/uninstall.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+import ora3 from "ora";
+import fs4 from "fs";
+var uninstallCommand = new Command6("uninstall").description("Uninstall an agent template").alias("rm").argument("<name>", "Agent name to uninstall").option("--keep-files", "Remove from registry but keep workspace files").action(async (name, options) => {
+  try {
+    const config = loadConfig();
+    const installed = config.installed.find((a) => a.name === name);
+    if (!installed) {
+      console.error(
+        chalk6.red(`
+  Agent "${name}" is not installed.
+`)
+      );
+      console.log(
+        chalk6.dim("  Use 'soulhub list' to see installed agents.")
+      );
+      process.exit(1);
+    }
+    const spinner = ora3(
+      `Uninstalling ${chalk6.cyan(name)}...`
+    ).start();
+    if (!options.keepFiles && fs4.existsSync(installed.workspace)) {
+      fs4.rmSync(installed.workspace, { recursive: true, force: true });
+      spinner.text = `Removed workspace: ${installed.workspace}`;
+    }
+    removeInstallRecord(name);
+    spinner.succeed(
+      `${chalk6.cyan.bold(name)} uninstalled.`
+    );
+    if (options.keepFiles) {
+      console.log(
+        chalk6.dim(`  Files kept at: ${installed.workspace}`)
+      );
+    }
+    console.log();
+  } catch (error) {
+    console.error(
+      chalk6.red(`Error: ${error instanceof Error ? error.message : error}`)
+    );
+    process.exit(1);
+  }
+});
+
+// src/commands/publish.ts
+import { Command as Command7 } from "commander";
+import chalk7 from "chalk";
+import ora4 from "ora";
+import fs5 from "fs";
+import path4 from "path";
+import yaml3 from "js-yaml";
+var publishCommand = new Command7("publish").description("Publish an agent template to the SoulHub community").argument(
+  "[directory]",
+  "Agent workspace directory (defaults to current directory)"
+).action(async (directory) => {
+  try {
+    const dir = directory ? path4.resolve(directory) : process.cwd();
+    const spinner = ora4("Validating agent template...").start();
+    const requiredFiles = ["manifest.yaml", "IDENTITY.md", "SOUL.md"];
+    const missing = requiredFiles.filter(
+      (f) => !fs5.existsSync(path4.join(dir, f))
+    );
+    if (missing.length > 0) {
+      spinner.fail("Missing required files:");
+      for (const f of missing) {
+        console.log(chalk7.red(`  - ${f}`));
+      }
+      console.log();
+      console.log(chalk7.dim("  Required files: manifest.yaml, IDENTITY.md, SOUL.md"));
+      console.log(
+        chalk7.dim(
+          "  See: https://soulhub.dev/docs/contributing"
+        )
+      );
+      return;
+    }
+    const manifestContent = fs5.readFileSync(
+      path4.join(dir, "manifest.yaml"),
+      "utf-8"
+    );
+    const manifest = yaml3.load(manifestContent);
+    const requiredFields = [
+      "name",
+      "displayName",
+      "description",
+      "category",
+      "version",
+      "author"
+    ];
+    const missingFields = requiredFields.filter(
+      (f) => !manifest[f]
+    );
+    if (missingFields.length > 0) {
+      spinner.fail("Missing required fields in manifest.yaml:");
+      for (const f of missingFields) {
+        console.log(chalk7.red(`  - ${f}`));
+      }
+      return;
+    }
+    const validCategories = [
+      "self-media",
+      "development",
+      "operations",
+      "support",
+      "education",
+      "dispatcher"
+    ];
+    if (!validCategories.includes(manifest.category)) {
+      spinner.fail(
+        `Invalid category: ${manifest.category}. Must be one of: ${validCategories.join(", ")}`
+      );
+      return;
+    }
+    spinner.succeed("Template validation passed!");
+    console.log();
+    console.log(chalk7.bold(`  ${manifest.displayName}`));
+    console.log(
+      chalk7.dim(`  ${manifest.name} v${manifest.version}`)
+    );
+    console.log(`  ${manifest.description}`);
+    console.log();
+    console.log(chalk7.bold("  Next steps to publish:"));
+    console.log();
+    console.log(
+      `  1. Fork ${chalk7.cyan("github.com/soulhub-community/soulhub")}`
+    );
+    console.log(
+      `  2. Copy your agent directory to ${chalk7.cyan(`registry/agents/${manifest.name}/`)}`
+    );
+    console.log(
+      `  3. Submit a Pull Request`
+    );
+    console.log();
+    console.log(
+      chalk7.dim(
+        "  Your template will be reviewed and added to the community registry."
+      )
+    );
+    console.log();
+  } catch (error) {
+    console.error(
+      chalk7.red(`Error: ${error instanceof Error ? error.message : error}`)
+    );
+    process.exit(1);
+  }
+});
+
+// src/index.ts
+var program = new Command8();
+program.name("soulhub").description("SoulHub CLI - Install and manage AI agent persona templates").version("0.1.0");
+program.addCommand(searchCommand);
+program.addCommand(infoCommand);
+program.addCommand(installCommand);
+program.addCommand(listCommand);
+program.addCommand(updateCommand);
+program.addCommand(uninstallCommand);
+program.addCommand(publishCommand);
+program.parse();