clawdentity 0.0.0

package/dist/postinstall.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/postinstall.js

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+
+// src/install-skill-mode.ts
+import { constants, existsSync } from "fs";
+import { access, copyFile, mkdir, readdir, readFile } from "fs/promises";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { dirname, join, relative } from "path";
+import { fileURLToPath } from "url";
+
+// src/io.ts
+var withTrailingNewline = (value) => value.endsWith("\n") ? value : `${value}
+`;
+var writeStdoutLine = (value) => {
+  process.stdout.write(withTrailingNewline(value));
+};
+var writeStderrLine = (value) => {
+  process.stderr.write(withTrailingNewline(value));
+};
+
+// src/install-skill-mode.ts
+var OPENCLAW_DIR_NAME = ".openclaw";
+var SKILL_PACKAGE_NAME = "@clawdentity/openclaw-skill";
+var SKILL_DIR_NAME = "clawdentity-openclaw-relay";
+var RELAY_MODULE_FILE_NAME = "relay-to-peer.mjs";
+function isRecord(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 getErrorCode(error) {
+  if (!isRecord(error)) {
+    return void 0;
+  }
+  return typeof error.code === "string" ? error.code : void 0;
+}
+function parseBooleanFlag(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "" || normalized === "1" || normalized === "true" || normalized === "yes") {
+    return true;
+  }
+  if (normalized === "0" || normalized === "false" || normalized === "no") {
+    return false;
+  }
+  return void 0;
+}
+function hasSkillFlagInNpmArgv(rawArgv) {
+  if (!rawArgv || rawArgv.trim().length === 0) {
+    return false;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(rawArgv);
+  } catch {
+    return false;
+  }
+  if (!isRecord(parsed)) {
+    return false;
+  }
+  const original = parsed.original;
+  if (!Array.isArray(original)) {
+    return false;
+  }
+  return original.some((entry) => entry === "--skill");
+}
+function isSkillInstallRequested(env = process.env) {
+  const envFlag = parseBooleanFlag(env.npm_config_skill);
+  if (envFlag !== void 0) {
+    return envFlag;
+  }
+  return hasSkillFlagInNpmArgv(env.npm_config_argv);
+}
+function resolveHomeDir(inputHomeDir) {
+  if (typeof inputHomeDir === "string" && inputHomeDir.trim().length > 0) {
+    return inputHomeDir.trim();
+  }
+  return homedir();
+}
+function resolveOpenclawDir(homeDir, inputOpenclawDir) {
+  if (typeof inputOpenclawDir === "string" && inputOpenclawDir.trim().length > 0) {
+    return inputOpenclawDir.trim();
+  }
+  return join(homeDir, OPENCLAW_DIR_NAME);
+}
+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 = join(
+    dirname(fileURLToPath(import.meta.url)),
+    "..",
+    "skill-bundle",
+    "openclaw-skill"
+  );
+  if (existsSync(bundledSkillRoot)) {
+    return bundledSkillRoot;
+  }
+  const require2 = createRequire(import.meta.url);
+  let packageJsonPath;
+  try {
+    packageJsonPath = require2.resolve(`${SKILL_PACKAGE_NAME}/package.json`);
+    return dirname(packageJsonPath);
+  } catch {
+    const workspaceFallbackRoot = join(
+      dirname(fileURLToPath(import.meta.url)),
+      "..",
+      "..",
+      "openclaw-skill"
+    );
+    if (existsSync(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 using --skill mode.",
+      details: {
+        packageName: SKILL_PACKAGE_NAME,
+        bundledSkillRoot,
+        workspaceFallbackRoot
+      }
+    });
+  }
+}
+async function assertReadableFile(filePath, details) {
+  try {
+    await access(filePath, constants.R_OK);
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") {
+      throw new SkillInstallError({
+        code: "CLI_SKILL_ARTIFACT_MISSING",
+        message: "Required skill artifact is missing",
+        details: {
+          ...details,
+          sourcePath: filePath
+        }
+      });
+    }
+    throw error;
+  }
+}
+async function listFilesRecursively(directoryPath) {
+  const entries = await readdir(directoryPath, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries.sort(
+    (left, right) => left.name.localeCompare(right.name)
+  )) {
+    const entryPath = join(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 = join(input.skillPackageRoot, "skill");
+  const skillDocSource = join(skillRoot, "SKILL.md");
+  const referencesRoot = join(skillRoot, "references");
+  const relaySource = join(
+    input.skillPackageRoot,
+    "dist",
+    RELAY_MODULE_FILE_NAME
+  );
+  await assertReadableFile(skillDocSource, {
+    artifact: "SKILL.md"
+  });
+  await assertReadableFile(relaySource, {
+    artifact: RELAY_MODULE_FILE_NAME
+  });
+  let referenceFiles;
+  try {
+    referenceFiles = await listFilesRecursively(referencesRoot);
+  } catch (error) {
+    if (getErrorCode(error) === "ENOENT") {
+      throw new SkillInstallError({
+        code: "CLI_SKILL_ARTIFACT_MISSING",
+        message: "Required skill references directory is missing",
+        details: {
+          sourcePath: referencesRoot,
+          artifact: "references"
+        }
+      });
+    }
+    throw error;
+  }
+  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 = join(
+    input.openclawDir,
+    "workspace",
+    "skills",
+    SKILL_DIR_NAME
+  );
+  const artifacts = [
+    {
+      sourcePath: skillDocSource,
+      targetPath: join(targetSkillRoot, "SKILL.md")
+    },
+    {
+      sourcePath: relaySource,
+      targetPath: join(targetSkillRoot, RELAY_MODULE_FILE_NAME)
+    },
+    {
+      sourcePath: relaySource,
+      targetPath: join(
+        input.openclawDir,
+        "hooks",
+        "transforms",
+        RELAY_MODULE_FILE_NAME
+      )
+    }
+  ];
+  for (const referenceFile of referenceFiles) {
+    const relativePath = relative(referencesRoot, referenceFile);
+    artifacts.push({
+      sourcePath: referenceFile,
+      targetPath: join(targetSkillRoot, "references", relativePath)
+    });
+  }
+  return artifacts.sort(
+    (left, right) => left.targetPath.localeCompare(right.targetPath)
+  );
+}
+async function copyArtifact(input) {
+  const sourceContent = await readFile(input.sourcePath);
+  let existingContent;
+  try {
+    existingContent = await readFile(input.targetPath);
+  } catch (error) {
+    if (getErrorCode(error) !== "ENOENT") {
+      throw error;
+    }
+  }
+  if (existingContent !== void 0 && sourceContent.equals(existingContent)) {
+    return "unchanged";
+  }
+  await mkdir(dirname(input.targetPath), { recursive: true });
+  await copyFile(input.sourcePath, input.targetPath);
+  if (existingContent !== void 0) {
+    return "updated";
+  }
+  return "installed";
+}
+async function installOpenclawSkillArtifacts(options = {}) {
+  const env = options.env ?? process.env;
+  const homeDir = resolveHomeDir(options.homeDir);
+  const openclawDir = resolveOpenclawDir(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: join(
+      openclawDir,
+      "workspace",
+      "skills",
+      SKILL_DIR_NAME
+    ),
+    records
+  };
+}
+function toSummaryCounts(records) {
+  const installed = records.filter((record) => record.action === "installed");
+  const updated = records.filter((record) => record.action === "updated");
+  const unchanged = records.filter((record) => record.action === "unchanged");
+  return `installed=${installed.length} updated=${updated.length} unchanged=${unchanged.length}`;
+}
+function formatSkillInstallError(error) {
+  if (error instanceof SkillInstallError) {
+    const details = Object.entries(error.details).map(([key, value]) => `${key}=${value}`).join(" ");
+    if (details.length === 0) {
+      return `${error.code}: ${error.message}`;
+    }
+    return `${error.code}: ${error.message} (${details})`;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+async function runNpmSkillInstall(options = {}) {
+  const env = options.env ?? process.env;
+  const writeStdout = options.writeStdout ?? writeStdoutLine;
+  const writeStderr = options.writeStderr ?? writeStderrLine;
+  if (!isSkillInstallRequested(env)) {
+    return { skipped: true };
+  }
+  writeStdout("[clawdentity] skill install mode detected (--skill)");
+  try {
+    const result = await installOpenclawSkillArtifacts({
+      env,
+      homeDir: options.homeDir,
+      openclawDir: options.openclawDir,
+      skillPackageRoot: options.skillPackageRoot
+    });
+    for (const record of result.records) {
+      writeStdout(
+        `[clawdentity] ${record.action}: ${record.targetPath} (source: ${record.sourcePath})`
+      );
+    }
+    writeStdout(`[clawdentity] ${toSummaryCounts(result.records)}`);
+    return {
+      skipped: false,
+      ...result
+    };
+  } catch (error) {
+    writeStderr(
+      `[clawdentity] skill install failed: ${formatSkillInstallError(error)}`
+    );
+    throw error;
+  }
+}
+
+// src/postinstall.ts
+runNpmSkillInstall().catch(() => {
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "clawdentity",
+  "version": "0.0.0",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "clawdentity": "dist/bin.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "postinstall.mjs",
+    "skill-bundle"
+  ],
+  "scripts": {
+    "build": "pnpm run sync:skill-bundle && tsup",
+    "format": "biome format .",
+    "lint": "biome lint .",
+    "prepack": "pnpm run build",
+    "postinstall": "node ./postinstall.mjs",
+    "sync:skill-bundle": "node ./scripts/sync-skill-bundle.mjs",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "ws": "^8.19.0"
+  },
+  "devDependencies": {
+    "@clawdentity/connector": "workspace:*",
+    "@clawdentity/protocol": "workspace:*",
+    "@clawdentity/sdk": "workspace:*",
+    "@types/node": "^22.18.11"
+  }
+}

package/postinstall.mjs

@@ -0,0 +1,48 @@
+import { constants } from "node:fs";
+import { access } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+function parseBooleanFlag(value) {
+  if (typeof value !== "string") {
+    return undefined;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  if (
+    normalized === "" ||
+    normalized === "1" ||
+    normalized === "true" ||
+    normalized === "yes"
+  ) {
+    return true;
+  }
+
+  if (normalized === "0" || normalized === "false" || normalized === "no") {
+    return false;
+  }
+
+  return undefined;
+}
+
+const packageRoot = dirname(fileURLToPath(import.meta.url));
+const bundledPostinstallPath = join(packageRoot, "dist", "postinstall.js");
+const skillRequested = parseBooleanFlag(process.env.npm_config_skill) === true;
+
+try {
+  await access(bundledPostinstallPath, constants.R_OK);
+  await import(pathToFileURL(bundledPostinstallPath).href);
+} catch (error) {
+  if (error && typeof error === "object" && error.code === "ENOENT") {
+    if (skillRequested) {
+      process.stderr.write(
+        `[clawdentity] skill install failed: build artifact not found at ${bundledPostinstallPath}\n`,
+      );
+      process.exitCode = 1;
+    }
+  } else {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[clawdentity] postinstall failed: ${message}\n`);
+    process.exitCode = 1;
+  }
+}

package/skill-bundle/AGENTS.md

@@ -0,0 +1,12 @@
+# AGENTS.md (apps/cli/skill-bundle)
+
+## Purpose
+- Store bundled skill artifacts shipped with the CLI package for npm `--skill` postinstall.
+
+## Rules
+- Treat this folder as generated release input; do not hand-edit bundled files.
+- Regenerate by running `pnpm -F clawdentity run sync:skill-bundle` after changes in `apps/openclaw-skill`.
+- Required bundled files:
+  - `openclaw-skill/skill/SKILL.md`
+  - `openclaw-skill/skill/references/*`
+  - `openclaw-skill/dist/relay-to-peer.mjs`