@catch-claw/openclaw-agentar 1.0.0

package/index.ts

@@ -0,0 +1,750 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+type AgentarConfig = {
+  apiBaseUrl?: string;
+};
+
+type AgentarMeta = {
+  slug: string;
+  name: string;
+  description: string;
+  version: string;
+  skills?: string[];
+};
+
+type AgentarSearchResult = {
+  slug: string;
+  displayName: string;
+  summary: string;
+  version: string;
+};
+
+type AgentarIndexEntry = AgentarMeta & {
+  zip_url?: string;
+};
+
+type InstallContext = {
+  slug: string;
+  mode: "overwrite" | "new";
+  agentName: string;
+  contentDir: string;
+  targetWorkspace: string;
+  metadata?: AgentarMeta;
+};
+
+type InstallHooks = {
+  beforeInstall?: (ctx: InstallContext) => Promise<void>;
+  afterInstall?: (ctx: InstallContext) => Promise<void>;
+};
+
+type InstallResult = {
+  success: boolean;
+  slug: string;
+  version?: string;
+  agentName: string;
+  workspace: string;
+  skills: string[];
+  files: string[];
+  introduction?: string | null;
+};
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const DEFAULT_API_BASE_URL = "http://127.0.0.1:8080";
+const OPENCLAW_HOME = path.join(os.homedir(), ".openclaw");
+const MAIN_WORKSPACE = path.join(OPENCLAW_HOME, "workspace");
+const WORKSPACES_DIR = path.join(OPENCLAW_HOME, "agentar-workspaces");
+const WORKSPACE_FILES = [
+  "SOUL.md",
+  "USER.md",
+  "IDENTITY.md",
+  "TOOLS.md",
+  "HEARTBEAT.md",
+  "MEMORY.md",
+];
+const SKIP_FILES = ["AGENTS.md", "BOOTSTRAP.md"];
+const INTRO_MESSAGE =
+  "请做一下自我介绍，简要说明你是谁、你擅长什么、你能帮用户做哪些事情。";
+
+// ─── Fetch Helpers ───────────────────────────────────────────────────────────
+
+async function fetchJson<T>(url: string): Promise<T> {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
+  return res.json() as Promise<T>;
+}
+
+async function fetchToFile(url: string, dest: string): Promise<void> {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`HTTP ${res.status} for ${url}`);
+  const buffer = Buffer.from(await res.arrayBuffer());
+  fs.writeFileSync(dest, buffer);
+}
+
+// ─── Output Helpers ──────────────────────────────────────────────────────────
+
+function step(n: number, total: number, msg: string): void {
+  console.log(`\n  [${n}/${total}] ${msg}`);
+}
+
+function detail(label: string, value: string): void {
+  console.log(`        ${label}: ${value}`);
+}
+
+function success(msg: string): void {
+  console.log(`\n  ✓ ${msg}\n`);
+}
+
+function warn(msg: string): void {
+  console.log(`        ⚠ ${msg}`);
+}
+
+function box(text: string): void {
+  const lines = text.split("\n").filter(Boolean);
+  const maxLen = Math.max(...lines.map((l) => l.length));
+  const border = "─".repeat(maxLen + 2);
+  console.log(`  ┌${border}┐`);
+  for (const line of lines) {
+    console.log(`  │ ${line.padEnd(maxLen)} │`);
+  }
+  console.log(`  └${border}┘`);
+}
+
+// ─── Core Utilities ──────────────────────────────────────────────────────────
+
+function findOpenclawBin(): string {
+  try {
+    return execSync("which openclaw", { encoding: "utf-8" }).trim();
+  } catch {
+    const pnpmPath = path.join(os.homedir(), ".local/share/pnpm/openclaw");
+    if (fs.existsSync(pnpmPath)) return pnpmPath;
+    throw new Error("openclaw CLI not found on PATH");
+  }
+}
+
+function backupDirectory(dir: string): string | null {
+  if (!fs.existsSync(dir)) return null;
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupDir = `${dir}.bak.${timestamp}`;
+  fs.cpSync(dir, backupDir, { recursive: true });
+  return backupDir;
+}
+
+function mergeSkills(srcSkillsDir: string, destSkillsDir: string): string[] {
+  if (!fs.existsSync(srcSkillsDir)) return [];
+  fs.mkdirSync(destSkillsDir, { recursive: true });
+
+  const merged: string[] = [];
+  for (const entry of fs.readdirSync(srcSkillsDir, { withFileTypes: true })) {
+    const srcPath = path.join(srcSkillsDir, entry.name);
+    const destPath = path.join(destSkillsDir, entry.name);
+    if (entry.isDirectory()) {
+      fs.cpSync(srcPath, destPath, { recursive: true });
+      merged.push(entry.name);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+  return merged;
+}
+
+function extractWorkspaceFiles(
+  extractedDir: string,
+  targetDir: string,
+): string[] {
+  fs.mkdirSync(targetDir, { recursive: true });
+  const copiedFiles: string[] = [];
+
+  for (const file of WORKSPACE_FILES) {
+    const src = path.join(extractedDir, file);
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, path.join(targetDir, file));
+      copiedFiles.push(file);
+    }
+  }
+
+  for (const entry of fs.readdirSync(extractedDir, { withFileTypes: true })) {
+    if (entry.name === "skills" && entry.isDirectory()) continue;
+    if (SKIP_FILES.includes(entry.name)) continue;
+    if (WORKSPACE_FILES.includes(entry.name)) continue;
+    const src = path.join(extractedDir, entry.name);
+    const dest = path.join(targetDir, entry.name);
+    if (entry.isDirectory()) {
+      fs.cpSync(src, dest, { recursive: true });
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+    copiedFiles.push(entry.name);
+  }
+
+  return copiedFiles;
+}
+
+function resolveContentDir(extractDir: string): string {
+  const entries = fs
+    .readdirSync(extractDir)
+    .filter((e) => !e.startsWith(".") && e !== "__MACOSX");
+  if (
+    entries.length === 1 &&
+    fs.statSync(path.join(extractDir, entries[0])).isDirectory()
+  ) {
+    return path.join(extractDir, entries[0]);
+  }
+  return extractDir;
+}
+
+// ─── Install Pipeline ────────────────────────────────────────────────────────
+
+async function installAgentar(opts: {
+  slug: string;
+  mode: "overwrite" | "new";
+  agentName?: string;
+  apiBaseUrl: string;
+  hooks?: InstallHooks;
+  quiet?: boolean;
+}): Promise<InstallResult> {
+  const { slug, mode, apiBaseUrl, hooks, quiet } = opts;
+  const log = quiet ? () => {} : step;
+  const logDetail = quiet ? () => {} : detail;
+  const total = 5;
+
+  // [1/5] Fetch metadata
+  log(1, total, "Fetching metadata ...");
+  let metadata: AgentarMeta | undefined;
+  try {
+    const data = await fetchJson<{ agentars: AgentarIndexEntry[] }>(
+      `${apiBaseUrl}/api/v1/agentar/index`,
+    );
+    const entry = data.agentars?.find((a) => a.slug === slug);
+    if (entry) {
+      metadata = {
+        slug: entry.slug,
+        name: entry.name,
+        description: entry.description,
+        version: entry.version,
+        skills: entry.skills,
+      };
+      logDetail("name", metadata.name);
+      logDetail("version", metadata.version);
+      logDetail("description", metadata.description);
+    }
+  } catch {
+    // Metadata fetch is best-effort — continue without it
+  }
+
+  // [2/5] Download package
+  log(2, total, "Downloading package ...");
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentar-"));
+  const zipPath = path.join(tmpDir, `${slug}.zip`);
+  const downloadUrl = `${apiBaseUrl}/api/v1/agentar/download?slug=${encodeURIComponent(slug)}`;
+  logDetail("source", downloadUrl);
+
+  try {
+    await fetchToFile(downloadUrl, zipPath);
+  } catch (err) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    throw new Error(`Failed to download agentar "${slug}": ${err}`);
+  }
+
+  // [3/5] Extract and validate
+  log(3, total, "Extracting and validating ...");
+  const extractDir = path.join(tmpDir, "extracted");
+  fs.mkdirSync(extractDir, { recursive: true });
+  try {
+    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}"`);
+  }
+
+  const contentDir = resolveContentDir(extractDir);
+
+  if (!fs.existsSync(path.join(contentDir, "SOUL.md"))) {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    throw new Error(`Invalid agentar "${slug}": missing SOUL.md`);
+  }
+
+  // Preview extracted content
+  const previewFiles = fs
+    .readdirSync(contentDir)
+    .filter((e) => !e.startsWith(".") && e !== "__MACOSX");
+  const skillsDir = path.join(contentDir, "skills");
+  const skillCount = fs.existsSync(skillsDir)
+    ? fs
+        .readdirSync(skillsDir, { withFileTypes: true })
+        .filter((e) => e.isDirectory()).length
+    : 0;
+  const filesDesc = previewFiles.filter((f) => f !== "skills").join(", ");
+  logDetail(
+    "files",
+    skillCount > 0
+      ? `${filesDesc}, skills/ (${skillCount} skills)`
+      : filesDesc,
+  );
+
+  // Determine agent name
+  const agentName =
+    mode === "overwrite"
+      ? "main"
+      : opts.agentName || slug.replace(/[^a-zA-Z0-9_-]/g, "-");
+
+  // beforeInstall hook
+  const ctx: InstallContext = {
+    slug,
+    mode,
+    agentName,
+    contentDir,
+    targetWorkspace: "",
+    metadata,
+  };
+
+  if (hooks?.beforeInstall) {
+    await hooks.beforeInstall(ctx);
+  }
+
+  // [4/5] Deploy to workspace
+  log(4, total, "Deploying to workspace ...");
+  let targetWorkspace: string;
+
+  if (mode === "overwrite") {
+    const backupPath = backupDirectory(MAIN_WORKSPACE);
+    if (backupPath && !quiet) {
+      logDetail("backup", backupPath);
+    }
+    const copiedFiles = extractWorkspaceFiles(contentDir, MAIN_WORKSPACE);
+    const mergedSkills = mergeSkills(
+      path.join(contentDir, "skills"),
+      path.join(MAIN_WORKSPACE, "skills"),
+    );
+    targetWorkspace = MAIN_WORKSPACE;
+    logDetail("mode", "overwrite main agent");
+    logDetail("workspace", targetWorkspace);
+    if (mergedSkills.length > 0) {
+      logDetail("skills merged", mergedSkills.join(", "));
+    }
+
+    ctx.targetWorkspace = targetWorkspace;
+
+    if (hooks?.afterInstall) {
+      await hooks.afterInstall(ctx);
+    }
+
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+
+    return {
+      success: true,
+      slug,
+      version: metadata?.version,
+      agentName: "main",
+      workspace: targetWorkspace,
+      skills: mergedSkills,
+      files: copiedFiles,
+    };
+  }
+
+  // mode === "new"
+  const workspaceDir = path.join(WORKSPACES_DIR, agentName);
+  fs.mkdirSync(workspaceDir, { recursive: true });
+
+  const openclawBin = findOpenclawBin();
+  try {
+    execSync(
+      `"${openclawBin}" agents add "${agentName}" --workspace "${workspaceDir}" --non-interactive`,
+      { encoding: "utf-8", stdio: "pipe" },
+    );
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!msg.includes("already exists")) {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+      throw new Error(`Failed to create agent "${agentName}": ${msg}`);
+    }
+  }
+
+  const copiedFiles = extractWorkspaceFiles(contentDir, workspaceDir);
+  const mergedSkills = mergeSkills(
+    path.join(contentDir, "skills"),
+    path.join(workspaceDir, "skills"),
+  );
+  targetWorkspace = workspaceDir;
+
+  logDetail("mode", "new agent");
+  logDetail("agent", agentName);
+  logDetail("workspace", targetWorkspace);
+  if (mergedSkills.length > 0) {
+    logDetail("skills merged", mergedSkills.join(", "));
+  }
+
+  ctx.targetWorkspace = targetWorkspace;
+
+  if (hooks?.afterInstall) {
+    await hooks.afterInstall(ctx);
+  }
+
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+
+  return {
+    success: true,
+    slug,
+    version: metadata?.version,
+    agentName,
+    workspace: targetWorkspace,
+    skills: mergedSkills,
+    files: copiedFiles,
+  };
+}
+
+// ─── Self-Introduction ───────────────────────────────────────────────────────
+
+async function sendIntroduction(opts: {
+  agentName: string;
+  mode: "overwrite" | "new";
+  runtime?: OpenClawPluginApi["runtime"];
+  quiet?: boolean;
+}): Promise<string | null> {
+  const { agentName, mode, runtime, quiet } = opts;
+  const log = quiet ? () => {} : step;
+  const logDetail = quiet ? () => {} : detail;
+  const logWarn = quiet ? () => {} : warn;
+
+  log(5, 5, "Activating agent ...");
+  logDetail("action", "Sending introduction request ...");
+
+  // Tool mode: use runtime.subagent.run
+  if (runtime?.subagent) {
+    try {
+      const sessionKey =
+        mode === "overwrite"
+          ? "agent:main:session:main"
+          : `agent:${agentName}:session:main`;
+      const result = await runtime.subagent.run({
+        sessionKey,
+        message: INTRO_MESSAGE,
+      });
+      const reply =
+        typeof result === "object" && result !== null && "reply" in result
+          ? String((result as Record<string, unknown>).reply ?? "")
+          : typeof result === "string"
+            ? result
+            : "";
+      if (reply) return reply;
+    } catch {
+      logWarn("Could not reach agent via runtime");
+    }
+    return null;
+  }
+
+  // CLI mode: use execSync
+  try {
+    const openclawBin = findOpenclawBin();
+    const agentFlag = mode === "new" ? ` --agent "${agentName}"` : "";
+    const stdout = execSync(
+      `"${openclawBin}" agent${agentFlag} --message "${INTRO_MESSAGE}" --local`,
+      { encoding: "utf-8", stdio: "pipe", timeout: 60_000 },
+    );
+    return stdout.trim() || null;
+  } catch {
+    const agentFlag = mode === "new" ? ` --agent ${agentName}` : "";
+    logWarn("Could not reach agent (gateway not running?)");
+    logWarn(
+      `Try manually: openclaw agent${agentFlag} --message "请自我介绍" --local`,
+    );
+    return null;
+  }
+}
+
+// ─── Plugin Registration ─────────────────────────────────────────────────────
+
+export default function register(api: OpenClawPluginApi) {
+  const rawConfig = (api.pluginConfig ?? {}) as AgentarConfig;
+  const apiBaseUrl = rawConfig.apiBaseUrl?.trim() || DEFAULT_API_BASE_URL;
+
+  // ── Hook: inject agentar policy ──────────────────────────────────────────
+
+  api.on(
+    "before_prompt_build",
+    async () => ({
+      prependContext: [
+        "Agent template (agentar) policy (operator configured):",
+        "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.",
+      ].join("\n"),
+    }),
+    { priority: 80 },
+  );
+
+  // ── Tool: agentar_install ──────────────────────────────────────────────
+
+  api.registerTool(
+    () => ({
+      name: "agentar_install",
+      description:
+        "Install an agent template (agentar) from the marketplace. Downloads a zip containing workspace files (SOUL.md, skills, etc.) and either overwrites the main agent or creates a new one. Returns installation details and the agent's self-introduction.",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          slug: {
+            type: "string",
+            description: "The agentar slug to install",
+          },
+          mode: {
+            type: "string",
+            enum: ["overwrite", "new"],
+            description:
+              "overwrite: replace main agent workspace; new: create a new agent",
+          },
+          agentName: {
+            type: "string",
+            description:
+              "Name for the new agent (only used when mode=new, defaults to slug)",
+          },
+        },
+        required: ["slug", "mode"],
+      },
+      execute: async (params: Record<string, unknown>) => {
+        const slug = String(params.slug || "");
+        const mode = String(params.mode || "new") as "overwrite" | "new";
+        const agentName = params.agentName
+          ? String(params.agentName)
+          : undefined;
+
+        if (!slug) {
+          return { error: "slug is required" };
+        }
+
+        try {
+          const result = await installAgentar({
+            slug,
+            mode,
+            agentName,
+            apiBaseUrl,
+            quiet: true,
+          });
+
+          const introduction = await sendIntroduction({
+            agentName: result.agentName,
+            mode,
+            runtime: api.runtime,
+            quiet: true,
+          });
+
+          return { ...result, introduction };
+        } catch (err) {
+          return {
+            error: `Installation failed: ${err instanceof Error ? err.message : String(err)}`,
+          };
+        }
+      },
+    }),
+    { name: "agentar_install" },
+  );
+
+  // ── CLI: openclaw agentar ──────────────────────────────────────────────
+
+  api.registerCli(
+    (cliCtx) => {
+      const agentarCmd = cliCtx.program
+        .command("agentar")
+        .description("Manage agent templates (agentars)");
+
+      // ── search ─────────────────────────────────────────────────────────
+
+      agentarCmd
+        .command("search <query>")
+        .description("Search for agent templates")
+        .option("-l, --limit <n>", "Max results", "20")
+        .action(async (query: string, opts: { limit: string }) => {
+          try {
+            const url = `${apiBaseUrl}/api/v1/agentar/search?q=${encodeURIComponent(query)}&limit=${opts.limit}`;
+            const data = await fetchJson<{
+              results: AgentarSearchResult[];
+            }>(url);
+
+            if (!data.results || data.results.length === 0) {
+              console.log("No agentars found.");
+              return;
+            }
+
+            console.log(
+              '\nUse "openclaw agentar install <slug>" to install.\n',
+            );
+            for (const r of data.results) {
+              console.log(`  ${r.slug}  ${r.displayName}`);
+              if (r.summary) console.log(`    ${r.summary}`);
+              if (r.version) console.log(`    version: ${r.version}`);
+            }
+            console.log();
+          } catch (err) {
+            console.error(
+              `Search failed: ${err instanceof Error ? err.message : String(err)}`,
+            );
+            process.exit(1);
+          }
+        });
+
+      // ── list ───────────────────────────────────────────────────────────
+
+      agentarCmd
+        .command("list")
+        .description("List all available agent templates")
+        .action(async () => {
+          try {
+            const url = `${apiBaseUrl}/api/v1/agentar/index`;
+            const data = await fetchJson<{
+              agentars: AgentarIndexEntry[];
+            }>(url);
+
+            if (!data.agentars || data.agentars.length === 0) {
+              console.log("No agentars available.");
+              return;
+            }
+
+            console.log(
+              '\nUse "openclaw agentar install <slug>" to install.\n',
+            );
+            for (const a of data.agentars) {
+              console.log(`  ${a.slug}  ${a.name}`);
+              if (a.description) console.log(`    ${a.description}`);
+              if (a.version) console.log(`    version: ${a.version}`);
+              if (a.skills && a.skills.length > 0) {
+                console.log(`    skills: ${a.skills.join(", ")}`);
+              }
+            }
+            console.log();
+          } catch (err) {
+            console.error(
+              `List failed: ${err instanceof Error ? err.message : String(err)}`,
+            );
+            process.exit(1);
+          }
+        });
+
+      // ── install ────────────────────────────────────────────────────────
+
+      agentarCmd
+        .command("install <slug>")
+        .description("Install an agent template")
+        .option("--overwrite", "Overwrite the main agent workspace")
+        .option(
+          "--name <name>",
+          "Create a new agent with this name (implies new mode)",
+        )
+        .action(
+          async (
+            slug: string,
+            opts: {
+              overwrite?: boolean;
+              name?: string;
+            },
+          ) => {
+            let mode: "overwrite" | "new";
+
+            if (opts.overwrite) {
+              mode = "overwrite";
+            } else if (opts.name) {
+              mode = "new";
+            } else {
+              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(
+                  `\nInstall agentar "${slug}":\n  [1] Overwrite main agent (~/.openclaw/workspace)\n  [2] Create a new agent\nChoice (1/2): `,
+                  (ans: string) => {
+                    rl.close();
+                    resolve(ans.trim());
+                  },
+                );
+              });
+
+              mode = answer === "1" ? "overwrite" : "new";
+
+              if (mode === "new" && !opts.name) {
+                const rl2 = readline.createInterface({
+                  input: process.stdin,
+                  output: process.stdout,
+                });
+                opts.name = await new Promise<string>((resolve) => {
+                  rl2.question(
+                    `Agent name (default: ${slug}): `,
+                    (ans: string) => {
+                      rl2.close();
+                      resolve(ans.trim() || slug);
+                    },
+                  );
+                });
+              }
+            }
+
+            try {
+              console.log(`\n⟩ Installing agentar "${slug}" ...`);
+
+              const result = await installAgentar({
+                slug,
+                mode,
+                agentName: opts.name,
+                apiBaseUrl,
+              });
+
+              const introduction = await sendIntroduction({
+                agentName: result.agentName,
+                mode,
+              });
+
+              success("Installation complete");
+              console.log("  Summary:");
+              console.log(
+                `    agentar     ${result.slug}${result.version ? ` (v${result.version})` : ""}`,
+              );
+              console.log(`    agent       ${result.agentName}`);
+              console.log(`    workspace   ${result.workspace}`);
+              if (result.skills.length > 0) {
+                console.log(
+                  `    skills      ${result.skills.join(", ")}`,
+                );
+              }
+              if (result.files.length > 0) {
+                console.log(
+                  `    files       ${result.files.join(", ")}`,
+                );
+              }
+
+              if (introduction) {
+                console.log("\n  Agent introduction:");
+                box(introduction);
+              }
+
+              console.log("\n  Next steps:");
+              if (mode === "new") {
+                console.log(
+                  `    openclaw agent --agent ${result.agentName} --message "hello" --local`,
+                );
+              } else {
+                console.log(
+                  '    openclaw agent --message "hello" --local',
+                );
+              }
+              console.log();
+            } catch (err) {
+              console.error(
+                `\nInstall failed: ${err instanceof Error ? err.message : String(err)}`,
+              );
+              process.exit(1);
+            }
+          },
+        );
+    },
+    { commands: ["agentar"] },
+  );
+}

package/openclaw.plugin.json

@@ -0,0 +1,20 @@
+{
+  "id": "agentar",
+  "name": "Agentar Plugin",
+  "description": "Search, download, and install agent templates (agentars) from the marketplace.",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "apiBaseUrl": {
+        "type": "string"
+      }
+    }
+  },
+  "uiHints": {
+    "apiBaseUrl": {
+      "label": "API Base URL",
+      "help": "Base URL of the catchclaw-console backend (default: http://127.0.0.1:8080)"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@catch-claw/openclaw-agentar",
+  "version": "1.0.0",
+  "description": "Search, download, and install agent templates (agentars) for OpenClaw",
+  "license": "MIT",
+  "type": "module",
+  "openclaw": {
+    "extensions": ["./index.ts"]
+  },
+  "files": [
+    "index.ts",
+    "openclaw.plugin.json"
+  ],
+  "peerDependencies": {
+    "openclaw": "*"
+  }
+}