harness-everything 0.16.4 → 0.16.6

package/plugins/harness-everything/scripts/lib/claude-hooks.js

@@ -0,0 +1,84 @@
+// Merge/remove Harness's hook entries in a Claude Code settings.json without
+// disturbing anything else a user (or another tool) put there.
+const fs = require('fs');
+
+// Every hook this package ships is namespaced "harness:<phase>:<name>" (see
+// hooks/hooks.json) specifically so removal can match on that prefix alone.
+// To handle legacy installations (pre-0.3.0 or older) where hooks were installed
+// without an "id" field, we also check if any command contains keywords like
+// "harness-everything" or "harness-skills".
+function isHarnessHook(hook) {
+  if (!hook) return false;
+  if (hook.id && hook.id.startsWith('harness:')) {
+    return true;
+  }
+  if (Array.isArray(hook.hooks)) {
+    return hook.hooks.some(h => {
+      return h && typeof h.command === 'string' && (
+        h.command.includes('harness-everything') ||
+        h.command.includes('harness-skills') ||
+        h.command.includes('harness-state')
+      );
+    });
+  }
+  return false;
+}
+
+function mergeHarnessHooks(claudeConfig, resolvedHooks) {
+  claudeConfig.hooks = claudeConfig.hooks || {};
+  for (const [hookType, hookList] of Object.entries(resolvedHooks)) {
+    const existingList = claudeConfig.hooks[hookType] || [];
+    const mergedList = [...existingList];
+    hookList.forEach(newHook => {
+      const existsIdx = mergedList.findIndex(h => h.id === newHook.id);
+      if (existsIdx !== -1) {
+        mergedList[existsIdx] = newHook;
+      } else {
+        mergedList.push(newHook);
+      }
+    });
+    claudeConfig.hooks[hookType] = mergedList;
+  }
+  return claudeConfig;
+}
+
+function removeHarnessHooks(claudeSettingsFile) {
+  if (!fs.existsSync(claudeSettingsFile)) return false;
+  try {
+    const content = fs.readFileSync(claudeSettingsFile, 'utf8');
+    let config = JSON.parse(content);
+    if (!config.hooks) return false;
+
+    let modified = false;
+    for (const [hookType, hookList] of Object.entries(config.hooks)) {
+      if (!Array.isArray(hookList)) continue;
+      const originalLength = hookList.length;
+      config.hooks[hookType] = hookList.filter(hook => !isHarnessHook(hook));
+      if (config.hooks[hookType].length !== originalLength) {
+        modified = true;
+      }
+      if (config.hooks[hookType].length === 0) {
+        delete config.hooks[hookType];
+      }
+    }
+    if (Object.keys(config.hooks || {}).length === 0) {
+      delete config.hooks;
+    }
+
+    if (modified) {
+      if (Object.keys(config).length === 0) {
+        fs.unlinkSync(claudeSettingsFile);
+        console.log(`  ✅ Cleaned up and removed empty Claude settings file: ${claudeSettingsFile}`);
+      } else {
+        fs.writeFileSync(claudeSettingsFile, JSON.stringify(config, null, 2), 'utf8');
+        console.log(`  ✅ Safely removed Harness hooks from Claude settings: ${claudeSettingsFile}`);
+      }
+      return true;
+    }
+  } catch (e) {
+    console.warn(`  ⚠️ Error cleaning Claude settings file ${claudeSettingsFile}: ${e.message}`);
+  }
+  return false;
+}
+
+module.exports = { isHarnessHook, mergeHarnessHooks, removeHarnessHooks };

package/plugins/harness-everything/scripts/lib/execution-contract.js

@@ -0,0 +1,70 @@
+const path = require('path');
+
+function normalizeCommand(command) {
+  if (Array.isArray(command)) {
+    return command.map((part) => String(part));
+  }
+  if (typeof command !== 'string') return null;
+  return command.trim().replace(/\s+/g, ' ');
+}
+
+function commandsEqual(actual, expected) {
+  const left = normalizeCommand(actual);
+  const right = normalizeCommand(expected);
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) &&
+      left.length === right.length && left.every((part, index) => part === right[index]);
+  }
+  return left !== null && left === right;
+}
+
+function commandTokens(command) {
+  if (typeof command !== 'string') return [];
+  return command.match(/"[^"]*"|'[^']*'|\S+/g) || [];
+}
+
+function commandMatches(actual, expected) {
+  if (commandsEqual(actual, expected)) return true;
+  if (typeof actual !== 'string' || typeof expected !== 'string') return false;
+  const target = expected.trim();
+  if (!target || /\s/.test(target) || !/\.(?:c?js|mjs|py|sh|ps1|bat|cmd)$/i.test(target)) return false;
+  const expectedName = path.basename(target.replace(/\\/g, '/')).toLowerCase();
+  const tokens = commandTokens(actual).map((token) => token.replace(/^['"]|['"]$/g, ''));
+  if (tokens.length < 2) return false;
+  const launcher = path.basename(tokens[0].replace(/\\/g, '/')).toLowerCase();
+  if (!new Set(['node', 'node.exe', 'bun', 'bun.exe', 'deno', 'deno.exe', 'python', 'python.exe', 'python3', 'python3.exe', 'ruby', 'ruby.exe']).has(launcher)) return false;
+  return tokens.slice(1).some((token) => path.basename(token.replace(/\\/g, '/')).toLowerCase() === expectedName);
+}
+
+function normalizeRepoPath(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.replace(/\\/g, '/').replace(/^\.\//, '');
+  const segments = normalized.split('/');
+  if (!normalized || normalized === '.' || path.posix.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized) || segments.includes('..')) return null;
+  return normalized;
+}
+
+function extractPatchPaths(patchText) {
+  if (typeof patchText !== 'string') return [];
+  const paths = [];
+  const marker = /^\*\*\* (?:Update File|Add File|Delete File|Move to):\s*(.+?)\s*$/gm;
+  for (const match of patchText.matchAll(marker)) {
+    if (!paths.includes(match[1])) paths.push(match[1]);
+  }
+  return paths;
+}
+
+function patchPathsAuthorized(patchText, allowedPaths) {
+  const paths = extractPatchPaths(patchText).map(normalizeRepoPath);
+  const allowed = new Set(Array.from(allowedPaths || []).map(normalizeRepoPath));
+  return paths.length > 0 && paths.every((candidate) => candidate && allowed.has(candidate));
+}
+
+module.exports = {
+  commandMatches,
+  commandsEqual,
+  extractPatchPaths,
+  normalizeCommand,
+  normalizeRepoPath,
+  patchPathsAuthorized,
+};

package/plugins/harness-everything/scripts/lib/gitignore.js

@@ -0,0 +1,199 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Checks if a target pattern is already covered by a line in an ignore file.
+ * Handles exact matches, trailing slash differences, and parent directory subsumption
+ * (e.g. `.claude/` or `.claude` subsumes `.claude/harness-everything/state/`).
+ */
+function isPatternCoveredByLine(pattern, gitignoreLine) {
+  const normPattern = pattern.trim().replace(/\\/g, '/');
+  const normLine = gitignoreLine.trim().replace(/\\/g, '/');
+
+  if (!normLine || normLine.startsWith('#') || normLine.startsWith('!')) {
+    return false;
+  }
+
+  const cleanLine = normLine.endsWith('/') ? normLine.slice(0, -1) : normLine;
+  const cleanPattern = normPattern.endsWith('/') ? normPattern.slice(0, -1) : normPattern;
+
+  // Exact match or slash variant (e.g. '.claude' vs '.claude/')
+  if (cleanLine === cleanPattern) {
+    return true;
+  }
+
+  // Parent directory check: e.g. '.claude' covers '.claude/harness-everything/'
+  if (cleanPattern.startsWith(cleanLine + '/')) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Resolves the real git directory for a workspace. `.git` is usually a
+ * directory, but in submodules and worktrees it is a FILE containing
+ * `gitdir: <path>` - resolve that pointer so info/exclude lands in the right
+ * place. Returns null when the workspace has no git repository.
+ */
+function resolveGitDir(wsRoot) {
+  const dotGit = path.join(wsRoot, '.git');
+  if (!fs.existsSync(dotGit)) return null;
+  try {
+    if (fs.statSync(dotGit).isDirectory()) return dotGit;
+    const content = fs.readFileSync(dotGit, 'utf8');
+    const m = content.match(/gitdir:\s*(.+)/);
+    if (!m) return null;
+    let gitdir = m[1].trim();
+    if (!path.isAbsolute(gitdir)) gitdir = path.resolve(wsRoot, gitdir);
+    return fs.existsSync(gitdir) ? gitdir : null;
+  } catch (e) {
+    return null;
+  }
+}
+
+const EXCLUDE_BANNER_BEGIN = '# --- Harness OS state (auto-managed; local only) ---';
+const EXCLUDE_BANNER_END = '# --- end Harness OS state ---';
+// Legacy marker written by older installers straight into .gitignore.
+const LEGACY_GITIGNORE_BANNER = '# Harness OS Auto-generated Ignore Rules';
+
+function readExcludeLines(gitDir) {
+  try {
+    return fs.readFileSync(path.join(gitDir, 'info', 'exclude'), 'utf8').split(/\r?\n/);
+  } catch (e) {
+    return null; // no exclude file yet - treat as empty but writable
+  }
+}
+
+function writeExcludeSection(gitDir, patterns) {
+  const infoDir = path.join(gitDir, 'info');
+  fs.mkdirSync(infoDir, { recursive: true });
+  const excludePath = path.join(infoDir, 'exclude');
+  let lines = [];
+  try {
+    lines = fs.readFileSync(excludePath, 'utf8').split(/\r?\n/);
+  } catch (e) {}
+
+  // Drop our previous section (if any), then rebuild it from the requested
+  // patterns - so removals from getIgnorePatterns() propagate on reinstall.
+  const beginIdx = lines.indexOf(EXCLUDE_BANNER_BEGIN);
+  const endIdx = lines.indexOf(EXCLUDE_BANNER_END);
+  if (beginIdx !== -1 && endIdx !== -1) {
+    lines.splice(beginIdx, endIdx - beginIdx + 1);
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop();
+
+  const section = ['', EXCLUDE_BANNER_BEGIN, ...patterns, EXCLUDE_BANNER_END, ''];
+  fs.writeFileSync(excludePath, lines.concat(section).join('\n'), 'utf8');
+}
+
+/**
+ * Idempotently records Harness state directories as LOCAL-ONLY ignores.
+ *
+ * Patterns go to `<gitdir>/info/exclude`, never the working tree's
+ * .gitignore - installing or self-healing must not produce a diff in the
+ * user's project. Also migrates away the legacy banner block that old
+ * versions appended to .gitignore.
+ */
+function ensureWorkspaceGitignorePatterns(wsRoot, patterns) {
+  const wanted = (patterns || []).filter(Boolean);
+
+  // Migration: strip the legacy banner + its pattern lines from .gitignore.
+  const gitignorePath = path.join(wsRoot, '.gitignore');
+  try {
+    if (fs.existsSync(gitignorePath)) {
+      const content = fs.readFileSync(gitignorePath, 'utf8');
+      if (content.includes(LEGACY_GITIGNORE_BANNER)) {
+        const lines = content.split(/\r?\n/);
+        const start = lines.findIndex(l => l.trim() === LEGACY_GITIGNORE_BANNER);
+        let end = start;
+        // The legacy block ran until the first non-pattern line (blank/comment/other rule).
+        for (let i = start + 1; i < lines.length; i++) {
+          const t = lines[i].trim();
+          if (t === '' || t.startsWith('#')) break;
+          end = i;
+        }
+        lines.splice(start, end - start + 1);
+        while (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop();
+        fs.writeFileSync(gitignorePath, lines.join('\n') + '\n', 'utf8');
+      }
+    }
+  } catch (err) {
+    console.warn(`  ⚠️ Failed to migrate legacy .gitignore entries: ${err.message}`);
+  }
+
+  const gitDir = resolveGitDir(wsRoot);
+  if (!gitDir) {
+    // No git repo -> nothing local-only to write into. State dirs are gated
+    // elsewhere (bootstrap refuses unmanaged workspaces), so this is fine.
+    return;
+  }
+
+  try {
+    const existing = readExcludeLines(gitDir) || [];
+    // Skip the write entirely when every wanted pattern is already inside our
+    // managed section OR covered by any ignore line (user's own broader rule).
+    const outside = existing.filter(
+      l => l !== EXCLUDE_BANNER_BEGIN && l !== EXCLUDE_BANNER_END
+    );
+    const missing = wanted.filter(p => !outside.some(line => isPatternCoveredByLine(p, line)));
+    const currentSection =
+      beginEnd(existing).start === -1
+        ? []
+        : existing.slice(beginEnd(existing).start + 1, beginEnd(existing).end);
+    const sameSet =
+      currentSection.filter(l => l.trim() && !l.trim().startsWith('#')).join('\n') ===
+      wanted.join('\n');
+    if (missing.length === 0 && sameSet) return;
+
+    writeExcludeSection(gitDir, wanted);
+    console.log(`  ✅ Recorded local-only ignore rules in .git/info/exclude: ${wanted.join(', ')}`);
+  } catch (err) {
+    console.warn(`  ⚠️ Failed to update .git/info/exclude: ${err.message}`);
+  }
+}
+
+function beginEnd(lines) {
+  return { start: lines.indexOf(EXCLUDE_BANNER_BEGIN), end: lines.indexOf(EXCLUDE_BANNER_END) };
+}
+
+/**
+ * Removes Harness's section from .git/info/exclude (uninstall cleanup).
+ * Never touches user-authored exclude rules.
+ */
+function removeWorkspaceExcludePatterns(wsRoot) {
+  const gitDir = resolveGitDir(wsRoot);
+  if (!gitDir) return;
+  try {
+    const excludePath = path.join(gitDir, 'info', 'exclude');
+    const lines = fs.readFileSync(excludePath, 'utf8').split(/\r?\n/);
+    const { start, end } = beginEnd(lines);
+    if (start === -1 || end === -1) return;
+    lines.splice(start, end - start + 1);
+    while (lines.length > 0 && lines[lines.length - 1].trim() === '') lines.pop();
+    fs.writeFileSync(excludePath, lines.join('\n') + '\n', 'utf8');
+  } catch (err) {
+    // Best-effort
+  }
+}
+
+// Only ever deletes a directory that is genuinely empty, and never recurses
+// past one of `stopDirs` (workspace root / user home / filesystem root) - so
+// this can only ever tidy up directories Harness itself just emptied out,
+// never reach into a parent that still holds unrelated content.
+function cleanEmptyDirs(dir, stopDirs) {
+  if (!fs.existsSync(dir)) return;
+  if ((stopDirs || []).includes(dir) || dir === path.parse(dir).root) return;
+  try {
+    const files = fs.readdirSync(dir);
+    if (files.length === 0) {
+      fs.rmdirSync(dir);
+      console.log(`  ✅ Cleaned up empty directory: ${dir}`);
+      cleanEmptyDirs(path.dirname(dir), stopDirs);
+    }
+  } catch (e) {
+    // ignore
+  }
+}
+
+module.exports = { ensureWorkspaceGitignorePatterns, removeWorkspaceExcludePatterns, resolveGitDir, cleanEmptyDirs };

package/plugins/harness-everything/scripts/lib/manifest.js

@@ -0,0 +1,142 @@
+// Tracks exactly what this package installed, so uninstall can remove
+// precisely those paths instead of sweeping shared directories that may also
+// hold content from other tools, the user's own manual additions, or
+// self-evolve's locally-generated skills.
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_NAME = 'harness-everything';
+const HARNESS_AUTHOR = 'Miya Daniel';
+const HARNESS_DIR_NAME = 'harness-everything';
+
+function getHarnessDir(homeDir) {
+  return path.join(homeDir, HARNESS_DIR_NAME);
+}
+
+function getManifestPath(homeDir) {
+  return path.join(getHarnessDir(homeDir), 'manifest.json');
+}
+
+function readManifest(manifestPath) {
+  if (!fs.existsSync(manifestPath)) return { package: PACKAGE_NAME, skills: [], agents: [] };
+  try {
+    const data = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    if (!Array.isArray(data.skills)) data.skills = [];
+    if (!Array.isArray(data.agents)) data.agents = [];
+    return data;
+  } catch (e) {
+    return { package: PACKAGE_NAME, skills: [], agents: [] };
+  }
+}
+
+function writeManifest(manifestPath, data) {
+  fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+  fs.writeFileSync(manifestPath, JSON.stringify(data, null, 2), 'utf8');
+}
+
+function isManifestEmpty(data) {
+  return (data.skills || []).length === 0 &&
+    (data.generated || []).length === 0 &&
+    (data.agents || []).length === 0;
+}
+
+// `references/` is copied by the installer into the same Harness-owned
+// bookkeeping directory as manifest.json. Once the manifest contains no
+// owned artifacts, both are package-owned leftovers and can be removed as a
+// unit without touching the platform home around them.
+function removeManifestArtifactsIfEmpty(manifestPath, data) {
+  if (!isManifestEmpty(data)) return false;
+  if (fs.existsSync(manifestPath)) fs.unlinkSync(manifestPath);
+  const harnessDir = path.dirname(manifestPath);
+  const referencesDir = path.join(harnessDir, 'references');
+  if (fs.existsSync(referencesDir)) fs.rmSync(referencesDir, { recursive: true, force: true });
+  try {
+    if (fs.existsSync(harnessDir) && fs.readdirSync(harnessDir).length === 0) fs.rmdirSync(harnessDir);
+  } catch (e) {
+    // Another owned runtime artifact may still live here; leave it intact.
+  }
+  return true;
+}
+
+function recordSkillInstall(manifestPath, packageVersion, skillId, dirPath, linkInfo = {}) {
+  const data = readManifest(manifestPath);
+  data.package = PACKAGE_NAME;
+  data.version = packageVersion;
+  data.updatedAt = new Date().toISOString();
+  const idx = data.skills.findIndex(s => s.dirPath === dirPath);
+  const entry = { id: skillId, dirPath, installedAt: new Date().toISOString() };
+  if (linkInfo.kind && linkInfo.kind !== 'copy') {
+    entry.kind = linkInfo.kind;
+    entry.canonicalPath = linkInfo.canonicalPath;
+  }
+  if (idx !== -1) data.skills[idx] = entry;
+  else data.skills.push(entry);
+  writeManifest(manifestPath, data);
+}
+
+function recordAgentInstall(manifestPath, packageVersion, agentId, filePath) {
+  const data = readManifest(manifestPath);
+  data.package = PACKAGE_NAME;
+  data.version = packageVersion;
+  data.updatedAt = new Date().toISOString();
+  const idx = data.agents.findIndex(agent => agent.filePath === filePath);
+  const entry = { id: agentId, filePath, installedAt: new Date().toISOString() };
+  if (idx !== -1) data.agents[idx] = entry;
+  else data.agents.push(entry);
+  writeManifest(manifestPath, data);
+}
+
+function recordGeneratedSkill(manifestPath, skillId, dirPath, description, triggers = []) {
+  const data = readManifest(manifestPath);
+  if (!Array.isArray(data.generated)) data.generated = [];
+  data.updatedAt = new Date().toISOString();
+  const idx = data.generated.findIndex(s => s.dirPath === dirPath || s.id === skillId);
+  const entry = {
+    id: skillId,
+    dirPath,
+    description,
+    triggers: Array.isArray(triggers) ? triggers : [],
+    generatedAt: new Date().toISOString()
+  };
+  if (idx !== -1) data.generated[idx] = { ...data.generated[idx], ...entry };
+  else data.generated.push(entry);
+  writeManifest(manifestPath, data);
+}
+
+function removeGeneratedSkill(manifestPath, dirPath) {
+  if (!fs.existsSync(manifestPath)) return;
+  const data = readManifest(manifestPath);
+  if (!Array.isArray(data.generated)) return;
+  data.generated = data.generated.filter(s => s.dirPath !== dirPath);
+  if (!removeManifestArtifactsIfEmpty(manifestPath, data)) writeManifest(manifestPath, data);
+}
+
+function removeSkillFromManifest(manifestPath, dirPath) {
+  if (!fs.existsSync(manifestPath)) return;
+  const data = readManifest(manifestPath);
+  data.skills = data.skills.filter(s => s.dirPath !== dirPath);
+  if (!removeManifestArtifactsIfEmpty(manifestPath, data)) writeManifest(manifestPath, data);
+}
+
+function removeAgentFromManifest(manifestPath, filePath) {
+  if (!fs.existsSync(manifestPath)) return;
+  const data = readManifest(manifestPath);
+  data.agents = data.agents.filter(agent => agent.filePath !== filePath);
+  if (!removeManifestArtifactsIfEmpty(manifestPath, data)) writeManifest(manifestPath, data);
+}
+
+module.exports = {
+  PACKAGE_NAME,
+  HARNESS_AUTHOR,
+  HARNESS_DIR_NAME,
+  getHarnessDir,
+  getManifestPath,
+  readManifest,
+  writeManifest,
+  recordSkillInstall,
+  recordAgentInstall,
+  recordGeneratedSkill,
+  removeGeneratedSkill,
+  removeSkillFromManifest,
+  removeAgentFromManifest,
+};

package/plugins/harness-everything/scripts/lib/path-boundary.js

@@ -0,0 +1,90 @@
+const fs = require('fs');
+const path = require('path');
+
+function boundaryError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function realpath(p) {
+  const resolver = fs.realpathSync.native || fs.realpathSync;
+  return resolver(p);
+}
+
+// Resolve the deepest existing ancestor first, then append missing segments.
+// This preserves the physical location of an existing junction/symlink even
+// when the final file has not been created yet.
+function canonicalizePath(candidate) {
+  const absolute = path.resolve(candidate);
+  const missing = [];
+  let cursor = absolute;
+
+  while (true) {
+    try {
+      fs.lstatSync(cursor);
+      return path.join(realpath(cursor), ...missing);
+    } catch (error) {
+      if (!['ENOENT', 'ENOTDIR'].includes(error.code)) throw error;
+      const parent = path.dirname(cursor);
+      if (parent === cursor) return path.join(cursor, ...missing);
+      missing.unshift(path.basename(cursor));
+      cursor = parent;
+    }
+  }
+}
+
+function isWithin(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === '' || (
+    relative !== '..' &&
+    !relative.startsWith(`..${path.sep}`) &&
+    !path.isAbsolute(relative)
+  );
+}
+
+// A caller may intentionally choose a symlink as the boundary root. Links
+// below that root are rejected so a later write/delete cannot follow an alias
+// whose target was changed after the initial lexical path check.
+function assertNoLinkComponents(root, candidate) {
+  const lexicalRoot = path.resolve(root);
+  const lexicalCandidate = path.resolve(candidate);
+  const relative = path.relative(lexicalRoot, lexicalCandidate);
+  if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return;
+
+  let cursor = lexicalRoot;
+  for (const segment of relative ? relative.split(path.sep) : []) {
+    cursor = path.join(cursor, segment);
+    try {
+      if (fs.lstatSync(cursor).isSymbolicLink()) {
+        throw boundaryError('LINK_COMPONENT_IN_BOUNDARY', `Link component is not allowed below boundary: ${cursor}`);
+      }
+    } catch (error) {
+      if (error.code === 'ENOENT' || error.code === 'ENOTDIR') break;
+      throw error;
+    }
+  }
+}
+
+function assertContainedPath(root, candidate) {
+  if (typeof root !== 'string' || typeof candidate !== 'string') {
+    throw boundaryError('INVALID_BOUNDARY_PATH', 'Boundary root and candidate must be strings');
+  }
+
+  assertNoLinkComponents(root, candidate);
+  const physicalRoot = canonicalizePath(root);
+  const physicalCandidate = canonicalizePath(candidate);
+  if (!isWithin(physicalRoot, physicalCandidate)) {
+    throw boundaryError(
+      'PATH_OUTSIDE_BOUNDARY',
+      `Path escapes boundary: ${candidate} is outside ${root}`
+    );
+  }
+  return { root: physicalRoot, target: physicalCandidate };
+}
+
+module.exports = {
+  assertContainedPath,
+  canonicalizePath,
+  isWithin,
+};