mixdog 0.7.6 → 0.7.8

package/scripts/run-mcp.mjs

@@ -19,10 +19,14 @@ import { fileURLToPath } from 'url';
 import { createRequire } from 'module';
 import { dirname, join } from 'path';
 import * as fs from 'fs';
-import { createHash, randomUUID } from 'crypto';
-import { execSync, spawn, spawnSync } from 'child_process';
+import { randomUUID } from 'crypto';
+import { execSync, spawn } from 'child_process';
 import * as os from 'os';
-import { assertSafeOwnedDir } from '../src/shared/user-data-guard.mjs';
+import {
+  ensureRuntimeDeps,
+  hasRequiredDeps,
+  renameWithRetrySync,
+} from './ensure-deps.mjs';
 
 // Stable per-terminal session id for this proxy supervisor's lifetime. The
 // child server.mjs is respawned on crash / dev-sync restart, but THIS
@@ -34,29 +38,6 @@ import { assertSafeOwnedDir } from '../src/shared/user-data-guard.mjs';
 // upstream-provided id if one already exists.
 const STABLE_TERMINAL_SESSION_ID = process.env.MIXDOG_SESSION_ID || randomUUID();
 
-const RENAME_RETRY_CODES = new Set(['EPERM', 'EACCES', 'EBUSY', 'EEXIST']);
-const RENAME_BACKOFFS_MS = Object.freeze([25, 50, 100, 200, 400, 800, 1200, 1600]);
-function sleepSync(ms) {
-  try {
-    const buf = new SharedArrayBuffer(4);
-    Atomics.wait(new Int32Array(buf), 0, 0, Math.max(1, Number(ms) || 1));
-  } catch {}
-}
-function renameWithRetrySync(src, dst) {
-  let lastErr = null;
-  for (let attempt = 0; attempt <= RENAME_BACKOFFS_MS.length; attempt++) {
-    try {
-      fs.renameSync(src, dst);
-      return true;
-    } catch (err) {
-      lastErr = err;
-      if (!RENAME_RETRY_CODES.has(err?.code) || attempt >= RENAME_BACKOFFS_MS.length) break;
-      sleepSync(RENAME_BACKOFFS_MS[attempt] + Math.floor(Math.random() * 50));
-    }
-  }
-  throw lastErr;
-}
-
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const __localRoot = join(__dirname, '..');
 
@@ -87,7 +68,6 @@ if (pluginRoot !== __localRoot) {
 }
 const serverPath = join(pluginRoot, 'server.mjs');
 const pluginPkg  = join(pluginRoot, 'package.json');
-const pluginLock = join(pluginRoot, 'bun.lock');
 const pluginNm   = join(pluginRoot, 'node_modules');
 
 process.stderr.write(`[boot-time] tag=run-mcp-entry tMs=${Date.now()}\n`);
@@ -110,17 +90,6 @@ try {
 // server.mjs reads MIXDOG_SUPERVISOR_PID + MIXDOG_SUPERVISOR_CACHE_DIR
 // from its env (set in spawnChild below) to identify the supervisor.
 
-const requiredDepNames = [
-  ['@modelcontextprotocol', 'sdk', 'package.json'],
-  ['zod', 'package.json'],
-  ['zod-to-json-schema', 'package.json'],
-  ['openai', 'package.json'],
-];
-
-function hasRequiredDeps(nmDir) {
-  return requiredDepNames.every((parts) => fs.existsSync(join(nmDir, ...parts)));
-}
-
 // ── Lightweight JSON-RPC line scanner ────────────────────────────────────────
 // Extracts `id` and `method` from a JSON-RPC line without a full JSON.parse.
 // Returns { id, method } (each may be undefined), or null on scan failure.
@@ -256,50 +225,6 @@ function _scanIdMethod(line) {
   }
 }
 
-const LOCK_POLL_MS  = 250;
-const LOCK_MAX_MS   = 15 * 60 * 1000;
-const LOCK_XHOST_MS = 10 * 60 * 1000;
-
-function acquireLock(lockFile) {
-  const start = Date.now();
-  while (Date.now() - start < LOCK_MAX_MS) {
-    try {
-      const body = JSON.stringify({
-        pid:       process.pid,
-        hostname:  os.hostname(),
-        startedAt: Date.now(),
-      });
-      // 'wx' = O_CREAT | O_EXCL — fails atomically if file already exists.
-      fs.writeFileSync(lockFile, body, { flag: 'wx' });
-      return;
-    } catch (e) {
-      if (e.code !== 'EEXIST') throw e;
-      try {
-        const raw  = fs.readFileSync(lockFile, 'utf8');
-        const body = JSON.parse(raw);
-        const st   = fs.statSync(lockFile);
-        const sameHost = body.hostname === os.hostname();
-        let dead = false;
-        if (sameHost) {
-          try { process.kill(body.pid, 0); }
-          catch (ke) { if (ke.code === 'ESRCH') dead = true; }
-        } else {
-          if (Date.now() - st.mtimeMs > LOCK_XHOST_MS) dead = true;
-        }
-        if (dead) fs.unlinkSync(lockFile);
-      } catch { /* lock may have been released between read and stat — retry */ }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_POLL_MS);
-    }
-  }
-  throw new Error(
-    `timed out waiting for dependency install lock after ${LOCK_MAX_MS / 60000} minutes`
-  );
-}
-
-function releaseLock(lockFile) {
-  try { fs.unlinkSync(lockFile); } catch {}
-}
-
 function ensureNmSymlink(linkPath, targetPath) {
   const linkType = process.platform === 'win32' ? 'junction' : 'dir';
   // EPERM/EBUSY here is almost always a transient AV / indexer lock on the
@@ -353,32 +278,6 @@ function ensureNmSymlink(linkPath, targetPath) {
   trySymlink();
 }
 
-function sha256(buf) {
-  return createHash('sha256').update(buf).digest('hex');
-}
-
-/**
- * SHA-256 hash that changes iff the resolved dep tree changes.
- * Primary: bun.lock. Fallback: dep-key objects from package.json (so the very
- * first install — before bun.lock exists — still hashes deterministically).
- */
-function computeDepHash(pkgJsonPath, pkgLockPath) {
-  if (fs.existsSync(pkgLockPath)) {
-    return sha256(fs.readFileSync(pkgLockPath));
-  }
-  const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
-  const depKeys = ['dependencies', 'optionalDependencies', 'peerDependencies'];
-  const depObj = {};
-  for (const k of depKeys) {
-    if (pkg[k]) {
-      depObj[k] = Object.fromEntries(
-        Object.entries(pkg[k]).sort(([a], [b]) => a.localeCompare(b))
-      );
-    }
-  }
-  return sha256(Buffer.from(JSON.stringify(depObj)));
-}
-
 const require = createRequire(import.meta.url);
 const { resolvePluginData } = require('../lib/plugin-paths.cjs');
 const dataDir = resolvePluginData();
@@ -433,67 +332,13 @@ try {
 // Install runtime deps into a DEDICATED <dataDir>/.deps/ subdir — NEVER the
 // data root, which holds user data (mixdog-config.json, user-workflow.*,
 // roles/). Running `bun install` with cwd=dataDir would wipe that state.
-const depsDir    = join(dataDir, '.deps');
-const sharedPkg  = join(depsDir, 'package.json');
-const sharedLock = join(depsDir, 'bun.lock');
-const sharedNm   = join(depsDir, 'node_modules');
-const stamp      = join(depsDir, '.deps-stamp');
-const stampTmp   = join(depsDir, '.deps-stamp.tmp');
-const lockFile   = join(depsDir, '.install.lock');
-
-const currentHash = computeDepHash(pluginPkg, pluginLock);
-let storedHash = '';
-try { storedHash = fs.readFileSync(stamp, 'utf8').trim(); } catch {}
-
-const needsInstall = (currentHash !== storedHash) || !hasRequiredDeps(sharedNm);
-
-if (needsInstall) {
-  // Hard guard: refuse to install anywhere that would clobber user data.
-  // assertSafeOwnedDir throws unless depsDir is an owned subdir (.deps).
-  assertSafeOwnedDir(depsDir, dataDir, 'bun install');
-  fs.mkdirSync(depsDir, { recursive: true });
-  acquireLock(lockFile);
-  try {
-    fs.copyFileSync(pluginPkg, sharedPkg);
-    if (fs.existsSync(pluginLock)) fs.copyFileSync(pluginLock, sharedLock);
-
-    const args = fs.existsSync(sharedLock)
-      ? ['install', '--frozen-lockfile']
-      : ['install'];
-    process.stderr.write(`[run-mcp] installing shared deps: bun ${args.join(' ')}\n`);
+ensureRuntimeDeps({
+  dataDir,
+  pluginRoot,
+  bunPath: process.env.BUN_EXEC_PATH,
+});
 
-    // First install on a clean machine downloads + extracts all deps, which
-    // routinely exceeds 30s; too low a ceiling times out into an empty
-    // node_modules and aborts the very first boot. 3 minutes covers a cold
-    // network fetch while still bounding a genuinely stuck install.
-    const INSTALL_TIMEOUT_MS = 180_000;
-    const result = spawnSync(process.env.BUN_EXEC_PATH || process.execPath, args, {
-      cwd: depsDir,
-      stdio: 'inherit',
-      timeout: INSTALL_TIMEOUT_MS,
-      windowsHide: true,
-    });
-    if (result.error?.code === 'ETIMEDOUT' || result.signal === 'SIGTERM') {
-      process.stderr.write(
-        `[run-mcp] WARN: bun install timed out after ${INSTALL_TIMEOUT_MS}ms — ` +
-        `continuing with existing node_modules (stale lock removed)\n`
-      );
-      try { fs.unlinkSync(lockFile); } catch {}
-    } else if (result.status !== 0) {
-      const detail = result.status ?? result.signal ?? 'unknown';
-      process.stderr.write(
-        `[run-mcp] WARN: bun install exited with status ${detail} — ` +
-        `continuing with existing node_modules if available\n`
-      );
-    } else {
-      // Atomic stamp write: tmp + rename so a crash cannot leave it half-written.
-      fs.writeFileSync(stampTmp, currentHash);
-      renameWithRetrySync(stampTmp, stamp);
-    }
-  } finally {
-    releaseLock(lockFile);
-  }
-}
+const sharedNm = join(dataDir, '.deps', 'node_modules');
 
 ensureNmSymlink(pluginNm, sharedNm);
 

package/setup/install.mjs

@@ -2,7 +2,7 @@
 // install.mjs — one-shot bootstrapper that registers the mixdog plugin in the
 // user's Claude Code settings so it auto-loads on the next session start.
 //
-// Run via:  npx mixdog setup | mixdog-install   (after the package is published)
+// Run via:  npx mixdog | mixdog install | mixdog-install   (after publish)
 //       or:  node setup/install.mjs             (from a checkout)
 //
 // It merges two keys into the user-scope settings file (preserving everything
@@ -19,14 +19,18 @@ import {
   existsSync,
   mkdirSync,
   copyFileSync,
+  mkdtempSync,
+  rmSync,
 } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
 import { realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { DEFAULT_MARKETPLACE, DEFAULT_PLUGIN } from '../src/shared/plugin-paths.mjs';
+import { resolveClaudeExecutable } from './locate-claude.mjs';
+import { createSpinner } from './tui.mjs';
 
 const MARKETPLACE = DEFAULT_MARKETPLACE;
 const PLUGIN_REF = `${DEFAULT_PLUGIN}@${DEFAULT_MARKETPLACE}`;
@@ -64,7 +68,7 @@ function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-function registerPluginInSettings() {
+function registerPluginInSettings(dryRun = false) {
   const dir = settingsDir();
   const file = join(dir, 'settings.json');
 
@@ -90,6 +94,15 @@ function registerPluginInSettings() {
   const already = settings.enabledPlugins[PLUGIN_REF] === true;
   settings.enabledPlugins[PLUGIN_REF] = true;
 
+  if (dryRun) {
+    console.log(`[dry-run] would register mixdog in ${file}`);
+    console.log(`[dry-run]   marketplace "${MARKETPLACE}" → github:${REPO}`);
+    console.log(
+      `[dry-run]   enabled plugin "${PLUGIN_REF}"${already ? ' (was already enabled)' : ''}`,
+    );
+    return;
+  }
+
   // Back up an existing file before the first write; create the dir otherwise.
   if (existsSync(file)) {
     const stamp = new Date().toISOString().replace(/[:.]/g, '-');
@@ -107,19 +120,223 @@ function registerPluginInSettings() {
   console.log(`\nNext: restart Claude Code (or run /reload-plugins). mixdog loads automatically.`);
 }
 
+const CLAUDE_SETUP_GUIDANCE =
+  'Install Claude Code first: https://code.claude.com/docs/en/setup';
+
+function officialClaudeInstallerCommandDescription() {
+  if (process.platform === 'win32') {
+    return 'powershell -NoProfile -Command "irm https://claude.ai/install.ps1 | iex"';
+  }
+  return 'bash -c "curl -fsSL https://claude.ai/install.sh | bash"';
+}
+
+function runOfficialClaudeInstaller() {
+  if (process.platform === 'win32') {
+    spawnSync(
+      'powershell.exe',
+      ['-NoProfile', '-Command', 'irm https://claude.ai/install.ps1 | iex'],
+      { stdio: 'inherit', windowsHide: true },
+    );
+  } else {
+    spawnSync('bash', ['-c', 'curl -fsSL https://claude.ai/install.sh | bash'], {
+      stdio: 'inherit',
+    });
+  }
+}
+
+function askInstallClaude() {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(
+      'Claude Code CLI not found. Install it now with the official installer? (y/N) ',
+      (answer) => {
+        rl.close();
+        const a = answer.trim().toLowerCase();
+        resolve(a === 'y' || a === 'yes');
+      },
+    );
+  });
+}
+
+async function ensureClaudeInstalled(dryRun = false) {
+  const claudePath = resolveClaudeExecutable();
+  if (claudePath) {
+    if (dryRun) console.log(`[dry-run] Claude Code detected at ${claudePath}`);
+    return;
+  }
+
+  if (dryRun) {
+    const cmd = officialClaudeInstallerCommandDescription();
+    console.log(
+      `[dry-run] Claude Code NOT found — would prompt to install via the official installer (${cmd})`,
+    );
+    return;
+  }
+
+  const interactive = process.stdin.isTTY && !process.env.CI;
+
+  if (!interactive) {
+    console.log(CLAUDE_SETUP_GUIDANCE);
+    return;
+  }
+
+  const yes = await askInstallClaude();
+  if (yes) {
+    runOfficialClaudeInstaller();
+    if (resolveClaudeExecutable()) {
+      console.log('✓ Claude Code detected.');
+      return;
+    }
+    console.log(
+      "✓ Claude Code installed — open a NEW terminal so 'claude' is on PATH, then start Claude Code (mixdog is being registered now).",
+    );
+    return;
+  }
+
+  console.log(CLAUDE_SETUP_GUIDANCE);
+}
+
+const WIZARD_STEP_LABELS = [
+  'Address form',
+  'Discord bot token',
+  'Voice transcription',
+  'Webhook receiver',
+  'Provider API keys',
+  'Model presets',
+  'Role → preset mapping',
+  'Search backend',
+  'Explorer maintenance preset',
+];
+
+function logDryRunWizard() {
+  console.log('[dry-run] would run the setup wizard (9 steps):');
+  for (let i = 0; i < WIZARD_STEP_LABELS.length; i += 1) {
+    console.log(`[dry-run]   ${i + 1}. ${WIZARD_STEP_LABELS[i]}`);
+  }
+}
+
+async function runInstallDemo() {
+  const tmpRoot = mkdtempSync(join(tmpdir(), 'mixdog-demo-'));
+  const configDir = join(tmpRoot, 'config');
+  const dataDir = join(tmpRoot, 'data');
+  process.env.CLAUDE_CONFIG_DIR = configDir;
+  process.env.CLAUDE_PLUGIN_DATA = dataDir;
+  mkdirSync(configDir, { recursive: true });
+  mkdirSync(dataDir, { recursive: true });
+
+  process.on('exit', () => {
+    try {
+      rmSync(tmpRoot, { recursive: true, force: true });
+    } catch {}
+  });
+
+  console.log('\n🎬 mixdog demo — real wizard UI, nothing saved (isolated temp, auto-cleaned).\n');
+
+  const claudePath = resolveClaudeExecutable();
+  if (claudePath) {
+    console.log(`[demo] Claude Code detected at ${claudePath}`);
+  } else {
+    console.log('[demo] Claude Code not detected');
+  }
+
+  console.log('[demo] skipping plugin registration');
+
+  const { runSetupWizard } = await import('./wizard.mjs');
+  await runSetupWizard();
+
+  console.log('[demo] skipping runtime dependency install');
+
+  console.log('\n✓ Demo complete — nothing was saved to your real config.');
+  try {
+    rmSync(tmpRoot, { recursive: true, force: true });
+  } catch {}
+}
+
 export async function runInstall() {
-  registerPluginInSettings();
+  const demo =
+    process.argv.includes('--demo') || process.env.MIXDOG_SETUP_DEMO === '1';
+  if (demo) {
+    await runInstallDemo();
+    return;
+  }
+
+  const dryRun =
+    process.argv.includes('--dry-run') || process.env.MIXDOG_SETUP_DRY_RUN === '1';
+
+  if (dryRun) {
+    console.log('[dry-run] mixdog install preview — no files, prompts, or installs');
+  }
+
+  await ensureClaudeInstalled(dryRun);
+  registerPluginInSettings(dryRun);
 
   // npx / node setup/install.mjs runs outside Claude Code — config.mjs needs a data dir.
   const pluginData = process.env.CLAUDE_PLUGIN_DATA;
-  if (!pluginData || !String(pluginData).trim()) {
+  const dataDir =
+    pluginData && String(pluginData).trim() ? String(pluginData).trim() : defaultPluginDataDir();
+  if (!dryRun && (!pluginData || !String(pluginData).trim())) {
     process.env.CLAUDE_PLUGIN_DATA = defaultPluginDataDir();
   }
 
-  const { runSetupWizard } = await import('./wizard.mjs');
-  await runSetupWizard();
+  if (dryRun) {
+    logDryRunWizard();
+  } else {
+    const { runSetupWizard } = await import('./wizard.mjs');
+    await runSetupWizard();
+  }
 
-  maybeStarNudge();
+  await prewarmRuntimeDepsBestEffort(dryRun, dataDir);
+
+  if (!dryRun) maybeStarNudge();
+}
+
+async function prewarmRuntimeDepsBestEffort(dryRun = false, dataDirOverride = null) {
+  const dataDir = dataDirOverride || process.env.CLAUDE_PLUGIN_DATA || defaultPluginDataDir();
+  if (dryRun) {
+    console.log(
+      `[dry-run] would prewarm runtime deps (bun install into ${join(dataDir, '.deps')})`,
+    );
+    return;
+  }
+
+  const spinner = createSpinner('Installing runtime dependencies…');
+  try {
+    const pluginRoot = join(dirname(fileURLToPath(import.meta.url)), '..');
+    mkdirSync(dataDir, { recursive: true });
+
+    const { resolveBun, installBunViaNpm } = await import('../scripts/resolve-bun.mjs');
+    const { ensureRuntimeDeps, resolveNmWithRequiredDeps } = await import('../scripts/ensure-deps.mjs');
+
+    let bunPath = resolveBun(pluginRoot);
+    if (!bunPath) {
+      installBunViaNpm(pluginRoot, { fatal: false });
+      bunPath = resolveBun(pluginRoot);
+    }
+    if (!bunPath) {
+      spinner.stop('bun unavailable — will install on first launch', false);
+      return;
+    }
+    const seedNm = resolveNmWithRequiredDeps(pluginRoot) || undefined;
+
+    const result = ensureRuntimeDeps({
+      dataDir,
+      pluginRoot,
+      bunPath,
+      seedNm,
+      logPrefix: '[setup]',
+      installStdio: 'pipe',
+    });
+    if (result?.satisfied) {
+      spinner.stop('prewarmed (first launch should skip bun install)', true);
+    } else {
+      spinner.stop(`will install on first launch (${result?.reason || 'prewarm did not complete'})`, false);
+    }
+  } catch (err) {
+    spinner.stop(
+      `prewarm skipped — ${err?.message || 'first MCP launch may run bun install'}`,
+      false,
+    );
+  }
 }
 
 // Non-blocking, opt-in star nudge. Only on a real interactive terminal — never

package/setup/locate-claude.mjs

@@ -0,0 +1,38 @@
+// locate-claude.mjs — shared PATH scan for the Claude Code CLI executable.
+
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function resolveClaudeExecutable() {
+  const win32 = process.platform === 'win32';
+  try {
+    const cmd = win32 ? 'where' : 'which';
+    const out = execFileSync(cmd, ['claude'], { encoding: 'utf8', windowsHide: true }).trim();
+    const first = out.split(/\r?\n/).map((l) => l.trim()).find(Boolean);
+    if (first && existsSync(first)) return first;
+  } catch { /* PATH scan */ }
+
+  const pathSep = win32 ? ';' : ':';
+  const dirs = String(process.env.PATH || '').split(pathSep).filter(Boolean);
+  const pathext = win32
+    ? String(process.env.PATHEXT || '.EXE;.CMD;.BAT').split(';').map((e) => e.toLowerCase())
+    : [''];
+  const bases = win32 ? ['claude'] : ['claude'];
+  for (const dir of dirs) {
+    for (const base of bases) {
+      if (win32) {
+        for (const ext of pathext) {
+          const candidate = join(dir, base + ext);
+          if (existsSync(candidate)) return candidate;
+        }
+        const bare = join(dir, base);
+        if (existsSync(bare)) return bare;
+      } else {
+        const candidate = join(dir, base);
+        if (existsSync(candidate)) return candidate;
+      }
+    }
+  }
+  return null;
+}

package/setup/mixdog-cli.mjs

@@ -1,63 +1,27 @@
 #!/usr/bin/env node
 // mixdog-cli.mjs — `mixdog` bin dispatcher: launch Claude Code with the dev
-// plugin load flags, or run setup/install on demand.
+// plugin load flags for other args; no args or `install` → runInstall().
 
-import { spawn, execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
+import { spawn } from 'node:child_process';
 import { realpathSync } from 'node:fs';
 import { constants as osConstants } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { DEFAULT_MARKETPLACE, DEFAULT_PLUGIN } from '../src/shared/plugin-paths.mjs';
 import { runInstall } from './install.mjs';
+import { resolveClaudeExecutable } from './locate-claude.mjs';
+
+export { resolveClaudeExecutable } from './locate-claude.mjs';
 
 const PLUGIN_LOAD_ARG = `plugin:${DEFAULT_PLUGIN}@${DEFAULT_MARKETPLACE}`;
 const CLAUDE_PREFIX = ['--dangerously-load-development-channels', PLUGIN_LOAD_ARG];
 
-function isSetupCommand(first) {
-  return first === 'setup' || first === 'install';
-}
-
 export function buildClaudeLaunchArgv(passthrough = []) {
   return [...CLAUDE_PREFIX, ...passthrough];
 }
 
-export function resolveClaudeExecutable() {
-  const win32 = process.platform === 'win32';
-  try {
-    const cmd = win32 ? 'where' : 'which';
-    const out = execFileSync(cmd, ['claude'], { encoding: 'utf8', windowsHide: true }).trim();
-    const first = out.split(/\r?\n/).map((l) => l.trim()).find(Boolean);
-    if (first && existsSync(first)) return first;
-  } catch { /* PATH scan */ }
-
-  const pathSep = win32 ? ';' : ':';
-  const dirs = String(process.env.PATH || '').split(pathSep).filter(Boolean);
-  const pathext = win32
-    ? String(process.env.PATHEXT || '.EXE;.CMD;.BAT').split(';').map((e) => e.toLowerCase())
-    : [''];
-  const bases = win32 ? ['claude'] : ['claude'];
-  for (const dir of dirs) {
-    for (const base of bases) {
-      if (win32) {
-        for (const ext of pathext) {
-          const candidate = join(dir, base + ext);
-          if (existsSync(candidate)) return candidate;
-        }
-        const bare = join(dir, base);
-        if (existsSync(bare)) return bare;
-      } else {
-        const candidate = join(dir, base);
-        if (existsSync(candidate)) return candidate;
-      }
-    }
-  }
-  return null;
-}
-
 export async function dispatchMixdogCli(argv = process.argv.slice(2)) {
   const [first] = argv;
-  if (isSetupCommand(first)) {
+  if (argv.length === 0 || first === 'install') {
     if (process.env.MIXDOG_CLI_DRY_RUN === '1') {
       process.stdout.write('mixdog-cli: route=setup\n');
       return 0;

package/setup/setup-server.mjs

@@ -7,8 +7,8 @@ import { fileURLToPath } from 'url';
 import http from 'http';
 import https from 'https';
 import { DEFAULT_MAINTENANCE, MAINTENANCE_SLOTS, DEFAULT_PRESETS, getPluginData } from '../src/agent/orchestrator/config.mjs';
-import { getOpenAIOAuthModelCatalogError, hasOpenAIOAuthCredentials } from '../src/agent/orchestrator/providers/openai-oauth.mjs';
-import { hasAnthropicOAuthCredentials } from '../src/agent/orchestrator/providers/anthropic-oauth.mjs';
+import { getOpenAIOAuthModelCatalogError, hasOpenAIOAuthCredentials, loginOAuth as loginOpenAIOAuth } from '../src/agent/orchestrator/providers/openai-oauth.mjs';
+import { hasAnthropicOAuthCredentials, loginOAuth as loginAnthropicOAuth } from '../src/agent/orchestrator/providers/anthropic-oauth.mjs';
 import { hasGrokOAuthCredentials, loginOAuth as loginGrokOAuth } from '../src/agent/orchestrator/providers/grok-oauth.mjs';
 import { resolvePluginData } from '../src/shared/plugin-paths.mjs';
 import { listSchedules } from '../src/shared/schedules-store.mjs';
@@ -2135,6 +2135,54 @@ async function handleRequest(req, res) {
     return;
   }
 
+  if (req.method === 'POST' && path === '/agent/openai-oauth/login') {
+    if (!isAllowedOrigin(req)) {
+      res.writeHead(403, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: false, error: 'forbidden: cross-origin' }));
+      return;
+    }
+    try {
+      const tokens = await loginOpenAIOAuth();
+      if (!tokens?.access_token) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'login cancelled or timed out' }));
+        return;
+      }
+      dropRuntimeModelCaches();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true }));
+    } catch (e) {
+      process.stderr.write('[setup] /agent/openai-oauth/login failed: ' + (e?.stack || e?.message || String(e)) + '\n');
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: false, error: e?.message || String(e) }));
+    }
+    return;
+  }
+
+  if (req.method === 'POST' && path === '/agent/anthropic-oauth/login') {
+    if (!isAllowedOrigin(req)) {
+      res.writeHead(403, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: false, error: 'forbidden: cross-origin' }));
+      return;
+    }
+    try {
+      const tokens = await loginAnthropicOAuth();
+      if (!tokens?.accessToken) {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ ok: false, error: 'login cancelled or timed out' }));
+        return;
+      }
+      dropRuntimeModelCaches();
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true }));
+    } catch (e) {
+      process.stderr.write('[setup] /agent/anthropic-oauth/login failed: ' + (e?.stack || e?.message || String(e)) + '\n');
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: false, error: e?.message || String(e) }));
+    }
+    return;
+  }
+
   if (req.method === 'GET' && path === '/agent/presets') {
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(JSON.stringify({ presets: readAgentPresets() }));