guardskills 0.1.0-alpha.4 → 1.1.0

package/dist/cli.cjs

@@ -308,6 +308,73 @@ function printHumanLocalReport(report) {
 function printJsonLocalReport(report) {
   console.log(JSON.stringify(report, null, 2));
 }
+function printHumanClawHubReport(report) {
+  console.log(`Command: ${report.command}`);
+  console.log(`Identifier: ${report.identifier}`);
+  console.log(`Registry: ${report.registry}`);
+  console.log(`Mapped Repo: ${report.repo}`);
+  console.log(`Skill: ${report.skill}`);
+  if (report.version) {
+    console.log(`Version: ${report.version}`);
+  }
+  console.log(`Mode: ${report.strict ? "strict" : "standard"}`);
+  if (report.configPath) {
+    console.log(`Config: ${report.configPath}`);
+  }
+  if (report.skillDir) {
+    console.log(`Skill Dir: ${report.skillDir}`);
+  }
+  if (report.commitSha) {
+    console.log(`Commit: ${report.commitSha}`);
+  }
+  if (report.moderation) {
+    const parts = [];
+    if (report.moderation.isSuspicious) {
+      parts.push("suspicious");
+    }
+    if (report.moderation.isMalwareBlocked) {
+      parts.push("malware-blocked");
+    }
+    if (report.moderation.isRemoved) {
+      parts.push("removed");
+    }
+    if (parts.length > 0) {
+      console.log(`ClawHub Moderation: ${parts.join(", ")}`);
+    }
+  }
+  console.log(`Files Scanned: ${report.scanFiles.length}`);
+  if (report.decision.riskScore === null) {
+    console.log("Result: UNVERIFIABLE");
+  } else {
+    console.log(`Risk Score: ${report.decision.riskScore.toFixed(1)}/100`);
+    console.log(`Decision: ${report.decision.level}`);
+  }
+  if (report.unverifiableReasons && report.unverifiableReasons.length > 0) {
+    console.log("Unverifiable Reasons:");
+    for (const reason of report.unverifiableReasons) {
+      console.log(`- ${reason}`);
+    }
+  }
+  if (report.decision.chainMatches.length > 0) {
+    console.log("Attack Chains:");
+    for (const chain of report.decision.chainMatches) {
+      console.log(`- ${chain.id} (+${chain.bonus}): ${chain.description}`);
+    }
+  }
+  if (report.decision.findings.length > 0) {
+    console.log("Findings:");
+    for (const finding of report.decision.findings.slice(0, 10)) {
+      const fileText = finding.file ? ` (${finding.file})` : "";
+      console.log(`- [${finding.severity}/${finding.confidence}] ${finding.title}${fileText}`);
+    }
+  } else {
+    console.log("Findings: none");
+  }
+  console.log(`Note: ${report.note}`);
+}
+function printJsonClawHubReport(report) {
+  console.log(JSON.stringify(report, null, 2));
+}
 
 // src/resolver/github.ts
 var import_node_path2 = __toESM(require("path"), 1);
@@ -1170,10 +1237,18 @@ async function runAddCommand(repo, rawOptions) {
   return runSkillsInstall(repo, options.skill);
 }
 
-// src/commands/scan-local.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+// src/commands/scan-clawhub.ts
 var import_zod3 = require("zod");
+
+// src/resolver/clawhub.ts
+var import_node_path4 = __toESM(require("path"), 1);
+var import_jszip = __toESM(require("jszip"), 1);
+var DEFAULT_REGISTRY_BASE_URL = "https://clawhub.ai";
+var DEFAULT_ARCHIVE_BASE_URL = "https://auth.clawdhub.com";
+var DEFAULT_REQUEST_TIMEOUT_MS2 = 15e3;
+var DEFAULT_MAX_FILE_SIZE_BYTES = 25e4;
+var DEFAULT_MAX_TOTAL_FILES = 120;
+var RETRYABLE_STATUS2 = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
 var ALLOWED_TEXT_EXTENSIONS2 = /* @__PURE__ */ new Set([
   ".md",
   ".txt",
@@ -1193,23 +1268,707 @@ var ALLOWED_TEXT_EXTENSIONS2 = /* @__PURE__ */ new Set([
   ".ini",
   ".cfg"
 ]);
-var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", ".turbo"]);
-var cliScanLocalOptionsSchema = import_zod3.z.object({
+function normalizeRegistryBaseUrl(input) {
+  const raw = input?.trim() || DEFAULT_REGISTRY_BASE_URL;
+  const withProtocol = /^https?:\/\//i.test(raw) ? raw : `https://${raw}`;
+  const url = new URL(withProtocol);
+  const pathname = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
+  return `${url.origin}${pathname}`;
+}
+function toApiCandidates(registryBaseUrl, identifier) {
+  const encodedIdentifier = encodeURIComponent(identifier);
+  const slugOnly = identifier.split("/").filter(Boolean).at(-1) ?? identifier;
+  const encodedSlug = encodeURIComponent(slugOnly);
+  return [
+    `${registryBaseUrl}/api/v1/package/${encodedIdentifier}`,
+    `${registryBaseUrl}/api/package/${encodedIdentifier}`,
+    `${registryBaseUrl}/api/v1/skills/${encodedSlug}`
+  ];
+}
+function tryParseClawHubUrl(input) {
+  try {
+    const parsed = new URL(input.trim());
+    const host = parsed.hostname.toLowerCase();
+    if (host !== "clawhub.ai" && host !== "www.clawhub.ai") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function extractIdentifierCandidates(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return [];
+  }
+  const candidates = [];
+  const pushUnique = (value) => {
+    if (!value) {
+      return;
+    }
+    const normalized = value.trim();
+    if (!normalized) {
+      return;
+    }
+    if (!candidates.includes(normalized)) {
+      candidates.push(normalized);
+    }
+  };
+  try {
+    const parsed = new URL(trimmed);
+    const host = parsed.hostname.toLowerCase();
+    if (host !== "clawhub.ai" && host !== "www.clawhub.ai") {
+      return [trimmed];
+    }
+    const segments = parsed.pathname.split("/").filter(Boolean);
+    if (segments.length >= 2 && segments[0] && segments[1]) {
+      pushUnique(`${segments[0]}/${segments[1]}`);
+    }
+    if (segments.length >= 3 && segments[0]?.toLowerCase() === "skills" && segments[1] && segments[2]) {
+      pushUnique(`${segments[1]}/${segments[2]}`);
+    }
+    if (segments.length > 0) {
+      pushUnique(segments.join("/"));
+      const last = segments.at(-1);
+      pushUnique(last);
+    }
+  } catch {
+    pushUnique(trimmed);
+  }
+  return candidates;
+}
+function mapClawHubError(error, operation) {
+  if (error instanceof GuardSkillsError) {
+    return error;
+  }
+  const status = typeof error === "object" && error !== null && "status" in error ? error.status : void 0;
+  const message = typeof error === "object" && error !== null && "message" in error ? String(error.message) : String(error);
+  const lowerMessage = message.toLowerCase();
+  if (status === 401 || status === 403) {
+    return new GuardSkillsError(
+      "CLAWHUB_AUTH",
+      `${operation} failed: authentication/authorization error from ClawHub.`,
+      { status, cause: error }
+    );
+  }
+  if (status === 404) {
+    return new GuardSkillsError("CLAWHUB_NOT_FOUND", `${operation} failed: resource not found.`, {
+      status,
+      cause: error
+    });
+  }
+  if (status !== void 0 && RETRYABLE_STATUS2.has(status)) {
+    return new GuardSkillsError(
+      status === 429 ? "CLAWHUB_RATE_LIMIT" : "CLAWHUB_TRANSIENT",
+      `${operation} failed with retryable ClawHub status ${status}.`,
+      { status, retryable: true, cause: error }
+    );
+  }
+  if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out") || lowerMessage.includes("abort")) {
+    return new GuardSkillsError("CLAWHUB_TIMEOUT", `${operation} timed out while calling ClawHub API.`, {
+      retryable: true,
+      cause: error
+    });
+  }
+  return new GuardSkillsError("CLAWHUB_UNKNOWN", `${operation} failed: ${message}`, {
+    status,
+    cause: error
+  });
+}
+function unwrapResponsePayload(payload) {
+  if (!payload || typeof payload !== "object") {
+    throw new GuardSkillsError("CLAWHUB_UNKNOWN", "ClawHub returned a non-object JSON payload.");
+  }
+  const objectPayload = payload;
+  if (objectPayload.data && typeof objectPayload.data === "object") {
+    return objectPayload.data;
+  }
+  return objectPayload;
+}
+async function fetchJson(url, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { accept: "application/json" },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw { status: response.status, message: `${response.status} ${response.statusText}` };
+    }
+    const payload = await response.json();
+    return unwrapResponsePayload(payload);
+  } catch (error) {
+    throw mapClawHubError(error, `ClawHub metadata fetch (${url})`);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function fetchText(url, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { accept: "text/html,application/xhtml+xml" },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw { status: response.status, message: `${response.status} ${response.statusText}` };
+    }
+    return await response.text();
+  } catch (error) {
+    throw mapClawHubError(error, `ClawHub page fetch (${url})`);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function fetchArrayBuffer(url, timeoutMs) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw { status: response.status, message: `${response.status} ${response.statusText}` };
+    }
+    return await response.arrayBuffer();
+  } catch (error) {
+    throw mapClawHubError(error, `ClawHub archive fetch (${url})`);
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function normalizeRepoRef(candidate) {
+  const trimmed = candidate.trim();
+  if (!trimmed) {
+    return null;
+  }
+  const shorthand = trimmed.match(/^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/);
+  if (shorthand && shorthand[1] && shorthand[2]) {
+    return `${shorthand[1]}/${shorthand[2].replace(/\.git$/i, "")}`;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    if (!(parsed.hostname === "github.com" || parsed.hostname === "www.github.com")) {
+      return null;
+    }
+    const parts = parsed.pathname.split("/").filter(Boolean);
+    if (parts.length < 2 || !parts[0] || !parts[1]) {
+      return null;
+    }
+    return `${parts[0]}/${parts[1].replace(/\.git$/i, "")}`;
+  } catch {
+    return null;
+  }
+}
+function getNestedString(obj, ...keys) {
+  let cursor = obj;
+  for (const key of keys) {
+    if (!cursor || typeof cursor !== "object" || !(key in cursor)) {
+      return void 0;
+    }
+    cursor = cursor[key];
+  }
+  return typeof cursor === "string" && cursor.trim() ? cursor.trim() : void 0;
+}
+function getNestedBoolean(obj, ...keys) {
+  let cursor = obj;
+  for (const key of keys) {
+    if (!cursor || typeof cursor !== "object" || !(key in cursor)) {
+      return void 0;
+    }
+    cursor = cursor[key];
+  }
+  return typeof cursor === "boolean" ? cursor : void 0;
+}
+function isLikelyTextFile2(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith("/skill.md") || lower === "skill.md") {
+    return true;
+  }
+  const ext = import_node_path4.default.posix.extname(lower);
+  return ALLOWED_TEXT_EXTENSIONS2.has(ext);
+}
+function isBinaryContent2(content) {
+  return content.includes("\0");
+}
+function collectGitHubRepos(value, collected, seen) {
+  if (value === null || value === void 0) {
+    return;
+  }
+  if (typeof value === "string") {
+    const repo = normalizeRepoRef(value);
+    if (repo) {
+      collected.add(repo);
+    }
+    return;
+  }
+  if (typeof value !== "object") {
+    return;
+  }
+  if (seen.has(value)) {
+    return;
+  }
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectGitHubRepos(item, collected, seen);
+    }
+    return;
+  }
+  for (const nested of Object.values(value)) {
+    collectGitHubRepos(nested, collected, seen);
+  }
+}
+function collectPossibleSkillNames(identifier, metadata, override) {
+  const names = /* @__PURE__ */ new Set();
+  if (override?.trim()) {
+    names.add(override.trim());
+  }
+  const lastSegment = identifier.split(/[/:@]/).filter(Boolean).at(-1);
+  if (lastSegment) {
+    names.add(lastSegment);
+  }
+  const maybePush = (value) => {
+    if (typeof value === "string" && value.trim()) {
+      names.add(value.trim());
+    }
+  };
+  maybePush(metadata.skill);
+  maybePush(metadata.slug);
+  maybePush(metadata.name);
+  maybePush(metadata.id);
+  return [...names];
+}
+function parseArchiveMetadata(metadata, identifier, requestedVersion) {
+  const ownerFromMetadata = getNestedString(metadata, "owner", "handle") ?? getNestedString(metadata, "owner") ?? getNestedString(metadata, "author") ?? getNestedString(metadata, "publisher");
+  const slugFromMetadata = getNestedString(metadata, "skill", "slug") ?? getNestedString(metadata, "slug") ?? getNestedString(metadata, "name");
+  const versionFromMetadata = requestedVersion ?? getNestedString(metadata, "latestVersion", "version") ?? getNestedString(metadata, "version");
+  const identifierParts = identifier.split("/").filter(Boolean);
+  const ownerFromIdentifier = identifierParts.length >= 2 ? identifierParts[0] : void 0;
+  const slugFromIdentifier = identifierParts.length > 0 ? identifierParts.at(-1) : void 0;
+  const owner = ownerFromMetadata ?? ownerFromIdentifier;
+  const slug = slugFromMetadata ?? slugFromIdentifier;
+  if (!owner || !slug) {
+    return null;
+  }
+  return { owner, slug, version: versionFromMetadata };
+}
+function parseClawHubModeration(metadata) {
+  const isSuspicious = getNestedBoolean(metadata, "moderation", "isSuspicious") ?? getNestedBoolean(metadata, "isSuspicious");
+  const isMalwareBlocked = getNestedBoolean(metadata, "moderation", "isMalwareBlocked") ?? getNestedBoolean(metadata, "isMalwareBlocked");
+  const isRemoved = getNestedBoolean(metadata, "moderation", "isRemoved") ?? getNestedBoolean(metadata, "isRemoved");
+  if (isSuspicious === void 0 && isMalwareBlocked === void 0 && isRemoved === void 0) {
+    return void 0;
+  }
+  return { isSuspicious, isMalwareBlocked, isRemoved };
+}
+async function resolveSkillFromArchive(metadata, identifier, options) {
+  const archiveMeta = parseArchiveMetadata(metadata, identifier, options.version);
+  if (!archiveMeta) {
+    return null;
+  }
+  const timeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS2;
+  const maxFileSizeBytes = options.maxFileSizeBytes ?? DEFAULT_MAX_FILE_SIZE_BYTES;
+  const maxTotalFiles = options.maxTotalFiles ?? DEFAULT_MAX_TOTAL_FILES;
+  const params = new URLSearchParams({ slug: archiveMeta.slug });
+  if (archiveMeta.version) {
+    params.set("version", archiveMeta.version);
+  }
+  const downloadUrl = `${DEFAULT_ARCHIVE_BASE_URL}/api/v1/download?${params.toString()}`;
+  const archiveBuffer = await fetchArrayBuffer(downloadUrl, timeoutMs);
+  const zip = await import_jszip.default.loadAsync(Buffer.from(archiveBuffer));
+  const files = new Array();
+  const unverifiableReasons = [];
+  let skillFilePath = null;
+  const entries = Object.values(zip.files);
+  for (const entry of entries) {
+    if (entry.dir) {
+      continue;
+    }
+    const normalizedPath = entry.name.replace(/\\/g, "/");
+    if (!isLikelyTextFile2(normalizedPath)) {
+      continue;
+    }
+    if (files.length >= maxTotalFiles) {
+      unverifiableReasons.push(
+        `Resolved archive file count exceeds maxTotalFiles=${maxTotalFiles}; scan truncated.`
+      );
+      break;
+    }
+    const contentBuffer = await entry.async("nodebuffer");
+    if (contentBuffer.length > maxFileSizeBytes) {
+      unverifiableReasons.push(
+        `File too large to scan safely: ${normalizedPath}`
+      );
+      continue;
+    }
+    const content = contentBuffer.toString("utf8");
+    if (isBinaryContent2(content)) {
+      unverifiableReasons.push(`Binary content detected: ${normalizedPath}`);
+      continue;
+    }
+    files.push({ path: normalizedPath, content });
+    if (!skillFilePath && normalizedPath.toLowerCase().endsWith("/skill.md")) {
+      skillFilePath = normalizedPath;
+    }
+    if (!skillFilePath && normalizedPath.toLowerCase() === "skill.md") {
+      skillFilePath = normalizedPath;
+    }
+  }
+  if (!skillFilePath) {
+    skillFilePath = files.find((file) => file.path.toLowerCase().endsWith("skill.md"))?.path ?? null;
+  }
+  if (!skillFilePath || files.length === 0) {
+    return null;
+  }
+  const moderation = parseClawHubModeration(metadata);
+  return {
+    source: `clawhub:${archiveMeta.owner}/${archiveMeta.slug}${archiveMeta.version ? `@${archiveMeta.version}` : ""}`,
+    owner: archiveMeta.owner,
+    repo: "clawhub-archive",
+    defaultBranch: "archive",
+    commitSha: archiveMeta.version ?? "archive",
+    skillName: options.skillNameOverride ?? archiveMeta.slug,
+    skillDir: import_node_path4.default.posix.dirname(skillFilePath),
+    skillFilePath,
+    files,
+    unverifiableReasons: [...unverifiableReasons],
+    sourceMetadata: moderation ? {
+      clawhubModeration: moderation
+    } : void 0
+  };
+}
+function extractMetadataFromClawHubPage(html, pageUrl) {
+  const metadata = {};
+  const githubUrlMatch = html.match(/https?:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)/i);
+  if (githubUrlMatch?.[1] && githubUrlMatch[2]) {
+    metadata.repository = `https://github.com/${githubUrlMatch[1]}/${githubUrlMatch[2]}`;
+  }
+  const directRepoMatch = html.match(/"repository"\s*:\s*"([^"]+)"/i);
+  if (directRepoMatch?.[1]) {
+    metadata.repository = directRepoMatch[1];
+  }
+  const pathnameParts = pageUrl.pathname.split("/").filter(Boolean);
+  if (pathnameParts.length >= 2 && pathnameParts[1]) {
+    metadata.skill = pathnameParts[1];
+  }
+  return Object.keys(metadata).length > 0 ? metadata : null;
+}
+async function resolveFromClawHubPageUrl(input, timeoutMs) {
+  const parsed = tryParseClawHubUrl(input);
+  if (!parsed) {
+    return null;
+  }
+  const html = await fetchText(parsed.toString(), timeoutMs);
+  return extractMetadataFromClawHubPage(html, parsed);
+}
+async function resolveSkillFromClawHub(identifier, options = {}) {
+  const identifierCandidates = extractIdentifierCandidates(identifier);
+  if (identifierCandidates.length === 0) {
+    throw new GuardSkillsError("CLAWHUB_UNKNOWN", "ClawHub identifier is required.");
+  }
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS2;
+  const registryBaseUrl = normalizeRegistryBaseUrl(options.registryBaseUrl);
+  let metadata = null;
+  let resolvedIdentifier = null;
+  let lastError = null;
+  for (const identifierCandidate of identifierCandidates) {
+    const candidateUrls = toApiCandidates(registryBaseUrl, identifierCandidate);
+    for (const url of candidateUrls) {
+      try {
+        metadata = await fetchJson(url, requestTimeoutMs);
+        resolvedIdentifier = identifierCandidate;
+        break;
+      } catch (error) {
+        const mapped = mapClawHubError(error, "ClawHub package lookup");
+        lastError = mapped;
+        if (mapped.code !== "CLAWHUB_NOT_FOUND") {
+          break;
+        }
+      }
+    }
+    if (metadata) {
+      break;
+    }
+  }
+  if (!metadata) {
+    try {
+      metadata = await resolveFromClawHubPageUrl(identifier, requestTimeoutMs);
+      if (metadata) {
+        resolvedIdentifier = identifierCandidates[0] ?? identifier;
+      }
+    } catch (error) {
+      lastError = mapClawHubError(error, "ClawHub skill page fallback");
+    }
+  }
+  if (!metadata) {
+    if (lastError) {
+      throw lastError;
+    }
+    throw new GuardSkillsError(
+      "CLAWHUB_NOT_FOUND",
+      `Unable to resolve '${identifier}' from ClawHub. Candidates tried: ${identifierCandidates.join(", ")}.`
+    );
+  }
+  const canonicalIdentifier = resolvedIdentifier ?? identifierCandidates[0] ?? identifier;
+  const repos = /* @__PURE__ */ new Set();
+  collectGitHubRepos(metadata, repos, /* @__PURE__ */ new Set());
+  const skillCandidates = collectPossibleSkillNames(canonicalIdentifier, metadata, options.skillNameOverride);
+  if (skillCandidates.length === 0) {
+    throw new GuardSkillsError(
+      "CLAWHUB_UNKNOWN",
+      `Could not infer skill name for ClawHub package '${canonicalIdentifier}'. Use --skill.`
+    );
+  }
+  let resolved = null;
+  let resolveError;
+  const githubOptions = {
+    requestTimeoutMs: options.requestTimeoutMs,
+    maxFileSizeBytes: options.maxFileSizeBytes,
+    maxAuxFiles: options.maxAuxFiles,
+    maxTotalFiles: options.maxTotalFiles,
+    retries: options.retries,
+    retryBaseDelayMs: options.retryBaseDelayMs
+  };
+  if (repos.size > 0) {
+    for (const repo of repos) {
+      for (const skillName of skillCandidates) {
+        try {
+          resolved = await resolveSkillFromGitHub(repo, skillName, githubOptions);
+          break;
+        } catch (error) {
+          resolveError = error;
+        }
+      }
+      if (resolved) {
+        break;
+      }
+    }
+  }
+  if (!resolved) {
+    const archiveResolved = await resolveSkillFromArchive(metadata, canonicalIdentifier, options);
+    if (archiveResolved) {
+      return archiveResolved;
+    }
+    if (repos.size === 0) {
+      throw new GuardSkillsError(
+        "CLAWHUB_UNKNOWN",
+        `ClawHub package '${canonicalIdentifier}' did not expose a resolvable GitHub source or archive payload.`
+      );
+    }
+    throw new GuardSkillsError(
+      "SKILL_NOT_FOUND",
+      `Unable to map ClawHub package '${canonicalIdentifier}' to a GitHub skill. Repos tried: ${[...repos].join(", ")}. Skill names tried: ${skillCandidates.join(", ")}.`,
+      { cause: resolveError }
+    );
+  }
+  const packageVersion = options.version ?? (typeof metadata.version === "string" ? metadata.version : void 0);
+  const sourceSuffix = packageVersion ? `${canonicalIdentifier}@${packageVersion}` : canonicalIdentifier;
+  const moderation = parseClawHubModeration(metadata);
+  return {
+    ...resolved,
+    source: `clawhub:${sourceSuffix}`,
+    unverifiableReasons: [...resolved.unverifiableReasons],
+    sourceMetadata: moderation ? {
+      ...resolved.sourceMetadata ?? {},
+      clawhubModeration: moderation
+    } : resolved.sourceMetadata
+  };
+}
+
+// src/commands/scan-clawhub.ts
+var cliScanClawHubOptionsSchema = import_zod3.z.object({
   config: import_zod3.z.string().optional(),
   strict: import_zod3.z.boolean().optional(),
   json: import_zod3.z.boolean().optional(),
   skill: import_zod3.z.string().min(1).optional(),
+  version: import_zod3.z.string().min(1).optional(),
+  clawhubRegistry: import_zod3.z.string().min(1).optional(),
+  githubTimeoutMs: import_zod3.z.coerce.number().int().min(1e3).max(12e4).optional(),
+  githubRetries: import_zod3.z.coerce.number().int().min(0).max(6).optional(),
+  githubRetryBaseMs: import_zod3.z.coerce.number().int().min(50).max(5e3).optional(),
   maxFileBytes: import_zod3.z.coerce.number().int().min(4096).max(5e6).optional(),
+  maxAuxFiles: import_zod3.z.coerce.number().int().min(1).max(200).optional(),
   maxTotalFiles: import_zod3.z.coerce.number().int().min(1).max(400).optional()
 });
-var effectiveScanLocalOptionsSchema = import_zod3.z.object({
+var effectiveScanClawHubOptionsSchema = import_zod3.z.object({
   strict: import_zod3.z.boolean(),
   json: import_zod3.z.boolean(),
   skill: import_zod3.z.string().min(1).optional(),
+  version: import_zod3.z.string().min(1).optional(),
+  clawhubRegistry: import_zod3.z.string().min(1),
+  githubTimeoutMs: import_zod3.z.number().int().min(1e3).max(12e4),
+  githubRetries: import_zod3.z.number().int().min(0).max(6),
+  githubRetryBaseMs: import_zod3.z.number().int().min(50).max(5e3),
   maxFileBytes: import_zod3.z.number().int().min(4096).max(5e6),
+  maxAuxFiles: import_zod3.z.number().int().min(1).max(200),
   maxTotalFiles: import_zod3.z.number().int().min(1).max(400)
 });
 var DEFAULT_OPTIONS2 = {
+  strict: false,
+  json: false,
+  skill: void 0,
+  version: void 0,
+  clawhubRegistry: "https://clawhub.ai",
+  githubTimeoutMs: 15e3,
+  githubRetries: 2,
+  githubRetryBaseMs: 300,
+  maxFileBytes: 25e4,
+  maxAuxFiles: 40,
+  maxTotalFiles: 120
+};
+function alignWithClawHubModeration(baseDecision, moderation) {
+  if (!moderation) {
+    return { decision: baseDecision };
+  }
+  if (moderation.isMalwareBlocked) {
+    return {
+      decision: {
+        ...baseDecision,
+        riskScore: 100,
+        safetyScore: 0,
+        level: "CRITICAL",
+        reason: "ClawHub moderation marked this skill as malware-blocked."
+      },
+      moderationNote: "Aligned with ClawHub moderation: malware-blocked."
+    };
+  }
+  if (moderation.isSuspicious && baseDecision.level === "SAFE") {
+    const adjustedRisk = Math.max(baseDecision.riskScore ?? 0, 30);
+    return {
+      decision: {
+        ...baseDecision,
+        riskScore: adjustedRisk,
+        safetyScore: 100 - adjustedRisk,
+        level: "WARNING",
+        reason: "ClawHub moderation marked this skill as suspicious."
+      },
+      moderationNote: "Aligned with ClawHub moderation: suspicious."
+    };
+  }
+  return { decision: baseDecision };
+}
+function resolveEffectiveScanClawHubOptions(cliOptions, config) {
+  const defaults = config.defaults ?? {};
+  const resolver = config.resolver ?? {};
+  return effectiveScanClawHubOptionsSchema.parse({
+    strict: cliOptions.strict ?? defaults.strict ?? DEFAULT_OPTIONS2.strict,
+    json: cliOptions.json ?? defaults.json ?? DEFAULT_OPTIONS2.json,
+    skill: cliOptions.skill ?? DEFAULT_OPTIONS2.skill,
+    version: cliOptions.version ?? DEFAULT_OPTIONS2.version,
+    clawhubRegistry: cliOptions.clawhubRegistry ?? DEFAULT_OPTIONS2.clawhubRegistry,
+    githubTimeoutMs: cliOptions.githubTimeoutMs ?? resolver.githubTimeoutMs ?? DEFAULT_OPTIONS2.githubTimeoutMs,
+    githubRetries: cliOptions.githubRetries ?? resolver.githubRetries ?? DEFAULT_OPTIONS2.githubRetries,
+    githubRetryBaseMs: cliOptions.githubRetryBaseMs ?? resolver.githubRetryBaseMs ?? DEFAULT_OPTIONS2.githubRetryBaseMs,
+    maxFileBytes: cliOptions.maxFileBytes ?? resolver.maxFileBytes ?? DEFAULT_OPTIONS2.maxFileBytes,
+    maxAuxFiles: cliOptions.maxAuxFiles ?? resolver.maxAuxFiles ?? DEFAULT_OPTIONS2.maxAuxFiles,
+    maxTotalFiles: cliOptions.maxTotalFiles ?? resolver.maxTotalFiles ?? DEFAULT_OPTIONS2.maxTotalFiles
+  });
+}
+async function runScanClawHubCommand(identifier, rawOptions) {
+  const cliOptions = cliScanClawHubOptionsSchema.parse(rawOptions);
+  const loadedConfig = loadGuardSkillsConfig(cliOptions.config);
+  const options = resolveEffectiveScanClawHubOptions(cliOptions, loadedConfig.config);
+  const resolved = await resolveSkillFromClawHub(identifier, {
+    registryBaseUrl: options.clawhubRegistry,
+    version: options.version,
+    skillNameOverride: options.skill,
+    requestTimeoutMs: options.githubTimeoutMs,
+    retries: options.githubRetries,
+    retryBaseDelayMs: options.githubRetryBaseMs,
+    maxFileSizeBytes: options.maxFileBytes,
+    maxAuxFiles: options.maxAuxFiles,
+    maxTotalFiles: options.maxTotalFiles
+  });
+  const scan = scanResolvedSkill(resolved);
+  const baseDecision = calculateRiskScore(scan.findings, {
+    strict: options.strict,
+    trustCredits: 0,
+    hasUnverifiableContent: scan.hasUnverifiableContent
+  });
+  const moderation = resolved.sourceMetadata?.clawhubModeration;
+  const { decision, moderationNote } = alignWithClawHubModeration(baseDecision, moderation);
+  const noteParts = ["ClawHub scan complete."];
+  if (moderationNote) {
+    noteParts.push(moderationNote);
+  }
+  if (decision.level === "UNSAFE" || decision.level === "CRITICAL" || decision.level === "UNVERIFIABLE") {
+    noteParts.push("Blocked-level risk detected.");
+  }
+  if (loadedConfig.path) {
+    noteParts.push(`Config: ${loadedConfig.path}`);
+  }
+  const report = {
+    command: "guardskills scan-clawhub",
+    identifier,
+    registry: options.clawhubRegistry,
+    strict: options.strict,
+    configPath: loadedConfig.path ?? void 0,
+    decision,
+    scanFiles: resolved.files.map((file) => file.path),
+    skillDir: resolved.skillDir,
+    repo: `${resolved.owner}/${resolved.repo}`,
+    skill: resolved.skillName,
+    version: options.version,
+    commitSha: resolved.commitSha,
+    moderation,
+    unverifiableReasons: scan.unverifiableReasons,
+    note: noteParts.join(" ")
+  };
+  if (options.json) {
+    printJsonClawHubReport(report);
+  } else {
+    printHumanClawHubReport(report);
+  }
+  return decision.level === "UNSAFE" || decision.level === "CRITICAL" || decision.level === "UNVERIFIABLE" ? 20 : 0;
+}
+
+// src/commands/scan-local.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var import_zod4 = require("zod");
+var ALLOWED_TEXT_EXTENSIONS3 = /* @__PURE__ */ new Set([
+  ".md",
+  ".txt",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".ps1",
+  ".py",
+  ".js",
+  ".ts",
+  ".mjs",
+  ".cjs",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".cfg"
+]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", ".turbo"]);
+var cliScanLocalOptionsSchema = import_zod4.z.object({
+  config: import_zod4.z.string().optional(),
+  strict: import_zod4.z.boolean().optional(),
+  json: import_zod4.z.boolean().optional(),
+  skill: import_zod4.z.string().min(1).optional(),
+  maxFileBytes: import_zod4.z.coerce.number().int().min(4096).max(5e6).optional(),
+  maxTotalFiles: import_zod4.z.coerce.number().int().min(1).max(400).optional()
+});
+var effectiveScanLocalOptionsSchema = import_zod4.z.object({
+  strict: import_zod4.z.boolean(),
+  json: import_zod4.z.boolean(),
+  skill: import_zod4.z.string().min(1).optional(),
+  maxFileBytes: import_zod4.z.number().int().min(4096).max(5e6),
+  maxTotalFiles: import_zod4.z.number().int().min(1).max(400)
+});
+var DEFAULT_OPTIONS3 = {
   strict: false,
   json: false,
   skill: void 0,
@@ -1220,28 +1979,28 @@ function toPosixPath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function getNearbyPathSuggestions(targetPath) {
-  const parent = import_node_path4.default.dirname(targetPath);
+  const parent = import_node_path5.default.dirname(targetPath);
   if (!import_node_fs2.default.existsSync(parent)) {
     return [];
   }
-  const needle = import_node_path4.default.basename(targetPath).toLowerCase();
+  const needle = import_node_path5.default.basename(targetPath).toLowerCase();
   const suggestions = [];
   for (const entry of import_node_fs2.default.readdirSync(parent, { withFileTypes: true })) {
     if (entry.name.toLowerCase().includes(needle)) {
-      suggestions.push(import_node_path4.default.join(parent, entry.name));
+      suggestions.push(import_node_path5.default.join(parent, entry.name));
     }
   }
   return suggestions.slice(0, 5);
 }
 function isSkillFile(filePath) {
-  return import_node_path4.default.basename(filePath).toLowerCase() === "skill.md";
+  return import_node_path5.default.basename(filePath).toLowerCase() === "skill.md";
 }
 function isScannableTextFile(filePath) {
   if (isSkillFile(filePath)) {
     return true;
   }
-  const ext = import_node_path4.default.extname(filePath).toLowerCase();
-  return ALLOWED_TEXT_EXTENSIONS2.has(ext);
+  const ext = import_node_path5.default.extname(filePath).toLowerCase();
+  return ALLOWED_TEXT_EXTENSIONS3.has(ext);
 }
 function findSkillDirs(rootDir) {
   const found = /* @__PURE__ */ new Set();
@@ -1256,7 +2015,7 @@ function findSkillDirs(rootDir) {
     if (seen > 5e3) {
       break;
     }
-    const skillFile = import_node_path4.default.join(current.dir, "SKILL.md");
+    const skillFile = import_node_path5.default.join(current.dir, "SKILL.md");
     if (import_node_fs2.default.existsSync(skillFile) && import_node_fs2.default.statSync(skillFile).isFile()) {
       found.add(current.dir);
       continue;
@@ -1277,7 +2036,7 @@ function findSkillDirs(rootDir) {
       if (SKIP_DIRS.has(entry.name)) {
         continue;
       }
-      stack.push({ dir: import_node_path4.default.join(current.dir, entry.name), depth: current.depth + 1 });
+      stack.push({ dir: import_node_path5.default.join(current.dir, entry.name), depth: current.depth + 1 });
     }
   }
   return [...found].sort();
@@ -1286,7 +2045,7 @@ function formatCandidates(candidates) {
   return candidates.map((candidate) => `- ${toPosixPath(candidate)}`).join("\n");
 }
 function resolveSkillDirectory(inputPath, preferredSkillName) {
-  const absoluteInput = import_node_path4.default.resolve(inputPath);
+  const absoluteInput = import_node_path5.default.resolve(inputPath);
   if (!import_node_fs2.default.existsSync(absoluteInput)) {
     const suggestions = getNearbyPathSuggestions(absoluteInput);
     const suggestionText = suggestions.length > 0 ? `
@@ -1306,11 +2065,11 @@ ${formatCandidates(suggestions)}` : "";
       );
     }
     return {
-      skillDir: import_node_path4.default.dirname(absoluteInput),
+      skillDir: import_node_path5.default.dirname(absoluteInput),
       note: "Using parent directory of provided SKILL.md file."
     };
   }
-  const directSkillFile = import_node_path4.default.join(absoluteInput, "SKILL.md");
+  const directSkillFile = import_node_path5.default.join(absoluteInput, "SKILL.md");
   if (import_node_fs2.default.existsSync(directSkillFile) && import_node_fs2.default.statSync(directSkillFile).isFile()) {
     return { skillDir: absoluteInput };
   }
@@ -1323,7 +2082,7 @@ ${formatCandidates(suggestions)}` : "";
   }
   if (preferredSkillName) {
     const matches = discovered.filter(
-      (directory) => import_node_path4.default.basename(directory).toLowerCase() === preferredSkillName.toLowerCase()
+      (directory) => import_node_path5.default.basename(directory).toLowerCase() === preferredSkillName.toLowerCase()
     );
     if (matches.length === 1) {
       const selected = matches[0];
@@ -1335,7 +2094,7 @@ ${formatCandidates(suggestions)}` : "";
         note: `Auto-selected skill '${preferredSkillName}' under the provided path.`
       };
     }
-    const available = discovered.map((directory) => import_node_path4.default.basename(directory));
+    const available = discovered.map((directory) => import_node_path5.default.basename(directory));
     throw new GuardSkillsError(
       "INVALID_LOCAL_PATH",
       `Requested --skill '${preferredSkillName}' was not found.
@@ -1375,7 +2134,7 @@ function collectLocalFiles(skillDir, options) {
       continue;
     }
     for (const entry of entries) {
-      const fullPath = import_node_path4.default.join(currentDir, entry.name);
+      const fullPath = import_node_path5.default.join(currentDir, entry.name);
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name)) {
           stack.push(fullPath);
@@ -1385,7 +2144,7 @@ function collectLocalFiles(skillDir, options) {
       if (!entry.isFile()) {
         continue;
       }
-      const relativePath = toPosixPath(import_node_path4.default.relative(skillDir, fullPath));
+      const relativePath = toPosixPath(import_node_path5.default.relative(skillDir, fullPath));
       if (!isScannableTextFile(relativePath)) {
         continue;
       }
@@ -1424,11 +2183,11 @@ function resolveEffectiveScanLocalOptions(cliOptions, config) {
   const defaults = config.defaults ?? {};
   const resolver = config.resolver ?? {};
   return effectiveScanLocalOptionsSchema.parse({
-    strict: cliOptions.strict ?? defaults.strict ?? DEFAULT_OPTIONS2.strict,
-    json: cliOptions.json ?? defaults.json ?? DEFAULT_OPTIONS2.json,
-    skill: cliOptions.skill ?? DEFAULT_OPTIONS2.skill,
-    maxFileBytes: cliOptions.maxFileBytes ?? resolver.maxFileBytes ?? DEFAULT_OPTIONS2.maxFileBytes,
-    maxTotalFiles: cliOptions.maxTotalFiles ?? resolver.maxTotalFiles ?? DEFAULT_OPTIONS2.maxTotalFiles
+    strict: cliOptions.strict ?? defaults.strict ?? DEFAULT_OPTIONS3.strict,
+    json: cliOptions.json ?? defaults.json ?? DEFAULT_OPTIONS3.json,
+    skill: cliOptions.skill ?? DEFAULT_OPTIONS3.skill,
+    maxFileBytes: cliOptions.maxFileBytes ?? resolver.maxFileBytes ?? DEFAULT_OPTIONS3.maxFileBytes,
+    maxTotalFiles: cliOptions.maxTotalFiles ?? resolver.maxTotalFiles ?? DEFAULT_OPTIONS3.maxTotalFiles
   });
 }
 async function runScanLocalCommand(inputPath, rawOptions) {
@@ -1449,7 +2208,7 @@ async function runScanLocalCommand(inputPath, rawOptions) {
     repo: "local",
     defaultBranch: "local",
     commitSha: "local",
-    skillName: options.skill ?? import_node_path4.default.basename(target.skillDir),
+    skillName: options.skill ?? import_node_path5.default.basename(target.skillDir),
     skillDir: toPosixPath(target.skillDir),
     skillFilePath: "SKILL.md",
     files,
@@ -1493,7 +2252,7 @@ async function runScanLocalCommand(inputPath, rawOptions) {
 // src/cli.ts
 async function main() {
   const program = new import_commander.Command();
-  program.name("guardskills").description("Security wrapper around skills add").version("0.1.0-alpha.3");
+  program.name("guardskills").description("Security wrapper around skills add").version("1.1.0");
   program.command("add").description("Scan a skill source and conditionally install it via skills CLI").argument("<repo>", "GitHub repository URL or owner/repo").requiredOption("--skill <name>", "Skill name to install").option("--config <path>", "Path to guardskills.config.json").option("--strict", "Use stricter risk thresholds").option("--ci", "Deterministic CI mode: scan + gate only, no install handoff").option("--json", "Output machine-readable JSON").option("--yes", "Auto-confirm warnings").option("--dry-run", "Scan only, do not install").option("--force", "Override UNSAFE outcome").option("--allow-unverifiable", "Override UNVERIFIABLE outcome").option("--github-timeout-ms <ms>", "GitHub API request timeout in milliseconds").option("--github-retries <count>", "Retry count for retryable GitHub errors").option("--github-retry-base-ms <ms>", "Base backoff delay for GitHub retries").option("--max-file-bytes <bytes>", "Max file size to scan").option("--max-aux-files <count>", "Max auxiliary files from scripts/src folders").option("--max-total-files <count>", "Max total resolved files to scan").action(async (repo, options) => {
     const code = await runAddCommand(repo, options);
     process.exitCode = code;
@@ -1502,6 +2261,10 @@ async function main() {
     const code = await runScanLocalCommand(inputPath, options);
     process.exitCode = code;
   });
+  program.command("scan-clawhub").description("Scan a ClawHub skill package and print a risk decision").argument("<identifier>", "ClawHub package identifier").option("--skill <name>", "Override skill folder name to resolve in source repository").option("--version <version>", "Preferred package version/tag").option("--clawhub-registry <url>", "ClawHub registry base URL").option("--config <path>", "Path to guardskills.config.json").option("--strict", "Use stricter risk thresholds").option("--json", "Output machine-readable JSON").option("--github-timeout-ms <ms>", "Upstream resolver request timeout in milliseconds").option("--github-retries <count>", "Retry count for retryable upstream errors").option("--github-retry-base-ms <ms>", "Base backoff delay for upstream retries").option("--max-file-bytes <bytes>", "Max file size to scan").option("--max-aux-files <count>", "Max auxiliary files from scripts/src folders").option("--max-total-files <count>", "Max total resolved files to scan").action(async (identifier, options) => {
+    const code = await runScanClawHubCommand(identifier, options);
+    process.exitCode = code;
+  });
   await program.parseAsync(process.argv);
 }
 main().catch((error) => {