contextos-agents 1.6.1 → 2.0.0-beta.2

package/.agents/filesystem/lockfile-v2.js

@@ -0,0 +1,275 @@
+/**
+ * .agents/filesystem/lockfile-v2.js
+ * ContextOS Lockfile v2 Schema Manager & CAS Revision Tracker
+ *
+ * Implements:
+ * - Dual-hashing: Exact byte SHA-256 + CRLF-normalized semantic text SHA-256
+ * - Monotonic revision tracking with Compare-And-Swap (CAS) concurrency guard
+ * - Schema v2 validation adhering to .agents/schemas/lockfile.v2.schema.json
+ * - Generator provenance and artifact metadata management
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { safeRenameSync } = require('./safe-path.js');
+
+const DEFAULT_LOCKFILE_SUBPATH = path.join('.agents', 'lockfile.v2.json');
+const SCHEMA_PATH = path.join(__dirname, '..', 'schemas', 'lockfile.v2.schema.json');
+
+const ERROR_CODES = {
+  INVALID_SCHEMA: 'CTX_LOCKFILE_INVALID_SCHEMA',
+  REVISION_CONFLICT: 'CTX_LOCKFILE_REVISION_CONFLICT',
+  CORRUPT: 'CTX_LOCKFILE_CORRUPT',
+};
+
+class LockfileV2Error extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = 'LockfileV2Error';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+/**
+ * Computes exact SHA-256 hash of raw byte buffer or string.
+ * Format: sha256:<hex>
+ */
+function computeExactHash(content) {
+  const buf = Buffer.isBuffer(content) ? content : Buffer.from(String(content), 'utf8');
+  const hash = crypto.createHash('sha256').update(buf).digest('hex');
+  return `sha256:${hash}`;
+}
+
+/**
+ * Computes semantic CRLF-normalized text SHA-256 hash to prevent false dirty states across Git checkouts.
+ * Format: sha256:<hex>
+ */
+function computeSemanticHash(content) {
+  const str = Buffer.isBuffer(content) ? content.toString('utf8') : String(content);
+  // Normalize Windows CRLF to LF and trim trailing carriage returns
+  const normalized = str.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+  const hash = crypto.createHash('sha256').update(normalized, 'utf8').digest('hex');
+  return `sha256:${hash}`;
+}
+
+class LockfileV2Manager {
+  constructor(projectRoot, options = {}) {
+    this.projectRoot = path.resolve(projectRoot);
+    this.lockfilePath = options.lockfilePath
+      ? path.resolve(this.projectRoot, options.lockfilePath)
+      : path.resolve(this.projectRoot, DEFAULT_LOCKFILE_SUBPATH);
+    this.schema = this.loadSchema();
+  }
+
+  loadSchema() {
+    try {
+      if (fs.existsSync(SCHEMA_PATH)) {
+        return JSON.parse(fs.readFileSync(SCHEMA_PATH, 'utf8'));
+      }
+    } catch {
+      // Best-effort schema load
+    }
+    return null;
+  }
+
+  /**
+   * Initializes a fresh Lockfile v2 data structure.
+   */
+  createEmpty(meta = {}) {
+    return {
+      schemaVersion: 2,
+      revision: 1,
+      package: {
+        name: meta.packageName || 'contextos-project',
+        version: meta.packageVersion || '1.0.0',
+        compilerVersion: meta.compilerVersion || '2.0.0',
+      },
+      profile: {
+        id: meta.profileId || 'default',
+        hash: meta.profileHash || 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
+      },
+      sourceGraphHash: meta.sourceGraphHash || 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
+      enabledAdapters: meta.enabledAdapters || [],
+      managedFiles: {},
+    };
+  }
+
+  /**
+   * Reads and parses Lockfile v2 from disk. Returns null if file does not exist.
+   */
+  read() {
+    if (!fs.existsSync(this.lockfilePath)) {
+      return null;
+    }
+
+    try {
+      const raw = fs.readFileSync(this.lockfilePath, 'utf8');
+      const parsed = JSON.parse(raw);
+      this.validate(parsed);
+      return parsed;
+    } catch (err) {
+      if (err instanceof LockfileV2Error) throw err;
+      throw new LockfileV2Error(
+        ERROR_CODES.CORRUPT,
+        `Lockfile at '${this.lockfilePath}' is corrupt or unparseable: ${err.message}`,
+        { error: err.message, lockfilePath: this.lockfilePath }
+      );
+    }
+  }
+
+  /**
+   * Validates lockfile structure against LockfileV2 specification.
+   */
+  validate(data) {
+    if (!data || typeof data !== 'object') {
+      throw new LockfileV2Error(ERROR_CODES.INVALID_SCHEMA, 'Lockfile data must be a non-null object');
+    }
+
+    if (data.schemaVersion !== 2) {
+      throw new LockfileV2Error(
+        ERROR_CODES.INVALID_SCHEMA,
+        `Expected schemaVersion 2, got '${data.schemaVersion}'`
+      );
+    }
+
+    if (typeof data.revision !== 'number' || data.revision < 1) {
+      throw new LockfileV2Error(
+        ERROR_CODES.INVALID_SCHEMA,
+        `Lockfile revision must be a positive integer, got '${data.revision}'`
+      );
+    }
+
+    if (!data.package || !data.package.name || !data.package.version) {
+      throw new LockfileV2Error(
+        ERROR_CODES.INVALID_SCHEMA,
+        'Lockfile missing required package identity (name, version)'
+      );
+    }
+
+    if (!data.profile || !data.profile.id || !data.profile.hash) {
+      throw new LockfileV2Error(
+        ERROR_CODES.INVALID_SCHEMA,
+        'Lockfile missing required profile metadata (id, hash)'
+      );
+    }
+
+    if (!Array.isArray(data.enabledAdapters)) {
+      throw new LockfileV2Error(
+        ERROR_CODES.INVALID_SCHEMA,
+        'Lockfile enabledAdapters must be an array'
+      );
+    }
+
+    if (!data.managedFiles || typeof data.managedFiles !== 'object') {
+      throw new LockfileV2Error(
+        ERROR_CODES.INVALID_SCHEMA,
+        'Lockfile managedFiles must be an object map'
+      );
+    }
+
+    // Validate individual file records
+    for (const [filePath, record] of Object.entries(data.managedFiles)) {
+      if (!record.exactSha256 || !record.semanticTextSha256 || !record.kind || !record.generator) {
+        throw new LockfileV2Error(
+          ERROR_CODES.INVALID_SCHEMA,
+          `Managed file '${filePath}' record is missing required fields (exactSha256, semanticTextSha256, kind, generator)`,
+          { filePath, record }
+        );
+      }
+    }
+
+    return true;
+  }
+
+  /**
+   * Saves lockfile to disk with optimistic concurrency Compare-And-Swap (CAS).
+   *
+   * @param {object} data - Lockfile data to write
+   * @param {number} [expectedRevision] - Optional expected revision on disk before increment
+   * @returns {object} Updated lockfile data with incremented revision
+   */
+  write(data, expectedRevision = undefined) {
+    const currentOnDisk = this.read();
+
+    if (expectedRevision !== undefined && currentOnDisk !== null) {
+      if (currentOnDisk.revision !== expectedRevision) {
+        throw new LockfileV2Error(
+          ERROR_CODES.REVISION_CONFLICT,
+          `Compare-And-Swap failed: disk revision is ${currentOnDisk.revision}, expected ${expectedRevision}`,
+          { actualRevision: currentOnDisk.revision, expectedRevision }
+        );
+      }
+    }
+
+    // Increment revision
+    const nextRevision = currentOnDisk ? currentOnDisk.revision + 1 : (data.revision || 1);
+    const dataToWrite = {
+      ...data,
+      schemaVersion: 2,
+      revision: nextRevision,
+    };
+
+    this.validate(dataToWrite);
+
+    const dir = path.dirname(this.lockfilePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    const tmpPath = `${this.lockfilePath}.tmp-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    fs.writeFileSync(tmpPath, JSON.stringify(dataToWrite, null, 2) + '\n', 'utf8');
+
+    try {
+      safeRenameSync(tmpPath, this.lockfilePath);
+    } catch (err) {
+      try {
+        if (fs.existsSync(tmpPath)) fs.unlinkSync(tmpPath);
+      } catch {
+        // Best-effort cleanup
+      }
+      throw err;
+    }
+
+    return dataToWrite;
+  }
+
+  /**
+   * Adds or updates a managed file entry in memory.
+   */
+  recordManagedFile(data, relativePosixPath, fileMeta) {
+    if (!data.managedFiles) data.managedFiles = {};
+
+    data.managedFiles[relativePosixPath] = {
+      exactSha256: fileMeta.exactSha256,
+      semanticTextSha256: fileMeta.semanticTextSha256,
+      kind: fileMeta.kind || 'generated-adapter',
+      generator: fileMeta.generator,
+      inputsHash: fileMeta.inputsHash || 'sha256:0000000000000000000000000000000000000000000000000000000000000000',
+      mode: fileMeta.mode || 420,
+      lastTransaction: fileMeta.lastTransaction || undefined,
+    };
+
+    return data;
+  }
+
+  /**
+   * Removes a managed file entry from memory.
+   */
+  removeManagedFile(data, relativePosixPath) {
+    if (data.managedFiles && data.managedFiles[relativePosixPath]) {
+      delete data.managedFiles[relativePosixPath];
+    }
+    return data;
+  }
+}
+
+module.exports = {
+  LockfileV2Manager,
+  computeExactHash,
+  computeSemanticHash,
+  LockfileV2Error,
+  ERROR_CODES,
+  DEFAULT_LOCKFILE_SUBPATH,
+};

package/.agents/filesystem/platform-hardening.js

@@ -0,0 +1,222 @@
+/**
+ * .agents/filesystem/platform-hardening.js
+ * ContextOS — Cross-Platform Hardening & Resilience Engine
+ *
+ * Implements Section 21 of CONTEXTOS_IMPLEMENTATION_PLAN.md:
+ *   - 21.1: Platform support contract (Node 18 Core, Node 20 Runtime, filesystem checks)
+ *   - 21.2: Windows resilience (EPERM/EBUSY rename/unlink retry wrappers, ADS, reserved names)
+ *   - 21.4: macOS APFS Unicode normalization (NFC standard)
+ *   - 21.5: UNC / Network filesystem rejection (distributed lock safety)
+ *   - 21.6: Platform-aware repository fingerprint (no blanket lowercase, git common dir, persisted UUID)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+function sha256(str) {
+  return crypto.createHash('sha256').update(str || '').digest('hex');
+}
+
+/**
+ * Checks if a given path is an unsupported UNC or Network Share (Section 21.5).
+ *
+ * @param {string} targetPath
+ * @returns {boolean} True if path is UNC or network share
+ */
+function isNetworkOrUNCPath(targetPath) {
+  if (typeof targetPath !== 'string') return false;
+  const normalized = targetPath.replace(/\\/g, '/');
+
+  // UNC paths on Windows: //server/share or \\server\share
+  if (normalized.startsWith('//')) {
+    return true;
+  }
+
+  // Windows extended-length UNC: \\?\UNC\server\share
+  if (/^\\\\[?.]\\UNC\\/i.test(targetPath)) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Validates platform runtime compatibility (Section 21.1).
+ *
+ * @param {Object} [options]
+ * @param {'core'|'runtime'} [options.component='core']
+ * @returns {{ supported: boolean, nodeVersion: number, required: number, issues: string[] }}
+ */
+function validatePlatformSupport(options = {}) {
+  const component = options.component || 'core';
+  const nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
+  const requiredMajor = component === 'runtime' ? 20 : 18;
+  const issues = [];
+
+  if (nodeMajor < requiredMajor) {
+    issues.push(
+      `Node.js version ${process.versions.node} is below required minimum v${requiredMajor}.x for ContextOS ${component}.`
+    );
+  }
+
+  return {
+    supported: issues.length === 0,
+    nodeVersion: nodeMajor,
+    required: requiredMajor,
+    issues,
+  };
+}
+
+/**
+ * Computes platform-aware repository fingerprint (Section 21.6).
+ * Preserves Linux case while normalizing Windows/macOS drive letters and APFS.
+ * Incorporates persisted repository UUID and Git common directory identity.
+ *
+ * @param {string} repoRoot
+ * @returns {string} SHA-256 fingerprint
+ */
+function calculateRepositoryFingerprint(repoRoot) {
+  const resolved = path.resolve(repoRoot);
+  let canonicalPath = resolved;
+
+  if (process.platform === 'win32') {
+    // Normalize drive letter uppercase (e.g. C:) and forward slashes
+    canonicalPath = canonicalPath.replace(/^([a-zA-Z]):/, (_, drive) => drive.toUpperCase() + ':');
+    canonicalPath = canonicalPath.toLowerCase(); // Case-insensitive on Windows
+  } else if (process.platform === 'darwin') {
+    // APFS is typically case-insensitive, normalize Unicode NFC
+    canonicalPath = canonicalPath.normalize('NFC').toLowerCase();
+  }
+
+  // Persisted repository UUID
+  const stateDir = path.join(resolved, '.agents', '.contextos');
+  const uuidFile = path.join(stateDir, 'repo-id');
+  let repoUuid = '';
+
+  if (fs.existsSync(uuidFile)) {
+    try {
+      repoUuid = fs.readFileSync(uuidFile, 'utf8').trim();
+    } catch {}
+  }
+
+  if (!repoUuid) {
+    repoUuid = crypto.randomUUID();
+    try {
+      fs.mkdirSync(stateDir, { recursive: true });
+      fs.writeFileSync(uuidFile, repoUuid, 'utf8');
+    } catch {}
+  }
+
+  // Check Git directory identity if present
+  let gitIdentity = 'nogit';
+  const gitDir = path.join(resolved, '.git');
+  if (fs.existsSync(gitDir)) {
+    try {
+      const gitStat = fs.statSync(gitDir);
+      gitIdentity = `${gitStat.ino || 0}:${gitStat.dev || 0}`;
+    } catch {}
+  }
+
+  const payload = `${canonicalPath}|${repoUuid}|${gitIdentity}`;
+  return sha256(payload);
+}
+
+/**
+ * Normalizes Unicode text to NFC standard (Section 21.4).
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function normalizeUnicodeNFC(text) {
+  if (typeof text !== 'string') return text;
+  return text.normalize('NFC');
+}
+
+/**
+ * Synchronously renames a file with exponential backoff retry for Windows antivirus/indexer contention (Section 21.2).
+ *
+ * @param {string} source
+ * @param {string} destination
+ * @param {Object} [options]
+ * @param {number} [options.maxRetries=5]
+ * @param {number} [options.retryDelayMs=20]
+ */
+function safeRenameSync(source, destination, options = {}) {
+  const maxRetries = options.maxRetries || 5;
+  const retryDelayMs = options.retryDelayMs || 20;
+
+  let lastErr = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      if (process.platform === 'win32' && fs.existsSync(destination)) {
+        try { fs.unlinkSync(destination); } catch {}
+      }
+      fs.renameSync(source, destination);
+      return true;
+    } catch (err) {
+      lastErr = err;
+      if (err.code === 'EPERM' || err.code === 'EBUSY' || err.code === 'EACCES') {
+        if (attempt < maxRetries) {
+          const sleepMs = Math.floor(retryDelayMs * Math.pow(1.5, attempt));
+          // Busy-wait briefly for sync operation
+          const start = Date.now();
+          while (Date.now() - start < sleepMs) {}
+          continue;
+        }
+      }
+      throw err;
+    }
+  }
+
+  throw lastErr;
+}
+
+/**
+ * Synchronously unlinks a file with retry for transient Windows locks (Section 21.2).
+ *
+ * @param {string} targetPath
+ * @param {Object} [options]
+ * @param {number} [options.maxRetries=5]
+ * @param {number} [options.retryDelayMs=20]
+ */
+function safeUnlinkSync(targetPath, options = {}) {
+  if (!fs.existsSync(targetPath)) return true;
+
+  const maxRetries = options.maxRetries || 5;
+  const retryDelayMs = options.retryDelayMs || 20;
+
+  let lastErr = null;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      fs.unlinkSync(targetPath);
+      return true;
+    } catch (err) {
+      lastErr = err;
+      if (err.code === 'EPERM' || err.code === 'EBUSY' || err.code === 'EACCES') {
+        if (attempt < maxRetries) {
+          const sleepMs = Math.floor(retryDelayMs * Math.pow(1.5, attempt));
+          const start = Date.now();
+          while (Date.now() - start < sleepMs) {}
+          continue;
+        }
+      }
+      if (!fs.existsSync(targetPath)) return true;
+      throw err;
+    }
+  }
+
+  throw lastErr;
+}
+
+module.exports = {
+  isNetworkOrUNCPath,
+  validatePlatformSupport,
+  calculateRepositoryFingerprint,
+  normalizeUnicodeNFC,
+  safeRenameSync,
+  safeUnlinkSync,
+};

package/.agents/filesystem/project-lock.js

@@ -0,0 +1,218 @@
+/**
+ * .agents/filesystem/project-lock.js
+ * ContextOS Project-Wide Inter-Process Mutation Lock
+ *
+ * Enforces single-writer mutual exclusion during compilation, export, and migration.
+ * - Atomic acquisition via exclusive filesystem creation (O_CREAT | O_EXCL / 'wx')
+ * - Cryptographic UUID token prevents zombie/stale processes from releasing new locks
+ * - Stale process detection via PID liveness probe (kill(pid, 0))
+ * - Structured machine-readable diagnostic output (CTX_PROJECT_BUSY)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { isNetworkOrUNCPath } = require('./platform-hardening.js');
+
+const LOCK_SUBPATH = path.join('.agents', '.contextos', 'locks', 'mutation.lock');
+const ERROR_CODES = {
+  BUSY: 'CTX_PROJECT_BUSY',
+  INVALID_TOKEN: 'CTX_LOCK_INVALID_TOKEN',
+  NOT_LOCKED: 'CTX_LOCK_NOT_LOCKED',
+  UNSUPPORTED: 'UNSUPPORTED',
+};
+
+class ProjectLockError extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.name = 'ProjectLockError';
+    this.code = code;
+    this.details = details;
+  }
+}
+
+/**
+ * Checks if a PID is alive on the local system.
+ */
+function isPidAlive(pid) {
+  if (typeof pid !== 'number' || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === 'EPERM'; // Process exists but lacks permission to signal
+  }
+}
+
+class ProjectMutationLock {
+  constructor(projectRoot, options = {}) {
+    if (isNetworkOrUNCPath(projectRoot)) {
+      throw new ProjectLockError(
+        ERROR_CODES.UNSUPPORTED,
+        `UNC/network filesystem mutation is unsupported for projectRoot: ${projectRoot}`,
+        { projectRoot, status: 'UNSUPPORTED' }
+      );
+    }
+    this.projectRoot = path.resolve(projectRoot);
+    this.lockPath = options.lockPath
+      ? path.resolve(this.projectRoot, options.lockPath)
+      : path.resolve(this.projectRoot, LOCK_SUBPATH);
+    this.lockDir = path.dirname(this.lockPath);
+    this.currentToken = null;
+  }
+
+  /**
+   * Reads and parses current lock payload, or null if lock doesn't exist.
+   */
+  inspect() {
+    try {
+      if (!fs.existsSync(this.lockPath)) return null;
+      const raw = fs.readFileSync(this.lockPath, 'utf8');
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Checks if lock is currently held.
+   */
+  isLocked() {
+    return this.inspect() !== null;
+  }
+
+  /**
+   * Attempts to acquire the mutation lock exclusively.
+   *
+   * @param {object} [meta] - Context metadata
+   * @param {string} [meta.command='mutation'] - Triggering command
+   * @param {string} [meta.projectFingerprint=''] - Project identity fingerprint
+   * @param {boolean} [meta.autoReapStale=true] - Automatically reclaim lock if holder PID is dead
+   * @returns {string} The secret lock token required for release
+   */
+  acquire(meta = {}) {
+    if (!fs.existsSync(this.lockDir)) {
+      fs.mkdirSync(this.lockDir, { recursive: true });
+    }
+
+    const {
+      command = 'mutation',
+      projectFingerprint = '',
+      autoReapStale = true,
+    } = meta;
+
+    // Check for existing lock and inspect holder
+    const existing = this.inspect();
+    if (existing) {
+      if (autoReapStale && existing.pid && !isPidAlive(existing.pid)) {
+        // Holder PID is dead, safe to reap stale lock
+        this.forceUnlock(`Auto-reaped stale lock from dead PID ${existing.pid}`);
+      } else {
+        throw new ProjectLockError(
+          ERROR_CODES.BUSY,
+          `Project is busy: lock is held by PID ${existing.pid} (${existing.command || 'unknown'}) since ${existing.acquiredAt}`,
+          { lockDetails: existing }
+        );
+      }
+    }
+
+    const token = crypto.randomUUID();
+    const payload = {
+      token,
+      pid: process.pid,
+      processStartedAt: new Date(Date.now() - Math.floor(process.uptime() * 1000)).toISOString(),
+      hostname: os.hostname(),
+      command,
+      projectFingerprint,
+      acquiredAt: new Date().toISOString(),
+    };
+
+    let fd = null;
+    try {
+      // 'wx' flag opens for writing, failing if path already exists (O_CREAT | O_EXCL)
+      fd = fs.openSync(this.lockPath, 'wx');
+      fs.writeFileSync(fd, JSON.stringify(payload, null, 2), 'utf8');
+      fs.fsyncSync(fd);
+    } catch (err) {
+      if (err.code === 'EEXIST') {
+        const currentHolder = this.inspect();
+        throw new ProjectLockError(
+          ERROR_CODES.BUSY,
+          `Project is busy: lock acquired concurrently by another process`,
+          { lockDetails: currentHolder }
+        );
+      }
+      throw err;
+    } finally {
+      if (fd !== null) {
+        try {
+          fs.closeSync(fd);
+        } catch {
+          // Best effort close
+        }
+      }
+    }
+
+    this.currentToken = token;
+    return token;
+  }
+
+  /**
+   * Releases lock verifying ownership token.
+   *
+   * @param {string} [token] - Release token (defaults to currently held token)
+   */
+  release(token = this.currentToken) {
+    if (!token) {
+      throw new ProjectLockError(
+        ERROR_CODES.INVALID_TOKEN,
+        'Cannot release lock: no token provided and no token actively held in session'
+      );
+    }
+
+    const current = this.inspect();
+    if (!current) {
+      this.currentToken = null;
+      return; // Already unlocked
+    }
+
+    if (current.token !== token) {
+      throw new ProjectLockError(
+        ERROR_CODES.INVALID_TOKEN,
+        `Token mismatch: current lock belongs to PID ${current.pid} acquired at ${current.acquiredAt}`,
+        { expectedToken: current.token, attemptedToken: token }
+      );
+    }
+
+    try {
+      fs.unlinkSync(this.lockPath);
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+
+    this.currentToken = null;
+  }
+
+  /**
+   * Administratively forces removal of the lock.
+   */
+  forceUnlock(reason = 'Administrative force unlock') {
+    try {
+      if (fs.existsSync(this.lockPath)) {
+        fs.unlinkSync(this.lockPath);
+      }
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+    this.currentToken = null;
+    return { success: true, reason };
+  }
+}
+
+module.exports = {
+  ProjectMutationLock,
+  ProjectLockError,
+  ERROR_CODES,
+  isPidAlive,
+};