@tinycloud/operations 0.3.3-beta.12 → 0.3.3-beta.14

package/coverage.json

@@ -3,6 +3,7 @@
   "source": "packages/cli/src/command-registry.ts",
   "commands": [
     { "command": "init", "status": "legacy" },
+    { "command": "context", "status": "excluded", "reason": "Read-only local CLI context diagnostics; performs no storage operation." },
     { "command": "enable", "status": "legacy" },
     { "command": "enable share", "status": "legacy" },
     { "command": "auth", "status": "legacy" },

package/dist/artifacts.cjs

@@ -6958,8 +6958,18 @@ var DEFAULT_LOCK_TIMEOUT_MS = 2e3;
 var DEFAULT_LOCK_RETRY_MS = 25;
 var DEFAULT_STALE_LOCK_MS = 3e4;
 var TEST_LOCK_CONTENTION_SIGNAL_PATH = "TC_TEST_PROFILE_LOCK_CONTENTION_SIGNAL_PATH";
+var PRIVATE_FILE_MODE = 384;
+var PRIVATE_DIR_MODE = 448;
 var TEST_LOCK_RECOVERY_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_RECOVERY_BARRIER_DIR";
+var TEST_LOCK_OWNERLESS_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_OWNERLESS_BARRIER_DIR";
+var TEST_LOCK_PUBLISH_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_PUBLISH_BARRIER_DIR";
+var TEST_LOCK_RELEASE_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_RELEASE_BARRIER_DIR";
+var TEST_LOCK_CLAIM_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_CLAIM_BARRIER_DIR";
+var TEST_LOCK_CLAIMED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_CLAIMED_BARRIER_DIR";
+var TEST_LOCK_FENCED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_FENCED_BARRIER_DIR";
+var TEST_LOCK_VERIFIED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_VERIFIED_BARRIER_DIR";
 var invocationStateRoot = new import_node_async_hooks.AsyncLocalStorage();
+var heldProfileLocks = new import_node_async_hooks.AsyncLocalStorage();
 var ProfileLockTimeoutError = class extends Error {
   constructor(profile, timeoutMs) {
     super(`Timed out waiting for the profile lock for "${profile}" after ${timeoutMs}ms.`);
@@ -6986,9 +6996,6 @@ function profileStoreMetadataPath(profile, store) {
 function profileLockPath(profile) {
   return (0, import_node_path.join)(profilePath(profile), ".lock");
 }
-function profileLockMetadataPath(profile) {
-  return (0, import_node_path.join)(profileLockPath(profile), "owner.json");
-}
 async function readJson(filePath) {
   try {
     return JSON.parse(await (0, import_promises.readFile)(filePath, "utf8"));
@@ -7005,9 +7012,9 @@ async function writeJsonAtomic(filePath, value) {
   );
   const contents = `${JSON.stringify(value, null, 2)}
 `;
-  await (0, import_promises.mkdir)(directory, { recursive: true });
+  await (0, import_promises.mkdir)(directory, { recursive: true, mode: PRIVATE_DIR_MODE });
   try {
-    await (0, import_promises.writeFile)(temporaryPath, contents, "utf8");
+    await (0, import_promises.writeFile)(temporaryPath, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
     await (0, import_promises.rename)(temporaryPath, filePath);
   } catch (error) {
     await (0, import_promises.rm)(temporaryPath, { force: true }).catch(() => void 0);
@@ -7037,10 +7044,15 @@ async function readProfileStore(profile, store) {
 }
 async function withProfileLock(profile, action, options = {}) {
   const normalizedProfile = validateProfileName(profile);
+  const lockPath = profileLockPath(normalizedProfile);
+  const held = (heldProfileLocks.getStore() ?? []).filter((ownership2) => ownership2.active);
+  if (held.some((ownership2) => ownership2.lockPath === lockPath)) return action();
   const release = await acquireProfileLock(normalizedProfile, options);
+  const ownership = { lockPath, active: true };
   try {
-    return await action();
+    return await heldProfileLocks.run([...held, ownership], action);
   } finally {
+    ownership.active = false;
     await release();
   }
 }
@@ -7067,28 +7079,18 @@ async function acquireProfileLock(profile, options) {
   const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_LOCK_MS;
   const startedAt = Date.now();
   const lockPath = profileLockPath(profile);
-  await (0, import_promises.mkdir)(profilePath(profile), { recursive: true });
+  await (0, import_promises.mkdir)(profilePath(profile), { recursive: true, mode: PRIVATE_DIR_MODE });
+  for (const directory of [tinycloudHomePath(), profilesPath(), profilePath(profile)]) {
+    await (0, import_promises.chmod)(directory, PRIVATE_DIR_MODE);
+  }
   while (true) {
-    try {
-      await (0, import_promises.mkdir)(lockPath);
-      const token = (0, import_node_crypto.randomUUID)();
-      try {
-        await writeJsonAtomic(profileLockMetadataPath(profile), {
-          pid: process.pid,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          token
-        });
-      } catch (error) {
-        await (0, import_promises.rmdir)(lockPath).catch(() => void 0);
-        throw error;
-      }
+    const token = (0, import_node_crypto.randomUUID)();
+    if (await publishProfileLock(profile, lockPath, token)) {
       return async () => {
-        await releaseProfileLock(lockPath, token);
+        await releaseProfileLock(profile, lockPath, token);
       };
-    } catch (error) {
-      if (!isLockAlreadyHeld(error)) throw error;
-      await signalTestLockContention(profile);
     }
+    await signalTestLockContention(profile);
     if (await recoverStaleLock(profile, lockPath, staleAfterMs)) continue;
     const elapsedMs = Date.now() - startedAt;
     if (elapsedMs >= timeoutMs) {
@@ -7097,21 +7099,35 @@ async function acquireProfileLock(profile, options) {
     await sleep(Math.min(retryMs, timeoutMs - elapsedMs));
   }
 }
-async function releaseProfileLock(lockPath, token) {
-  const ownerPath = (0, import_node_path.join)(lockPath, "owner.json");
-  const claimPath = (0, import_node_path.join)(lockPath, `.release-${token}.json`);
+async function publishProfileLock(profile, lockPath, token) {
   try {
-    await (0, import_promises.rename)(ownerPath, claimPath);
+    await (0, import_promises.mkdir)(lockPath, { mode: PRIVATE_DIR_MODE });
   } catch (error) {
-    if (isErrno(error, "ENOENT")) return;
+    if (isErrno(error, "EEXIST")) return false;
     throw error;
   }
-  const claimed = await readJson(claimPath).catch(() => null);
-  if (claimed?.token !== token) {
-    await (0, import_promises.rename)(claimPath, ownerPath).catch(() => void 0);
-    return;
+  await waitForTestBarrier(TEST_LOCK_PUBLISH_BARRIER_DIR, profile);
+  const staged = (0, import_node_path.join)((0, import_node_path.dirname)(lockPath), `.lock-owner-${token}.tmp`);
+  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token };
+  try {
+    await (0, import_promises.writeFile)(staged, `${JSON.stringify(owner, null, 2)}
+`, { encoding: "utf8", mode: PRIVATE_FILE_MODE, flag: "wx" });
+    await (0, import_promises.link)(staged, (0, import_node_path.join)(lockPath, "owner.json"));
+    return true;
+  } catch (error) {
+    if (isErrno(error, "EEXIST") || isErrno(error, "ENOENT")) return false;
+    await (0, import_promises.rmdir)(lockPath).catch(() => void 0);
+    throw error;
+  } finally {
+    await (0, import_promises.rm)(staged, { force: true }).catch(() => void 0);
   }
-  await (0, import_promises.rm)(claimPath, { force: true });
+}
+async function releaseProfileLock(profile, lockPath, token) {
+  const ownerPath = (0, import_node_path.join)(lockPath, "owner.json");
+  const owner = await readJson(ownerPath).catch(() => null);
+  if (owner?.token !== token) return;
+  await (0, import_promises.rm)(ownerPath, { force: true });
+  await waitForTestBarrier(TEST_LOCK_RELEASE_BARRIER_DIR, profile);
   await (0, import_promises.rmdir)(lockPath).catch(() => void 0);
 }
 async function signalTestLockContention(profile) {
@@ -7128,32 +7144,79 @@ async function signalTestLockContention(profile) {
   await (0, import_promises.writeFile)(signalPath, `${profile}
 `, { encoding: "utf8", flag: "wx" }).catch(() => void 0);
 }
+async function recoverOwnerlessLock(profile, lockPath, staleAfterMs) {
+  try {
+    const { mtimeMs } = await (0, import_promises.stat)(lockPath);
+    if (Date.now() - mtimeMs < staleAfterMs) return false;
+  } catch {
+    return false;
+  }
+  const checkedAt = performance.now();
+  await waitForTestBarrier(TEST_LOCK_OWNERLESS_BARRIER_DIR, profile);
+  try {
+    const entries = await (0, import_promises.readdir)(lockPath);
+    if (entries.includes("owner.json")) return false;
+    if (recoveryFenced(checkedAt, staleAfterMs)) return false;
+    for (const name of entries.filter((entry) => ABANDONED_CLAIM.test(entry))) {
+      await (0, import_promises.rm)((0, import_node_path.join)(lockPath, name), { force: true });
+    }
+    await (0, import_promises.rmdir)(lockPath);
+  } catch {
+    return false;
+  }
+  await removeAgedOwnerFiles(lockPath, staleAfterMs);
+  return true;
+}
+function recoveryFenced(since, staleAfterMs) {
+  return performance.now() - since >= staleAfterMs / 2;
+}
+var ABANDONED_CLAIM = /^\.(?:release|stale)-[0-9a-f-]+\.json$/;
+var STAGED_OWNER = /^\.lock-owner-[0-9a-f-]+\.tmp$/;
+async function removeAgedOwnerFiles(lockPath, staleAfterMs) {
+  const directory = (0, import_node_path.dirname)(lockPath);
+  const names = await (0, import_promises.readdir)(directory).catch(() => []);
+  for (const name of names.filter((entry) => STAGED_OWNER.test(entry))) {
+    const path = (0, import_node_path.join)(directory, name);
+    const aged = await (0, import_promises.stat)(path).then(({ mtimeMs }) => Date.now() - mtimeMs >= staleAfterMs, () => false);
+    if (aged) await (0, import_promises.rm)(path, { force: true }).catch(() => void 0);
+  }
+}
 async function recoverStaleLock(profile, lockPath, staleAfterMs) {
   const ownerPath = (0, import_node_path.join)(lockPath, "owner.json");
   const owner = await readJson(ownerPath).catch(() => null);
+  if (owner === null) return recoverOwnerlessLock(profile, lockPath, staleAfterMs);
   if (!isStaleOwner(owner, staleAfterMs)) return false;
   const observedToken = typeof owner?.token === "string" && owner.token.length > 0 ? owner.token : "legacy";
-  await waitForTestStaleRecoveryBarrier(profile);
+  await waitForTestBarrier(TEST_LOCK_RECOVERY_BARRIER_DIR, profile);
   const claimPath = (0, import_node_path.join)(lockPath, `.stale-${(0, import_node_crypto.randomUUID)()}.json`);
   try {
-    await (0, import_promises.rename)(ownerPath, claimPath);
-  } catch (error) {
-    if (isErrno(error, "ENOENT")) return false;
+    await (0, import_promises.link)(ownerPath, claimPath);
+  } catch {
     return false;
   }
+  const claimedAt = performance.now();
+  await waitForTestBarrier(TEST_LOCK_CLAIM_BARRIER_DIR, profile);
   const claimed = await readJson(claimPath).catch(() => null);
   const sameInstance = claimed !== null && (observedToken === "legacy" ? claimed.token === void 0 : claimed.token === observedToken);
-  if (!sameInstance) {
-    await (0, import_promises.rename)(claimPath, ownerPath).catch(() => void 0);
+  await waitForTestBarrier(TEST_LOCK_VERIFIED_BARRIER_DIR, profile);
+  if (sameInstance && recoveryFenced(claimedAt, staleAfterMs)) {
+    await (0, import_promises.rm)(claimPath, { force: true });
+    await waitForTestBarrier(TEST_LOCK_FENCED_BARRIER_DIR, profile);
     return false;
   }
+  if (sameInstance) {
+    await (0, import_promises.rm)(ownerPath, { force: true });
+    await waitForTestBarrier(TEST_LOCK_CLAIMED_BARRIER_DIR, profile);
+  }
   await (0, import_promises.rm)(claimPath, { force: true });
   await (0, import_promises.rmdir)(lockPath).catch(() => void 0);
+  if (!sameInstance) return false;
+  await removeAgedOwnerFiles(lockPath, staleAfterMs);
   return true;
 }
-async function waitForTestStaleRecoveryBarrier(profile) {
+async function waitForTestBarrier(environmentName, profile) {
   if (process.env.NODE_ENV !== "test") return;
-  const barrierDirectory = process.env[TEST_LOCK_RECOVERY_BARRIER_DIR];
+  const barrierDirectory = process.env[environmentName];
   if (!barrierDirectory) return;
   await (0, import_promises.mkdir)(barrierDirectory, { recursive: true });
   const readyPath = (0, import_node_path.join)(barrierDirectory, `ready-${process.pid}-${profile}`);
@@ -7177,9 +7240,6 @@ function isStaleOwner(owner, staleAfterMs) {
   }
   return !isProcessAlive(owner.pid);
 }
-function isLockAlreadyHeld(error) {
-  return isErrno(error, "EEXIST") || isErrno(error, "ENOTEMPTY");
-}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);