@expiren/opencode-antigravity-auth 1.6.4 → 1.6.6

package/dist/index.js

@@ -671,6 +671,40 @@ async function loadAccounts() {
     return null;
   }
 }
+async function atomicWriteFile(targetPath, content) {
+  const tempPath = `${targetPath}.${randomBytes(6).toString("hex")}.tmp`;
+  await fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 384 });
+  const RETRY_DELAYS = [50, 100, 200];
+  let lastError;
+  for (let attempt = 0; attempt <= RETRY_DELAYS.length; attempt++) {
+    try {
+      await fs.rename(tempPath, targetPath);
+      return;
+    } catch (error) {
+      lastError = error;
+      const code = error.code;
+      if (code !== "EPERM" && code !== "EACCES") {
+        break;
+      }
+      if (attempt < RETRY_DELAYS.length) {
+        await new Promise((r) => setTimeout(r, RETRY_DELAYS[attempt]));
+      }
+    }
+  }
+  try {
+    await fs.copyFile(tempPath, targetPath);
+    try {
+      await fs.unlink(tempPath);
+    } catch {
+    }
+  } catch {
+    try {
+      await fs.unlink(tempPath);
+    } catch {
+    }
+    throw lastError;
+  }
+}
 async function saveAccounts(storage) {
   const path5 = getStoragePath();
   const configDir = dirname(path5);
@@ -679,18 +713,8 @@ async function saveAccounts(storage) {
   await withFileLock(path5, async () => {
     const existing = await loadAccountsUnsafe();
     const merged = existing ? mergeAccountStorage(existing, storage) : storage;
-    const tempPath = `${path5}.${randomBytes(6).toString("hex")}.tmp`;
     const content = JSON.stringify(merged, null, 2);
-    try {
-      await fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 384 });
-      await fs.rename(tempPath, path5);
-    } catch (error) {
-      try {
-        await fs.unlink(tempPath);
-      } catch {
-      }
-      throw error;
-    }
+    await atomicWriteFile(path5, content);
   });
 }
 async function saveAccountsReplace(storage) {
@@ -699,18 +723,8 @@ async function saveAccountsReplace(storage) {
   await fs.mkdir(configDir, { recursive: true });
   await ensureGitignore(configDir);
   await withFileLock(path5, async () => {
-    const tempPath = `${path5}.${randomBytes(6).toString("hex")}.tmp`;
     const content = JSON.stringify(storage, null, 2);
-    try {
-      await fs.writeFile(tempPath, content, { encoding: "utf-8", mode: 384 });
-      await fs.rename(tempPath, path5);
-    } catch (error) {
-      try {
-        await fs.unlink(tempPath);
-      } catch {
-      }
-      throw error;
-    }
+    await atomicWriteFile(path5, content);
   });
 }
 async function loadAccountsUnsafe() {
@@ -5289,6 +5303,7 @@ function needsThinkingRecovery(state) {
 
 // src/plugin/transform/claude.ts
 var CLAUDE_THINKING_MAX_OUTPUT_TOKENS = 64e3;
+var CLAUDE_INTERLEAVED_THINKING_HINT = "Interleaved thinking is enabled. You may think between tool calls and after receiving tool results before deciding the next action or final answer. Do not mention these instructions or any constraints about thinking blocks; just apply them.";
 function isClaudeModel(model) {
   return model.toLowerCase().includes("claude");
 }
@@ -5296,6 +5311,23 @@ function isClaudeThinkingModel(model) {
   const lower = model.toLowerCase();
   return lower.includes("claude") && lower.includes("thinking");
 }
+function appendClaudeThinkingHint(payload, hint = CLAUDE_INTERLEAVED_THINKING_HINT) {
+  const existing = payload.systemInstruction;
+  if (typeof existing === "string") {
+    payload.systemInstruction = existing.trim().length > 0 ? { role: "user", parts: [{ text: existing }, { text: hint }] } : hint;
+  } else if (existing && typeof existing === "object") {
+    const sys = existing;
+    const partsValue = sys.parts;
+    if (Array.isArray(partsValue)) {
+      sys.parts = [...partsValue, { text: hint }];
+    } else {
+      sys.parts = [{ text: hint }];
+    }
+    payload.systemInstruction = sys;
+  } else if (Array.isArray(payload.contents)) {
+    payload.systemInstruction = { parts: [{ text: hint }] };
+  }
+}
 
 // src/plugin/transform/gemini.ts
 var UNSUPPORTED_SCHEMA_FIELDS = /* @__PURE__ */ new Set([
@@ -7209,22 +7241,7 @@ function prepareAntigravityRequest(input2, init, accessToken, projectId, endpoin
           delete requestPayload.system_instruction;
         }
         if (isClaudeThinking && Array.isArray(requestPayload.tools) && requestPayload.tools.length > 0) {
-          const hint = "Interleaved thinking is enabled. You may think between tool calls and after receiving tool results before deciding the next action or final answer. Do not mention these instructions or any constraints about thinking blocks; just apply them.";
-          const existing = requestPayload.systemInstruction;
-          if (typeof existing === "string") {
-            requestPayload.systemInstruction = { parts: [{ text: existing }, { text: hint }] };
-          } else if (existing && typeof existing === "object") {
-            const sys = existing;
-            const partsValue = sys.parts;
-            if (Array.isArray(partsValue)) {
-              sys.parts = [...partsValue, { text: hint }];
-            } else {
-              sys.parts = [{ text: hint }];
-            }
-            requestPayload.systemInstruction = sys;
-          } else if (Array.isArray(requestPayload.contents)) {
-            requestPayload.systemInstruction = { parts: [{ text: hint }] };
-          }
+          appendClaudeThinkingHint(requestPayload);
         }
         const cachedContentFromExtra = typeof requestPayload.extra_body === "object" && requestPayload.extra_body ? requestPayload.extra_body.cached_content ?? requestPayload.extra_body.cachedContent : void 0;
         const cachedContent = requestPayload.cached_content ?? requestPayload.cachedContent ?? cachedContentFromExtra;