@catch-claw/openclaw-agentar 1.0.0 → 1.1.0

package/index.ts

@@ -54,6 +54,22 @@ type InstallResult = {
   introduction?: string | null;
 };
 
+type AgentWorkspaceInfo = {
+  id: string;
+  name?: string;
+  workspace: string;
+  isDefault: boolean;
+};
+
+type ExportResult = {
+  success: boolean;
+  agentName: string;
+  workspace: string;
+  outputPath: string;
+  files: string[];
+  includeMemory: boolean;
+};
+
 // ─── Constants ───────────────────────────────────────────────────────────────
 
 const DEFAULT_API_BASE_URL = "http://127.0.0.1:8080";
@@ -69,6 +85,7 @@ const WORKSPACE_FILES = [
   "MEMORY.md",
 ];
 const SKIP_FILES = ["AGENTS.md", "BOOTSTRAP.md"];
+const EXPORT_SKIP_DIRS = [".git", ".openclaw", "__MACOSX", "memory"];
 const INTRO_MESSAGE =
   "请做一下自我介绍，简要说明你是谁、你擅长什么、你能帮用户做哪些事情。";
 
@@ -119,11 +136,26 @@ function box(text: string): void {
 // ─── Core Utilities ──────────────────────────────────────────────────────────
 
 function findOpenclawBin(): string {
+  const isWin = process.platform === "win32";
   try {
-    return execSync("which openclaw", { encoding: "utf-8" }).trim();
+    return execSync(isWin ? "where openclaw" : "which openclaw", {
+      encoding: "utf-8",
+    })
+      .split(/\r?\n/)[0]
+      .trim();
   } catch {
-    const pnpmPath = path.join(os.homedir(), ".local/share/pnpm/openclaw");
-    if (fs.existsSync(pnpmPath)) return pnpmPath;
+    const fallbacks = isWin
+      ? [
+          path.join(
+            process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"),
+            "pnpm",
+            "openclaw.cmd",
+          ),
+        ]
+      : [path.join(os.homedir(), ".local/share/pnpm/openclaw")];
+    for (const p of fallbacks) {
+      if (fs.existsSync(p)) return p;
+    }
     throw new Error("openclaw CLI not found on PATH");
   }
 }
@@ -199,6 +231,187 @@ function resolveContentDir(extractDir: string): string {
   return extractDir;
 }
 
+function discoverAgents(): AgentWorkspaceInfo[] {
+  const openclawBin = findOpenclawBin();
+  try {
+    const stdout = execSync(`"${openclawBin}" agents list --json`, {
+      encoding: "utf-8",
+      stdio: "pipe",
+    });
+    const parsed = JSON.parse(stdout);
+    const agents: AgentWorkspaceInfo[] = [];
+
+    // Handle both array format and wrapped format
+    const list = Array.isArray(parsed) ? parsed : parsed.agents ?? [];
+    for (const entry of list) {
+      agents.push({
+        id: String(entry.id ?? ""),
+        name: entry.name ?? entry.identityName,
+        workspace: String(entry.workspace ?? ""),
+        isDefault: Boolean(entry.isDefault),
+      });
+    }
+
+    // Ensure at least the default main agent is present
+    if (agents.length === 0) {
+      agents.push({
+        id: "main",
+        workspace: MAIN_WORKSPACE,
+        isDefault: true,
+      });
+    }
+
+    return agents;
+  } catch {
+    // Fallback: return default main agent if CLI fails
+    return [
+      {
+        id: "main",
+        workspace: MAIN_WORKSPACE,
+        isDefault: true,
+      },
+    ];
+  }
+}
+
+function collectExportFiles(
+  workspaceDir: string,
+  includeMemory: boolean,
+): { tempDir: string; files: string[] } {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentar-export-"));
+  const files: string[] = [];
+
+  for (const entry of fs.readdirSync(workspaceDir, { withFileTypes: true })) {
+    // 1. Skip metadata directories
+    if (entry.isDirectory() && EXPORT_SKIP_DIRS.includes(entry.name)) continue;
+
+    // 2. Skip skills/ (handled separately)
+    if (entry.name === "skills" && entry.isDirectory()) continue;
+
+    // 3. Skip files matching SKIP_FILES (AGENTS.md, BOOTSTRAP.md)
+    if (SKIP_FILES.includes(entry.name)) continue;
+
+    // 4. Conditionally skip MEMORY.md
+    if (entry.name === "MEMORY.md" && !includeMemory) continue;
+
+    // 5. Skip hidden files/directories
+    if (entry.name.startsWith(".")) continue;
+
+    // 6. Copy to temp directory
+    const src = path.join(workspaceDir, entry.name);
+    const dest = path.join(tempDir, entry.name);
+    if (entry.isDirectory()) {
+      fs.cpSync(src, dest, { recursive: true });
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+    files.push(entry.name);
+  }
+
+  // 7. Handle skills/ separately
+  const skillsDir = path.join(workspaceDir, "skills");
+  if (fs.existsSync(skillsDir)) {
+    fs.cpSync(skillsDir, path.join(tempDir, "skills"), { recursive: true });
+    files.push("skills");
+  }
+
+  return { tempDir, files };
+}
+
+// ─── Export Pipeline ────────────────────────────────────────────────────────
+
+async function exportAgentar(opts: {
+  agentName: string;
+  outputPath?: string;
+  includeMemory?: boolean;
+  quiet?: boolean;
+}): Promise<ExportResult> {
+  const { agentName, includeMemory = false, quiet } = opts;
+  const log = quiet ? () => {} : step;
+  const logDetail = quiet ? () => {} : detail;
+  const total = 3;
+
+  // [1/3] Validate workspace
+  log(1, total, "Validating workspace ...");
+  const agents = discoverAgents();
+  const agent = agents.find((a) => a.id === agentName);
+  if (!agent) {
+    const available = agents.map((a) => a.id).join(", ");
+    throw new Error(
+      `Agent "${agentName}" not found. Available agents: ${available}`,
+    );
+  }
+
+  const workspaceDir = agent.workspace;
+  if (!fs.existsSync(workspaceDir)) {
+    throw new Error(
+      `Workspace directory does not exist: ${workspaceDir}`,
+    );
+  }
+  if (!fs.existsSync(path.join(workspaceDir, "SOUL.md"))) {
+    throw new Error(
+      `Invalid workspace: missing SOUL.md in ${workspaceDir}`,
+    );
+  }
+  logDetail("workspace", workspaceDir);
+  logDetail("SOUL.md", "found");
+
+  // [2/3] Collect files
+  log(2, total, "Collecting files ...");
+  const { tempDir, files } = collectExportFiles(workspaceDir, includeMemory);
+
+  // Preview collected content
+  const skillsDir = path.join(tempDir, "skills");
+  const skillCount = fs.existsSync(skillsDir)
+    ? fs
+        .readdirSync(skillsDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory()).length
+    : 0;
+  const filesDesc = files.filter((f) => f !== "skills").join(", ");
+  logDetail(
+    "files",
+    skillCount > 0
+      ? `${filesDesc}, skills/ (${skillCount} skills)`
+      : filesDesc,
+  );
+
+  // [3/3] Create ZIP package
+  log(3, total, "Creating ZIP package ...");
+  const resolvedOutput = path.resolve(
+    opts.outputPath || `./${agentName}.zip`,
+  );
+  logDetail("output", resolvedOutput);
+
+  try {
+    if (process.platform === "win32") {
+      execSync(
+        `powershell -NoProfile -Command "Compress-Archive -Force -Path '${tempDir}\\*' -DestinationPath '${resolvedOutput}'"`,
+        { encoding: "utf-8" },
+      );
+    } else {
+      execSync(`cd "${tempDir}" && zip -r -q "${resolvedOutput}" .`, {
+        encoding: "utf-8",
+      });
+    }
+  } catch (err) {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    throw new Error(
+      `Failed to create ZIP: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+
+  fs.rmSync(tempDir, { recursive: true, force: true });
+
+  return {
+    success: true,
+    agentName,
+    workspace: workspaceDir,
+    outputPath: resolvedOutput,
+    files,
+    includeMemory,
+  };
+}
+
 // ─── Install Pipeline ────────────────────────────────────────────────────────
 
 async function installAgentar(opts: {
@@ -257,9 +470,16 @@ async function installAgentar(opts: {
   const extractDir = path.join(tmpDir, "extracted");
   fs.mkdirSync(extractDir, { recursive: true });
   try {
-    execSync(`unzip -o -q "${zipPath}" -d "${extractDir}"`, {
-      encoding: "utf-8",
-    });
+    if (process.platform === "win32") {
+      execSync(
+        `powershell -NoProfile -Command "Expand-Archive -Force -Path '${zipPath}' -DestinationPath '${extractDir}'"`,
+        { encoding: "utf-8" },
+      );
+    } else {
+      execSync(`unzip -o -q "${zipPath}" -d "${extractDir}"`, {
+        encoding: "utf-8",
+      });
+    }
   } catch {
     fs.rmSync(tmpDir, { recursive: true, force: true });
     throw new Error(`Failed to extract agentar zip for "${slug}"`);
@@ -476,6 +696,8 @@ export default function register(api: OpenClawPluginApi) {
         "1. When user asks to install/switch agent persona, use the `agentar_install` tool.",
         "2. Always confirm with the user before overwriting the main agent workspace.",
         "3. When installing, ask if the user wants to overwrite the main agent or create a new one.",
+        "4. When user asks to export/share/package an agent, use the `agentar_export` tool.",
+        "5. Call agentar_export without parameters first to show available agents, then let user choose.",
       ].join("\n"),
     }),
     { priority: 80 },
@@ -547,6 +769,78 @@ export default function register(api: OpenClawPluginApi) {
     { name: "agentar_install" },
   );
 
+  // ── Tool: agentar_export ──────────────────────────────────────────────
+
+  api.registerTool(
+    () => ({
+      name: "agentar_export",
+      description:
+        "Export an agent workspace as a distributable ZIP package. Call without agentName to list available agents first. Returns agent list when agentName is omitted, or export result when agentName is provided.",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          agentName: {
+            type: "string",
+            description:
+              "Agent ID to export (e.g. 'main'). Omit to list available agents.",
+          },
+          outputPath: {
+            type: "string",
+            description:
+              "Output ZIP file path. Defaults to ./<agentName>.zip",
+          },
+          includeMemory: {
+            type: "boolean",
+            description:
+              "Whether to include MEMORY.md in the export (default: false)",
+          },
+        },
+        required: [],
+      },
+      execute: async (params: Record<string, unknown>) => {
+        const agentName = params.agentName
+          ? String(params.agentName)
+          : undefined;
+        const outputPath = params.outputPath
+          ? String(params.outputPath)
+          : undefined;
+        const includeMemory = Boolean(params.includeMemory ?? false);
+
+        // No agentName → return available agents list
+        if (!agentName) {
+          try {
+            const agents = discoverAgents();
+            return {
+              agents: agents.map((a) => ({
+                ...a,
+                exists: fs.existsSync(a.workspace),
+              })),
+            };
+          } catch (err) {
+            return {
+              error: `Failed to discover agents: ${err instanceof Error ? err.message : String(err)}`,
+            };
+          }
+        }
+
+        // agentName provided → execute export
+        try {
+          return await exportAgentar({
+            agentName,
+            outputPath,
+            includeMemory,
+            quiet: true,
+          });
+        } catch (err) {
+          return {
+            error: `Export failed: ${err instanceof Error ? err.message : String(err)}`,
+          };
+        }
+      },
+    }),
+    { name: "agentar_export" },
+  );
+
   // ── CLI: openclaw agentar ──────────────────────────────────────────────
 
   api.registerCli(
@@ -744,6 +1038,206 @@ export default function register(api: OpenClawPluginApi) {
             }
           },
         );
+
+      // ── export ────────────────────────────────────────────────────────
+
+      agentarCmd
+        .command("export")
+        .description("Export an agent workspace as a ZIP package")
+        .option("--agent <id>", "Agent ID to export")
+        .option("-o, --output <path>", "Output ZIP file path")
+        .option("--include-memory", "Include MEMORY.md in export")
+        .option("--json", "Output result as JSON")
+        .action(
+          async (opts: {
+            agent?: string;
+            output?: string;
+            includeMemory?: boolean;
+            json?: boolean;
+          }) => {
+            try {
+              // Discover available agents
+              const agents = discoverAgents();
+
+              let selectedAgent: AgentWorkspaceInfo;
+
+              if (opts.agent) {
+                // Non-interactive: use provided agent ID
+                const found = agents.find((a) => a.id === opts.agent);
+                if (!found) {
+                  const available = agents
+                    .map((a) => a.id)
+                    .join(", ");
+                  console.error(
+                    `Agent "${opts.agent}" not found. Available: ${available}`,
+                  );
+                  process.exit(1);
+                }
+                selectedAgent = found;
+              } else {
+                // Interactive: let user choose
+                console.log("\n⟩ Discovering agents ...\n");
+                console.log("  Available agents:");
+                for (let i = 0; i < agents.length; i++) {
+                  const a = agents[i];
+                  const exists = fs.existsSync(a.workspace);
+                  const defaultTag = a.isDefault ? "  [default]" : "";
+                  const notFound = exists ? "" : "  (not found)";
+                  console.log(
+                    `  [${i + 1}] ${a.id} (${a.workspace})${defaultTag}${notFound}`,
+                  );
+                }
+
+                const readline = await import("node:readline");
+                const rl = readline.createInterface({
+                  input: process.stdin,
+                  output: process.stdout,
+                });
+
+                const answer = await new Promise<string>((resolve) => {
+                  rl.question(
+                    `\n  Select agent (default: 1): `,
+                    (ans: string) => {
+                      rl.close();
+                      resolve(ans.trim());
+                    },
+                  );
+                });
+
+                const idx = answer ? parseInt(answer, 10) - 1 : 0;
+                if (idx < 0 || idx >= agents.length) {
+                  console.error("Invalid selection.");
+                  process.exit(1);
+                }
+                selectedAgent = agents[idx];
+              }
+
+              // Include memory?
+              let includeMemory = opts.includeMemory ?? false;
+              if (!opts.agent && !opts.includeMemory) {
+                const readline = await import("node:readline");
+                const rl = readline.createInterface({
+                  input: process.stdin,
+                  output: process.stdout,
+                });
+                const memAnswer = await new Promise<string>((resolve) => {
+                  rl.question(
+                    "  Include MEMORY.md? (y/N): ",
+                    (ans: string) => {
+                      rl.close();
+                      resolve(ans.trim().toLowerCase());
+                    },
+                  );
+                });
+                includeMemory = memAnswer === "y" || memAnswer === "yes";
+              }
+
+              // Output path
+              let outputPath = opts.output;
+              if (!opts.agent && !opts.output) {
+                const defaultPath = `./${selectedAgent.id}.zip`;
+                const readline = await import("node:readline");
+                const rl = readline.createInterface({
+                  input: process.stdin,
+                  output: process.stdout,
+                });
+                const pathAnswer = await new Promise<string>((resolve) => {
+                  rl.question(
+                    `  Output path (default: ${defaultPath}): `,
+                    (ans: string) => {
+                      rl.close();
+                      resolve(ans.trim());
+                    },
+                  );
+                });
+                outputPath = pathAnswer || defaultPath;
+              }
+
+              // Check if output file already exists (interactive mode)
+              const resolvedOutput = path.resolve(
+                outputPath || `./${selectedAgent.id}.zip`,
+              );
+              if (!opts.agent && fs.existsSync(resolvedOutput)) {
+                const readline = await import("node:readline");
+                const rl = readline.createInterface({
+                  input: process.stdin,
+                  output: process.stdout,
+                });
+                const overwrite = await new Promise<string>((resolve) => {
+                  rl.question(
+                    `  File "${resolvedOutput}" already exists. Overwrite? (y/N): `,
+                    (ans: string) => {
+                      rl.close();
+                      resolve(ans.trim().toLowerCase());
+                    },
+                  );
+                });
+                if (overwrite !== "y" && overwrite !== "yes") {
+                  console.log("  Export cancelled.");
+                  return;
+                }
+              }
+
+              console.log(
+                `\n⟩ Exporting agent "${selectedAgent.id}" ...`,
+              );
+
+              const result = await exportAgentar({
+                agentName: selectedAgent.id,
+                outputPath,
+                includeMemory,
+              });
+
+              if (opts.json) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+              }
+
+              success("Export complete");
+              console.log("  Summary:");
+              console.log(`    agent       ${result.agentName}`);
+              console.log(`    workspace   ${result.workspace}`);
+              console.log(`    output      ${result.outputPath}`);
+              if (result.files.length > 0) {
+                const skillsEntry = result.files.includes("skills");
+                const nonSkillFiles = result.files.filter(
+                  (f) => f !== "skills",
+                );
+                let filesLine = nonSkillFiles.join(", ");
+                if (skillsEntry) {
+                  const exportSkillsDir = path.join(
+                    result.workspace,
+                    "skills",
+                  );
+                  const skillCount = fs.existsSync(exportSkillsDir)
+                    ? fs
+                        .readdirSync(exportSkillsDir, {
+                          withFileTypes: true,
+                        })
+                        .filter((e) => e.isDirectory()).length
+                    : 0;
+                  filesLine +=
+                    skillCount > 0
+                      ? `, skills/ (${skillCount} skills)`
+                      : ", skills/";
+                }
+                console.log(`    files       ${filesLine}`);
+              }
+              if (result.includeMemory) {
+                console.log("    memory      included");
+              }
+
+              console.log(
+                `\n  Use "openclaw agentar install <slug>" with the exported ZIP to install elsewhere.\n`,
+              );
+            } catch (err) {
+              console.error(
+                `\nExport failed: ${err instanceof Error ? err.message : String(err)}`,
+              );
+              process.exit(1);
+            }
+          },
+        );
     },
     { commands: ["agentar"] },
   );

package/openclaw.plugin.json

@@ -1,5 +1,5 @@
 {
-  "id": "agentar",
+  "id": "openclaw-agentar",
   "name": "Agentar Plugin",
   "description": "Search, download, and install agent templates (agentars) from the marketplace.",
   "configSchema": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@catch-claw/openclaw-agentar",
-  "version": "1.0.0",
-  "description": "Search, download, and install agent templates (agentars) for OpenClaw",
+  "version": "1.1.0",
+  "description": "Search, download, install, and export agent templates (agentars) for OpenClaw",
   "license": "MIT",
   "type": "module",
   "openclaw": {