rulesync 7.15.1 → 7.16.0

package/dist/cli/index.js

@@ -47,6 +47,7 @@ import {
   directoryExists,
   ensureDir,
   fileExists,
+  findControlCharacter,
   findFilesByGlobs,
   formatError,
   generate,
@@ -62,7 +63,7 @@ import {
   removeTempDirectory,
   stringifyFrontmatter,
   writeFileContent
-} from "../chunk-L5AQUWUM.js";
+} from "../chunk-E5YWRHGW.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -1618,21 +1619,12 @@ import { Semaphore as Semaphore2 } from "es-toolkit/promise";
 
 // src/lib/git-client.ts
 import { execFile } from "child_process";
-import { join as join4 } from "path";
+import { isAbsolute, join as join4, relative } from "path";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var GIT_TIMEOUT_MS = 6e4;
-var ALLOWED_URL_SCHEMES = /^(https?:\/\/|ssh:\/\/|git:\/\/|file:\/\/\/|[a-zA-Z0-9_.+-]+@[a-zA-Z0-9.-]+:[a-zA-Z0-9_.+/~-]+)/;
+var ALLOWED_URL_SCHEMES = /^(https?:\/\/|ssh:\/\/|git:\/\/|file:\/\/\/).+$|^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9.-]+:[a-zA-Z0-9_.+/~-]+$/;
 var INSECURE_URL_SCHEMES = /^(git:\/\/|http:\/\/)/;
-function findControlCharacter(value) {
-  for (let i = 0; i < value.length; i++) {
-    const code = value.charCodeAt(i);
-    if (code >= 0 && code <= 31 || code === 127) {
-      return { position: i, hex: `0x${code.toString(16).padStart(2, "0")}` };
-    }
-  }
-  return null;
-}
 var GitClientError = class extends Error {
   constructor(message, cause) {
     super(message, { cause });
@@ -1688,6 +1680,7 @@ async function resolveDefaultRef(url) {
     const ref = stdout.match(/^ref: refs\/heads\/(.+)\tHEAD$/m)?.[1];
     const sha = stdout.match(/^([0-9a-f]{40})\tHEAD$/m)?.[1];
     if (!ref || !sha) throw new GitClientError(`Could not parse default branch from: ${url}`);
+    validateRef(ref);
     return { ref, sha };
   } catch (error) {
     if (error instanceof GitClientError) throw error;
@@ -1714,6 +1707,17 @@ async function fetchSkillFiles(params) {
   const { url, ref, skillsPath } = params;
   validateGitUrl(url);
   validateRef(ref);
+  if (skillsPath.split(/[/\\]/).includes("..") || isAbsolute(skillsPath)) {
+    throw new GitClientError(
+      `Invalid skillsPath "${skillsPath}": must be a relative path without ".."`
+    );
+  }
+  const ctrl = findControlCharacter(skillsPath);
+  if (ctrl) {
+    throw new GitClientError(
+      `skillsPath contains control character ${ctrl.hex} at position ${ctrl.position}`
+    );
+  }
   await checkGitAvailable();
   const tmpDir = await createTempDirectory("rulesync-git-");
   try {
@@ -1748,7 +1752,9 @@ async function fetchSkillFiles(params) {
   }
 }
 var MAX_WALK_DEPTH = 20;
-async function walkDirectory(dir, baseDir, depth = 0) {
+var MAX_TOTAL_FILES = 1e4;
+var MAX_TOTAL_SIZE = 100 * 1024 * 1024;
+async function walkDirectory(dir, baseDir, depth = 0, ctx = { totalFiles: 0, totalSize: 0 }) {
   if (depth > MAX_WALK_DEPTH) {
     throw new GitClientError(
       `Directory tree exceeds max depth of ${MAX_WALK_DEPTH}: "${dir}". Aborting to prevent resource exhaustion.`
@@ -1763,7 +1769,7 @@ async function walkDirectory(dir, baseDir, depth = 0) {
       continue;
     }
     if (await directoryExists(fullPath)) {
-      results.push(...await walkDirectory(fullPath, baseDir, depth + 1));
+      results.push(...await walkDirectory(fullPath, baseDir, depth + 1, ctx));
     } else {
       const size = await getFileSize(fullPath);
       if (size > MAX_FILE_SIZE) {
@@ -1772,8 +1778,20 @@ async function walkDirectory(dir, baseDir, depth = 0) {
         );
         continue;
       }
+      ctx.totalFiles++;
+      ctx.totalSize += size;
+      if (ctx.totalFiles >= MAX_TOTAL_FILES) {
+        throw new GitClientError(
+          `Repository exceeds max file count of ${MAX_TOTAL_FILES}. Aborting to prevent resource exhaustion.`
+        );
+      }
+      if (ctx.totalSize >= MAX_TOTAL_SIZE) {
+        throw new GitClientError(
+          `Repository exceeds max total size of ${MAX_TOTAL_SIZE / 1024 / 1024}MB. Aborting to prevent resource exhaustion.`
+        );
+      }
       const content = await readFileContent(fullPath);
-      results.push({ relativePath: fullPath.substring(baseDir.length + 1), content, size });
+      results.push({ relativePath: relative(baseDir, fullPath), content, size });
     }
   }
   return results;
@@ -1782,14 +1800,14 @@ async function walkDirectory(dir, baseDir, depth = 0) {
 // src/lib/sources-lock.ts
 import { createHash } from "crypto";
 import { join as join5 } from "path";
-import { optional, z as z4 } from "zod/mini";
+import { optional, refine, z as z4 } from "zod/mini";
 var LOCKFILE_VERSION = 1;
 var LockedSkillSchema = z4.object({
   integrity: z4.string()
 });
 var LockedSourceSchema = z4.object({
   requestedRef: optional(z4.string()),
-  resolvedRef: z4.string(),
+  resolvedRef: z4.string().check(refine((v) => /^[0-9a-f]{40}$/.test(v), "resolvedRef must be a 40-character hex SHA")),
   resolvedAt: optional(z4.string()),
   skills: z4.record(z4.string(), LockedSkillSchema)
 });
@@ -1992,6 +2010,8 @@ async function resolveAndFetchSources(params) {
       logger.error(`Failed to fetch source "${sourceEntry.source}": ${formatError(error)}`);
       if (error instanceof GitHubClientError) {
         logGitHubAuthHints(error);
+      } else if (error instanceof GitClientError) {
+        logGitClientHints(error);
       }
     }
   }
@@ -2012,6 +2032,13 @@ async function resolveAndFetchSources(params) {
   }
   return { fetchedSkillCount: totalSkillCount, sourcesProcessed: sources.length };
 }
+function logGitClientHints(error) {
+  if (error.message.includes("not installed")) {
+    logger.info("Hint: Install git and ensure it is available on your PATH.");
+  } else {
+    logger.info("Hint: Check your git credentials (SSH keys, credential helper, or access token).");
+  }
+}
 async function checkLockedSkillsExist(curatedDir, skillNames) {
   if (skillNames.length === 0) return true;
   for (const name of skillNames) {
@@ -2021,9 +2048,88 @@ async function checkLockedSkillsExist(curatedDir, skillNames) {
   }
   return true;
 }
+async function cleanPreviousCuratedSkills(curatedDir, lockedSkillNames) {
+  const resolvedCuratedDir = resolve(curatedDir);
+  for (const prevSkill of lockedSkillNames) {
+    const prevDir = join6(curatedDir, prevSkill);
+    if (!resolve(prevDir).startsWith(resolvedCuratedDir + sep)) {
+      logger.warn(
+        `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
+      );
+      continue;
+    }
+    if (await directoryExists(prevDir)) {
+      await removeDirectory(prevDir);
+    }
+  }
+}
+function shouldSkipSkill(params) {
+  const { skillName, sourceKey, localSkillNames, alreadyFetchedSkillNames } = params;
+  if (skillName.includes("..") || skillName.includes("/") || skillName.includes("\\")) {
+    logger.warn(
+      `Skipping skill with invalid name "${skillName}" from ${sourceKey}: contains path traversal characters.`
+    );
+    return true;
+  }
+  if (localSkillNames.has(skillName)) {
+    logger.debug(
+      `Skipping remote skill "${skillName}" from ${sourceKey}: local skill takes precedence.`
+    );
+    return true;
+  }
+  if (alreadyFetchedSkillNames.has(skillName)) {
+    logger.warn(
+      `Skipping duplicate skill "${skillName}" from ${sourceKey}: already fetched from another source.`
+    );
+    return true;
+  }
+  return false;
+}
+async function writeSkillAndComputeIntegrity(params) {
+  const { skillName, files, curatedDir, locked, resolvedSha, sourceKey } = params;
+  const written = [];
+  for (const file of files) {
+    checkPathTraversal({
+      relativePath: file.relativePath,
+      intendedRootDir: join6(curatedDir, skillName)
+    });
+    await writeFileContent(join6(curatedDir, skillName, file.relativePath), file.content);
+    written.push({ path: file.relativePath, content: file.content });
+  }
+  const integrity = computeSkillIntegrity(written);
+  const lockedSkillEntry = locked?.skills[skillName];
+  if (lockedSkillEntry?.integrity && lockedSkillEntry.integrity !== integrity && resolvedSha === locked?.resolvedRef) {
+    logger.warn(
+      `Integrity mismatch for skill "${skillName}" from ${sourceKey}: expected "${lockedSkillEntry.integrity}", got "${integrity}". Content may have been tampered with.`
+    );
+  }
+  return { integrity };
+}
+function buildLockUpdate(params) {
+  const { lock, sourceKey, fetchedSkills, locked, requestedRef, resolvedSha } = params;
+  const fetchedNames = Object.keys(fetchedSkills);
+  const mergedSkills = { ...fetchedSkills };
+  if (locked) {
+    for (const [skillName, skillEntry] of Object.entries(locked.skills)) {
+      if (!(skillName in mergedSkills)) {
+        mergedSkills[skillName] = skillEntry;
+      }
+    }
+  }
+  const updatedLock = setLockedSource(lock, sourceKey, {
+    requestedRef,
+    resolvedRef: resolvedSha,
+    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    skills: mergedSkills
+  });
+  logger.info(
+    `Fetched ${fetchedNames.length} skill(s) from ${sourceKey}: ${fetchedNames.join(", ") || "(none)"}`
+  );
+  return { updatedLock, fetchedNames };
+}
 async function fetchSource(params) {
   const { sourceEntry, client, baseDir, localSkillNames, alreadyFetchedSkillNames, updateSources } = params;
-  let { lock } = params;
+  const { lock } = params;
   const parsed = parseSource(sourceEntry.source);
   if (parsed.provider === "gitlab") {
     logger.warn(`GitLab sources are not yet supported. Skipping "${sourceEntry.source}".`);
@@ -2076,37 +2182,15 @@ async function fetchSource(params) {
   const semaphore = new Semaphore2(FETCH_CONCURRENCY_LIMIT);
   const fetchedSkills = {};
   if (locked) {
-    const resolvedCuratedDir = resolve(curatedDir);
-    for (const prevSkill of lockedSkillNames) {
-      const prevDir = join6(curatedDir, prevSkill);
-      if (!resolve(prevDir).startsWith(resolvedCuratedDir + sep)) {
-        logger.warn(
-          `Skipping removal of "${prevSkill}": resolved path is outside the curated directory.`
-        );
-        continue;
-      }
-      if (await directoryExists(prevDir)) {
-        await removeDirectory(prevDir);
-      }
-    }
+    await cleanPreviousCuratedSkills(curatedDir, lockedSkillNames);
   }
   for (const skillDir of filteredDirs) {
-    if (skillDir.name.includes("..") || skillDir.name.includes("/") || skillDir.name.includes("\\")) {
-      logger.warn(
-        `Skipping skill with invalid name "${skillDir.name}" from ${sourceKey}: contains path traversal characters.`
-      );
-      continue;
-    }
-    if (localSkillNames.has(skillDir.name)) {
-      logger.debug(
-        `Skipping remote skill "${skillDir.name}" from ${sourceKey}: local skill takes precedence.`
-      );
-      continue;
-    }
-    if (alreadyFetchedSkillNames.has(skillDir.name)) {
-      logger.warn(
-        `Skipping duplicate skill "${skillDir.name}" from ${sourceKey}: already fetched from another source.`
-      );
+    if (shouldSkipSkill({
+      skillName: skillDir.name,
+      sourceKey,
+      localSkillNames,
+      alreadyFetchedSkillNames
+    })) {
       continue;
     }
     const allFiles = await listDirectoryRecursive({
@@ -2129,55 +2213,39 @@ async function fetchSource(params) {
     const skillFiles = [];
     for (const file of files) {
       const relativeToSkill = file.path.substring(skillDir.path.length + 1);
-      const localFilePath = join6(curatedDir, skillDir.name, relativeToSkill);
-      checkPathTraversal({
-        relativePath: relativeToSkill,
-        intendedRootDir: join6(curatedDir, skillDir.name)
-      });
       const content = await withSemaphore(
         semaphore,
         () => client.getFileContent(parsed.owner, parsed.repo, file.path, ref)
       );
-      await writeFileContent(localFilePath, content);
-      skillFiles.push({ path: relativeToSkill, content });
-    }
-    const integrity = computeSkillIntegrity(skillFiles);
-    const lockedSkillEntry = locked?.skills[skillDir.name];
-    if (lockedSkillEntry && lockedSkillEntry.integrity && lockedSkillEntry.integrity !== integrity && resolvedSha === locked?.resolvedRef) {
-      logger.warn(
-        `Integrity mismatch for skill "${skillDir.name}" from ${sourceKey}: expected "${lockedSkillEntry.integrity}", got "${integrity}". Content may have been tampered with.`
-      );
-    }
-    fetchedSkills[skillDir.name] = { integrity };
+      skillFiles.push({ relativePath: relativeToSkill, content });
+    }
+    fetchedSkills[skillDir.name] = await writeSkillAndComputeIntegrity({
+      skillName: skillDir.name,
+      files: skillFiles,
+      curatedDir,
+      locked,
+      resolvedSha,
+      sourceKey
+    });
     logger.debug(`Fetched skill "${skillDir.name}" from ${sourceKey}`);
   }
-  const fetchedNames = Object.keys(fetchedSkills);
-  const mergedSkills = { ...fetchedSkills };
-  if (locked) {
-    for (const [skillName, skillEntry] of Object.entries(locked.skills)) {
-      if (!(skillName in mergedSkills)) {
-        mergedSkills[skillName] = skillEntry;
-      }
-    }
-  }
-  lock = setLockedSource(lock, sourceKey, {
+  const result = buildLockUpdate({
+    lock,
+    sourceKey,
+    fetchedSkills,
+    locked,
     requestedRef,
-    resolvedRef: resolvedSha,
-    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    skills: mergedSkills
+    resolvedSha
   });
-  logger.info(
-    `Fetched ${fetchedNames.length} skill(s) from ${sourceKey}: ${fetchedNames.join(", ") || "(none)"}`
-  );
   return {
-    skillCount: fetchedNames.length,
-    fetchedSkillNames: fetchedNames,
-    updatedLock: lock
+    skillCount: result.fetchedNames.length,
+    fetchedSkillNames: result.fetchedNames,
+    updatedLock: result.updatedLock
   };
 }
 async function fetchSourceViaGit(params) {
   const { sourceEntry, baseDir, localSkillNames, alreadyFetchedSkillNames, updateSources, frozen } = params;
-  let { lock } = params;
+  const { lock } = params;
   const url = sourceEntry.source;
   const locked = getLockedSource(lock, url);
   const lockedSkillNames = locked ? getLockedSkillNames(locked) : [];
@@ -2233,68 +2301,35 @@ async function fetchSourceViaGit(params) {
   const allNames = [...skillFileMap.keys()];
   const filteredNames = isWildcard ? allNames : allNames.filter((n) => skillFilter.includes(n));
   if (locked) {
-    const base = resolve(curatedDir);
-    for (const prev of lockedSkillNames) {
-      const dir = join6(curatedDir, prev);
-      if (resolve(dir).startsWith(base + sep) && await directoryExists(dir)) {
-        await removeDirectory(dir);
-      }
-    }
+    await cleanPreviousCuratedSkills(curatedDir, lockedSkillNames);
   }
   const fetchedSkills = {};
   for (const skillName of filteredNames) {
-    if (skillName.includes("..") || skillName.includes("/") || skillName.includes("\\")) {
-      logger.warn(
-        `Skipping skill with invalid name "${skillName}" from ${url}: contains path traversal characters.`
-      );
-      continue;
-    }
-    if (localSkillNames.has(skillName)) {
-      logger.debug(
-        `Skipping remote skill "${skillName}" from ${url}: local skill takes precedence.`
-      );
-      continue;
-    }
-    if (alreadyFetchedSkillNames.has(skillName)) {
-      logger.warn(
-        `Skipping duplicate skill "${skillName}" from ${url}: already fetched from another source.`
-      );
+    if (shouldSkipSkill({ skillName, sourceKey: url, localSkillNames, alreadyFetchedSkillNames })) {
       continue;
     }
-    const files = skillFileMap.get(skillName) ?? [];
-    const written = [];
-    for (const file of files) {
-      checkPathTraversal({
-        relativePath: file.relativePath,
-        intendedRootDir: join6(curatedDir, skillName)
-      });
-      await writeFileContent(join6(curatedDir, skillName, file.relativePath), file.content);
-      written.push({ path: file.relativePath, content: file.content });
-    }
-    const integrity = computeSkillIntegrity(written);
-    const lockedSkillEntry = locked?.skills[skillName];
-    if (lockedSkillEntry?.integrity && lockedSkillEntry.integrity !== integrity && resolvedSha === locked?.resolvedRef) {
-      logger.warn(`Integrity mismatch for skill "${skillName}" from ${url}.`);
-    }
-    fetchedSkills[skillName] = { integrity };
-  }
-  const fetchedNames = Object.keys(fetchedSkills);
-  const mergedSkills = { ...fetchedSkills };
-  if (locked) {
-    for (const [k, v] of Object.entries(locked.skills)) {
-      if (!(k in mergedSkills)) mergedSkills[k] = v;
-    }
+    fetchedSkills[skillName] = await writeSkillAndComputeIntegrity({
+      skillName,
+      files: skillFileMap.get(skillName) ?? [],
+      curatedDir,
+      locked,
+      resolvedSha,
+      sourceKey: url
+    });
   }
-  lock = setLockedSource(lock, url, {
+  const result = buildLockUpdate({
+    lock,
+    sourceKey: url,
+    fetchedSkills,
+    locked,
     requestedRef,
-    resolvedRef: resolvedSha,
-    resolvedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    skills: mergedSkills
+    resolvedSha
   });
-  logger.info(
-    `Fetched ${fetchedNames.length} skill(s) from ${url}: ${fetchedNames.join(", ") || "(none)"}`
-  );
-  return { skillCount: fetchedNames.length, fetchedSkillNames: fetchedNames, updatedLock: lock };
+  return {
+    skillCount: result.fetchedNames.length,
+    fetchedSkillNames: result.fetchedNames,
+    updatedLock: result.updatedLock
+  };
 }
 
 // src/cli/commands/install.ts
@@ -4110,7 +4145,7 @@ async function updateCommand(currentVersion, options) {
 }
 
 // src/cli/index.ts
-var getVersion = () => "7.15.1";
+var getVersion = () => "7.16.0";
 var main = async () => {
   const program = new Command();
   const version = getVersion();