mixdog 1.4.1 → 1.4.3

package/src/runtime/agent/orchestrator/providers/model-cache.mjs

@@ -1,7 +1,31 @@
 import { readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { getPluginData } from '../config.mjs';
-import { updateJsonAtomicSync, writeJsonAtomicSync } from '../../../shared/atomic-file.mjs';
+import { updateJsonAtomic, writeJsonAtomicAsync } from '../../../shared/atomic-file.mjs';
+
+// Disk writes never block the event loop: they run on the async atomic-file
+// primitives, one at a time per cache file, in the order they were requested
+// (a later write is never overtaken by an earlier one finishing late). Every
+// instance of one file shares these module-level tables, since several
+// instances and several providers can address the same path.
+const writeTails = new Map(); // path → tail of that file's write chain
+// path → JSON text of the newest save() whose write has not finished. Sync
+// readers see it, so a save is visible at once although its disk write is not.
+const unsettledSaves = new Map();
+
+function enqueueWrite(p, task) {
+  const run = (writeTails.get(p) ?? Promise.resolve()).then(task);
+  writeTails.set(p, run);
+  run.then(() => {
+    if (writeTails.get(p) === run) writeTails.delete(p);
+  });
+  return run;
+}
+
+/** Resolves once every cache write requested so far has settled (shutdown, tests). */
+export async function flushModelCacheWrites() {
+  while (writeTails.size) await Promise.all([...writeTails.values()]);
+}
 
 // Shared model-catalog disk-cache CRUD, parameterized over the small bits each
 // provider varies: cache file name, TTL, an optional schema-version gate, and an
@@ -15,9 +39,10 @@ export function makeModelCache({ fileName, ttlMs, version = null, onSave = null
   // allowStale skips the TTL only; the schema-version gate still applies.
   function loadEntrySync({ allowStale = false } = {}) {
     const p = path();
-    if (!existsSync(p)) return null;
+    const unsettled = unsettledSaves.get(p);
+    if (unsettled === undefined && !existsSync(p)) return null;
     try {
-      const raw = JSON.parse(readFileSync(p, 'utf-8'));
+      const raw = JSON.parse(unsettled ?? readFileSync(p, 'utf-8'));
       if (version != null && raw?.version !== version) return null;
       if (!raw?.fetchedAt || !Array.isArray(raw.models)) return null;
       if (!allowStale && Date.now() - raw.fetchedAt > ttlMs) return null;
@@ -31,56 +56,98 @@ export function makeModelCache({ fileName, ttlMs, version = null, onSave = null
     return loadEntrySync(options)?.models ?? null;
   }
 
+  // The in-memory state (sync readers, onSave mirror) updates at once; the
+  // returned promise settles, never rejecting, when the disk write has.
   function save(models, extra = {}) {
+    const p = path();
+    // The value as of this call: later mutation of `models` must not change
+    // what lands on disk (the old synchronous write captured it the same way).
+    let text;
+    let record;
+    try {
+      text = JSON.stringify({
+        ...extra,
+        ...(version != null ? { version } : {}),
+        fetchedAt: Date.now(),
+        models,
+      });
+      record = JSON.parse(text);
+      unsettledSaves.set(p, text);
+    } catch {
+      return Promise.resolve();
+    }
     try {
-      writeJsonAtomicSync(
-        path(),
-        {
-          ...extra,
-          ...(version != null ? { version } : {}),
-          fetchedAt: Date.now(),
-          models,
-        },
-        { lock: true, fsyncDir: true }
-      );
       if (onSave) onSave(models);
     } catch {
       /* best-effort */
     }
+    return enqueueWrite(p, async () => {
+      try {
+        await writeJsonAtomicAsync(p, record, { lock: true, fsyncDir: true });
+      } catch {
+        /* best-effort */
+      } finally {
+        if (unsettledSaves.get(p) === text) unsettledSaves.delete(p);
+      }
+    });
   }
 
   // A discovery request claims a generation when it starts. Its roster is
   // written only if no newer request started meanwhile — in this process
   // (generation) or another one (`requestedAt` checked under the file lock) —
   // and `isCurrent()` (the credential it was fetched with is still active) holds.
+  // The returned publish() resolves, never rejecting, to whether the roster was
+  // written; the cross-process check runs under the file lock, so the answer
+  // is only known once the queued write has run.
   let generation = 0;
   function beginSave(isCurrent) {
     const claimed = ++generation;
     const requestedAt = Date.now();
+    const stillWanted = () => claimed === generation && isCurrent();
     return (models, extra = {}) => {
-      if (claimed !== generation || !isCurrent()) return false;
-      let written = false;
+      if (!stillWanted()) return Promise.resolve(false);
+      const p = path();
+      // The roster as of this call, not as mutated while the write waits.
+      let snapshot;
       try {
-        updateJsonAtomicSync(
-          path(),
-          (cur) => {
-            if (Number(cur?.requestedAt) > requestedAt) return undefined;
-            written = true;
-            return {
-              ...extra,
-              ...(version != null ? { version } : {}),
-              fetchedAt: Date.now(),
-              requestedAt,
-              models,
-            };
-          },
-          { fsyncDir: true }
-        );
+        snapshot = JSON.parse(JSON.stringify({ extra, models }));
       } catch {
-        /* best-effort */
+        return Promise.resolve(false);
       }
-      if (written && onSave) onSave(models);
-      return written;
+      return enqueueWrite(p, async () => {
+        // A newer request may have started while this write waited its turn.
+        if (!stillWanted()) return false;
+        let written = false;
+        try {
+          await updateJsonAtomic(
+            p,
+            (cur) => {
+              if (Number(cur?.requestedAt) > requestedAt) return undefined;
+              // The lock wait is asynchronous: a newer request or a credential
+              // change may have landed since the checks above. Re-decide now,
+              // right before accepting the data.
+              if (!stillWanted()) return undefined;
+              written = true;
+              return {
+                ...snapshot.extra,
+                ...(version != null ? { version } : {}),
+                fetchedAt: Date.now(),
+                requestedAt,
+                models: snapshot.models,
+              };
+            },
+            { fsyncDir: true }
+          );
+        } catch {
+          /* best-effort */
+        }
+        try {
+          if (written && onSave) onSave(models);
+        } catch {
+          /* best-effort */
+        }
+        return written;
+      });
     };
   }
 

package/src/runtime/agent/orchestrator/providers/muse-code-oauth.mjs

@@ -435,7 +435,7 @@ export class MuseCodeOAuthProvider {
       });
     const rows = discovered.map((row) => museRow(row.id, row));
     // A superseded or other-credential response never replaces the live roster either.
-    if (publish(discovered)) inner._enrichedModels = rows;
+    if (await publish(discovered)) inner._enrichedModels = rows;
     return rows;
   }
 

package/src/runtime/agent/orchestrator/providers/oauth-secret-fields.fixtures.mjs

@@ -0,0 +1,45 @@
+// The authorization code a test login sends: redacted by value, since `code`
+// alone is also an error/status field.
+export const AUTH_CODE = 'SECRET-CODE';
+
+// Every secret field a token endpoint might echo, each with a distinct value
+// that a test can search for in pages, errors and logs.
+export const SECRET_FIELDS = {
+  access_token: 'SECRET-ACCESS',
+  refresh_token: 'SECRET-REFRESH',
+  id_token: 'SECRET-ID',
+  client_secret: 'SECRET-CLIENT',
+  code: AUTH_CODE,
+  code_verifier: 'SECRET-VERIFIER',
+  code_challenge: 'SECRET-CHALLENGE',
+  device_code: 'SECRET-DEVICE',
+  accessToken: 'SECRET-CAMEL-ACCESS',
+  refreshToken: 'SECRET-CAMEL-REFRESH',
+  idToken: 'SECRET-CAMEL-ID',
+  clientSecret: 'SECRET-CAMEL-CLIENT',
+  token: 'SECRET-TOKEN',
+};
+
+export const SECRET_RE = /SECRET-/;
+
+/** Valid JSON whose secret keys are written with escapes, nested in objects and arrays. */
+export const ESCAPED_SECRET_BODY = String.raw`{"error":{"code":400,"details":[{"client\u005fsecret":"SECRET-ESC-CLIENT","Refresh\u005FToken":"SECRET-ESC-REFRESH"},["x",{"\u0069d_token":"SECRET-ESC-ID"}]],"meta":{"api\u005Fkey":"SECRET-ESC-KEY","acc\u0065ss\u005ftoken":"SECRET-ESC-ACCESS"}}}`;
+
+/** Valid JSON whose secrets sit inside string values: form-encoded, a query string, nested JSON. */
+export const STRING_SECRET_BODY = JSON.stringify({
+  error: 'invalid_request',
+  detail: 'access_token=SECRET-FORM-ACCESS&client_secret=SECRET-FORM-CLIENT',
+  error_uri: 'https://auth.example/cb?client_secret=SECRET-QUERY-CLIENT&state=ok',
+  nested: JSON.stringify({ refresh_token: 'SECRET-NESTED', inner: String.raw`{"client\u005fsecret":"SECRET-DEEP"}` }),
+});
+
+/** Token-endpoint failure bodies carrying every secret field (JSON, escaped JSON, strings, form-encoded). */
+export const SECRET_BODIES = [
+  JSON.stringify({ error: 'invalid_grant', ...SECRET_FIELDS }),
+  ESCAPED_SECRET_BODY,
+  STRING_SECRET_BODY,
+  new URLSearchParams({ error: 'invalid_grant', ...SECRET_FIELDS }).toString(),
+];
+
+/** A 200 body that is not JSON but carries tokens (the parser would quote it). */
+export const MALFORMED_TOKEN_BODY = '{"access_token":"SECRET-ACCESS","refresh_token":"SECRET-REFRESH" oops';

package/src/runtime/agent/orchestrator/providers/openai-compat-response-normalization.mjs

@@ -234,12 +234,10 @@ export function normalizeCompatChatResponse({
     model: response.model || useModel,
     toolCalls,
     stopReason,
-    // P1 audit fix: a text-only completion that hit finish_reason=
-    // 'length' (no tool calls, so not thrown above as
-    // ProviderIncompleteError) previously returned as an ordinary
-    // success with no signal that the content is a mid-sentence
-    // cutoff. Flag it so loop.mjs can surface a one-line warning
-    // instead of silently treating a truncated answer as complete.
+    // A text-only completion that hit finish_reason='length' (no tool
+    // calls, so not thrown above as ProviderIncompleteError) is flagged so
+    // loop.mjs can surface a one-line warning instead of silently treating
+    // a mid-sentence cutoff as complete.
     ...(stopReason === 'length' && (assembled.content || '').length > 0 ? { truncated: true } : {}),
     ...(reasoningContent !== null ? { reasoningContent } : {}),
     ...(Object.keys(providerMetadata).length ? { providerMetadata } : {}),