isomorphic-jj 1.7.0 → 1.8.0

package/src/core/storage-manager.js

@@ -5,6 +5,7 @@
  */
 
 import { JJError } from '../utils/errors.js';
+import { KeyedMutex } from '../utils/mutex.js';
 
 export class Storage {
   /**
@@ -18,6 +19,13 @@ export class Storage {
     this.repoDir = `${dir}/.jj/repo`; // Core repo data
     this.workingCopyDir = `${dir}/.jj/working_copy`; // Default workspace working copy
     this.cache = new Map();
+
+    // Serializes write()/appendLine() critical sections per path so that
+    // concurrent same-process callers (e.g. a user command racing
+    // BackgroundOps's autosnapshot) can't interleave a read-modify-write
+    // cycle and silently lose an update. This only protects callers that
+    // share this Storage instance — cross-process locking is out of scope.
+    this._locks = new KeyedMutex();
   }
 
   /**
@@ -92,8 +100,28 @@ export class Storage {
    * @param {Object|string} data - Data to write (object will be stringified)
    */
   async write(path, data) {
+    return this._locks.run(path, () => this._writeLocked(path, data));
+  }
+
+  /**
+   * Unlocked implementation of write(). Only call this from within a
+   * `this._locks.run(path, ...)` critical section (directly from write()
+   * itself, or from appendLine() which holds the same path's lock already).
+   *
+   * @param {string} path - Relative path from .jj directory
+   * @param {Object|string} data - Data to write (object will be stringified)
+   */
+  async _writeLocked(path, data) {
     const fullPath = `${this.jjDir}/${path}`;
-    const tmpPath = `${fullPath}.tmp.${Date.now()}`;
+    // Random suffix (not just a millisecond timestamp) so two concurrent
+    // writes to the same path never collide on the temp filename — a
+    // collision would let one write's error-cleanup unlink() delete the
+    // other's still in-flight temp file.
+    const tmpSuffix =
+      typeof crypto !== 'undefined' && crypto.randomUUID
+        ? crypto.randomUUID()
+        : `${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+    const tmpPath = `${fullPath}.tmp.${Date.now()}.${tmpSuffix}`;
     const jsonData = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
 
     try {
@@ -163,16 +191,25 @@ export class Storage {
     const fullPath = `${this.jjDir}/${path}`;
 
     try {
-      // Read existing content
-      let existing = '';
-      try {
-        existing = await this.fs.promises.readFile(fullPath, 'utf8');
-      } catch (error) {
-        if (error.code !== 'ENOENT') throw error;
-      }
+      // Hold the same per-path lock write() uses for the *entire*
+      // read-modify-write cycle (not just the write half). Without this,
+      // two concurrent appendLine() calls on the same path can both read
+      // the pre-append content, and the loser's write silently drops its
+      // line even though both calls report success.
+      await this._locks.run(path, async () => {
+        // Read existing content
+        let existing = '';
+        try {
+          existing = await this.fs.promises.readFile(fullPath, 'utf8');
+        } catch (error) {
+          if (error.code !== 'ENOENT') throw error;
+        }
 
-      // Write atomically
-      await this.write(path, existing + line + '\n');
+        // Write atomically (already inside this path's lock, so use the
+        // unlocked implementation to avoid deadlocking on a non-reentrant
+        // per-key mutex).
+        await this._writeLocked(path, existing + line + '\n');
+      });
     } catch (error) {
       throw new JJError('STORAGE_WRITE_FAILED', `Failed to append to ${path}: ${error.message}`, {
         path: fullPath,

package/src/core/tag-store.js

@@ -56,18 +56,36 @@ export class TagStore {
     this.fs = fs;
     this.jjDir = jjDir;
     this.tagsFile = `${jjDir}/store/tags.json`;
+    /**
+     * Tracking info for local tags mirrored from a remote (jj v0.44 `jj tag
+     * track`/`untrack`). Keyed by local tag name: { remote, remoteName }.
+     * @type {Record<string, any>}
+     */
+    this.tracking = {};
   }
 
   /**
-   * Loads tags from storage
+   * Loads tags (and their remote-tracking info, jj v0.44) from storage
    * @returns {Promise<Record<string, any>>} Map of tag name to changeId
    */
   async load() {
     try {
       const data = await this.fs.promises.readFile(this.tagsFile, 'utf8');
-      return JSON.parse(data);
+      const parsed = JSON.parse(data);
+
+      // v0.44: tags.json may be either the legacy flat `{ name: changeId }`
+      // map, or the newer `{ tags: {...}, tracked: {...} }` shape that also
+      // carries remote-tracking state. Support both for backward compat.
+      if (parsed && typeof parsed === 'object' && 'tags' in parsed) {
+        this.tracking = parsed.tracked || {};
+        return parsed.tags || {};
+      }
+
+      this.tracking = {};
+      return parsed || {};
     } catch (error) {
       if (error.code === 'ENOENT') {
+        this.tracking = {};
         return {};
       }
       throw error;
@@ -75,7 +93,7 @@ export class TagStore {
   }
 
   /**
-   * Saves tags to storage
+   * Saves tags (and their remote-tracking info, jj v0.44) to storage
    * @param {Object} tags - Map of tag name to changeId
    * @returns {Promise<void>}
    */
@@ -87,7 +105,10 @@ export class TagStore {
     } catch (err) {
       // Directory might already exist, ignore
     }
-    await this.fs.promises.writeFile(this.tagsFile, JSON.stringify(tags, null, 2));
+    await this.fs.promises.writeFile(
+      this.tagsFile,
+      JSON.stringify({ tags, tracked: this.tracking || {} }, null, 2)
+    );
   }
 
   /**
@@ -116,9 +137,11 @@ export class TagStore {
   }
 
   /**
-   * Lists all tags, optionally filtered by pattern
+   * Lists all tags, optionally filtered by pattern. Each entry also carries
+   * a `tracking: { remote, ref }` field when the tag is tracking a remote
+   * (jj v0.44 `jj tag track`).
    * @param {string} [pattern] - Optional glob pattern
-   * @returns {Promise<Array<{name: string, changeId: string}>>}
+   * @returns {Promise<Array<Record<string, any>>>}
    */
   async list(pattern) {
     const tags = await this.load();
@@ -129,10 +152,17 @@ export class TagStore {
       tagNames = tagNames.filter((name) => matchesPattern(name, pattern));
     }
 
-    return tagNames.map((name) => ({
-      name,
-      changeId: tags[name],
-    }));
+    return tagNames.map((name) => {
+      /** @type {Record<string, any>} */
+      const tag = { name, changeId: tags[name] };
+      if (this.tracking && this.tracking[name]) {
+        tag.tracking = {
+          remote: this.tracking[name].remote,
+          ref: this.tracking[name].remoteName || name,
+        };
+      }
+      return tag;
+    });
   }
 
   /**

package/src/utils/atomic-write.js

@@ -0,0 +1,44 @@
+/**
+ * Shared atomic-write helper for filesystem writes.
+ *
+ * Writes content to a uniquely-named temp file, then renames it over the
+ * canonical path. A crash/error between those two steps leaves the
+ * canonical file untouched (never a truncated/partial write) — the temp
+ * file is best-effort cleaned up on failure.
+ *
+ * This mirrors the pattern `Storage.write()` (src/core/storage-manager.js)
+ * already uses for JSON stores, factored out so the protobuf-backed stores
+ * (JJOperationStore, JJViewStore, JJTreeState) can use it too instead of
+ * calling `writeFile()` directly on the canonical path — see issue #16.
+ */
+
+/**
+ * @param {any} fs - Filesystem implementation (Node fs, LightningFS, etc.)
+ * @param {string} targetPath - Canonical path to write to
+ * @param {string|Uint8Array} content - Content to write
+ */
+export async function atomicWriteFile(fs, targetPath, content) {
+  const tmpSuffix =
+    typeof crypto !== 'undefined' && crypto.randomUUID
+      ? crypto.randomUUID()
+      : `${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+  const tmpPath = `${targetPath}.tmp.${Date.now()}.${tmpSuffix}`;
+
+  try {
+    const dirPath = targetPath.substring(0, targetPath.lastIndexOf('/'));
+    if (dirPath) {
+      await fs.promises.mkdir(dirPath, { recursive: true });
+    }
+
+    await fs.promises.writeFile(tmpPath, content);
+    await fs.promises.rename(tmpPath, targetPath);
+  } catch (error) {
+    try {
+      await fs.promises.unlink(tmpPath);
+    } catch {
+      // Best-effort cleanup; ignore if the temp file was never created (or
+      // is already gone).
+    }
+    throw error;
+  }
+}

package/src/utils/mutex.js

@@ -0,0 +1,63 @@
+/**
+ * Small in-process locking utilities.
+ *
+ * These provide same-process concurrency safety only — they do not protect
+ * against races between separate OS processes sharing the same on-disk
+ * repository. Cross-process locking is a separate concern (e.g. a lockfile
+ * with retry/backoff) and is intentionally out of scope here.
+ */
+
+/**
+ * A simple FIFO async mutex: `run(fn)` queues `fn` to execute only once all
+ * previously-queued work on this mutex has settled, serializing access to
+ * whatever critical section `fn` represents.
+ */
+export class Mutex {
+  constructor() {
+    /** @type {Promise<any>} */
+    this._queue = Promise.resolve();
+  }
+
+  /**
+   * @template T
+   * @param {() => Promise<T>} fn
+   * @returns {Promise<T>}
+   */
+  run(fn) {
+    const result = this._queue.then(() => fn());
+    // Keep the queue moving even if `fn` rejects — a failed critical section
+    // must not permanently wedge the lock for subsequent callers.
+    this._queue = result.then(
+      () => undefined,
+      () => undefined
+    );
+    return result;
+  }
+}
+
+/**
+ * A registry of mutexes keyed by an arbitrary string (typically a file path),
+ * so unrelated paths don't contend with each other while operations on the
+ * *same* path are fully serialized.
+ */
+export class KeyedMutex {
+  constructor() {
+    /** @type {Map<string, Mutex>} */
+    this._mutexes = new Map();
+  }
+
+  /**
+   * @template T
+   * @param {string} key
+   * @param {() => Promise<T>} fn
+   * @returns {Promise<T>}
+   */
+  run(key, fn) {
+    let mutex = this._mutexes.get(key);
+    if (!mutex) {
+      mutex = new Mutex();
+      this._mutexes.set(key, mutex);
+    }
+    return mutex.run(fn);
+  }
+}