helloloop 0.6.1 → 0.7.0

package/src/engine_selection_settings.mjs

@@ -4,35 +4,101 @@ import path from "node:path";
 import { fileExists, readJson, writeJson } from "./common.mjs";
 import { normalizeEngineName } from "./engine_metadata.mjs";
 
+function defaultEmailNotificationSettings() {
+  return {
+    enabled: false,
+    to: [],
+    from: "",
+    smtp: {
+      host: "",
+      port: 465,
+      secure: true,
+      starttls: false,
+      username: "",
+      usernameEnv: "",
+      password: "",
+      passwordEnv: "",
+      timeoutSeconds: 30,
+      rejectUnauthorized: true,
+    },
+  };
+}
+
 function defaultUserSettings() {
   return {
     defaultEngine: "",
     lastSelectedEngine: "",
+    notifications: {
+      email: defaultEmailNotificationSettings(),
+    },
   };
 }
 
+export function resolveUserSettingsHome() {
+  return String(process.env.HELLOLOOP_HOME || "").trim()
+    || path.join(os.homedir(), ".helloloop");
+}
+
 export function resolveUserSettingsFile(userSettingsFile = "") {
   return userSettingsFile
-    || String(process.env.HELLOLOOP_USER_SETTINGS_FILE || "").trim()
-    || path.join(os.homedir(), ".helloloop", "settings.json");
+    || String(process.env.HELLOLOOP_SETTINGS_FILE || "").trim()
+    || path.join(resolveUserSettingsHome(), "settings.json");
 }
 
-export function loadUserSettings(options = {}) {
+function normalizeEmailNotificationSettings(emailSettings = {}) {
+  const defaults = defaultEmailNotificationSettings();
+  const smtp = emailSettings?.smtp || {};
+
+  return {
+    ...defaults,
+    ...emailSettings,
+    to: Array.isArray(emailSettings?.to)
+      ? emailSettings.to.map((item) => String(item || "").trim()).filter(Boolean)
+      : (typeof emailSettings?.to === "string" && emailSettings.to.trim() ? [emailSettings.to.trim()] : []),
+    smtp: {
+      ...defaults.smtp,
+      ...smtp,
+    },
+  };
+}
+
+export function loadUserSettingsDocument(options = {}) {
   const settingsFile = resolveUserSettingsFile(options.userSettingsFile);
-  if (!fileExists(settingsFile)) {
-    return defaultUserSettings();
-  }
+  const settings = fileExists(settingsFile) ? readJson(settingsFile) : {};
 
-  const settings = readJson(settingsFile);
   return {
+    ...defaultUserSettings(),
+    ...settings,
     defaultEngine: normalizeEngineName(settings?.defaultEngine),
     lastSelectedEngine: normalizeEngineName(settings?.lastSelectedEngine),
+    notifications: {
+      ...(settings?.notifications || {}),
+      email: normalizeEmailNotificationSettings(settings?.notifications?.email || {}),
+    },
+  };
+}
+
+export function loadUserSettings(options = {}) {
+  const settings = loadUserSettingsDocument(options);
+  return {
+    defaultEngine: settings.defaultEngine,
+    lastSelectedEngine: settings.lastSelectedEngine,
   };
 }
 
 export function saveUserSettings(settings, options = {}) {
+  const currentSettings = loadUserSettingsDocument(options);
   writeJson(resolveUserSettingsFile(options.userSettingsFile), {
-    defaultEngine: normalizeEngineName(settings?.defaultEngine),
-    lastSelectedEngine: normalizeEngineName(settings?.lastSelectedEngine),
+    ...currentSettings,
+    ...settings,
+    defaultEngine: normalizeEngineName(settings?.defaultEngine ?? currentSettings.defaultEngine),
+    lastSelectedEngine: normalizeEngineName(settings?.lastSelectedEngine ?? currentSettings.lastSelectedEngine),
+    notifications: {
+      ...(currentSettings.notifications || {}),
+      ...(settings?.notifications || {}),
+      email: normalizeEmailNotificationSettings(
+        settings?.notifications?.email ?? currentSettings.notifications?.email ?? {},
+      ),
+    },
   });
 }

package/src/global_config.mjs

@@ -0,0 +1,21 @@
+import { fileExists } from "./common.mjs";
+import { loadUserSettingsDocument, resolveUserSettingsFile } from "./engine_selection_settings.mjs";
+
+export function resolveGlobalConfigFile(explicitFile = "") {
+  return resolveUserSettingsFile(explicitFile);
+}
+
+export function loadGlobalConfig(options = {}) {
+  const configFile = resolveGlobalConfigFile(options.globalConfigFile);
+  const loaded = loadUserSettingsDocument({
+    userSettingsFile: configFile,
+  });
+
+  return {
+    ...loaded,
+    _meta: {
+      configFile,
+      exists: fileExists(configFile),
+    },
+  };
+}

package/src/install_shared.mjs

@@ -38,6 +38,54 @@ export function assertPathInside(parentDir, targetDir, label) {
   }
 }
 
+function sleepSync(ms) {
+  const shared = new SharedArrayBuffer(4);
+  const view = new Int32Array(shared);
+  Atomics.wait(view, 0, 0, Math.max(0, ms));
+}
+
+function isRetryableRemoveError(error) {
+  const code = String(error?.code || "").toUpperCase();
+  return ["ENOTEMPTY", "EPERM", "EBUSY"].includes(code);
+}
+
+function removeDirectoryWithRetries(targetPath) {
+  const retryDelaysMs = [0, 50, 150, 300];
+  let lastError = null;
+
+  for (const delayMs of retryDelaysMs) {
+    if (delayMs > 0) {
+      sleepSync(delayMs);
+    }
+    try {
+      fs.rmSync(targetPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+      return;
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableRemoveError(error)) {
+        throw error;
+      }
+    }
+  }
+
+  const tempPath = `${targetPath}.removing-${Date.now()}`;
+  fs.renameSync(targetPath, tempPath);
+  try {
+    fs.rmSync(tempPath, { recursive: true, force: true, maxRetries: 3, retryDelay: 100 });
+  } catch (error) {
+    throw lastError || error;
+  }
+}
+
+function removeFsPath(targetPath) {
+  const stats = fs.lstatSync(targetPath);
+  if (stats.isDirectory() && !stats.isSymbolicLink()) {
+    removeDirectoryWithRetries(targetPath);
+    return;
+  }
+  fs.rmSync(targetPath, { force: true, recursive: true, maxRetries: 3, retryDelay: 100 });
+}
+
 export function removeTargetIfNeeded(targetPath, force) {
   if (!fileExists(targetPath)) {
     return;
@@ -45,14 +93,14 @@ export function removeTargetIfNeeded(targetPath, force) {
   if (!force) {
     throw new Error(`目标目录已存在：${targetPath}。若要覆盖，请追加 --force。`);
   }
-  fs.rmSync(targetPath, { recursive: true, force: true });
+  removeFsPath(targetPath);
 }
 
 export function removePathIfExists(targetPath) {
   if (!fileExists(targetPath)) {
     return false;
   }
-  fs.rmSync(targetPath, { recursive: true, force: true });
+  removeFsPath(targetPath);
   return true;
 }