Clawsec Nanoclaw

-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAS7nijfMcUoOBCj4yOXJX+GYGv2pFl2Yaha1P4v5Cm6A=
-----END PUBLIC KEY-----

/**
 * File Integrity Monitor for NanoClaw
 *
 * TypeScript port of ClawSec's soul-guardian with NanoClaw-specific adaptations.
 *
 * Key Features:
 * - SHA-256 baseline tracking for protected files
 * - Drift detection with unified diff generation
 * - Auto-restore for critical files (with quarantine)
 * - Hash-chained tamper-evident audit log
 * - Per-file policy (restore/alert/ignore modes)
 *
 * Security Model:
 * - Baselines stored on host only (containers access via IPC)
 * - Atomic file operations for restores
 * - Refuses to operate on symlinks
 * - Hash-chained audit log prevents tampering
 */

import fs from 'fs';
import path from 'path';
import crypto from 'crypto';
// glob is available when running in the NanoClaw host environment.
// For type checking in the clawsec repo, we declare a minimal interface.
// eslint-disable-next-line @typescript-eslint/no-namespace
declare namespace glob {
  function sync(pattern: string, options?: { nodir?: boolean }): string[];
}

// ============================================================================
// Types
// ============================================================================

export interface PolicyTarget {
  path?: string;
  pattern?: string;
  mode: 'restore' | 'alert' | 'ignore';
  priority: 'critical' | 'high' | 'medium' | 'low';
  description: string;
}

export interface Policy {
  version: number;
  description: string;
  nanoclaw_version: string;
  targets: PolicyTarget[];
  notes?: string[];
}

export interface FileBaseline {
  sha256: string;
  approved_at: string;
  approved_by: string;
  mode: 'restore' | 'alert' | 'ignore';
  priority: string;
}

export interface BaselinesManifest {
  schema_version: string;
  algorithm: 'sha256';
  created_at: string;
  files: Record<string, FileBaseline>;
}

export interface AuditEntry {
  ts: string;
  event: 'init' | 'drift' | 'restore' | 'approve' | 'error';
  actor: string;
  note?: string;
  path: string;
  mode?: string;
  expected_sha?: string;
  found_sha?: string;
  patch_path?: string;
  quarantine_path?: string;
  error?: string;
  chain?: {
    prev: string;
    hash: string;
  };
}

export interface DriftedFile {
  path: string;
  mode: 'restore' | 'alert';
  expected_sha: string;
  found_sha: string;
  patch_path: string;
  restored: boolean;
  quarantine_path?: string;
  error?: string;
}

export interface CheckResult {
  success: boolean;
  timestamp: string;
  drift_detected: boolean;
  files: Array<{
    path: string;
    status: 'ok' | 'drifted' | 'restored' | 'error';
    mode: string;
    expected_sha?: string;
    found_sha?: string;
    patch_path?: string;
    quarantine_path?: string;
    error?: string;
  }>;
  summary: {
    total: number;
    ok: number;
    drifted: number;
    restored: number;
    alerted: number;
    errors: number;
  };
}

export interface IntegrityMonitorOptions {
  policyPath: string;
  stateDir: string;
}

// ============================================================================
// Constants
// ============================================================================

const CHAIN_GENESIS = '0'.repeat(64);

// ============================================================================
// Utility Functions
// ============================================================================

function utcNowIso(): string {
  return new Date().toISOString();
}

function sha256Hex(data: Buffer | string): string {
  const hash = crypto.createHash('sha256');
  hash.update(data);
  return hash.digest('hex');
}

function sha256File(filePath: string): string {
  const data = fs.readFileSync(filePath);
  return sha256Hex(data);
}

function isSymlink(filePath: string): boolean {
  try {
    const stats = fs.lstatSync(filePath);
    return stats.isSymbolicLink();
  } catch {
    return false;
  }
}

function refuseSymlink(filePath: string): void {
  if (isSymlink(filePath)) {
    throw new Error(`Refusing to operate on symlink: ${filePath}`);
  }
}

function ensureDir(dirPath: string): void {
  fs.mkdirSync(dirPath, { recursive: true });
}

function atomicWrite(filePath: string, data: string | Buffer): void {
  ensureDir(path.dirname(filePath));
  const tmpPath = `${filePath}.tmp.${Date.now()}`;
  fs.writeFileSync(tmpPath, data);
  fs.renameSync(tmpPath, filePath);
}

function unifiedDiff(oldText: string, newText: string, oldLabel: string, newLabel: string): string {
  // Simple unified diff implementation
  const oldLines = oldText.split('\n');
  const newLines = newText.split('\n');

  const lines: string[] = [];
  lines.push(`--- ${oldLabel}`);
  lines.push(`+++ ${newLabel}`);
  lines.push(`@@ -1,${oldLines.length} +1,${newLines.length} @@`);

  for (let i = 0; i < Math.max(oldLines.length, newLines.length); i++) {
    if (i < oldLines.length && i < newLines.length) {
      if (oldLines[i] !== newLines[i]) {
        lines.push(`-${oldLines[i]}`);
        lines.push(`+${newLines[i]}`);
      } else {
        lines.push(` ${oldLines[i]}`);
      }
    } else if (i < oldLines.length) {
      lines.push(`-${oldLines[i]}`);
    } else {
      lines.push(`+${newLines[i]}`);
    }
  }

  return lines.join('\n');
}

function safePatchTag(tag: string): string {
  return tag.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 40) || 'patch';
}

// ============================================================================
// Integrity Monitor Class
// ============================================================================

export class IntegrityMonitor {
  private policyPath: string;
  private stateDir: string;
  private baselinesPath: string;
  private auditPath: string;
  private approvedDir: string;
  private patchesDir: string;
  private quarantineDir: string;

  private policy: Policy | null = null;
  private baselines: BaselinesManifest | null = null;

  constructor(options: IntegrityMonitorOptions) {
    this.policyPath = options.policyPath;
    this.stateDir = options.stateDir;
    this.baselinesPath = path.join(this.stateDir, 'baselines.json');
    this.auditPath = path.join(this.stateDir, 'audit.jsonl');
    this.approvedDir = path.join(this.stateDir, 'approved');
    this.patchesDir = path.join(this.stateDir, 'patches');
    this.quarantineDir = path.join(this.stateDir, 'quarantine');
  }

  // --------------------------------------------------------------------------
  // Initialization
  // --------------------------------------------------------------------------

  async init(actor: string = 'system', note: string = 'initial baseline'): Promise<void> {
    ensureDir(this.stateDir);
    ensureDir(this.approvedDir);
    ensureDir(this.patchesDir);
    ensureDir(this.quarantineDir);

    // Load policy
    this.policy = this.loadPolicy();

    // Load or create baselines
    this.baselines = this.loadBaselines();

    // Resolve targets and initialize missing baselines
    const targets = this.resolveTargets();
    let initialized = false;

    for (const target of targets) {
      if (target.mode === 'ignore') continue;

      try {
        if (!fs.existsSync(target.path)) continue;

        refuseSymlink(target.path);

        // Check if already has baseline
        if (this.baselines.files[target.path]) continue;

        // Create baseline
        const sha = sha256File(target.path);
        const snapshot = path.join(this.approvedDir, path.basename(target.path));
        fs.copyFileSync(target.path, snapshot);

        this.baselines.files[target.path] = {
          sha256: sha,
          approved_at: utcNowIso(),
          approved_by: actor,
          mode: target.mode,
          priority: target.priority
        };

        this.appendAudit({
          ts: utcNowIso(),
          event: 'init',
          actor,
          note,
          path: target.path,
          mode: target.mode,
          expected_sha: sha
        });

        initialized = true;
      } catch (error) {
        console.error(`Failed to initialize baseline for ${target.path}:`, error);
      }
    }

    if (initialized) {
      this.saveBaselines();
    }
  }

  // --------------------------------------------------------------------------
  // Policy Management
  // --------------------------------------------------------------------------

  private loadPolicy(): Policy {
    const raw = fs.readFileSync(this.policyPath, 'utf-8');
    return JSON.parse(raw);
  }

  private resolveTargets(): Array<{ path: string; mode: 'restore' | 'alert' | 'ignore'; priority: string }> {
    if (!this.policy) throw new Error('Policy not loaded');

    const targets: Array<{ path: string; mode: 'restore' | 'alert' | 'ignore'; priority: string }> = [];

    for (const target of this.policy.targets) {
      if (target.path) {
        // Direct path
        targets.push({
          path: path.resolve(target.path),
          mode: target.mode,
          priority: target.priority
        });
      } else if (target.pattern) {
        // Glob pattern
        try {
          const matches = glob.sync(target.pattern, { nodir: true });
          for (const match of matches) {
            targets.push({
              path: path.resolve(match),
              mode: target.mode,
              priority: target.priority
            });
          }
        } catch (error) {
          console.error(`Failed to expand pattern ${target.pattern}:`, error);
        }
      }
    }

    return targets;
  }

  private normalizeBaselines(manifest: BaselinesManifest): BaselinesManifest {
    const normalizedFiles: Record<string, FileBaseline> = {};
    for (const [filePath, baseline] of Object.entries(manifest.files || {})) {
      normalizedFiles[path.resolve(filePath)] = baseline;
    }

    return {
      ...manifest,
      files: normalizedFiles,
    };
  }

  // --------------------------------------------------------------------------
  // Baseline Management
  // --------------------------------------------------------------------------

  private loadBaselines(): BaselinesManifest {
    if (fs.existsSync(this.baselinesPath)) {
      const raw = fs.readFileSync(this.baselinesPath, 'utf-8');
      return this.normalizeBaselines(JSON.parse(raw));
    }

    return {
      schema_version: '1',
      algorithm: 'sha256',
      created_at: utcNowIso(),
      files: {}
    };
  }

  private saveBaselines(): void {
    const data = JSON.stringify(this.baselines, null, 2);
    atomicWrite(this.baselinesPath, data);
  }

  // --------------------------------------------------------------------------
  // Audit Log with Hash Chaining
  // --------------------------------------------------------------------------

  private getLastAuditHash(): string {
    if (!fs.existsSync(this.auditPath)) {
      return CHAIN_GENESIS;
    }

    const content = fs.readFileSync(this.auditPath, 'utf-8');
    const lines = content.trim().split('\n').filter(l => l.trim());

    if (lines.length === 0) {
      return CHAIN_GENESIS;
    }

    try {
      const lastEntry = JSON.parse(lines[lines.length - 1]);
      return lastEntry.chain?.hash || CHAIN_GENESIS;
    } catch {
      return CHAIN_GENESIS;
    }
  }

  private appendAudit(entry: Omit<AuditEntry, 'chain'>): void {
    ensureDir(path.dirname(this.auditPath));

    const prevHash = this.getLastAuditHash();

    // Compute current hash
    const entryWithoutChain = { ...entry };
    const payload = prevHash + '\n' + JSON.stringify(entryWithoutChain, Object.keys(entryWithoutChain).sort());
    const currentHash = sha256Hex(payload);

    const record: AuditEntry = {
      ...entry,
      chain: {
        prev: prevHash,
        hash: currentHash
      }
    };

    fs.appendFileSync(this.auditPath, JSON.stringify(record) + '\n');
  }

  // --------------------------------------------------------------------------
  // Drift Detection
  // --------------------------------------------------------------------------

  async checkIntegrity(autoRestore: boolean = true, actor: string = 'agent'): Promise<CheckResult> {
    if (!this.baselines) {
      throw new Error('Baselines not loaded. Call init() first.');
    }

    const result: CheckResult = {
      success: true,
      timestamp: utcNowIso(),
      drift_detected: false,
      files: [],
      summary: {
        total: 0,
        ok: 0,
        drifted: 0,
        restored: 0,
        alerted: 0,
        errors: 0
      }
    };

    for (const [filePath, baseline] of Object.entries(this.baselines.files)) {
      result.summary.total++;

      try {
        if (!fs.existsSync(filePath)) {
          result.files.push({
            path: filePath,
            status: 'error',
            mode: baseline.mode,
            error: 'File not found'
          });
          result.summary.errors++;

          this.appendAudit({
            ts: utcNowIso(),
            event: 'error',
            actor,
            path: filePath,
            error: 'File not found'
          });

          continue;
        }

        refuseSymlink(filePath);

        const currentSha = sha256File(filePath);

        if (currentSha === baseline.sha256) {
          // No drift
          result.files.push({
            path: filePath,
            status: 'ok',
            mode: baseline.mode,
            expected_sha: baseline.sha256,
            found_sha: currentSha
          });
          result.summary.ok++;
          continue;
        }

        // Drift detected
        result.drift_detected = true;
        result.summary.drifted++;

        // Generate diff
        const snapshot = path.join(this.approvedDir, path.basename(filePath));
        const oldText = fs.existsSync(snapshot) ? fs.readFileSync(snapshot, 'utf-8') : '';
        const newText = fs.readFileSync(filePath, 'utf-8');
        const diff = unifiedDiff(oldText, newText, `approved/${path.basename(filePath)}`, path.basename(filePath));

        const patchPath = path.join(
          this.patchesDir,
          `${new Date().toISOString().replace(/[:.]/g, '-')}-drift-${safePatchTag(path.basename(filePath))}.patch`
        );
        fs.writeFileSync(patchPath, diff);

        this.appendAudit({
          ts: utcNowIso(),
          event: 'drift',
          actor,
          path: filePath,
          mode: baseline.mode,
          expected_sha: baseline.sha256,
          found_sha: currentSha,
          patch_path: patchPath
        });

        // Handle based on mode
        if (baseline.mode === 'restore' && autoRestore) {
          // Auto-restore
          try {
            const quarantinePath = path.join(
              this.quarantineDir,
              `${safePatchTag(path.basename(filePath))}.${Date.now()}.quarantine`
            );
            fs.copyFileSync(filePath, quarantinePath);

            if (fs.existsSync(snapshot)) {
              atomicWrite(filePath, fs.readFileSync(snapshot));
            }

            this.appendAudit({
              ts: utcNowIso(),
              event: 'restore',
              actor,
              path: filePath,
              mode: baseline.mode,
              quarantine_path: quarantinePath
            });

            result.files.push({
              path: filePath,
              status: 'restored',
              mode: baseline.mode,
              expected_sha: baseline.sha256,
              found_sha: currentSha,
              patch_path: patchPath,
              quarantine_path: quarantinePath
            });
            result.summary.restored++;
          } catch (error) {
            result.files.push({
              path: filePath,
              status: 'error',
              mode: baseline.mode,
              expected_sha: baseline.sha256,
              found_sha: currentSha,
              patch_path: patchPath,
              error: `Restore failed: ${error instanceof Error ? error.message : String(error)}`
            });
            result.summary.errors++;
          }
        } else {
          // Alert only
          result.files.push({
            path: filePath,
            status: 'drifted',
            mode: baseline.mode,
            expected_sha: baseline.sha256,
            found_sha: currentSha,
            patch_path: patchPath
          });
          result.summary.alerted++;
        }

      } catch (error) {
        result.files.push({
          path: filePath,
          status: 'error',
          mode: baseline.mode,
          error: error instanceof Error ? error.message : String(error)
        });
        result.summary.errors++;

        this.appendAudit({
          ts: utcNowIso(),
          event: 'error',
          actor,
          path: filePath,
          error: error instanceof Error ? error.message : String(error)
        });
      }
    }

    return result;
  }

  // --------------------------------------------------------------------------
  // Approve Changes
  // --------------------------------------------------------------------------

  async approveChange(filePath: string, actor: string, note: string = ''): Promise<void> {
    if (!this.baselines) {
      throw new Error('Baselines not loaded');
    }

    const normalizedFilePath = path.resolve(filePath);

    if (!fs.existsSync(normalizedFilePath)) {
      throw new Error(`File not found: ${normalizedFilePath}`);
    }

    refuseSymlink(normalizedFilePath);

    const targets = this.resolveTargets();
    const target = targets.find(t => t.path === normalizedFilePath);
    if (!target || target.mode === 'ignore') {
      throw new Error(`File ${normalizedFilePath} not in policy`);
    }

    const previousSha = this.baselines.files[normalizedFilePath]?.sha256;
    const currentSha = sha256File(normalizedFilePath);

    // Generate diff
    const snapshot = path.join(this.approvedDir, path.basename(normalizedFilePath));
    const oldText = fs.existsSync(snapshot) ? fs.readFileSync(snapshot, 'utf-8') : '';
    const newText = fs.readFileSync(normalizedFilePath, 'utf-8');
    const diff = unifiedDiff(
      oldText,
      newText,
      `approved/${path.basename(normalizedFilePath)}`,
      path.basename(normalizedFilePath)
    );

    const patchPath = path.join(
      this.patchesDir,
      `${new Date().toISOString().replace(/[:.]/g, '-')}-approve-${safePatchTag(path.basename(normalizedFilePath))}.patch`
    );
    fs.writeFileSync(patchPath, diff);

    // Update baseline
    if (!this.baselines.files[normalizedFilePath]) {
      this.baselines.files[normalizedFilePath] = {
        sha256: currentSha,
        approved_at: utcNowIso(),
        approved_by: actor,
        mode: target.mode,
        priority: target.priority
      };
    } else {
      this.baselines.files[normalizedFilePath].sha256 = currentSha;
      this.baselines.files[normalizedFilePath].approved_at = utcNowIso();
      this.baselines.files[normalizedFilePath].approved_by = actor;
    }

    // Update snapshot
    fs.copyFileSync(normalizedFilePath, snapshot);

    // Save and audit
    this.saveBaselines();

    this.appendAudit({
      ts: utcNowIso(),
      event: 'approve',
      actor,
      note,
      path: normalizedFilePath,
      expected_sha: previousSha,
      found_sha: currentSha,
      patch_path: patchPath
    });
  }

  // --------------------------------------------------------------------------
  // Status and Verification
  // --------------------------------------------------------------------------

  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  getStatus(filePath?: string): any {
    if (!this.baselines) {
      throw new Error('Baselines not loaded');
    }

    const normalizedFilePath = filePath ? path.resolve(filePath) : null;
    const files = normalizedFilePath
      ? { [normalizedFilePath]: this.baselines.files[normalizedFilePath] }
      : this.baselines.files;

    return {
      baseline_age: this.baselines.created_at,
      files: Object.entries(files).map(([path, baseline]) => ({
        path,
        mode: baseline?.mode,
        priority: baseline?.priority,
        has_baseline: !!baseline,
        baseline_sha: baseline?.sha256,
        approved_at: baseline?.approved_at,
        snapshot_exists: fs.existsSync(this.approvedDir + '/' + path.split('/').pop())
      }))
    };
  }

  verifyAuditChain(): { valid: boolean; entries: number; errors: string[] } {
    if (!fs.existsSync(this.auditPath)) {
      return { valid: true, entries: 0, errors: [] };
    }

    const content = fs.readFileSync(this.auditPath, 'utf-8');
    const lines = content.trim().split('\n').filter(l => l.trim());

    const errors: string[] = [];
    let prevHash = CHAIN_GENESIS;

    for (let i = 0; i < lines.length; i++) {
      try {
        const entry: AuditEntry = JSON.parse(lines[i]);

        if (entry.chain?.prev !== prevHash) {
          errors.push(`Line ${i + 1}: Chain break (expected prev=${prevHash}, got=${entry.chain?.prev})`);
        }

        const entryWithoutChain = { ...entry };
        delete entryWithoutChain.chain;
        const payload = prevHash + '\n' + JSON.stringify(entryWithoutChain, Object.keys(entryWithoutChain).sort());
        const expectedHash = sha256Hex(payload);

        if (entry.chain?.hash !== expectedHash) {
          errors.push(`Line ${i + 1}: Hash mismatch`);
        }

        prevHash = entry.chain?.hash || CHAIN_GENESIS;
      } catch (error) {
        errors.push(`Line ${i + 1}: Parse error - ${error}`);
      }
    }

    return {
      valid: errors.length === 0,
      entries: lines.length,
      errors
    };
  }
}

{
  "version": 1,
  "description": "NanoClaw file integrity monitoring policy",
  "nanoclaw_version": "0.1.0",
  "targets": [
    {
      "path": "/workspace/project/data/registered_groups.json",
      "mode": "restore",
      "priority": "critical",
      "description": "Group registration config - prevents unauthorized group access"
    },
    {
      "path": "/workspace/group/CLAUDE.md",
      "mode": "restore",
      "priority": "high",
      "description": "Group-specific agent instructions"
    },
    {
      "path": "/workspace/project/groups/global/CLAUDE.md",
      "mode": "restore",
      "priority": "high",
      "description": "Global agent instructions shared across all groups"
    },
    {
      "pattern": "/workspace/project/container/**/*.ts",
      "mode": "alert",
      "priority": "medium",
      "description": "Container runtime code - alert on changes for awareness"
    },
    {
      "pattern": "/workspace/project/host/**/*.ts",
      "mode": "alert",
      "priority": "medium",
      "description": "Host process code - alert on changes for awareness"
    },
    {
      "pattern": "/workspace/ipc/**/*",
      "mode": "ignore",
      "priority": "low",
      "description": "IPC files change constantly - ignore"
    },
    {
      "pattern": "/workspace/group/conversations/**/*",
      "mode": "ignore",
      "priority": "low",
      "description": "Chat history - expected to change frequently"
    }
  ],
  "notes": [
    "Mode 'restore': Auto-restore file to approved baseline on drift + alert user",
    "Mode 'alert': Alert user about drift but do not auto-restore",
    "Mode 'ignore': No monitoring, file changes are expected",
    "Patterns use glob syntax with ** for recursive matching"
  ]
}

/**
 * ClawSec Advisory Cache Manager for NanoClaw
 *
 * Manages fetching, verifying, and caching the ClawSec advisory feed.
 * Runs on the host side (not in container).
 *
 * Security:
 * - Ed25519 signature verification using Node.js crypto
 * - Fail-closed policy: invalid signature = reject feed
 * - TLS 1.2+ enforcement with certificate validation
 * - Public key embedded (not user-modifiable)
 * - Cache stored in host-managed directory
 */

import crypto from 'node:crypto';
import fs from 'node:fs/promises';
import https from 'node:https';
import path from 'node:path';
import { evaluateAdvisoryRisk } from '../lib/risk.js';

// ClawSec public key (from clawsec-signing-public.pem)
const PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
MCowBQYDK2VwAyEAS7nijfMcUoOBCj4yOXJX+GYGv2pFl2Yaha1P4v5Cm6A=
-----END PUBLIC KEY-----`;

const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
const FEED_URL = 'https://clawsec.prompt.security/advisories/feed.json';
const FETCH_TIMEOUT_MS = 10000;

export interface Advisory {
  id: string;
  severity: string;
  type?: string;
  title?: string;
  description?: string;
  action?: string;
  published?: string;
  updated?: string;
  exploitability_score?: 'high' | 'medium' | 'low' | 'unknown' | string;
  exploitability_rationale?: string;
  affected: string[];
}

export interface FeedPayload {
  version: string;
  updated?: string;
  advisories: Advisory[];
}

export interface AdvisoryCache {
  feed: FeedPayload;
  fetchedAt: string;
  verified: boolean;
  publicKeyFingerprint: string;
}

interface Logger {
  info(msg: string | object, ...args: unknown[]): void;
  error(msg: string | object, ...args: unknown[]): void;
  warn(msg: string | object, ...args: unknown[]): void;
}

export class AdvisoryCacheManager {
  private cache: AdvisoryCache | null = null;
  private refreshPromise: Promise<void> | null = null;
  private cacheFile: string;
  private logger: Logger;

  constructor(dataDir: string, logger: Logger) {
    this.cacheFile = path.join(dataDir, 'clawsec-advisory-cache.json');
    this.logger = logger;
  }

  /**
   * Initialize cache manager. Loads cache from disk and refreshes if stale.
   */
  async initialize(): Promise<void> {
    await this.loadCacheFromDisk();

    if (!this.cache || this.isCacheStale()) {
      try {
        await this.refresh();
      } catch (error) {
        this.logger.error({ error }, 'Failed to initialize advisory cache');
        // Continue with stale cache if available
      }
    }
  }

  /**
   * Refresh advisory cache from remote feed.
   * Thread-safe: prevents concurrent refreshes.
   */
  async refresh(): Promise<void> {
    // Prevent concurrent refreshes
    if (this.refreshPromise) {
      return this.refreshPromise;
    }

    this.refreshPromise = this._doRefresh();
    try {
      await this.refreshPromise;
    } finally {
      this.refreshPromise = null;
    }
  }

  /**
   * Get current cache. Returns null if cache is stale or missing.
   */
  getCache(): AdvisoryCache | null {
    if (!this.cache || this.isCacheStale()) {
      return null;
    }
    return this.cache;
  }

  /**
   * Get cache even if stale (for fallback scenarios)
   */
  getCacheAllowStale(): AdvisoryCache | null {
    return this.cache;
  }

  private async _doRefresh(): Promise<void> {
    try {
      this.logger.info('Refreshing advisory cache from ClawSec feed');

      const feed = await this.fetchAndVerifyFeed();
      const fingerprint = this.calculateKeyFingerprint();

      this.cache = {
        feed,
        fetchedAt: new Date().toISOString(),
        verified: true,
        publicKeyFingerprint: fingerprint,
      };

      await this.saveCacheToDisk();
      this.logger.info({
        advisories: feed.advisories.length,
        updated: feed.updated,
      }, 'Advisory cache refreshed successfully');
    } catch (error) {
      this.logger.error({ error }, 'Failed to refresh advisory cache');
      throw error;
    }
  }

  private isCacheStale(): boolean {
    if (!this.cache) return true;
    const age = Date.now() - Date.parse(this.cache.fetchedAt);
    return age > CACHE_TTL_MS;
  }

  private async fetchAndVerifyFeed(): Promise<FeedPayload> {
    // Fetch feed and signature in parallel
    const [payloadRaw, signatureRaw] = await Promise.all([
      this.secureFetch(FEED_URL),
      this.secureFetch(`${FEED_URL}.sig`),
    ]);

    // Verify Ed25519 signature
    if (!this.verifySignature(payloadRaw, signatureRaw)) {
      throw new Error('Feed signature verification failed (Ed25519)');
    }

    // Parse and validate
    const feed = JSON.parse(payloadRaw) as FeedPayload;
    if (!this.isValidFeed(feed)) {
      throw new Error('Invalid feed format');
    }

    return feed;
  }

  private async secureFetch(url: string): Promise<string> {
    return new Promise((resolve, reject) => {
      // Create secure HTTPS agent with TLS 1.2+ enforcement
      const agent = new https.Agent({
        minVersion: 'TLSv1.2',
        rejectUnauthorized: true,
        ciphers: 'TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256',
      });

      const req = https.get(url, {
        agent,
        timeout: FETCH_TIMEOUT_MS,
        headers: {
          'User-Agent': 'NanoClaw/1.0',
          'Accept': 'application/json,text/plain',
        },
      }, (res) => {
        if (res.statusCode !== 200) {
          reject(new Error(`HTTP ${res.statusCode} from ${url}`));
          return;
        }

        let data = '';
        res.on('data', (chunk) => { data += chunk; });
        res.on('end', () => resolve(data));
        res.on('error', reject);
      });

      req.on('error', reject);
      req.on('timeout', () => {
        req.destroy();
        reject(new Error(`Timeout fetching ${url}`));
      });
    });
  }

  private verifySignature(payload: string, signatureBase64: string): boolean {
    try {
      // Decode base64 signature
      const trimmed = signatureBase64.trim();
      let encoded = trimmed;

      // Handle JSON-wrapped signature: {"signature": "base64..."}
      if (trimmed.startsWith('{')) {
        try {
          const parsed = JSON.parse(trimmed);
          if (typeof parsed.signature === 'string') {
            encoded = parsed.signature;
          }
        } catch {
          // Not JSON, use as-is
        }
      }

      const normalized = encoded.replace(/\s+/g, '');
      const sigBuffer = Buffer.from(normalized, 'base64');

      // Verify Ed25519 signature using Node.js crypto
      const publicKey = crypto.createPublicKey(PUBLIC_KEY_PEM);
      return crypto.verify(
        null, // algorithm null = Ed25519 raw mode
        Buffer.from(payload, 'utf8'),
        publicKey,
        sigBuffer
      );
    } catch (error) {
      this.logger.warn({ error }, 'Signature verification failed');
      return false;
    }
  }

  private isValidFeed(feed: unknown): feed is FeedPayload {
    if (typeof feed !== 'object' || !feed) return false;
    const f = feed as FeedPayload;

    if (typeof f.version !== 'string' || !f.version.trim()) return false;
    if (!Array.isArray(f.advisories)) return false;

    // Validate each advisory
    return f.advisories.every((a: unknown) => {
      if (typeof a !== 'object' || !a) return false;
      const advisory = a as Advisory;

      return (
        typeof advisory.id === 'string' &&
        advisory.id.trim() !== '' &&
        typeof advisory.severity === 'string' &&
        advisory.severity.trim() !== '' &&
        Array.isArray(advisory.affected) &&
        advisory.affected.every(
          (affected) => typeof affected === 'string' && affected.trim() !== ''
        )
      );
    });
  }

  private calculateKeyFingerprint(): string {
    const publicKey = crypto.createPublicKey(PUBLIC_KEY_PEM);
    const der = publicKey.export({ type: 'spki', format: 'der' });
    return crypto.createHash('sha256').update(der).digest('hex');
  }

  private async loadCacheFromDisk(): Promise<void> {
    try {
      const data = await fs.readFile(this.cacheFile, 'utf8');
      const parsed = JSON.parse(data) as AdvisoryCache;

      // Validate cache structure
      if (this.isValidCache(parsed)) {
        this.cache = parsed;
        this.logger.info({
          age: Date.now() - Date.parse(parsed.fetchedAt),
          advisories: parsed.feed.advisories.length,
        }, 'Loaded advisory cache from disk');
      } else {
        this.logger.warn('Invalid cache format on disk, discarding');
        this.cache = null;
      }
    } catch {
      this.cache = null;
    }
  }

  private isValidCache(cache: unknown): cache is AdvisoryCache {
    if (typeof cache !== 'object' || !cache) return false;
    const c = cache as AdvisoryCache;

    return (
      this.isValidFeed(c.feed) &&
      typeof c.fetchedAt === 'string' &&
      typeof c.verified === 'boolean' &&
      typeof c.publicKeyFingerprint === 'string'
    );
  }

  private async saveCacheToDisk(): Promise<void> {
    if (!this.cache) return;

    try {
      await fs.mkdir(path.dirname(this.cacheFile), { recursive: true });

      // Atomic write: temp file then rename
      const tempFile = `${this.cacheFile}.tmp`;
      await fs.writeFile(tempFile, JSON.stringify(this.cache, null, 2), 'utf8');
      await fs.rename(tempFile, this.cacheFile);

      this.logger.info({ path: this.cacheFile }, 'Advisory cache saved to disk');
    } catch (error) {
      this.logger.error({ error }, 'Failed to save advisory cache to disk');
      throw error;
    }
  }
}

/**
 * Helper: Match advisories against installed skills
 */
export function findAdvisoryMatches(
  advisories: Advisory[],
  skills: Array<{ name: string; version: string | null; dirName: string }>
): Array<{
  advisory: Advisory;
  skill: { name: string; version: string | null; dirName: string };
  matchedAffected: string[];
}> {
  const matches: Array<{
    advisory: Advisory;
    skill: { name: string; version: string | null; dirName: string };
    matchedAffected: string[];
  }> = [];

  for (const advisory of advisories) {
    for (const skill of skills) {
      const matchedAffected: string[] = [];

      for (const affected of advisory.affected) {
        // Parse affected specifier: skill-name or skill-name@version
        const atIndex = affected.lastIndexOf('@');
        const affectedName = atIndex > 0 ? affected.slice(0, atIndex) : affected;
        const _affectedVersion = atIndex > 0 ? affected.slice(atIndex + 1) : '*';

        // Match by name or directory name
        if (affectedName === skill.name || affectedName === skill.dirName) {
          // TODO: implement version range matching
          matchedAffected.push(affected);
        }
      }

      if (matchedAffected.length > 0) {
        matches.push({ advisory, skill, matchedAffected });
      }
    }
  }

  return matches;
}

/**
 * Helper: Evaluate safety recommendation for a skill
 */
export function evaluateSkillSafety(advisories: Advisory[]): {
  safe: boolean;
  recommendation: 'install' | 'block' | 'review';
  reason: string;
} {
  return evaluateAdvisoryRisk(advisories);
}

/* eslint-disable @typescript-eslint/no-explicit-any */
/**
 * ClawSec File Integrity Monitoring IPC Handler for NanoClaw Host
 *
 * Add these handlers to /workspace/project/src/ipc.ts
 *
 * This processes integrity monitoring requests from agents running in containers.
 */

import fs from 'fs';
import path from 'path';
import { IntegrityMonitor } from '../guardian/integrity-monitor';

const RESULT_DIR = '/workspace/ipc/clawsec_results';
const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;

// ============================================================================
// Integrity Service (Singleton)
// ============================================================================

export class IntegrityService {
  private monitor: IntegrityMonitor | null = null;
  private initialized = false;

  async initialize(): Promise<void> {
    if (this.initialized) return;

    try {
      this.monitor = new IntegrityMonitor({
        policyPath: '/workspace/project/skills/clawsec-nanoclaw/guardian/policy.json',
        stateDir: '/workspace/project/data/soul-guardian'
      });

      // Initialize baselines on first run
      await this.monitor.init('system', 'initial baseline');

      this.initialized = true;
      console.log('[IntegrityService] Initialized successfully');
    } catch (error) {
      console.error('[IntegrityService] Initialization failed:', error);
      throw error;
    }
  }

  getMonitor(): IntegrityMonitor {
    if (!this.monitor) {
      throw new Error('IntegrityService not initialized');
    }
    return this.monitor;
  }

  isInitialized(): boolean {
    return this.initialized;
  }
}

// Global singleton instance
let integrityServiceInstance: IntegrityService | null = null;

export function getIntegrityService(): IntegrityService {
  if (!integrityServiceInstance) {
    integrityServiceInstance = new IntegrityService();
  }
  return integrityServiceInstance;
}

// ============================================================================
// IPC Handler Integration
// ============================================================================

/**
 * Add this to the IpcDeps interface in /workspace/project/src/ipc.ts:
 *
 * export interface IpcDeps {
 *   // ... existing deps
 *   integrityService?: IntegrityService;
 * }
 */

/**
 * Add these cases to the switch statement in processTaskIpc:
 */

export async function handleIntegrityIpc(
  task: any,
  deps: { integrityService?: IntegrityService },
  logger: any
): Promise<void> {
  const { type, requestId, groupFolder: _groupFolder } = task;
  const validatedRequestId = validateRequestId(requestId);

  if (!validatedRequestId) {
    logger.warn({ type, requestId }, 'Invalid integrity IPC request id');
    return;
  }

  const safeTask = { ...task, requestId: validatedRequestId };

  if (!deps.integrityService) {
    logger.warn({ task }, 'IntegrityService not available');
    writeResult(validatedRequestId, {
      success: false,
      error: 'IntegrityService not initialized'
    });
    return;
  }

  const service = deps.integrityService;

  if (!service.isInitialized()) {
    try {
      await service.initialize();
    } catch (error) {
      logger.error({ error }, 'Failed to initialize IntegrityService');
      writeResult(validatedRequestId, {
        success: false,
        error: `Initialization failed: ${error instanceof Error ? error.message : String(error)}`
      });
      return;
    }
  }

  switch (type) {
    case 'integrity_check':
      await handleIntegrityCheck(safeTask, service, logger);
      break;

    case 'integrity_approve':
      await handleIntegrityApprove(safeTask, service, logger);
      break;

    case 'integrity_status':
      await handleIntegrityStatus(safeTask, service, logger);
      break;

    case 'integrity_verify_audit':
      await handleIntegrityVerifyAudit(safeTask, service, logger);
      break;

    default:
      logger.warn({ type }, 'Unknown integrity task type');
  }
}

// ============================================================================
// Individual Handlers
// ============================================================================

async function handleIntegrityCheck(
  task: any,
  service: IntegrityService,
  logger: any
): Promise<void> {
  const { requestId, mode, autoRestore, groupFolder } = task;

  logger.info({ requestId, groupFolder }, 'Processing integrity_check');

  try {
    const monitor = service.getMonitor();

    if (mode === 'status') {
      // Status mode: just return baseline info
      const status = monitor.getStatus();
      writeResult(requestId, {
        success: true,
        mode: 'status',
        ...status
      });
    } else {
      // Check mode: detect drift and optionally restore
      const result = await monitor.checkIntegrity(autoRestore !== false, 'agent');

      writeResult(requestId, result);

      if (result.drift_detected) {
        logger.warn(
          { requestId, drifted: result.summary.drifted, restored: result.summary.restored },
          'Integrity drift detected'
        );
      } else {
        logger.info({ requestId }, 'Integrity check passed');
      }
    }
  } catch (error) {
    logger.error({ error, requestId }, 'Integrity check failed');
    writeResult(requestId, {
      success: false,
      error: error instanceof Error ? error.message : String(error)
    });
  }
}

async function handleIntegrityApprove(
  task: any,
  service: IntegrityService,
  logger: any
): Promise<void> {
  const { requestId, path: filePath, note, approvedBy, groupFolder } = task;

  logger.info({ requestId, filePath, groupFolder }, 'Processing integrity_approve');

  try {
    const monitor = service.getMonitor();

    await monitor.approveChange(filePath, approvedBy || 'agent', note || '');

    writeResult(requestId, {
      success: true,
      path: filePath,
      approved_at: new Date().toISOString(),
      approved_by: approvedBy,
      note
    });

    logger.info({ requestId, filePath }, 'File change approved');
  } catch (error) {
    logger.error({ error, requestId, filePath }, 'Approve change failed');
    writeResult(requestId, {
      success: false,
      error: error instanceof Error ? error.message : String(error),
      path: filePath
    });
  }
}

async function handleIntegrityStatus(
  task: any,
  service: IntegrityService,
  logger: any
): Promise<void> {
  const { requestId, path: filePath, groupFolder } = task;

  logger.info({ requestId, filePath, groupFolder }, 'Processing integrity_status');

  try {
    const monitor = service.getMonitor();
    const status = monitor.getStatus(filePath);

    writeResult(requestId, {
      success: true,
      ...status
    });

    logger.info({ requestId }, 'Status retrieved');
  } catch (error) {
    logger.error({ error, requestId }, 'Status check failed');
    writeResult(requestId, {
      success: false,
      error: error instanceof Error ? error.message : String(error)
    });
  }
}

async function handleIntegrityVerifyAudit(
  task: any,
  service: IntegrityService,
  logger: any
): Promise<void> {
  const { requestId, groupFolder } = task;

  logger.info({ requestId, groupFolder }, 'Processing integrity_verify_audit');

  try {
    const monitor = service.getMonitor();
    const verification = monitor.verifyAuditChain();

    writeResult(requestId, {
      success: true,
      ...verification
    });

    if (!verification.valid) {
      logger.error({ requestId, errors: verification.errors }, 'Audit chain verification failed');
    } else {
      logger.info({ requestId, entries: verification.entries }, 'Audit chain verified');
    }
  } catch (error) {
    logger.error({ error, requestId }, 'Audit verification failed');
    writeResult(requestId, {
      success: false,
      error: error instanceof Error ? error.message : String(error)
    });
  }
}

// ============================================================================
// Helper Functions
// ============================================================================

function validateRequestId(requestId: unknown): string | null {
  if (typeof requestId !== 'string') return null;
  const normalized = requestId.trim();
  if (!REQUEST_ID_PATTERN.test(normalized)) return null;
  return normalized;
}

function resolveResultPath(requestId: string): string {
  const safeRequestId = validateRequestId(requestId);
  if (!safeRequestId) {
    throw new Error('Invalid integrity IPC request id');
  }

  const resultDir = RESULT_DIR;
  const normalizedResultDir = path.resolve(resultDir);
  const resultPath = path.resolve(normalizedResultDir, `${safeRequestId}.json`);
  const relativePath = path.relative(normalizedResultDir, resultPath);

  if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
    throw new Error('Integrity IPC result path escapes result directory');
  }

  return resultPath;
}

function writeResult(requestId: string, result: any): void {
  const resultPath = resolveResultPath(requestId);
  const resultDir = path.dirname(resultPath);

  // Ensure directory exists
  if (!fs.existsSync(resultDir)) {
    fs.mkdirSync(resultDir, { recursive: true });
  }

  fs.writeFileSync(resultPath, JSON.stringify(result, null, 2));
}

// ============================================================================
// Integration Instructions
// ============================================================================

/**
 * To integrate into NanoClaw host process:
 *
 * 1. Add IntegrityService to IpcDeps in src/ipc.ts:
 *
 *    import { IntegrityService, getIntegrityService } from '../skills/clawsec-nanoclaw/host-services/integrity-handler';
 *
 *    export interface IpcDeps {
 *      // ... existing deps
 *      integrityService?: IntegrityService;
 *    }
 *
 * 2. Initialize in main.ts:
 *
 *    const integrityService = getIntegrityService();
 *    await integrityService.initialize();
 *
 *    const ipcDeps: IpcDeps = {
 *      // ... existing deps
 *      integrityService
 *    };
 *
 * 3. Add handler calls in processTaskIpc switch statement:
 *
 *    case 'integrity_check':
 *    case 'integrity_approve':
 *    case 'integrity_status':
 *    case 'integrity_verify_audit':
 *      await handleIntegrityIpc(task, deps, logger);
 *      break;
 *
 * 4. Ensure /workspace/ipc/clawsec_results/ directory exists and is writable
 *
 * 5. Ensure /workspace/project/data/soul-guardian/ directory exists and is writable
 */

// Example scheduled task for continuous monitoring:
//
// schedule_task({
//   prompt: `
//     Run clawsec_check_integrity to check for file tampering.
//     If drift_detected is true and files were restored, send alert:
//     "SECURITY: Unauthorized changes detected and reverted in:
//     [list restored files with their paths]
//     Review patches in /workspace/project/data/soul-guardian/patches/"
//   `,
//   schedule_type: 'cron',
//   schedule_value: '*/30 * * * *',  // Every 30 minutes
//   context_mode: 'isolated'
// });

/**
 * ClawSec Advisory Feed IPC Handler Additions for NanoClaw
 *
 * Add this case to the switch statement in /workspace/project/src/ipc.ts
 * inside the processTaskIpc function.
 *
 * This handler processes advisory cache refresh requests from agents.
 */

import { AdvisoryCacheManager } from './advisory-cache';
import { SkillSignatureVerifier } from './skill-signature-handler';

// Add to IpcDeps interface:
export interface IpcDeps {
  advisoryCacheManager?: AdvisoryCacheManager;
  signatureVerifier?: SkillSignatureVerifier;
}

interface IpcLogger {
  info(obj: Record<string, unknown>, msg?: string): void;
  warn(obj: Record<string, unknown>, msg?: string): void;
  error(obj: Record<string, unknown>, msg?: string): void;
}

// eslint-disable-next-line @typescript-eslint/no-explicit-any
type IpcTask = Record<string, any>;

/**
 * Placeholder for the host-side writeResponse function.
 * The actual implementation lives in the NanoClaw host process.
 */
declare function writeResponse(requestId: string, data: Record<string, unknown>): Promise<void>;

/**
 * Handle advisory and signature IPC tasks.
 *
 * In the host process, call this from the processTaskIpc switch statement
 * for the 'refresh_advisory_cache' and 'verify_skill_signature' cases.
 */
export async function handleAdvisoryIpc(
  task: IpcTask,
  deps: IpcDeps,
  logger: IpcLogger,
  sourceGroup: string,
): Promise<void> {
  switch (task.type) {
    case 'refresh_advisory_cache':
      // Any group can request cache refresh (rate-limited by cache manager)
      logger.info({ sourceGroup }, 'Advisory cache refresh requested via IPC');
      if (deps.advisoryCacheManager) {
        try {
          await deps.advisoryCacheManager.refresh();
          logger.info({ sourceGroup }, 'Advisory cache refreshed successfully');
        } catch (error) {
          logger.error({ error, sourceGroup }, 'Advisory cache refresh failed');
        }
      } else {
        logger.warn({ sourceGroup }, 'Advisory cache manager not initialized');
      }
      break;

    case 'verify_skill_signature': {
      // Skill signature verification (Phase 1)
      const { requestId, packagePath, signaturePath } = task;

      logger.info({ sourceGroup, requestId, packagePath }, 'Verifying skill signature');

      try {
        if (!deps.signatureVerifier) {
          throw new Error('Signature verification service not available');
        }

        const result = await deps.signatureVerifier.verify({
          packagePath,
          signaturePath,
        });

        await writeResponse(requestId, {
          success: true,
          message: result.valid ? 'Signature valid' : 'Signature invalid',
          data: result,
        });

        logger.info(
          { sourceGroup, requestId, valid: result.valid, signer: result.signer },
          'Signature verification completed'
        );
      } catch (error: unknown) {
        const err = error as Error & { code?: string };
        logger.error({ error, sourceGroup, requestId, packagePath }, 'Signature verification failed');

        const errorCode = err.code || 'CRYPTO_ERROR';
        await writeResponse(requestId, {
          success: false,
          message: err.message || 'Verification failed',
          error: {
            code: errorCode,
            details: error
          }
        });
      }
      break;
    }
  }
}