@remnic/core 9.3.599 → 9.3.601

package/dist/index.js

@@ -3618,10 +3618,14 @@ function hashContent3(content) {
 }
 
 // src/spaces/index.ts
+import { spawnSync } from "child_process";
+import crypto7 from "crypto";
 import fs7 from "fs";
 import path11 from "path";
-import crypto7 from "crypto";
 var MANIFEST_VERSION = 1;
+var MANIFEST_LOCK_STALE_MS = 3e4;
+var MANIFEST_LOCK_TIMEOUT_MS = MANIFEST_LOCK_STALE_MS + 1e4;
+var MANIFEST_LOCK_SLEEP_MS = 20;
 function normalizeSpaceMemoryDir(memoryDir) {
   return path11.resolve(memoryDir);
 }
@@ -3633,24 +3637,283 @@ function getManifestPath(baseDir) {
   return path11.join(getSpacesDir(baseDir), "manifest.json");
 }
 function loadManifest(baseDir, memoryDirOverride) {
+  if (fs7.existsSync(getManifestPath(baseDir))) {
+    try {
+      return readManifestUnlocked(baseDir, memoryDirOverride, { bootstrapIfMissing: false });
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  return updateManifest(baseDir, (manifest) => manifest, memoryDirOverride);
+}
+function saveManifest(manifest, baseDir) {
+  withManifestLock(baseDir, () => {
+    saveManifestUnlocked(manifest, baseDir);
+  });
+}
+function updateManifest(baseDir, updater, memoryDirOverride) {
+  return withManifestLock(baseDir, () => {
+    const manifest = readManifestUnlocked(baseDir, memoryDirOverride);
+    const result = updater(manifest);
+    saveManifestUnlocked(manifest, baseDir);
+    return result;
+  });
+}
+function readManifestUnlocked(baseDir, memoryDirOverride, options = {}) {
   const manifestPath2 = getManifestPath(baseDir);
   if (!fs7.existsSync(manifestPath2)) {
+    if (options.bootstrapIfMissing === false) {
+      const error = new Error(`Spaces manifest not found: ${manifestPath2}`);
+      error.code = "ENOENT";
+      throw error;
+    }
     const personalSpace = createPersonalSpace(baseDir, memoryDirOverride);
-    const manifest = {
+    return {
       activeSpaceId: personalSpace.id,
       spaces: [personalSpace],
       version: MANIFEST_VERSION
     };
-    saveManifest(manifest, baseDir);
-    return manifest;
   }
   const raw = JSON.parse(fs7.readFileSync(manifestPath2, "utf8"));
   return raw;
 }
-function saveManifest(manifest, baseDir) {
+function saveManifestUnlocked(manifest, baseDir) {
   const manifestPath2 = getManifestPath(baseDir);
-  fs7.mkdirSync(path11.dirname(manifestPath2), { recursive: true });
-  fs7.writeFileSync(manifestPath2, JSON.stringify(manifest, null, 2) + "\n");
+  const manifestDir2 = path11.dirname(manifestPath2);
+  fs7.mkdirSync(manifestDir2, { recursive: true });
+  const tempPath = path11.join(manifestDir2, `.manifest.${process.pid}.${Date.now()}.${crypto7.randomUUID()}.tmp`);
+  try {
+    fs7.writeFileSync(tempPath, `${JSON.stringify(manifest, null, 2)}
+`, { flag: "wx" });
+    fs7.renameSync(tempPath, manifestPath2);
+  } catch (error) {
+    try {
+      fs7.rmSync(tempPath, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function withManifestLock(baseDir, operation) {
+  const lockDir = `${getManifestPath(baseDir)}.lock`;
+  fs7.mkdirSync(path11.dirname(lockDir), { recursive: true });
+  const lockOwner = acquireManifestLock(lockDir);
+  try {
+    return operation();
+  } finally {
+    releaseManifestLock(lockDir, lockOwner);
+  }
+}
+function acquireManifestLock(lockDir) {
+  const deadline = Date.now() + MANIFEST_LOCK_TIMEOUT_MS;
+  const owner = createManifestLockOwner();
+  const reclaimDir = getManifestLockReclaimDir(lockDir);
+  while (true) {
+    if (fs7.existsSync(reclaimDir)) {
+      removeStaleManifestReclaimLock(reclaimDir);
+    }
+    if (fs7.existsSync(reclaimDir)) {
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for spaces manifest reclaim lock: ${reclaimDir}`);
+      }
+      sleepSync(MANIFEST_LOCK_SLEEP_MS);
+      continue;
+    }
+    try {
+      fs7.mkdirSync(lockDir, { recursive: false });
+      try {
+        fs7.writeFileSync(path11.join(lockDir, "owner"), `${owner}
+`, { flag: "wx" });
+      } catch (error) {
+        fs7.rmSync(lockDir, { recursive: true, force: true });
+        throw error;
+      }
+      if (fs7.existsSync(reclaimDir)) {
+        releaseManifestLock(lockDir, owner);
+        if (Date.now() >= deadline) {
+          throw new Error(`Timed out waiting for spaces manifest reclaim lock: ${reclaimDir}`);
+        }
+        sleepSync(MANIFEST_LOCK_SLEEP_MS);
+        continue;
+      }
+      return owner;
+    } catch (error) {
+      const code = error.code;
+      if (code !== "EEXIST") {
+        throw error;
+      }
+      removeStaleManifestLock(lockDir);
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for spaces manifest lock: ${lockDir}`);
+      }
+      sleepSync(MANIFEST_LOCK_SLEEP_MS);
+    }
+  }
+}
+function releaseManifestLock(lockDir, owner) {
+  try {
+    const ownerPath = path11.join(lockDir, "owner");
+    if (fs7.readFileSync(ownerPath, "utf8").trim() === owner) {
+      fs7.rmSync(lockDir, { recursive: true, force: true });
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+  }
+}
+function removeStaleManifestLock(lockDir) {
+  const reclaimDir = getManifestLockReclaimDir(lockDir);
+  const reclaimOwner = createManifestLockOwner();
+  try {
+    fs7.mkdirSync(reclaimDir, { recursive: false });
+    try {
+      fs7.writeFileSync(path11.join(reclaimDir, "owner"), `${reclaimOwner}
+`, { flag: "wx" });
+    } catch (error) {
+      fs7.rmSync(reclaimDir, { recursive: true, force: true });
+      throw error;
+    }
+  } catch (error) {
+    const code = error.code;
+    if (code === "EEXIST") {
+      return;
+    }
+    throw error;
+  }
+  try {
+    const snapshot = readManifestLockSnapshot(lockDir);
+    if (!snapshot || Date.now() - snapshot.mtimeMs <= MANIFEST_LOCK_STALE_MS) {
+      return;
+    }
+    if (isManifestLockOwnerActive(snapshot.owner)) {
+      return;
+    }
+    const tombstoneDir = `${lockDir}.stale.${process.pid}.${crypto7.randomUUID()}`;
+    try {
+      fs7.renameSync(lockDir, tombstoneDir);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+      return;
+    }
+    fs7.rmSync(tombstoneDir, { recursive: true, force: true });
+  } finally {
+    fs7.rmSync(reclaimDir, { recursive: true, force: true });
+  }
+}
+function getManifestLockReclaimDir(lockDir) {
+  return `${lockDir}.reclaim`;
+}
+function createManifestLockOwner() {
+  return JSON.stringify({
+    pid: process.pid,
+    startKey: readProcessStartKey(process.pid),
+    token: crypto7.randomUUID()
+  });
+}
+function removeStaleManifestReclaimLock(reclaimDir) {
+  const snapshot = readManifestLockSnapshot(reclaimDir);
+  if (!snapshot || Date.now() - snapshot.mtimeMs <= MANIFEST_LOCK_STALE_MS) {
+    return;
+  }
+  if (isManifestLockOwnerActive(snapshot.owner)) {
+    return;
+  }
+  const tombstoneDir = `${reclaimDir}.stale.${process.pid}.${crypto7.randomUUID()}`;
+  try {
+    fs7.renameSync(reclaimDir, tombstoneDir);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      throw error;
+    }
+    return;
+  }
+  fs7.rmSync(tombstoneDir, { recursive: true, force: true });
+}
+function readManifestLockSnapshot(lockDir) {
+  let stat;
+  try {
+    stat = fs7.statSync(lockDir);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  }
+  try {
+    const owner = fs7.readFileSync(path11.join(lockDir, "owner"), "utf8").trim();
+    return { mtimeMs: stat.mtimeMs, owner };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { mtimeMs: stat.mtimeMs };
+    }
+    throw error;
+  }
+}
+function isManifestLockOwnerActive(owner) {
+  if (!owner) {
+    return false;
+  }
+  const parsed = parseManifestLockOwner(owner);
+  if (!parsed) {
+    return false;
+  }
+  const currentStartKey = readProcessStartKey(parsed.pid);
+  if (currentStartKey && parsed.startKey) {
+    return currentStartKey === parsed.startKey;
+  }
+  return isProcessAlive(parsed.pid);
+}
+function parseManifestLockOwner(owner) {
+  try {
+    const parsed = JSON.parse(owner);
+    const pid = typeof parsed.pid === "number" ? parsed.pid : Number.NaN;
+    if (Number.isInteger(pid) && pid > 0) {
+      return {
+        pid,
+        startKey: typeof parsed.startKey === "string" && parsed.startKey.length > 0 ? parsed.startKey : void 0
+      };
+    }
+  } catch {
+  }
+  const legacyPid = Number(owner.split(":", 1)[0]);
+  return Number.isInteger(legacyPid) && legacyPid > 0 ? { pid: legacyPid } : void 0;
+}
+function readProcessStartKey(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return void 0;
+  }
+  const result = spawnSync("ps", ["-p", String(pid), "-o", "lstart="], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.error || result.status !== 0 || typeof result.stdout !== "string") {
+    return void 0;
+  }
+  const startKey = result.stdout.trim().replace(/\s+/g, " ");
+  return startKey.length > 0 ? startKey : void 0;
+}
+function isProcessAlive(pid) {
+  if (pid === process.pid) {
+    return true;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ESRCH") {
+      return false;
+    }
+    return true;
+  }
+}
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 function createPersonalSpace(baseDir, memoryDirOverride) {
   const homeDir = baseDir ?? resolveHomeDir();
@@ -3681,84 +3944,91 @@ function getActiveSpace(baseDir) {
   return space;
 }
 function createSpace(options) {
-  const manifest = loadManifest(options.baseDir);
   const id = options.name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-");
-  if (manifest.spaces.some((s) => s.id === id)) {
-    throw new Error(`Space "${id}" already exists`);
-  }
-  if (options.parentSpaceId && !manifest.spaces.some((s) => s.id === options.parentSpaceId)) {
-    throw new Error(`Parent space "${options.parentSpaceId}" not found`);
-  }
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const memoryDir = normalizeSpaceMemoryDir(
-    options.memoryDir ?? path11.join(
-      getSpacesDir(options.baseDir),
+    options.memoryDir ?? path11.join(getSpacesDir(options.baseDir), id, "memory")
+  );
+  const space = updateManifest(options.baseDir, (manifest) => {
+    if (manifest.spaces.some((s) => s.id === id)) {
+      throw new Error(`Space "${id}" already exists`);
+    }
+    if (options.parentSpaceId && !manifest.spaces.some((s) => s.id === options.parentSpaceId)) {
+      throw new Error(`Parent space "${options.parentSpaceId}" not found`);
+    }
+    const created = {
       id,
-      "memory"
-    )
+      name: options.name,
+      kind: options.kind,
+      description: options.description,
+      memoryDir,
+      createdAt: now,
+      updatedAt: now,
+      owner: readEnvVar("USER"),
+      parentSpaceId: options.parentSpaceId
+    };
+    fs7.mkdirSync(memoryDir, { recursive: true });
+    manifest.spaces.push(created);
+    manifest.updatedAt = now;
+    return created;
+  });
+  appendAudit(
+    {
+      action: "space.create",
+      sourceSpaceId: id,
+      details: `Created ${options.kind} space "${options.name}"`
+    },
+    options.baseDir
   );
-  const space = {
-    id,
-    name: options.name,
-    kind: options.kind,
-    description: options.description,
-    memoryDir,
-    createdAt: now,
-    updatedAt: now,
-    owner: readEnvVar("USER"),
-    parentSpaceId: options.parentSpaceId
-  };
-  fs7.mkdirSync(memoryDir, { recursive: true });
-  manifest.spaces.push(space);
-  manifest.updatedAt = now;
-  saveManifest(manifest, options.baseDir);
-  appendAudit({
-    action: "space.create",
-    sourceSpaceId: id,
-    details: `Created ${options.kind} space "${options.name}"`
-  }, options.baseDir);
   return space;
 }
 function deleteSpace(spaceId, baseDir) {
-  const manifest = loadManifest(baseDir);
   if (spaceId === "personal") {
     throw new Error("Cannot delete the personal space");
   }
-  const idx = manifest.spaces.findIndex((s) => s.id === spaceId);
-  if (idx === -1) throw new Error(`Space "${spaceId}" not found`);
-  if (manifest.activeSpaceId === spaceId) {
-    manifest.activeSpaceId = "personal";
-  }
-  for (const space of manifest.spaces) {
-    if (space.parentSpaceId === spaceId) {
-      space.parentSpaceId = void 0;
+  updateManifest(baseDir, (manifest) => {
+    const idx = manifest.spaces.findIndex((s) => s.id === spaceId);
+    if (idx === -1) throw new Error(`Space "${spaceId}" not found`);
+    if (manifest.activeSpaceId === spaceId) {
+      manifest.activeSpaceId = "personal";
     }
-  }
-  manifest.spaces.splice(idx, 1);
-  saveManifest(manifest, baseDir);
-  appendAudit({
-    action: "space.delete",
-    sourceSpaceId: spaceId,
-    details: `Deleted space "${spaceId}"`
-  }, baseDir);
+    for (const space of manifest.spaces) {
+      if (space.parentSpaceId === spaceId) {
+        space.parentSpaceId = void 0;
+      }
+    }
+    manifest.spaces.splice(idx, 1);
+  });
+  appendAudit(
+    {
+      action: "space.delete",
+      sourceSpaceId: spaceId,
+      details: `Deleted space "${spaceId}"`
+    },
+    baseDir
+  );
 }
 function switchSpace(spaceId, baseDir) {
-  const manifest = loadManifest(baseDir);
-  const space = manifest.spaces.find((s) => s.id === spaceId);
-  if (!space) throw new Error(`Space "${spaceId}" not found`);
-  const previousId = manifest.activeSpaceId;
-  manifest.activeSpaceId = spaceId;
-  saveManifest(manifest, baseDir);
-  appendAudit({
-    action: "space.switch",
-    sourceSpaceId: previousId,
-    targetSpaceId: spaceId,
-    details: `Switched from "${previousId}" to "${spaceId}"`
-  }, baseDir);
+  const { previousId, spaceName } = updateManifest(baseDir, (manifest) => {
+    const space = manifest.spaces.find((s) => s.id === spaceId);
+    if (!space) throw new Error(`Space "${spaceId}" not found`);
+    const previousId2 = manifest.activeSpaceId;
+    manifest.activeSpaceId = spaceId;
+    return { previousId: previousId2, spaceName: space.name };
+  });
+  appendAudit(
+    {
+      action: "space.switch",
+      sourceSpaceId: previousId,
+      targetSpaceId: spaceId,
+      details: `Switched from "${previousId}" to "${spaceId}"`
+    },
+    baseDir
+  );
   return {
     previousSpaceId: previousId,
     currentSpaceId: spaceId,
-    message: `Switched to "${space.name}"`
+    message: `Switched to "${spaceName}"`
   };
 }
 function pushToSpace(sourceSpaceId, targetSpaceId, options) {
@@ -3772,12 +4042,15 @@ function pushToSpace(sourceSpaceId, targetSpaceId, options) {
     filterIds: options?.memoryIds,
     force: options?.force
   });
-  appendAudit({
-    action: "space.push",
-    sourceSpaceId,
-    targetSpaceId,
-    details: `Pushed ${result.merged} memories, ${result.conflicts.length} conflicts`
-  }, options?.baseDir);
+  appendAudit(
+    {
+      action: "space.push",
+      sourceSpaceId,
+      targetSpaceId,
+      details: `Pushed ${result.merged} memories, ${result.conflicts.length} conflicts`
+    },
+    options?.baseDir
+  );
   return {
     sourceSpaceId,
     targetSpaceId,
@@ -3797,12 +4070,15 @@ function pullFromSpace(sourceSpaceId, targetSpaceId, options) {
     filterIds: options?.memoryIds,
     force: options?.force
   });
-  appendAudit({
-    action: "space.pull",
-    sourceSpaceId,
-    targetSpaceId,
-    details: `Pulled ${result.merged} memories, ${result.conflicts.length} conflicts`
-  }, options?.baseDir);
+  appendAudit(
+    {
+      action: "space.pull",
+      sourceSpaceId,
+      targetSpaceId,
+      details: `Pulled ${result.merged} memories, ${result.conflicts.length} conflicts`
+    },
+    options?.baseDir
+  );
   return {
     sourceSpaceId,
     targetSpaceId,
@@ -3812,22 +4088,26 @@ function pullFromSpace(sourceSpaceId, targetSpaceId, options) {
   };
 }
 function shareSpace(spaceId, members, baseDir) {
-  const manifest = loadManifest(baseDir);
-  const space = manifest.spaces.find((s) => s.id === spaceId);
-  if (!space) throw new Error(`Space "${spaceId}" not found`);
-  if (space.kind === "personal") throw new Error("Cannot share personal space");
-  space.members = [.../* @__PURE__ */ new Set([...space.members ?? [], ...members])];
-  space.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  saveManifest(manifest, baseDir);
-  appendAudit({
-    action: "space.share",
-    sourceSpaceId: spaceId,
-    details: `Shared with: ${members.join(", ")}`
-  }, baseDir);
+  const spaceName = updateManifest(baseDir, (manifest) => {
+    const space = manifest.spaces.find((s) => s.id === spaceId);
+    if (!space) throw new Error(`Space "${spaceId}" not found`);
+    if (space.kind === "personal") throw new Error("Cannot share personal space");
+    space.members = [.../* @__PURE__ */ new Set([...space.members ?? [], ...members])];
+    space.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    return space.name;
+  });
+  appendAudit(
+    {
+      action: "space.share",
+      sourceSpaceId: spaceId,
+      details: `Shared with: ${members.join(", ")}`
+    },
+    baseDir
+  );
   return {
     spaceId,
     sharedWith: members,
-    message: `Shared "${space.name}" with ${members.length} member(s)`
+    message: `Shared "${spaceName}" with ${members.length} member(s)`
   };
 }
 function promoteSpace(sourceSpaceId, targetSpaceId, options) {
@@ -3846,12 +4126,15 @@ function promoteSpace(sourceSpaceId, targetSpaceId, options) {
     filterIds: options?.memoryIds,
     force: options?.forceOverwrite !== void 0 ? options.forceOverwrite : options?.force ?? false
   });
-  appendAudit({
-    action: "space.promote",
-    sourceSpaceId,
-    targetSpaceId,
-    details: `Promoted ${result.merged} memories from "${source.name}" to "${target.name}"`
-  }, options?.baseDir);
+  appendAudit(
+    {
+      action: "space.promote",
+      sourceSpaceId,
+      targetSpaceId,
+      details: `Promoted ${result.merged} memories from "${source.name}" to "${target.name}"`
+    },
+    options?.baseDir
+  );
   return {
     sourceSpaceId,
     targetSpaceId,
@@ -3870,12 +4153,15 @@ function mergeSpaces(sourceSpaceId, targetSpaceId, options) {
   const result = copyMemories(source.memoryDir, target.memoryDir, {
     force: options?.force
   });
-  appendAudit({
-    action: "space.merge",
-    sourceSpaceId,
-    targetSpaceId,
-    details: `Merged: ${result.merged} merged, ${result.conflicts.length} conflicts, ${result.skipped} skipped`
-  }, options?.baseDir);
+  appendAudit(
+    {
+      action: "space.merge",
+      sourceSpaceId,
+      targetSpaceId,
+      details: `Merged: ${result.merged} merged, ${result.conflicts.length} conflicts, ${result.skipped} skipped`
+    },
+    options?.baseDir
+  );
   return {
     ...result,
     durationMs: Date.now() - startTime
@@ -3895,7 +4181,8 @@ function appendAudit(entry, baseDir) {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     ...entry
   };
-  fs7.appendFileSync(auditPath, JSON.stringify(full) + "\n");
+  fs7.appendFileSync(auditPath, `${JSON.stringify(full)}
+`);
 }
 function copyMemories(sourceDir, targetDir, options) {
   let merged = 0;