soulhubcli 1.0.4 → 1.0.6

package/dist/index.js

@@ -8,26 +8,158 @@ import { Command } from "commander";
 import chalk from "chalk";
 
 // src/utils.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 import { execSync } from "child_process";
 import yaml from "js-yaml";
+
+// src/logger.ts
+import fs from "fs";
+import path from "path";
+var LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var LOG_RETENTION_DAYS = 7;
+var Logger = class {
+  logDir;
+  verbose = false;
+  initialized = false;
+  constructor() {
+    const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+    this.logDir = path.join(home, ".soulhub", "logs");
+  }
+  /**
+   * 初始化日志系统
+   * @param verbose 是否开启 debug 级别输出到终端
+   */
+  init(verbose = false) {
+    this.verbose = verbose;
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+    this.initialized = true;
+    this.cleanOldLogs();
+  }
+  /**
+   * 获取当前日志文件路径（按日期）
+   */
+  getLogFilePath() {
+    const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    return path.join(this.logDir, `soulhub-${date}.log`);
+  }
+  /**
+   * 格式化日志行
+   */
+  formatLine(level, message, meta) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const levelTag = level.toUpperCase().padEnd(5);
+    let line = `[${timestamp}] ${levelTag} ${message}`;
+    if (meta && Object.keys(meta).length > 0) {
+      line += ` | ${JSON.stringify(meta)}`;
+    }
+    return line;
+  }
+  /**
+   * 写入日志到文件
+   */
+  write(level, message, meta) {
+    if (!this.initialized) {
+      try {
+        this.init(this.verbose);
+      } catch {
+        return;
+      }
+    }
+    const line = this.formatLine(level, message, meta);
+    try {
+      fs.appendFileSync(this.getLogFilePath(), line + "\n");
+    } catch {
+    }
+    if (this.verbose && LEVEL_PRIORITY[level] === LEVEL_PRIORITY.debug) {
+      console.log(`  ${line}`);
+    }
+  }
+  /**
+   * 清理超过保留天数的旧日志
+   */
+  cleanOldLogs() {
+    try {
+      const files = fs.readdirSync(this.logDir);
+      const now = Date.now();
+      const maxAge = LOG_RETENTION_DAYS * 24 * 60 * 60 * 1e3;
+      for (const file of files) {
+        if (!file.startsWith("soulhub-") || !file.endsWith(".log")) continue;
+        const filePath = path.join(this.logDir, file);
+        const stat = fs.statSync(filePath);
+        if (now - stat.mtimeMs > maxAge) {
+          fs.unlinkSync(filePath);
+        }
+      }
+    } catch {
+    }
+  }
+  // ==========================================
+  // 公开的日志方法
+  // ==========================================
+  debug(message, meta) {
+    this.write("debug", message, meta);
+  }
+  info(message, meta) {
+    this.write("info", message, meta);
+  }
+  warn(message, meta) {
+    this.write("warn", message, meta);
+  }
+  error(message, meta) {
+    this.write("error", message, meta);
+  }
+  /**
+   * 记录错误对象（自动提取 message 和 stack）
+   */
+  errorObj(message, err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    const stack = err instanceof Error ? err.stack : void 0;
+    this.write("error", message, { error: errMsg, stack });
+  }
+  /**
+   * 获取日志目录路径（供用户查看）
+   */
+  getLogDir() {
+    return this.logDir;
+  }
+  /**
+   * 获取今天的日志文件路径
+   */
+  getTodayLogFile() {
+    return this.getLogFilePath();
+  }
+};
+var logger = new Logger();
+
+// src/utils.ts
 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`;
+  logger.debug(`Fetching registry index`, { url });
   const response = await fetch(url);
   if (!response.ok) {
+    logger.error(`Failed to fetch registry index`, { url, status: response.status, statusText: response.statusText });
     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}`;
+  logger.debug(`Fetching agent file`, { agentName, fileName, url });
   const response = await fetch(url);
   if (!response.ok) {
+    logger.error(`Failed to fetch agent file`, { agentName, fileName, url, status: response.status });
     throw new Error(
       `Failed to fetch ${fileName} for ${agentName}: ${response.statusText}`
     );
@@ -36,8 +168,10 @@ async function fetchAgentFile(agentName, fileName) {
 }
 async function fetchRecipeFile(recipeName, fileName) {
   const url = `${getRegistryUrl()}/recipes/${recipeName}/${fileName}`;
+  logger.debug(`Fetching recipe file`, { recipeName, fileName, url });
   const response = await fetch(url);
   if (!response.ok) {
+    logger.error(`Failed to fetch recipe file`, { recipeName, fileName, url, status: response.status });
     throw new Error(
       `Failed to fetch ${fileName} for recipe ${recipeName}: ${response.statusText}`
     );
@@ -46,26 +180,26 @@ async function fetchRecipeFile(recipeName, fileName) {
 }
 function findOpenClawDir(customDir) {
   if (customDir) {
-    const resolved = path.resolve(customDir);
-    if (fs.existsSync(resolved)) {
+    const resolved = path2.resolve(customDir);
+    if (fs2.existsSync(resolved)) {
       return resolved;
     }
     return resolved;
   }
   const envHome = process.env.OPENCLAW_HOME;
   if (envHome) {
-    const resolved = path.resolve(envHome);
-    if (fs.existsSync(resolved)) {
+    const resolved = path2.resolve(envHome);
+    if (fs2.existsSync(resolved)) {
       return resolved;
     }
     return resolved;
   }
   const candidates = [
-    path.join(process.env.HOME || "~", ".openclaw"),
-    path.join(process.cwd(), ".openclaw")
+    path2.join(process.env.HOME || "~", ".openclaw"),
+    path2.join(process.cwd(), ".openclaw")
   ];
   for (const candidate of candidates) {
-    if (fs.existsSync(candidate)) {
+    if (fs2.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -73,12 +207,12 @@ function findOpenClawDir(customDir) {
 }
 function getConfigPath() {
   const home = process.env.HOME || "~";
-  return path.join(home, ".soulhub", "config.json");
+  return path2.join(home, ".soulhub", "config.json");
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (fs.existsSync(configPath)) {
-    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  if (fs2.existsSync(configPath)) {
+    return JSON.parse(fs2.readFileSync(configPath, "utf-8"));
   }
   return {
     installed: [],
@@ -87,11 +221,11 @@ function loadConfig() {
 }
 function saveConfig(config) {
   const configPath = getConfigPath();
-  const configDir = path.dirname(configPath);
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
+  const configDir = path2.dirname(configPath);
+  if (!fs2.existsSync(configDir)) {
+    fs2.mkdirSync(configDir, { recursive: true });
   }
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
 function recordInstall(name, version, workspace) {
   const config = loadConfig();
@@ -103,6 +237,7 @@ function recordInstall(name, version, workspace) {
     workspace
   });
   saveConfig(config);
+  logger.debug(`Recorded install`, { name, version, workspace });
 }
 function removeInstallRecord(name) {
   const config = loadConfig();
@@ -110,17 +245,17 @@ function removeInstallRecord(name) {
   saveConfig(config);
 }
 function getWorkspaceDir(clawDir, agentName) {
-  return path.join(clawDir, `workspace-${agentName}`);
+  return path2.join(clawDir, `workspace-${agentName}`);
 }
 function getMainWorkspaceDir(clawDir) {
-  return path.join(clawDir, "workspace");
+  return path2.join(clawDir, "workspace");
 }
 function checkMainAgentExists(clawDir) {
   const workspaceDir = getMainWorkspaceDir(clawDir);
-  if (!fs.existsSync(workspaceDir)) {
+  if (!fs2.existsSync(workspaceDir)) {
     return { exists: false, hasContent: false, workspaceDir };
   }
-  const entries = fs.readdirSync(workspaceDir);
+  const entries = fs2.readdirSync(workspaceDir);
   const hasIdentity = entries.includes("IDENTITY.md");
   const hasSoul = entries.includes("SOUL.md");
   return {
@@ -130,22 +265,22 @@ function checkMainAgentExists(clawDir) {
   };
 }
 function getOpenClawConfigPath(clawDir) {
-  return path.join(clawDir, "openclaw.json");
+  return path2.join(clawDir, "openclaw.json");
 }
 function readOpenClawConfig(clawDir) {
   const configPath = getOpenClawConfigPath(clawDir);
-  if (!fs.existsSync(configPath)) {
+  if (!fs2.existsSync(configPath)) {
     return null;
   }
   try {
-    return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return JSON.parse(fs2.readFileSync(configPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeOpenClawConfig(clawDir, config) {
   const configPath = getOpenClawConfigPath(clawDir);
-  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+  fs2.writeFileSync(configPath, JSON.stringify(config, null, 2));
 }
 function updateOpenClawConfig(clawDir, updater) {
   const config = readOpenClawConfig(clawDir);
@@ -198,20 +333,20 @@ function addAgentToOpenClawConfig(clawDir, agentId, agentName, isMain) {
       config.agents.list.push({
         id: agentId,
         name: agentName,
-        workspace: path.join(clawDir, `workspace-${agentId}`),
-        agentDir: path.join(clawDir, `agents/${agentId}/agent`)
+        workspace: path2.join(clawDir, `workspace-${agentId}`),
+        agentDir: path2.join(clawDir, `agents/${agentId}/agent`)
       });
     }
     return config;
   });
 }
 function readSoulHubPackage(dir) {
-  const yamlPath = path.join(dir, "soulhub.yaml");
-  if (!fs.existsSync(yamlPath)) {
+  const yamlPath = path2.join(dir, "soulhub.yaml");
+  if (!fs2.existsSync(yamlPath)) {
     return null;
   }
   try {
-    return yaml.load(fs.readFileSync(yamlPath, "utf-8"));
+    return yaml.load(fs2.readFileSync(yamlPath, "utf-8"));
   } catch {
     return null;
   }
@@ -221,7 +356,7 @@ function detectPackageKind(dir) {
   if (pkg) {
     return pkg.kind;
   }
-  if (fs.existsSync(path.join(dir, "IDENTITY.md"))) {
+  if (fs2.existsSync(path2.join(dir, "IDENTITY.md"))) {
     return "agent";
   }
   return "unknown";
@@ -253,27 +388,136 @@ function checkOpenClawInstalled(customDir) {
   };
 }
 function backupAgentWorkspace(workspaceDir) {
-  if (!fs.existsSync(workspaceDir)) {
+  if (!fs2.existsSync(workspaceDir)) {
+    return null;
+  }
+  const entries = fs2.readdirSync(workspaceDir);
+  if (entries.length === 0) {
+    return null;
+  }
+  const clawDir = path2.dirname(workspaceDir);
+  const backupBaseDir = path2.join(clawDir, "agentbackup");
+  if (!fs2.existsSync(backupBaseDir)) {
+    fs2.mkdirSync(backupBaseDir, { recursive: true });
+  }
+  const dirName = path2.basename(workspaceDir);
+  let backupDir = path2.join(backupBaseDir, dirName);
+  if (fs2.existsSync(backupDir)) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    backupDir = path2.join(backupBaseDir, `${dirName}-${timestamp}`);
+  }
+  fs2.cpSync(workspaceDir, backupDir, { recursive: true });
+  logger.info(`Workspace backed up`, { from: workspaceDir, to: backupDir });
+  return backupDir;
+}
+function moveBackupAgentWorkspace(workspaceDir) {
+  if (!fs2.existsSync(workspaceDir)) {
     return null;
   }
-  const entries = fs.readdirSync(workspaceDir);
+  const entries = fs2.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 clawDir = path2.dirname(workspaceDir);
+  const backupBaseDir = path2.join(clawDir, "agentbackup");
+  if (!fs2.existsSync(backupBaseDir)) {
+    fs2.mkdirSync(backupBaseDir, { recursive: true });
   }
-  const dirName = path.basename(workspaceDir);
-  let backupDir = path.join(backupBaseDir, dirName);
-  if (fs.existsSync(backupDir)) {
+  const dirName = path2.basename(workspaceDir);
+  let backupDir = path2.join(backupBaseDir, dirName);
+  if (fs2.existsSync(backupDir)) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-    backupDir = path.join(backupBaseDir, `${dirName}-${timestamp}`);
+    backupDir = path2.join(backupBaseDir, `${dirName}-${timestamp}`);
   }
-  fs.cpSync(workspaceDir, backupDir, { recursive: true });
+  fs2.renameSync(workspaceDir, backupDir);
+  logger.info(`Workspace moved to backup`, { from: workspaceDir, to: backupDir });
   return backupDir;
 }
+function backupAllWorkerWorkspaces(clawDir) {
+  const results = [];
+  const workerDirs = listAgentWorkspaces(clawDir);
+  for (const dirName of workerDirs) {
+    const fullPath = path2.join(clawDir, dirName);
+    const backupDir = moveBackupAgentWorkspace(fullPath);
+    if (backupDir) {
+      results.push({ name: dirName, backupDir });
+    }
+  }
+  return results;
+}
+function listAgentWorkspaces(clawDir) {
+  if (!fs2.existsSync(clawDir)) {
+    return [];
+  }
+  return fs2.readdirSync(clawDir).filter((entry) => {
+    const fullPath = path2.join(clawDir, entry);
+    return fs2.statSync(fullPath).isDirectory() && entry.startsWith("workspace-");
+  });
+}
+function getBackupManifestPath() {
+  const home = process.env.HOME || "~";
+  return path2.join(home, ".soulhub", "backups.json");
+}
+function loadBackupManifest() {
+  const manifestPath = getBackupManifestPath();
+  if (fs2.existsSync(manifestPath)) {
+    try {
+      return JSON.parse(fs2.readFileSync(manifestPath, "utf-8"));
+    } catch {
+      return { records: [] };
+    }
+  }
+  return { records: [] };
+}
+function saveBackupManifest(manifest) {
+  const manifestPath = getBackupManifestPath();
+  const manifestDir = path2.dirname(manifestPath);
+  if (!fs2.existsSync(manifestDir)) {
+    fs2.mkdirSync(manifestDir, { recursive: true });
+  }
+  manifest.records = manifest.records.slice(0, 50);
+  fs2.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+}
+function generateBackupId() {
+  const now = /* @__PURE__ */ new Date();
+  const ts = now.toISOString().replace(/[:.\-T]/g, "").slice(0, 14);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `${ts}-${rand}`;
+}
+function createBackupRecord(installType, packageName, clawDir) {
+  let openclawJsonSnapshot = null;
+  const configPath = path2.join(clawDir, "openclaw.json");
+  if (fs2.existsSync(configPath)) {
+    try {
+      openclawJsonSnapshot = fs2.readFileSync(configPath, "utf-8");
+    } catch {
+    }
+  }
+  return {
+    id: generateBackupId(),
+    installType,
+    packageName,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    clawDir,
+    openclawJsonSnapshot,
+    items: [],
+    installedWorkerIds: [],
+    installedMainAgent: null
+  };
+}
+function addBackupItem(record, item) {
+  record.items.push(item);
+}
+function commitBackupRecord(record) {
+  if (record.items.length === 0 && record.installedWorkerIds.length === 0 && !record.installedMainAgent) {
+    logger.debug("No backup items to record, skipping.");
+    return;
+  }
+  const manifest = loadBackupManifest();
+  manifest.records.unshift(record);
+  saveBackupManifest(manifest);
+  logger.info(`Backup record saved`, { id: record.id, items: record.items.length, workers: record.installedWorkerIds.length });
+}
 var CATEGORY_LABELS = {
   "self-media": "Self Media",
   development: "Development",
@@ -284,6 +528,7 @@ var CATEGORY_LABELS = {
 };
 function registerAgentToOpenClaw(agentName, workspaceDir, _clawDir) {
   const agentId = agentName.toLowerCase().replace(/[\s_]+/g, "-");
+  logger.debug(`Registering agent to OpenClaw`, { agentId, workspaceDir });
   try {
     execSync(
       `openclaw agents add "${agentId}" --workspace "${workspaceDir}" --non-interactive --json`,
@@ -303,12 +548,14 @@ function registerAgentToOpenClaw(agentName, workspaceDir, _clawDir) {
     }
     const isCommandNotFound = cliError && typeof cliError === "object" && "code" in cliError && cliError.code === "ENOENT" || stderr.includes("not found") || stderr.includes("not recognized");
     if (isCommandNotFound) {
+      logger.error(`OpenClaw CLI not found`);
       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);
+    logger.error(`openclaw agents add failed`, { agentId, stderr, error: errMsg });
     return {
       success: false,
       message: `openclaw agents add failed: ${stderr || errMsg}`
@@ -316,6 +563,7 @@ function registerAgentToOpenClaw(agentName, workspaceDir, _clawDir) {
   }
 }
 function restartOpenClawGateway() {
+  logger.debug(`Restarting OpenClaw Gateway`);
   try {
     execSync("openclaw gateway restart", {
       stdio: "pipe",
@@ -393,9 +641,11 @@ var searchCommand = new Command("search").description("Search for agent template
     );
     console.log();
   } catch (error) {
+    logger.errorObj("Search command failed", error);
     console.error(
       chalk.red(`Error: ${error instanceof Error ? error.message : error}`)
     );
+    console.error(chalk.dim(`  See logs: ${logger.getTodayLogFile()}`));
     process.exit(1);
   }
 });
@@ -466,9 +716,11 @@ var infoCommand = new Command2("info").description("View detailed information ab
     );
     console.log();
   } catch (error) {
+    logger.errorObj("Info command failed", error);
     console.error(
       chalk2.red(`Error: ${error instanceof Error ? error.message : error}`)
     );
+    console.error(chalk2.dim(`  See logs: ${logger.getTodayLogFile()}`));
     process.exit(1);
   }
 });
@@ -477,8 +729,8 @@ var infoCommand = new Command2("info").description("View detailed information ab
 import { Command as Command3 } from "commander";
 import chalk3 from "chalk";
 import ora from "ora";
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 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>",
@@ -501,9 +753,11 @@ var installCommand = new Command3("install").description("Install an agent or te
       process.exit(1);
     }
   } catch (error) {
+    logger.errorObj("Install command failed", error);
     console.error(
       chalk3.red(`Error: ${error instanceof Error ? error.message : error}`)
     );
+    console.error(chalk3.dim(`  See logs: ${logger.getTodayLogFile()}`));
     process.exit(1);
   }
 });
@@ -514,11 +768,14 @@ async function installFromRegistry(name, targetDir, clawDir) {
   const recipe = index.recipes.find((r) => r.name === name);
   if (agent && !recipe) {
     spinner.stop();
+    logger.info(`Installing single agent from registry: ${name}`);
     await installSingleAgent(name, targetDir, clawDir);
   } else if (recipe) {
     spinner.stop();
+    logger.info(`Installing team recipe from registry: ${name}`);
     await installRecipeFromRegistry(name, recipe, targetDir, clawDir);
   } else {
+    logger.warn(`"${name}" not found in registry`);
     spinner.fail(`"${name}" not found in registry.`);
     console.log(chalk3.dim("  Use 'soulhub search' to find available agents and teams."));
   }
@@ -544,7 +801,7 @@ async function installSingleAgent(name, targetDir, clawDir) {
   }
   let workspaceDir;
   if (targetDir) {
-    workspaceDir = path2.resolve(targetDir);
+    workspaceDir = path3.resolve(targetDir);
   } else {
     const resolvedClawDir = findOpenClawDir(clawDir);
     if (!resolvedClawDir) {
@@ -554,9 +811,10 @@ async function installSingleAgent(name, targetDir, clawDir) {
     }
     workspaceDir = getMainWorkspaceDir(resolvedClawDir);
   }
+  const resolvedClawDirForBackup = findOpenClawDir(clawDir);
+  const backupRecord = !targetDir ? createBackupRecord("single-agent", name, resolvedClawDirForBackup) : null;
   if (!targetDir) {
-    const resolvedClawDir = findOpenClawDir(clawDir);
-    const mainCheck = checkMainAgentExists(resolvedClawDir);
+    const mainCheck = checkMainAgentExists(resolvedClawDirForBackup);
     if (mainCheck.hasContent) {
       spinner.warn(
         `Existing main agent detected. Backing up workspace...`
@@ -564,6 +822,13 @@ async function installSingleAgent(name, targetDir, clawDir) {
       const backupDir = backupAgentWorkspace(workspaceDir);
       if (backupDir) {
         console.log(chalk3.yellow(`  \u26A0 Existing main agent backed up to: ${backupDir}`));
+        addBackupItem(backupRecord, {
+          originalPath: workspaceDir,
+          backupPath: backupDir,
+          method: "cp",
+          role: "main",
+          agentId: "main"
+        });
       }
     }
   } else {
@@ -572,8 +837,8 @@ async function installSingleAgent(name, targetDir, clawDir) {
       console.log(chalk3.yellow(`  \u26A0 Existing agent backed up to: ${backupDir}`));
     }
   }
-  if (!fs2.existsSync(workspaceDir)) {
-    fs2.mkdirSync(workspaceDir, { recursive: true });
+  if (!fs3.existsSync(workspaceDir)) {
+    fs3.mkdirSync(workspaceDir, { recursive: true });
   }
   if (!targetDir) {
     spinner.text = `Registering ${chalk3.cyan(agent.displayName)} as main agent...`;
@@ -585,6 +850,11 @@ async function installSingleAgent(name, targetDir, clawDir) {
   await downloadAgentFiles(name, workspaceDir, spinner);
   await saveAgentManifest(name, agent, workspaceDir);
   recordInstall(name, agent.version, workspaceDir);
+  if (backupRecord) {
+    backupRecord.installedMainAgent = name;
+    commitBackupRecord(backupRecord);
+  }
+  logger.info(`Single agent installed: ${name}`, { version: agent.version, workspace: workspaceDir });
   spinner.succeed(
     `${chalk3.cyan.bold(agent.displayName)} installed as main agent!`
   );
@@ -607,7 +877,7 @@ async function installRecipeFromRegistry(name, recipe, targetDir, clawDir) {
       return;
     }
   }
-  const resolvedClawDir = targetDir ? path2.resolve(targetDir) : findOpenClawDir(clawDir);
+  const resolvedClawDir = targetDir ? path3.resolve(targetDir) : findOpenClawDir(clawDir);
   if (!resolvedClawDir) {
     spinner.fail("OpenClaw workspace directory not found.");
     printOpenClawInstallHelp();
@@ -622,9 +892,29 @@ async function installRecipeFromRegistry(name, recipe, targetDir, clawDir) {
     spinner.fail(`Failed to fetch soulhub.yaml for recipe "${name}". Recipe packages must include a soulhub.yaml file.`);
     return;
   }
+  const recipeBackupRecord = !targetDir ? createBackupRecord("team-registry", name, resolvedClawDir) : null;
+  if (!targetDir) {
+    spinner.text = "Backing up existing worker agents...";
+    const backupResults = backupAllWorkerWorkspaces(resolvedClawDir);
+    for (const { name: dirName, backupDir } of backupResults) {
+      logger.info(`Existing worker backed up (mv)`, { dirName, backupDir });
+      console.log(chalk3.yellow(`  \u26A0 Existing ${dirName} moved to: ${backupDir}`));
+      const agentId = dirName.replace(/^workspace-/, "");
+      addBackupItem(recipeBackupRecord, {
+        originalPath: path3.join(resolvedClawDir, dirName),
+        backupPath: backupDir,
+        method: "mv",
+        role: "worker",
+        agentId
+      });
+    }
+    if (backupResults.length > 0) {
+      console.log(chalk3.dim(`  ${backupResults.length} existing worker(s) backed up.`));
+    }
+  }
   if (pkg.dispatcher) {
     spinner.text = `Installing dispatcher ${chalk3.blue(pkg.dispatcher.name)}...`;
-    await installDispatcher(pkg.dispatcher, resolvedClawDir, clawDir, targetDir, spinner);
+    await installDispatcher(pkg.dispatcher, resolvedClawDir, clawDir, targetDir, spinner, recipeBackupRecord);
   }
   const index = await fetchIndex();
   const workerIds = [];
@@ -632,11 +922,7 @@ async function installRecipeFromRegistry(name, recipe, targetDir, clawDir) {
     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}`));
-    }
+    const workerDir = targetDir ? path3.join(resolvedClawDir, `workspace-${agentId}`) : getWorkspaceDir(resolvedClawDir, agentId);
     if (!targetDir) {
       const regResult = registerAgentToOpenClaw(agentId, workerDir, clawDir);
       if (!regResult.success) {
@@ -644,7 +930,7 @@ async function installRecipeFromRegistry(name, recipe, targetDir, clawDir) {
         continue;
       }
     } else {
-      fs2.mkdirSync(workerDir, { recursive: true });
+      fs3.mkdirSync(workerDir, { recursive: true });
     }
     await downloadAgentFiles(agentName, workerDir, spinner);
     const agentInfo = index.agents.find((a) => a.name === agentName);
@@ -659,6 +945,12 @@ async function installRecipeFromRegistry(name, recipe, targetDir, clawDir) {
     const dispatcherId = "main";
     configureMultiAgentCommunication(resolvedClawDir, dispatcherId, workerIds);
   }
+  if (recipeBackupRecord) {
+    recipeBackupRecord.installedWorkerIds = workerIds;
+    recipeBackupRecord.installedMainAgent = pkg.dispatcher?.name || null;
+    commitBackupRecord(recipeBackupRecord);
+  }
+  logger.info(`Team installed from registry: ${name}`, { dispatcher: pkg.dispatcher?.name, workers: workerIds });
   spinner.succeed(
     `Team ${chalk3.cyan.bold(recipe.displayName)} installed! (1 dispatcher + ${workerIds.length} workers)`
   );
@@ -672,42 +964,52 @@ async function installFromSource(source, targetDir, clawDir) {
   let packageDir;
   let tempDir = null;
   if (source.startsWith("http://") || source.startsWith("https://")) {
+    logger.info(`Downloading package from URL: ${source}`);
     spinner.text = "Downloading package...";
-    const response = await fetch(source);
+    const response = await fetch(source, {
+      headers: {
+        "User-Agent": "soulhub-cli",
+        "Accept": "application/zip, application/octet-stream"
+      }
+    });
     if (!response.ok) {
+      logger.error(`Download failed`, { url: source, status: response.status, statusText: response.statusText });
       spinner.fail(`Failed to download: ${response.statusText}`);
       return;
     }
     const contentType = response.headers.get("content-type") || "";
+    logger.debug(`Response content-type: ${contentType}`);
     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 });
+      tempDir = path3.join(process.env.HOME || "/tmp", ".soulhub", "tmp", `pkg-${Date.now()}`);
+      fs3.mkdirSync(tempDir, { recursive: true });
       await extractZipToDir(zip, tempDir);
       packageDir = tempDir;
     } else {
+      logger.error(`Unsupported content type from URL`, { url: source, contentType });
       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 zipData = fs3.readFileSync(path3.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 });
+    tempDir = path3.join(process.env.HOME || "/tmp", ".soulhub", "tmp", `pkg-${Date.now()}`);
+    fs3.mkdirSync(tempDir, { recursive: true });
     await extractZipToDir(zip, tempDir);
     packageDir = tempDir;
   } else {
-    packageDir = path2.resolve(source);
-    if (!fs2.existsSync(packageDir)) {
+    packageDir = path3.resolve(source);
+    if (!fs3.existsSync(packageDir)) {
       spinner.fail(`Directory not found: ${packageDir}`);
       return;
     }
   }
   const kind = detectPackageKind(packageDir);
+  logger.info(`Detected package type: ${kind}`, { packageDir });
   spinner.text = `Detected package type: ${chalk3.blue(kind)}`;
   if (kind === "agent") {
     spinner.stop();
@@ -716,16 +1018,17 @@ async function installFromSource(source, targetDir, clawDir) {
     spinner.stop();
     await installTeamFromDir(packageDir, targetDir, clawDir);
   } else {
+    logger.error(`Cannot determine package type`, { packageDir, files: fs3.existsSync(packageDir) ? fs3.readdirSync(packageDir) : [] });
     spinner.fail("Cannot determine package type. Expected soulhub.yaml or IDENTITY.md.");
   }
-  if (tempDir && fs2.existsSync(tempDir)) {
-    fs2.rmSync(tempDir, { recursive: true, force: true });
+  if (tempDir && fs3.existsSync(tempDir)) {
+    fs3.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);
+  const agentName = pkg?.name || path3.basename(packageDir);
   if (!targetDir) {
     const clawCheck = checkOpenClawInstalled(clawDir);
     if (!clawCheck.installed) {
@@ -736,7 +1039,7 @@ async function installSingleAgentFromDir(packageDir, targetDir, clawDir) {
   }
   let workspaceDir;
   if (targetDir) {
-    workspaceDir = path2.resolve(targetDir);
+    workspaceDir = path3.resolve(targetDir);
   } else {
     const resolvedClawDir = findOpenClawDir(clawDir);
     if (!resolvedClawDir) {
@@ -745,6 +1048,7 @@ async function installSingleAgentFromDir(packageDir, targetDir, clawDir) {
     }
     workspaceDir = getMainWorkspaceDir(resolvedClawDir);
   }
+  const localBackupRecord = !targetDir ? createBackupRecord("single-agent-local", agentName, findOpenClawDir(clawDir)) : null;
   if (!targetDir) {
     const resolvedClawDir = findOpenClawDir(clawDir);
     const mainCheck = checkMainAgentExists(resolvedClawDir);
@@ -753,11 +1057,18 @@ async function installSingleAgentFromDir(packageDir, targetDir, clawDir) {
       const backupDir = backupAgentWorkspace(workspaceDir);
       if (backupDir) {
         console.log(chalk3.yellow(`  \u26A0 Existing main agent backed up to: ${backupDir}`));
+        addBackupItem(localBackupRecord, {
+          originalPath: workspaceDir,
+          backupPath: backupDir,
+          method: "cp",
+          role: "main",
+          agentId: "main"
+        });
       }
     }
   }
-  if (!fs2.existsSync(workspaceDir)) {
-    fs2.mkdirSync(workspaceDir, { recursive: true });
+  if (!fs3.existsSync(workspaceDir)) {
+    fs3.mkdirSync(workspaceDir, { recursive: true });
   }
   if (!targetDir) {
     spinner.text = `Registering ${chalk3.cyan(agentName)} as main agent...`;
@@ -767,6 +1078,11 @@ async function installSingleAgentFromDir(packageDir, targetDir, clawDir) {
   spinner.text = `Copying soul files...`;
   copyAgentFilesFromDir(packageDir, workspaceDir);
   recordInstall(agentName, pkg?.version || "local", workspaceDir);
+  if (localBackupRecord) {
+    localBackupRecord.installedMainAgent = agentName;
+    commitBackupRecord(localBackupRecord);
+  }
+  logger.info(`Single agent installed from dir: ${agentName}`, { source: packageDir, workspace: workspaceDir });
   spinner.succeed(`${chalk3.cyan.bold(agentName)} installed as main agent!`);
   console.log();
   console.log(`  ${chalk3.dim("Location:")} ${workspaceDir}`);
@@ -792,14 +1108,34 @@ async function installTeamFromDir(packageDir, targetDir, clawDir) {
       return;
     }
   }
-  const resolvedClawDir = targetDir ? path2.resolve(targetDir) : findOpenClawDir(clawDir);
+  const resolvedClawDir = targetDir ? path3.resolve(targetDir) : findOpenClawDir(clawDir);
   if (!resolvedClawDir) {
     spinner.fail("OpenClaw workspace directory not found.");
     return;
   }
+  const teamBackupRecord = !targetDir ? createBackupRecord("team-local", pkg.name, resolvedClawDir) : null;
+  if (!targetDir) {
+    spinner.text = "Backing up existing worker agents...";
+    const backupResults = backupAllWorkerWorkspaces(resolvedClawDir);
+    for (const { name: dirName, backupDir } of backupResults) {
+      logger.info(`Existing worker backed up (mv)`, { dirName, backupDir });
+      console.log(chalk3.yellow(`  \u26A0 Existing ${dirName} moved to: ${backupDir}`));
+      const agentId = dirName.replace(/^workspace-/, "");
+      addBackupItem(teamBackupRecord, {
+        originalPath: path3.join(resolvedClawDir, dirName),
+        backupPath: backupDir,
+        method: "mv",
+        role: "worker",
+        agentId
+      });
+    }
+    if (backupResults.length > 0) {
+      console.log(chalk3.dim(`  ${backupResults.length} existing worker(s) backed up.`));
+    }
+  }
   if (pkg.dispatcher) {
     spinner.text = `Installing dispatcher ${chalk3.blue(pkg.dispatcher.name)}...`;
-    const mainWorkspace = targetDir ? path2.join(resolvedClawDir, "workspace") : getMainWorkspaceDir(resolvedClawDir);
+    const mainWorkspace = targetDir ? path3.join(resolvedClawDir, "workspace") : getMainWorkspaceDir(resolvedClawDir);
     if (!targetDir) {
       const mainCheck = checkMainAgentExists(resolvedClawDir);
       if (mainCheck.hasContent) {
@@ -807,17 +1143,26 @@ async function installTeamFromDir(packageDir, targetDir, clawDir) {
         const backupDir = backupAgentWorkspace(mainWorkspace);
         if (backupDir) {
           console.log(chalk3.yellow(`  \u26A0 Existing main agent backed up to: ${backupDir}`));
+          if (teamBackupRecord) {
+            addBackupItem(teamBackupRecord, {
+              originalPath: mainWorkspace,
+              backupPath: backupDir,
+              method: "cp",
+              role: "main",
+              agentId: "main"
+            });
+          }
         }
       }
     }
-    if (!fs2.existsSync(mainWorkspace)) {
-      fs2.mkdirSync(mainWorkspace, { recursive: true });
+    if (!fs3.existsSync(mainWorkspace)) {
+      fs3.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)) {
+    const dispatcherSourceDir = path3.join(packageDir, pkg.dispatcher.dir);
+    if (fs3.existsSync(dispatcherSourceDir)) {
       copyAgentFilesFromDir(dispatcherSourceDir, mainWorkspace);
     }
     recordInstall("dispatcher", pkg.version || "local", mainWorkspace);
@@ -827,11 +1172,7 @@ async function installTeamFromDir(packageDir, targetDir, clawDir) {
     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}`));
-    }
+    const workerWorkspace = targetDir ? path3.join(resolvedClawDir, `workspace-${agentId}`) : getWorkspaceDir(resolvedClawDir, agentId);
     if (!targetDir) {
       const regResult = registerAgentToOpenClaw(agentId, workerWorkspace, clawDir);
       if (!regResult.success) {
@@ -839,10 +1180,10 @@ async function installTeamFromDir(packageDir, targetDir, clawDir) {
         continue;
       }
     } else {
-      fs2.mkdirSync(workerWorkspace, { recursive: true });
+      fs3.mkdirSync(workerWorkspace, { recursive: true });
     }
-    const workerSourceDir = path2.join(packageDir, agentDir);
-    if (fs2.existsSync(workerSourceDir)) {
+    const workerSourceDir = path3.join(packageDir, agentDir);
+    if (fs3.existsSync(workerSourceDir)) {
       copyAgentFilesFromDir(workerSourceDir, workerWorkspace);
     }
     recordInstall(agentId, pkg.version || "local", workerWorkspace);
@@ -852,6 +1193,12 @@ async function installTeamFromDir(packageDir, targetDir, clawDir) {
     spinner.text = "Configuring multi-agent communication...";
     configureMultiAgentCommunication(resolvedClawDir, "main", workerIds);
   }
+  if (teamBackupRecord) {
+    teamBackupRecord.installedWorkerIds = workerIds;
+    teamBackupRecord.installedMainAgent = pkg.dispatcher?.name || null;
+    commitBackupRecord(teamBackupRecord);
+  }
+  logger.info(`Team installed from dir: ${pkg.name}`, { dispatcher: pkg.dispatcher?.name, workers: workerIds, source: packageDir });
   spinner.succeed(
     `Team ${chalk3.cyan.bold(pkg.name)} installed! (${pkg.dispatcher ? "1 dispatcher + " : ""}${workerIds.length} workers)`
   );
@@ -861,11 +1208,11 @@ async function installTeamFromDir(packageDir, targetDir, clawDir) {
   }
 }
 async function downloadAgentFiles(agentName, workspaceDir, spinner) {
-  fs2.mkdirSync(workspaceDir, { recursive: true });
+  fs3.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);
+    fs3.writeFileSync(path3.join(workspaceDir, fileName), content);
     spinner.text = `Downloaded ${fileName}`;
   }
   const optionalFiles = ["USER.md.template", "TOOLS.md.template"];
@@ -873,7 +1220,7 @@ async function downloadAgentFiles(agentName, workspaceDir, spinner) {
     try {
       const content = await fetchAgentFile(agentName, fileName);
       const actualName = fileName.replace(".template", "");
-      fs2.writeFileSync(path2.join(workspaceDir, actualName), content);
+      fs3.writeFileSync(path3.join(workspaceDir, actualName), content);
     } catch {
     }
   }
@@ -881,7 +1228,7 @@ async function downloadAgentFiles(agentName, workspaceDir, spinner) {
 async function saveAgentManifest(agentName, agent, workspaceDir) {
   try {
     const manifestContent = await fetchAgentFile(agentName, "manifest.yaml");
-    fs2.writeFileSync(path2.join(workspaceDir, "manifest.yaml"), manifestContent);
+    fs3.writeFileSync(path3.join(workspaceDir, "manifest.yaml"), manifestContent);
   } catch {
     const manifest = {
       name: agent.name,
@@ -892,21 +1239,21 @@ async function saveAgentManifest(agentName, agent, workspaceDir) {
       version: agent.version,
       author: agent.author
     };
-    fs2.writeFileSync(path2.join(workspaceDir, "manifest.yaml"), yaml2.dump(manifest));
+    fs3.writeFileSync(path3.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));
+    const sourcePath = path3.join(sourceDir, fileName);
+    if (fs3.existsSync(sourcePath)) {
+      fs3.mkdirSync(targetDir, { recursive: true });
+      fs3.copyFileSync(sourcePath, path3.join(targetDir, fileName));
     }
   }
 }
-async function installDispatcher(dispatcher, resolvedClawDir, clawDir, targetDir, spinner) {
-  const mainWorkspace = targetDir ? path2.join(resolvedClawDir, "workspace") : getMainWorkspaceDir(resolvedClawDir);
+async function installDispatcher(dispatcher, resolvedClawDir, clawDir, targetDir, spinner, backupRecord) {
+  const mainWorkspace = targetDir ? path3.join(resolvedClawDir, "workspace") : getMainWorkspaceDir(resolvedClawDir);
   if (!targetDir) {
     const mainCheck = checkMainAgentExists(resolvedClawDir);
     if (mainCheck.hasContent) {
@@ -914,11 +1261,20 @@ async function installDispatcher(dispatcher, resolvedClawDir, clawDir, targetDir
       const backupDir = backupAgentWorkspace(mainWorkspace);
       if (backupDir) {
         console.log(chalk3.yellow(`  \u26A0 Existing main agent backed up to: ${backupDir}`));
+        if (backupRecord) {
+          addBackupItem(backupRecord, {
+            originalPath: mainWorkspace,
+            backupPath: backupDir,
+            method: "cp",
+            role: "main",
+            agentId: "main"
+          });
+        }
       }
     }
   }
-  if (!fs2.existsSync(mainWorkspace)) {
-    fs2.mkdirSync(mainWorkspace, { recursive: true });
+  if (!fs3.existsSync(mainWorkspace)) {
+    fs3.mkdirSync(mainWorkspace, { recursive: true });
   }
   if (!targetDir) {
     addAgentToOpenClawConfig(resolvedClawDir, "main", dispatcher.name, true);
@@ -931,13 +1287,13 @@ async function installDispatcher(dispatcher, resolvedClawDir, clawDir, targetDir
 async function extractZipToDir(zip, targetDir) {
   const entries = Object.entries(zip.files);
   for (const [relativePath, file] of entries) {
-    const fullPath = path2.join(targetDir, relativePath);
+    const fullPath = path3.join(targetDir, relativePath);
     if (file.dir) {
-      fs2.mkdirSync(fullPath, { recursive: true });
+      fs3.mkdirSync(fullPath, { recursive: true });
     } else {
-      fs2.mkdirSync(path2.dirname(fullPath), { recursive: true });
+      fs3.mkdirSync(path3.dirname(fullPath), { recursive: true });
       const content = await file.async("nodebuffer");
-      fs2.writeFileSync(fullPath, content);
+      fs3.writeFileSync(fullPath, content);
     }
   }
 }
@@ -1008,9 +1364,11 @@ var listCommand = new Command4("list").description("List installed agent templat
       console.log();
     }
   } catch (error) {
+    logger.errorObj("List command failed", error);
     console.error(
       chalk4.red(`Error: ${error instanceof Error ? error.message : error}`)
     );
+    console.error(chalk4.dim(`  See logs: ${logger.getTodayLogFile()}`));
     process.exit(1);
   }
 });
@@ -1019,8 +1377,8 @@ var listCommand = new Command4("list").description("List installed agent templat
 import { Command as Command5 } from "commander";
 import chalk5 from "chalk";
 import ora2 from "ora";
-import fs3 from "fs";
-import path3 from "path";
+import fs4 from "fs";
+import path4 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();
@@ -1049,8 +1407,8 @@ var updateCommand = new Command5("update").description("Update installed agent t
       }
       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 });
+      if (!fs4.existsSync(workspaceDir)) {
+        fs4.mkdirSync(workspaceDir, { recursive: true });
       }
       for (const fileName of ["IDENTITY.md", "SOUL.md", "manifest.yaml"]) {
         try {
@@ -1058,8 +1416,8 @@ var updateCommand = new Command5("update").description("Update installed agent t
             installed.name,
             fileName
           );
-          fs3.writeFileSync(
-            path3.join(workspaceDir, fileName),
+          fs4.writeFileSync(
+            path4.join(workspaceDir, fileName),
             content
           );
         } catch {
@@ -1073,13 +1431,16 @@ var updateCommand = new Command5("update").description("Update installed agent t
     if (updated === 0) {
       spinner.succeed("All agents are up to date.");
     } else {
+      logger.info(`Updated ${updated} agent(s)`);
       spinner.succeed(`Updated ${updated} agent(s).`);
     }
     console.log();
   } catch (error) {
+    logger.errorObj("Update command failed", error);
     console.error(
       chalk5.red(`Error: ${error instanceof Error ? error.message : error}`)
     );
+    console.error(chalk5.dim(`  See logs: ${logger.getTodayLogFile()}`));
     process.exit(1);
   }
 });
@@ -1088,7 +1449,7 @@ var updateCommand = new Command5("update").description("Update installed agent t
 import { Command as Command6 } from "commander";
 import chalk6 from "chalk";
 import ora3 from "ora";
-import fs4 from "fs";
+import fs5 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();
@@ -1107,11 +1468,12 @@ var uninstallCommand = new Command6("uninstall").description("Uninstall an agent
     const spinner = ora3(
       `Uninstalling ${chalk6.cyan(name)}...`
     ).start();
-    if (!options.keepFiles && fs4.existsSync(installed.workspace)) {
-      fs4.rmSync(installed.workspace, { recursive: true, force: true });
+    if (!options.keepFiles && fs5.existsSync(installed.workspace)) {
+      fs5.rmSync(installed.workspace, { recursive: true, force: true });
       spinner.text = `Removed workspace: ${installed.workspace}`;
     }
     removeInstallRecord(name);
+    logger.info(`Agent uninstalled: ${name}`, { workspace: installed.workspace, keepFiles: !!options.keepFiles });
     spinner.succeed(
       `${chalk6.cyan.bold(name)} uninstalled.`
     );
@@ -1122,9 +1484,11 @@ var uninstallCommand = new Command6("uninstall").description("Uninstall an agent
     }
     console.log();
   } catch (error) {
+    logger.errorObj("Uninstall command failed", error);
     console.error(
       chalk6.red(`Error: ${error instanceof Error ? error.message : error}`)
     );
+    console.error(chalk6.dim(`  See logs: ${logger.getTodayLogFile()}`));
     process.exit(1);
   }
 });
@@ -1133,19 +1497,19 @@ var uninstallCommand = new Command6("uninstall").description("Uninstall an agent
 import { Command as Command7 } from "commander";
 import chalk7 from "chalk";
 import ora4 from "ora";
-import fs5 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path5 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 dir = directory ? path5.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))
+      (f) => !fs6.existsSync(path5.join(dir, f))
     );
     if (missing.length > 0) {
       spinner.fail("Missing required files:");
@@ -1161,8 +1525,8 @@ var publishCommand = new Command7("publish").description("Publish an agent templ
       );
       return;
     }
-    const manifestContent = fs5.readFileSync(
-      path4.join(dir, "manifest.yaml"),
+    const manifestContent = fs6.readFileSync(
+      path5.join(dir, "manifest.yaml"),
       "utf-8"
     );
     const manifest = yaml3.load(manifestContent);
@@ -1225,16 +1589,27 @@ var publishCommand = new Command7("publish").description("Publish an agent templ
     );
     console.log();
   } catch (error) {
+    logger.errorObj("Publish command failed", error);
     console.error(
       chalk7.red(`Error: ${error instanceof Error ? error.message : error}`)
     );
+    console.error(chalk7.dim(`  See logs: ${logger.getTodayLogFile()}`));
     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.name("soulhub").description("SoulHub CLI - Install and manage AI agent persona templates").version("0.1.0").option("--verbose", "Enable verbose debug logging").hook("preAction", () => {
+  const opts = program.opts();
+  const verbose = opts.verbose || process.env.SOULHUB_DEBUG === "1";
+  logger.init(verbose);
+  logger.info("CLI started", {
+    args: process.argv.slice(2),
+    version: "0.1.0",
+    node: process.version
+  });
+});
 program.addCommand(searchCommand);
 program.addCommand(infoCommand);
 program.addCommand(installCommand);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "soulhubcli",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "SoulHub CLI - Install and manage AI agent persona templates for OpenClaw",
   "type": "module",
   "bin": {