feat(core): atomic write rollout for credentials, memory, config, JSONL (closes #3681, #4095 Phase 2)

packages/cli/src/config/trustedFolders.test.ts

@@ -5,7 +5,11 @@
  */
 
 import * as osActual from 'node:os';
-import { FatalConfigError, ideContextStore } from '@qwen-code/qwen-code-core';
+import {
+  atomicWriteFileSync,
+  FatalConfigError,
+  ideContextStore,
+} from '@qwen-code/qwen-code-core';
 import {
   describe,
   it,
@@ -50,17 +54,24 @@ vi.mock('strip-json-comments', () => ({
   default: vi.fn((content) => content),
 }));
 
+vi.mock('@qwen-code/qwen-code-core', async (importOriginal) => {
+  const actual =
+    await importOriginal<typeof import('@qwen-code/qwen-code-core')>();
+  return {
+    ...actual,
+    atomicWriteFileSync: vi.fn(),
+  };
+});
+
 describe('Trusted Folders Loading', () => {
   let mockFsExistsSync: Mocked<typeof fs.existsSync>;
   let mockStripJsonComments: Mocked<typeof stripJsonComments>;
-  let mockFsWriteFileSync: Mocked<typeof fs.writeFileSync>;
 
   beforeEach(() => {
     resetTrustedFoldersForTesting();
     vi.resetAllMocks();
     mockFsExistsSync = vi.mocked(fs.existsSync);
     mockStripJsonComments = vi.mocked(stripJsonComments);
-    mockFsWriteFileSync = vi.mocked(fs.writeFileSync);
     vi.mocked(osActual.homedir).mockReturnValue('/mock/home/user');
     (mockStripJsonComments as unknown as Mock).mockImplementation(
       (jsonString: string) => jsonString,
@@ -190,10 +201,10 @@ describe('Trusted Folders Loading', () => {
     expect(loadedFolders.user.config['/new/path']).toBe(
       TrustLevel.TRUST_FOLDER,
     );
-    expect(mockFsWriteFileSync).toHaveBeenCalledWith(
+    expect(atomicWriteFileSync).toHaveBeenCalledWith(
       getTrustedFoldersPath(),
       JSON.stringify({ '/new/path': TrustLevel.TRUST_FOLDER }, null, 2),
-      { encoding: 'utf-8', mode: 0o600 },
+      { encoding: 'utf-8', mode: 0o600, forceMode: true },
     );
   });
 });

packages/cli/src/config/trustedFolders.ts

@@ -7,6 +7,7 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import {
+  atomicWriteFileSync,
   FatalConfigError,
   getErrorMessage,
   isWithinRoot,
@@ -179,10 +180,10 @@ export function saveTrustedFolders(
       fs.mkdirSync(dirPath, { recursive: true });
     }
 
-    fs.writeFileSync(
+    atomicWriteFileSync(
       trustedFoldersFile.path,
       JSON.stringify(trustedFoldersFile.config, null, 2),
-      { encoding: 'utf-8', mode: 0o600 },
+      { encoding: 'utf-8', mode: 0o600, forceMode: true },
     );
   } catch (error) {
     writeStderrLine('Error saving trusted folders file.');

packages/cli/src/services/tips/tipHistory.ts

@@ -10,7 +10,7 @@
 
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { Storage } from '@qwen-code/qwen-code-core';
+import { atomicWriteFileSync, Storage } from '@qwen-code/qwen-code-core';
 
 interface TipHistoryEntry {
   totalShown: number;
@@ -114,8 +114,9 @@ export class TipHistory {
       if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
       }
-      fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2), {
+      atomicWriteFileSync(this.filePath, JSON.stringify(this.data, null, 2), {
         mode: 0o600,
+        forceMode: true,
       });
     } catch {
       // Silently ignore write errors — tips are non-critical

packages/core/src/core/logger.test.ts

@@ -22,6 +22,7 @@ import {
 } from './logger.js';
 import { Storage } from '../config/storage.js';
 import { getProjectHash } from '../utils/paths.js';
+import { atomicWriteFile } from '../utils/atomicFileWrite.js';
 import { promises as fs, existsSync } from 'node:fs';
 import path from 'node:path';
 import type { Content } from '@google/genai';
@@ -73,6 +74,26 @@ vi.mock('../utils/session.js', () => ({
   sessionId: 'test-session-id',
 }));
 
+// Re-export the real atomicWriteFile so tests can override individual
+// calls (e.g. .mockRejectedValueOnce) while preserving normal behavior.
+// The default implementation is re-attached in `beforeEach` because the
+// suite calls `vi.resetAllMocks()` which strips vi.fn(impl) back to no-op.
+vi.mock('../utils/atomicFileWrite.js', async () => {
+  const actual = await vi.importActual<
+    typeof import('../utils/atomicFileWrite.js')
+  >('../utils/atomicFileWrite.js');
+  return {
+    ...actual,
+    atomicWriteFile: vi.fn(actual.atomicWriteFile),
+  };
+});
+
+const realAtomicWriteFile = (
+  await vi.importActual<typeof import('../utils/atomicFileWrite.js')>(
+    '../utils/atomicFileWrite.js',
+  )
+).atomicWriteFile;
+
 vi.mock('../utils/debugLogger.js', async (importOriginal) => {
   const original =
     await importOriginal<typeof import('../utils/debugLogger.js')>();
@@ -93,6 +114,9 @@ describe('Logger', () => {
 
   beforeEach(async () => {
     vi.resetAllMocks();
+    // resetAllMocks blanks the vi.fn(actual) delegation — re-attach so the
+    // logger's initialize/append paths still hit the real disk.
+    vi.mocked(atomicWriteFile).mockImplementation(realAtomicWriteFile);
     vi.useFakeTimers();
     vi.setSystemTime(new Date('2025-01-01T12:00:00.000Z'));
     originalHome = process.env['HOME'];
@@ -440,7 +464,7 @@ describe('Logger', () => {
     });
 
     it('should not throw, not increment messageId, and log error if writing to file fails', async () => {
-      vi.spyOn(fs, 'writeFile').mockRejectedValueOnce(new Error('Disk full'));
+      vi.mocked(atomicWriteFile).mockRejectedValueOnce(new Error('Disk full'));
       const initialMessageId = logger['messageId'];
       const initialLogCount = logger['logs'].length;
 
@@ -892,7 +916,7 @@ describe('Logger', () => {
       await logger.logMessage(MessageSenderType.USER, 'kept');
       vi.advanceTimersByTime(1000);
 
-      vi.spyOn(fs, 'writeFile').mockRejectedValueOnce(new Error('Disk full'));
+      vi.mocked(atomicWriteFile).mockRejectedValueOnce(new Error('Disk full'));
       await logger.logMessage(MessageSenderType.USER, 'failed write');
 
       expect(logger['lastLoggedUserEntry']).toBeNull();
@@ -938,7 +962,7 @@ describe('Logger', () => {
         'cancelled prompt',
       ]);
 
-      vi.spyOn(fs, 'writeFile').mockRejectedValueOnce(new Error('Disk full'));
+      vi.mocked(atomicWriteFile).mockRejectedValueOnce(new Error('Disk full'));
       const removed = await logger.removeLastUserMessage();
       expect(removed).toBe(false);
 
@@ -987,7 +1011,7 @@ describe('Logger', () => {
       const trackedAfterUser = logger['lastLoggedUserEntry'];
       expect(trackedAfterUser).not.toBeNull();
 
-      vi.spyOn(fs, 'writeFile').mockRejectedValueOnce(new Error('Disk full'));
+      vi.mocked(atomicWriteFile).mockRejectedValueOnce(new Error('Disk full'));
       await logger.logMessage(MessageSenderType.MODEL_SWITCH, 'qwen→qwen-max');
 
       // Tracker is unchanged — the non-USER failure didn't shift which

packages/core/src/core/logger.ts

@@ -8,6 +8,7 @@ import path from 'node:path';
 import { promises as fs } from 'node:fs';
 import type { Content } from '@google/genai';
 import type { Storage } from '../config/storage.js';
+import { atomicWriteFile } from '../utils/atomicFileWrite.js';
 import { createDebugLogger, type DebugLogger } from '../utils/debugLogger.js';
 
 const LOG_FILE_NAME = 'logs.json';
@@ -187,7 +188,7 @@ export class Logger {
       }
       this.logs = await this._readLogFile();
       if (!fileExisted && this.logs.length === 0) {
-        await fs.writeFile(this.logFilePath, '[]', 'utf-8');
+        await atomicWriteFile(this.logFilePath, '[]', { encoding: 'utf-8' });
       }
       const sessionLogs = this.logs.filter(
         (entry) => entry.sessionId === this.sessionId,
@@ -258,10 +259,10 @@ export class Logger {
     currentLogsOnDisk.push(entryToAppend);
 
     try {
-      await fs.writeFile(
+      await atomicWriteFile(
         this.logFilePath,
         JSON.stringify(currentLogsOnDisk, null, 2),
-        'utf-8',
+        { encoding: 'utf-8' },
       );
       this.logs = currentLogsOnDisk;
       return entryToAppend; // Return the successfully appended entry
@@ -461,10 +462,10 @@ export class Logger {
       currentLogsOnDisk.splice(idx, 1);
 
       try {
-        await fs.writeFile(
+        await atomicWriteFile(
           logFilePath,
           JSON.stringify(currentLogsOnDisk, null, 2),
-          'utf-8',
+          { encoding: 'utf-8' },
         );
         this.logs = currentLogsOnDisk;
         // Roll back this instance's nextMessageId so a subsequent log doesn't
@@ -539,7 +540,9 @@ export class Logger {
     // Always save with the new encoded path.
     const path = this._checkpointPath(tag);
     try {
-      await fs.writeFile(path, JSON.stringify(conversation, null, 2), 'utf-8');
+      await atomicWriteFile(path, JSON.stringify(conversation, null, 2), {
+        encoding: 'utf-8',
+      });
     } catch (error) {
       this.debugLogger.error('Error writing to checkpoint file:', error);
     }

packages/core/src/extension/extensionManager.ts

@@ -24,6 +24,10 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
 
+import {
+  atomicWriteFile,
+  atomicWriteFileSync,
+} from '../utils/atomicFileWrite.js';
 import { getErrorMessage } from '../utils/errors.js';
 import {
   EXTENSIONS_CONFIG_FILENAME,
@@ -530,7 +534,7 @@ export class ExtensionManager {
 
   private writeEnablementConfig(config: AllExtensionsEnablementConfig): void {
     fs.mkdirSync(this.configDir, { recursive: true });
-    fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
+    atomicWriteFileSync(this.configFilePath, JSON.stringify(config, null, 2));
   }
 
   /**
@@ -1070,7 +1074,7 @@ export class ExtensionManager {
           destinationPath,
           INSTALL_METADATA_FILENAME,
         );
-        await fs.promises.writeFile(metadataPath, metadataString);
+        await atomicWriteFile(metadataPath, metadataString);
 
         extension = await this.loadExtension({ extensionDir: destinationPath });
         if (!extension) {

packages/core/src/hooks/trustedHooks.ts

@@ -12,6 +12,7 @@ import {
   type HookDefinition,
   type HookEventName,
 } from './types.js';
+import { atomicWriteFileSync } from '../utils/atomicFileWrite.js';
 import { createDebugLogger } from '../utils/debugLogger.js';
 
 const debugLogger = createDebugLogger('TRUSTED_HOOKS');
@@ -50,7 +51,7 @@ export class TrustedHooksManager {
       if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
       }
-      fs.writeFileSync(
+      atomicWriteFileSync(
         this.configPath,
         JSON.stringify(this.trustedHooks, null, 2),
       );

packages/core/src/index.ts

@@ -269,6 +269,7 @@ export * from './followup/index.js';
 // Utilities
 // ============================================================================
 
+export * from './utils/atomicFileWrite.js';
 export * from './utils/browser.js';
 export * from './utils/bundlePaths.js';
 export * from './utils/configResolver.js';

packages/core/src/lsp/NativeLspService.ts

@@ -45,6 +45,7 @@ import type {
 import * as path from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import * as fs from 'node:fs';
+import { atomicWriteFileSync } from '../utils/atomicFileWrite.js';
 import { createDebugLogger } from '../utils/debugLogger.js';
 import { globSync } from 'glob';
 
@@ -1306,12 +1307,17 @@ export class NativeLspService {
       throw new Error(`Refusing to apply edits outside workspace: ${filePath}`);
     }
 
-    // Read the current file content
+    // Read the current file content. Only treat ENOENT as "new file"; any
+    // other read failure (EACCES on a read-protected file, EISDIR, etc.)
+    // must propagate — otherwise the atomic rename below would silently
+    // replace the unreadable target with edits applied to an empty buffer.
     let content: string;
     try {
       content = fs.readFileSync(filePath, 'utf-8');
-    } catch {
-      // File doesn't exist, treat as empty
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException)?.code !== 'ENOENT') {
+        throw err;
+      }
       content = '';
     }
 
@@ -1347,8 +1353,20 @@ export class NativeLspService {
       lines.splice(startLine, endLine - startLine + 1, ...newLines);
     }
 
-    // Write back to file
-    fs.writeFileSync(filePath, lines.join('\n'), 'utf-8');
+    // Honor file-level write permissions. Atomic rename (tmp + rename)
+    // would otherwise bypass a chmod 0444 lock because rename only needs
+    // parent-directory write access. ENOENT is fine — LSP may be creating
+    // the file via edits.
+    try {
+      fs.accessSync(filePath, fs.constants.W_OK);
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException)?.code !== 'ENOENT') {
+        throw err;
+      }
+    }
+
+    // Atomic write so a crash mid-edit can't leave the user file half-written.
+    atomicWriteFileSync(filePath, lines.join('\n'), { encoding: 'utf-8' });
   }
 
   /**