@shomra/agent 0.3.29 → 0.3.30

package/src/inventory/artifacts/classify.mjs

@@ -1,21 +1,30 @@
 import path from 'node:path';
 import { extOf } from './limits.mjs';
 import { SETTINGS_BASENAMES } from './marketplaces.mjs';
+import { isInstructionPath } from '../../detect/signals/instruction-paths.mjs';
+import { PLUGIN_MANIFEST_RE } from './plugins.mjs';
+import { EXTENSION_MANIFEST_RE } from './extensions.mjs';
+
+export const COMMAND_PATH_RE = /(^|\/)commands?\/|(^|\/)\.[\w-]+\/prompts?\/|(^|\/)\.(?:windsurf|devin|clinerules)\/workflows\//;
 
 export function classify(rel, vendor) {
   const lower = rel.toLowerCase().replace(/\\/g, '/');
   const base = path.basename(lower);
   const ext = extOf(lower);
 
+  if (vendor === 'claude-desktop') return EXTENSION_MANIFEST_RE.test(lower) ? 'extension' : null;
+  if (PLUGIN_MANIFEST_RE.test(lower)) return 'plugin';
   if (base === 'skill.md') return 'skill';
   if (SETTINGS_BASENAMES.has(base)) return 'hook';
+  if (vendor === 'copilot' && ext === 'json' && /(^|\/)hooks\/[^/]+\.json$/.test(lower)) return 'hook';
   if (/(^|\/)(sub)?agents?\//.test(lower) && ext === 'md') return 'subagent';
-  if (/(^|\/)(commands?|prompts?|workflows?)\//.test(lower) && (ext === 'md' || ext === 'toml')) {
+  if (COMMAND_PATH_RE.test(lower) && !/(^|\/)\.github\/workflows\//.test(lower) && (ext === 'md' || ext === 'toml')) {
 
     if (vendor === 'copilot' && !/(^|\/)(prompts|chatmodes)\//.test(lower)) return null;
     return 'command';
   }
   if (vendor === 'copilot' && /(^|\/)chatmodes\//.test(lower) && ext === 'md') return 'subagent';
+  if (lower.split('/').length <= 5 && !/(^|\/)(extensions|plugins|marketplaces|node_modules|cache|projects)\//.test(lower) && isInstructionPath(lower)) return 'rules';
   return null;
 }
 

package/src/inventory/artifacts/discover.mjs

@@ -4,8 +4,12 @@ import { clampArtifact } from '../../core/wire-limits.mjs';
 import { classify, declaredName } from './classify.mjs';
 import { readText } from './file-read.mjs';
 import { canonicalHooks } from './hooks.mjs';
-import { MAX_ARTIFACTS, MAX_BUNDLED, MAX_DIRS, MAX_TOTAL_BYTES, TEXT_EXTS, extOf } from './limits.mjs';
+import { bundleHookScripts } from './hook-scripts.mjs';
+import { HOME, MAX_ARTIFACTS, MAX_BUNDLED, MAX_DIRS, MAX_TOTAL_BYTES, TEXT_EXTS, extOf } from './limits.mjs';
+import { extractInstructionImports } from '../../detect/signals/instruction-paths.mjs';
 import { CATALOGUE_DIR_RE, PLUGIN_PATH_RE, installedMarketplaces } from './marketplaces.mjs';
+import { MARKETPLACE_ROOT_RE, MAX_MANIFEST_BYTES, bundlePluginComponents, installedPluginManifests, manifestName, pluginRootOf } from './plugins.mjs';
+import { bundleExtensionSource } from './extensions.mjs';
 import { artifactRoots } from './roots.mjs';
 import { walkRoot } from './walk.mjs';
 
@@ -16,10 +20,13 @@ function relativeToSite(site, absolutePath) {
 }
 
 function artifactName(kind, content, absolutePath) {
+  if (kind === 'plugin') return manifestName(content, path.basename(pluginRootOf(absolutePath)) || path.basename(absolutePath));
+  if (kind === 'extension') return manifestName(content, path.basename(path.dirname(absolutePath)));
   const declared = declaredName(content);
   if (declared) return declared;
   if (kind === 'skill') return path.basename(path.dirname(absolutePath));
   if (kind === 'hook') return `${path.basename(absolutePath)} · hooks`;
+  if (kind === 'rules') return path.basename(absolutePath);
   return path.basename(absolutePath).replace(/\.(md|toml)$/i, '');
 }
 
@@ -30,8 +37,10 @@ function resolveActivation(marketplace, installed) {
 }
 
 function readArtifactContent(kind, absolutePath) {
-  const read = readText(absolutePath);
+  const manifest = kind === 'plugin' || kind === 'extension';
+  const read = readText(absolutePath, manifest ? MAX_MANIFEST_BYTES : undefined);
   if (!read) return null;
+  if (manifest && read.truncated) return { ...read, content: null, oversize: true };
   if (kind !== 'hook') return { ...read, content: read.text };
   const content = canonicalHooks(read.text);
   return content ? { ...read, content } : null;
@@ -77,7 +86,12 @@ function collectFromSite({ site, files, state, project }) {
     }
 
     const marketplace = PLUGIN_PATH_RE.exec(relativePath)?.[2] ?? null;
-    const activation = resolveActivation(marketplace, installed);
+
+    if (kind === 'plugin' && marketplace && !MARKETPLACE_ROOT_RE.test(relativePath)) {
+      availableBy.set(marketplace, (availableBy.get(marketplace) ?? 0) + 1);
+      continue;
+    }
+    const activation = kind === 'plugin' && marketplace ? 'active' : resolveActivation(marketplace, installed);
     if (activation === 'not-installed') {
       availableBy.set(marketplace, (availableBy.get(marketplace) ?? 0) + 1);
       continue;
@@ -85,6 +99,10 @@ function collectFromSite({ site, files, state, project }) {
 
     const read = readArtifactContent(kind, absolutePath);
     if (!read) continue;
+    if (read.oversize) {
+      capped.push({ reason: 'manifest-too-large', path: relativePath });
+      continue;
+    }
     if (read.bytes > budget.bytes) {
       capped.push({ reason: 'byte-budget', path: relativePath });
       continue;
@@ -97,6 +115,76 @@ function collectFromSite({ site, files, state, project }) {
     consumed.add(absolutePath);
     artifacts.push(artifact);
     if (kind === 'skill') skills.push({ artifact, dir: path.dirname(absolutePath), site });
+    if (kind === 'rules') state.rules.push({ artifact, absolutePath });
+    if (kind === 'plugin') state.plugins.push({ artifact, absolutePath, site });
+    if (kind === 'extension') state.extensions.push({ artifact, absolutePath, site });
+    if (kind === 'hook') (state.hooks ??= []).push({ artifact, absolutePath, site });
+  }
+}
+
+function collectInstalledPlugins({ sites, state, project }) {
+  const { artifacts, capped, consumed, budget } = state;
+  for (const site of sites) {
+    if (site.vendor !== 'claude-code' || site.scope !== 'user') continue;
+    for (const { manifest, marketplace } of installedPluginManifests(site.dir)) {
+      if (consumed.has(manifest)) continue;
+      if (artifacts.length >= MAX_ARTIFACTS) { capped.push({ reason: 'artifact-cap', path: manifest }); return; }
+      const relativePath = relativeToSite(site, manifest);
+      const read = readArtifactContent('plugin', manifest);
+      if (!read) continue;
+      if (read.oversize) { capped.push({ reason: 'manifest-too-large', path: relativePath }); continue; }
+      if (read.bytes > budget.bytes) { capped.push({ reason: 'byte-budget', path: relativePath }); continue; }
+      budget.bytes -= Buffer.byteLength(read.content);
+      const artifact = buildArtifact({
+        kind: 'plugin', content: read.content, read, relativePath, site, project, marketplace, activation: 'active', absolutePath: manifest,
+      });
+      consumed.add(manifest);
+      artifacts.push(artifact);
+      state.plugins.push({ artifact, absolutePath: manifest, site });
+    }
+  }
+}
+
+const IMPORT_READABLE_RE = /\.(?:md|mdx|markdown|mdc|rst|txt)$/i;
+const IMPORT_SECRET_RE = /(?:^|[\\/])(?:\.env|\.ssh|\.aws|\.gnupg|\.netrc|\.npmrc)|id_(?:rsa|dsa|ecdsa|ed25519)|secret|credential|password|\.pem$|\.key$/i;
+const MAX_IMPORT_DEPTH = 5;
+
+function resolveImport(ref, fromFile) {
+  if (ref.startsWith('~/')) return path.join(HOME, ref.slice(2));
+  if (path.isAbsolute(ref)) return ref;
+  return path.resolve(path.dirname(fromFile), ref);
+}
+
+function bundleRuleImports(state) {
+  const { capped, budget } = state;
+  for (const { artifact, absolutePath } of state.rules) {
+    const seen = new Set([absolutePath]);
+    const queue = [{ file: absolutePath, text: artifact.content, depth: 0 }];
+    while (queue.length) {
+      const { file, text, depth } = queue.shift();
+      if (depth >= MAX_IMPORT_DEPTH) continue;
+      for (const ref of extractInstructionImports(text)) {
+        if (!IMPORT_READABLE_RE.test(ref) || IMPORT_SECRET_RE.test(ref)) continue;
+        const target = resolveImport(ref, file);
+        if (seen.has(target)) continue;
+        seen.add(target);
+        if (artifact.files.length >= MAX_BUNDLED) {
+          capped.push({ reason: 'bundle-cap', path: artifact.path });
+          queue.length = 0;
+          break;
+        }
+        const read = readText(target);
+        if (!read) continue;
+        if (read.bytes > budget.bytes) {
+          capped.push({ reason: 'byte-budget', path: ref });
+          continue;
+        }
+        budget.bytes -= Buffer.byteLength(read.text);
+        artifact.files.push({ path: ref.replace(/^[~.]*\//, ''), content: read.text, binary: false });
+        queue.push({ file: target, text: read.text, depth: depth + 1 });
+      }
+    }
+    if (artifact.files.length) artifact.metadata.importCount = artifact.files.length;
   }
 }
 
@@ -164,12 +252,34 @@ export function discoverAgentArtifacts(cwd = process.cwd(), roots = null) {
     capped: [],
     consumed: new Set(),
     skills: [],
+    rules: [],
+    plugins: [],
+    extensions: [],
     availableBy: new Map(),
   };
 
   const walked = walkSites(sites, state.budget);
   for (const { site, files } of walked) collectFromSite({ site, files, state, project });
+  collectInstalledPlugins({ sites, state, project });
   bundleSkillFiles({ skills: state.skills, walked, state });
+  bundleRuleImports(state);
+  for (const { artifact, absolutePath, site } of state.hooks ?? []) {
+    bundleHookScripts(artifact, absolutePath, {
+      projectDir: site.scope === 'project' ? path.dirname(site.dir) : cwd,
+      relPath: (abs) => {
+        const rel = relativeToSite(site, abs);
+        return rel.startsWith('..') || path.isAbsolute(rel) ? null : rel;
+      },
+      budget: state.budget,
+      capped: state.capped,
+    });
+  }
+  for (const { artifact, absolutePath, site } of state.extensions) {
+    bundleExtensionSource(artifact, absolutePath, (abs) => relativeToSite(site, abs), state.budget, state.capped);
+  }
+  for (const { artifact, absolutePath, site } of state.plugins) {
+    bundlePluginComponents(artifact, absolutePath, (abs) => relativeToSite(site, abs), state.budget, state.capped);
+  }
 
   if (state.budget.dirs <= 0) state.capped.push({ reason: 'walk-budget', path: null });
 

package/src/inventory/artifacts/extensions.mjs

@@ -0,0 +1,70 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readText } from './file-read.mjs';
+import { HOME } from './limits.mjs';
+
+const MAX_SOURCE_FILES = 20;
+const MAX_SOURCE_BYTES = 200_000;
+const MAX_WALK_DEPTH = 4;
+const CODE_RE = /\.(?:[cm]?js|jsx|ts|tsx|py|pyw)$/i;
+const SKIP_DIRS = new Set(['node_modules', '.venv', 'venv', 'site-packages', '__pycache__', 'dist-packages', '.git']);
+
+export const EXTENSIONS_DIR_NAME = 'Claude Extensions';
+
+export function claudeDesktopDataDir(platform = process.platform) {
+  if (platform === 'darwin') return path.join(HOME, 'Library', 'Application Support', 'Claude');
+  if (platform === 'win32') return path.join(process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming'), 'Claude');
+  return path.join(HOME, '.config', 'Claude');
+}
+
+export const EXTENSION_MANIFEST_RE = /^claude extensions\/[^/]+\/manifest\.json$/i;
+
+function inside(root, target) {
+  const rel = path.relative(root, target);
+  return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+function realInside(root, target) {
+  try { return inside(fs.realpathSync(root), fs.realpathSync(target)); } catch { return false; }
+}
+
+function sourceFiles(dir, depth = 0, out = []) {
+  if (depth > MAX_WALK_DEPTH || out.length >= MAX_SOURCE_FILES * 3) return out;
+  let entries = [];
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { return out; }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) { if (!SKIP_DIRS.has(e.name)) sourceFiles(full, depth + 1, out); }
+    else if (e.isFile() && CODE_RE.test(e.name)) out.push(full);
+  }
+  return out;
+}
+
+export function bundleExtensionSource(artifact, absManifest, toRel, budget, capped) {
+  const root = path.dirname(absManifest);
+  let doc = null;
+  try { doc = JSON.parse(artifact.content); } catch { return; }
+  const entry = typeof doc?.server?.entry_point === 'string' ? doc.server.entry_point.replace(/^\$\{__dirname\}[\\/]?/, '') : null;
+  const entryAbs = entry ? path.resolve(root, entry) : null;
+  const candidates = [
+    ...(entryAbs && inside(root, entryAbs) ? [entryAbs] : []),
+    ...sourceFiles(root).filter((f) => f !== entryAbs),
+  ];
+  for (const abs of candidates) {
+    if (artifact.files.length >= MAX_SOURCE_FILES) { capped.push({ reason: 'bundle-cap', path: artifact.path }); break; }
+    if (!realInside(root, abs)) continue;
+    const read = readText(abs, MAX_SOURCE_BYTES);
+    if (!read || read.truncated) continue;
+    if (Buffer.byteLength(read.text) > budget.bytes) { capped.push({ reason: 'byte-budget', path: toRel(abs) }); continue; }
+    budget.bytes -= Buffer.byteLength(read.text);
+    artifact.files.push({ path: toRel(abs), content: read.text, binary: false });
+  }
+  artifact.metadata.bundledCount = artifact.files.length;
+
+  const id = path.basename(root);
+  try {
+    const dataDir = path.dirname(path.dirname(root));
+    const settings = JSON.parse(fs.readFileSync(path.join(dataDir, 'Claude Extensions Settings', `${id}.json`), 'utf8'));
+    if (settings?.isEnabled === false) artifact.metadata.activation = 'disabled';
+  } catch {  }
+}

package/src/inventory/artifacts/hook-scripts.mjs

@@ -0,0 +1,128 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+import { loadConfig } from '../../core/config.mjs';
+import { redactLocally } from '../../detect/local-redact.mjs';
+import { readText } from './file-read.mjs';
+import { HOME, MAX_BUNDLED } from './limits.mjs';
+
+export const HOOK_SCRIPT_MODES = ['full', 'hash', 'off'];
+
+const SCRIPT_EXT = /\.(?:sh|bash|zsh|ps1|psm1|bat|cmd|py|js|mjs|cjs|ts|rb|pl|php|lua)$/i;
+const SECRET_PATH = /(?:^|[\\/])(?:\.env|\.ssh|\.aws|\.gnupg|\.netrc|\.npmrc|\.kube|\.docker)(?:[\\/]|$)|id_(?:rsa|dsa|ecdsa|ed25519)|secret|credential|password|\.pem$|\.key$/i;
+const COMMAND_KEYS = new Set(['command', 'bash', 'sh', 'powershell', 'pwsh', 'windows', 'linux', 'osx']);
+const EXTS = 'sh|bash|zsh|ps1|psm1|bat|cmd|py|js|mjs|cjs|ts|rb|pl|php|lua';
+const REF_RE = new RegExp(`(?:^|["'\\s=;&|(\`])((?:\\$\\{?[A-Za-z_]\\w*\\}?|%[A-Za-z_]\\w*%|~|[A-Za-z]:)?[\\\\/]?(?:[\\w.@-]+[\\\\/])*[\\w.@-]+\\.(?:${EXTS}))(?=["'\\s;|&)\`]|$)`, 'g');
+const QUOTED_REF_RE = new RegExp(`(["'])((?:\\$\\{?[A-Za-z_]\\w*\\}?|%[A-Za-z_]\\w*%|~|[A-Za-z]:)?[^"'\\n]*[\\\\/][^"'\\n]*?\\.(?:${EXTS}))\\1`, 'g');
+const SHOMRA_GUARD_RE = /(?:^|[\\/])(?:shomra(?:-agent)?\.m?js|@shomra[\\/]agent[\\/].*)$/i;
+const MAX_REFS = 40;
+
+export function hookScriptMode(env = process.env, cfg = null) {
+  const raw = String(env.SHOMRA_HOOK_SCRIPTS ?? (cfg ?? safeConfig()).hookScripts ?? 'full').trim().toLowerCase();
+  return HOOK_SCRIPT_MODES.includes(raw) ? raw : 'full';
+}
+
+function safeConfig() {
+  try {
+    return loadConfig();
+  } catch {
+    return {};
+  }
+}
+
+export function hookCommands(canonical) {
+  let doc;
+  try {
+    doc = JSON.parse(canonical);
+  } catch {
+    return [];
+  }
+  const out = [];
+  const walk = (n, depth) => {
+    if (!n || depth > 12 || out.length > 200) return;
+    if (Array.isArray(n)) return n.forEach((v) => walk(v, depth + 1));
+    if (typeof n !== 'object') return;
+    for (const [k, v] of Object.entries(n)) {
+      if (COMMAND_KEYS.has(k) && typeof v === 'string') out.push(v);
+      else walk(v, depth + 1);
+    }
+  };
+  walk(doc?.hooks, 0);
+  return out;
+}
+
+export function scriptRefs(command) {
+  const out = new Set();
+  const cmd = String(command).replace(/(["'])(\$\{?[A-Za-z_]\w*\}?|%[A-Za-z_]\w*%)\1(?=[\\/])/g, '$2');
+  for (const m of cmd.matchAll(QUOTED_REF_RE)) if (out.size < MAX_REFS) out.add(m[2].trim());
+  const unquoted = cmd.replace(QUOTED_REF_RE, ' ');
+  for (const m of unquoted.matchAll(REF_RE)) {
+    if (out.size >= MAX_REFS) break;
+    out.add(m[1].trim());
+  }
+  return [...out];
+}
+
+export function pluginRootOf(hookFile) {
+  const norm = hookFile.replace(/\\/g, '/');
+  if (/\/hooks\/hooks\.json$/i.test(norm)) return path.dirname(path.dirname(hookFile));
+  if (/\/\.claude-plugin\/plugin\.json$/i.test(norm)) return path.dirname(path.dirname(hookFile));
+  return path.dirname(hookFile);
+}
+
+export function resolveRef(ref, { hookFile, projectDir }) {
+  const m = /^(\$\{?([A-Za-z_]\w*)\}?|%([A-Za-z_]\w*)%|~)([\\/].*)$/.exec(ref);
+  if (m) {
+    const name = (m[2] ?? m[3] ?? '').toUpperCase();
+    const rest = m[4].replace(/^[\\/]/, '');
+    const base =
+      m[1] === '~' || name === 'HOME' || name === 'USERPROFILE' ? HOME
+        : name === 'CLAUDE_PLUGIN_ROOT' || name === 'EXTENSIONPATH' ? pluginRootOf(hookFile)
+          : /^(?:CLAUDE|GEMINI|CURSOR|QWEN)_PROJECT_DIR$|^PWD$/.test(name) ? projectDir
+            : null;
+    return base ? [path.join(base, rest)] : [];
+  }
+  if (path.isAbsolute(ref) || /^[A-Za-z]:[\\/]/.test(ref)) return [ref];
+  return [...new Set([path.resolve(projectDir, ref), path.resolve(path.dirname(hookFile), ref)])];
+}
+
+const sha256 = (s) => crypto.createHash('sha256').update(s).digest('hex');
+
+export function bundleHookScripts(artifact, hookFile, { projectDir, relPath, budget, capped, mode = hookScriptMode() }) {
+  if (mode === 'off') return;
+  const refs = [...new Set(hookCommands(artifact.content).flatMap(scriptRefs))].filter((r) => SCRIPT_EXT.test(r));
+  const scripts = [];
+  for (const ref of refs) {
+    if (SECRET_PATH.test(ref)) continue;
+    if (SHOMRA_GUARD_RE.test(ref)) {
+      scripts.push({ ref, state: 'shomra-guard' });
+      continue;
+    }
+    if (artifact.files.length >= MAX_BUNDLED) {
+      capped.push({ reason: 'bundle-cap', path: artifact.path });
+      break;
+    }
+    const target = resolveRef(ref, { hookFile, projectDir }).find((p) => readText(p) != null);
+    if (!target || SECRET_PATH.test(target)) {
+      scripts.push({ ref, state: 'missing' });
+      continue;
+    }
+    const read = readText(target);
+    const digest = sha256(read.text);
+    const wirePath = relPath(target) ?? ref.replace(/^(?:\$\{?\w+\}?|%\w+%|~)?[\\/]*/, '').replace(/\\/g, '/');
+    if (mode === 'hash') {
+      artifact.files.push({ path: wirePath, content: null, binary: false, sha256: digest, withheld: true });
+      scripts.push({ ref, path: wirePath, sha256: digest, bytes: read.bytes, state: 'withheld' });
+      continue;
+    }
+    if (read.bytes > budget.bytes) {
+      capped.push({ reason: 'byte-budget', path: wirePath });
+      scripts.push({ ref, path: wirePath, sha256: digest, bytes: read.bytes, state: 'over-budget' });
+      continue;
+    }
+    const masked = redactLocally(read.text, { categories: ['secret'] });
+    budget.bytes -= Buffer.byteLength(masked.text);
+    artifact.files.push({ path: wirePath, content: masked.text, binary: false, sha256: digest, ...(read.truncated ? { truncated: true } : {}) });
+    scripts.push({ ref, path: wirePath, sha256: digest, bytes: read.bytes, state: 'sent', maskedSecrets: masked.masked.length });
+  }
+  if (refs.length) artifact.metadata.hookScripts = { mode, scripts: scripts.slice(0, MAX_BUNDLED) };
+}

package/src/inventory/artifacts/limits.mjs

@@ -3,7 +3,7 @@ import path from 'node:path';
 
 export const HOME = os.homedir();
 
-export const ARTIFACT_KINDS = ['skill', 'command', 'subagent', 'hook'];
+export const ARTIFACT_KINDS = ['skill', 'command', 'subagent', 'hook', 'rules', 'plugin', 'extension'];
 
 export const MAX_DEPTH = 6;
 

package/src/inventory/artifacts/plugins.mjs

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readJsonAt, readText, stripJsonComments } from './file-read.mjs';
+import { canonicalHooks } from './hooks.mjs';
+import { HOME } from './limits.mjs';
+
+export { PLUGIN_MANIFEST_RE } from '../../detect/signals/manifests.mjs';
+export const MARKETPLACE_ROOT_RE = /(^|\/)plugins\/marketplaces\/[^/]+\/\.claude-plugin\/marketplace\.json$/i;
+export const MAX_MANIFEST_BYTES = 200_000;
+
+const MAX_COMPONENT_FILES = 12;
+const MAX_BIN_NAMES = 40;
+
+export function pluginRootOf(absManifest) {
+  const dir = path.dirname(absManifest);
+  const base = path.basename(dir).toLowerCase();
+  if (/^\.(claude|codex|cursor|copilot|github)-plugin$|^\.plugin$/.test(base)) return path.dirname(dir);
+  if (base === 'plugin' && path.basename(path.dirname(dir)).toLowerCase() === '.github') return path.dirname(path.dirname(dir));
+  if (base === 'plugins' && path.basename(path.dirname(dir)).toLowerCase() === '.agents') return path.dirname(path.dirname(dir));
+  return dir;
+}
+
+export function manifestName(text, fallback) {
+  try {
+    const doc = JSON.parse(stripJsonComments(text));
+    const n = doc?.name ?? doc?.id;
+    if (typeof n === 'string' && n.trim()) return n.trim().slice(0, 200);
+  } catch {  }
+  return fallback;
+}
+
+function inside(root, target) {
+  const rel = path.relative(root, target);
+  return !!rel && !rel.startsWith('..') && !path.isAbsolute(rel);
+}
+
+function insideReal(root, target) {
+  try {
+    return inside(fs.realpathSync(root), fs.realpathSync(target));
+  } catch {
+    return false;
+  }
+}
+
+function declaredComponentPaths(text) {
+  let doc;
+  try { doc = JSON.parse(stripJsonComments(text)); } catch { return []; }
+  const out = [];
+  for (const key of ['hooks', 'mcpServers', 'lspServers', 'monitors']) {
+    const v = doc?.[key];
+    for (const p of typeof v === 'string' ? [v] : Array.isArray(v) ? v : []) {
+      if (typeof p === 'string' && p.trim()) out.push(p.trim().replace(/^\$\{?(?:CLAUDE_PLUGIN_ROOT|PLUGIN_ROOT)\}?\/?/, './'));
+    }
+  }
+  return out;
+}
+
+export function bundlePluginComponents(artifact, absManifest, toRel, budget, capped) {
+  const root = pluginRootOf(absManifest);
+  const wanted = new Set(['hooks/hooks.json', '.mcp.json', 'mcp.json', '.lsp.json', 'monitors/monitors.json']);
+  for (const p of declaredComponentPaths(artifact.content)) wanted.add(p.replace(/^\.\//, ''));
+
+  for (const rel of wanted) {
+    if (artifact.files.length >= MAX_COMPONENT_FILES) { capped.push({ reason: 'bundle-cap', path: artifact.path }); break; }
+    const abs = path.resolve(root, rel);
+    if (!inside(root, abs) || !/\.json$/i.test(abs) || !insideReal(root, abs)) continue;
+    const read = readText(abs, MAX_MANIFEST_BYTES);
+    if (!read || read.truncated) continue;
+    const content = /hooks[^/\\]*\.json$/i.test(abs) ? canonicalHooks(read.text) : read.text;
+    if (!content) continue;
+    if (Buffer.byteLength(content) > budget.bytes) { capped.push({ reason: 'byte-budget', path: toRel(abs) }); continue; }
+    budget.bytes -= Buffer.byteLength(content);
+    artifact.files.push({ path: toRel(abs), content, binary: false });
+  }
+
+  let bin = [];
+  try { bin = fs.readdirSync(path.join(root, 'bin'), { withFileTypes: true }).filter((e) => e.isFile()).map((e) => e.name); } catch {  }
+  for (const name of bin.slice(0, MAX_BIN_NAMES)) artifact.files.push({ path: toRel(path.join(root, 'bin', name)), content: null, binary: true });
+
+  artifact.metadata.bundledCount = artifact.files.length;
+}
+
+export function installedPluginManifests(claudeDir) {
+  const doc = readJsonAt(path.join(claudeDir, 'plugins', 'installed_plugins.json'));
+  if (!doc || typeof doc !== 'object') return [];
+  const out = [];
+  const seen = new Set();
+  for (const [key, value] of Object.entries(doc.plugins ?? {})) {
+    const records = Array.isArray(value) ? value : [value];
+    for (const r of records) {
+      const installPath = typeof r?.installPath === 'string' ? r.installPath : null;
+      if (!installPath) continue;
+      const abs = path.resolve(installPath);
+      if (!inside(HOME, abs)) continue;
+      for (const candidate of [path.join(abs, '.claude-plugin', 'plugin.json'), path.join(abs, 'plugin.json')]) {
+        if (seen.has(candidate) || !fs.existsSync(candidate) || !insideReal(HOME, candidate)) continue;
+        seen.add(candidate);
+        const at = key.indexOf('@');
+        out.push({ manifest: candidate, marketplace: at > -1 ? key.slice(at + 1) : null });
+        break;
+      }
+    }
+  }
+  return out;
+}

package/src/inventory/artifacts/roots.mjs

@@ -1,8 +1,45 @@
 import path from 'node:path';
 import { HOME } from './limits.mjs';
+import { EXTENSIONS_DIR_NAME, claudeDesktopDataDir } from './extensions.mjs';
+
+const PLAT = process.platform;
+const APPDATA = process.env.APPDATA || path.join(HOME, 'AppData', 'Roaming');
+const XDG = PLAT === 'win32' ? APPDATA : path.join(HOME, '.config');
+const CLAUDE_MANAGED = PLAT === 'win32' ? 'C:\\Program Files\\ClaudeCode' : PLAT === 'darwin' ? '/Library/Application Support/ClaudeCode' : '/etc/claude-code';
+
+export function rulesRoots() {
+  return [
+    { vendor: 'claude-code', scope: 'user', dir: CLAUDE_MANAGED, managed: true },
+    { vendor: 'qwen-code', scope: 'user', dir: path.join(HOME, '.qwen') },
+    { vendor: 'roo', scope: 'user', dir: path.join(HOME, '.roo') },
+    { vendor: 'kiro', scope: 'user', dir: path.join(HOME, '.kiro') },
+    { vendor: 'augment', scope: 'user', dir: path.join(HOME, '.augment') },
+    { vendor: 'junie', scope: 'user', dir: path.join(HOME, '.junie') },
+    { vendor: 'cline', scope: 'user', dir: path.join(HOME, 'Documents', 'Cline') },
+    { vendor: 'zed', scope: 'user', dir: path.join(XDG, PLAT === 'win32' ? 'Zed' : 'zed') },
+    { vendor: 'goose', scope: 'user', dir: PLAT === 'win32' ? path.join(APPDATA, 'Block', 'goose', 'config') : path.join(HOME, '.config', 'goose') },
+    { vendor: 'amp', scope: 'user', dir: path.join(HOME, '.config', 'amp') },
+    { vendor: 'opencode', scope: 'user', dir: path.join(HOME, '.config', 'opencode') },
+    { vendor: 'agents-md', scope: 'user', dir: path.join(HOME, '.agents') },
+    { vendor: 'continue', scope: 'user', dir: path.join(HOME, '.continue') },
+  ];
+}
+
+export function projectVendorRoots(cwd = process.cwd()) {
+  return [
+    { vendor: 'roo', scope: 'project', dir: path.join(cwd, '.roo') },
+    { vendor: 'qwen-code', scope: 'project', dir: path.join(cwd, '.qwen') },
+    { vendor: 'kiro', scope: 'project', dir: path.join(cwd, '.kiro') },
+    { vendor: 'cline', scope: 'project', dir: path.join(cwd, '.clinerules') },
+    { vendor: 'continue', scope: 'project', dir: path.join(cwd, '.continue') },
+    { vendor: 'agents-md', scope: 'project', dir: path.join(cwd, '.agents') },
+  ];
+}
 
 export function artifactRoots(cwd = process.cwd()) {
   return [
+    ...rulesRoots(),
+    ...projectVendorRoots(cwd),
     { vendor: 'claude-code', scope: 'user', dir: path.join(HOME, '.claude') },
     { vendor: 'claude-code', scope: 'project', dir: path.join(cwd, '.claude') },
     { vendor: 'cursor', scope: 'user', dir: path.join(HOME, '.cursor') },
@@ -11,10 +48,13 @@ export function artifactRoots(cwd = process.cwd()) {
     { vendor: 'codex', scope: 'project', dir: path.join(cwd, '.codex') },
     { vendor: 'gemini', scope: 'user', dir: path.join(HOME, '.gemini') },
     { vendor: 'gemini', scope: 'project', dir: path.join(cwd, '.gemini') },
+    { vendor: 'windsurf', scope: 'user', dir: path.join(HOME, '.codeium', 'windsurf') },
     { vendor: 'windsurf', scope: 'project', dir: path.join(cwd, '.windsurf') },
     { vendor: 'opencode', scope: 'user', dir: path.join(HOME, '.opencode') },
     { vendor: 'opencode', scope: 'project', dir: path.join(cwd, '.opencode') },
 
+    { vendor: 'copilot', scope: 'user', dir: path.join(HOME, '.copilot') },
     { vendor: 'copilot', scope: 'project', dir: path.join(cwd, '.github') },
+    { vendor: 'claude-desktop', scope: 'user', dir: path.join(claudeDesktopDataDir(), EXTENSIONS_DIR_NAME) },
   ];
 }