@sanqianx/ai-coding-event-bridge-console 0.7.2 → 0.7.4

package/src/bridge/core/consumer-registry.js

@@ -1,111 +1,111 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const { CrossProcessLock, lockPathFor } = require('./lock');
-const { writeJsonAtomicSync, readJsonIfExists, ensureDirSync } = require('./fs-utils');
-
-class ConsumerRegistry {
-  constructor(homeDir) {
-    // Pure reads on a machine without a Bridge home must not create one;
-    // the directory is materialized on the first write.
-    this.homeDir = homeDir;
-    this.consumersFile = path.join(homeDir, 'consumers.json');
-    this.lock = new CrossProcessLock(lockPathFor(homeDir, 'install.lock'));
-  }
-
-  async _withLock(fn) {
-    return this.lock.withLock(fn);
-  }
-
-  _read() {
-    const saved = readJsonIfExists(this.consumersFile);
-    if (saved && typeof saved === 'object' && Array.isArray(saved.consumers)) {
-      return saved;
-    }
-    return { schema: 'bridge-consumers/v1', consumers: [] };
-  }
-
-  _write(state) {
-    ensureDirSync(this.homeDir);
-    writeJsonAtomicSync(this.consumersFile, state);
-  }
-
-  async registerConsumer(name, meta = {}) {
-    if (typeof name !== 'string' || !name) {
-      throw new TypeError('consumer name is required');
-    }
-    return this._withLock(async () => {
-      const state = this._read();
-      let entry = state.consumers.find((c) => c.name === name);
-      if (!entry) {
-        entry = { name, ack: 0, registeredAt: new Date().toISOString(), meta: {} };
-        state.consumers.push(entry);
-      }
-      entry.meta = { ...(entry.meta || {}), ...meta };
-      entry.lastSeenAt = new Date().toISOString();
-      this._write(state);
-      return { ...entry };
-    });
-  }
-
-  async unregisterConsumer(name) {
-    return this._withLock(async () => {
-      const state = this._read();
-      const before = state.consumers.length;
-      state.consumers = state.consumers.filter((c) => c.name !== name);
-      this._write(state);
-      return { removed: before - state.consumers.length };
-    });
-  }
-
-  async ackConsumerCursor(name, sequence, { journalId = 'global' } = {}) {
-    if (!Number.isInteger(sequence) || sequence < 0) {
-      throw new TypeError('ack sequence must be a non-negative integer');
-    }
-    return this._withLock(async () => {
-      const state = this._read();
-      const entry = state.consumers.find((c) => c.name === name);
-      if (!entry) {
-        const err = new Error(`consumer ${name} is not registered`);
-        err.code = 'CONSUMER_NOT_REGISTERED';
-        throw err;
-      }
-      if (journalId === 'global') entry.ack = Math.max(entry.ack || 0, sequence);
-      else {
-        if (!consumesJournal(entry, journalId)) throw new Error(`consumer ${name} is not registered for journal ${journalId}`);
-        entry.cursors = { ...(entry.cursors || {}), [journalId]: Math.max((entry.cursors || {})[journalId] || 0, sequence) };
-      }
-      entry.lastSeenAt = new Date().toISOString();
-      this._write(state);
-      return { name, journalId, ack: journalId === 'global' ? entry.ack : entry.cursors[journalId] };
-    });
-  }
-
-  async getConsumers() {
-    if (!fs.existsSync(this.consumersFile)) return [];
-    return this._withLock(async () => {
-      const state = this._read();
-      return state.consumers.map((c) => ({ ...c }));
-    });
-  }
-
-  async getMinAck({ journalId = 'global' } = {}) {
-    if (!fs.existsSync(this.consumersFile)) return null;
-    return this._withLock(async () => {
-      const state = this._read();
-      const consumers = state.consumers.filter(c => consumesJournal(c, journalId));
-      if (consumers.length === 0) return null;
-      return consumers.reduce((min, c) => Math.min(min, journalId === 'global' ? c.ack || 0 : (c.cursors || {})[journalId] || 0), Number.POSITIVE_INFINITY);
-    });
-  }
-}
-
-// Legacy consumers are global-only. An explicit wildcard protects journals
-// created after registration too; an offline consumer is never expired.
-function consumesJournal(consumer, journalId) {
-  const journals = consumer.meta && consumer.meta.journals;
-  return Array.isArray(journals) ? journals.includes('*') || journals.includes(journalId) : journalId === 'global';
-}
-
-module.exports = { ConsumerRegistry, consumesJournal };
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { CrossProcessLock, lockPathFor } = require('./lock');
+const { writeJsonAtomicSync, readJsonIfExists, ensureDirSync } = require('./fs-utils');
+
+class ConsumerRegistry {
+  constructor(homeDir) {
+    // Pure reads on a machine without a Bridge home must not create one;
+    // the directory is materialized on the first write.
+    this.homeDir = homeDir;
+    this.consumersFile = path.join(homeDir, 'consumers.json');
+    this.lock = new CrossProcessLock(lockPathFor(homeDir, 'install.lock'));
+  }
+
+  async _withLock(fn) {
+    return this.lock.withLock(fn);
+  }
+
+  _read() {
+    const saved = readJsonIfExists(this.consumersFile);
+    if (saved && typeof saved === 'object' && Array.isArray(saved.consumers)) {
+      return saved;
+    }
+    return { schema: 'bridge-consumers/v1', consumers: [] };
+  }
+
+  _write(state) {
+    ensureDirSync(this.homeDir);
+    writeJsonAtomicSync(this.consumersFile, state);
+  }
+
+  async registerConsumer(name, meta = {}) {
+    if (typeof name !== 'string' || !name) {
+      throw new TypeError('consumer name is required');
+    }
+    return this._withLock(async () => {
+      const state = this._read();
+      let entry = state.consumers.find((c) => c.name === name);
+      if (!entry) {
+        entry = { name, ack: 0, registeredAt: new Date().toISOString(), meta: {} };
+        state.consumers.push(entry);
+      }
+      entry.meta = { ...(entry.meta || {}), ...meta };
+      entry.lastSeenAt = new Date().toISOString();
+      this._write(state);
+      return { ...entry };
+    });
+  }
+
+  async unregisterConsumer(name) {
+    return this._withLock(async () => {
+      const state = this._read();
+      const before = state.consumers.length;
+      state.consumers = state.consumers.filter((c) => c.name !== name);
+      this._write(state);
+      return { removed: before - state.consumers.length };
+    });
+  }
+
+  async ackConsumerCursor(name, sequence, { journalId = 'global' } = {}) {
+    if (!Number.isInteger(sequence) || sequence < 0) {
+      throw new TypeError('ack sequence must be a non-negative integer');
+    }
+    return this._withLock(async () => {
+      const state = this._read();
+      const entry = state.consumers.find((c) => c.name === name);
+      if (!entry) {
+        const err = new Error(`consumer ${name} is not registered`);
+        err.code = 'CONSUMER_NOT_REGISTERED';
+        throw err;
+      }
+      if (journalId === 'global') entry.ack = Math.max(entry.ack || 0, sequence);
+      else {
+        if (!consumesJournal(entry, journalId)) throw new Error(`consumer ${name} is not registered for journal ${journalId}`);
+        entry.cursors = { ...(entry.cursors || {}), [journalId]: Math.max((entry.cursors || {})[journalId] || 0, sequence) };
+      }
+      entry.lastSeenAt = new Date().toISOString();
+      this._write(state);
+      return { name, journalId, ack: journalId === 'global' ? entry.ack : entry.cursors[journalId] };
+    });
+  }
+
+  async getConsumers() {
+    if (!fs.existsSync(this.consumersFile)) return [];
+    return this._withLock(async () => {
+      const state = this._read();
+      return state.consumers.map((c) => ({ ...c }));
+    });
+  }
+
+  async getMinAck({ journalId = 'global' } = {}) {
+    if (!fs.existsSync(this.consumersFile)) return null;
+    return this._withLock(async () => {
+      const state = this._read();
+      const consumers = state.consumers.filter(c => consumesJournal(c, journalId));
+      if (consumers.length === 0) return null;
+      return consumers.reduce((min, c) => Math.min(min, journalId === 'global' ? c.ack || 0 : (c.cursors || {})[journalId] || 0), Number.POSITIVE_INFINITY);
+    });
+  }
+}
+
+// Legacy consumers are global-only. An explicit wildcard protects journals
+// created after registration too; an offline consumer is never expired.
+function consumesJournal(consumer, journalId) {
+  const journals = consumer.meta && consumer.meta.journals;
+  return Array.isArray(journals) ? journals.includes('*') || journals.includes(journalId) : journalId === 'global';
+}
+
+module.exports = { ConsumerRegistry, consumesJournal };

package/src/bridge/core/event-schema.js

@@ -1,127 +1,127 @@
-'use strict';
-
-const { isValidRepoIdentityV1 } = require('./repo-context');
-
-const SOURCES = ['claude-code', 'codex', 'opencode', 'zcode'];
-const IDENTITY_CONFIDENCE_LEVELS = ['exact', 'partial', 'unavailable'];
-const CAPTURE_STATUSES = ['complete', 'partial', 'gap'];
-const ROLES = ['user', 'assistant'];
-
-// AUD-ID-001: a shared fake session id aggregates unrelated events.
-const FORBIDDEN_SESSION_IDS = new Set(['', 'unknown-session', 'unknown', 'null', 'none']);
-
-class EventSchemaError extends Error {
-  constructor(message, field) {
-    super(message);
-    this.name = 'EventSchemaError';
-    this.field = field;
-  }
-}
-
-function evidenceLevelFor({ sessionId, turnId }) {
-  if (sessionId && turnId) return 'exact';
-  if (sessionId || turnId) return 'partial';
-  return 'unavailable';
-}
-
-const CONFIDENCE_RANK = { unavailable: 0, partial: 1, exact: 2 };
-
-function clampConfidence(requested, evidence) {
-  return CONFIDENCE_RANK[requested] <= CONFIDENCE_RANK[evidence] ? requested : evidence;
-}
-
-function raiseConfidenceToEvidence(current, evidence) {
-  return CONFIDENCE_RANK[evidence] > CONFIDENCE_RANK[current] ? evidence : current;
-}
-
-function validateAndNormalizeEvent(input) {
-  if (!input || typeof input !== 'object') {
-    throw new EventSchemaError('event must be an object', 'event');
-  }
-  if (!SOURCES.includes(input.source)) {
-    throw new EventSchemaError(`source must be one of ${SOURCES.join(', ')}`, 'source');
-  }
-  if (typeof input.eventType !== 'string' || !input.eventType) {
-    throw new EventSchemaError('eventType is required', 'eventType');
-  }
-  if (input.role !== undefined && input.role !== null && !ROLES.includes(input.role)) {
-    throw new EventSchemaError('role must be user, assistant or null', 'role');
-  }
-  if (input.content !== undefined && input.content !== null && typeof input.content !== 'string') {
-    throw new EventSchemaError('content must be a string or null', 'content');
-  }
-
-  let sessionId = input.sessionId === undefined ? null : input.sessionId;
-  if (sessionId !== null) {
-    if (typeof sessionId !== 'string') {
-      throw new EventSchemaError('sessionId must be a string or null', 'sessionId');
-    }
-    if (FORBIDDEN_SESSION_IDS.has(sessionId.toLowerCase())) {
-      throw new EventSchemaError('fake session ids such as unknown-session are forbidden', 'sessionId');
-    }
-  }
-  let turnId = input.turnId === undefined ? null : input.turnId;
-  if (turnId !== null && typeof turnId !== 'string') {
-    throw new EventSchemaError('turnId must be a string or null', 'turnId');
-  }
-
-  if (
-    input.identityConfidence !== undefined &&
-    !IDENTITY_CONFIDENCE_LEVELS.includes(input.identityConfidence)
-  ) {
-    throw new EventSchemaError('identityConfidence must be exact, partial or unavailable', 'identityConfidence');
-  }
-  if (input.repoIdentity !== undefined && input.repoIdentity !== null) {
-    // New automatic data must use repo-identity/v1 objects from
-    // resolveRepoContext. Plain strings are legacy records only; malformed
-    // objects are rejected so a guessed identity can never enter the journal.
-    if (typeof input.repoIdentity !== 'string' && !isValidRepoIdentityV1(input.repoIdentity)) {
-      throw new EventSchemaError('repoIdentity must be a valid repo-identity/v1 object, a legacy string, or null', 'repoIdentity');
-    }
-  }
-  if (input.eventKey !== undefined && input.eventKey !== null) {
-    if (typeof input.eventKey !== 'string' || !input.eventKey) {
-      throw new EventSchemaError('eventKey must be a non-empty string when present', 'eventKey');
-    }
-  }
-  if (input.captureStatus !== undefined && !CAPTURE_STATUSES.includes(input.captureStatus)) {
-    throw new EventSchemaError('captureStatus must be complete, partial or gap', 'captureStatus');
-  }
-
-  // Confidence may never overstate the captured evidence.
-  const evidenceLevel = evidenceLevelFor({ sessionId, turnId });
-  const requested = input.identityConfidence || evidenceLevel;
-  const identityConfidence = clampConfidence(requested, evidenceLevel);
-
-  const normalized = {
-    source: input.source,
-    eventType: input.eventType,
-    role: input.role === undefined ? null : input.role,
-    sessionId,
-    turnId,
-    identityConfidence,
-    captureStatus: input.captureStatus || 'complete'
-  };
-  if (input.content !== undefined) normalized.content = input.content;
-  if (input.eventKey !== undefined) normalized.eventKey = input.eventKey;
-  if (input.repoIdentity !== undefined) normalized.repoIdentity = input.repoIdentity;
-  if (input.projectPath !== undefined) normalized.projectPath = input.projectPath;
-  if (input.branch !== undefined) normalized.branch = input.branch;
-  if (input.headAtCapture !== undefined) normalized.headAtCapture = input.headAtCapture;
-  if (input.capturedAt !== undefined) normalized.capturedAt = input.capturedAt;
-  if (input.rawEventType !== undefined) normalized.rawEventType = input.rawEventType;
-  if (input.meta !== undefined) normalized.meta = input.meta;
-  return normalized;
-}
-
-module.exports = {
-  validateAndNormalizeEvent,
-  EventSchemaError,
-  SOURCES,
-  IDENTITY_CONFIDENCE_LEVELS,
-  CAPTURE_STATUSES,
-  FORBIDDEN_SESSION_IDS,
-  evidenceLevelFor,
-  clampConfidence,
-  raiseConfidenceToEvidence
-};
+'use strict';
+
+const { isValidRepoIdentityV1 } = require('./repo-context');
+
+const SOURCES = ['claude-code', 'codex', 'opencode', 'zcode'];
+const IDENTITY_CONFIDENCE_LEVELS = ['exact', 'partial', 'unavailable'];
+const CAPTURE_STATUSES = ['complete', 'partial', 'gap'];
+const ROLES = ['user', 'assistant'];
+
+// AUD-ID-001: a shared fake session id aggregates unrelated events.
+const FORBIDDEN_SESSION_IDS = new Set(['', 'unknown-session', 'unknown', 'null', 'none']);
+
+class EventSchemaError extends Error {
+  constructor(message, field) {
+    super(message);
+    this.name = 'EventSchemaError';
+    this.field = field;
+  }
+}
+
+function evidenceLevelFor({ sessionId, turnId }) {
+  if (sessionId && turnId) return 'exact';
+  if (sessionId || turnId) return 'partial';
+  return 'unavailable';
+}
+
+const CONFIDENCE_RANK = { unavailable: 0, partial: 1, exact: 2 };
+
+function clampConfidence(requested, evidence) {
+  return CONFIDENCE_RANK[requested] <= CONFIDENCE_RANK[evidence] ? requested : evidence;
+}
+
+function raiseConfidenceToEvidence(current, evidence) {
+  return CONFIDENCE_RANK[evidence] > CONFIDENCE_RANK[current] ? evidence : current;
+}
+
+function validateAndNormalizeEvent(input) {
+  if (!input || typeof input !== 'object') {
+    throw new EventSchemaError('event must be an object', 'event');
+  }
+  if (!SOURCES.includes(input.source)) {
+    throw new EventSchemaError(`source must be one of ${SOURCES.join(', ')}`, 'source');
+  }
+  if (typeof input.eventType !== 'string' || !input.eventType) {
+    throw new EventSchemaError('eventType is required', 'eventType');
+  }
+  if (input.role !== undefined && input.role !== null && !ROLES.includes(input.role)) {
+    throw new EventSchemaError('role must be user, assistant or null', 'role');
+  }
+  if (input.content !== undefined && input.content !== null && typeof input.content !== 'string') {
+    throw new EventSchemaError('content must be a string or null', 'content');
+  }
+
+  let sessionId = input.sessionId === undefined ? null : input.sessionId;
+  if (sessionId !== null) {
+    if (typeof sessionId !== 'string') {
+      throw new EventSchemaError('sessionId must be a string or null', 'sessionId');
+    }
+    if (FORBIDDEN_SESSION_IDS.has(sessionId.toLowerCase())) {
+      throw new EventSchemaError('fake session ids such as unknown-session are forbidden', 'sessionId');
+    }
+  }
+  let turnId = input.turnId === undefined ? null : input.turnId;
+  if (turnId !== null && typeof turnId !== 'string') {
+    throw new EventSchemaError('turnId must be a string or null', 'turnId');
+  }
+
+  if (
+    input.identityConfidence !== undefined &&
+    !IDENTITY_CONFIDENCE_LEVELS.includes(input.identityConfidence)
+  ) {
+    throw new EventSchemaError('identityConfidence must be exact, partial or unavailable', 'identityConfidence');
+  }
+  if (input.repoIdentity !== undefined && input.repoIdentity !== null) {
+    // New automatic data must use repo-identity/v1 objects from
+    // resolveRepoContext. Plain strings are legacy records only; malformed
+    // objects are rejected so a guessed identity can never enter the journal.
+    if (typeof input.repoIdentity !== 'string' && !isValidRepoIdentityV1(input.repoIdentity)) {
+      throw new EventSchemaError('repoIdentity must be a valid repo-identity/v1 object, a legacy string, or null', 'repoIdentity');
+    }
+  }
+  if (input.eventKey !== undefined && input.eventKey !== null) {
+    if (typeof input.eventKey !== 'string' || !input.eventKey) {
+      throw new EventSchemaError('eventKey must be a non-empty string when present', 'eventKey');
+    }
+  }
+  if (input.captureStatus !== undefined && !CAPTURE_STATUSES.includes(input.captureStatus)) {
+    throw new EventSchemaError('captureStatus must be complete, partial or gap', 'captureStatus');
+  }
+
+  // Confidence may never overstate the captured evidence.
+  const evidenceLevel = evidenceLevelFor({ sessionId, turnId });
+  const requested = input.identityConfidence || evidenceLevel;
+  const identityConfidence = clampConfidence(requested, evidenceLevel);
+
+  const normalized = {
+    source: input.source,
+    eventType: input.eventType,
+    role: input.role === undefined ? null : input.role,
+    sessionId,
+    turnId,
+    identityConfidence,
+    captureStatus: input.captureStatus || 'complete'
+  };
+  if (input.content !== undefined) normalized.content = input.content;
+  if (input.eventKey !== undefined) normalized.eventKey = input.eventKey;
+  if (input.repoIdentity !== undefined) normalized.repoIdentity = input.repoIdentity;
+  if (input.projectPath !== undefined) normalized.projectPath = input.projectPath;
+  if (input.branch !== undefined) normalized.branch = input.branch;
+  if (input.headAtCapture !== undefined) normalized.headAtCapture = input.headAtCapture;
+  if (input.capturedAt !== undefined) normalized.capturedAt = input.capturedAt;
+  if (input.rawEventType !== undefined) normalized.rawEventType = input.rawEventType;
+  if (input.meta !== undefined) normalized.meta = input.meta;
+  return normalized;
+}
+
+module.exports = {
+  validateAndNormalizeEvent,
+  EventSchemaError,
+  SOURCES,
+  IDENTITY_CONFIDENCE_LEVELS,
+  CAPTURE_STATUSES,
+  FORBIDDEN_SESSION_IDS,
+  evidenceLevelFor,
+  clampConfidence,
+  raiseConfidenceToEvidence
+};

package/src/bridge/core/fs-utils.js

@@ -1,81 +1,81 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-function fsyncDir(dir) {
-  try {
-    const fd = fs.openSync(dir, 'r');
-    try {
-      fs.fsyncSync(fd);
-    } finally {
-      fs.closeSync(fd);
-    }
-  } catch (_) {
-    // Directory fsync is best effort (not supported for directories on Windows).
-  }
-}
-
-function appendLineSync(file, line) {
-  const fd = fs.openSync(file, 'a');
-  try {
-    fs.writeSync(fd, line);
-    fs.fsyncSync(fd);
-  } finally {
-    fs.closeSync(fd);
-  }
-}
-
-function writeJsonAtomicSync(file, value) {
-  const tmp = `${file}.tmp`;
-  const fd = fs.openSync(tmp, 'w');
-  try {
-    fs.writeSync(fd, `${JSON.stringify(value, null, 2)}\n`);
-    fs.fsyncSync(fd);
-  } finally {
-    fs.closeSync(fd);
-  }
-  fs.renameSync(tmp, file);
-  fsyncDir(path.dirname(file));
-}
-
-function writeTextAtomicSync(file, text) {
-  const tmp = `${file}.tmp`;
-  const fd = fs.openSync(tmp, 'w');
-  try {
-    fs.writeSync(fd, text);
-    fs.fsyncSync(fd);
-  } finally {
-    fs.closeSync(fd);
-  }
-  fs.renameSync(tmp, file);
-  fsyncDir(path.dirname(file));
-}
-
-function readJsonIfExists(file) {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch (err) {
-    if (err && (err.code === 'ENOENT' || err instanceof SyntaxError)) return null;
-    throw err;
-  }
-}
-
-function ensureDirSync(dir) {
-  fs.mkdirSync(dir, { recursive: true });
-}
-
-function copyDirSync(src, dest) {
-  ensureDirSync(dest);
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-    const from = path.join(src, entry.name);
-    const to = path.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      copyDirSync(from, to);
-    } else if (entry.isFile()) {
-      fs.copyFileSync(from, to);
-    }
-  }
-}
-
-module.exports = { fsyncDir, appendLineSync, writeJsonAtomicSync, writeTextAtomicSync, readJsonIfExists, ensureDirSync, copyDirSync };
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function fsyncDir(dir) {
+  try {
+    const fd = fs.openSync(dir, 'r');
+    try {
+      fs.fsyncSync(fd);
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch (_) {
+    // Directory fsync is best effort (not supported for directories on Windows).
+  }
+}
+
+function appendLineSync(file, line) {
+  const fd = fs.openSync(file, 'a');
+  try {
+    fs.writeSync(fd, line);
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function writeJsonAtomicSync(file, value) {
+  const tmp = `${file}.tmp`;
+  const fd = fs.openSync(tmp, 'w');
+  try {
+    fs.writeSync(fd, `${JSON.stringify(value, null, 2)}\n`);
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, file);
+  fsyncDir(path.dirname(file));
+}
+
+function writeTextAtomicSync(file, text) {
+  const tmp = `${file}.tmp`;
+  const fd = fs.openSync(tmp, 'w');
+  try {
+    fs.writeSync(fd, text);
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, file);
+  fsyncDir(path.dirname(file));
+}
+
+function readJsonIfExists(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (err) {
+    if (err && (err.code === 'ENOENT' || err instanceof SyntaxError)) return null;
+    throw err;
+  }
+}
+
+function ensureDirSync(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function copyDirSync(src, dest) {
+  ensureDirSync(dest);
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const from = path.join(src, entry.name);
+    const to = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDirSync(from, to);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(from, to);
+    }
+  }
+}
+
+module.exports = { fsyncDir, appendLineSync, writeJsonAtomicSync, writeTextAtomicSync, readJsonIfExists, ensureDirSync, copyDirSync };