@omnidev-ai/core 0.11.0 → 0.12.0

package/dist/index.js

@@ -959,8 +959,18 @@ async function loadCapabilityConfig(capabilityPath) {
   return config;
 }
 async function importCapabilityExports(capabilityPath) {
-  const indexPath = join7(capabilityPath, "index.ts");
-  if (!existsSync8(indexPath)) {
+  const builtIndexPath = join7(capabilityPath, "dist", "index.js");
+  const jsIndexPath = join7(capabilityPath, "index.js");
+  const tsIndexPath = join7(capabilityPath, "index.ts");
+  let indexPath = null;
+  if (existsSync8(builtIndexPath)) {
+    indexPath = builtIndexPath;
+  } else if (existsSync8(jsIndexPath)) {
+    indexPath = jsIndexPath;
+  } else if (existsSync8(tsIndexPath)) {
+    indexPath = tsIndexPath;
+  }
+  if (!indexPath) {
     return {};
   }
   try {
@@ -972,6 +982,11 @@ async function importCapabilityExports(capabilityPath) {
     if (errorMessage.includes("Cannot find module")) {
       const match = errorMessage.match(/Cannot find module '([^']+)'/);
       const missingModule = match ? match[1] : "unknown";
+      if (indexPath === tsIndexPath && missingModule?.endsWith(".js")) {
+        throw new Error(`Capability at ${capabilityPath} has TypeScript files but no built output.
+Add a "build" script to package.json (e.g., "build": "tsc") and run it to compile TypeScript.
+The build output should be in dist/index.js.`);
+      }
       throw new Error(`Missing dependency '${missingModule}' for capability at ${capabilityPath}.
 If this is a project-specific capability, install dependencies or remove it from .omni/capabilities/`);
     }
@@ -1634,6 +1649,7 @@ function getActiveProviders(config) {
 }
 
 // src/capability/sources.ts
+import { createHash } from "node:crypto";
 var OMNI_LOCAL = ".omni";
 var SKILL_DIRS = ["skills", "skill"];
 var AGENT_DIRS = ["agents", "agent", "subagents", "subagent"];
@@ -1751,12 +1767,18 @@ function stringifyLockFile(lockFile) {
     lines.push(`[capabilities.${id}]`);
     lines.push(`source = "${entry.source}"`);
     lines.push(`version = "${entry.version}"`);
+    if (entry.version_source) {
+      lines.push(`version_source = "${entry.version_source}"`);
+    }
     if (entry.commit) {
       lines.push(`commit = "${entry.commit}"`);
     }
     if (entry.ref) {
       lines.push(`ref = "${entry.ref}"`);
     }
+    if (entry.content_hash) {
+      lines.push(`content_hash = "${entry.content_hash}"`);
+    }
     lines.push(`updated_at = "${entry.updated_at}"`);
     lines.push("");
   }
@@ -1786,6 +1808,83 @@ async function getRepoCommit(repoPath) {
 function shortCommit(commit) {
   return commit.substring(0, 7);
 }
+function shortContentHash(hash) {
+  return hash.substring(0, 12);
+}
+var CONTENT_HASH_EXCLUDES = [
+  ".git",
+  "node_modules",
+  ".omni",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  "dist",
+  "build",
+  ".DS_Store",
+  "Thumbs.db"
+];
+async function computeContentHash(dirPath, excludePatterns = CONTENT_HASH_EXCLUDES) {
+  const hash = createHash("sha256");
+  const files = [];
+  async function collectFiles(currentPath, relativeTo) {
+    const entries = await readdir(currentPath, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const fullPath = join8(currentPath, entry.name);
+      const relativePath = fullPath.slice(relativeTo.length + 1);
+      if (excludePatterns.some((pattern) => entry.name === pattern || relativePath.startsWith(`${pattern}/`))) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await collectFiles(fullPath, relativeTo);
+      } else if (entry.isFile()) {
+        const content = await readFile9(fullPath);
+        files.push({ relativePath, content });
+      }
+    }
+  }
+  await collectFiles(dirPath, dirPath);
+  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  for (const file of files) {
+    hash.update(file.relativePath);
+    hash.update(file.content);
+  }
+  return hash.digest("hex");
+}
+async function detectDisplayVersion(dirPath, fallback, fallbackSource) {
+  const capTomlPath = join8(dirPath, "capability.toml");
+  if (existsSync11(capTomlPath)) {
+    try {
+      const content = await readFile9(capTomlPath, "utf-8");
+      const parsed = parseToml2(content);
+      const capability = parsed["capability"];
+      if (capability?.["version"] && typeof capability["version"] === "string") {
+        return { version: capability["version"], source: "capability.toml" };
+      }
+    } catch {}
+  }
+  const pluginJsonPath = join8(dirPath, ".claude-plugin", "plugin.json");
+  if (existsSync11(pluginJsonPath)) {
+    try {
+      const content = await readFile9(pluginJsonPath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed.version && typeof parsed.version === "string") {
+        return { version: parsed.version, source: "plugin.json" };
+      }
+    } catch {}
+  }
+  const pkgJsonPath = join8(dirPath, "package.json");
+  if (existsSync11(pkgJsonPath)) {
+    try {
+      const content = await readFile9(pkgJsonPath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed.version && typeof parsed.version === "string") {
+        return { version: parsed.version, source: "package.json" };
+      }
+    } catch {}
+  }
+  return { version: fallback, source: fallbackSource };
+}
 async function cloneRepo(gitUrl, targetPath, ref) {
   await mkdir(join8(targetPath, ".."), { recursive: true });
   const args = ["clone", "--depth", "1"];
@@ -2054,15 +2153,9 @@ async function fetchGitCapabilitySource(id, config, options) {
   if (config.path) {
     const tempPath = join8(OMNI_LOCAL, "_temp", `${id}-repo`);
     if (existsSync11(join8(tempPath, ".git"))) {
-      if (!options?.silent) {
-        console.log(`  Checking ${id}...`);
-      }
       updated = await fetchRepo(tempPath, config.ref);
       commit = await getRepoCommit(tempPath);
     } else {
-      if (!options?.silent) {
-        console.log(`  Cloning ${id} from ${config.source}...`);
-      }
       await mkdir(join8(tempPath, ".."), { recursive: true });
       await cloneRepo(gitUrl, tempPath, config.ref);
       commit = await getRepoCommit(tempPath);
@@ -2077,6 +2170,7 @@ async function fetchGitCapabilitySource(id, config, options) {
     }
     await mkdir(join8(targetPath, ".."), { recursive: true });
     await cp(sourcePath, targetPath, { recursive: true });
+    await rm(tempPath, { recursive: true });
     repoPath = targetPath;
   } else {
     if (existsSync11(join8(targetPath, ".git"))) {
@@ -2116,20 +2210,12 @@ async function fetchGitCapabilitySource(id, config, options) {
       }
     }
   }
-  let version = shortCommit(commit);
-  const pkgJsonPath = join8(repoPath, "package.json");
-  if (existsSync11(pkgJsonPath)) {
-    try {
-      const pkgJson = JSON.parse(await readFile9(pkgJsonPath, "utf-8"));
-      if (pkgJson.version) {
-        version = pkgJson.version;
-      }
-    } catch {}
-  }
+  const versionResult = await detectDisplayVersion(repoPath, shortCommit(commit), "commit");
   return {
     id,
     path: targetPath,
-    version,
+    version: versionResult.version,
+    versionSource: versionResult.source,
     commit,
     updated,
     wrapped: needsWrap
@@ -2145,8 +2231,14 @@ async function fetchFileCapabilitySource(id, config, options) {
   if (!sourceStats.isDirectory()) {
     throw new Error(`File source must be a directory: ${sourcePath}`);
   }
-  if (!existsSync11(join8(sourcePath, "capability.toml"))) {
-    throw new Error(`No capability.toml found in: ${sourcePath}`);
+  const contentHash = await computeContentHash(sourcePath);
+  const hasCapToml = existsSync11(join8(sourcePath, "capability.toml"));
+  let needsWrap = false;
+  if (!hasCapToml) {
+    needsWrap = await shouldWrapDirectory(sourcePath);
+    if (!needsWrap) {
+      throw new Error(`No capability.toml found in: ${sourcePath} (and no wrappable content detected)`);
+    }
   }
   if (!options?.silent) {
     console.log(`  Copying ${id} from ${sourcePath}...`);
@@ -2156,26 +2248,86 @@ async function fetchFileCapabilitySource(id, config, options) {
   }
   await mkdir(join8(targetPath, ".."), { recursive: true });
   await cp(sourcePath, targetPath, { recursive: true });
-  let version = "local";
-  const capTomlPath = join8(targetPath, "capability.toml");
-  if (existsSync11(capTomlPath)) {
-    try {
-      const content = await readFile9(capTomlPath, "utf-8");
-      const parsed = parseToml2(content);
-      const capability = parsed["capability"];
-      if (capability?.["version"] && typeof capability["version"] === "string") {
-        version = capability["version"];
+  if (needsWrap) {
+    await normalizeFolderNames(targetPath);
+    const content = await discoverContent(targetPath);
+    await generateFileSourceCapabilityToml(id, config.source, shortContentHash(contentHash), content, targetPath);
+    if (!options?.silent) {
+      const parts = [];
+      if (content.skills.length > 0)
+        parts.push(`${content.skills.length} skills`);
+      if (content.agents.length > 0)
+        parts.push(`${content.agents.length} agents`);
+      if (content.commands.length > 0)
+        parts.push(`${content.commands.length} commands`);
+      if (parts.length > 0) {
+        console.log(`    Wrapped: ${parts.join(", ")}`);
       }
-    } catch {}
+    }
   }
+  const versionResult = await detectDisplayVersion(targetPath, shortContentHash(contentHash), "content_hash");
   return {
     id,
     path: targetPath,
-    version,
+    version: versionResult.version,
+    versionSource: versionResult.source,
+    contentHash,
     updated: true,
-    wrapped: false
+    wrapped: needsWrap
   };
 }
+async function generateFileSourceCapabilityToml(id, source, hashVersion, content, targetPath) {
+  const pluginMeta = await parsePluginJson(targetPath);
+  const readmeDesc = await readReadmeDescription(targetPath);
+  let description;
+  if (pluginMeta?.description) {
+    description = pluginMeta.description;
+  } else if (readmeDesc) {
+    description = readmeDesc;
+  } else {
+    const parts = [];
+    if (content.skills.length > 0) {
+      parts.push(`${content.skills.length} skill${content.skills.length > 1 ? "s" : ""}`);
+    }
+    if (content.agents.length > 0) {
+      parts.push(`${content.agents.length} agent${content.agents.length > 1 ? "s" : ""}`);
+    }
+    if (content.commands.length > 0) {
+      parts.push(`${content.commands.length} command${content.commands.length > 1 ? "s" : ""}`);
+    }
+    description = parts.length > 0 ? `${parts.join(", ")}` : `Wrapped from ${source}`;
+  }
+  const name = pluginMeta?.name || `${id} (wrapped)`;
+  const version = pluginMeta?.version || hashVersion;
+  let tomlContent = `# Auto-generated by OmniDev - DO NOT EDIT
+# This capability was wrapped from a local directory
+
+[capability]
+id = "${id}"
+name = "${name}"
+version = "${version}"
+description = "${description}"
+`;
+  if (pluginMeta?.author?.name || pluginMeta?.author?.email) {
+    tomlContent += `
+[capability.author]
+`;
+    if (pluginMeta.author.name) {
+      tomlContent += `name = "${pluginMeta.author.name}"
+`;
+    }
+    if (pluginMeta.author.email) {
+      tomlContent += `email = "${pluginMeta.author.email}"
+`;
+    }
+  }
+  tomlContent += `
+[capability.metadata]
+wrapped = true
+source = "${source}"
+`;
+  await writeFile3(join8(targetPath, "capability.toml"), tomlContent, "utf-8");
+}
 async function fetchCapabilitySource(id, sourceConfig, options) {
   const config = parseSourceConfig(sourceConfig);
   if (isFileSourceConfig(sourceConfig) || isFileSource(config.source)) {
@@ -2298,13 +2450,14 @@ async function generateMcpCapabilities(config) {
 }
 async function fetchAllCapabilitySources(config, options) {
   await generateMcpCapabilities(config);
+  const tempDir = join8(OMNI_LOCAL, "_temp");
+  if (existsSync11(tempDir)) {
+    await rm(tempDir, { recursive: true });
+  }
   const sources = config.capabilities?.sources;
   if (!sources || Object.keys(sources).length === 0) {
     return [];
   }
-  if (!options?.silent) {
-    console.log("Fetching capability sources...");
-  }
   const results = [];
   const lockFile = await loadLockFile();
   let lockUpdated = false;
@@ -2315,11 +2468,15 @@ async function fetchAllCapabilitySources(config, options) {
       const lockEntry = {
         source: typeof source === "string" ? source : source.source,
         version: result.version,
+        version_source: result.versionSource,
         updated_at: new Date().toISOString()
       };
       if (result.commit) {
         lockEntry.commit = result.commit;
       }
+      if (result.contentHash) {
+        lockEntry.content_hash = result.contentHash;
+      }
       if (!isFileSourceConfig(source)) {
         const gitConfig = parseSourceConfig(source);
         if (gitConfig.ref) {
@@ -2327,14 +2484,10 @@ async function fetchAllCapabilitySources(config, options) {
         }
       }
       const existing = lockFile.capabilities[id];
-      const hasChanged = !existing || existing.commit !== result.commit;
+      const hasChanged = !existing || result.commit && existing.commit !== result.commit || result.contentHash && existing.content_hash !== result.contentHash;
       if (hasChanged) {
         lockFile.capabilities[id] = lockEntry;
         lockUpdated = true;
-        if (!options?.silent && result.updated) {
-          const oldVersion = existing?.version || "new";
-          console.log(`  ${result.wrapped ? "+" : "~"} ${id}: ${oldVersion} -> ${result.version}`);
-        }
       }
     } catch (error) {
       console.error(`  Failed to fetch ${id}: ${error}`);
@@ -2343,14 +2496,6 @@ async function fetchAllCapabilitySources(config, options) {
   if (lockUpdated) {
     await saveLockFile(lockFile);
   }
-  if (!options?.silent && results.length > 0) {
-    const updated = results.filter((r) => r.updated).length;
-    if (updated > 0) {
-      console.log(`  Updated ${updated} capability source(s)`);
-    } else {
-      console.log(`  All ${results.length} source(s) up to date`);
-    }
-  }
   return results;
 }
 async function checkForUpdates(config) {
@@ -2728,7 +2873,7 @@ function buildMcpServerConfig(mcp) {
   }
   return config2;
 }
-async function syncMcpJson(capabilities2, previousManifest, options = {}) {
+async function syncMcpJson(capabilities2, previousManifest) {
   const mcpJson = await readMcpJson();
   const previouslyManagedMcps = new Set;
   for (const resources of Object.values(previousManifest.capabilities)) {
@@ -2739,17 +2884,12 @@ async function syncMcpJson(capabilities2, previousManifest, options = {}) {
   for (const serverName of previouslyManagedMcps) {
     delete mcpJson.mcpServers[serverName];
   }
-  let addedCount = 0;
   for (const cap of capabilities2) {
     if (cap.config.mcp) {
       mcpJson.mcpServers[cap.id] = buildMcpServerConfig(cap.config.mcp);
-      addedCount++;
     }
   }
   await writeMcpJson(mcpJson);
-  if (!options.silent) {
-    console.log(`  - .mcp.json (${addedCount} MCP server(s))`);
-  }
 }
 // src/state/manifest.ts
 import { existsSync as existsSync15, mkdirSync as mkdirSync2, rmSync } from "node:fs";
@@ -2858,14 +2998,104 @@ async function isProviderEnabled(providerId) {
   const current = await readEnabledProviders();
   return current.includes(providerId);
 }
+// src/state/security-allows.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync4 } from "node:fs";
+import { readFile as readFile15, writeFile as writeFile9 } from "node:fs/promises";
+var OMNI_DIR = ".omni";
+var SECURITY_PATH = `${OMNI_DIR}/security.json`;
+var DEFAULT_STATE = {
+  version: 1,
+  modifiedAt: new Date().toISOString(),
+  allows: {}
+};
+async function readSecurityAllows() {
+  if (!existsSync17(SECURITY_PATH)) {
+    return { ...DEFAULT_STATE };
+  }
+  try {
+    const content = await readFile15(SECURITY_PATH, "utf-8");
+    const state = JSON.parse(content);
+    return state;
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+async function writeSecurityAllows(state) {
+  mkdirSync4(OMNI_DIR, { recursive: true });
+  state.modifiedAt = new Date().toISOString();
+  await writeFile9(SECURITY_PATH, `${JSON.stringify(state, null, 2)}
+`, "utf-8");
+}
+async function addSecurityAllow(capabilityId, findingType) {
+  const state = await readSecurityAllows();
+  if (!state.allows[capabilityId]) {
+    state.allows[capabilityId] = [];
+  }
+  if (state.allows[capabilityId].includes(findingType)) {
+    return false;
+  }
+  state.allows[capabilityId].push(findingType);
+  await writeSecurityAllows(state);
+  return true;
+}
+async function removeSecurityAllow(capabilityId, findingType) {
+  const state = await readSecurityAllows();
+  if (!state.allows[capabilityId]) {
+    return false;
+  }
+  const index = state.allows[capabilityId].indexOf(findingType);
+  if (index === -1) {
+    return false;
+  }
+  state.allows[capabilityId].splice(index, 1);
+  if (state.allows[capabilityId].length === 0) {
+    delete state.allows[capabilityId];
+  }
+  await writeSecurityAllows(state);
+  return true;
+}
+async function isSecurityAllowed(capabilityId, findingType) {
+  const state = await readSecurityAllows();
+  const allows = state.allows[capabilityId];
+  if (!allows)
+    return false;
+  return allows.includes(findingType);
+}
+async function getCapabilityAllows(capabilityId) {
+  const state = await readSecurityAllows();
+  return state.allows[capabilityId] ?? [];
+}
+async function getAllSecurityAllows() {
+  const state = await readSecurityAllows();
+  const result = [];
+  for (const [capabilityId, findingTypes] of Object.entries(state.allows)) {
+    for (const findingType of findingTypes) {
+      result.push({ capabilityId, findingType });
+    }
+  }
+  return result;
+}
+async function clearCapabilityAllows(capabilityId) {
+  const state = await readSecurityAllows();
+  if (!state.allows[capabilityId]) {
+    return false;
+  }
+  delete state.allows[capabilityId];
+  await writeSecurityAllows(state);
+  return true;
+}
+async function clearAllSecurityAllows() {
+  const state = { ...DEFAULT_STATE };
+  await writeSecurityAllows(state);
+}
 // src/sync.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdirSync as mkdirSync4 } from "node:fs";
+import { mkdirSync as mkdirSync5 } from "node:fs";
 async function installCapabilityDependencies(silent) {
-  const { existsSync: existsSync17, readdirSync: readdirSync7 } = await import("node:fs");
+  const { existsSync: existsSync18, readdirSync: readdirSync7, readFileSync: readFileSync2 } = await import("node:fs");
   const { join: join9 } = await import("node:path");
   const capabilitiesDir = ".omni/capabilities";
-  if (!existsSync17(capabilitiesDir)) {
+  if (!existsSync18(capabilitiesDir)) {
     return;
   }
   const entries = readdirSync7(capabilitiesDir, { withFileTypes: true });
@@ -2887,31 +3117,70 @@ async function installCapabilityDependencies(silent) {
     }
     const capabilityPath = join9(capabilitiesDir, entry.name);
     const packageJsonPath = join9(capabilityPath, "package.json");
-    if (!existsSync17(packageJsonPath)) {
+    if (!existsSync18(packageJsonPath)) {
       continue;
     }
-    if (!silent) {
-      console.log(`Installing dependencies for ${capabilityPath}...`);
-    }
     await new Promise((resolve2, reject) => {
-      const useNpmCi = hasNpm && existsSync17(join9(capabilityPath, "package-lock.json"));
+      const useNpmCi = hasNpm && existsSync18(join9(capabilityPath, "package-lock.json"));
       const cmd = hasBun ? "bun" : "npm";
       const args = hasBun ? ["install"] : useNpmCi ? ["ci"] : ["install"];
       const proc = spawn2(cmd, args, {
         cwd: capabilityPath,
-        stdio: silent ? "ignore" : "inherit"
+        stdio: "pipe"
+      });
+      let stderr = "";
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
       });
       proc.on("close", (code) => {
         if (code === 0) {
           resolve2();
         } else {
-          reject(new Error(`Failed to install dependencies for ${capabilityPath}`));
+          reject(new Error(`Failed to install dependencies for ${capabilityPath}:
+${stderr}`));
         }
       });
       proc.on("error", (error) => {
         reject(error);
       });
     });
+    const hasIndexTs = existsSync18(join9(capabilityPath, "index.ts"));
+    const hasBuiltIndex = existsSync18(join9(capabilityPath, "dist", "index.js"));
+    if (hasIndexTs && !hasBuiltIndex) {
+      let hasBuildScript = false;
+      try {
+        const pkgJson = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+        hasBuildScript = Boolean(pkgJson.scripts?.build);
+      } catch {}
+      if (hasBuildScript) {
+        await new Promise((resolve2, reject) => {
+          const cmd = hasBun ? "bun" : "npm";
+          const args = ["run", "build"];
+          const proc = spawn2(cmd, args, {
+            cwd: capabilityPath,
+            stdio: "pipe"
+          });
+          let stderr = "";
+          proc.stderr?.on("data", (data) => {
+            stderr += data.toString();
+          });
+          proc.on("close", (code) => {
+            if (code === 0) {
+              resolve2();
+            } else {
+              reject(new Error(`Failed to build capability ${capabilityPath}:
+${stderr}`));
+            }
+          });
+          proc.on("error", (error) => {
+            reject(error);
+          });
+        });
+      } else if (!silent) {
+        console.warn(`Warning: Capability at ${capabilityPath} has index.ts but no build script.
+  Add a "build" script to package.json (e.g., "build": "tsc") to compile TypeScript.`);
+      }
+    }
   }
 }
 async function buildSyncBundle(options) {
@@ -2945,23 +3214,11 @@ async function buildSyncBundle(options) {
 async function syncAgentConfiguration(options) {
   const silent = options?.silent ?? false;
   const adapters = options?.adapters ?? [];
-  if (!silent) {
-    console.log("Syncing agent configuration...");
-  }
   const { bundle } = await buildSyncBundle({ silent });
   const capabilities2 = bundle.capabilities;
   const previousManifest = await loadManifest();
   const currentCapabilityIds = new Set(capabilities2.map((c) => c.id));
-  const cleanupResult = await cleanupStaleResources(previousManifest, currentCapabilityIds);
-  if (!silent && (cleanupResult.deletedSkills.length > 0 || cleanupResult.deletedRules.length > 0)) {
-    console.log("Cleaned up stale resources:");
-    if (cleanupResult.deletedSkills.length > 0) {
-      console.log(`  - Removed ${cleanupResult.deletedSkills.length} skill(s): ${cleanupResult.deletedSkills.join(", ")}`);
-    }
-    if (cleanupResult.deletedRules.length > 0) {
-      console.log(`  - Removed ${cleanupResult.deletedRules.length} rule(s): ${cleanupResult.deletedRules.join(", ")}`);
-    }
-  }
+  await cleanupStaleResources(previousManifest, currentCapabilityIds);
   for (const capability of capabilities2) {
     const defaultExport = capability.exports.default;
     if (defaultExport && typeof defaultExport.sync === "function") {
@@ -2982,8 +3239,8 @@ async function syncAgentConfiguration(options) {
       }
     }
   }
-  mkdirSync4(".omni", { recursive: true });
-  await syncMcpJson(capabilities2, previousManifest, { silent });
+  mkdirSync5(".omni", { recursive: true });
+  await syncMcpJson(capabilities2, previousManifest);
   const newManifest = buildManifestFromCapabilities(capabilities2);
   await saveManifest(newManifest);
   if (adapters.length > 0) {
@@ -2994,22 +3251,12 @@ async function syncAgentConfiguration(options) {
     };
     for (const adapter of adapters) {
       try {
-        const result = await adapter.sync(bundle, ctx);
-        if (!silent && result.filesWritten.length > 0) {
-          console.log(`  - ${adapter.displayName}: ${result.filesWritten.length} files`);
-        }
+        await adapter.sync(bundle, ctx);
       } catch (error) {
         console.error(`Error running ${adapter.displayName} adapter:`, error);
       }
     }
   }
-  if (!silent) {
-    console.log("✓ Synced:");
-    console.log(`  - ${bundle.docs.length} docs, ${bundle.rules.length} rules`);
-    if (adapters.length > 0) {
-      console.log(`  - Provider adapters: ${adapters.map((a) => a.displayName).join(", ")}`);
-    }
-  }
   return {
     capabilities: capabilities2.map((c) => c.id),
     skillCount: bundle.skills.length,
@@ -3031,6 +3278,427 @@ function generateInstructionsContent(rules, _docs) {
   }
   return content.trim();
 }
+// src/security/scanner.ts
+import { existsSync as existsSync18 } from "node:fs";
+import { lstat, readdir as readdir2, readFile as readFile16, readlink, realpath } from "node:fs/promises";
+import { join as join9, relative, resolve as resolve2 } from "node:path";
+
+// src/security/types.ts
+var DEFAULT_SECURITY_CONFIG = {
+  mode: "off",
+  trusted_sources: [],
+  scan: {
+    unicode: true,
+    symlinks: true,
+    scripts: true,
+    binaries: false
+  }
+};
+var DEFAULT_SCAN_SETTINGS = {
+  unicode: true,
+  symlinks: true,
+  scripts: true,
+  binaries: false
+};
+
+// src/security/scanner.ts
+var UNICODE_PATTERNS = {
+  bidi: [
+    8234,
+    8235,
+    8236,
+    8237,
+    8238,
+    8294,
+    8295,
+    8296,
+    8297
+  ],
+  zeroWidth: [
+    8203,
+    8204,
+    8205,
+    8288,
+    65279
+  ],
+  control: [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    11,
+    12,
+    14,
+    15,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    30,
+    31,
+    127
+  ]
+};
+var SUSPICIOUS_SCRIPT_PATTERNS = [
+  {
+    pattern: /curl\s+.*\|\s*(ba)?sh/i,
+    message: "Piping curl to shell can execute arbitrary remote code",
+    severity: "high"
+  },
+  {
+    pattern: /wget\s+.*\|\s*(ba)?sh/i,
+    message: "Piping wget to shell can execute arbitrary remote code",
+    severity: "high"
+  },
+  {
+    pattern: /eval\s*\(\s*\$\(/,
+    message: "eval with command substitution can be dangerous",
+    severity: "medium"
+  },
+  {
+    pattern: /rm\s+-rf\s+\/($|\s)|rm\s+-rf\s+~($|\s)/,
+    message: "Recursive deletion from root or home directory",
+    severity: "critical"
+  },
+  {
+    pattern: /chmod\s+777/,
+    message: "Setting world-writable permissions",
+    severity: "medium"
+  },
+  {
+    pattern: /\bsudo\b.*>/,
+    message: "Using sudo with output redirection",
+    severity: "medium"
+  },
+  {
+    pattern: /base64\s+-d.*\|\s*(ba)?sh/i,
+    message: "Decoding and executing base64 content",
+    severity: "high"
+  }
+];
+var BINARY_EXTENSIONS = new Set([
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".o",
+  ".a",
+  ".lib",
+  ".pyc",
+  ".pyo",
+  ".class",
+  ".jar",
+  ".war",
+  ".ear",
+  ".wasm",
+  ".node"
+]);
+var TEXT_EXTENSIONS = new Set([
+  ".md",
+  ".txt",
+  ".toml",
+  ".yaml",
+  ".yml",
+  ".json",
+  ".js",
+  ".ts",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".py",
+  ".rb"
+]);
+async function scanFileForUnicode(filePath, relativePath) {
+  const findings = [];
+  try {
+    const content = await readFile16(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    for (let lineNum = 0;lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      if (!line)
+        continue;
+      for (let col = 0;col < line.length; col++) {
+        const codePoint = line.codePointAt(col);
+        if (codePoint === undefined)
+          continue;
+        if (UNICODE_PATTERNS.bidi.includes(codePoint)) {
+          findings.push({
+            type: "unicode_bidi",
+            severity: "high",
+            file: relativePath,
+            line: lineNum + 1,
+            column: col + 1,
+            message: "Bidirectional text override character detected",
+            details: `Codepoint U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`
+          });
+        }
+        if (UNICODE_PATTERNS.zeroWidth.includes(codePoint)) {
+          if (codePoint === 65279 && lineNum === 0 && col === 0)
+            continue;
+          findings.push({
+            type: "unicode_zero_width",
+            severity: "medium",
+            file: relativePath,
+            line: lineNum + 1,
+            column: col + 1,
+            message: "Zero-width character detected",
+            details: `Codepoint U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`
+          });
+        }
+        if (UNICODE_PATTERNS.control.includes(codePoint)) {
+          findings.push({
+            type: "unicode_control",
+            severity: "medium",
+            file: relativePath,
+            line: lineNum + 1,
+            column: col + 1,
+            message: "Suspicious control character detected",
+            details: `Codepoint U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`
+          });
+        }
+      }
+    }
+  } catch {}
+  return findings;
+}
+async function scanFileForScripts(filePath, relativePath) {
+  const findings = [];
+  try {
+    const content = await readFile16(filePath, "utf-8");
+    const lines = content.split(`
+`);
+    for (let lineNum = 0;lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+      if (!line)
+        continue;
+      for (const { pattern, message, severity } of SUSPICIOUS_SCRIPT_PATTERNS) {
+        if (pattern.test(line)) {
+          findings.push({
+            type: "suspicious_script",
+            severity,
+            file: relativePath,
+            line: lineNum + 1,
+            message,
+            details: line.trim().substring(0, 100)
+          });
+        }
+      }
+    }
+  } catch {}
+  return findings;
+}
+async function checkSymlink(symlinkPath, relativePath, capabilityRoot) {
+  try {
+    const linkTarget = await readlink(symlinkPath);
+    const resolvedTarget = resolve2(join9(symlinkPath, "..", linkTarget));
+    const normalizedRoot = await realpath(capabilityRoot);
+    if (linkTarget.startsWith("/")) {
+      return {
+        type: "symlink_absolute",
+        severity: "high",
+        file: relativePath,
+        message: "Symlink points to an absolute path",
+        details: `Target: ${linkTarget}`
+      };
+    }
+    const relativeToRoot = relative(normalizedRoot, resolvedTarget);
+    if (relativeToRoot.startsWith("..") || relativeToRoot.startsWith("/")) {
+      return {
+        type: "symlink_escape",
+        severity: "critical",
+        file: relativePath,
+        message: "Symlink escapes capability directory",
+        details: `Resolves to: ${resolvedTarget}`
+      };
+    }
+  } catch {}
+  return null;
+}
+function isBinaryFile(filePath) {
+  const ext = filePath.toLowerCase().substring(filePath.lastIndexOf("."));
+  return BINARY_EXTENSIONS.has(ext);
+}
+function isTextFile(filePath) {
+  const ext = filePath.toLowerCase().substring(filePath.lastIndexOf("."));
+  return TEXT_EXTENSIONS.has(ext);
+}
+async function scanCapability(capabilityId, capabilityPath, settings = DEFAULT_SCAN_SETTINGS) {
+  const startTime = Date.now();
+  const findings = [];
+  if (!existsSync18(capabilityPath)) {
+    return {
+      capabilityId,
+      path: capabilityPath,
+      findings: [],
+      passed: true,
+      duration: Date.now() - startTime
+    };
+  }
+  async function scanDirectory(dirPath) {
+    const entries = await readdir2(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join9(dirPath, entry.name);
+      const relativePath = relative(capabilityPath, fullPath);
+      if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "__pycache__") {
+        continue;
+      }
+      const stats = await lstat(fullPath);
+      if (stats.isSymbolicLink() && settings.symlinks) {
+        const finding = await checkSymlink(fullPath, relativePath, capabilityPath);
+        if (finding) {
+          findings.push(finding);
+        }
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await scanDirectory(fullPath);
+        continue;
+      }
+      if (entry.isFile()) {
+        if (settings.binaries && isBinaryFile(fullPath)) {
+          findings.push({
+            type: "binary_file",
+            severity: "low",
+            file: relativePath,
+            message: "Binary file detected in capability"
+          });
+        }
+        if (isTextFile(fullPath)) {
+          if (settings.unicode) {
+            const unicodeFindings = await scanFileForUnicode(fullPath, relativePath);
+            findings.push(...unicodeFindings);
+          }
+          if (settings.scripts) {
+            const ext = fullPath.toLowerCase().substring(fullPath.lastIndexOf("."));
+            if ([".sh", ".bash", ".zsh", ".fish", ".py", ".rb", ".js", ".ts"].includes(ext)) {
+              const scriptFindings = await scanFileForScripts(fullPath, relativePath);
+              findings.push(...scriptFindings);
+            }
+          }
+        }
+      }
+    }
+  }
+  await scanDirectory(capabilityPath);
+  return {
+    capabilityId,
+    path: capabilityPath,
+    findings,
+    passed: findings.length === 0 || findings.every((f) => f.severity === "low"),
+    duration: Date.now() - startTime
+  };
+}
+async function scanCapabilities(capabilities2, config2 = {}) {
+  const settings = {
+    ...DEFAULT_SCAN_SETTINGS,
+    ...config2.scan
+  };
+  const results = [];
+  for (const cap of capabilities2) {
+    if (config2.trusted_sources && config2.trusted_sources.length > 0) {}
+    const result = await scanCapability(cap.id, cap.path, settings);
+    results.push(result);
+  }
+  const findingsByType = {
+    unicode_bidi: 0,
+    unicode_zero_width: 0,
+    unicode_control: 0,
+    symlink_escape: 0,
+    symlink_absolute: 0,
+    suspicious_script: 0,
+    binary_file: 0
+  };
+  const findingsBySeverity = {
+    low: 0,
+    medium: 0,
+    high: 0,
+    critical: 0
+  };
+  let totalFindings = 0;
+  let capabilitiesWithFindings = 0;
+  for (const result of results) {
+    if (result.findings.length > 0) {
+      capabilitiesWithFindings++;
+    }
+    for (const finding of result.findings) {
+      totalFindings++;
+      findingsByType[finding.type]++;
+      findingsBySeverity[finding.severity]++;
+    }
+  }
+  return {
+    totalCapabilities: capabilities2.length,
+    capabilitiesWithFindings,
+    totalFindings,
+    findingsByType,
+    findingsBySeverity,
+    results,
+    allPassed: results.every((r) => r.passed)
+  };
+}
+function formatScanResults(summary, verbose = false) {
+  const lines = [];
+  lines.push("Security Scan Results");
+  lines.push("=====================");
+  lines.push("");
+  if (summary.totalFindings === 0) {
+    lines.push("✓ No security issues found");
+    return lines.join(`
+`);
+  }
+  lines.push(`Found ${summary.totalFindings} issue(s) in ${summary.capabilitiesWithFindings} capability(ies)`);
+  lines.push("");
+  if (summary.findingsBySeverity.critical > 0) {
+    lines.push(`  ✗ Critical: ${summary.findingsBySeverity.critical}`);
+  }
+  if (summary.findingsBySeverity.high > 0) {
+    lines.push(`  ✗ High: ${summary.findingsBySeverity.high}`);
+  }
+  if (summary.findingsBySeverity.medium > 0) {
+    lines.push(`  ! Medium: ${summary.findingsBySeverity.medium}`);
+  }
+  if (summary.findingsBySeverity.low > 0) {
+    lines.push(`  · Low: ${summary.findingsBySeverity.low}`);
+  }
+  lines.push("");
+  if (verbose) {
+    for (const result of summary.results) {
+      if (result.findings.length === 0)
+        continue;
+      lines.push(`${result.capabilityId}:`);
+      for (const finding of result.findings) {
+        const location = finding.line ? `:${finding.line}${finding.column ? `:${finding.column}` : ""}` : "";
+        const severity = finding.severity.toUpperCase().padEnd(8);
+        lines.push(`  [${severity}] ${finding.file}${location}`);
+        lines.push(`             ${finding.message}`);
+        if (finding.details) {
+          lines.push(`             ${finding.details}`);
+        }
+      }
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
 // src/templates/agents.ts
 function generateAgentsTemplate() {
   return `# Project Instructions
@@ -3202,6 +3870,7 @@ function getVersion() {
   return version;
 }
 export {
+  writeSecurityAllows,
   writeProviderConfig,
   writeMcpJson,
   writeEnabledProviders,
@@ -3218,9 +3887,13 @@ export {
   sourceToGitUrl,
   setProfile,
   setActiveProfile,
+  scanCapability,
+  scanCapabilities,
   saveManifest,
   saveLockFile,
   resolveEnabledCapabilities,
+  removeSecurityAllow,
+  readSecurityAllows,
   readMcpJson,
   readEnabledProviders,
   readCapabilityIdFromPath,
@@ -3251,6 +3924,7 @@ export {
   loadCapability,
   loadBaseConfig,
   isValidMatcherPattern,
+  isSecurityAllowed,
   isProviderEnabled,
   isPromptHookEvent,
   isMatcherEvent,
@@ -3271,6 +3945,8 @@ export {
   getHooksConfigPath,
   getEventsWithHooks,
   getEnabledCapabilities,
+  getCapabilityAllows,
+  getAllSecurityAllows,
   getActiveProviders,
   getActiveProfile,
   generateSkillTemplate,
@@ -3281,6 +3957,7 @@ export {
   generateClaudeTemplate,
   generateCapabilityToml2 as generateCapabilityToml,
   generateAgentsTemplate,
+  formatScanResults,
   findDuplicateCommands,
   fetchCapabilitySource,
   fetchAllCapabilitySources,
@@ -3295,6 +3972,8 @@ export {
   countHooks,
   containsOmnidevVariables,
   containsClaudeVariables,
+  clearCapabilityAllows,
+  clearAllSecurityAllows,
   clearActiveProfileState,
   cleanupStaleResources,
   checkForUpdates,
@@ -3303,6 +3982,7 @@ export {
   buildManifestFromCapabilities,
   buildCommand,
   buildCapabilityRegistry,
+  addSecurityAllow,
   VARIABLE_MAPPINGS,
   SESSION_START_MATCHERS,
   PROMPT_HOOK_EVENTS,
@@ -3313,6 +3993,8 @@ export {
   HOOK_EVENTS,
   HOOKS_DIRECTORY,
   HOOKS_CONFIG_FILENAME,
+  DEFAULT_SECURITY_CONFIG,
+  DEFAULT_SCAN_SETTINGS,
   DEFAULT_PROMPT_TIMEOUT,
   DEFAULT_COMMAND_TIMEOUT,
   COMMON_TOOL_MATCHERS