@doubledigit/cli 0.1.0

package/dist/lib/lock-file.js

@@ -0,0 +1,117 @@
+/**
+ * Manage dd-apps.lock.json — tracks externally-installed micro-apps.
+ *
+ * The lock file lives at the monorepo root and records the source,
+ * content hash, and timestamps for every app installed via `dd install`.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+const EMPTY_LOCK = { version: 1, apps: {} };
+/** Directories excluded from content hashing */
+const HASH_EXCLUDE_DIRS = new Set(['node_modules', '.turbo', 'dist']);
+/**
+ * Read and parse the lock file. Returns an empty lock structure if the file
+ * does not exist. Throws on malformed files to avoid silent data loss.
+ */
+export function readLockFile(lockPath) {
+    if (!fs.existsSync(lockPath)) {
+        return { ...EMPTY_LOCK, apps: {} };
+    }
+    const raw = fs.readFileSync(lockPath, 'utf-8');
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        // Back up the corrupted file so the user doesn't lose data
+        const backupPath = lockPath + '.bak';
+        fs.copyFileSync(lockPath, backupPath);
+        throw new Error(`Lock file is corrupted (backed up to ${backupPath}).\n` +
+            `Fix or delete ${lockPath} and retry.\n` +
+            `Parse error: ${err instanceof Error ? err.message : err}`);
+    }
+    const lock = parsed;
+    if (lock.version !== 1 ||
+        typeof lock.apps !== 'object' ||
+        lock.apps === null ||
+        Array.isArray(lock.apps)) {
+        const backupPath = lockPath + '.bak';
+        fs.copyFileSync(lockPath, backupPath);
+        throw new Error(`Lock file has unexpected format (backed up to ${backupPath}).\n` +
+            `Expected { version: 1, apps: {...} }. Fix or delete ${lockPath} and retry.`);
+    }
+    return lock;
+}
+/**
+ * Write the lock file to disk with deterministic key ordering.
+ */
+export function writeLockFile(lockPath, lock) {
+    const sorted = {
+        version: lock.version,
+        apps: Object.fromEntries(Object.entries(lock.apps).sort(([a], [b]) => a.localeCompare(b))),
+    };
+    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+    fs.writeFileSync(lockPath, JSON.stringify(sorted, null, 2) + '\n', 'utf-8');
+}
+/**
+ * Add or update a single entry in the lock file.
+ */
+export function addLockEntry(lockPath, key, entry) {
+    const lock = readLockFile(lockPath);
+    lock.apps[key] = entry;
+    writeLockFile(lockPath, lock);
+}
+/**
+ * Remove an entry from the lock file. No-op if the key doesn't exist.
+ */
+export function removeLockEntry(lockPath, key) {
+    const lock = readLockFile(lockPath);
+    if (!(key in lock.apps))
+        return;
+    delete lock.apps[key];
+    writeLockFile(lockPath, lock);
+}
+/**
+ * Check whether an app was externally installed (i.e. tracked in the lock file).
+ */
+export function isExternalApp(lockPath, key) {
+    const lock = readLockFile(lockPath);
+    return key in lock.apps;
+}
+/**
+ * Compute a deterministic SHA-256 content hash of every file in a directory.
+ *
+ * Excludes `node_modules`, `.turbo`, and `dist`. File paths are sorted for
+ * determinism and the hash covers both path and content.
+ */
+export async function computeContentHash(dir) {
+    const entries = [];
+    collectFiles(dir, dir, entries);
+    // Sort by relative path for determinism
+    entries.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    const hash = crypto.createHash('sha256');
+    for (const entry of entries) {
+        hash.update(entry.relativePath);
+        hash.update(':');
+        hash.update(entry.content);
+    }
+    return hash.digest('hex');
+}
+function collectFiles(baseDir, currentDir, out) {
+    const items = fs.readdirSync(currentDir, { withFileTypes: true });
+    for (const item of items) {
+        if (HASH_EXCLUDE_DIRS.has(item.name))
+            continue;
+        const fullPath = path.join(currentDir, item.name);
+        if (item.isDirectory()) {
+            collectFiles(baseDir, fullPath, out);
+        }
+        else if (item.isFile()) {
+            out.push({
+                relativePath: path.relative(baseDir, fullPath).split(path.sep).join('/'),
+                content: fs.readFileSync(fullPath),
+            });
+        }
+    }
+}