@hamzaabili/opencode-integrity 0.0.0-stage → 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,1260 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { homedir as homedir2 } from "node:os";
+import { relative as relative3, resolve as resolve4 } from "node:path";
+
+// src/assets.ts
+import { readdir as readdir2, realpath as realpath2 } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { basename, dirname as dirname2, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2 } from "node:path";
+
+// src/util.ts
+import { createHash, randomUUID } from "node:crypto";
+import {
+  mkdir,
+  readdir,
+  readFile,
+  readlink,
+  realpath,
+  rename,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+async function readTextFileCapped(path, maxBytes = 2 * 1024 * 1024) {
+  try {
+    const info = await stat(path);
+    if (info.size > maxBytes)
+      return;
+  } catch {
+    return;
+  }
+  return await readTextFile(path);
+}
+async function readTextFile(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return;
+  }
+}
+async function readJsonFileCapped(path, maxBytes = 2 * 1024 * 1024) {
+  const text = await readTextFileCapped(path, maxBytes);
+  if (text === undefined)
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+async function readJsonFile(path) {
+  const text = await readTextFile(path);
+  if (text === undefined)
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDirectory(path) {
+  try {
+    return (await stat(path)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function writeFileAtomic(path, content, mode = 420) {
+  await mkdir(dirname(path), { recursive: true });
+  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  await writeFile(temporary, content, { mode });
+  await rename(temporary, path);
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function hashText(value) {
+  return `sha256:${sha256(value)}`;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+  const record = value;
+  const keys = Object.keys(record).sort();
+  return `{${keys.filter((key) => record[key] !== undefined).map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function hashObject(value) {
+  return hashText(stableStringify(value));
+}
+function isInside(parent, child) {
+  const rel = relative(resolve(parent), resolve(child));
+  return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
+}
+var IGNORED_DIRS = new Set([".git"]);
+async function hashDirectory(root, maxFiles = 5000, maxBytes = 50 * 1024 * 1024) {
+  const files = [];
+  const visited = new Set;
+  let bytes = 0;
+  let truncated = false;
+  async function walk(directory, depth) {
+    if (truncated)
+      return;
+    if (depth > 32) {
+      truncated = true;
+      return;
+    }
+    let real;
+    try {
+      real = await realpath(directory);
+    } catch {
+      return;
+    }
+    if (visited.has(real))
+      return;
+    visited.add(real);
+    let entries;
+    try {
+      entries = await readdir(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (files.length >= maxFiles || bytes >= maxBytes) {
+        truncated = true;
+        return;
+      }
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRS.has(entry.name))
+          continue;
+        await walk(join(directory, entry.name), depth + 1);
+        continue;
+      }
+      const path = join(directory, entry.name);
+      if (entry.isSymbolicLink()) {
+        let target = "";
+        try {
+          target = await readlink(path);
+        } catch {
+          continue;
+        }
+        let content = Buffer.from(`link:${target}`);
+        try {
+          const targetPath = resolve(dirname(path), target);
+          const info = await stat(targetPath);
+          if (info.isDirectory()) {
+            await walk(targetPath, depth + 1);
+          } else if (info.isFile()) {
+            if (info.size > maxBytes - bytes) {
+              truncated = true;
+              return;
+            }
+            const targetContent = await readFile(targetPath);
+            bytes += targetContent.byteLength;
+            content = Buffer.from(`link:${target}\x00${sha256(targetContent.toString("base64"))}`);
+          }
+        } catch {}
+        files.push({ path: relative(root, path), content });
+        bytes += content.byteLength;
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      try {
+        const info = await stat(path);
+        if (info.size > maxBytes - bytes) {
+          truncated = true;
+          return;
+        }
+        const content = await readFile(path);
+        files.push({ path: relative(root, path), content });
+        bytes += content.byteLength;
+      } catch {}
+    }
+  }
+  await walk(root, 0);
+  const lines = files.sort((a, b) => a.path.localeCompare(b.path)).map((file) => `${file.path}\x00${sha256(file.content.toString("base64"))}`);
+  return {
+    hash: hashText(lines.join(`
+`)),
+    files: files.length,
+    bytes,
+    truncated
+  };
+}
+function parseJsonc(text) {
+  let output = "";
+  let inString = false;
+  let escaped = false;
+  for (let index = 0;index < text.length; index += 1) {
+    const character = text[index] ?? "";
+    const next = text[index + 1] ?? "";
+    if (inString) {
+      output += character;
+      if (escaped)
+        escaped = false;
+      else if (character === "\\")
+        escaped = true;
+      else if (character === '"')
+        inString = false;
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      output += character;
+      continue;
+    }
+    if (character === "/" && next === "/") {
+      while (index < text.length && text[index] !== `
+`)
+        index += 1;
+      output += `
+`;
+      continue;
+    }
+    if (character === "/" && next === "*") {
+      index += 2;
+      while (index < text.length && !(text[index] === "*" && text[index + 1] === "/"))
+        index += 1;
+      index += 1;
+      output += " ";
+      continue;
+    }
+    output += character;
+  }
+  let cleaned = "";
+  let string = false;
+  let escapedInString = false;
+  for (let index = 0;index < output.length; index += 1) {
+    const character = output[index] ?? "";
+    if (string) {
+      cleaned += character;
+      if (escapedInString)
+        escapedInString = false;
+      else if (character === "\\")
+        escapedInString = true;
+      else if (character === '"')
+        string = false;
+      continue;
+    }
+    if (character === '"') {
+      string = true;
+      cleaned += character;
+      continue;
+    }
+    if (character === ",") {
+      let next = index + 1;
+      while (next < output.length && /\s/.test(output[next] ?? ""))
+        next += 1;
+      const following = output[next] ?? "";
+      if (following === "}" || following === "]")
+        continue;
+    }
+    cleaned += character;
+  }
+  return JSON.parse(cleaned);
+}
+async function readJsoncFile(path) {
+  const text = await readTextFile(path);
+  if (text === undefined)
+    return;
+  try {
+    return parseJsonc(text);
+  } catch {
+    return;
+  }
+}
+function globMatch(pattern, value) {
+  let source = "";
+  for (let index = 0;index < pattern.length; index += 1) {
+    const character = pattern[index] ?? "";
+    if (character === "*")
+      source += ".*";
+    else if (character === "?")
+      source += ".";
+    else
+      source += character.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  try {
+    return new RegExp(`^${source}$`, "s").test(value);
+  } catch {
+    return false;
+  }
+}
+function ignored(id, patterns) {
+  return patterns.some((pattern) => globMatch(pattern, id));
+}
+var CAPABILITY_PATTERNS = [
+  ["network", /\b(fetch\(|node:https?|from ["']https?["']|undici|WebSocket|axios)/],
+  ["filesystem", /\b(node:fs|from ["']fs["']|readFile|writeFile|readdir|mkdir)/],
+  ["process", /\b(child_process|spawn\(|execFile\(|exec\()/],
+  ["environment", /process\.env/],
+  ["dynamic-code", /\b(eval\(|new Function\()/]
+];
+function detectCapabilities(text) {
+  return CAPABILITY_PATTERNS.filter(([, pattern]) => pattern.test(text)).map(([name]) => name);
+}
+var SUSPICIOUS_PATTERNS = [
+  ["zero-width-characters", /[\u200B-\u200D\uFEFF]/],
+  ["bidi-controls", /[\u202A-\u202E\u2066-\u2069]/],
+  ["html-comment", /<!--/],
+  [
+    "ignore-instructions",
+    /\b(ignore|disregard)\s+(all\s+)?(previous|prior|above)\s+instructions?\b/i
+  ],
+  ["do-not-tell", /\bdo\s+not\s+(tell|inform|mention)\b/i],
+  ["exfiltration-language", /\b(exfiltrate|send\s+.*\b(token|secret|credential|env)\b)/i]
+];
+function detectSuspicious(text) {
+  return SUSPICIOUS_PATTERNS.filter(([, pattern]) => pattern.test(text)).map(([name]) => name);
+}
+
+// src/assets.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function secretKey(key) {
+  return /(token|secret|password|api[-_]?key|authorization|cookie|credential)/i.test(key);
+}
+function redactValue(key, value) {
+  return secretKey(key) ? "[redacted]" : value;
+}
+function redactRecord(value) {
+  if (!isObject(value))
+    return {};
+  const output = {};
+  for (const [key, entry] of Object.entries(value))
+    output[key] = redactValue(key, entry);
+  return output;
+}
+function redactCommand(command) {
+  return command.map((entry) => entry.replace(/((?:token|secret|password|api[-_]?key)=)[^\s]+/gi, "$1[redacted]"));
+}
+function sanitizeUrl(value) {
+  try {
+    return new URL(value).origin;
+  } catch {
+    return "[invalid-url]";
+  }
+}
+function packageJsonPath(root) {
+  return join2(root, "package.json");
+}
+async function walkUpToPackage(start) {
+  let current = resolve2(start);
+  for (let depth = 0;depth < 8; depth += 1) {
+    if (await pathExists(packageJsonPath(current)))
+      return current;
+    const parent = dirname2(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return;
+}
+async function resolvePluginRoot(ref, directory, home) {
+  const target = ref.localPath ?? ref.target;
+  if (isAbsolute2(target) || target.startsWith(".") || target.startsWith("~/")) {
+    const expanded = target.startsWith("~") ? resolve2(home, target.slice(2)) : resolve2(directory, target);
+    if (await isDirectory(expanded))
+      return expanded;
+    return await walkUpToPackage(dirname2(expanded));
+  }
+  const direct = join2(directory, "node_modules", target);
+  if (await isDirectory(direct))
+    return direct;
+  try {
+    const require2 = createRequire(join2(directory, "package.json"));
+    const entry = require2.resolve(target);
+    return await walkUpToPackage(dirname2(entry));
+  } catch {
+    return;
+  }
+}
+async function entryText(root, realRoot) {
+  const manifest = await readJsonFileCapped(packageJsonPath(root));
+  const candidates = new Set;
+  if (typeof manifest?.main === "string")
+    candidates.add(manifest.main);
+  if (typeof manifest?.module === "string")
+    candidates.add(manifest.module);
+  const exports = manifest?.exports;
+  if (typeof exports === "string")
+    candidates.add(exports);
+  else if (isObject(exports)) {
+    for (const value of Object.values(exports)) {
+      if (typeof value === "string")
+        candidates.add(value);
+      else if (isObject(value)) {
+        for (const nested of Object.values(value))
+          if (typeof nested === "string")
+            candidates.add(nested);
+      }
+    }
+  }
+  candidates.add("index.ts");
+  candidates.add("index.js");
+  for (const candidate of candidates) {
+    const path = join2(root, candidate);
+    if (!isInside(root, path))
+      continue;
+    const real = await realpath2(path).catch(() => {
+      return;
+    });
+    if (real === undefined || !isInside(realRoot, real))
+      continue;
+    const text = await readTextFileCapped(real);
+    if (text !== undefined)
+      return text;
+  }
+  return "";
+}
+async function pluginAsset(id, ref, directory, home, allowOutside = false) {
+  const root = await resolvePluginRoot(ref, directory, home);
+  if (root === undefined) {
+    return {
+      warning: `${id}: package not installed (${ref.target}); run the package manager first`
+    };
+  }
+  const realRoot = await realpath2(root).catch(() => root);
+  const realDirectory = await realpath2(directory).catch(() => directory);
+  if (!allowOutside && !isInside(realDirectory, realRoot)) {
+    return { warning: `${id}: local plugin resolves outside the project and was ignored` };
+  }
+  const manifest = await readJsonFileCapped(packageJsonPath(realRoot));
+  const version = ref.version ?? (typeof manifest?.version === "string" ? manifest.version : undefined);
+  const content = await hashDirectory(root);
+  const text = await entryText(root, realRoot);
+  return {
+    asset: {
+      source: ref.target,
+      version,
+      packageHash: hashObject(manifest ?? {}),
+      contentHash: content.hash,
+      files: content.files,
+      bytes: content.bytes,
+      capabilities: detectCapabilities(text),
+      truncated: content.truncated
+    },
+    warning: content.truncated ? `${id}: hash truncated at 5000 files / 50 MiB` : undefined
+  };
+}
+async function skillFiles(root) {
+  const output = [];
+  async function walk(directory, depth) {
+    if (depth > 4)
+      return;
+    let entries;
+    try {
+      entries = await readdir2(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name === "node_modules" || entry.name === ".git")
+        continue;
+      const path = join2(directory, entry.name);
+      if (entry.isDirectory())
+        await walk(path, depth + 1);
+      else if (entry.isFile() && entry.name === "SKILL.md")
+        output.push(path);
+    }
+  }
+  await walk(root, 0);
+  return output.sort();
+}
+function skillID(path, content) {
+  const match = /^---\s*\n([\s\S]*?)\n---/.exec(content);
+  const name = match?.[1]?.match(/^name:\s*["']?([^"'\n]+)["']?/m)?.[1];
+  return (name ?? basename(dirname2(path))).trim();
+}
+async function scanSkills(directory, warnings = []) {
+  const root = join2(directory, ".opencode", "skills");
+  const output = {};
+  for (const path of await skillFiles(root)) {
+    const content = await readTextFileCapped(path);
+    if (content === undefined) {
+      warnings.push(`${path}: skill too large or unreadable; not hashed`);
+      continue;
+    }
+    const directoryHash = await hashDirectory(dirname2(path));
+    if (directoryHash.truncated)
+      warnings.push(`${path}: skill directory too large to hash completely`);
+    output[skillID(path, content)] = {
+      path: path.slice(directory.length + 1),
+      contentHash: hashText(content),
+      directoryHash: directoryHash.hash,
+      files: directoryHash.files,
+      bytes: directoryHash.bytes,
+      truncated: directoryHash.truncated,
+      suspicious: detectSuspicious(content)
+    };
+  }
+  return output;
+}
+function mcpConfigAsset(_name, config) {
+  if (!isObject(config))
+    return;
+  const type = typeof config.type === "string" ? config.type : typeof config.url === "string" ? "remote" : "local";
+  const transport = type === "remote" ? "remote" : "local";
+  if (config.disabled === true)
+    return;
+  const commandValue = config.command;
+  const command = Array.isArray(commandValue) ? commandValue.filter((entry) => typeof entry === "string") : typeof commandValue === "string" ? commandValue.trim().split(/\s+/) : [];
+  const environment = redactRecord(config.environment ?? config.env);
+  const headers = redactRecord(config.headers);
+  const canonical = {
+    type,
+    command: redactCommand(command),
+    cwd: typeof config.cwd === "string" ? config.cwd : undefined,
+    url: typeof config.url === "string" ? config.url : undefined,
+    environment,
+    headers,
+    codemode: config.codemode
+  };
+  return {
+    transport,
+    configHash: hashObject(canonical),
+    command: command[0] === undefined ? undefined : basename(command[0]),
+    url: typeof config.url === "string" ? sanitizeUrl(config.url) : undefined,
+    envKeys: Object.keys(environment).sort(),
+    toolsSource: "none"
+  };
+}
+
+// src/config.ts
+import { join as join3 } from "node:path";
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function pluginRef(value) {
+  if (typeof value === "string") {
+    return value.trim().length > 0 ? { target: value.trim() } : undefined;
+  }
+  if (Array.isArray(value) && typeof value[0] === "string") {
+    return { target: value[0] };
+  }
+  if (isObject2(value) && typeof value.package === "string") {
+    return { target: value.package };
+  }
+  return;
+}
+function configPaths(directory) {
+  return [
+    join3(directory, "opencode.json"),
+    join3(directory, "opencode.jsonc"),
+    join3(directory, ".opencode", "opencode.json"),
+    join3(directory, ".opencode", "opencode.jsonc")
+  ];
+}
+function mcpFromConfig(data) {
+  const output = {};
+  if (!isObject2(data.mcp))
+    return output;
+  if (isObject2(data.mcp.servers))
+    Object.assign(output, data.mcp.servers);
+  for (const [name, value] of Object.entries(data.mcp)) {
+    if (name === "servers" || name === "timeout")
+      continue;
+    if (isObject2(value))
+      output[name] = value;
+  }
+  return output;
+}
+async function loadGlobalMcp(home) {
+  const output = {};
+  for (const path of [
+    join3(home, ".config", "opencode", "opencode.json"),
+    join3(home, ".config", "opencode", "opencode.jsonc")
+  ]) {
+    if (!await pathExists(path))
+      continue;
+    const data = await readJsoncFile(path);
+    if (isObject2(data))
+      Object.assign(output, mcpFromConfig(data));
+  }
+  return output;
+}
+async function loadProjectConfig(directory) {
+  const files = [];
+  const plugins = [];
+  const mcp = {};
+  const warnings = [];
+  for (const path of configPaths(directory)) {
+    if (!await pathExists(path))
+      continue;
+    const data = await readJsoncFile(path);
+    if (!isObject2(data)) {
+      warnings.push(`${path}: unreadable or invalid JSONC`);
+      continue;
+    }
+    files.push(path);
+    const values = [
+      ...Array.isArray(data.plugins) ? data.plugins : [],
+      ...Array.isArray(data.plugin) ? data.plugin : []
+    ];
+    for (const value of values) {
+      const ref = pluginRef(value);
+      if (ref !== undefined)
+        plugins.push(ref);
+    }
+    Object.assign(mcp, mcpFromConfig(data));
+  }
+  const pluginDirectory = join3(directory, ".opencode", "plugins");
+  if (await isDirectory(pluginDirectory)) {
+    const { readdir } = await import("node:fs/promises");
+    for (const entry of await readdir(pluginDirectory, { withFileTypes: true })) {
+      if (entry.isDirectory())
+        plugins.push({
+          target: join3(pluginDirectory, entry.name),
+          localPath: join3(pluginDirectory, entry.name)
+        });
+      else if (entry.isFile() && /\.(ts|js|mjs|cjs)$/.test(entry.name)) {
+        plugins.push({
+          target: join3(pluginDirectory, entry.name),
+          localPath: join3(pluginDirectory, entry.name)
+        });
+      }
+    }
+  }
+  return { files, plugins: dedupe(plugins), mcp, warnings };
+}
+function dedupe(values) {
+  const seen = new Set;
+  return values.filter((value) => {
+    if (seen.has(value.target))
+      return false;
+    seen.add(value.target);
+    return true;
+  });
+}
+
+// src/types.ts
+var SCHEMA_VERSION = 1;
+
+// src/lockfile.ts
+function sortRecord(value) {
+  return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
+}
+function sortAssets(assets) {
+  return {
+    plugins: sortRecord(assets.plugins),
+    mcp: Object.fromEntries(Object.entries(assets.mcp).sort(([a], [b]) => a.localeCompare(b)).map(([name, asset]) => [
+      name,
+      { ...asset, tools: asset.tools === undefined ? undefined : sortRecord(asset.tools) }
+    ])),
+    skills: sortRecord(assets.skills)
+  };
+}
+function createLockfile(assets, opencode, version = "0.1.0") {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    generatedBy: `opencode-integrity@${version}`,
+    opencode,
+    assets: sortAssets(assets)
+  };
+}
+async function readLockfile(path) {
+  const raw = await readJsonFile(path);
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+    return;
+  const record = raw;
+  if (record.schemaVersion !== SCHEMA_VERSION || typeof record.assets !== "object")
+    return;
+  const assets = record.assets;
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    generatedBy: typeof record.generatedBy === "string" ? record.generatedBy : "unknown",
+    opencode: typeof record.opencode === "string" ? record.opencode : undefined,
+    assets: {
+      plugins: isRecord(assets.plugins) ? assets.plugins : {},
+      mcp: isRecord(assets.mcp) ? assets.mcp : {},
+      skills: isRecord(assets.skills) ? assets.skills : {}
+    }
+  };
+}
+async function writeLockfile(path, lockfile) {
+  const canonical = JSON.parse(stableStringify(lockfile));
+  await writeFileAtomic(path, `${JSON.stringify(canonical, null, 2)}
+`);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function diffAssets(locked, current, compareTools = true) {
+  const drift = [];
+  for (const [id, asset] of Object.entries(current.plugins)) {
+    const before = locked.plugins[id];
+    if (before === undefined) {
+      drift.push({
+        asset: "plugin",
+        id,
+        change: "added",
+        severity: "high",
+        message: `new plugin ${id}`
+      });
+      continue;
+    }
+    if (before.truncated === true || asset.truncated === true) {
+      drift.push({
+        asset: "plugin",
+        id,
+        change: "changed",
+        field: "hash incomplete",
+        severity: "high",
+        message: `plugin ${id}: package too large to hash completely; reduce it or inspect manually`
+      });
+      continue;
+    }
+    if (before.contentHash !== asset.contentHash || before.packageHash !== asset.packageHash) {
+      const fields = [];
+      if (before.version !== asset.version)
+        fields.push(`version ${before.version ?? "?"} -> ${asset.version ?? "?"}`);
+      if (before.contentHash !== asset.contentHash)
+        fields.push("package content changed");
+      drift.push({
+        asset: "plugin",
+        id,
+        change: "changed",
+        field: fields.join(", "),
+        severity: "high",
+        message: `plugin ${id}: ${fields.join(", ") || "content changed"}`
+      });
+    }
+    const added = (asset.capabilities ?? []).filter((capability) => !(before.capabilities ?? []).includes(capability));
+    if (added.length > 0) {
+      drift.push({
+        asset: "plugin",
+        id,
+        change: "changed",
+        field: `capabilities +${added.join(",")}`,
+        severity: "high",
+        message: `plugin ${id}: new capabilities ${added.join(", ")}`
+      });
+    }
+  }
+  for (const id of Object.keys(locked.plugins)) {
+    if (current.plugins[id] === undefined) {
+      drift.push({
+        asset: "plugin",
+        id,
+        change: "removed",
+        severity: "low",
+        message: `plugin ${id} removed`
+      });
+    }
+  }
+  for (const [id, asset] of Object.entries(current.mcp)) {
+    const before = locked.mcp[id];
+    if (before === undefined) {
+      drift.push({
+        asset: "mcp",
+        id,
+        change: "added",
+        severity: "high",
+        message: `new MCP server ${id}`
+      });
+      continue;
+    }
+    if (before.configHash !== asset.configHash) {
+      drift.push({
+        asset: "mcp",
+        id,
+        change: "changed",
+        field: "config",
+        severity: "medium",
+        message: `MCP server ${id}: command, URL or environment changed`
+      });
+    }
+    if (!compareTools)
+      continue;
+    const beforeTools = before.tools ?? {};
+    const currentTools = asset.tools ?? {};
+    for (const [tool, toolAsset] of Object.entries(currentTools)) {
+      const previous = beforeTools[tool];
+      if (previous === undefined) {
+        drift.push({
+          asset: "mcp-tool",
+          id: tool,
+          parent: id,
+          change: "added",
+          severity: "high",
+          message: `MCP server ${id}: new tool ${tool}${(toolAsset.suspicious ?? []).length > 0 ? ` [suspicious: ${(toolAsset.suspicious ?? []).join(", ")}]` : ""}`
+        });
+        continue;
+      }
+      const fields = [];
+      if (previous.descriptionHash !== toolAsset.descriptionHash)
+        fields.push("description");
+      if (previous.inputHash !== toolAsset.inputHash)
+        fields.push("input schema");
+      if (fields.length > 0 || previous.descriptorHash !== toolAsset.descriptorHash) {
+        drift.push({
+          asset: "mcp-tool",
+          id: tool,
+          parent: id,
+          change: "changed",
+          field: fields.join(", ") || "descriptor",
+          severity: "high",
+          message: `MCP server ${id}: tool ${tool} changed (${fields.join(", ") || "descriptor"})${(toolAsset.suspicious ?? []).length > 0 ? ` [suspicious: ${(toolAsset.suspicious ?? []).join(", ")}]` : ""}`
+        });
+      }
+    }
+    for (const tool of Object.keys(beforeTools)) {
+      if (currentTools[tool] === undefined) {
+        drift.push({
+          asset: "mcp-tool",
+          id: tool,
+          parent: id,
+          change: "removed",
+          severity: "medium",
+          message: `MCP server ${id}: tool ${tool} removed`
+        });
+      }
+    }
+  }
+  for (const id of Object.keys(locked.mcp)) {
+    if (current.mcp[id] === undefined) {
+      drift.push({
+        asset: "mcp",
+        id,
+        change: "removed",
+        severity: "medium",
+        message: `MCP server ${id} removed`
+      });
+    }
+  }
+  for (const [id, asset] of Object.entries(current.skills)) {
+    const before = locked.skills[id];
+    if (before === undefined) {
+      drift.push({
+        asset: "skill",
+        id,
+        change: "added",
+        severity: "high",
+        message: `new skill ${id}`
+      });
+      continue;
+    }
+    if (before.truncated === true || asset.truncated === true) {
+      drift.push({
+        asset: "skill",
+        id,
+        change: "changed",
+        field: "hash incomplete",
+        severity: "high",
+        message: `skill ${id}: directory too large to hash completely; inspect manually`
+      });
+      continue;
+    }
+    if (before.contentHash !== asset.contentHash || before.path !== asset.path || before.directoryHash !== asset.directoryHash) {
+      const field = before.contentHash !== asset.contentHash ? "content" : before.path !== asset.path ? "path" : "files";
+      drift.push({
+        asset: "skill",
+        id,
+        change: "changed",
+        field,
+        severity: "high",
+        message: `skill ${id}: ${field} changed${(asset.suspicious ?? []).length > 0 ? ` [suspicious: ${(asset.suspicious ?? []).join(", ")}]` : ""}`
+      });
+    }
+  }
+  for (const id of Object.keys(locked.skills)) {
+    if (current.skills[id] === undefined) {
+      drift.push({
+        asset: "skill",
+        id,
+        change: "removed",
+        severity: "low",
+        message: `skill ${id} removed`
+      });
+    }
+  }
+  return drift.sort((a, b) => a.asset.localeCompare(b.asset) || a.id.localeCompare(b.id));
+}
+function audit(locked, current, warnings, compareTools = true) {
+  if (locked === undefined) {
+    return { locked: false, ok: true, drift: [], warnings, assets: current };
+  }
+  const drift = diffAssets(locked, current, compareTools);
+  return {
+    locked: true,
+    ok: drift.length === 0,
+    drift,
+    warnings,
+    assets: current,
+    lockedAssets: locked
+  };
+}
+function formatDrift(drift) {
+  if (drift.length === 0)
+    return "no drift";
+  return drift.map((entry) => {
+    const icon = entry.change === "added" ? "+" : entry.change === "removed" ? "-" : "~";
+    return `${icon} [${entry.severity}] ${entry.message}`;
+  }).join(`
+`);
+}
+function severityCounts(drift) {
+  const output = { high: 0, medium: 0, low: 0 };
+  for (const entry of drift)
+    output[entry.severity] = (output[entry.severity] ?? 0) + 1;
+  return output;
+}
+
+// src/audit.ts
+function filterAssets(assets, include) {
+  return {
+    plugins: include.includes("plugins") ? assets.plugins : {},
+    mcp: include.includes("mcp") ? assets.mcp : {},
+    skills: include.includes("skills") ? assets.skills : {}
+  };
+}
+async function collectStaticAssets(directory, home, options) {
+  const config = await loadProjectConfig(directory);
+  const warnings = [...config.warnings];
+  const plugins = {};
+  for (const ref of config.plugins) {
+    const id = ref.target;
+    const result = await pluginAsset(id, ref, directory, home);
+    if (result.asset !== undefined)
+      plugins[id] = result.asset;
+    if (result.warning !== undefined)
+      warnings.push(result.warning);
+  }
+  const mcp = {};
+  const mcpConfig = options?.includeGlobal === true ? { ...await loadGlobalMcp(home), ...config.mcp } : config.mcp;
+  for (const [name, value] of Object.entries(mcpConfig)) {
+    const asset = mcpConfigAsset(name, value);
+    if (asset !== undefined)
+      mcp[name] = asset;
+  }
+  const include = options?.include ?? ["plugins", "mcp", "skills"];
+  return {
+    assets: filterAssets({ plugins, mcp, skills: await scanSkills(directory) }, include),
+    warnings,
+    files: config.files
+  };
+}
+function mergeRuntimeTools(current, previous) {
+  if (previous === undefined)
+    return current;
+  const mcp = {};
+  for (const [name, asset] of Object.entries(current.mcp)) {
+    const old = previous.assets.mcp[name];
+    mcp[name] = old !== undefined && old.configHash === asset.configHash && old.tools !== undefined ? { ...asset, tools: old.tools, toolsSource: old.toolsSource ?? "runtime" } : asset;
+  }
+  return { ...current, mcp };
+}
+function filterIgnored(drift, patterns) {
+  if (patterns.length === 0)
+    return [...drift];
+  return drift.filter((entry) => {
+    const id = entry.asset === "mcp-tool" ? `${entry.parent}:${entry.id}` : entry.id;
+    return !ignored(id, patterns) && !ignored(`${entry.asset}:${id}`, patterns);
+  });
+}
+function describeAudit(result, verbose = false) {
+  const lines = [];
+  if (!result.locked) {
+    lines.push("No lockfile found. This is an audit only.");
+  } else if (result.ok) {
+    lines.push("Integrity OK: no drift from opencode.lock.json.");
+  } else {
+    const counts = severityCounts(result.drift);
+    lines.push(`Drift detected: ${result.drift.length} change(s) — ${counts.high ?? 0} high, ${counts.medium ?? 0} medium, ${counts.low ?? 0} low.`);
+    lines.push(formatDrift(result.drift));
+  }
+  const pluginCount = Object.keys(result.assets.plugins).length;
+  const mcpCount = Object.keys(result.assets.mcp).length;
+  const toolCount = Object.values(result.assets.mcp).reduce((sum, asset) => sum + Object.keys(asset.tools ?? {}).length, 0);
+  const skillCount = Object.keys(result.assets.skills).length;
+  lines.push(`Assets: ${pluginCount} plugin(s), ${mcpCount} MCP server(s), ${toolCount} MCP tool(s), ${skillCount} skill(s).`);
+  if (verbose) {
+    for (const [id, asset] of Object.entries(result.assets.plugins)) {
+      lines.push(`  plugin ${id}${asset.version === undefined ? "" : `@${asset.version}`} ${asset.files ?? 0} files [${(asset.capabilities ?? []).join(", ") || "no detected capabilities"}]`);
+    }
+    for (const [id, asset] of Object.entries(result.assets.mcp)) {
+      lines.push(`  mcp ${id} (${asset.transport}) ${asset.command ?? asset.url ?? ""}`);
+    }
+    for (const [id, asset] of Object.entries(result.assets.skills)) {
+      lines.push(`  skill ${id} ${asset.bytes} bytes${(asset.suspicious ?? []).length > 0 ? ` suspicious: ${(asset.suspicious ?? []).join(", ")}` : ""}`);
+    }
+  }
+  for (const warning of result.warnings)
+    lines.push(`warning: ${warning}`);
+  return lines.join(`
+`);
+}
+
+// src/options.ts
+import { homedir } from "node:os";
+import { isAbsolute as isAbsolute3, resolve as resolve3 } from "node:path";
+var DEFAULTS = {
+  lockfile: "opencode.lock.json",
+  mode: "warn",
+  include: ["plugins", "mcp", "skills"],
+  ignore: [],
+  includeGlobal: false
+};
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+function stringArray(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function expandPath(value, directory, home = homedir()) {
+  let output = value;
+  if (output === "~")
+    output = home;
+  else if (output.startsWith("~/"))
+    output = resolve3(home, output.slice(2));
+  return isAbsolute3(output) ? resolve3(output) : resolve3(directory, output);
+}
+function parseOptions(raw, directory, home = homedir()) {
+  const input = record(raw);
+  const include = stringArray(input.include).filter((entry) => ["plugins", "mcp", "skills"].includes(entry));
+  const lockfile = typeof input.lockfile === "string" && input.lockfile.trim().length > 0 ? expandPath(input.lockfile, directory, home) : resolve3(directory, DEFAULTS.lockfile);
+  const trace = typeof input.trace === "string" && input.trace.trim().length > 0 ? expandPath(input.trace, directory, home) : undefined;
+  return {
+    lockfile,
+    mode: input.mode === "enforce" ? "enforce" : "warn",
+    include: include.length > 0 ? include : DEFAULTS.include,
+    ignore: stringArray(input.ignore),
+    includeGlobal: input.includeGlobal === true,
+    trace
+  };
+}
+
+// src/policy.ts
+function generatePolicy(assets) {
+  const policies = [];
+  for (const id of Object.keys(assets.mcp).sort()) {
+    policies.push({ action: "mcp.use", resource: id, effect: "allow" });
+  }
+  for (const id of Object.keys(assets.skills).sort()) {
+    policies.push({ action: "skill.use", resource: id, effect: "allow" });
+  }
+  for (const asset of Object.values(assets.plugins)) {
+    const resource = asset.source.startsWith(".") ? asset.source : asset.source.split("@").slice(0, 2).join("@");
+    policies.push({ action: "plugin.use", resource, effect: "allow" });
+  }
+  return { policies };
+}
+
+// src/sarif.ts
+var RULES = [
+  "plugin-changed",
+  "plugin-added",
+  "plugin-removed",
+  "mcp-changed",
+  "mcp-added",
+  "mcp-removed",
+  "mcp-tool-changed",
+  "mcp-tool-added",
+  "mcp-tool-removed",
+  "skill-changed",
+  "skill-added",
+  "skill-removed",
+  "lockfile-missing"
+];
+function ruleID(entry) {
+  const suffix = entry.asset === "mcp-tool" ? `mcp-tool-${entry.change}` : `${entry.asset}-${entry.change}`;
+  return `integrity/${RULES.includes(suffix) ? suffix : "plugin-changed"}`;
+}
+function toSarif(drift, version, lockfile, missingLockfile = false) {
+  return {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "opencode-integrity",
+            informationUri: "https://github.com/Hamza-Abili/opencode-integrity",
+            version,
+            rules: RULES.map((id) => ({ id: `integrity/${id}` }))
+          }
+        },
+        results: [
+          ...missingLockfile ? [
+            {
+              ruleId: "integrity/lockfile-missing",
+              level: "error",
+              message: { text: `no lockfile at ${lockfile}; run integrity lock` },
+              locations: [{ physicalLocation: { artifactLocation: { uri: lockfile } } }]
+            }
+          ] : [],
+          ...drift.map((entry) => ({
+            ruleId: ruleID(entry),
+            level: entry.severity === "high" ? "error" : entry.severity === "medium" ? "warning" : "note",
+            message: { text: entry.message },
+            locations: [{ physicalLocation: { artifactLocation: { uri: lockfile } } }]
+          }))
+        ]
+      }
+    ]
+  };
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/cli.ts
+function parseArgs(argv) {
+  const output = {
+    command: "audit",
+    directory: process.cwd(),
+    home: homedir2(),
+    format: "text",
+    strict: false,
+    ignore: [],
+    includeGlobal: false
+  };
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index] ?? "";
+    const next = () => {
+      index += 1;
+      return argv[index] ?? "";
+    };
+    if (["audit", "lock", "check", "diff", "policy", "version"].includes(arg)) {
+      output.command = arg;
+      continue;
+    }
+    switch (arg) {
+      case "--directory":
+      case "-C":
+        output.directory = resolve4(next());
+        break;
+      case "--home":
+        output.home = resolve4(next());
+        break;
+      case "--lockfile":
+        output.lockfile = next();
+        break;
+      case "--json":
+        output.format = "json";
+        break;
+      case "--format": {
+        const value = next();
+        output.format = value === "json" || value === "sarif" ? value : "text";
+        break;
+      }
+      case "--strict":
+        output.strict = true;
+        break;
+      case "--ignore":
+        output.ignore.push(next());
+        break;
+      case "--include-global":
+        output.includeGlobal = true;
+        break;
+      case "--version":
+      case "-v":
+        output.command = "version";
+        break;
+      default:
+        break;
+    }
+  }
+  return output;
+}
+function usage() {
+  return [
+    "opencode-integrity <audit|lock|check|diff|policy|version> [options]",
+    "",
+    "  audit     show loaded assets and drift (exit 0)",
+    "  lock      write opencode.lock.json from the current project",
+    "  check     compare against the lockfile (exit 1 on drift)",
+    "  diff      print the drift report (exit 0)",
+    "  policy    emit OpenCode policy allow statements from the lockfile",
+    "",
+    "  --directory, -C <path>  project directory (default: cwd)",
+    "  --home <path>           home directory (default: $HOME)",
+    "  --lockfile <path>       lockfile path (default: <project>/opencode.lock.json)",
+    "  --format text|json|sarif",
+    "  --strict                audit exits 1 on drift or an unlocked project",
+    "  --ignore <pattern>      ignore an asset id (repeatable)",
+    "  --include-global        include global MCP config (runtime also plugins/skills)"
+  ].join(`
+`);
+}
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  if (args.command === "version") {
+    console.log(`opencode-integrity ${VERSION}`);
+    return 0;
+  }
+  if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    console.log(usage());
+    return 0;
+  }
+  const options = parseOptions({
+    lockfile: args.lockfile,
+    ignore: args.ignore,
+    includeGlobal: args.includeGlobal,
+    mode: "warn"
+  }, args.directory, args.home);
+  const current = await collectStaticAssets(args.directory, args.home, options);
+  const rawPrevious = await readLockfile(options.lockfile);
+  const previous = rawPrevious === undefined ? undefined : { ...rawPrevious, assets: filterAssets(rawPrevious.assets, options.include) };
+  if (args.command === "lock") {
+    const merged = filterAssets(mergeRuntimeTools(current.assets, previous), options.include);
+    const lockfile = createLockfile(merged, undefined, VERSION);
+    await writeLockfile(options.lockfile, lockfile);
+    if (args.format === "json")
+      console.log(JSON.stringify(lockfile, null, 2));
+    else {
+      console.log(`locked ${options.lockfile}`);
+      console.log(`assets: ${Object.keys(merged.plugins).length} plugin(s), ${Object.keys(merged.mcp).length} MCP server(s), ${Object.keys(merged.skills).length} skill(s)`);
+      const missing = Object.entries(merged.mcp).filter(([, asset]) => Object.keys(asset.tools ?? {}).length === 0).map(([name]) => name);
+      if (missing.length > 0) {
+        console.log(`warning: no runtime MCP tool descriptors for ${missing.join(", ")}; run /integrity lock inside OpenCode to pin tool definitions.`);
+      }
+    }
+    return 0;
+  }
+  if (args.command === "policy") {
+    const assets = previous?.assets ?? current.assets;
+    console.log(JSON.stringify(generatePolicy(assets), null, 2));
+    return 0;
+  }
+  const merged = filterAssets(mergeRuntimeTools(current.assets, previous), options.include);
+  const result = audit(previous?.assets, merged, current.warnings, false);
+  const drift = filterIgnored(result.drift, options.ignore);
+  const final = { ...result, drift, ok: drift.length === 0 };
+  if (args.format === "sarif") {
+    const uri = relative3(args.directory, options.lockfile) || options.lockfile;
+    console.log(JSON.stringify(toSarif(drift, VERSION, uri, !final.locked), null, 2));
+  } else if (args.format === "json") {
+    console.log(JSON.stringify(final, null, 2));
+  } else if (args.command === "diff") {
+    console.log(drift.length === 0 ? "no drift" : formatDrift(drift));
+  } else {
+    console.log(describeAudit(final, args.command === "audit"));
+    if (final.locked && !final.ok) {
+      const counts = severityCounts(drift);
+      console.log(`summary: ${counts.high ?? 0} high, ${counts.medium ?? 0} medium, ${counts.low ?? 0} low`);
+    }
+  }
+  if (args.command === "check")
+    return final.ok && final.locked ? 0 : 1;
+  if (args.command === "audit" && args.strict)
+    return final.ok && final.locked ? 0 : 1;
+  return 0;
+}
+process.exitCode = await main();