mixdog 0.7.1

package/setup/launch-core.mjs

@@ -0,0 +1,507 @@
+// launch-core.mjs — importable config-UI launch core.
+//
+// Extracted from launch.mjs so the same alive-probe → stale-server
+// detection → spawn → requestOpen sequence can run BOTH from the CLI
+// shim (launch.mjs, which keeps the Windows console-hide / self-respawn
+// mitigations for direct `bun launch.mjs` invocation) AND from inside the
+// resident MCP server (the `open_config` tool). When the MCP server — a
+// long-lived background process — spawns setup-server with windowsHide:true,
+// no console window is created at all, so the conhost flash the CLI path
+// fights with FFI/wscript shims simply never happens.
+//
+// Import-safe: no top-level side effects, no env mutation at module load.
+// All paths/ports are module constants; per-call state (plugin root/data)
+// is derived inside launchConfigUi().
+
+import { spawn, execSync } from 'child_process';
+import { openSync, closeSync, readFileSync, writeSync, writeFileSync, appendFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import http from 'http';
+import net from 'net';
+import { tmpdir } from 'os';
+import { resolvePluginData } from '../src/shared/plugin-paths.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const server = join(__dirname, 'setup-server.mjs');
+// Reuse the launcher's own runtime (bun.exe from the CLI shebang, or the
+// bun that runs the MCP server). Spawning setup-server by absolute path lets
+// us drop shell:true on Windows; the cmd.exe wrapper was swallowing the
+// child's stderr and turning real bun startup errors into an empty log.
+const CHILD_INTERPRETER = process.execPath;
+export const PORT = 3458;
+export const CONFIG_UI_URL = `http://localhost:${PORT}`;
+
+function ping(timeoutMs = 1500) {
+  return new Promise(resolve => {
+    // setup-server listens on 127.0.0.1 only. agent:false disables Node's
+    // default keepAlive socket pool; Connection: close prevents any keepalive
+    // negotiation that could leave half-open sockets between probes.
+    const req = http.get({
+      host: '127.0.0.1', port: PORT, path: '/',
+      agent: false, headers: { Connection: 'close' },
+    }, res => { res.resume(); resolve(true); });
+    req.on('error', () => resolve(false));
+    req.setTimeout(timeoutMs, () => { req.destroy(); resolve(false); });
+  });
+}
+
+// TCP-level liveness probe used as a fallback when HTTP ping times out but
+// the server is actually accepting connections. Distinguishes "server is
+// listening but its handler is momentarily slow" from "server is dead" so
+// the launcher doesn't false-trigger spawnServerWithLog and crash on the
+// port collision.
+function tcpOpen(timeoutMs = 300) {
+  return new Promise(resolve => {
+    const s = net.connect({ host: '127.0.0.1', port: PORT });
+    s.setTimeout(timeoutMs);
+    s.once('connect', () => { s.destroy(); resolve(true); });
+    s.once('timeout', () => { s.destroy(); resolve(false); });
+    s.once('error', () => resolve(false));
+  });
+}
+
+// GET /api/plugin-path. Returns the absolute plugin root the running
+// setup-server identifies as, or null on any failure. Used to detect a
+// stale or wrong-plugin server still bound to PORT before we hand it the
+// /open call — otherwise a different version's setup window can pop up.
+function fetchPluginPath(timeoutMs = 1500) {
+  return new Promise(resolve => {
+    const req = http.get(`http://127.0.0.1:${PORT}/api/plugin-path`, res => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(body);
+          resolve(typeof json?.path === 'string' ? json.path : null);
+        } catch {
+          resolve(null);
+        }
+      });
+    });
+    req.on('error', () => resolve(null));
+    req.setTimeout(timeoutMs, () => { req.destroy(); resolve(null); });
+  });
+}
+
+// Watchdog disabled — returning 0 keeps setup-server alive after the MCP
+// host exits (until the user closes the chrome window). The previous
+// execSync('powershell …') ancestor walk was a major conhost-flash source
+// on every /mixdog:config invocation; removing it eliminated that flash.
+function findAncestorPid() {
+  return 0;
+}
+
+function requestOpen() {
+  return new Promise(resolve => {
+    const req = http.get(`http://127.0.0.1:${PORT}/open`, res => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', chunk => { body += chunk; });
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(body);
+          resolve(json.ok === true);
+        } catch {
+          resolve(res.statusCode >= 200 && res.statusCode < 300);
+        }
+      });
+    });
+    req.on('error', () => resolve(false));
+    // /open now holds the in-process open mutex until the spawned browser is
+    // discoverable or its wscript launcher's bounded focus loop (~6s) exits,
+    // so the response can legitimately take several seconds. Allow headroom
+    // above that bound so a slow-but-successful open is not reported as a
+    // failure (which would throw a spurious LaunchError).
+    req.setTimeout(12000, () => { req.destroy(); resolve(false); });
+  });
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function waitForServer(timeoutMs = 4000, shouldStop = () => false) {
+  const deadline = Date.now() + timeoutMs;
+  let ready = false;
+  while (Date.now() < deadline) {
+    ready = await ping(500);
+    if (ready) break;
+    if (shouldStop()) break;
+    await sleep(250);
+  }
+  return ready && !shouldStop();
+}
+
+function openLaunchLog() {
+  const path = join(tmpdir(), `mixdog-setup-launch-${process.pid}.log`);
+  const fd = openSync(path, 'a');
+  writeSync(fd, [
+    '',
+    `[${new Date().toISOString()}] setup-server launch`,
+    `launcherPid=${process.pid}`,
+    `execPath=${process.execPath}`,
+    `interpreter=${CHILD_INTERPRETER}`,
+    `server=${server}`,
+    `cwd=${dirname(__dirname)}`,
+    '--- child stdout/stderr ---',
+  ].join('\n') + '\n');
+  return { path, fd };
+}
+
+function writeLog(fd, message) {
+  try {
+    if (typeof fd === 'number') writeSync(fd, message);
+  } catch {}
+}
+
+function closeLog(fd) {
+  try {
+    if (typeof fd === 'number') closeSync(fd);
+  } catch {}
+}
+
+function readLog(path) {
+  try { return readFileSync(path, 'utf8').trim(); } catch { return ''; }
+}
+
+// In the importable core a launch failure THROWS (with the same diagnostic
+// text the CLI used to print to stderr). The CLI shim catches and converts
+// it back to a stderr write + process.exit(1); the MCP tool surfaces it as
+// an error result.
+class LaunchError extends Error {}
+
+function cmdSetLine(name, value) {
+  return `set "${name}=${String(value ?? '').replace(/"/g, '')}"`;
+}
+
+function cmdQuote(value) {
+  return `"${String(value).replace(/"/g, '""')}"`;
+}
+
+function spawnWscriptHidden(vbsPath) {
+  return new Promise(resolve => {
+    let child;
+    try {
+      child = spawn('wscript.exe', ['//B', '//NoLogo', vbsPath], {
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+    } catch (error) {
+      resolve({ ok: false, error: error?.message || String(error) });
+      return;
+    }
+    child.once('error', error => resolve({ ok: false, error: error?.message || String(error) }));
+    child.once('exit', code => resolve({ ok: code === 0, code }));
+  });
+}
+
+// Spawn setup-server with a launch log, wait for readiness, and throw a
+// LaunchError on failure. Shared by the cold-start (!alive) path and the
+// stale-server takeover path so both use one implementation.
+async function spawnServerWithLog(pluginRoot, pluginData, { openOnStart = true } = {}) {
+  const launchLog = openLaunchLog();
+  let spawnError = null;
+  let childExit = null;
+  let child;
+
+  if (process.platform === 'win32') {
+    closeLog(launchLog.fd);
+    const stamp = `${process.pid}-${Date.now()}`;
+    const cmdPath = join(tmpdir(), `mixdog-setup-server-${stamp}.cmd`);
+    const vbsPath = join(tmpdir(), `mixdog-setup-server-${stamp}.vbs`);
+    const batchLines = [
+      '@echo off',
+      'setlocal',
+      cmdSetLine('CLAUDE_PLUGIN_ROOT', pluginRoot),
+      cmdSetLine('CLAUDE_PLUGIN_DATA', pluginData),
+      cmdSetLine('MIXDOG_SETUP_OPEN_ON_START', openOnStart ? '1' : '0'),
+      cmdSetLine('MIXDOG_SETUP_PARENT_PID', String(findAncestorPid() || '')),
+      process.env.USERPROFILE ? cmdSetLine('USERPROFILE', process.env.USERPROFILE) : '',
+      process.env.APPDATA ? cmdSetLine('APPDATA', process.env.APPDATA) : '',
+      process.env.LOCALAPPDATA ? cmdSetLine('LOCALAPPDATA', process.env.LOCALAPPDATA) : '',
+      process.env.PATH ? cmdSetLine('PATH', process.env.PATH) : '',
+      `cd /d ${cmdQuote(pluginRoot)}`,
+      `echo [${new Date().toISOString()}] hidden setup-server cmd start>>${cmdQuote(launchLog.path)}`,
+      `${cmdQuote(CHILD_INTERPRETER)} ${cmdQuote(server)}>>${cmdQuote(launchLog.path)} 2>&1`,
+      'set "mixdogExit=%ERRORLEVEL%"',
+      'del "%~f0" >NUL 2>&1',
+      'exit /b %mixdogExit%',
+    ].filter(Boolean);
+    writeFileSync(cmdPath, batchLines.join('\r\n'), 'utf8');
+
+    const escVbs = s => String(s).replace(/"/g, '""');
+    const cmdLine = `cmd.exe /d /c ""${cmdPath}""`;
+    const vbsLines = [
+      'Option Explicit',
+      'Const HIDDEN_WINDOW = 0',
+      'Dim Wmi, Startup, cmdLine, cwd, pid, rc',
+      'Set Wmi = GetObject("winmgmts:{impersonationLevel=impersonate}!\\\\.\\root\\cimv2")',
+      'Set Startup = Wmi.Get("Win32_ProcessStartup").SpawnInstance_',
+      'Startup.ShowWindow = HIDDEN_WINDOW',
+      `cmdLine = "${escVbs(cmdLine)}"`,
+      `cwd = "${escVbs(pluginRoot)}"`,
+      'rc = Wmi.Get("Win32_Process").Create(cmdLine, cwd, Startup, pid)',
+      'If rc <> 0 Then WScript.Quit rc',
+    ];
+    writeFileSync(vbsPath, vbsLines.join('\r\n'), 'utf8');
+
+    const launched = await spawnWscriptHidden(vbsPath);
+    if (!launched.ok) {
+      throw new LaunchError(
+        `Failed to spawn hidden setup-server for ${CONFIG_UI_URL}\n` +
+        `Launch log: ${launchLog.path}\n` +
+        `wscript result: ${launched.error || `exit ${launched.code}`}\n`,
+      );
+    }
+    if (!await waitForServer(15000)) {
+      const captured = readLog(launchLog.path);
+      throw new LaunchError(
+        `setup-server did not become ready at ${CONFIG_UI_URL}/ within 15000ms (hidden WMI launch).\n` +
+        `Launch log: ${launchLog.path}\n` +
+        (captured ? `--- setup-server launch log ---\n${captured}\n--- end setup-server launch log ---\n` : 'No setup-server output was captured.\n'),
+      );
+    }
+    return;
+  }
+
+  try {
+    child = spawn(CHILD_INTERPRETER, [server], {
+      detached: true,
+      // Console-less parents (hidden wscript/PowerShell chain) would
+      // otherwise hand the detached console child a fresh visible window.
+      windowsHide: true,
+      // Use a real file descriptor, not parent pipes/stdio. This keeps the
+      // detached child independent after unref() while preserving first-start
+      // stdout/stderr for diagnostics. shell:false (default) on every
+      // platform — cmd.exe wrapping was eating the child's stderr.
+      stdio: ['ignore', launchLog.fd, launchLog.fd],
+      cwd: pluginRoot,
+      env: {
+        ...process.env,
+        CLAUDE_PLUGIN_ROOT: pluginRoot,
+        CLAUDE_PLUGIN_DATA: pluginData,
+        MIXDOG_SETUP_OPEN_ON_START: openOnStart ? '1' : '0',
+        MIXDOG_SETUP_PARENT_PID: String(findAncestorPid() || ''),
+      },
+      windowsHide: true,
+    });
+  } catch (error) {
+    closeLog(launchLog.fd);
+    throw new LaunchError(
+      `Failed to spawn setup-server for ${CONFIG_UI_URL}\n` +
+      `Launch log: ${launchLog.path}\n` +
+      `${error?.stack || error?.message || String(error)}\n`,
+    );
+  }
+
+  child.once('error', error => {
+    spawnError = error;
+    writeLog(launchLog.fd, `\n[${new Date().toISOString()}] child error: ${error?.stack || error?.message || String(error)}\n`);
+  });
+  child.once('exit', (code, signal) => {
+    childExit = { code, signal };
+    writeLog(launchLog.fd, `\n[${new Date().toISOString()}] child exit: code=${code} signal=${signal}\n`);
+  });
+  child.unref();
+
+  if (!await waitForServer(15000, () => Boolean(spawnError || childExit))) {
+    closeLog(launchLog.fd);
+    const captured = readLog(launchLog.path);
+    const status = spawnError
+      ? `spawn error: ${spawnError?.stack || spawnError?.message || String(spawnError)}`
+      : childExit
+        ? `child exit: code=${childExit.code} signal=${childExit.signal}`
+        : 'child did not report an error or exit before readiness timeout';
+    throw new LaunchError(
+      `setup-server did not become ready at ${CONFIG_UI_URL}/ within 15000ms (${status}).\n` +
+      `Launch log: ${launchLog.path}\n` +
+      (captured ? `--- setup-server launch log ---\n${captured}\n--- end setup-server launch log ---\n` : 'No setup-server output was captured.\n'),
+    );
+  }
+
+  closeLog(launchLog.fd);
+}
+
+// Probe for an already-running setup-server. A live server answers the HTTP
+// ping immediately; if its event loop is momentarily blocked inside a sync
+// spawn (chrome /open path), the kernel still completes the TCP accept, so the
+// tcpOpen fallback detects it. A short window therefore suffices.
+function probeOnce() {
+  return new Promise(resolve => {
+    const req = http.get({
+      host: '127.0.0.1', port: PORT, path: '/',
+      agent: false, headers: { Connection: 'close' },
+    }, res => { res.resume(); resolve('up'); });
+    req.on('error', e => resolve(e?.code === 'ECONNREFUSED' ? 'refused' : 'timeout'));
+    req.setTimeout(800, () => { req.destroy(); resolve('timeout'); });
+  });
+}
+
+async function aliveProbe() {
+  const deadline = Date.now() + 1500;
+  while (Date.now() < deadline) {
+    const state = await probeOnce();
+    if (state === 'up') return true;
+    if (state === 'refused') return false;
+    await sleep(150);
+  }
+  return false;
+}
+
+// Resolve / start the resident setup-server and open (or re-open) the config
+// UI window, returning the UI URL on success. Throws LaunchError with a
+// diagnostic message on failure.
+//
+// Options:
+//   pluginRoot — override the plugin root (defaults to CLAUDE_PLUGIN_ROOT or
+//                the directory above setup/).
+//   trace      — optional (msg:string)=>void hook for diagnostics; defaults
+//                to a tmp trace-log writer (matches the CLI's behaviour).
+//   prewarm    — when true, only ensure the server is alive (spawned
+//                window-free, MIXDOG_SETUP_OPEN_ON_START unset). Never opens
+//                or re-focuses a window; a no-op when the server already runs.
+export async function launchConfigUi(options = {}) {
+  const pluginRoot = options.pluginRoot || process.env.CLAUDE_PLUGIN_ROOT || dirname(__dirname);
+  const prewarm = options.prewarm === true;
+  // Slash-command shells expand ${CLAUDE_PLUGIN_ROOT} into argv but do not
+  // export it, so the spawned setup-server inherits a stripped env. Re-derive
+  // both ROOT and DATA so plugin-paths and the stricter channels-lib guard
+  // (which checks CLAUDE_PLUGIN_DATA directly) both succeed in the child.
+  process.env.CLAUDE_PLUGIN_ROOT = pluginRoot;
+  const pluginData = process.env.CLAUDE_PLUGIN_DATA || resolvePluginData();
+  process.env.CLAUDE_PLUGIN_DATA = pluginData;
+
+  const traceFn = typeof options.trace === 'function'
+    ? options.trace
+    : (() => {
+        const traceLogPath = join(tmpdir(), `mixdog-launch-trace-${process.pid}.log`);
+        return msg => {
+          try { appendFileSync(traceLogPath, `[${new Date().toISOString()}] ${msg}\n`); } catch {}
+        };
+      })();
+  const __trace = msg => { try { traceFn(msg); } catch {} };
+  __trace(`launchConfigUi entry parentPid=${process.ppid} pluginRoot=${pluginRoot}`);
+
+  const alive = await aliveProbe();
+  __trace(`aliveProbe result alive=${alive}`);
+
+  // Pre-warm mode: ensure the server is booted window-free, then return.
+  // Already alive → cheap no-op (no requestOpen, no window). Not alive →
+  // spawn with openOnStart:false so setup-server boots without opening a
+  // browser window. No stale-server takeover: pre-warm is best-effort and
+  // must never kill another install's server.
+  if (prewarm) {
+    if (alive) {
+      __trace(`prewarm: server already alive → no-op`);
+      return CONFIG_UI_URL;
+    }
+    __trace(`prewarm: !alive → spawnServerWithLog (window-free)`);
+    await spawnServerWithLog(pluginRoot, pluginData, { openOnStart: false });
+    __trace(`prewarm: spawnServerWithLog completed`);
+    return CONFIG_UI_URL;
+  }
+
+  if (!alive) {
+    // Boot window-free; the unconditional requestOpen below owns opening the
+    // window. Spawning with openOnStart:1 here would double-open and races a
+    // concurrent every-session prewarm that may bind the port first (in which
+    // case our own openOnStart child never gets to open anything).
+    __trace(`branch: !alive → spawnServerWithLog (window-free)`);
+    await spawnServerWithLog(pluginRoot, pluginData, { openOnStart: false });
+    __trace(`spawnServerWithLog completed`);
+  }
+
+  // Confirm the live server belongs to THIS plugin install before reusing it
+  // (a stale or different-version setup-server would otherwise own the
+  // window). After a !alive spawn above this simply re-confirms our own server.
+  const remoteRoot = await fetchPluginPath();
+  __trace(`fetchPluginPath returned remoteRoot=${remoteRoot}`);
+  if (remoteRoot) {
+    // Normalize: trailing slash strip + backslash → forward slash + lowercase
+    // so `C:/x` and `C:\x` compare equal (lowercase only on Windows).
+    const normalize = p => { const s = p.replace(/[\\/]+$/, '').replace(/\\/g, '/'); return process.platform === 'win32' ? s.toLowerCase() : s; };
+    const expected = normalize(pluginRoot);
+    const actual = normalize(remoteRoot);
+    __trace(`compare expected=${expected} actual=${actual} mismatch=${expected !== actual}`);
+    if (expected !== actual) {
+      // Invariant: single live plugin install owns PORT. The occupying server
+      // belongs to a different install — resolve its PID, terminate it, poll
+      // until the port is free, then take ownership via spawnServerWithLog().
+      let stalePid = null;
+      let pidResolveError = null;
+      let killError = null;
+      try {
+        if (process.platform === 'win32') {
+          const out = execSync(
+            `powershell -NoProfile -Command "(Get-NetTCPConnection -LocalPort ${PORT} -ErrorAction SilentlyContinue | Select-Object -First 1).OwningProcess"`,
+            { encoding: 'utf8', timeout: 3000, windowsHide: true },
+          ).trim();
+          const n = parseInt(out, 10);
+          if (Number.isFinite(n) && n > 0) stalePid = n;
+        } else {
+          const out = execSync(`lsof -ti :${PORT}`, { encoding: 'utf8', timeout: 3000 }).trim();
+          const n = parseInt(out.split('\n')[0], 10);
+          if (Number.isFinite(n) && n > 0) stalePid = n;
+        }
+      } catch (e) { pidResolveError = e; }
+      if (stalePid !== null) {
+        try {
+          if (process.platform === 'win32') {
+            // /T kills the whole process tree — the setup-server spawns child
+            // browser/server descendants that survive a PID-only Stop-Process,
+            // leaking processes and holding the port.
+            execSync(`taskkill /T /F /PID ${stalePid}`, { timeout: 3000, windowsHide: true });
+          } else {
+            // setup-server is launched detached (its own process-group leader),
+            // so the port-owning PID equals the group id. Negative PID signals
+            // the whole group, reaping descendants a bare kill would orphan.
+            try { execSync(`kill -KILL -${stalePid}`, { timeout: 3000 }); }
+            catch { execSync(`kill -KILL ${stalePid}`, { timeout: 3000 }); }
+          }
+        } catch (e) { killError = e; }
+      }
+      // Poll until port is free (250ms ticks, 3000ms deadline).
+      const killDeadline = Date.now() + 3000;
+      let portFree = false;
+      while (Date.now() < killDeadline) {
+        await sleep(250);
+        portFree = !(await ping(300));
+        if (portFree) break;
+      }
+      if (!portFree) {
+        const errorDetails = [
+          pidResolveError && `  PID resolution failure: ${pidResolveError?.message || String(pidResolveError)}`,
+          killError && `  kill failure: ${killError?.message || String(killError)}`,
+        ].filter(Boolean).join('\n');
+        throw new LaunchError(
+          `Port ${PORT} is in use by a different mixdog plugin instance and could not be reclaimed (kill of PID ${stalePid ?? 'unknown'} failed or timed out).\n` +
+          `  expected plugin root: ${pluginRoot}\n` +
+          `  actual plugin root:   ${remoteRoot}\n` +
+          (errorDetails ? errorDetails + '\n' : '') +
+          `Stop the other setup-server (or change PORT) and retry.\n`,
+        );
+      }
+      __trace(`takeover: killed stalePid=${stalePid}, port freed, spawning new server`);
+      await spawnServerWithLog(pluginRoot, pluginData, { openOnStart: false });
+      __trace(`takeover: spawnServerWithLog completed`);
+    }
+  }
+  // Invariant: a non-prewarm launch ALWAYS opens the window through the
+  // idempotent /open endpoint once the server is ready — regardless of which
+  // process (this launcher, a concurrent every-session prewarm, or a
+  // pre-existing server) actually booted it. Relying on the spawned child's
+  // MIXDOG_SETUP_OPEN_ON_START would silently no-op whenever a window-free
+  // prewarm server bound the port first.
+  __trace(`branch: requestOpen`);
+  const opened = await requestOpen();
+  __trace(`requestOpen returned ${opened}`);
+  if (!opened) {
+    throw new LaunchError(`Failed to open config UI window for ${CONFIG_UI_URL}\n`);
+  }
+  __trace(`launchConfigUi success`);
+  return CONFIG_UI_URL;
+}
+
+export { LaunchError, tcpOpen };

package/setup/launch.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env bun
+// launch.mjs — CLI shim for the config-UI launcher.
+//
+// The launch SEQUENCE (alive probe → stale-server detection → spawn →
+// requestOpen) now lives in launch-core.mjs so the resident MCP server can
+// import and run it window-free via the `open_config` tool. This file keeps
+// only the bits that exist BECAUSE the CLI is invoked through a
+// console-subsystem bun.exe: the FFI console-hide and the hidden-wscript
+// self-respawn. Both collapse the conhost flash that the slash command's
+// shell-out produces. Neither is needed (or wanted) inside the MCP server,
+// which spawns setup-server with windowsHide:true and never flashes at all.
+import { spawn } from 'child_process';
+import { writeFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { tmpdir } from 'os';
+
+// Hide our own console window as the very first thing on Windows. Claude Code
+// runs this script via a console-subsystem bun.exe, which flashes an empty
+// terminal for ~0.5s before the self-respawn below hands off to a hidden
+// child. Hiding the console here collapses that flash to bun's startup time.
+// SAFETY GUARD: only hide when this console belongs to us ALONE.
+// GetConsoleProcessList returning a single PID equal to ours means a dedicated
+// console (the flash case). A shared console — Claude Code's own terminal with
+// our stdio piped into it — reports the host process too; hiding that would
+// make the user's working terminal vanish, so we must never touch it. stdout
+// capture is unaffected (Claude Code reads the pipe, not the window).
+if (process.platform === 'win32') {
+  try {
+    const { dlopen, FFIType, ptr } = await import('bun:ffi');
+    const k32 = dlopen('kernel32.dll', {
+      GetConsoleWindow: { args: [], returns: FFIType.ptr },
+      GetConsoleProcessList: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.u32 },
+    });
+    const u32 = dlopen('user32.dll', {
+      ShowWindow: { args: [FFIType.ptr, FFIType.i32], returns: FFIType.i32 },
+    });
+    const hwnd = k32.symbols.GetConsoleWindow();
+    if (hwnd) {
+      const list = new Uint32Array(16);
+      const count = k32.symbols.GetConsoleProcessList(ptr(list), list.length);
+      if (count === 1 && list[0] === process.pid) {
+        u32.symbols.ShowWindow(hwnd, 0); // SW_HIDE
+      }
+    }
+  } catch { /* FFI unavailable/failed — leave the console alone; at worst the brief flash remains */ }
+}
+
+// Windows self-respawn under hidden wscript. Without this, the bun console
+// flashes briefly between the slash command's shell-out and the detached
+// setup-server spawn (two flashes total). Self-respawn shrinks it to one
+// flash: parent exits immediately, hidden child re-runs this script with
+// stdio detached so setup-server boot work happens entirely off-screen. The
+// --hidden argv flag prevents recursion.
+if (process.platform === 'win32' && !process.argv.includes('--hidden')) {
+  // wscript.exe is a GUI host (no console of its own), so spawning it does
+  // not flash a conhost window. Use Shell.Application.ShellExecute (NOT
+  // WScript.Shell.Run — Wsh.Run silently no-ops when launching bun.exe with
+  // an embedded-quote command line; ShellExecute keeps app and args as
+  // separate parameters) with show=0 (SW_HIDE) for the hidden child bun.
+  const __scriptPath = fileURLToPath(import.meta.url);
+  const __bunExe = process.execPath;
+  const __escVbs = s => String(s).replace(/"/g, '""');
+  // Forward --prewarm into the hidden child so the re-run boots the server
+  // window-free instead of opening the config window.
+  const __prewarmArg = process.argv.includes('--prewarm') ? ' --prewarm' : '';
+  const __argsStr = `"${__scriptPath}" --hidden${__prewarmArg}`;
+  const __vbsLines = [
+    'Set Shell = CreateObject("Shell.Application")',
+    `Shell.ShellExecute "${__escVbs(__bunExe)}", "${__escVbs(__argsStr)}", "", "open", 0`,
+  ];
+  const __vbsPath = join(tmpdir(), `mixdog-launch-respawn-${process.pid}-${Date.now()}.vbs`);
+  writeFileSync(__vbsPath, __vbsLines.join('\r\n'), 'utf8');
+  const __child = spawn('wscript.exe', ['//B', '//NoLogo', __vbsPath], {
+    stdio: 'ignore', windowsHide: true, detached: true,
+  });
+  __child.unref();
+  // Brief wait so wscript finishes parsing the .vbs and dispatches
+  // ShellExecute before this parent exits. Without it, parent termination
+  // races wscript startup and the hidden child never spawns.
+  await new Promise(resolve => setTimeout(resolve, 500));
+  process.stdout.write(`Config UI: http://localhost:3458\n`, () => process.exit(0));
+}
+
+// Delegate the actual launch sequence to the shared core. Reuse the trace-log
+// behaviour the inlined implementation had by letting launchConfigUi default
+// its own tmp trace writer. A LaunchError is converted back to the legacy
+// stderr-write + exit(1) contract the slash command relied on.
+const { launchConfigUi, LaunchError, CONFIG_UI_URL } = await import(
+  join(dirname(fileURLToPath(import.meta.url)), 'launch-core.mjs'),
+);
+
+try {
+  const prewarm = process.argv.includes('--prewarm');
+  const url = await launchConfigUi({ prewarm });
+  process.stdout.write(`Config UI: ${url}\n`, () => process.exit(0));
+} catch (err) {
+  const message = err instanceof LaunchError ? err.message : `${err?.stack || err?.message || String(err)}\n`;
+  await new Promise(resolve => process.stderr.write(message, resolve));
+  process.exit(1);
+}