mixdog 0.9.52 → 0.9.53

package/src/tui/dist/index.mjs

@@ -14888,6 +14888,79 @@ function writeFileAtomicSync(filePath, data, opts = {}) {
 function writeJsonAtomicSync(filePath, value, opts = {}) {
   return writeFileAtomicSync(filePath, JSON.stringify(value, null, opts.compact ? 0 : 2) + "\n", opts);
 }
+async function writeFileAtomicAsync(filePath, data, opts = {}) {
+  const run = async () => {
+    const dir = dirname4(filePath);
+    mkdirSync3(dir, { recursive: true });
+    const tmp = join4(dir, `.${basename4(filePath)}.${randomBytes2(12).toString("hex")}.tmp`);
+    try {
+      const writeOpts = { encoding: opts.encoding || "utf8", flag: "wx", mode: opts.mode !== void 0 ? opts.mode : 384 };
+      writeFileSync3(tmp, data, writeOpts);
+      if (opts.secret === true) await _enforceOwnerOnlyAclWin32Async(tmp);
+      if (opts.fsync !== false) {
+        let fd = null;
+        try {
+          fd = openSync(tmp, "r");
+          fsyncSync(fd);
+        } catch (err) {
+          if (!["EPERM", "ENOTSUP", "EINVAL"].includes(err?.code)) throw err;
+        } finally {
+          try {
+            if (fd !== null) closeSync(fd);
+          } catch {
+          }
+        }
+      }
+      if (opts.createOnly === true) {
+        try {
+          linkSync(tmp, filePath);
+        } catch (err) {
+          try {
+            unlinkSync2(tmp);
+          } catch {
+          }
+          if (err?.code === "EEXIST") return false;
+          throw err;
+        }
+        try {
+          unlinkSync2(tmp);
+        } catch {
+        }
+      } else {
+        renameWithRetrySync(tmp, filePath, opts);
+      }
+      if (opts.secret === true) await _enforceOwnerOnlyAclWin32Async(filePath);
+      if (opts.fsyncDir === true) {
+        let dfd = null;
+        try {
+          dfd = openSync(dir, "r");
+          fsyncSync(dfd);
+        } catch (err) {
+          if (!["EPERM", "ENOTSUP", "EINVAL", "EACCES"].includes(err?.code)) throw err;
+        } finally {
+          try {
+            if (dfd !== null) closeSync(dfd);
+          } catch {
+          }
+        }
+      }
+      return true;
+    } catch (err) {
+      try {
+        if (existsSync4(tmp)) unlinkSync2(tmp);
+      } catch {
+      }
+      throw err;
+    }
+  };
+  if (opts.lock === true) {
+    return withFileLock(`${filePath}.lock`, run, opts);
+  }
+  return run();
+}
+function writeJsonAtomicAsync(filePath, value, opts = {}) {
+  return writeFileAtomicAsync(filePath, JSON.stringify(value, null, opts.compact ? 0 : 2) + "\n", opts);
+}
 async function updateJsonAtomic(filePath, mutator, opts = {}) {
   const { lock: _lock, ...writeOpts } = opts;
   return withFileLock(`${filePath}.lock`, () => {
@@ -14915,6 +14988,13 @@ import {
   statSync as statSync3,
   writeFileSync as writeFileSync4
 } from "fs";
+import {
+  copyFile as copyFileP,
+  mkdir as mkdirP,
+  readdir as readdirP,
+  rm as rmP,
+  stat as statP
+} from "fs/promises";
 import { dirname as dirname5, join as join5, resolve as resolve3 } from "path";
 import { homedir as homedir3 } from "os";
 import { createHash } from "crypto";
@@ -14977,44 +15057,44 @@ function loadLatestMixdogConfigFromBackup(_dataDir) {
   }
   return null;
 }
-function copyTree(src, dst, copied) {
-  const st = statSync3(src);
+function markUserDataInitialized(dataDir) {
+  try {
+    mkdirSync4(getBackupRoot(), { recursive: true });
+    writeFileSync4(initMarkerPath(dataDir), JSON.stringify({
+      dataDir,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    }, null, 2) + "\n", "utf8");
+  } catch {
+  }
+}
+async function copyTreeAsync(src, dst, copied) {
+  const st = await statP(src);
   if (st.isDirectory()) {
-    for (const name of readdirSync(src)) {
-      copyTree(join5(src, name), join5(dst, name), copied);
+    for (const name of await readdirP(src)) {
+      await copyTreeAsync(join5(src, name), join5(dst, name), copied);
     }
     return;
   }
   if (!st.isFile()) return;
-  mkdirSync4(dirname5(dst), { recursive: true });
-  copyFileSync(src, dst);
+  await mkdirP(dirname5(dst), { recursive: true });
+  await copyFileP(src, dst);
   copied.push(dst);
 }
-function pruneBackups(keep = 40) {
+async function pruneBackupsAsync(keep = 40) {
   let entries = [];
   try {
-    entries = readdirSync(getBackupRoot(), { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
+    entries = (await readdirP(getBackupRoot(), { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().reverse();
   } catch {
     return;
   }
   for (const name of entries.slice(keep)) {
     try {
-      rmSync(join5(getBackupRoot(), name), { recursive: true, force: true });
+      await rmP(join5(getBackupRoot(), name), { recursive: true, force: true });
     } catch {
     }
   }
 }
-function markUserDataInitialized(dataDir) {
-  try {
-    mkdirSync4(getBackupRoot(), { recursive: true });
-    writeFileSync4(initMarkerPath(dataDir), JSON.stringify({
-      dataDir,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    }, null, 2) + "\n", "utf8");
-  } catch {
-  }
-}
-function backupUserData(dataDir, reason = "snapshot") {
+async function backupUserDataAsync(dataDir, reason = "snapshot") {
   if (process.env.MIXDOG_SKIP_USER_DATA_BACKUP === "1" || process.env.MIXDOG_SKIP_USER_DATA_BACKUP === "true") {
     return { dir: null, copied: [] };
   }
@@ -15023,15 +15103,15 @@ function backupUserData(dataDir, reason = "snapshot") {
   const copied = [];
   for (const rel of USER_DATA_FILES) {
     const src = join5(dataDir, rel);
-    if (existsSync5(src)) copyTree(src, join5(backupDir, rel), copied);
+    if (existsSync5(src)) await copyTreeAsync(src, join5(backupDir, rel), copied);
   }
   for (const rel of USER_DATA_DIRS) {
     const src = join5(dataDir, rel);
-    if (existsSync5(src)) copyTree(src, join5(backupDir, rel), copied);
+    if (existsSync5(src)) await copyTreeAsync(src, join5(backupDir, rel), copied);
   }
   if (copied.length > 0) {
     markUserDataInitialized(dataDir);
-    pruneBackups();
+    await pruneBackupsAsync();
     if (process.env.MIXDOG_SETUP_QUIET !== "1") {
       process.stderr.write(`[user-data-backup] ${reason}: copied ${copied.length} file(s) to ${backupDir}
 `);
@@ -15059,7 +15139,13 @@ var AGENT_PROVIDER_ENV_ALIASES = Object.freeze({
 
 // src/runtime/shared/config.mjs
 var _require = createRequire3(import.meta.url);
-var { getSecret: _getSecret, setSecret: _setSecret, deleteSecret: _deleteSecret, hasSecret: _hasSecret } = _require("../../lib/keychain-cjs.cjs");
+var {
+  getSecret: _getSecret,
+  setSecret: _setSecret,
+  deleteSecret: _deleteSecret,
+  hasSecret: _hasSecret,
+  invalidateSecretCache: _invalidateSecretCache
+} = _require("../../lib/keychain-cjs.cjs");
 var DATA_DIR = resolvePluginData();
 var CONFIG_PATH = join6(DATA_DIR, "mixdog-config.json");
 var GENERATED_KEY = "_generated";
@@ -15152,27 +15238,6 @@ function readJsonFile(path2) {
     return null;
   }
 }
-function writeJsonFile(path2, data) {
-  mkdirSync5(dirname6(path2), { recursive: true, mode: 448 });
-  if (path2 === CONFIG_PATH) {
-    try {
-      backupUserData(DATA_DIR, "pre-config-write");
-    } catch {
-    }
-  }
-  writeJsonAtomicSync(path2, data, { lock: false, fsyncDir: true, mode: 384, secret: true });
-  if (path2 === CONFIG_PATH) {
-    invalidateConfigReadCache();
-    try {
-      markUserDataInitialized(DATA_DIR);
-    } catch {
-    }
-    try {
-      backupUserData(DATA_DIR, "post-config-write");
-    } catch {
-    }
-  }
-}
 function readAll() {
   const parsed = readJsonFile(CONFIG_PATH);
   if (parsed != null) return parsed;
@@ -15231,22 +15296,58 @@ function readAllForRmW() {
     return restoreAllForRmWOrThrow(parseErr.message);
   }
 }
-function writeAll(data) {
-  writeJsonFile(CONFIG_PATH, data);
-}
-function withConfigLock(fn) {
-  return withFileLockSync(`${CONFIG_PATH}.lock`, fn, { secret: true });
-}
 function readSection(section) {
   return stripGeneratedMarker(readAll()[section] ?? null) ?? {};
 }
-function updateSection(section, updater) {
-  withConfigLock(() => {
+async function writeJsonFileAsync(path2, data) {
+  mkdirSync5(dirname6(path2), { recursive: true, mode: 448 });
+  if (path2 === CONFIG_PATH) {
+    try {
+      await backupUserDataAsync(DATA_DIR, "pre-config-write");
+    } catch {
+    }
+  }
+  await writeJsonAtomicAsync(path2, data, { lock: false, fsyncDir: true, mode: 384, secret: true });
+  if (path2 === CONFIG_PATH) {
+    invalidateConfigReadCache();
+    try {
+      markUserDataInitialized(DATA_DIR);
+    } catch {
+    }
+    try {
+      await backupUserDataAsync(DATA_DIR, "post-config-write");
+    } catch {
+    }
+  }
+}
+async function writeAllAsync(data) {
+  await writeJsonFileAsync(CONFIG_PATH, data);
+}
+function withConfigLockAsync(fn) {
+  return withFileLock(`${CONFIG_PATH}.lock`, fn, { secret: true });
+}
+var _pendingConfigWrites = /* @__PURE__ */ new Set();
+function trackConfigWrite(work) {
+  let promise;
+  try {
+    promise = Promise.resolve(work());
+  } catch (error) {
+    promise = Promise.reject(error);
+  }
+  _pendingConfigWrites.add(promise);
+  const remove = () => {
+    _pendingConfigWrites.delete(promise);
+  };
+  promise.then(remove, remove);
+  return promise;
+}
+function updateSectionAsync(section, updater) {
+  return trackConfigWrite(() => withConfigLockAsync(async () => {
     const all = readAllForRmW();
     const current = stripGeneratedMarker(all[section] || {});
     all[section] = stripGeneratedMarker(typeof updater === "function" ? updater(current) : updater);
-    writeAll(all);
-  });
+    await writeAllAsync(all);
+  }));
 }
 var CAPABILITY_DEFAULTS = Object.freeze({ homeAccess: false });
 var SECRET_ACCOUNTS = Object.freeze({
@@ -15348,7 +15449,7 @@ async function toggleVoice({ pushNotice, setProgressHint } = {}) {
   const dataDir = resolvePluginData();
   if (isVoiceEnabled()) {
     try {
-      updateSection("voice", (current) => ({ ...current, enabled: false }));
+      await updateSectionAsync("voice", (current) => ({ ...current, enabled: false }));
     } catch (err) {
       pushNotice?.(`Voice OFF failed: ${err?.message || err}`, "error");
       return { ok: false, error: err?.message || String(err) };
@@ -15363,7 +15464,7 @@ async function toggleVoice({ pushNotice, setProgressHint } = {}) {
   _voiceInstallBusy = true;
   try {
     await ensureVoiceRuntimeReady({ dataDir, pushNotice, setProgressHint });
-    updateSection("voice", (current) => ({ ...current, enabled: true }));
+    await updateSectionAsync("voice", (current) => ({ ...current, enabled: true }));
     setProgressHint?.("");
     pushNotice?.("Voice ON \u2014 channel voice messages will be transcribed", "info");
     return true;
@@ -20860,19 +20961,21 @@ function App({ store, initialStatusLine = "", forceOnboarding = false }) {
         }
         if (channelPrompt.kind === "webhook-domain") {
           if (!commandText) return false;
-          store.setWebhookConfig?.({ ngrokDomain: commandText });
-          resumeAfterChannelPrompt(channelPrompt);
+          Promise.resolve(store.setWebhookConfig?.({ ngrokDomain: commandText })).then(() => resumeAfterChannelPrompt(channelPrompt)).catch((e) => {
+            store.pushNotice(`webhook config update failed: ${e?.message || e}`, "error");
+          });
           return true;
         }
         const parts = commandText.split("|").map((part) => part.trim());
         if (channelPrompt.kind === "channel-add") {
           const isPipe = parts.length > 1;
           const channelId = isPipe ? parts[1] : parts[0];
-          store.setChannel({
+          Promise.resolve(store.setChannel({
             channelId,
             backend: channelPrompt.backend
+          })).then(() => resumeAfterChannelPrompt(channelPrompt)).catch((e) => {
+            store.pushNotice(`channel save failed: ${e?.message || e}`, "error");
           });
-          resumeAfterChannelPrompt(channelPrompt);
           return true;
         }
         if (channelPrompt.kind === "schedule-add") {
@@ -25982,13 +26085,13 @@ function createEngineApiB(bag) {
       pushNotice("webhook/ngrok authtoken forgotten", "info");
       return result;
     },
-    setChannel: (entry) => {
-      const result = runtime.setChannel(entry);
+    setChannel: async (entry) => {
+      const result = await runtime.setChannel(entry);
       pushNotice("channel saved", "info");
       return result;
     },
-    setWebhookConfig: (patch) => {
-      const result = runtime.setWebhookConfig(patch);
+    setWebhookConfig: async (patch) => {
+      const result = await runtime.setWebhookConfig(patch);
       pushNotice("webhook config updated", "info");
       return result;
     },
@@ -26076,6 +26179,39 @@ function createEngineApiB(bag) {
     listSessions: (options) => {
       return runtime.listSessions(options);
     },
+    switchContext: async (options) => {
+      if (getState().commandBusy) return false;
+      set({ commandBusy: true });
+      clearToastTimers();
+      resetAllStreamingMarkdownStablePrefixes();
+      const rollbackSnapshot = snapshotTuiBeforeSessionReset();
+      resetTuiForPendingSessionReset();
+      try {
+        await runtime.switchContext(options);
+        clearUiActivityBeforeContextSync();
+        flags.pendingSessionReset = false;
+        resetStatsAndSyncContext();
+        set({
+          items: replaceItems([]),
+          toasts: [],
+          queued: [],
+          thinking: null,
+          spinner: null,
+          lastTurn: null,
+          sessionId: null,
+          cwd: runtime.cwd,
+          ...routeState(),
+          stats: { ...getState().stats }
+        });
+        return true;
+      } catch (error) {
+        restoreTuiAfterFailedSessionReset(rollbackSnapshot);
+        throw error;
+      } finally {
+        flags.pendingSessionReset = false;
+        set({ commandBusy: false });
+      }
+    },
     newSession: async () => {
       if (getState().commandBusy) return false;
       set({ commandBusy: true });
@@ -27972,6 +28108,7 @@ async function runTui({ provider, model, toolMode, remote, forceOnboarding } = {
     name: "mixdog-tui",
     signals: ["SIGINT", "SIGTERM", "SIGHUP"],
     timeoutMs: EXIT_WAIT_TIMEOUT_MS + 1e3,
+    restoreTerminal,
     beforeCleanup: restoreTerminal,
     cleanup: disposeStoreOnce,
     afterCleanup: (reason) => {

package/src/tui/engine/session-api-ext.mjs

@@ -280,13 +280,13 @@ export function createEngineApiB(bag) {
       pushNotice('webhook/ngrok authtoken forgotten', 'info');
       return result;
     },
-    setChannel: (entry) => {
-      const result = runtime.setChannel(entry);
+    setChannel: async (entry) => {
+      const result = await runtime.setChannel(entry);
       pushNotice('channel saved', 'info');
       return result;
     },
-    setWebhookConfig: (patch) => {
-      const result = runtime.setWebhookConfig(patch);
+    setWebhookConfig: async (patch) => {
+      const result = await runtime.setWebhookConfig(patch);
       pushNotice('webhook config updated', 'info');
       return result;
     },
@@ -376,6 +376,39 @@ export function createEngineApiB(bag) {
     listSessions: (options) => {
       return runtime.listSessions(options);
     },
+    switchContext: async (options) => {
+      if (getState().commandBusy) return false;
+      set({ commandBusy: true });
+      clearToastTimers();
+      resetAllStreamingMarkdownStablePrefixes();
+      const rollbackSnapshot = snapshotTuiBeforeSessionReset();
+      resetTuiForPendingSessionReset();
+      try {
+        await runtime.switchContext(options);
+        clearUiActivityBeforeContextSync();
+        flags.pendingSessionReset = false;
+        resetStatsAndSyncContext();
+        set({
+          items: replaceItems([]),
+          toasts: [],
+          queued: [],
+          thinking: null,
+          spinner: null,
+          lastTurn: null,
+          sessionId: null,
+          cwd: runtime.cwd,
+          ...routeState(),
+          stats: { ...getState().stats },
+        });
+        return true;
+      } catch (error) {
+        restoreTuiAfterFailedSessionReset(rollbackSnapshot);
+        throw error;
+      } finally {
+        flags.pendingSessionReset = false;
+        set({ commandBusy: false });
+      }
+    },
     newSession: async () => {
       if (getState().commandBusy) return false;
       set({ commandBusy: true });

package/src/tui/index.jsx

@@ -530,6 +530,7 @@ export async function runTui({ provider, model, toolMode, remote, forceOnboardin
     name: 'mixdog-tui',
     signals: ['SIGINT', 'SIGTERM', 'SIGHUP'],
     timeoutMs: EXIT_WAIT_TIMEOUT_MS + 1000,
+    restoreTerminal,
     beforeCleanup: restoreTerminal,
     cleanup: disposeStoreOnce,
     afterCleanup: (reason) => {

package/src/tui/lib/voice-setup.mjs

@@ -18,7 +18,7 @@
  * loaded lazily via dynamic import — it should not load into memory unless a
  * user actually asks for voice.
  */
-import { readSection, updateSection } from '../../runtime/shared/config.mjs';
+import { readSection, updateSectionAsync } from '../../runtime/shared/config.mjs';
 import { resolvePluginData } from '../../runtime/shared/plugin-paths.mjs';
 
 let _voiceRuntimeFetcherPromise = null;
@@ -148,12 +148,12 @@ export async function ensureVoiceRuntimeReady({ dataDir = resolvePluginData(), p
 export async function toggleVoice({ pushNotice, setProgressHint } = {}) {
   const dataDir = resolvePluginData();
   if (isVoiceEnabled()) {
-    // updateSection is a synchronous file write (readAllForRmW + atomic write
-    // under a file lock) and can throw — a locked/corrupt config, a
+    // The async RMW preserves the shared config lock/ACL protocol without
+    // blocking the TUI event loop. It can still throw — a locked/corrupt config,
     // permissions error, etc. Guard it the same way the ON path is guarded and
     // report failure via pushNotice instead of silently pretending success.
     try {
-      updateSection('voice', (current) => ({ ...current, enabled: false }));
+      await updateSectionAsync('voice', (current) => ({ ...current, enabled: false }));
     } catch (err) {
       pushNotice?.(`Voice OFF failed: ${err?.message || err}`, 'error');
       return { ok: false, error: err?.message || String(err) };
@@ -168,7 +168,7 @@ export async function toggleVoice({ pushNotice, setProgressHint } = {}) {
   _voiceInstallBusy = true;
   try {
     await ensureVoiceRuntimeReady({ dataDir, pushNotice, setProgressHint });
-    updateSection('voice', (current) => ({ ...current, enabled: true }));
+    await updateSectionAsync('voice', (current) => ({ ...current, enabled: true }));
     setProgressHint?.('');
     pushNotice?.('Voice ON — channel voice messages will be transcribed', 'info');
     return true;

package/scripts/_devtools-stub.mjs

@@ -1 +0,0 @@
-export default {connectToDevTools(){}};