@tinycloud/operations 0.3.3-beta.9 → 0.3.3

package/dist/artifacts.js

@@ -2177,16 +2177,17 @@ var KVService = class extends BaseService {
             ...options?.ifNoneMatch === void 0 ? {} : { "if-none-match": options.ifNoneMatch }
           }
         );
+        if (response.status === 401 || response.status === 403) {
+          const errorText = await response.text();
+          const message = errorText.trim().length > 0 ? errorText : `Failed to put key "${key}": ${response.status} - ${response.statusText || "authorization failed"}`;
+          const { resource, action: requiredAction } = parseAuthError(errorText);
+          return err(authUnauthorizedError("kv", message, {
+            status: response.status,
+            ...requiredAction && { requiredAction },
+            ...resource && { resource }
+          }));
+        }
         if (!response.ok) {
-          if (response.status === 401) {
-            const errorText2 = await response.text();
-            const { resource, action } = parseAuthError(errorText2);
-            return err(authUnauthorizedError("kv", errorText2, {
-              status: response.status,
-              ...action && { requiredAction: action },
-              ...resource && { resource }
-            }));
-          }
           const errorText = await response.text();
           if (response.status === 412) {
             return err(serviceError(
@@ -6927,11 +6928,15 @@ function canonicalizeCaveats(caveats) {
 import { randomUUID } from "crypto";
 import { AsyncLocalStorage } from "async_hooks";
 import {
+  chmod,
+  link,
   mkdir,
   readFile,
+  readdir,
   rename,
   rmdir,
   rm,
+  stat,
   writeFile
 } from "fs/promises";
 import { homedir } from "os";
@@ -6940,8 +6945,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 AsyncLocalStorage();
+var heldProfileLocks = new AsyncLocalStorage();
 var ProfileLockTimeoutError = class extends Error {
   constructor(profile, timeoutMs) {
     super(`Timed out waiting for the profile lock for "${profile}" after ${timeoutMs}ms.`);
@@ -6968,9 +6983,6 @@ function profileStoreMetadataPath(profile, store) {
 function profileLockPath(profile) {
   return join(profilePath(profile), ".lock");
 }
-function profileLockMetadataPath(profile) {
-  return join(profileLockPath(profile), "owner.json");
-}
 async function readJson(filePath) {
   try {
     return JSON.parse(await readFile(filePath, "utf8"));
@@ -6987,9 +6999,9 @@ async function writeJsonAtomic(filePath, value) {
   );
   const contents = `${JSON.stringify(value, null, 2)}
 `;
-  await mkdir(directory, { recursive: true });
+  await mkdir(directory, { recursive: true, mode: PRIVATE_DIR_MODE });
   try {
-    await writeFile(temporaryPath, contents, "utf8");
+    await writeFile(temporaryPath, contents, { encoding: "utf8", mode: PRIVATE_FILE_MODE });
     await rename(temporaryPath, filePath);
   } catch (error) {
     await rm(temporaryPath, { force: true }).catch(() => void 0);
@@ -7019,10 +7031,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();
   }
 }
@@ -7049,28 +7066,18 @@ async function acquireProfileLock(profile, options) {
   const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_LOCK_MS;
   const startedAt = Date.now();
   const lockPath = profileLockPath(profile);
-  await mkdir(profilePath(profile), { recursive: true });
+  await mkdir(profilePath(profile), { recursive: true, mode: PRIVATE_DIR_MODE });
+  for (const directory of [tinycloudHomePath(), profilesPath(), profilePath(profile)]) {
+    await chmod(directory, PRIVATE_DIR_MODE);
+  }
   while (true) {
-    try {
-      await mkdir(lockPath);
-      const token = randomUUID();
-      try {
-        await writeJsonAtomic(profileLockMetadataPath(profile), {
-          pid: process.pid,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          token
-        });
-      } catch (error) {
-        await rmdir(lockPath).catch(() => void 0);
-        throw error;
-      }
+    const token = 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) {
@@ -7079,21 +7086,35 @@ async function acquireProfileLock(profile, options) {
     await sleep(Math.min(retryMs, timeoutMs - elapsedMs));
   }
 }
-async function releaseProfileLock(lockPath, token) {
-  const ownerPath = join(lockPath, "owner.json");
-  const claimPath = join(lockPath, `.release-${token}.json`);
+async function publishProfileLock(profile, lockPath, token) {
   try {
-    await rename(ownerPath, claimPath);
+    await 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 rename(claimPath, ownerPath).catch(() => void 0);
-    return;
+  await waitForTestBarrier(TEST_LOCK_PUBLISH_BARRIER_DIR, profile);
+  const staged = join(dirname(lockPath), `.lock-owner-${token}.tmp`);
+  const owner = { pid: process.pid, createdAt: (/* @__PURE__ */ new Date()).toISOString(), token };
+  try {
+    await writeFile(staged, `${JSON.stringify(owner, null, 2)}
+`, { encoding: "utf8", mode: PRIVATE_FILE_MODE, flag: "wx" });
+    await link(staged, join(lockPath, "owner.json"));
+    return true;
+  } catch (error) {
+    if (isErrno(error, "EEXIST") || isErrno(error, "ENOENT")) return false;
+    await rmdir(lockPath).catch(() => void 0);
+    throw error;
+  } finally {
+    await rm(staged, { force: true }).catch(() => void 0);
   }
-  await rm(claimPath, { force: true });
+}
+async function releaseProfileLock(profile, lockPath, token) {
+  const ownerPath = join(lockPath, "owner.json");
+  const owner = await readJson(ownerPath).catch(() => null);
+  if (owner?.token !== token) return;
+  await rm(ownerPath, { force: true });
+  await waitForTestBarrier(TEST_LOCK_RELEASE_BARRIER_DIR, profile);
   await rmdir(lockPath).catch(() => void 0);
 }
 async function signalTestLockContention(profile) {
@@ -7110,32 +7131,79 @@ async function signalTestLockContention(profile) {
   await writeFile(signalPath, `${profile}
 `, { encoding: "utf8", flag: "wx" }).catch(() => void 0);
 }
+async function recoverOwnerlessLock(profile, lockPath, staleAfterMs) {
+  try {
+    const { mtimeMs } = await 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 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 rm(join(lockPath, name), { force: true });
+    }
+    await 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 = dirname(lockPath);
+  const names = await readdir(directory).catch(() => []);
+  for (const name of names.filter((entry) => STAGED_OWNER.test(entry))) {
+    const path = join(directory, name);
+    const aged = await stat(path).then(({ mtimeMs }) => Date.now() - mtimeMs >= staleAfterMs, () => false);
+    if (aged) await rm(path, { force: true }).catch(() => void 0);
+  }
+}
 async function recoverStaleLock(profile, lockPath, staleAfterMs) {
   const ownerPath = 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 = join(lockPath, `.stale-${randomUUID()}.json`);
   try {
-    await rename(ownerPath, claimPath);
-  } catch (error) {
-    if (isErrno(error, "ENOENT")) return false;
+    await 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 rename(claimPath, ownerPath).catch(() => void 0);
+  await waitForTestBarrier(TEST_LOCK_VERIFIED_BARRIER_DIR, profile);
+  if (sameInstance && recoveryFenced(claimedAt, staleAfterMs)) {
+    await rm(claimPath, { force: true });
+    await waitForTestBarrier(TEST_LOCK_FENCED_BARRIER_DIR, profile);
     return false;
   }
+  if (sameInstance) {
+    await rm(ownerPath, { force: true });
+    await waitForTestBarrier(TEST_LOCK_CLAIMED_BARRIER_DIR, profile);
+  }
   await rm(claimPath, { force: true });
   await 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 mkdir(barrierDirectory, { recursive: true });
   const readyPath = join(barrierDirectory, `ready-${process.pid}-${profile}`);
@@ -7159,9 +7227,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);