ContextLock — Trusted Content Verification for AI Coding Tools

import { hashFilename } from "@contextlock/cli-publisher";

// Produce a hash-protected copy of your file
const result = await hashFilename({
  filePath: "./my-package/SKILL.md",
  hashLength: 16,  // embed first 16 hex chars of SHA-256 (default)
});

console.log(result.hashedPath);    // "./my-package/SKILL.a3f5c9e8d1f24a6c.md"
console.log(result.hash);          // full 64-char SHA-256
console.log(result.embeddedHash);  // "a3f5c9e8d1f24a6c"

import { verifyFilenameHash } from "@contextlock/core";

const check = await verifyFilenameHash("./SKILL.a3f5c9e8d1f24a6c.md");
console.log(check.matches);  // true if content still matches the filename hash
// Note: this is advisory only — it does NOT prove who created the file

import { protect } from "@contextlock/cli-publisher";

const result = await protect({
  directory: "./my-package",
  mode: "hash",
});
// result.filesProtected === 2
// result.hashResults → [{ originalPath, hashedPath, hash, embeddedHash }, ...]

import { protect } from "@contextlock/cli-publisher";

const result = await protect({
  directory: "./my-package",
  mode: "sign",
  packageName: "acme-secure-skills",
  version: 1,                       // monotonic integer (anti-rollback counter)
  displayVersion: "1.0.0",          // human-facing, informational
  publisherName: "Acme Security",
  keyId: "cl-acme-2026",            // short key label (DSSE keyid hint)
});

// If no keypair exists, one is generated automatically:
console.log(result.keyGenerated);                    // true
console.log(result.keyResult!.fingerprint);          // "c8e4b7d5..."
console.log(result.signResult!.envelopePath);        // "./my-package/contextlock.dsse.json"
console.log(result.filesProtected);                  // 2

import { initKey, buildManifest, signManifest, verify } from "@contextlock/cli-publisher";

// 1. Generate Ed25519 keypair (raw 32-byte keys, base64url)
const keys = await initKey({ output: "./keys", keyId: "cl-acme-2026" });
// → keys.privateKeyPath, keys.publicKeyPath, keys.fingerprint, keys.keyId

// 2. Build a contextlock/2 manifest for a package directory
const manifest = await buildManifest({
  directory: "./my-package",
  packageName: "acme-secure-skills",
  version: 1,                        // integer, monotonic
  displayVersion: "1.0.0",
  publisherName: "Acme Security",
  keyId: keys.keyId,
  expiresDays: 365,                  // expires_at is REQUIRED in v2
});
// → contextlock.manifest.json (unsigned intermediate) written to ./my-package

// 3. Sign the manifest into the DSSE envelope
const sig = await signManifest({
  manifestPath: manifest.manifestPath,
  privateKeyPath: keys.privateKeyPath,
});
// → contextlock.dsse.json written alongside (the ONLY artifact you ship)

// 4. Verify before publishing (signature + every file's length, hash, lints)
const result = await verify({ directory: "./my-package" });
// → result.success === true, result.signatureValid === true

import { trustAdd, trustList, userVerify, trustRevoke, install, inspect } from "@contextlock/cli-user";

// 1. Trust a publisher by their public key
await trustAdd({
  publicKeyPath: "./acme-public.key",
  publisherName: "Acme Security",
  keyId: "cl-acme-2026",            // optional label; defaults to cl-<fp8>
  trustStorePath: "./truststore.json",
});

// 2. List trusted publishers
const { publishers } = await trustList({ trustStorePath: "./truststore.json" });
// → [{ publisher: "Acme Security", key_id: "cl-acme-2026", fingerprint: "c8e4b7..." }]

// 3. Install a downloaded package: verify EVERYTHING, then place files (Layer 1)
const installed = await install({
  source: "./downloads/acme-secure-skills",
  dest: "./.claude/skills/acme-secure-skills",
  trustStorePath: "./truststore.json",
});
// → installed.installed === true, or nothing was written at all

// 4. Verify a file in place
const result = await userVerify({
  filePath: "./my-package/SKILL.md",
  trustStorePath: "./truststore.json",
});
// → result.result.status === "trusted"
// → result.displayMessage === "✓ ./my-package/SKILL.md — trusted (publisher: Acme Security, key: cl-acme-2026)"

// 5. Inspect an envelope payload (pretty-print; does NOT verify)
const inspected = await inspect({ envelopePath: "./my-package/contextlock.dsse.json" });

// 6. Revoke a compromised key (by label or fingerprint)
await trustRevoke({
  keyId: "cl-acme-2026",
  trustStorePath: "./truststore.json",
});

import { hashFilename } from "@contextlock/cli-publisher";

// Just hash-protect each file — done in seconds
const skill = await hashFilename({ filePath: "./my-package/SKILL.md" });
const rules = await hashFilename({ filePath: "./my-package/RULES.md" });

console.log(skill.hashedPath);  // ./my-package/SKILL.a3f5c9e8d1f24a6c.md
console.log(rules.hashedPath);  // ./my-package/RULES.7b2e1df4c8a93b50.md

// Distribute these files. Users can verify integrity by checking the hash in the name.
// But this does NOT prove you are the publisher.

import { protect, verify } from "@contextlock/cli-publisher";
import { writeFile, mkdir } from "node:fs/promises";

// Setup: create a sample package
await mkdir("./demo-package", { recursive: true });
await writeFile("./demo-package/SKILL.md", `# Code Review Skill
You are an expert code reviewer. Focus on security, performance, and readability.
Always explain your reasoning.`, "utf-8");

await writeFile("./demo-package/RULES.md", `# Rules
1. Never approve code with known vulnerabilities.
2. Flag any hardcoded credentials.
3. Suggest tests for untested code paths.`, "utf-8");

// One command does it all: generates keys, builds the manifest, signs the envelope
const result = await protect({
  directory: "./demo-package",
  mode: "sign",
  packageName: "code-review-skills",
  version: 1,
  displayVersion: "1.0.0",
  publisherName: "YourName",
});

console.log(`Protected ${result.filesProtected} files`);
if (result.keyGenerated) {
  console.log(`Generated keypair — fingerprint: ${result.keyResult!.fingerprint}`);
  console.log(`Share your public key: ${result.keyResult!.publicKeyPath}`);
}
console.log(`Envelope: ${result.signResult!.envelopePath}`);

// Verify everything is correct before distributing
const check = await verify({ directory: "./demo-package" });
console.log(`Pre-publish check: ${check.success ? "PASS" : "FAIL"}`);
for (const f of check.fileResults) {
  console.log(`  ${f.status === "ok" ? "✓" : "✗"} ${f.path}`);
}

// Distribute: ./demo-package/ now contains:
//   SKILL.md, RULES.md, contextlock.dsse.json
//   Share contextlock-public.key separately (website, README, key server)

import { trustAdd, userVerify, trustList } from "@contextlock/cli-user";

// Step 1: Add the publisher's public key to your trust store
// (You got the public key file from the publisher's website or docs)
const addResult = await trustAdd({
  publicKeyPath: "./downloaded/contextlock-public.key",
  publisherName: "Acme Security",
  trustStorePath: "./my-truststore.json",
});
console.log(`Trusted: ${addResult.publisherName} (${addResult.fingerprint})`);

// Step 2: Confirm your trust store
const { publishers } = await trustList({ trustStorePath: "./my-truststore.json" });
for (const p of publishers) {
  console.log(`  ${p.publisher} — ${p.fingerprint}`);
}

// Step 3: Verify a file from the downloaded package
const result = await userVerify({
  filePath: "./downloaded/acme-skills/SKILL.md",
  trustStorePath: "./my-truststore.json",
});
console.log(result.displayMessage);
// ✓ ./downloaded/acme-skills/SKILL.md — trusted (publisher: Acme Security, key: c8e4b7...)

// Step 4: What happens if someone tampered with the file?
// (Simulate: edit SKILL.md, then verify again)
const tampered = await userVerify({
  filePath: "./downloaded/acme-skills/SKILL.md",
  trustStorePath: "./my-truststore.json",
});
console.log(tampered.displayMessage);
// ✗ ./downloaded/acme-skills/SKILL.md — modified (expected: a3f5c9..., computed: 7b2e1d...)

import { ClaudeCodeAdapter, formatBlockMessage } from "@contextlock/adapter-claude-code";
import { trustAdd } from "@contextlock/cli-user";
import type { VerificationResult } from "@contextlock/core";

// Step 1: Set up trust store with approved publishers
await trustAdd({
  publicKeyPath: "./keys/acme-public.key",
  publisherName: "Acme Security",
  trustStorePath: "./team-truststore.json",
  policy: {
    default_action: "block",           // strict for this publisher
    allow_expired_manifest: false,
    allow_offline_cached_manifest: true,
  },
});

await trustAdd({
  publicKeyPath: "./keys/internal-public.key",
  publisherName: "Internal Team",
  trustStorePath: "./team-truststore.json",
  policy: {
    default_action: "warn",            // more lenient for internal
    allow_expired_manifest: true,
    allow_offline_cached_manifest: true,
  },
});

// Step 2: Create adapter with team policy
const adapter = new ClaudeCodeAdapter({
  trustStorePath: "./team-truststore.json",
  cachePath: "./tcv-cache.json",
  policyLevel: "balanced",  // team default: balanced
});

// Step 3: Intercept file loads (this is what the adapter does automatically)
async function onFileLoad(filePath: string) {
  const decision = await adapter.onFileLoad(filePath);

  switch (decision) {
    case "allow":
      console.log(`✓ Loading ${filePath}`);
      break;
    case "warn":
      console.log(`⚠ ${filePath} is unverified — proceed with caution`);
      break;
    case "block": {
      const status = await adapter.getVerificationStatus(filePath);
      console.log(formatBlockMessage(filePath, status));
      break;
    }
  }

  return decision;
}

// Demo: simulate file load events
await onFileLoad("./project/SKILL.md");      // ✓ trusted → allow
await onFileLoad("./project/RULES.md");      // ✗ modified → block
await onFileLoad("./project/README.md");     // not protected → allow
await onFileLoad("./unknown/SKILL.md");      // unknown signer → warn

import { ClaudeCodeAdapter, formatBlockMessage } from "@contextlock/adapter-claude-code";

const adapter = new ClaudeCodeAdapter({
  trustStorePath: "/path/to/tcv-truststore.json",
  cachePath: "/path/to/tcv-cache.json",
  policyLevel: "balanced",  // "strict" | "balanced" | "audit"
});

// Before loading any protected file, check the policy decision
async function beforeFileLoad(filePath: string): Promise<boolean> {
  const decision = await adapter.onFileLoad(filePath);

  if (decision === "block") {
    const result = await adapter.getVerificationStatus(filePath);
    const message = formatBlockMessage(filePath, result);
    // Display message to user, prevent file from being loaded
    console.error(message);
    return false;
  }

  if (decision === "warn") {
    const result = await adapter.getVerificationStatus(filePath);
    // Show warning, let user decide
    console.warn(`⚠ Unverified: ${filePath} — ${result.reason}`);
    // Return true to allow with warning, or false to block
    return true;
  }

  // "allow" or "audit" — proceed
  return true;
}

// claude-code-plugin.ts
import { ClaudeCodeAdapter, formatBlockMessage } from "@contextlock/adapter-claude-code";

const adapter = new ClaudeCodeAdapter({
  trustStorePath: `${process.env.HOME}/.contextlock/truststore.json`,
  cachePath: `${process.env.HOME}/.contextlock/cache.json`,
  policyLevel: "balanced",
});

/**
 * Called by Claude Code before loading any instruction file.
 * Returns the file content if allowed, or null if blocked.
 */
export async function verifyAndLoad(filePath: string): Promise<string | null> {
  const decision = await adapter.onFileLoad(filePath);

  if (decision === "block") {
    const status = await adapter.getVerificationStatus(filePath);
    console.error(formatBlockMessage(filePath, status));
    return null;
  }

  if (decision === "warn") {
    const status = await adapter.getVerificationStatus(filePath);
    console.warn(`[ContextLock] Warning: ${filePath} — ${status.reason ?? status.status}`);
  }

  // File is allowed — read and return content
  const { readFile } = await import("node:fs/promises");
  return readFile(filePath, "utf-8");
}

/**
 * Verify all protected files in a project directory at startup.
 */
export async function verifyProject(projectDir: string): Promise<void> {
  const { findProtectedFiles, DEFAULT_PATTERNS } = await import("@contextlock/core");
  const files = await findProtectedFiles(projectDir, DEFAULT_PATTERNS);

  for (const file of files) {
    const fullPath = `${projectDir}/${file}`;
    const decision = await adapter.onFileLoad(fullPath);
    const status = await adapter.getVerificationStatus(fullPath);

    switch (status.status) {
      case "trusted":
        console.log(`  ✓ ${file} — ${status.publisher}`);
        break;
      case "modified":
        console.error(`  ✗ ${file} — MODIFIED (blocked)`);
        break;
      case "untrusted":
        console.warn(`  ? ${file} — unverified`);
        break;
      default:
        console.warn(`  ! ${file} — ${status.status}: ${status.reason}`);
    }
  }
}

import { OpenClawAdapter, formatBlockMessage } from "@contextlock/adapter-openclaw";

const adapter = new OpenClawAdapter({
  trustStorePath: "/path/to/tcv-truststore.json",
  cachePath: "/path/to/tcv-cache.json",
  policyLevel: "strict",  // OpenClaw may prefer stricter defaults
});

// openclaw-plugin.ts
import { OpenClawAdapter, formatBlockMessage } from "@contextlock/adapter-openclaw";

const adapter = new OpenClawAdapter({
  trustStorePath: `${process.env.HOME}/.contextlock/truststore.json`,
  cachePath: `${process.env.HOME}/.contextlock/cache.json`,
  policyLevel: "strict",
});

/**
 * OpenClaw file load interceptor.
 * Register this as a middleware in OpenClaw's file loading pipeline.
 */
export async function openclawFileMiddleware(
  filePath: string,
  next: () => Promise<string>,
): Promise<string> {
  const decision = await adapter.onFileLoad(filePath);

  if (decision === "block") {
    const status = await adapter.getVerificationStatus(filePath);
    throw new Error(formatBlockMessage(filePath, status));
  }

  if (decision === "warn") {
    const status = await adapter.getVerificationStatus(filePath);
    console.warn(`[ContextLock] ${filePath}: ${status.status} — ${status.reason ?? "unverified"}`);
  }

  return next();
}

/**
 * Verify all skill files before an OpenClaw agent session starts.
 */
export async function preSessionVerification(skillDir: string): Promise<{
  verified: string[];
  blocked: string[];
  warnings: string[];
}> {
  const { findProtectedFiles, DEFAULT_PATTERNS } = await import("@contextlock/core");
  const files = await findProtectedFiles(skillDir, DEFAULT_PATTERNS);

  const verified: string[] = [];
  const blocked: string[] = [];
  const warnings: string[] = [];

  for (const file of files) {
    const fullPath = `${skillDir}/${file}`;
    const result = await adapter.getVerificationStatus(fullPath);

    switch (result.status) {
      case "trusted":
        verified.push(file);
        break;
      case "modified":
      case "revoked":
      case "error":
        blocked.push(file);
        break;
      default:
        warnings.push(file);
    }
  }

  return { verified, blocked, warnings };
}

// extension.ts
import * as vscode from "vscode";
import {
  VerificationEngine,
  evaluatePolicy,
  DEFAULT_PATTERNS,
  isProtectedFile,
} from "@contextlock/core";
import type { VerificationEngineConfig, PolicyLevel } from "@contextlock/core";

let engine: VerificationEngine;

export function activate(context: vscode.ExtensionContext) {
  const config = vscode.workspace.getConfiguration("contextlock");
  const trustStorePath = config.get<string>("trustStorePath",
    `${process.env.HOME}/.contextlock/truststore.json`);
  const policyLevel = config.get<PolicyLevel>("policyLevel", "balanced");

  const engineConfig: VerificationEngineConfig = {
    trustStorePath,
    cachePath: `${context.globalStorageUri.fsPath}/tcv-cache.json`,
    protectedPatterns: DEFAULT_PATTERNS,
    policyLevel,
  };

  engine = new VerificationEngine(engineConfig);

  // Register file system watcher for protected files
  const watcher = vscode.workspace.createFileSystemWatcher("**/*.md");

  watcher.onDidChange(async (uri) => {
    if (isProtectedFile(uri.fsPath, DEFAULT_PATTERNS)) {
      await verifyAndNotify(uri.fsPath, policyLevel);
    }
  });

  // Register manual verify command
  const verifyCmd = vscode.commands.registerCommand(
    "contextlock.verifyFile",
    async () => {
      const editor = vscode.window.activeTextEditor;
      if (!editor) return;
      await verifyAndNotify(editor.document.uri.fsPath, policyLevel);
    },
  );

  // Register verify-all command
  const verifyAllCmd = vscode.commands.registerCommand(
    "contextlock.verifyAll",
    async () => {
      await verifyWorkspace(policyLevel);
    },
  );

  // Status bar item showing verification state
  const statusBar = vscode.window.createStatusBarItem(
    vscode.StatusBarAlignment.Right, 100,
  );
  statusBar.command = "contextlock.verifyFile";
  statusBar.show();

  // Update status bar when active editor changes
  vscode.window.onDidChangeActiveTextEditor(async (editor) => {
    if (!editor) {
      statusBar.hide();
      return;
    }
    const filePath = editor.document.uri.fsPath;
    if (!isProtectedFile(filePath, DEFAULT_PATTERNS)) {
      statusBar.hide();
      return;
    }
    const result = await engine.verify(filePath);
    switch (result.status) {
      case "trusted":
        statusBar.text = "$(shield) TCV: Trusted";
        statusBar.backgroundColor = undefined;
        break;
      case "modified":
        statusBar.text = "$(shield) TCV: Modified";
        statusBar.backgroundColor = new vscode.ThemeColor(
          "statusBarItem.errorBackground",
        );
        break;
      case "untrusted":
        statusBar.text = "$(shield) TCV: Untrusted";
        statusBar.backgroundColor = new vscode.ThemeColor(
          "statusBarItem.warningBackground",
        );
        break;
      default:
        statusBar.text = `$(shield) TCV: ${result.status}`;
        statusBar.backgroundColor = new vscode.ThemeColor(
          "statusBarItem.warningBackground",
        );
    }
    statusBar.show();
  });

  context.subscriptions.push(watcher, verifyCmd, verifyAllCmd, statusBar);
}

async function verifyAndNotify(filePath: string, policyLevel: PolicyLevel) {
  const result = await engine.verify(filePath);
  const decision = evaluatePolicy({
    level: policyLevel,
    verificationResult: result,
  });

  switch (decision) {
    case "allow":
      vscode.window.showInformationMessage(
        `✓ ${filePath}: Verified — ${result.publisher} (${result.keyId?.slice(0, 12)}...)`,
      );
      break;
    case "warn":
      vscode.window.showWarningMessage(
        `⚠ ${filePath}: ${result.status} — ${result.reason ?? "unverified"}`,
      );
      break;
    case "block":
      vscode.window.showErrorMessage(
        `✗ ${filePath}: BLOCKED — ${result.reason ?? result.status}`,
      );
      break;
  }
}

async function verifyWorkspace(policyLevel: PolicyLevel) {
  const folders = vscode.workspace.workspaceFolders;
  if (!folders) return;

  const { findProtectedFiles } = await import("@contextlock/core");
  const results: string[] = [];

  for (const folder of folders) {
    const files = await findProtectedFiles(folder.uri.fsPath, DEFAULT_PATTERNS);
    for (const file of files) {
      const fullPath = `${folder.uri.fsPath}/${file}`;
      const result = await engine.verify(fullPath);
      const icon = result.status === "trusted" ? "✓" : result.status === "modified" ? "✗" : "?";
      results.push(`${icon} ${file} — ${result.status}`);
    }
  }

  const panel = vscode.window.createOutputChannel("ContextLock");
  panel.clear();
  panel.appendLine("ContextLock Verification Report");
  panel.appendLine("=".repeat(40));
  for (const line of results) {
    panel.appendLine(line);
  }
  panel.show();
}

// In your VS Code extension, add this pattern:
const COPILOT_PATTERNS = [
  ...DEFAULT_PATTERNS,
  "**/.github/copilot-instructions.md",
];

const adapter = new ClaudeCodeAdapter({
  trustStorePath: "~/.contextlock/truststore.json",
  cachePath: "~/.contextlock/cache.json",
  policyLevel: "balanced",
  protectedPatterns: COPILOT_PATTERNS,
});

// contextlock-mcp-server.ts
// Expose verification as MCP tools that any compatible AI assistant can call

import { VerificationEngine, DEFAULT_PATTERNS, TrustStore } from "@contextlock/core";

// Tool: verify_file
// Input: { filePath: string }
// Output: { status, publisher, keyId, reason }
async function verifyFile(args: { filePath: string }) {
  const engine = new VerificationEngine({
    trustStorePath: "~/.contextlock/truststore.json",
    cachePath: "~/.contextlock/cache.json",
    protectedPatterns: DEFAULT_PATTERNS,
    policyLevel: "balanced",
  });

  const result = await engine.verify(args.filePath);
  return {
    status: result.status,
    publisher: result.publisher,
    keyId: result.keyId,
    reason: result.reason,
    fileHash: result.fileHash,
    expectedHash: result.expectedHash,
  };
}

// Tool: list_trusted_publishers
// Input: {}
// Output: { publishers: [...] }
async function listTrustedPublishers() {
  const store = new TrustStore();
  await store.load("~/.contextlock/truststore.json");
  return {
    publishers: store.listPublishers().map((p) => ({
      name: p.publisher,
      keyId: p.key_id,
      fingerprint: p.fingerprint,
      revoked: p.revoked,
    })),
  };
}

// Tool: is_protected
// Input: { filePath: string }
// Output: { protected: boolean }
function isFileProtected(args: { filePath: string }) {
  const engine = new VerificationEngine({
    trustStorePath: "~/.contextlock/truststore.json",
    cachePath: "~/.contextlock/cache.json",
    protectedPatterns: DEFAULT_PATTERNS,
    policyLevel: "balanced",
  });
  return { protected: engine.isProtected(args.filePath) };
}