clawvault 2.6.0 → 3.0.0

package/dist/commands/compat.cjs

@@ -0,0 +1,369 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/compat.ts
+var compat_exports = {};
+__export(compat_exports, {
+  checkOpenClawCompatibility: () => checkOpenClawCompatibility,
+  compatCommand: () => compatCommand,
+  compatibilityExitCode: () => compatibilityExitCode
+});
+module.exports = __toCommonJS(compat_exports);
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_child_process = require("child_process");
+var import_url = require("url");
+var import_meta = {};
+var REQUIRED_HOOK_EVENTS = ["gateway:startup", "command:new", "session:start"];
+var REQUIRED_HOOK_BIN = "clawvault";
+function readOptionalFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    return fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function findPackageRoot() {
+  let dir = path.dirname((0, import_url.fileURLToPath)(import_meta.url));
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return path.dirname((0, import_url.fileURLToPath)(import_meta.url));
+}
+function resolveOpenClawHooksDir() {
+  const candidates = [
+    path.join(process.env.HOME || "", ".openclaw", "hooks", "clawvault"),
+    path.join(process.env.OPENCLAW_HOME || "", "hooks", "clawvault"),
+    path.join(process.env.OPENCLAW_STATE_DIR || "", "hooks", "clawvault")
+  ].filter((p) => p && !p.startsWith(path.sep + "hooks"));
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveProjectFile(relativePath, baseDir) {
+  if (baseDir) {
+    return path.resolve(baseDir, relativePath);
+  }
+  const fromCwd = path.resolve(process.cwd(), relativePath);
+  if (fs.existsSync(fromCwd)) {
+    return fromCwd;
+  }
+  if (relativePath.startsWith("hooks/clawvault/")) {
+    const hooksDir = resolveOpenClawHooksDir();
+    if (hooksDir) {
+      const hookRelative = relativePath.replace("hooks/clawvault/", "");
+      const fromHooks = path.resolve(hooksDir, hookRelative);
+      if (fs.existsSync(fromHooks)) {
+        return fromHooks;
+      }
+      const fromNestedHooks = path.resolve(hooksDir, "hooks", "clawvault", hookRelative);
+      if (fs.existsSync(fromNestedHooks)) {
+        return fromNestedHooks;
+      }
+    }
+  }
+  return path.resolve(findPackageRoot(), relativePath);
+}
+function checkOpenClawCli() {
+  const result = (0, import_child_process.spawnSync)("openclaw", ["--version"], { stdio: "ignore" });
+  if (result.error) {
+    return {
+      label: "openclaw CLI available",
+      status: "warn",
+      detail: "openclaw binary not found",
+      hint: "Install OpenClaw CLI to enable hook runtime validation."
+    };
+  }
+  if (typeof result.status === "number" && result.status !== 0) {
+    return {
+      label: "openclaw CLI available",
+      status: "warn",
+      detail: `openclaw --version exited with code ${result.status}`,
+      hint: "Ensure OpenClaw CLI is installed and runnable in PATH."
+    };
+  }
+  if (typeof result.signal === "string" && result.signal.length > 0) {
+    return {
+      label: "openclaw CLI available",
+      status: "warn",
+      detail: `openclaw --version terminated by signal ${result.signal}`,
+      hint: "Ensure OpenClaw CLI can execute normally in PATH."
+    };
+  }
+  return { label: "openclaw CLI available", status: "ok" };
+}
+function checkPackageHookRegistration(options) {
+  let packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
+  if (packageRaw && !options.baseDir) {
+    try {
+      const parsed = JSON.parse(packageRaw);
+      if (!parsed.openclaw?.hooks) {
+        const fallbackPath = path.resolve(findPackageRoot(), "package.json");
+        const fallbackRaw = readOptionalFile(fallbackPath);
+        if (fallbackRaw) packageRaw = fallbackRaw;
+      }
+    } catch {
+    }
+  }
+  if (!packageRaw) {
+    return {
+      label: "package hook registration",
+      status: "error",
+      detail: "package.json not found"
+    };
+  }
+  try {
+    const parsed = JSON.parse(packageRaw);
+    const registeredHooks = parsed.openclaw?.hooks ?? [];
+    if (registeredHooks.includes("./hooks/clawvault")) {
+      return {
+        label: "package hook registration",
+        status: "ok",
+        detail: "./hooks/clawvault"
+      };
+    }
+    return {
+      label: "package hook registration",
+      status: "error",
+      detail: "Missing ./hooks/clawvault in package openclaw.hooks"
+    };
+  } catch (err) {
+    return {
+      label: "package hook registration",
+      status: "error",
+      detail: err?.message || "Unable to parse package.json"
+    };
+  }
+}
+function checkHookManifest(options) {
+  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
+  if (!hookRaw) {
+    return {
+      label: "hook manifest",
+      status: "error",
+      detail: "HOOK.md not found"
+    };
+  }
+  try {
+    const parsed = (0, import_gray_matter.default)(hookRaw);
+    const openclaw = parsed.data?.metadata?.openclaw;
+    const events = Array.isArray(openclaw?.events) ? openclaw?.events ?? [] : [];
+    const missingEvents = REQUIRED_HOOK_EVENTS.filter((event) => !events.includes(event));
+    if (missingEvents.length === 0) {
+      return {
+        label: "hook manifest events",
+        status: "ok",
+        detail: events.join(", ")
+      };
+    }
+    return {
+      label: "hook manifest events",
+      status: "error",
+      detail: `Missing events: ${missingEvents.join(", ")}`
+    };
+  } catch (err) {
+    return {
+      label: "hook manifest events",
+      status: "error",
+      detail: err?.message || "Unable to parse HOOK.md frontmatter"
+    };
+  }
+}
+function checkHookManifestRequirements(options) {
+  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
+  if (!hookRaw) {
+    return {
+      label: "hook manifest requirements",
+      status: "error",
+      detail: "HOOK.md not found"
+    };
+  }
+  try {
+    const parsed = (0, import_gray_matter.default)(hookRaw);
+    const requiresBins = parsed.data?.metadata?.openclaw?.requires?.bins;
+    const bins = Array.isArray(requiresBins) ? requiresBins : [];
+    if (bins.includes(REQUIRED_HOOK_BIN)) {
+      return {
+        label: "hook manifest requirements",
+        status: "ok",
+        detail: `bins: ${bins.join(", ")}`
+      };
+    }
+    return {
+      label: "hook manifest requirements",
+      status: "warn",
+      detail: `Missing required hook bin "${REQUIRED_HOOK_BIN}"`,
+      hint: 'Add metadata.openclaw.requires.bins: ["clawvault"] to hooks/clawvault/HOOK.md.'
+    };
+  } catch (err) {
+    return {
+      label: "hook manifest requirements",
+      status: "error",
+      detail: err?.message || "Unable to parse HOOK.md frontmatter"
+    };
+  }
+}
+function checkHookHandlerSafety(options) {
+  const handlerRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/handler.js", options.baseDir));
+  if (!handlerRaw) {
+    return {
+      label: "hook handler script",
+      status: "error",
+      detail: "handler.js not found"
+    };
+  }
+  const usesExecFileSync = handlerRaw.includes("execFileSync");
+  const usesExecSync = /\bexecSync\b/.test(handlerRaw);
+  const enablesShell = /\bshell\s*:\s*true\b/.test(handlerRaw);
+  const delegatesAutoProfile = /['"]--profile['"]\s*,\s*['"]auto['"]/.test(handlerRaw);
+  const violations = [];
+  if (!usesExecFileSync || usesExecSync) {
+    violations.push("execFileSync-only execution path");
+  }
+  if (enablesShell) {
+    violations.push("shell:false execution option");
+  }
+  if (!delegatesAutoProfile) {
+    violations.push("shared context profile delegation (--profile auto)");
+  }
+  if (violations.length > 0) {
+    return {
+      label: "hook handler safety",
+      status: "warn",
+      detail: `Missing conventions: ${violations.join(", ")}`,
+      hint: "Use execFileSync (no shell), avoid execSync, and delegate profile inference via --profile auto."
+    };
+  }
+  return { label: "hook handler safety", status: "ok" };
+}
+function checkSkillMetadata(options) {
+  const skillRaw = readOptionalFile(resolveProjectFile("SKILL.md", options.baseDir));
+  if (!skillRaw) {
+    return {
+      label: "skill metadata",
+      status: "warn",
+      detail: "SKILL.md not found",
+      hint: "Ensure SKILL.md is present for OpenClaw skill distribution."
+    };
+  }
+  let hasOpenClawMetadata = false;
+  let parseError;
+  try {
+    const parsed = (0, import_gray_matter.default)(skillRaw);
+    const frontmatter = parsed.data ?? {};
+    const metadata = frontmatter.metadata && typeof frontmatter.metadata === "object" && !Array.isArray(frontmatter.metadata) ? frontmatter.metadata : void 0;
+    hasOpenClawMetadata = Boolean(
+      metadata && typeof metadata.openclaw === "object" && metadata.openclaw !== null || typeof frontmatter.openclaw === "object" && frontmatter.openclaw !== null
+    );
+  } catch {
+    parseError = "Unable to parse SKILL.md frontmatter";
+    hasOpenClawMetadata = false;
+  }
+  if (!hasOpenClawMetadata) {
+    hasOpenClawMetadata = /"openclaw"\s*:/.test(skillRaw);
+  }
+  if (!hasOpenClawMetadata) {
+    const detail = parseError ? `${parseError} (or missing metadata.openclaw)` : "Missing metadata.openclaw in SKILL.md";
+    return {
+      label: "skill metadata",
+      status: "warn",
+      detail,
+      hint: "Add metadata.openclaw to SKILL.md frontmatter for OpenClaw compatibility."
+    };
+  }
+  return { label: "skill metadata", status: "ok" };
+}
+function checkOpenClawCompatibility(options = {}) {
+  const checks = [
+    checkOpenClawCli(),
+    checkPackageHookRegistration(options),
+    checkHookManifest(options),
+    checkHookManifestRequirements(options),
+    checkHookHandlerSafety(options),
+    checkSkillMetadata(options)
+  ];
+  const warnings = checks.filter((check) => check.status === "warn").length;
+  const errors = checks.filter((check) => check.status === "error").length;
+  return {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checks,
+    warnings,
+    errors
+  };
+}
+function formatCompatibilityReport(report) {
+  const lines = [];
+  lines.push("OpenClaw Compatibility Report");
+  lines.push("-".repeat(34));
+  lines.push(`Generated: ${report.generatedAt}`);
+  lines.push("");
+  for (const check of report.checks) {
+    const prefix = check.status === "ok" ? "\u2713" : check.status === "warn" ? "\u26A0" : "\u2717";
+    lines.push(`${prefix} ${check.label}${check.detail ? ` \u2014 ${check.detail}` : ""}`);
+    if (check.hint) {
+      lines.push(`  ${check.hint}`);
+    }
+  }
+  lines.push("");
+  lines.push(`Warnings: ${report.warnings}`);
+  lines.push(`Errors: ${report.errors}`);
+  return lines.join("\n");
+}
+function compatibilityExitCode(report, options = {}) {
+  if (report.errors > 0) {
+    return 1;
+  }
+  if (options.strict && report.warnings > 0) {
+    return 1;
+  }
+  return 0;
+}
+async function compatCommand(options = {}) {
+  const report = checkOpenClawCompatibility({ baseDir: options.baseDir });
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(formatCompatibilityReport(report));
+  }
+  return report;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkOpenClawCompatibility,
+  compatCommand,
+  compatibilityExitCode
+});

package/dist/commands/compat.d.cts

@@ -0,0 +1,28 @@
+type CompatStatus = 'ok' | 'warn' | 'error';
+interface CompatCheck {
+    label: string;
+    status: CompatStatus;
+    detail?: string;
+    hint?: string;
+}
+interface CompatReport {
+    generatedAt: string;
+    checks: CompatCheck[];
+    warnings: number;
+    errors: number;
+}
+interface CompatOptions {
+    baseDir?: string;
+}
+interface CompatCommandOptions {
+    json?: boolean;
+    strict?: boolean;
+    baseDir?: string;
+}
+declare function checkOpenClawCompatibility(options?: CompatOptions): CompatReport;
+declare function compatibilityExitCode(report: CompatReport, options?: {
+    strict?: boolean;
+}): number;
+declare function compatCommand(options?: CompatCommandOptions): Promise<CompatReport>;
+
+export { type CompatCheck, type CompatCommandOptions, type CompatReport, type CompatStatus, checkOpenClawCompatibility, compatCommand, compatibilityExitCode };

package/dist/commands/compat.js

@@ -2,7 +2,8 @@ import {
   checkOpenClawCompatibility,
   compatCommand,
   compatibilityExitCode
-} from "../chunk-QVMXF7FY.js";
+} from "../chunk-3D6BCTP6.js";
+import "../chunk-3RG5ZIWI.js";
 export {
   checkOpenClawCompatibility,
   compatCommand,