@gakim-digital/dexter-bridge 0.5.20 → 0.11.0

package/src/cli.js

@@ -1,11 +1,14 @@
 import os from 'node:os';
+import path from 'node:path';
 import readline from 'node:readline/promises';
+import { spawn } from 'node:child_process';
 import {
   BRIDGE_BUILD_FINGERPRINT,
   BRIDGE_CAPABILITIES,
   BRIDGE_VERSION,
   clearConfig,
   defaultConfigDir,
+  normalizeBridgeProduct,
   normalizeAgentName,
   readConfig,
   resolveAgentName,
@@ -13,7 +16,7 @@ import {
   resolveCompanionModelName,
   saveConfigPatch,
 } from './config.js';
-import { checkAllAgents, executeRun } from './agent.js';
+import { checkAgentAvailability, checkAllAgents, executeRun } from './agent.js';
 import {
   claimPairing,
   DexterBridgeApiError,
@@ -26,22 +29,30 @@ import {
   logLocationHint,
 } from './logger.js';
 import { createLocalAgentAdapter } from './providers/index.js';
+import {
+  discoverRuntimeProfiles,
+  normalizeRuntimeSelection,
+  publicRuntimeProfile,
+  runtimeDriver,
+  runtimeProfileMap,
+} from './runtimeProfiles.js';
 
 function usage() {
   return [
-    'Dexter Bridge',
+    'Local Agent Bridge for Dexter and InstaWebAI',
     '',
     'Usage:',
-    '  dexter-bridge connect [code-or-token] [--agent claude-code|codex|dry-run] [--model <model>] [--once] [--api <url>]',
+    '  dexter-bridge connect [code-or-token] --runtime codex|claude-code|opencode [--once] [--api <url>]',
     '  dexter-bridge pair <code-or-token> [--api <url>]',
-    '  dexter-bridge start [--agent claude-code|codex|dry-run] [--model <model>] [--once] [--api <url>]',
-    '  dexter-bridge status [--api <url>]',
-    '  dexter-bridge doctor',
+    '  dexter-bridge start [--runtime codex|claude-code|opencode] [--once] [--api <url>]',
+    '  dexter-bridge status [--runtime codex|claude-code|opencode] [--api <url>]',
+    '  dexter-bridge doctor [--runtime codex|claude-code|opencode]',
     '  dexter-bridge logout',
     '',
     'Environment:',
     '  DEXTER_API_URL              API base URL, e.g. https://api.example.com/iwm-api/0.0.1',
-    '  DEXTER_BRIDGE_AGENT         claude-code, codex, or dry-run',
+    '  DEXTER_BRIDGE_RUNTIME       codex, claude-code, or opencode',
+    '  DEXTER_BRIDGE_AGENT         claude-code, codex, opencode, or dry-run',
     '  DEXTER_BRIDGE_MODEL         Companion model, e.g. claude-code:sonnet or codex:gpt-5.5',
     '  DEXTER_BRIDGE_CLAUDE_BIN    Claude CLI binary name/path',
     '  DEXTER_BRIDGE_CLAUDE_ARGS   Claude CLI args, default: -p',
@@ -51,6 +62,39 @@ function usage() {
   ].join('\n');
 }
 
+function requestedRuntime(flags = {}, config = {}, env = process.env) {
+  const raw = flags.runtime || env.DEXTER_BRIDGE_RUNTIME || config.runtimeSelection;
+  if (!raw) return null;
+  const runtime = normalizeRuntimeSelection(raw);
+  if (runtime) return runtime;
+  const error = new Error('Runtime must be codex, claude-code, or opencode.');
+  error.code = 'DEXTER_RUNTIME_INVALID';
+  error.exitCode = 2;
+  throw error;
+}
+
+function runtimeAgent(runtime) {
+  if (runtime === 'codex') return 'codex';
+  if (runtime === 'claude-code') return 'claude-code';
+  return 'dry-run';
+}
+
+function runtimeLabel(runtime) {
+  if (runtime === 'codex') return 'Codex';
+  if (runtime === 'claude-code') return 'Claude Code';
+  if (runtime === 'opencode') return 'OpenCode';
+  return 'Local agent';
+}
+
+function configDirForFlags(flags, env = process.env) {
+  if (flags['config-dir']) return flags['config-dir'];
+  if (env.DEXTER_BRIDGE_CONFIG_DIR) return defaultConfigDir(env);
+  const runtime = requestedRuntime(flags, {}, env);
+  return runtime
+    ? path.join(defaultConfigDir(env), 'app-builder', runtime)
+    : defaultConfigDir(env);
+}
+
 function parseArgv(argv) {
   const flags = {};
   const positional = [];
@@ -77,7 +121,10 @@ function parseArgv(argv) {
 
 function requireDeviceToken(config) {
   if (!config.deviceToken) {
-    const error = new Error('Dexter Bridge is not paired. Run `dexter-bridge pair <code>` from Dexter Settings.');
+    const product = normalizeBridgeProduct(config.product);
+    const error = new Error(
+      `${product.name} Bridge is not paired. Generate a new bridge command from ${product.name}.`,
+    );
     error.exitCode = 2;
     throw error;
   }
@@ -87,7 +134,7 @@ function requireDeviceToken(config) {
 async function promptForPairingCode() {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   try {
-    const answer = await rl.question('Paste the pairing code from the Dexter plugin and press Enter: ');
+    const answer = await rl.question('Paste the pairing code from the product connection screen and press Enter: ');
     return answer.trim();
   } catch {
     return '';
@@ -107,13 +154,56 @@ function pollBackoffMs(failureCount, baseMs = 1000, maxMs = 30000) {
   return Math.min(maximum, base * (2 ** Math.min(10, failures - 1)));
 }
 
+function startRunAwakeGuard({
+  platform = process.platform,
+  env = process.env,
+  spawnImpl = spawn,
+  pid = process.pid,
+} = {}) {
+  if (
+    platform !== 'darwin'
+    || ['0', 'false', 'no', 'off'].includes(
+      String(env.DEXTER_BRIDGE_PREVENT_IDLE_SLEEP || 'true').trim().toLowerCase(),
+    )
+  ) {
+    return null;
+  }
+  try {
+    const child = spawnImpl(
+      '/usr/bin/caffeinate',
+      ['-i', '-m', '-w', String(pid)],
+      {
+        stdio: 'ignore',
+        windowsHide: true,
+      },
+    );
+    child.once?.('error', () => undefined);
+    child.unref?.();
+    return {
+      close() {
+        if (child.killed) return;
+        try {
+          child.kill('SIGTERM');
+        } catch {
+          // The guard already exited with its parent process.
+        }
+      },
+    };
+  } catch {
+    return null;
+  }
+}
+
 async function executeClaimedRun({
   run,
   execute = executeRun,
   executeOptions,
   once = false,
   logger,
+  product,
+  preventIdleSleep = false,
 }) {
+  const awakeGuard = preventIdleSleep ? startRunAwakeGuard() : null;
   try {
     await execute(run, executeOptions);
     return true;
@@ -123,8 +213,11 @@ async function executeClaimedRun({
       error: errorMeta(error),
     });
     if (once) throw error;
-    console.error(`Dexter run ${run?.runId || 'unknown'} failed; continuing to poll.`);
+    const productName = normalizeBridgeProduct(product).name;
+    console.error(`${productName} run ${run?.runId || 'unknown'} failed; continuing to poll.`);
     return false;
+  } finally {
+    awakeGuard?.close();
   }
 }
 
@@ -142,13 +235,14 @@ function isInvalidPairingError(error) {
 }
 
 function clearInvalidPairing(configDir, cause) {
+  const product = normalizeBridgeProduct(readConfig(configDir).product);
   saveConfigPatch({
     deviceToken: null,
     device: null,
     pairedAt: null,
   }, configDir);
   const error = new Error(
-    'This Dexter Bridge pairing was disconnected. Reopen Dexter and run the new pairing command.',
+    `This ${product.name} Bridge pairing was disconnected. Reopen ${product.name} and run the new pairing command.`,
     { cause },
   );
   error.code = 'FRAMER_COMPANION_NOT_PAIRED';
@@ -170,15 +264,38 @@ function agentEnvironment(config = {}, baseEnv = process.env) {
   return env;
 }
 
-async function inspectAvailability(config = {}) {
+async function inspectAvailability(config = {}, runtimeSelection = null) {
   try {
-    const checks = await checkAllAgents({ env: agentEnvironment(config) });
-    const allChecks = [...checks.agents, checks.dryRun];
+    const bridgeEnv = agentEnvironment(config);
+    const checks =
+      runtimeSelection === 'codex' || runtimeSelection === 'claude-code'
+        ? {
+            agents: [
+              await checkAgentAvailability(runtimeSelection, undefined, {
+                env: bridgeEnv,
+              }),
+            ],
+            dryRun: null,
+          }
+        : runtimeSelection === 'opencode'
+          ? { agents: [], dryRun: null }
+          : await checkAllAgents({ env: bridgeEnv });
+    const allChecks = [...checks.agents, ...(checks.dryRun ? [checks.dryRun] : [])];
     const available = allChecks.filter((check) => check.ok);
+    const runtimeProfiles = await discoverRuntimeProfiles({
+      agentChecks: checks.agents,
+      config,
+      env: bridgeEnv,
+      runtimeSelection,
+    });
+    const profileModels = runtimeProfiles.flatMap((profile) => profile.models || []);
     return {
       metadata: {
         availableAgents: available.map((check) => check.agent).join(','),
-        availableModels: available.flatMap((check) => check.models || []).join(','),
+        availableModels: profileModels.map((model) => model.id).join(','),
+        availableModelDetails: JSON.stringify(
+          profileModels,
+        ),
         agentVersions: available.map((check) => `${check.agent}=${check.version || 'unknown'}`).join(','),
         bridgeCapabilities: BRIDGE_CAPABILITIES.join(','),
         bridgeVersion: BRIDGE_VERSION,
@@ -192,12 +309,14 @@ async function inspectAvailability(config = {}) {
       ),
       agents: checks.agents,
       dryRun: checks.dryRun,
+      runtimeProfiles,
     };
   } catch {
     return {
       metadata: {
         availableAgents: '',
         availableModels: '',
+        availableModelDetails: '[]',
         agentVersions: '',
         bridgeCapabilities: BRIDGE_CAPABILITIES.join(','),
         bridgeVersion: BRIDGE_VERSION,
@@ -206,19 +325,41 @@ async function inspectAvailability(config = {}) {
       agentCommands: {},
       agents: [],
       dryRun: null,
+      runtimeProfiles: [],
     };
   }
 }
 
-async function availabilityMetadata(config = {}) {
-  return (await inspectAvailability(config)).metadata;
-}
-
 function selectedAgentCheck(availability, agent) {
   if (agent === 'dry-run') return availability.dryRun;
   return availability.agents.find((check) => check.agent === agent) || null;
 }
 
+function requireAvailableRuntime(availability, runtimeSelection) {
+  const driver = runtimeDriver(runtimeSelection);
+  const profile = availability.runtimeProfiles.find(
+    (candidate) => candidate.driver === driver,
+  );
+  if (profile?.authState === 'ready' && profile.models?.length) return profile;
+
+  if (runtimeSelection === 'codex' || runtimeSelection === 'claude-code') {
+    requireAvailableAgent(
+      availability,
+      runtimeSelection,
+      process.platform,
+    );
+  }
+
+  const error = new Error(
+    runtimeSelection === 'opencode'
+      ? 'OpenCode is not ready. Install OpenCode, connect a model provider in OpenCode, then run this command again.'
+      : `${runtimeLabel(runtimeSelection)} did not advertise any usable models.`,
+  );
+  error.code = 'DEXTER_RUNTIME_NOT_READY';
+  error.exitCode = 2;
+  throw error;
+}
+
 function requireAvailableAgent(availability, agent, platform = process.platform) {
   const check = selectedAgentCheck(availability, agent);
   if (check?.ok) return check;
@@ -229,8 +370,8 @@ function requireAvailableAgent(availability, agent, platform = process.platform)
     message = check.error || 'Claude Code is not signed in. Run `claude auth login`, then try again.';
   } else if (agent === 'claude-code' && (check?.code === 'DEXTER_AGENT_NOT_FOUND' || !check)) {
     message = platform === 'win32'
-      ? 'Claude Code was not found. In PowerShell, run `claude --version`. Dexter also checks `%USERPROFILE%\\.local\\bin\\claude.exe`. If Claude is installed elsewhere, set `DEXTER_BRIDGE_CLAUDE_BIN` to its full path, then run the Dexter connection command again.'
-      : 'Claude Code was not found. Run `claude --version` in this terminal. If Claude is installed elsewhere, set `DEXTER_BRIDGE_CLAUDE_BIN` to its full path, then run the Dexter connection command again.';
+      ? 'Claude Code was not found. In PowerShell, run `claude --version`. The bridge also checks `%USERPROFILE%\\.local\\bin\\claude.exe`. If Claude is installed elsewhere, set `DEXTER_BRIDGE_CLAUDE_BIN` to its full path, then run the connection command again.'
+      : 'Claude Code was not found. Run `claude --version` in this terminal. If Claude is installed elsewhere, set `DEXTER_BRIDGE_CLAUDE_BIN` to its full path, then run the connection command again.';
   }
 
   const error = new Error(message);
@@ -239,15 +380,36 @@ function requireAvailableAgent(availability, agent, platform = process.platform)
   throw error;
 }
 
+function availableModel(check, requestedModel) {
+  const models = Array.isArray(check?.models) ? check.models : [];
+  return models.includes(requestedModel) ? requestedModel : models[0] || requestedModel;
+}
+
 async function pairCommand({ apiBaseUrl, args, flags, configDir }) {
   const codeOrToken = args[0];
   if (!codeOrToken) throw new Error('Pairing code or token is required.');
   const isToken = /^dcpp_/i.test(codeOrToken);
   const config = readConfig(configDir);
-  const agent = resolveAgentName({ flagValue: flags.agent, config });
-  const model = resolveCompanionModelName({ flagValue: flags.model, config, agent });
-  const availability = await inspectAvailability(config);
-  requireAvailableAgent(availability, agent);
+  const runtimeSelection = requestedRuntime(flags, config);
+  const agent = runtimeSelection
+    ? runtimeAgent(runtimeSelection)
+    : resolveAgentName({ flagValue: flags.agent, config });
+  const requestedModel = runtimeSelection
+    ? flags.model || config.model
+    : resolveCompanionModelName({ flagValue: flags.model, config, agent });
+  const availability = await inspectAvailability(config, runtimeSelection);
+  const runtimeProfile = runtimeSelection
+    ? requireAvailableRuntime(availability, runtimeSelection)
+    : null;
+  const check = runtimeProfile
+    ? null
+    : availability.agents.find((candidate) => candidate.agent === agent && candidate.ok)
+      || availability.agents.find((candidate) => candidate.ok)
+      || availability.dryRun;
+  const model = runtimeProfile
+    ? runtimeProfile.models.find((candidate) => candidate.id === requestedModel)?.id
+      || runtimeProfile.models[0].id
+    : availableModel(check, requestedModel);
   const result = await claimPairing(apiBaseUrl, {
     pairingCode: isToken ? undefined : codeOrToken,
     pairingToken: isToken ? codeOrToken : undefined,
@@ -255,24 +417,43 @@ async function pairCommand({ apiBaseUrl, args, flags, configDir }) {
     agent,
     model,
     metadata: availability.metadata,
+    runtimeProfiles: availability.runtimeProfiles.map(publicRuntimeProfile),
+    runtimeSelection,
   });
   saveConfigPatch({
     apiBaseUrl,
     agent,
     model,
+    runtimeSelection,
+    product: normalizeBridgeProduct(result.product),
     deviceToken: result.deviceToken,
     device: result.device,
     agentCommands: availability.agentCommands,
     pairedAt: new Date().toISOString(),
   }, configDir);
-  console.log(`Paired Dexter Bridge: ${result.device?.name || 'device'}`);
+  const product = normalizeBridgeProduct(result.product);
+  console.log(`Paired ${product.name} Bridge: ${result.device?.name || 'device'}`);
+  if (runtimeSelection) {
+    console.log(`Runtime: ${runtimeProfile?.label || runtimeLabel(runtimeSelection)}`);
+  }
   console.log(`API: ${apiBaseUrl}`);
 }
 
 async function statusCommand({ apiBaseUrl, config, configDir }) {
+  const product = normalizeBridgeProduct(config.product);
   const deviceToken = requireDeviceToken(config);
-  const agent = resolveAgentName({ config });
-  const model = resolveCompanionModelName({ config, agent });
+  const runtimeSelection = requestedRuntime({}, config);
+  const agent = runtimeSelection
+    ? runtimeAgent(runtimeSelection)
+    : resolveAgentName({ config });
+  const availability = await inspectAvailability(config, runtimeSelection);
+  const runtimeProfile = runtimeSelection
+    ? requireAvailableRuntime(availability, runtimeSelection)
+    : null;
+  const model = runtimeProfile
+    ? runtimeProfile.models.find((candidate) => candidate.id === config.model)?.id
+      || runtimeProfile.models[0].id
+    : resolveCompanionModelName({ config, agent });
   let result;
   try {
     result = await heartbeat(apiBaseUrl, {
@@ -280,14 +461,18 @@ async function statusCommand({ apiBaseUrl, config, configDir }) {
       status: 'ready',
       agent,
       model,
-      metadata: await availabilityMetadata(config),
+      metadata: availability.metadata,
+      runtimeProfiles: availability.runtimeProfiles.map(publicRuntimeProfile),
     });
   } catch (error) {
     if (isInvalidPairingError(error)) throw clearInvalidPairing(configDir, error);
     throw error;
   }
   console.log(`Status: ${result.device?.online ? 'online' : 'paired'}`);
-  console.log(`Device: ${result.device?.name || 'Dexter Bridge'}`);
+  console.log(`Device: ${result.device?.name || `${product.name} Bridge`}`);
+  if (runtimeSelection) {
+    console.log(`Runtime: ${runtimeProfile?.label || runtimeLabel(runtimeSelection)}`);
+  }
   console.log(`Model: ${result.device?.model?.displayName || model}`);
   console.log(`API: ${apiBaseUrl}`);
 }
@@ -297,39 +482,68 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
   let deviceToken = config.deviceToken;
   if (!deviceToken) {
     // First run: pair interactively so `npx @gakim-digital/dexter-bridge` alone is
-    // enough — the Dexter plugin shows the code, the user pastes it here.
     if (!process.stdin.isTTY) requireDeviceToken(config);
-    console.log('Dexter Bridge is not paired with your Dexter account yet.');
-    console.log('Open the Dexter plugin in Framer and pick Connect → Codex to get a pairing code.');
+    console.log('This local agent bridge is not paired yet.');
+    console.log('Open the product connection screen and generate a new bridge command.');
     const code = await promptForPairingCode();
     if (!code) requireDeviceToken(config);
     await pairCommand({ apiBaseUrl, args: [code], flags, configDir });
     activeConfig = readConfig(configDir);
     deviceToken = activeConfig.deviceToken;
   }
-  const agent = resolveAgentName({ flagValue: flags.agent, config: activeConfig });
-  const model = resolveCompanionModelName({ flagValue: flags.model, config: activeConfig, agent });
+  const product = normalizeBridgeProduct(activeConfig.product);
+  const runtimeSelection = requestedRuntime(flags, activeConfig);
+  if (product.connectionScope === 'app-builder' && !runtimeSelection) {
+    const error = new Error('This App Builder connection requires --runtime codex, --runtime claude-code, or --runtime opencode.');
+    error.code = 'DEXTER_RUNTIME_REQUIRED';
+    error.exitCode = 2;
+    throw error;
+  }
+  const agent = runtimeSelection
+    ? runtimeAgent(runtimeSelection)
+    : resolveAgentName({ flagValue: flags.agent, config: activeConfig });
+  const requestedModel = runtimeSelection
+    ? flags.model || activeConfig.model
+    : resolveCompanionModelName({ flagValue: flags.model, config: activeConfig, agent });
   const waitMs = Number(flags['wait-ms'] || 25000);
   const once = Boolean(flags.once);
   const bridgeEnv = agentEnvironment(activeConfig);
-  const availability = await inspectAvailability(activeConfig);
-  requireAvailableAgent(availability, agent);
+  const availability = await inspectAvailability(activeConfig, runtimeSelection);
+  const runtimeProfile = runtimeSelection
+    ? requireAvailableRuntime(availability, runtimeSelection)
+    : null;
+  const check = runtimeProfile
+    ? null
+    : requireAvailableAgent(availability, agent);
+  const model = runtimeProfile
+    ? runtimeProfile.models.find((candidate) => candidate.id === requestedModel)?.id
+      || runtimeProfile.models[0].id
+    : availableModel(check, requestedModel);
   const metadata = availability.metadata;
   const pollLogger = createRunLogger({ runId: 'bridge-poll' });
+  const profiles = runtimeProfileMap(availability.runtimeProfiles);
   const providerAdapters = new Map();
-  const providerAdapterForAgent = (runAgent) => {
-    if (providerAdapters.has(runAgent)) return providerAdapters.get(runAgent);
-    const adapter = createLocalAgentAdapter(runAgent, {
+  const providerAdapterForProfile = (runtimeProfile) => {
+    const profile = profiles.get(runtimeProfile?.id) || runtimeProfile;
+    if (!profile?.id) return null;
+    if (providerAdapters.has(profile.id)) return providerAdapters.get(profile.id);
+    const adapter = createLocalAgentAdapter(profile, {
       env: bridgeEnv,
+      product,
       trace: pollLogger,
+      credentials: profile.credentials,
     });
-    providerAdapters.set(runAgent, adapter);
+    providerAdapters.set(profile.id, adapter);
     return adapter;
   };
   let pollFailureCount = 0;
 
-  console.log(`Dexter Bridge connected to ${apiBaseUrl}`);
-  console.log(`Agent: ${agent}`);
+  console.log(`${product.name} Bridge connected to ${apiBaseUrl}`);
+  console.log(
+    `${runtimeSelection ? 'Runtime' : 'Agent'}: ${
+      runtimeSelection ? runtimeProfile?.label || runtimeLabel(runtimeSelection) : agent
+    }`,
+  );
   console.log(`Model: ${model}`);
   console.log(`Logs: ${logLocationHint()}`);
   console.log('Waiting for runs...');
@@ -338,7 +552,14 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
     while (true) {
       let poll;
       try {
-        poll = await pollRun(apiBaseUrl, { deviceToken, waitMs, agent, model, metadata });
+        poll = await pollRun(apiBaseUrl, {
+          deviceToken,
+          waitMs,
+          agent,
+          model,
+          metadata,
+          runtimeProfiles: availability.runtimeProfiles.map(publicRuntimeProfile),
+        });
         pollFailureCount = 0;
       } catch (error) {
         if (isInvalidPairingError(error)) {
@@ -353,24 +574,44 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
         const retryInMs = pollBackoffMs(pollFailureCount);
         pollLogger.error('poll_failed', { error: errorMeta(error) });
         if (pollFailureCount === 1 || (pollFailureCount & (pollFailureCount - 1)) === 0) {
-          console.error(`Dexter poll failed; retrying in ${Math.round(retryInMs / 1000)}s.`);
+          console.error(`${product.name} polling failed; retrying in ${Math.round(retryInMs / 1000)}s.`);
         }
         await wait(retryInMs);
         continue;
       }
       if (poll.run) {
         console.log(`Claimed run ${poll.run.runId}.`);
-        const runAgent = normalizeAgentName(poll.run?.companion?.agent || agent);
+        const runtimeProfile = poll.run?.runtimeProfile || null;
+        const runAgent = normalizeAgentName(
+          poll.run?.companion?.agent
+          || (
+            runtimeProfile?.driver === 'claude-code-cli'
+              ? 'claude-code'
+              : runtimeProfile?.driver === 'opencode'
+                ? 'opencode'
+                : 'codex'
+          ),
+        );
         await executeClaimedRun({
           run: poll.run,
           once,
+          preventIdleSleep: true,
           logger: pollLogger,
+          product,
           executeOptions: {
             apiBaseUrl,
             deviceToken,
             agent: runAgent,
             selectedModel: model,
-            providerAdapter: providerAdapterForAgent(runAgent),
+            runtimeProfile,
+            providerAdapter: runtimeProfile
+              ? providerAdapterForProfile(runtimeProfile)
+              : createLocalAgentAdapter(runAgent, {
+                  env: bridgeEnv,
+                  product,
+                  trace: pollLogger,
+                }),
+            product,
             env: bridgeEnv,
             maxSteps: flags['max-steps'],
           },
@@ -379,7 +620,7 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
         continue;
       }
       if (once) {
-        console.log('No pending Dexter runs.');
+        console.log(`No pending ${product.name} runs.`);
         return;
       }
     }
@@ -389,7 +630,14 @@ async function startCommand({ apiBaseUrl, config, flags, configDir }) {
   }
 }
 
-async function doctorCommand() {
+async function doctorCommand(runtimeSelection = null) {
+  if (runtimeSelection) {
+    const availability = await inspectAvailability({}, runtimeSelection);
+    const profile = requireAvailableRuntime(availability, runtimeSelection);
+    console.log(`${runtimeLabel(runtimeSelection)}: ready`);
+    console.log(`Models: ${profile.models.map((model) => model.displayName || model.id).join(', ')}`);
+    return;
+  }
   const checks = await checkAllAgents();
   for (const check of checks.agents) {
     if (check.ok) console.log(`${check.command}: ok ${check.output || ''}`.trim());
@@ -404,7 +652,7 @@ export async function runCli(argv) {
     return;
   }
 
-  const configDir = parsed.flags['config-dir'] || defaultConfigDir();
+  const configDir = configDirForFlags(parsed.flags);
   const config = readConfig(configDir);
   const apiBaseUrl = resolveApiBaseUrl({
     flagValue: parsed.flags.api,
@@ -427,7 +675,7 @@ export async function runCli(argv) {
       return;
     case 'pair':
       await pairCommand({ apiBaseUrl, args: parsed.args, flags: parsed.flags, configDir });
-      console.log('Run `dexter-bridge start` to go online.');
+      console.log(`Run \`dexter-bridge start\` to bring ${normalizeBridgeProduct(readConfig(configDir).product).name} online.`);
       return;
     case 'start':
       await startCommand({ apiBaseUrl, config: { ...config, apiBaseUrl }, flags: parsed.flags, configDir });
@@ -436,11 +684,14 @@ export async function runCli(argv) {
       await statusCommand({ apiBaseUrl, config, configDir });
       return;
     case 'doctor':
-      await doctorCommand();
+      await doctorCommand(requestedRuntime(parsed.flags, config));
       return;
     case 'logout':
-      clearConfig(configDir);
-      console.log('Dexter Bridge local pairing removed.');
+      {
+        const product = normalizeBridgeProduct(config.product);
+        clearConfig(configDir);
+        console.log(`${product.name} Bridge local pairing removed.`);
+      }
       return;
     default:
       throw new Error(`Unknown command "${parsed.command}".\n\n${usage()}`);
@@ -450,10 +701,15 @@ export async function runCli(argv) {
 export const __private__ = {
   agentEnvironment,
   clearInvalidPairing,
+  configDirForFlags,
   executeClaimedRun,
+  startRunAwakeGuard,
   isInvalidPairingError,
   parseArgv,
   pollBackoffMs,
+  requestedRuntime,
+  availableModel,
+  requireAvailableRuntime,
   requireAvailableAgent,
   selectedAgentCheck,
   usage,