@zshuangmu/agenthub 0.1.0

package/src/cli.js

@@ -0,0 +1,343 @@
+/**
+ * AgentHub CLI
+ * AI Agent 打包与分发平台
+ *
+ * 根据 PRD v1.1 规范实现
+ */
+
+import {
+  infoCommand,
+  installCommand,
+  packCommand,
+  publishCommand,
+  publishRemoteCommand,
+  serveCommand,
+  searchCommand,
+  apiCommand,
+  webCommand,
+} from "./index.js";
+
+const VERSION = "0.1.0";
+
+function printHelp() {
+  console.log(`
+AgentHub v${VERSION} - AI Agent 打包与分发平台
+
+用法:
+  agenthub <command> [options]
+
+命令:
+  pack        打包 OpenClaw 工作区为 Agent Bundle
+  publish     发布 Bundle 到本地 Registry
+  publish-remote  发布 Bundle 到远程服务器
+  install     安装 Agent 到目标工作区
+  search      搜索 Registry 中的 Agent
+  info        查看 Agent 详情
+  serve       启动 Web + API 服务
+
+选项:
+  --help, -h      显示帮助信息
+  --version, -v   显示版本号
+
+详细帮助:
+  agenthub <command> --help
+
+示例:
+  # 打包 Agent
+  agenthub pack --workspace ./my-workspace --config openclaw.json --output ./bundles
+
+  # 发布 Agent
+  agenthub publish ./bundles/my-agent.agent --registry ./.registry
+
+  # 安装 Agent
+  agenthub install my-agent --registry ./.registry --target-workspace ./workspace
+
+  # 搜索 Agent
+  agenthub search "code review" --registry ./.registry
+
+  # 启动完整服务（前端+后端）
+  agenthub serve --registry ./.registry --port 3000
+
+`);
+}
+
+function printCommandHelp(command) {
+  const helps = {
+    pack: `
+agenthub pack - 打包 Agent
+
+用法:
+  agenthub pack --workspace <dir> --config <file> --output <dir>
+
+选项:
+  --workspace <dir>   OpenClaw 工作区目录 (必需)
+  --config <file>     openclaw.json 配置文件路径 (必需)
+  --output <dir>      输出目录 (默认: ./bundles)
+  --tags <tags>       标签，逗号分隔
+  --category <cat>    分类
+
+示例:
+  agenthub pack --workspace ./my-agent --config ./openclaw.json
+`,
+    publish: `
+agenthub publish - 发布 Agent
+
+用法:
+  agenthub publish <bundle-dir> --registry <dir>
+
+选项:
+  --registry <dir>    Registry 目录 (必需)
+
+示例:
+  agenthub publish ./bundles/my-agent.agent --registry ./.registry
+`,
+    install: `
+agenthub install - 安装 Agent
+
+用法:
+  agenthub install <agent-slug>[:version] --registry <dir> --target-workspace <dir>
+
+选项:
+  --registry <dir>          Registry 目录 (必需)
+  --target-workspace <dir>  目标工作区目录 (必需)
+  --force                   强制覆盖
+
+示例:
+  agenthub install code-review-assistant --registry ./.registry --target-workspace ./workspace
+  agenthub install my-agent:1.0.0 --registry ./.registry --target-workspace ./workspace
+`,
+    search: `
+agenthub search - 搜索 Agent
+
+用法:
+  agenthub search <query> --registry <dir>
+
+选项:
+  --registry <dir>    Registry 目录 (必需)
+
+示例:
+  agenthub search "code review" --registry ./.registry
+  agenthub search "" --registry ./.registry  # 列出所有
+`,
+    serve: `
+agenthub serve - 启动完整服务（前端+后端）
+
+用法:
+  agenthub serve --registry <dir> --port <port>
+
+选项:
+  --registry <dir>    Registry 目录 (必需)
+  --port <port>       前端端口号 (默认: 3000)
+  --api-port <port>   后端 API 端口号 (默认: 3001)
+
+示例:
+  agenthub serve --registry ./.registry --port 3000
+`,
+  };
+
+  console.log(helps[command] || `未知命令: ${command}`);
+}
+
+function parseArgs(argv) {
+  const positionals = [];
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--help" || token === "-h") {
+      options.help = true;
+    } else if (token === "--version" || token === "-v") {
+      options.version = true;
+    } else if (token.startsWith("--")) {
+      const rawKey = token.slice(2);
+      const camelKey = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+      const value = argv[index + 1];
+      if (value && !value.startsWith("-")) {
+        options[rawKey] = value;
+        options[camelKey] = value;
+        index += 1;
+      } else {
+        options[rawKey] = true;
+        options[camelKey] = true;
+      }
+    } else {
+      positionals.push(token);
+    }
+  }
+  return { positionals, options };
+}
+
+async function main() {
+  const { positionals, options } = parseArgs(process.argv.slice(2));
+  const [command, ...rest] = positionals;
+
+  // 全局选项
+  if (options.version) {
+    console.log(`AgentHub v${VERSION}`);
+    return;
+  }
+
+  if (!command) {
+    printHelp();
+    return;
+  }
+
+  // 命令帮助
+  if (options.help) {
+    printCommandHelp(command);
+    return;
+  }
+
+  // 命令路由
+  try {
+    switch (command) {
+      case "pack": {
+        if (!options.workspace || !options.config) {
+          console.error("错误: --workspace 和 --config 是必需的");
+          console.log("\n运行 'agenthub pack --help' 查看帮助");
+          process.exitCode = 1;
+          return;
+        }
+        const result = await packCommand(options);
+        console.log(`✓ 打包完成: ${result.bundleDir}`);
+        return;
+      }
+
+      case "publish": {
+        if (!rest[0]) {
+          console.error("错误: 需要指定 bundle 目录");
+          process.exitCode = 1;
+          return;
+        }
+        const result = await publishCommand(rest[0], options);
+        console.log(`✓ 已发布 ${result.slug}@${result.version}`);
+        return;
+      }
+
+      case "publish-remote": {
+        if (!rest[0]) {
+          console.error("错误: 需要指定 bundle 目录");
+          process.exitCode = 1;
+          return;
+        }
+        const result = await publishRemoteCommand(rest[0], options);
+        console.log(`✓ 已发布到远程 ${result.slug}@${result.version}`);
+        return;
+      }
+
+      case "search": {
+        const results = await searchCommand(rest[0] || "", options);
+        if (results.length === 0) {
+          console.log("未找到匹配的 Agent");
+        } else {
+          console.log(`\n找到 ${results.length} 个 Agent:\n`);
+          for (const entry of results) {
+            console.log(`  ${entry.slug}@${entry.version} - ${entry.description || ""}`);
+          }
+        }
+        return;
+      }
+
+      case "info": {
+        if (!rest[0]) {
+          console.error("错误: 需要指定 agent slug");
+          process.exitCode = 1;
+          return;
+        }
+        const result = await infoCommand(rest[0], options);
+        console.log(`\n📦 ${result.name} (${result.slug}@${result.version})`);
+        console.log(`   ${result.description}`);
+        console.log(`   Runtime: ${result.runtime?.type || "openclaw"} ${result.runtime?.version || ""}`);
+        const mem = result.includes?.memory || {};
+        if (mem.count > 0) {
+          console.log(`   Memory: ${mem.count} 条 (public: ${mem.public}, portable: ${mem.portable})`);
+        }
+        console.log(`\n   安装命令: agenthub install ${result.slug}`);
+        return;
+      }
+
+      case "install": {
+        if (!rest[0]) {
+          console.error("错误: 需要指定 agent slug");
+          process.exitCode = 1;
+          return;
+        }
+        console.log(`\n📥 正在安装 ${rest[0]}...\n`);
+        const result = await installCommand(rest[0], options);
+        console.log(`✓ 已安装 ${result.manifest.slug}@${result.manifest.version}`);
+        console.log(`  位置: ${options.targetWorkspace || "当前目录"}`);
+        return;
+      }
+
+      case "serve": {
+        const result = await serveCommand(options);
+        console.log(`Server listening at ${result.baseUrl}`);
+        console.log(`\n🌐 AgentHub 服务已启动`);
+        console.log(`   地址: ${result.baseUrl}`);
+        console.log(`   API:  ${result.baseUrl}/api/agents`);
+        console.log(`\n按 Ctrl+C 停止服务\n`);
+
+        const shutdown = async () => {
+          process.off("SIGINT", shutdown);
+          process.off("SIGTERM", shutdown);
+          await result.close();
+          process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        return;
+      }
+
+      case "api": {
+        const port = options.port || "3001";
+        const result = await apiCommand({ ...options, port });
+        console.log(`Server listening at ${result.baseUrl}`);
+        console.log(`\n🔧 API 服务已启动`);
+        console.log(`   地址: ${result.baseUrl}`);
+        console.log(`   端点: ${result.baseUrl}/api/agents`);
+        console.log(`   统计: ${result.baseUrl}/api/stats`);
+        console.log(`\n按 Ctrl+C 停止服务\n`);
+
+        const shutdown = async () => {
+          process.off("SIGINT", shutdown);
+          process.off("SIGTERM", shutdown);
+          await result.close();
+          process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        return;
+      }
+
+      case "web": {
+        const port = options.port || "3000";
+        const apiBase = options.apiBase || "http://127.0.0.1:3001";
+        const result = await webCommand({ port, apiBase });
+        console.log(`Server listening at ${result.baseUrl}`);
+        console.log(`\n🌐 Web 服务已启动`);
+        console.log(`   地址: ${result.baseUrl}`);
+        console.log(`   API:  ${apiBase}`);
+        console.log(`\n按 Ctrl+C 停止服务\n`);
+
+        const shutdown = async () => {
+          process.off("SIGINT", shutdown);
+          process.off("SIGTERM", shutdown);
+          await result.close();
+          process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        return;
+      }
+
+      default:
+        console.error(`未知命令: ${command}`);
+        console.log("\n运行 'agenthub --help' 查看可用命令");
+        process.exitCode = 1;
+    }
+  } catch (error) {
+    console.error(`\n❌ 错误: ${error.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/src/commands/api.js

@@ -0,0 +1,8 @@
+import { createApiServer } from "../api-server.js";
+
+export async function apiCommand(options) {
+  const registry = options.registry || "./.registry";
+  const port = parseInt(options.port || "3001", 10);
+
+  return createApiServer({ registryDir: registry, port });
+}

package/src/commands/info.js

@@ -0,0 +1,6 @@
+import path from "node:path";
+import { readAgentInfo } from "../lib/registry.js";
+
+export async function infoCommand(agentSpec, options) {
+  return readAgentInfo(path.resolve(options.registry), agentSpec);
+}

package/src/commands/install.js

@@ -0,0 +1,10 @@
+import path from "node:path";
+import { installBundle } from "../lib/install.js";
+
+export async function installCommand(agentSpec, options) {
+  return installBundle({
+    registryDir: path.resolve(options.registry),
+    agentSpec,
+    targetWorkspace: path.resolve(options.targetWorkspace),
+  });
+}

package/src/commands/list.js

@@ -0,0 +1,91 @@
+/**
+ * List Command
+ * 列出已安装的 Agent
+ */
+
+import path from "node:path";
+import { stat, readdir, readFile } from "node:fs/promises";
+
+async function pathExists(targetPath) {
+  try {
+    await stat(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function readJson(filePath) {
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+
+export async function listCommand(options = {}) {
+  // 检查多个可能的安装位置
+  const locations = [];
+
+  // 1. 当前目录的 .agenthub
+  const cwd = process.cwd();
+  const cwdAgenthub = path.join(cwd, ".agenthub");
+  if (await pathExists(cwdAgenthub)) {
+    const installs = await findInstallsInDir(cwd);
+    locations.push(...installs.map((i) => ({ ...i, location: cwd })));
+  }
+
+  // 2. 如果指定了 target-workspace
+  if (options.targetWorkspace) {
+    const targetPath = path.resolve(options.targetWorkspace);
+    const installs = await findInstallsInDir(targetPath);
+    locations.push(...installs.map((i) => ({ ...i, location: targetPath })));
+  }
+
+  return locations;
+}
+
+async function findInstallsInDir(dirPath) {
+  const installs = [];
+  const agenthubDir = path.join(dirPath, ".agenthub");
+  const installRecordPath = path.join(agenthubDir, "install.json");
+
+  if (await pathExists(installRecordPath)) {
+    try {
+      const record = await readJson(installRecordPath);
+      installs.push({
+        slug: record.slug,
+        version: record.version,
+        installedAt: record.installedAt || record.updatedAt,
+        rolledBackAt: record.rolledBackAt,
+      });
+    } catch {
+      // 无效的安装记录
+    }
+  }
+
+  return installs;
+}
+
+export function formatListOutput(installs) {
+  if (installs.length === 0) {
+    return "\n📭 暂无已安装的 Agent\n\n安装命令: agenthub install <agent-slug>\n";
+  }
+
+  const lines = [];
+  lines.push("\n📦 已安装的 Agent:\n");
+  lines.push("─".repeat(60));
+
+  for (const install of installs) {
+    const status = install.rolledBackAt ? "↩️ " : "✓ ";
+    lines.push(`  ${status} ${install.slug}@${install.version}`);
+    if (install.location) {
+      lines.push(`     位置: ${install.location}`);
+    }
+    if (install.installedAt) {
+      lines.push(`     安装时间: ${install.installedAt}`);
+    }
+    lines.push("");
+  }
+
+  lines.push("─".repeat(60));
+  lines.push(`\n共 ${installs.length} 个已安装的 Agent\n`);
+
+  return lines.join("\n");
+}

package/src/commands/pack.js

@@ -0,0 +1,151 @@
+/**
+ * Pack Command
+ * 打包 OpenClaw 工作区为 Agent Bundle
+ *
+ * 根据 PRD v1.1 Bundle 结构规范实现
+ */
+
+import path from "node:path";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { countFiles, copyDir, ensureDir, readJson, writeJson, pathExists } from "../lib/fs-utils.js";
+import { createManifest, validateManifest, generateBundleId } from "../lib/manifest.js";
+import { extractOpenClawTemplate } from "../lib/openclaw-config.js";
+
+const WORKSPACE_CORE_FILES = ["AGENTS.md", "SOUL.md", "USER.md", "IDENTITY.md", "TOOLS.md", "HEARTBEAT.md", "BOOTSTRAP.md"];
+
+/**
+ * 扫描工作区文件
+ */
+async function scanWorkspace(workspacePath) {
+  const files = {
+    core: [],
+    skills: [],
+    prompts: [],
+    canvas: false,
+  };
+
+  for (const filename of WORKSPACE_CORE_FILES) {
+    const filePath = path.join(workspacePath, filename);
+    if (await pathExists(filePath)) {
+      files.core.push(filename);
+    }
+  }
+
+  // 检查 skills 目录
+  const skillsPath = path.join(workspacePath, "skills");
+  if (await pathExists(skillsPath)) {
+    const entries = await readdir(skillsPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        files.skills.push(entry.name);
+      }
+    }
+  }
+
+  // 检查 PROMPTS 目录
+  const promptsPath = path.join(workspacePath, "PROMPTS");
+  if (await pathExists(promptsPath)) {
+    const entries = await readdir(promptsPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".txt")) {
+        files.prompts.push(entry.name);
+      }
+    }
+  }
+
+  // 检查 canvas 目录
+  const canvasPath = path.join(workspacePath, "canvas");
+  files.canvas = await pathExists(canvasPath);
+
+  return files;
+}
+
+/**
+ * Pack 命令主函数
+ */
+export async function packCommand(options) {
+  const workspace = path.resolve(options.workspace || process.cwd());
+  const output = path.resolve(options.output ?? "./bundles");
+  const configPath = options.config ? path.resolve(options.config) : null;
+
+  // 从工作区名称生成 slug
+  const slug = path.basename(workspace).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+  const bundleDir = path.join(output, `${slug}-1.0.0.agent`);
+
+  // 1. 扫描工作区
+  const workspaceFiles = await scanWorkspace(workspace);
+
+  // 2. 统计 Memory 分层
+  const memoryCounts = {
+    public: await countFiles(path.join(workspace, "memory", "public")),
+    portable: await countFiles(path.join(workspace, "memory", "portable")),
+    private: await countFiles(path.join(workspace, "memory", "private")),
+  };
+
+  // 3. 读取并处理 OpenClaw 配置
+  let template = {};
+  if (configPath && (await pathExists(configPath))) {
+    const config = await readJson(configPath);
+    template = extractOpenClawTemplate(config);
+  }
+
+  // 4. 生成 MANIFEST
+  const manifest = createManifest({
+    slug,
+    name: path.basename(workspace),
+    memoryCounts,
+    openclawTemplate: template,
+    skills: workspaceFiles.skills,
+    prompts: workspaceFiles.prompts,
+    tags: options.tags ? options.tags.split(",").map((t) => t.trim()) : [],
+    category: options.category,
+  });
+
+  // 5. 验证 MANIFEST
+  const validation = validateManifest(manifest);
+  if (!validation.valid) {
+    throw new Error(`Invalid manifest: ${validation.errors.join(", ")}`);
+  }
+
+  // 6. 创建 Bundle 目录结构
+  await ensureDir(bundleDir);
+
+  // 6.1 复制 WORKSPACE
+  await copyDir(workspace, path.join(bundleDir, "WORKSPACE"));
+
+  // 6.2 写入 OPENCLAW.template.json
+  await writeJson(path.join(bundleDir, "OPENCLAW.template.json"), template);
+
+  // 6.3 写入 MANIFEST.json
+  await writeJson(path.join(bundleDir, "MANIFEST.json"), manifest);
+
+  // 6.4 生成 README.md
+  const readme = `# ${manifest.name}
+
+${manifest.description}
+
+## 安装
+
+\`\`\`bash
+agenthub install ${manifest.slug}
+\`\`\`
+
+## 包含内容
+
+- **记忆**: ${manifest.includes.memory.count} 条
+- **技能**: ${manifest.includes.skills.join(", ") || "无"}
+- **提示词**: ${manifest.includes.prompts} 个
+
+## 要求
+
+- 运行时: OpenClaw ${manifest.runtime.version}
+`;
+  await writeFile(path.join(bundleDir, "README.md"), readme, "utf8");
+
+  return {
+    bundleDir,
+    manifest,
+    validation,
+    bundleId: generateBundleId(manifest.slug, manifest.version),
+  };
+}

package/src/commands/publish-remote.js

@@ -0,0 +1,9 @@
+import path from "node:path";
+import { publishRemoteBundle } from "../lib/bundle-transfer.js";
+
+export async function publishRemoteCommand(bundleDir, options) {
+  return publishRemoteBundle({
+    bundleDir: path.resolve(bundleDir),
+    serverUrl: options.server,
+  });
+}

package/src/commands/publish.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+import { publishBundle } from "../lib/registry.js";
+
+export async function publishCommand(bundleDir, options) {
+  const registry = path.resolve(options.registry);
+  return publishBundle(path.resolve(bundleDir), registry);
+}

package/src/commands/rollback.js

@@ -0,0 +1,64 @@
+/**
+ * Rollback Command
+ * 回滚 Agent 到指定版本
+ */
+
+import path from "node:path";
+import { pathExists, readJson, writeJson } from "../lib/fs-utils.js";
+import { installBundle } from "../lib/install.js";
+import { versionsCommand } from "./versions.js";
+
+export async function rollbackCommand(agentSpec, options) {
+  const registryDir = path.resolve(options.registry);
+  const targetWorkspace = options.targetWorkspace ? path.resolve(options.targetWorkspace) : null;
+  const targetVersion = options.to;
+
+  if (!targetVersion) {
+    throw new Error("请指定回滚版本: --to <version>");
+  }
+
+  const [slug] = agentSpec.split(":");
+
+  // 验证目标版本存在
+  const versions = await versionsCommand(slug, { registry: registryDir });
+  const versionExists = versions.some((v) => v.version === targetVersion);
+  if (!versionExists) {
+    throw new Error(`版本 ${targetVersion} 不存在`);
+  }
+
+  // 获取当前版本
+  let currentVersion = null;
+  if (targetWorkspace) {
+    const installRecordPath = path.join(targetWorkspace, ".agenthub", "install.json");
+    if (await pathExists(installRecordPath)) {
+      const record = await readJson(installRecordPath);
+      currentVersion = record.version;
+    }
+  }
+
+  // 执行回滚
+  const result = await installBundle({
+    registryDir,
+    agentSpec: `${slug}:${targetVersion}`,
+    targetWorkspace,
+  });
+
+  // 记录回滚
+  if (targetWorkspace) {
+    const installRecordPath = path.join(targetWorkspace, ".agenthub", "install.json");
+    await writeJson(installRecordPath, {
+      slug,
+      version: targetVersion,
+      rolledBackAt: new Date().toISOString(),
+      rolledBackFrom: currentVersion,
+    });
+  }
+
+  return {
+    rolledBack: true,
+    message: `已回滚 ${slug} 从 ${currentVersion || "未知"} 到 ${targetVersion}`,
+    currentVersion: targetVersion,
+    previousVersion: currentVersion,
+    manifest: result.manifest,
+  };
+}

package/src/commands/search.js

@@ -0,0 +1,7 @@
+import path from "node:path";
+import { searchRegistry } from "../lib/registry.js";
+
+export async function searchCommand(query, options) {
+  const results = await searchRegistry(path.resolve(options.registry), query);
+  return results;
+}