@tinycloud/operations 0.3.3-beta.9 → 0.3.4-beta.0

package/dist/cli-runtime.js

@@ -3618,16 +3618,17 @@ var init_dist2 = __esm({
                 ...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(
@@ -7089,11 +7090,15 @@ var init_authority = __esm({
 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";
@@ -7136,9 +7141,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"));
@@ -7155,9 +7157,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);
@@ -7197,10 +7199,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();
   }
 }
@@ -7227,28 +7234,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) {
@@ -7257,21 +7254,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) {
@@ -7288,32 +7299,77 @@ 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;
+}
+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}`);
@@ -7337,9 +7393,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);
@@ -7360,7 +7413,7 @@ function isErrno(error, code) {
 function sleep(milliseconds) {
   return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
 }
-var DEFAULT_PROFILE, DEFAULT_LOCK_TIMEOUT_MS, DEFAULT_LOCK_RETRY_MS, DEFAULT_STALE_LOCK_MS, TEST_LOCK_CONTENTION_SIGNAL_PATH, TEST_LOCK_RECOVERY_BARRIER_DIR, invocationStateRoot, ProfileLockTimeoutError;
+var DEFAULT_PROFILE, DEFAULT_LOCK_TIMEOUT_MS, DEFAULT_LOCK_RETRY_MS, DEFAULT_STALE_LOCK_MS, TEST_LOCK_CONTENTION_SIGNAL_PATH, PRIVATE_FILE_MODE, PRIVATE_DIR_MODE, TEST_LOCK_RECOVERY_BARRIER_DIR, TEST_LOCK_OWNERLESS_BARRIER_DIR, TEST_LOCK_PUBLISH_BARRIER_DIR, TEST_LOCK_RELEASE_BARRIER_DIR, TEST_LOCK_CLAIM_BARRIER_DIR, TEST_LOCK_CLAIMED_BARRIER_DIR, TEST_LOCK_FENCED_BARRIER_DIR, TEST_LOCK_VERIFIED_BARRIER_DIR, invocationStateRoot, heldProfileLocks, ProfileLockTimeoutError, ABANDONED_CLAIM, STAGED_OWNER;
 var init_state = __esm({
   "src/state.ts"() {
     "use strict";
@@ -7369,8 +7422,18 @@ var init_state = __esm({
     DEFAULT_LOCK_RETRY_MS = 25;
     DEFAULT_STALE_LOCK_MS = 3e4;
     TEST_LOCK_CONTENTION_SIGNAL_PATH = "TC_TEST_PROFILE_LOCK_CONTENTION_SIGNAL_PATH";
+    PRIVATE_FILE_MODE = 384;
+    PRIVATE_DIR_MODE = 448;
     TEST_LOCK_RECOVERY_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_RECOVERY_BARRIER_DIR";
+    TEST_LOCK_OWNERLESS_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_OWNERLESS_BARRIER_DIR";
+    TEST_LOCK_PUBLISH_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_PUBLISH_BARRIER_DIR";
+    TEST_LOCK_RELEASE_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_RELEASE_BARRIER_DIR";
+    TEST_LOCK_CLAIM_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_CLAIM_BARRIER_DIR";
+    TEST_LOCK_CLAIMED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_CLAIMED_BARRIER_DIR";
+    TEST_LOCK_FENCED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_FENCED_BARRIER_DIR";
+    TEST_LOCK_VERIFIED_BARRIER_DIR = "TC_TEST_PROFILE_LOCK_VERIFIED_BARRIER_DIR";
     invocationStateRoot = new AsyncLocalStorage();
+    heldProfileLocks = new AsyncLocalStorage();
     ProfileLockTimeoutError = class extends Error {
       constructor(profile, timeoutMs) {
         super(`Timed out waiting for the profile lock for "${profile}" after ${timeoutMs}ms.`);
@@ -7378,6 +7441,8 @@ var init_state = __esm({
         this.name = "ProfileLockTimeoutError";
       }
     };
+    ABANDONED_CLAIM = /^\.(?:release|stale)-[0-9a-f-]+\.json$/;
+    STAGED_OWNER = /^\.lock-owner-[0-9a-f-]+\.tmp$/;
   }
 });
 
@@ -10060,7 +10125,7 @@ var init_profile = __esm({
   "src/profile.ts"() {
     "use strict";
     init_state();
-    DEFAULT_HOST = "https://node.tinycloud.xyz";
+    DEFAULT_HOST = "https://tee.node.tinycloud.xyz";
   }
 });