fix: keep internal audit logs in user data

Route upload audit and account rotation output through one internal userData log resolver with a contained fallback directory.

Report active writer paths to diagnostics and log reveal actions while preserving the configurable fileuploader.log fallback contract and leaving existing Desktop files untouched.

Cover primary paths, fallback containment, rotation, active path reporting, log opening, and upload log isolation with focused tests.

lib/upload-audit.js

@@ -1,58 +1,84 @@
 const nodePath = require('path');
 
-function getUploadAuditLogPath(uploadLogPath, pathApi = nodePath) {
-  if (typeof uploadLogPath !== 'string' || !uploadLogPath.trim()) return null;
-  return pathApi.join(pathApi.dirname(uploadLogPath), 'upload-audit.log');
-}
-
-function createUploadAuditWriter(options) {
+function createInternalLogPathResolver(options) {
   const source = options && typeof options === 'object' ? options : {};
   const fs = source.fs;
   const path = source.path || nodePath;
-  const resolveUploadLogTarget = source.resolveUploadLogTarget;
+  const userDataPath = typeof source.userDataPath === 'string' ? source.userDataPath.trim() : '';
+
+  if (!fs || typeof fs.mkdirSync !== 'function' || !userDataPath) {
+    throw new TypeError('createInternalLogPathResolver requires fs and userDataPath');
+  }
+
+  const directories = [path.join(userDataPath, 'logs'), path.join(userDataPath, 'internal-logs')];
+
+  return function resolveInternalLogPath(fileName, excludedPaths = new Set()) {
+    if (typeof fileName !== 'string' || !fileName || path.basename(fileName) !== fileName) return null;
+    const excluded = excludedPaths instanceof Set
+      ? excludedPaths
+      : new Set(Array.isArray(excludedPaths) ? excludedPaths : [excludedPaths]);
+    for (const directory of directories) {
+      const targetPath = path.join(directory, fileName);
+      if (excluded.has(targetPath)) continue;
+      try {
+        fs.mkdirSync(directory, { recursive: true });
+        return targetPath;
+      } catch {}
+    }
+    return null;
+  };
+}
+
+function createInternalLogWriter(options) {
+  const source = options && typeof options === 'object' ? options : {};
+  const fs = source.fs;
+  const path = source.path || nodePath;
+  const fileName = source.fileName;
+  const resolveInternalLogPath = source.resolveInternalLogPath;
   const rotateLogFile = typeof source.rotateLogFile === 'function' ? source.rotateLogFile : () => {};
-  const invalidateUploadLogTarget = typeof source.invalidateUploadLogTarget === 'function' ? source.invalidateUploadLogTarget : () => {};
-  const persistFallbackLogPath = typeof source.persistFallbackLogPath === 'function' ? source.persistFallbackLogPath : async () => {};
   const reportError = typeof source.reportError === 'function' ? source.reportError : () => {};
   const retryDelays = Array.isArray(source.retryDelays) && source.retryDelays.length > 0 ? source.retryDelays : [0, 100, 250];
   const maxBytes = Number.isFinite(source.maxBytes) ? source.maxBytes : 10 * 1024 * 1024;
   const maxBackups = Number.isFinite(source.maxBackups) ? source.maxBackups : 2;
   let activePath = null;
 
-  if (!fs || !fs.promises || typeof fs.promises.appendFile !== 'function' || typeof resolveUploadLogTarget !== 'function') {
-    throw new TypeError('createUploadAuditWriter requires fs and resolveUploadLogTarget');
+  if (!fs || !fs.promises || typeof fs.promises.appendFile !== 'function' || typeof resolveInternalLogPath !== 'function' || typeof fileName !== 'string') {
+    throw new TypeError('createInternalLogWriter requires fs, fileName and resolveInternalLogPath');
   }
 
   async function append(line, label) {
-    let excludedPath = null;
+    const excludedPaths = new Set();
     for (const delay of retryDelays) {
       if (delay) await new Promise(resolve => setTimeout(resolve, delay));
-      const uploadTarget = resolveUploadLogTarget(excludedPath);
-      const targetPath = uploadTarget && getUploadAuditLogPath(uploadTarget.path, path);
-      if (!targetPath) continue;
+      const targetPath = resolveInternalLogPath(fileName, excludedPaths);
+      if (!targetPath) break;
+      excludedPaths.add(targetPath);
       try {
         fs.mkdirSync(path.dirname(targetPath), { recursive: true });
         rotateLogFile(targetPath, maxBytes, maxBackups);
         await fs.promises.appendFile(targetPath, line, 'utf-8');
         activePath = targetPath;
-        if (uploadTarget.isFallback) {
-          try {
-            await persistFallbackLogPath(uploadTarget.path);
-          } catch (error) {
-            reportError('audit-fallback-persist', error);
-          }
-        }
         return true;
       } catch (error) {
-        excludedPath = uploadTarget.path;
-        invalidateUploadLogTarget();
         reportError(label, error);
       }
     }
     return false;
   }
 
-  return { append, getActivePath: () => activePath };
+  return {
+    append,
+    getActivePath: () => activePath,
+    getPath: () => activePath || resolveInternalLogPath(fileName)
+  };
 }
 
-module.exports = { getUploadAuditLogPath, createUploadAuditWriter };
+function createUploadAuditWriter(options) {
+  return createInternalLogWriter({ ...options, fileName: 'upload-audit.log' });
+}
+
+function getLogOpenDirectory(targetPath, fallbackDirectory, pathApi = nodePath) {
+  return typeof targetPath === 'string' && targetPath ? pathApi.dirname(targetPath) : fallbackDirectory;
+}
+
+module.exports = { createInternalLogPathResolver, createInternalLogWriter, createUploadAuditWriter, getLogOpenDirectory };