mixdog 1.2.0 → 1.2.1

package/src/runtime/effort-judge/judge-client.mjs

@@ -20,12 +20,19 @@ const MODEL_FILES = ['model.onnx', 'tokenizer.json'];
 // The worker runs one judgment at a time, so requests are sent one by one:
 // each answer's deadline starts when it is sent, and the wait for earlier
 // requests is bounded separately so a burst of turns queues instead of
-// timing out behind each other.
+// timing out behind each other. The next request is sent only once the worker
+// has answered the previous one: an answer that missed its deadline still
+// occupies the worker, and sending into it would start the next deadline
+// while the worker is busy, failing it too.
+// 500 ms covers the 18-layer judge's tail while parallel agents share the CPU.
 // MIXDOG_EFFORT_JUDGE_TIMEOUT_MS raises it on a host whose CPUs are shared
 // with heavy work (parallel benchmark containers).
 const WARM_TIMEOUT_MS =
-  Number(process.env.MIXDOG_EFFORT_JUDGE_TIMEOUT_MS) > 0 ? Number(process.env.MIXDOG_EFFORT_JUDGE_TIMEOUT_MS) : 400;
+  Number(process.env.MIXDOG_EFFORT_JUDGE_TIMEOUT_MS) > 0 ? Number(process.env.MIXDOG_EFFORT_JUDGE_TIMEOUT_MS) : 500;
 const QUEUE_WAIT_MS = 1000;
+// A worker that has not answered for this long is stuck; it is replaced so
+// the queue does not stay blocked behind it.
+const STUCK_MS = 10_000;
 let queueTail = Promise.resolve();
 // A turn that arrives while the judge is still loading (its first use, or the
 // first turn after a model update) waits at most this long; loading takes about 2 s on a desktop CPU.
@@ -107,7 +114,7 @@ function settle(id, fn) {
   const entry = pending.get(id);
   if (!entry) return;
   pending.delete(id);
-  clearTimeout(entry.timer);
+  entry.done();
   fn(entry);
 }
 
@@ -151,11 +158,27 @@ function ensureWorker(dir) {
   return created;
 }
 
+// `answer` settles with the probabilities or fails at the deadline; `done`
+// resolves once the worker has answered (or exited), when it can take the next request.
 function request(target, { request: text, prev, prevRequest, step }) {
   const id = ++msgId;
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => settle(id, (entry) => entry.reject(new Error('timeout'))), WARM_TIMEOUT_MS);
-    pending.set(id, { resolve, reject, timer });
+  let finish;
+  const done = new Promise((resolve) => {
+    finish = resolve;
+  });
+  const answer = new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('timeout')), WARM_TIMEOUT_MS);
+    const stuck = setTimeout(() => void target.terminate().catch(() => {}), STUCK_MS);
+    stuck.unref();
+    pending.set(id, {
+      resolve,
+      reject,
+      done: () => {
+        clearTimeout(timer);
+        clearTimeout(stuck);
+        finish();
+      },
+    });
     // The worker formats the text the way its model was trained.
     target.postMessage({
       action: 'judge',
@@ -169,6 +192,9 @@ function request(target, { request: text, prev, prevRequest, step }) {
       ...(step ? { step } : {}),
     });
   });
+  // A caller that gave up while queued never reads its answer.
+  answer.catch(() => {});
+  return { answer, done };
 }
 
 // One install at a time (the settings install and the boot refresh can overlap).
@@ -257,19 +283,31 @@ export async function judgeTurn(input) {
   if (!ready && !(await waitReady(COLD_WAIT_MS))) {
     return { skipped: lastLoadError ? `load-error: ${lastLoadError}` : 'warming' };
   }
-  const queuedAt = Date.now();
-  const run = queueTail.then(async () => {
-    if (worker !== target || !ready) return { skipped: 'effort judge exited' };
-    if (Date.now() - queuedAt > QUEUE_WAIT_MS) return { skipped: 'busy' };
-    const startedAt = Date.now();
-    try {
-      return { probs: await request(target, input), ms: Date.now() - startedAt };
-    } catch (error) {
-      return { skipped: String(error?.message || error) };
-    }
+  let abandoned = false;
+  const turn = queueTail.then(() => {
+    if (abandoned) return null;
+    if (worker !== target || !ready) return { exited: true };
+    return { startedAt: Date.now(), ...request(target, input) };
   });
-  queueTail = run;
-  return run;
+  queueTail = turn.then((sent) => sent?.done);
+  let timer;
+  const sent = await Promise.race([
+    turn,
+    new Promise((resolve) => {
+      timer = setTimeout(resolve, QUEUE_WAIT_MS, null);
+    }),
+  ]);
+  clearTimeout(timer);
+  if (!sent) {
+    abandoned = true;
+    return { skipped: 'busy' };
+  }
+  if (sent.exited) return { skipped: 'effort judge exited' };
+  try {
+    return { probs: await sent.answer, ms: Date.now() - sent.startedAt };
+  } catch (error) {
+    return { skipped: String(error?.message || error) };
+  }
 }
 
 // MIXDOG_EFFORT_DECISIONS_LOG redirects the log, e.g. for benchmark runs whose

package/src/runtime/memory/lib/memory.mjs

@@ -161,7 +161,7 @@ async function _migrateRecallIndexesIfStale(db) {
 }
 
 // One-time cleanup: attachment-only placeholder rows ('(attachment)' user
-// content, e.g. Discord provider discord.mjs:724) predate the
+// content from the former channel provider) predate the
 // shouldExcludeIngestMessage() ingest-time filter (session-ingest.mjs).
 // Delete any already-persisted rows so they stop polluting recall/cycle1.
 // Idempotent (no-op once cleaned); best-effort so a failure never blocks boot.

package/src/runtime/memory/lib/session-ingest.mjs

@@ -201,8 +201,8 @@ function isExcludedUserIngestText(m, text) {
   if (metaSource === 'task-notification') return true;
   // `Reference files:` synthetic user rows (manager.mjs isReferenceFilesMessage).
   if (/^Reference files:\s*/i.test(trimmedStart)) return true;
-  // Attachment-only placeholder rows (e.g. Discord provider discord.mjs:724
-  // `"(attachment)"` fallback when a message carries no text, only files).
+  // Attachment-only placeholder rows (`"(attachment)"` fallback written by the
+  // former channel provider when a message carried no text, only files).
   if (text.trim() === '(attachment)') return true;
   // Compaction summary user rows (compact.mjs isSummaryMessage / SUMMARY_PREFIX).
   if (metaSource === 'compact-summary') return true;

package/src/runtime/shared/atomic-file.mjs

@@ -21,7 +21,7 @@ import {
 } from 'node:fs/promises';
 import { dirname, basename, join } from 'node:path';
 import { randomBytes } from 'node:crypto';
-import { DEFAULT_BACKOFFS_MS, withFileLock, withFileLockSync } from './file-lock.mjs';
+import { DEFAULT_BACKOFFS_MS, recordLockTiming, withFileLock, withFileLockSync } from './file-lock.mjs';
 import {
   enforceOwnerOnlyAclWin32 as _enforceOwnerOnlyAclWin32,
   enforceOwnerOnlyAclWin32Async as _enforceOwnerOnlyAclWin32Async,
@@ -321,9 +321,30 @@ export async function writeFileAtomicAsync(filePath, data, opts = {}) {
   };
   // Acquire the file lock before occupying an I/O slot. Otherwise a waiter can
   // exhaust the gate while the current lock owner needs it to finish its write.
-  return opts.lock === true
-    ? withFileLock(`${filePath}.lock`, () => _runAdaptiveFileIo(run), opts)
-    : _runAdaptiveFileIo(run);
+  if (opts.lock !== true) return _runAdaptiveFileIo(run);
+  const lockPath = `${filePath}.lock`;
+  return withFileLock(
+    lockPath,
+    async () => {
+      const queuedAt = Date.now();
+      let startedAt = 0;
+      try {
+        return await _runAdaptiveFileIo(() => {
+          startedAt = Date.now();
+          return run();
+        });
+      } finally {
+        const now = Date.now();
+        // Recorded from this (lock-owner) context so the held warning can
+        // split the hold into gate wait vs. the write itself.
+        recordLockTiming(lockPath, {
+          ioGateWaitMs: (startedAt || now) - queuedAt,
+          writeMs: startedAt ? now - startedAt : 0,
+        });
+      }
+    },
+    opts
+  );
 }
 
 export function writeJsonAtomicAsync(filePath, value, opts = {}) {

package/src/runtime/shared/extension-scopes.mjs

@@ -16,6 +16,7 @@
 import { resolve, sep } from 'node:path';
 import { clean } from './clean.mjs';
 import { isPlainObject } from './object.mjs';
+import { parseMcpToolName } from './tool-primitives.mjs';
 
 export const EXTENSION_SCOPE_KINDS = Object.freeze(['skills', 'mcp', 'plugins']);
 
@@ -123,9 +124,10 @@ export function skillAllowedForCwd(scopes, skill, cwd) {
   return true;
 }
 
-export function mcpServerNameOfTool(toolName) {
-  const match = /^mcp__(.+?)__(.+)$/.exec(clean(toolName));
-  return match ? match[1] : '';
+/** Server of an MCP tool definition or name (metadata first; see parseMcpToolName). */
+export function mcpServerNameOfTool(toolOrName) {
+  const value = toolOrName && typeof toolOrName === 'object' ? toolOrName : clean(toolOrName);
+  return clean(parseMcpToolName(value)?.server);
 }
 
 /** New config with one entry replaced; `projects` null/empty removes it (global). */

package/src/runtime/shared/file-lock.mjs

@@ -177,16 +177,38 @@ function warnLockRateLimited(warnedAt, lockPath, line) {
   }
 }
 
-function reportLockWait(lockPath, waitedMs, mode) {
+function formatLockTiming(timing) {
+  return Object.entries(timing || {})
+    .filter(([, ms]) => Number.isFinite(ms))
+    .map(([name, ms]) => ` ${name}=${ms}ms`)
+    .join('');
+}
+
+// Lets a lock owner's callback attribute its time (io gate wait, write) to the
+// held-warning of the lock it runs under.
+export function recordLockTiming(lockPath, fields) {
+  const lease = heldLockPaths.getStore()?.get(lockPath);
+  if (lease?.active) Object.assign(lease.timing, fields);
+}
+
+function reportLockWait(lockPath, waitedMs, mode, timing) {
   if (waitedMs < LOCK_WAIT_WARN_MS) return;
-  warnLockRateLimited(lockWaitWarnedAt, lockPath, `[atomic-file] ${mode} lock wait ${waitedMs}ms: ${lockPath}\n`);
+  warnLockRateLimited(
+    lockWaitWarnedAt,
+    lockPath,
+    `[atomic-file] ${mode} lock wait ${waitedMs}ms:${formatLockTiming(timing)} ${lockPath}\n`
+  );
 }
 
 // A lock held this long starves every waiter (they time out at 2s), so the
 // holder's duration is reported once released.
-function reportLockHeld(lockPath, heldMs, mode) {
+function reportLockHeld(lockPath, heldMs, mode, timing) {
   if (heldMs < LOCK_HELD_WARN_MS) return;
-  warnLockRateLimited(lockHeldWarnedAt, lockPath, `[atomic-file] ${mode} lock held ${heldMs}ms: ${lockPath}\n`);
+  warnLockRateLimited(
+    lockHeldWarnedAt,
+    lockPath,
+    `[atomic-file] ${mode} lock held ${heldMs}ms:${formatLockTiming(timing)} ${lockPath}\n`
+  );
 }
 
 function* tryAcquireReclaimGuard(lockPath) {
@@ -387,7 +409,7 @@ export function sweepStagedLockFiles(lockPath, now = Date.now()) {
   return removed;
 }
 
-function* acquireLock(lockPath, opts, mode, markHeld) {
+function* acquireLock(lockPath, opts, mode, markHeld, timing = null) {
   const timeoutMs = lockTimeoutMs(opts);
   const staleMs = lockStaleMs(opts);
   const deadline = Date.now() + timeoutMs;
@@ -415,7 +437,9 @@ function* acquireLock(lockPath, opts, mode, markHeld) {
       attempt += 1;
       continue;
     }
-    reportLockWait(lockPath, Date.now() - waitStartedAt, mode);
+    const osMs = Date.now() - waitStartedAt;
+    if (timing) timing.osAcquireMs = osMs;
+    reportLockWait(lockPath, osMs, mode, timing);
     return;
   }
   throw timeoutError(lockPath, timeoutMs, lastError, yield* describeLockHolder(lockPath));
@@ -444,13 +468,15 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
 export async function withFileLock(lockPath, fn, opts = {}) {
   if (heldLockPaths.getStore()?.get(lockPath)?.active) return fn();
   if (lockTimeoutMs(opts) <= 0) return withOsFileLock(lockPath, fn, opts);
-  return lockQueue(lockPath, () => withOsFileLock(lockPath, fn, opts));
+  const enqueuedAt = Date.now();
+  return lockQueue(lockPath, () => withOsFileLock(lockPath, fn, opts, Date.now() - enqueuedAt));
 }
 
-async function withOsFileLock(lockPath, fn, opts = {}) {
-  await runAsync(acquireLock(lockPath, opts, 'async', true));
+async function withOsFileLock(lockPath, fn, opts = {}, queueWaitMs = 0) {
+  const timing = { queueWaitMs };
+  await runAsync(acquireLock(lockPath, opts, 'async', true, timing));
   const heldSince = Date.now();
-  const lease = { active: false };
+  const lease = { active: false, timing };
   try {
     if (opts.secret === true) await enforceOwnerOnlyAclWin32Async(lockPath, { fresh: true });
     // Async descendants inherit a reference to this lease, not permanent
@@ -464,7 +490,7 @@ async function withOsFileLock(lockPath, fn, opts = {}) {
     try {
       await runAsync(releaseLock(lockPath));
     } finally {
-      reportLockHeld(lockPath, Date.now() - heldSince, 'async');
+      reportLockHeld(lockPath, Date.now() - heldSince, 'async', timing);
       // Unmark only once the lock file is gone: a sync waiter arriving while
       // the release is still pending must fail fast, not block its completion.
       unmarkOsHeld(lockPath);

package/src/runtime/shared/llm/anthropic-effort.mjs

@@ -96,6 +96,20 @@ function _catalogLevels(model) {
   return null;
 }
 
+/**
+ * Effort levels the wire builder sends unchanged for `model` (reserved `max`
+ * excluded), from the same capability gates normalizeAnthropicEffortInput and
+ * applyAnthropicEffortToBody use: catalog record first, regex ladder for an
+ * absent record. A model without effort support, or whose catalog record
+ * declares none, accepts none.
+ */
+export function anthropicEffortLevelsFor(model) {
+  if (!modelSupportsEffort(model)) return [];
+  const levels = ['low', 'medium', 'high'];
+  if (modelSupportsXhighEffort(model)) levels.push('xhigh');
+  return levels;
+}
+
 export const EFFORT_BETA_HEADER = 'effort-2025-11-24';
 
 export const LEGACY_EFFORT_BUDGET = Object.freeze({

package/src/runtime/shared/llm/model-catalog.mjs

@@ -904,7 +904,6 @@ export function pricingCatalogRevisionSync() {
 }
 
 let lastAuditedRevision = null;
-let lastAudit = null;
 function auditCachedModelPricing() {
   const revision = pricingCatalogRevisionSync();
   const rows = Object.entries(cachedProviderModelListsSync()).flatMap(([provider, models]) =>
@@ -919,17 +918,6 @@ function auditCachedModelPricing() {
     );
   }
   lastAuditedRevision = revision;
-  lastAudit = { revision, rows, unpriced };
-  return lastAudit;
-}
-
-/** Catalog routes without a complete list price, from the latest audit (run on demand when none is cached). */
-export function unpricedModelsSync() {
-  return (lastAudit ?? auditCachedModelPricing()).unpriced.map(({ provider, model, missingRates }) => ({
-    provider,
-    model,
-    missingRates: [...missingRates],
-  }));
 }
 
 /**

package/src/runtime/shared/llm/provider-catalog-registry.mjs

@@ -85,6 +85,12 @@ const PROVIDER_CATALOGS = Object.freeze({
   // Effort tiers live in the wire id; a row without levels has no effort
   // surface (resolveAntigravityWireModel drops the effort).
   'antigravity-oauth': { relay: true, rosterFiles: ['antigravity-oauth-models.json'], rosterLadderFinal: true },
+  // api.commandcode.ai/provider/v1 relays other vendors' models.
+  'command-code-oauth': {
+    relay: true,
+    rosterFiles: ['command-code-oauth-models.json'],
+    rosterLimitsAuthoritative: true,
+  },
   'cursor-oauth': { relay: true },
   'cursor-api': { relay: true },
   'opencode-go': { relay: true },

package/src/runtime/shared/plugin-manifest.mjs

@@ -7,10 +7,19 @@
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { readJsonSafe } from './json-file.mjs';
 
-/** `.codex-plugin/plugin.json` wins over a root-level `plugin.json`; a plugin
- *  without either is an empty manifest, never an error. */
+/** Manifest files in precedence order: `.codex-plugin/plugin.json`, a
+ *  root-level `plugin.json`, then Claude Code's `.claude-plugin/plugin.json`. */
+export const PLUGIN_MANIFEST_FILES = ['.codex-plugin/plugin.json', 'plugin.json', '.claude-plugin/plugin.json'];
+
+/** First readable manifest in `PLUGIN_MANIFEST_FILES` order; a plugin without
+ *  any is an empty manifest, never an error. A Claude Code manifest's `skills`
+ *  is a plugin-relative path (e.g. `./.claude/skills/`). */
 export function pluginManifest(root) {
-  return readJsonSafe(join(root, '.codex-plugin', 'plugin.json')) || readJsonSafe(join(root, 'plugin.json')) || {};
+  for (const rel of PLUGIN_MANIFEST_FILES) {
+    const manifest = readJsonSafe(join(root, ...rel.split('/')));
+    if (manifest) return manifest;
+  }
+  return {};
 }
 
 /** Resolve a manifest-relative path, refusing absolute paths and anything
@@ -21,22 +30,22 @@ export function resolveContainedPluginPath(root, rel) {
   const base = resolve(root);
   const abs = resolve(base, trimmed);
   const relToBase = relative(base, abs);
-  if (relToBase.startsWith('..') || isAbsolute(relToBase)) return null;
+  if (relToBase.split(/[\\/]/)[0] === '..' || isAbsolute(relToBase)) return null;
   return abs;
 }
 
-/** Skill roots a plugin contributes: the conventional `<root>/skills/` plus an
- *  optional manifest `skills` path. Deduplicated, absolute, root-contained. */
+/** Skill roots a plugin contributes: the conventional `<root>/skills/` plus the
+ *  manifest `skills` field, a path or a list of paths. Deduplicated, absolute,
+ *  root-contained. */
 export function pluginSkillsRoots(root) {
   const manifest = pluginManifest(root);
   const roots = new Set();
   const add = (rel) => {
+    if (typeof rel !== 'string' || !rel.trim()) return;
     const abs = resolveContainedPluginPath(root, rel);
     if (abs) roots.add(abs);
   };
   add('./skills/');
-  if (typeof manifest.skills === 'string' && manifest.skills.trim()) {
-    add(manifest.skills.trim());
-  }
+  for (const rel of Array.isArray(manifest.skills) ? manifest.skills : [manifest.skills]) add(rel);
   return [...roots];
 }

package/src/runtime/shared/pristine-execution-contract.json

@@ -66,11 +66,18 @@
     },
     "muse-code-oauth": {
       "credentialFile": "muse-code-oauth.json",
-      "credentialPathEnv": "MUSE_CODE_OAUTH_CREDENTIALS_PATH"
+      "credentialPathEnv": "MUSE_CODE_OAUTH_CREDENTIALS_PATH",
+      "modelCatalogFile": "muse-code-oauth-models.json"
+    },
+    "command-code-oauth": {
+      "credentialFile": "command-code-oauth.json",
+      "credentialPathEnv": "COMMAND_CODE_OAUTH_CREDENTIALS_PATH",
+      "modelCatalogFile": "command-code-oauth-models.json"
     },
     "mimo-oauth": {
       "credentialFile": "mimo-oauth.json",
-      "credentialPathEnv": "MIMO_OAUTH_CREDENTIALS_PATH"
+      "credentialPathEnv": "MIMO_OAUTH_CREDENTIALS_PATH",
+      "modelCatalogFile": "mimo-oauth-models.json"
     },
     "cursor-oauth": {
       "credentialFile": "cursor-oauth.json",

package/src/runtime/shared/pristine-execution.mjs

@@ -8,6 +8,12 @@ import { ACCOUNT_PROVIDERS, providerAccountPath, readProviderAccountPool } from
 import { AGENT_PROVIDER_ENV_ALIASES, getAgentApiKey } from './provider-api-key.mjs';
 import { platformEntryKey } from './native-asset.mjs';
 import { clean } from './clean.mjs';
+import { MODEL_PROXY_ENV, modelProxyClientMode } from './model-proxy-mode.mjs';
+import { installModelProxyChannel } from '../agent/orchestrator/providers/model-proxy-channel.mjs';
+import {
+  ModelProxyBridgeChannel,
+  readModelProxyBridgeDiscovery,
+} from '../agent/orchestrator/providers/model-proxy-bridge.mjs';
 
 const contractPath = fileURLToPath(new URL('./pristine-execution-contract.json', import.meta.url));
 
@@ -205,6 +211,12 @@ export function createPristineExecutionBoundary({
 
   const contract = PRISTINE_EXECUTION_CONTRACT;
   const hostEnv = { ...env };
+  // Remote (SSH) mode: this server holds no model credentials, so the child
+  // runtime's model calls go through the daemon's model proxy bridge. Its
+  // endpoint is read from the HOST runtime root, before it is retargeted
+  // below; a missing or stale one fails closed (never a local credential).
+  const proxyMode = modelProxyClientMode(hostEnv);
+  const bridgeEndpoint = proxyMode ? readModelProxyBridgeDiscovery(hostEnv.MIXDOG_RUNTIME_ROOT) : null;
   const originalEnv = new Map();
   const touchedKeys = new Set();
   const rememberEnv = (name) => {
@@ -227,6 +239,8 @@ export function createPristineExecutionBoundary({
   mkdirSync(runtimeRoot, { recursive: true, mode: 0o700 });
   let cleaned = false;
   let restoreAuthBindings = () => {};
+  let bridgeChannel = null;
+  let restoreModelProxyChannel = () => {};
   // rmSync backs off linearly (retryDelay × attempt), so 50 retries at 100ms
   // is a ≈128s budget per attempt. Callers whose result is already complete
   // (headless exec) pass a smaller budget and leave stragglers to the sweep.
@@ -238,6 +252,8 @@ export function createPristineExecutionBoundary({
       else env[name] = value;
     }
     restoreAuthBindings();
+    restoreModelProxyChannel();
+    bridgeChannel?.dispose('the headless run finished');
     const removal = { recursive: true, force: true, maxRetries: rootRemovalRetries, retryDelay: 100 };
     // Windows releases file handles (pg.log, sockets) a beat after the owning
     // process exits; rmSync retries absorb that EBUSY/EPERM window.
@@ -280,7 +296,7 @@ export function createPristineExecutionBoundary({
     const oauth = contract.oauthProviders[selectedProvider];
     const apiKeyEnv = contract.apiKeyProviders[selectedProvider];
     let selectedApiKey = null;
-    if (apiKeyEnv) {
+    if (apiKeyEnv && !proxyMode) {
       // Resolve before scrubbing so the selected provider may use its standard,
       // MIXDOG_AGENT_*, alias, or one provider-scoped keychain account. No
       // general config loader or all-provider credential scan is involved.
@@ -311,7 +327,15 @@ export function createPristineExecutionBoundary({
 
     let authMode = 'provider-managed';
     let catalogCount = 0;
-    if (oauth) {
+    if (proxyMode) {
+      // No API key, OAuth account or credential binding: the PC behind the
+      // daemon runs every call. The runtime root stays the pristine one, for
+      // the services this run owns; only model calls reach the daemon.
+      setEnv(MODEL_PROXY_ENV, 'client');
+      bridgeChannel = new ModelProxyBridgeChannel(bridgeEndpoint);
+      restoreModelProxyChannel = installModelProxyChannel(bridgeChannel);
+      authMode = 'model-proxy-bridge';
+    } else if (oauth) {
       // Sign-in writes the selected account of the host's provider-accounts
       // pool; the single legacy file remains for hosts that predate the pool.
       // An explicit credential path still overrides both. Read the pool from
@@ -340,8 +364,8 @@ export function createPristineExecutionBoundary({
         [selectedProvider]: sourceCredential,
       });
       authMode = 'in-process-host-oauth-binding';
-      const sourceCatalog = join(sourceDataDir, oauth.modelCatalogFile);
-      if (oauth.modelCatalogFile && existsSync(sourceCatalog)) {
+      const sourceCatalog = oauth.modelCatalogFile && join(sourceDataDir, oauth.modelCatalogFile);
+      if (sourceCatalog && existsSync(sourceCatalog)) {
         copyFileSync(sourceCatalog, join(dataDir, oauth.modelCatalogFile));
         catalogCount = 1;
       }