clawdentity 0.0.12 → 0.0.13

package/dist/index.js

@@ -6,8 +6,8 @@ var __export = (target, all) => {
 };
 
 // src/index.ts
-import { createRequire } from "module";
-import { Command as Command10 } from "commander";
+import { createRequire as createRequire2 } from "module";
+import { Command as Command11 } from "commander";
 
 // ../../packages/protocol/src/agent-registration-proof.ts
 var AGENT_REGISTRATION_PROOF_VERSION = "clawdentity.register.v1";
@@ -21167,13 +21167,7 @@ function resolveOpenclawConfigPath(openclawDir, homeDir) {
   return configCandidates[0];
 }
 function resolveDefaultTransformSource(openclawDir) {
-  return join6(
-    openclawDir,
-    "workspace",
-    "skills",
-    SKILL_DIR_NAME,
-    RELAY_MODULE_FILE_NAME
-  );
+  return join6(openclawDir, "skills", SKILL_DIR_NAME, RELAY_MODULE_FILE_NAME);
 }
 function resolveTransformTargetPath(openclawDir) {
   return join6(openclawDir, "hooks", "transforms", RELAY_MODULE_FILE_NAME);
@@ -21907,7 +21901,7 @@ async function runOpenclawDoctor(options = {}) {
           label: "Relay transform",
           status: "fail",
           message: "relay transform artifacts are missing or empty",
-          remediationHint: "Run: npm install clawdentity --skill",
+          remediationHint: "Run: clawdentity skill install",
           details: {
             transformTargetPath,
             relayTransformRuntimePath,
@@ -21937,7 +21931,7 @@ async function runOpenclawDoctor(options = {}) {
         label: "Relay transform",
         status: "fail",
         message: "missing relay transform artifacts",
-        remediationHint: "Run: npm install clawdentity --skill",
+        remediationHint: "Run: clawdentity skill install",
         details: {
           transformTargetPath,
           relayTransformRuntimePath,
@@ -22361,7 +22355,7 @@ var createOpenclawCommand = () => {
     "OpenClaw state directory (default ~/.openclaw)"
   ).option(
     "--transform-source <path>",
-    "Path to relay-to-peer.mjs (default <openclaw-dir>/workspace/skills/clawdentity-openclaw-relay/relay-to-peer.mjs)"
+    "Path to relay-to-peer.mjs (default <openclaw-dir>/skills/clawdentity-openclaw-relay/relay-to-peer.mjs)"
   ).option(
     "--openclaw-base-url <url>",
     "Base URL for local OpenClaw hook API (default http://127.0.0.1:18789)"
@@ -23296,9 +23290,341 @@ var createPairCommand = (dependencies = {}) => {
   return pairCommand;
 };
 
-// src/commands/verify.ts
-import { readFile as readFile6 } from "fs/promises";
+// src/commands/skill.ts
 import { Command as Command9 } from "commander";
+
+// src/install-skill-mode.ts
+import { constants, existsSync as existsSync2 } from "fs";
+import { access as access3, copyFile as copyFile2, mkdir as mkdir7, readdir as readdir2, readFile as readFile6 } from "fs/promises";
+import { createRequire } from "module";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname6, join as join8, relative } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var OPENCLAW_DIR_NAME2 = ".openclaw";
+var SKILL_PACKAGE_NAME = "@clawdentity/openclaw-skill";
+var SKILL_DIR_NAME2 = "clawdentity-openclaw-relay";
+var RELAY_MODULE_FILE_NAME2 = "relay-to-peer.mjs";
+function isRecord10(value) {
+  return typeof value === "object" && value !== null;
+}
+var SkillInstallError = class extends Error {
+  code;
+  details;
+  constructor(input) {
+    super(input.message);
+    this.name = "SkillInstallError";
+    this.code = input.code;
+    this.details = input.details ?? {};
+  }
+};
+function getErrorCode3(error48) {
+  if (!isRecord10(error48)) {
+    return void 0;
+  }
+  return typeof error48.code === "string" ? error48.code : void 0;
+}
+function resolveHomeDir2(inputHomeDir) {
+  if (typeof inputHomeDir === "string" && inputHomeDir.trim().length > 0) {
+    return inputHomeDir.trim();
+  }
+  return homedir4();
+}
+function resolveOpenclawDir2(homeDir, inputOpenclawDir) {
+  if (typeof inputOpenclawDir === "string" && inputOpenclawDir.trim().length > 0) {
+    return inputOpenclawDir.trim();
+  }
+  return join8(homeDir, OPENCLAW_DIR_NAME2);
+}
+function resolveSkillPackageRoot(input) {
+  if (typeof input.skillPackageRoot === "string" && input.skillPackageRoot.trim().length > 0) {
+    return input.skillPackageRoot.trim();
+  }
+  const overriddenRoot = input.env.CLAWDENTITY_SKILL_PACKAGE_ROOT;
+  if (typeof overriddenRoot === "string" && overriddenRoot.trim().length > 0) {
+    return overriddenRoot.trim();
+  }
+  const bundledSkillRoot = join8(
+    dirname6(fileURLToPath2(import.meta.url)),
+    "..",
+    "skill-bundle",
+    "openclaw-skill"
+  );
+  if (existsSync2(bundledSkillRoot)) {
+    return bundledSkillRoot;
+  }
+  const require3 = createRequire(import.meta.url);
+  let packageJsonPath;
+  try {
+    packageJsonPath = require3.resolve(`${SKILL_PACKAGE_NAME}/package.json`);
+    return dirname6(packageJsonPath);
+  } catch {
+    const workspaceFallbackRoot = join8(
+      dirname6(fileURLToPath2(import.meta.url)),
+      "..",
+      "..",
+      "openclaw-skill"
+    );
+    if (existsSync2(workspaceFallbackRoot)) {
+      return workspaceFallbackRoot;
+    }
+    throw new SkillInstallError({
+      code: "CLI_SKILL_PACKAGE_NOT_FOUND",
+      message: "Skill artifacts are unavailable. Set CLAWDENTITY_SKILL_PACKAGE_ROOT or provide bundled skill assets before running skill install.",
+      details: {
+        packageName: SKILL_PACKAGE_NAME,
+        bundledSkillRoot,
+        workspaceFallbackRoot
+      }
+    });
+  }
+}
+async function assertReadableFile(filePath, details) {
+  try {
+    await access3(filePath, constants.R_OK);
+  } catch (error48) {
+    if (getErrorCode3(error48) === "ENOENT") {
+      throw new SkillInstallError({
+        code: "CLI_SKILL_ARTIFACT_MISSING",
+        message: "Required skill artifact is missing",
+        details: {
+          ...details,
+          sourcePath: filePath
+        }
+      });
+    }
+    throw error48;
+  }
+}
+async function listFilesRecursively(directoryPath) {
+  const entries = await readdir2(directoryPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries.sort(
+    (left, right) => left.name.localeCompare(right.name)
+  )) {
+    const entryPath = join8(directoryPath, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFilesRecursively(entryPath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(entryPath);
+    }
+  }
+  return files;
+}
+async function resolveArtifacts(input) {
+  const skillRoot = join8(input.skillPackageRoot, "skill");
+  const skillDocSource = join8(skillRoot, "SKILL.md");
+  const referencesRoot = join8(skillRoot, "references");
+  const relaySource = join8(
+    input.skillPackageRoot,
+    "dist",
+    RELAY_MODULE_FILE_NAME2
+  );
+  await assertReadableFile(skillDocSource, {
+    artifact: "SKILL.md"
+  });
+  await assertReadableFile(relaySource, {
+    artifact: RELAY_MODULE_FILE_NAME2
+  });
+  let referenceFiles;
+  try {
+    referenceFiles = await listFilesRecursively(referencesRoot);
+  } catch (error48) {
+    if (getErrorCode3(error48) === "ENOENT") {
+      throw new SkillInstallError({
+        code: "CLI_SKILL_ARTIFACT_MISSING",
+        message: "Required skill references directory is missing",
+        details: {
+          sourcePath: referencesRoot,
+          artifact: "references"
+        }
+      });
+    }
+    throw error48;
+  }
+  if (referenceFiles.length === 0) {
+    throw new SkillInstallError({
+      code: "CLI_SKILL_REFERENCE_DIR_EMPTY",
+      message: "Required skill references directory is empty",
+      details: {
+        sourcePath: referencesRoot
+      }
+    });
+  }
+  const targetSkillRoot = join8(
+    input.openclawDir,
+    "skills",
+    SKILL_DIR_NAME2
+  );
+  const artifacts = [
+    {
+      sourcePath: skillDocSource,
+      targetPath: join8(targetSkillRoot, "SKILL.md")
+    },
+    {
+      sourcePath: relaySource,
+      targetPath: join8(targetSkillRoot, RELAY_MODULE_FILE_NAME2)
+    },
+    {
+      sourcePath: relaySource,
+      targetPath: join8(
+        input.openclawDir,
+        "hooks",
+        "transforms",
+        RELAY_MODULE_FILE_NAME2
+      )
+    }
+  ];
+  for (const referenceFile of referenceFiles) {
+    const relativePath = relative(referencesRoot, referenceFile);
+    artifacts.push({
+      sourcePath: referenceFile,
+      targetPath: join8(targetSkillRoot, "references", relativePath)
+    });
+  }
+  return artifacts.sort(
+    (left, right) => left.targetPath.localeCompare(right.targetPath)
+  );
+}
+async function copyArtifact(input) {
+  const sourceContent = await readFile6(input.sourcePath);
+  let existingContent;
+  try {
+    existingContent = await readFile6(input.targetPath);
+  } catch (error48) {
+    if (getErrorCode3(error48) !== "ENOENT") {
+      throw error48;
+    }
+  }
+  if (existingContent !== void 0 && sourceContent.equals(existingContent)) {
+    return "unchanged";
+  }
+  await mkdir7(dirname6(input.targetPath), { recursive: true });
+  await copyFile2(input.sourcePath, input.targetPath);
+  if (existingContent !== void 0) {
+    return "updated";
+  }
+  return "installed";
+}
+async function installOpenclawSkillArtifacts(options = {}) {
+  const env = options.env ?? process.env;
+  const homeDir = resolveHomeDir2(options.homeDir);
+  const openclawDir = resolveOpenclawDir2(homeDir, options.openclawDir);
+  const skillPackageRoot = resolveSkillPackageRoot({
+    skillPackageRoot: options.skillPackageRoot,
+    env
+  });
+  const artifacts = await resolveArtifacts({
+    skillPackageRoot,
+    openclawDir
+  });
+  const records = [];
+  for (const artifact of artifacts) {
+    const action = await copyArtifact(artifact);
+    records.push({
+      action,
+      sourcePath: artifact.sourcePath,
+      targetPath: artifact.targetPath
+    });
+  }
+  return {
+    homeDir,
+    openclawDir,
+    skillPackageRoot,
+    targetSkillDirectory: join8(openclawDir, "skills", SKILL_DIR_NAME2),
+    records
+  };
+}
+function formatSkillInstallError(error48) {
+  if (error48 instanceof SkillInstallError) {
+    const details = Object.entries(error48.details).map(([key, value]) => `${key}=${value}`).join(" ");
+    if (details.length === 0) {
+      return `${error48.code}: ${error48.message}`;
+    }
+    return `${error48.code}: ${error48.message} (${details})`;
+  }
+  if (error48 instanceof Error) {
+    return error48.message;
+  }
+  return String(error48);
+}
+
+// src/commands/skill.ts
+function collectStringOption(value, previous) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return previous;
+  }
+  return [...previous, trimmed];
+}
+function toInstallSummary(records) {
+  const installed = records.filter((record2) => record2.action === "installed");
+  const updated = records.filter((record2) => record2.action === "updated");
+  const unchanged = records.filter((record2) => record2.action === "unchanged");
+  return `installed=${installed.length} updated=${updated.length} unchanged=${unchanged.length}`;
+}
+async function runSkillInstall(options) {
+  const requestedDirs = (options.openclawDir ?? []).filter(
+    (dir) => dir.trim().length > 0
+  );
+  const dirs = requestedDirs.length > 0 ? requestedDirs : [void 0];
+  const results = [];
+  for (const openclawDir of dirs) {
+    const result = await installOpenclawSkillArtifacts({
+      openclawDir,
+      skillPackageRoot: options.skillPackageRoot
+    });
+    results.push(result);
+  }
+  return results;
+}
+var createSkillCommand = () => {
+  const skillCommand = new Command9("skill").description(
+    "Install and manage Clawdentity skill artifacts"
+  );
+  skillCommand.command("install").description("Install Clawdentity OpenClaw skill artifacts").option(
+    "--openclaw-dir <path>",
+    "OpenClaw state directory target (repeat for multiple profiles)",
+    collectStringOption,
+    []
+  ).option(
+    "--skill-package-root <path>",
+    "Override skill package root (defaults to bundled assets)"
+  ).option("--json", "Print machine-readable JSON output").action(
+    withErrorHandling(
+      "skill install",
+      async (options) => {
+        let results;
+        try {
+          results = await runSkillInstall(options);
+        } catch (error48) {
+          throw new Error(formatSkillInstallError(error48));
+        }
+        if (options.json) {
+          writeStdoutLine(JSON.stringify({ installs: results }, null, 2));
+          return;
+        }
+        for (const result of results) {
+          writeStdoutLine(`OpenClaw dir: ${result.openclawDir}`);
+          writeStdoutLine(`Skill source: ${result.skillPackageRoot}`);
+          writeStdoutLine(`Target skill dir: ${result.targetSkillDirectory}`);
+          for (const record2 of result.records) {
+            writeStdoutLine(
+              `${record2.action}: ${record2.targetPath} (source: ${record2.sourcePath})`
+            );
+          }
+          writeStdoutLine(toInstallSummary(result.records));
+        }
+      }
+    )
+  );
+  return skillCommand;
+};
+
+// src/commands/verify.ts
+import { readFile as readFile7 } from "fs/promises";
+import { Command as Command10 } from "commander";
 var logger10 = createLogger({ service: "cli", module: "verify" });
 var REGISTRY_KEYS_CACHE_FILE = "registry-keys.json";
 var CRL_CLAIMS_CACHE_FILE = "crl-claims.json";
@@ -23310,7 +23636,7 @@ var VerifyCommandError = class extends Error {
     this.name = "VerifyCommandError";
   }
 };
-var isRecord10 = (value) => {
+var isRecord11 = (value) => {
   return typeof value === "object" && value !== null;
 };
 var normalizeRegistryUrl2 = (registryUrl) => {
@@ -23346,7 +23672,7 @@ var resolveToken = async (tokenOrFile) => {
     throw new VerifyCommandError("invalid token (value is empty)");
   }
   try {
-    const fileContents = await readFile6(input, "utf-8");
+    const fileContents = await readFile7(input, "utf-8");
     const token = fileContents.trim();
     if (token.length === 0) {
       throw new VerifyCommandError(`invalid token (${input} is empty)`);
@@ -23378,7 +23704,7 @@ var parseResponseJson = async (response) => {
   }
 };
 var parseSigningKeys = (payload) => {
-  if (!isRecord10(payload) || !Array.isArray(payload.keys)) {
+  if (!isRecord11(payload) || !Array.isArray(payload.keys)) {
     throw new VerifyCommandError(
       "verification keys unavailable (response payload is invalid)"
     );
@@ -23397,7 +23723,7 @@ var parseSigningKeys = (payload) => {
 };
 var parseRegistryKeysCache = (rawCache) => {
   const parsed = parseJson(rawCache);
-  if (!isRecord10(parsed)) {
+  if (!isRecord11(parsed)) {
     return void 0;
   }
   const { registryUrl, fetchedAtMs, keys } = parsed;
@@ -23423,7 +23749,7 @@ var parseRegistryKeysCache = (rawCache) => {
 };
 var parseCrlCache = (rawCache) => {
   const parsed = parseJson(rawCache);
-  if (!isRecord10(parsed)) {
+  if (!isRecord11(parsed)) {
     return void 0;
   }
   const { registryUrl, fetchedAtMs, claims } = parsed;
@@ -23521,7 +23847,7 @@ var fetchCrlClaims = async (input) => {
     );
   }
   const payload = await parseResponseJson(response);
-  if (!isRecord10(payload) || typeof payload.crl !== "string") {
+  if (!isRecord11(payload) || typeof payload.crl !== "string") {
     throw new VerifyCommandError(
       "revocation check unavailable (response payload is invalid)"
     );
@@ -23566,7 +23892,7 @@ var loadCrlClaims = async (input) => {
   return claims;
 };
 var toInvalidTokenReason = (error48) => {
-  if (isRecord10(error48) && typeof error48.message === "string") {
+  if (isRecord11(error48) && typeof error48.message === "string") {
     return `invalid token (${error48.message})`;
   }
   if (error48 instanceof Error && error48.message.length > 0) {
@@ -23642,7 +23968,7 @@ var runVerify = async (tokenOrFile) => {
   printResult(true, `token verified (${claims.sub})`);
 };
 var createVerifyCommand = () => {
-  return new Command9("verify").description("Verify an AIT using registry keys and CRL state").argument(
+  return new Command10("verify").description("Verify an AIT using registry keys and CRL state").argument(
     "<tokenOrFile>",
     "Raw AIT token or file path containing the token"
   ).action(
@@ -23653,7 +23979,7 @@ var createVerifyCommand = () => {
 };
 
 // src/index.ts
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 var resolveCliVersion = () => {
   const packageJson = require2("../package.json");
   if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
@@ -23663,7 +23989,7 @@ var resolveCliVersion = () => {
 };
 var CLI_VERSION = resolveCliVersion();
 var createProgram = () => {
-  return new Command10("clawdentity").description("Clawdentity CLI - Agent identity management").version(CLI_VERSION).addCommand(createAdminCommand()).addCommand(createAgentCommand()).addCommand(createApiKeyCommand()).addCommand(createConnectorCommand()).addCommand(createConfigCommand()).addCommand(createInviteCommand()).addCommand(createOpenclawCommand()).addCommand(createPairCommand()).addCommand(createVerifyCommand());
+  return new Command11("clawdentity").description("Clawdentity CLI - Agent identity management").version(CLI_VERSION).addCommand(createAdminCommand()).addCommand(createAgentCommand()).addCommand(createApiKeyCommand()).addCommand(createConnectorCommand()).addCommand(createConfigCommand()).addCommand(createInviteCommand()).addCommand(createOpenclawCommand()).addCommand(createPairCommand()).addCommand(createSkillCommand()).addCommand(createVerifyCommand());
 };
 export {
   CLI_VERSION,