@chrisromp/copilot-bridge 0.6.0-dev.2

package/scripts/init.ts

@@ -0,0 +1,250 @@
+#!/usr/bin/env npx tsx
+/**
+ * copilot-bridge init — Interactive setup wizard.
+ *
+ * Usage: npm run init
+ *        npx tsx scripts/init.ts
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { heading, success, warn, fail, info, dim, blank, printCheck } from './lib/output.js';
+import { askRequired, askSecret, confirm, choose, closePrompts } from './lib/prompts.js';
+import { runAllPrereqs, checkNodeVersion } from './lib/prerequisites.js';
+import { pingServer, validateBotToken, checkChannelAccess, getChannelInfo } from './lib/mattermost.js';
+import { buildConfig, writeConfig, configExists, getConfigPath, getConfigDir, type BotEntry, type ChannelEntry, type ConfigDefaults } from './lib/config-gen.js';
+import { detectPlatform } from './lib/service.js';
+
+async function main() {
+  console.log();
+  heading('🚀 copilot-bridge setup');
+  dim('Interactive wizard to configure copilot-bridge.\n');
+
+  // --- Step 1: Prerequisites ---
+  heading('Step 1: Prerequisites');
+
+  const nodeCheck = checkNodeVersion();
+  printCheck(nodeCheck);
+  if (nodeCheck.status === 'fail') {
+    fail('Node.js 20+ is required. Please upgrade and re-run.');
+    process.exit(1);
+  }
+
+  const prereqs = runAllPrereqs();
+  // Skip node (already printed); print Copilot CLI and auth
+  for (const check of prereqs.slice(1)) {
+    printCheck(check);
+  }
+
+  const hasFail = prereqs.some(c => c.status === 'fail');
+  if (hasFail) {
+    blank();
+    warn('Some prerequisites failed. You can continue setup, but the bridge may not work until they are resolved.');
+    if (!await confirm('Continue anyway?', false)) {
+      process.exit(1);
+    }
+  }
+
+  // --- Check for existing config ---
+  if (configExists()) {
+    blank();
+    warn(`Existing config found at ${getConfigPath()}`);
+    if (!await confirm('Overwrite with a new config?', false)) {
+      info('Run "npm run check" to validate your existing config.');
+      closePrompts();
+      process.exit(0);
+    }
+  }
+
+  // --- Step 2: Mattermost connection ---
+  heading('Step 2: Mattermost Connection');
+  info('Connect to your Mattermost instance. You\'ll need the URL and a bot token.');
+  dim('Create bot accounts in Mattermost: System Console → Integrations → Bot Accounts\n');
+
+  let mmUrl = '';
+  while (true) {
+    mmUrl = await askRequired('Mattermost URL (e.g., https://chat.example.com)');
+    mmUrl = mmUrl.replace(/\/+$/, '');
+    if (!mmUrl.startsWith('http')) mmUrl = `https://${mmUrl}`;
+
+    const ping = await pingServer(mmUrl);
+    printCheck(ping);
+    if (ping.status === 'pass' || ping.status === 'warn') break;
+    if (!await confirm('Try a different URL?')) {
+      warn('Continuing with unverified URL.');
+      break;
+    }
+  }
+
+  // --- Step 3: Bot configuration ---
+  heading('Step 3: Bot Configuration');
+
+  const bots: BotEntry[] = [];
+  let addMore = true;
+
+  while (addMore) {
+    if (bots.length === 0) {
+      info('Enter the bot token from your Mattermost bot account.');
+      dim('You can add more bots later if you want multiple identities.\n');
+    }
+
+    const token = await askSecret(`Bot token${bots.length > 0 ? ' (for next bot)' : ''}`);
+    const validation = await validateBotToken(mmUrl, token);
+    printCheck(validation.result);
+
+    if (validation.result.status === 'pass' && validation.bot) {
+      const isAdmin = validation.bot.roles?.includes('system_admin')
+        || await confirm(`Is "${validation.bot.username}" an admin bot?`, false);
+
+      bots.push({
+        name: validation.bot.username,
+        token,
+        admin: !!isAdmin,
+      });
+      success(`Added bot "${validation.bot.username}"${isAdmin ? ' (admin)' : ''}`);
+    } else {
+      warn('Token validation failed. The token was still added — verify it later with "npm run check".');
+      let name = await askRequired('Bot username (for config)');
+      name = name.replace(/^@/, '');
+      bots.push({ name, token, admin: false });
+    }
+
+    if (bots.length >= 1) {
+      addMore = await confirm('Add another bot?', false);
+    }
+  }
+
+  // --- Step 4: Channel configuration ---
+  heading('Step 4: Channel Configuration');
+  info('Direct messages work automatically — no config needed.');
+  info('Group channels need their channel ID and a working directory.\n');
+
+  const channels: ChannelEntry[] = [];
+  let addChannels = await confirm('Configure group channels now?', false);
+
+  while (addChannels) {
+    const channelId = await askRequired('Channel ID (from Mattermost channel settings → View Info)');
+
+    // Validate channel access
+    const primaryBot = bots[0];
+    const access = await checkChannelAccess(mmUrl, primaryBot.token, channelId);
+    printCheck(access);
+
+    let channelName: string | undefined;
+    if (access.status === 'pass') {
+      const chInfo = await getChannelInfo(mmUrl, primaryBot.token, channelId);
+      channelName = chInfo?.displayName || chInfo?.name;
+    }
+
+    const workDir = await askRequired('Working directory (absolute path for this channel\'s workspace)');
+
+    // Create working directory if it doesn't exist
+    if (!fs.existsSync(workDir)) {
+      if (await confirm(`Directory "${workDir}" doesn't exist. Create it?`)) {
+        fs.mkdirSync(workDir, { recursive: true });
+        success(`Created ${workDir}`);
+      }
+    }
+
+    // If multiple bots, ask which one
+    let botName = bots[0].name;
+    if (bots.length > 1) {
+      const idx = await choose('Which bot for this channel?', bots.map(b => b.name));
+      botName = bots[idx].name;
+    }
+
+    channels.push({
+      id: channelId,
+      name: channelName,
+      platform: 'mattermost',
+      bot: botName,
+      workingDirectory: workDir,
+    });
+    success(`Added channel${channelName ? ` "${channelName}"` : ''}`);
+
+    addChannels = await confirm('Add another channel?', false);
+  }
+
+  if (channels.length === 0) {
+    info('No group channels configured. DMs will still work automatically.');
+  }
+
+  // --- Step 5: Defaults ---
+  heading('Step 5: Defaults');
+  dim('These can be changed later in config.json or via chat commands.\n');
+
+  const defaults: ConfigDefaults = {};
+
+  const modelChoice = await choose('Default model?', [
+    'claude-sonnet-4.6 (recommended)',
+    'claude-opus-4.6 (premium)',
+    'claude-haiku-4.5 (fast/cheap)',
+    'Other (enter manually)',
+  ]);
+  if (modelChoice === 3) {
+    defaults.model = await askRequired('Model name');
+  } else {
+    defaults.model = ['claude-sonnet-4.6', 'claude-opus-4.6', 'claude-haiku-4.5'][modelChoice];
+  }
+
+  const triggerChoice = await choose('Default trigger mode (for group channels — DMs always respond)?', [
+    'mention — bot responds only when @mentioned (recommended)',
+    'all — bot responds to every message in the channel',
+  ]);
+  defaults.triggerMode = triggerChoice === 0 ? 'mention' : 'all';
+  defaults.threadedReplies = await confirm('Reply in threads by default?', true);
+  defaults.verbose = await confirm('Verbose mode (show tool calls)?', false);
+
+  // --- Step 6: Generate config ---
+  heading('Step 6: Generate Config');
+
+  const config = buildConfig({ mmUrl, bots, channels, defaults });
+  const configPath = writeConfig(config);
+  success(`Config written to ${configPath}`);
+
+  // Ensure workspaces dir exists
+  const workspacesDir = path.join(getConfigDir(), 'workspaces');
+  if (!fs.existsSync(workspacesDir)) {
+    fs.mkdirSync(workspacesDir, { recursive: true });
+  }
+
+  // --- Step 7: Service setup ---
+  heading('Step 7: Service Setup (Optional)');
+
+  const osPlatform = detectPlatform();
+  if (osPlatform === 'macos') {
+    info('To run as a launchd service (auto-start at login):');
+    dim('  npm run install-service\n');
+  } else if (osPlatform === 'linux') {
+    info('To run as a systemd service (auto-start at boot):');
+    dim('  npm run install-service');
+    dim('  (requires sudo — installs to /etc/systemd/system/)\n');
+    dim('  Note: build first with npm run build\n');
+  } else {
+    info('Run the bridge manually: npm run dev (development) or npm start (production)');
+  }
+
+  // --- Done ---
+  heading('✅ Setup Complete');
+  blank();
+  info(`Config: ${configPath}`);
+  info(`Bots: ${bots.map(b => b.name).join(', ')}`);
+  if (channels.length > 0) info(`Channels: ${channels.length} configured`);
+  info('DMs: enabled automatically');
+  blank();
+  dim('Next steps:');
+  dim('  npm run dev              Start in development mode (watch)');
+  dim('  npm run check            Validate your setup');
+  dim('  npm run install-service  Install as a system service');
+  dim('  npm run build            Build for production');
+  dim('  npm start                Start production server');
+  blank();
+
+  closePrompts();
+}
+
+main().catch((err) => {
+  console.error('\nSetup failed:', err.message || err);
+  closePrompts();
+  process.exit(1);
+});

package/scripts/install-service.ts

@@ -0,0 +1,123 @@
+#!/usr/bin/env npx tsx
+/**
+ * copilot-bridge install-service — Install the bridge as a system service.
+ *
+ * macOS: installs a launchd plist (user-level, no sudo needed)
+ * Linux: installs a systemd unit (system-level, requires sudo)
+ *
+ * Usage: npm run install-service
+ *        npx tsx scripts/install-service.ts
+ */
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { heading, success, fail, info, dim, blank } from './lib/output.js';
+import {
+  detectPlatform,
+  generateLaunchdPlist, installLaunchd, getLaunchdInstallPath,
+  generateSystemdUnit, getSystemdInstallPath,
+} from './lib/service.js';
+import { execSync } from 'node:child_process';
+
+function main() {
+  const osPlatform = detectPlatform();
+  const bridgePath = process.cwd();
+  const homePath = os.homedir();
+  const user = os.userInfo().username;
+
+  heading('📦 copilot-bridge service installer');
+  blank();
+
+  if (osPlatform === 'macos') {
+    info('macOS detected — installing launchd service.');
+    dim('The service auto-starts at login and restarts on crash.\n');
+
+    const distPath = path.join(bridgePath, 'dist', 'index.js');
+    if (!fs.existsSync(distPath)) {
+      fail('dist/index.js not found. Run "npm run build" first.');
+      process.exit(1);
+    }
+
+    const plist = generateLaunchdPlist({
+      label: 'com.copilot-bridge',
+      bridgePath,
+      homePath,
+    });
+
+    const installPath = getLaunchdInstallPath();
+    if (fs.existsSync(installPath)) {
+      info(`Overwriting existing service at ${installPath}`);
+    }
+
+    const result = installLaunchd(plist);
+    if (result.installed) {
+      success(`Service installed at ${result.path}`);
+      blank();
+      dim('Management:');
+      dim('  launchctl list com.copilot-bridge                     # status');
+      dim('  launchctl kickstart -k gui/$(id -u)/com.copilot-bridge  # restart');
+      dim('  tail -f /tmp/copilot-bridge.log                        # logs');
+    } else {
+      fail(`Install failed: ${result.error}`);
+      process.exit(1);
+    }
+
+  } else if (osPlatform === 'linux') {
+    info('Linux detected — installing systemd service (system-scoped).');
+    dim('The service starts at boot and restarts on crash.\n');
+
+    // Check if dist/index.js exists
+    const distPath = path.join(bridgePath, 'dist', 'index.js');
+    if (!fs.existsSync(distPath)) {
+      fail('dist/index.js not found. Run "npm run build" first.');
+      process.exit(1);
+    }
+
+    const unit = generateSystemdUnit({ bridgePath, homePath, user });
+    const installPath = getSystemdInstallPath();
+    const tmpPath = path.join(os.tmpdir(), 'copilot-bridge.service');
+
+    // Write to temp, then sudo copy
+    fs.writeFileSync(tmpPath, unit, 'utf-8');
+
+    const isRoot = process.getuid?.() === 0;
+    if (!isRoot) {
+      info('This requires sudo to install to /etc/systemd/system/.');
+      blank();
+    }
+
+    try {
+      execSync(`sudo cp "${tmpPath}" "${installPath}"`, { stdio: 'inherit' });
+      fs.unlinkSync(tmpPath);
+      execSync('sudo systemctl daemon-reload', { stdio: 'inherit' });
+      execSync('sudo systemctl enable copilot-bridge', { stdio: 'inherit' });
+      execSync('sudo systemctl start copilot-bridge', { stdio: 'inherit' });
+      blank();
+      success(`Service installed and started at ${installPath}`);
+      blank();
+      dim('Management:');
+      dim('  sudo systemctl status copilot-bridge    # status');
+      dim('  sudo systemctl restart copilot-bridge   # restart');
+      dim('  sudo journalctl -u copilot-bridge -f    # logs');
+    } catch {
+      // sudo was denied or failed — leave temp file and show manual steps
+      blank();
+      fail('Automatic install failed (sudo may have been denied).');
+      blank();
+      info(`Service file written to: ${tmpPath}`);
+      info('To install manually:');
+      dim(`  sudo cp ${tmpPath} ${installPath}`);
+      dim('  sudo systemctl daemon-reload');
+      dim('  sudo systemctl enable --now copilot-bridge');
+      process.exit(1);
+    }
+
+  } else {
+    fail('Unsupported platform for automatic service install.');
+    info('Run the bridge manually: npm run dev (development) or npm start (production)');
+    process.exit(1);
+  }
+}
+
+main();

package/scripts/lib/config-gen.ts

@@ -0,0 +1,129 @@
+/**
+ * Config file generator. Collects structured input and writes
+ * ~/.copilot-bridge/config.json.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+export interface BotEntry {
+  name: string;
+  token: string;
+  admin: boolean;
+  agent?: string;
+}
+
+export interface ChannelEntry {
+  id: string;
+  name?: string;
+  platform: string;
+  bot: string;
+  workingDirectory: string;
+}
+
+export interface ConfigDefaults {
+  model?: string;
+  triggerMode?: string;
+  threadedReplies?: boolean;
+  verbose?: boolean;
+}
+
+export interface GeneratedConfig {
+  platforms: {
+    mattermost: {
+      url: string;
+      botToken?: string;
+      bots?: Record<string, { token: string; admin?: boolean; agent?: string }>;
+    };
+  };
+  channels: Array<{
+    id: string;
+    name?: string;
+    platform: string;
+    bot?: string;
+    workingDirectory: string;
+  }>;
+  defaults?: ConfigDefaults;
+}
+
+export function buildConfig(opts: {
+  mmUrl: string;
+  bots: BotEntry[];
+  channels: ChannelEntry[];
+  defaults?: ConfigDefaults;
+}): GeneratedConfig {
+  const config: GeneratedConfig = {
+    platforms: {
+      mattermost: {
+        url: opts.mmUrl,
+      },
+    },
+    channels: [],
+  };
+
+  // Single bot → botToken; multiple → bots object
+  if (opts.bots.length === 1) {
+    config.platforms.mattermost.botToken = opts.bots[0].token;
+  } else if (opts.bots.length > 1) {
+    config.platforms.mattermost.bots = {};
+    for (const bot of opts.bots) {
+      config.platforms.mattermost.bots[bot.name] = {
+        token: bot.token,
+        ...(bot.admin ? { admin: true } : {}),
+        ...(bot.agent ? { agent: bot.agent } : {}),
+      };
+    }
+  }
+
+  for (const ch of opts.channels) {
+    config.channels.push({
+      id: ch.id,
+      ...(ch.name ? { name: ch.name } : {}),
+      platform: ch.platform,
+      ...(opts.bots.length > 1 ? { bot: ch.bot } : {}),
+      workingDirectory: ch.workingDirectory,
+    });
+  }
+
+  if (opts.defaults) {
+    config.defaults = {};
+    if (opts.defaults.model) config.defaults.model = opts.defaults.model;
+    if (opts.defaults.triggerMode) config.defaults.triggerMode = opts.defaults.triggerMode;
+    if (opts.defaults.threadedReplies !== undefined) config.defaults.threadedReplies = opts.defaults.threadedReplies;
+    if (opts.defaults.verbose !== undefined) config.defaults.verbose = opts.defaults.verbose;
+  }
+
+  return config;
+}
+
+export function getConfigDir(): string {
+  return path.join(os.homedir(), '.copilot-bridge');
+}
+
+export function getConfigPath(): string {
+  return path.join(getConfigDir(), 'config.json');
+}
+
+export function configExists(): boolean {
+  return fs.existsSync(getConfigPath());
+}
+
+export function writeConfig(config: GeneratedConfig): string {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  const configPath = getConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  return configPath;
+}
+
+export function readExistingConfig(): GeneratedConfig | null {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}

package/scripts/lib/mattermost.ts

@@ -0,0 +1,109 @@
+/**
+ * Mattermost API validation helpers.
+ * Uses native fetch (Node 18+) — no @mattermost/client dependency.
+ */
+
+import type { CheckResult } from './output.js';
+
+export interface MattermostBotInfo {
+  id: string;
+  username: string;
+  email?: string;
+  roles?: string;
+  isBot?: boolean;
+}
+
+async function mmFetch(baseUrl: string, endpoint: string, token?: string): Promise<{ ok: boolean; status: number; data: any }> {
+  const url = `${baseUrl.replace(/\/+$/, '')}/api/v4${endpoint}`;
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+  };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  try {
+    const res = await fetch(url, { headers, signal: AbortSignal.timeout(10_000) });
+    const data = await res.json().catch(() => null);
+    return { ok: res.ok, status: res.status, data };
+  } catch (err: any) {
+    return { ok: false, status: 0, data: { message: err.message || String(err) } };
+  }
+}
+
+export async function pingServer(baseUrl: string): Promise<CheckResult> {
+  const { ok, status, data } = await mmFetch(baseUrl, '/system/ping');
+  if (ok && data?.status === 'OK') {
+    return { status: 'pass', label: `Mattermost: ${baseUrl}`, detail: 'reachable' };
+  }
+  if (status === 0) {
+    return { status: 'fail', label: `Mattermost: ${baseUrl}`, detail: 'connection failed — check URL' };
+  }
+  // Distinguish Mattermost auth rejection from CDN/WAF blocking:
+  // Mattermost returns JSON; Cloudflare/CDN returns HTML or no JSON body
+  if (status === 401 || status === 403) {
+    if (data && typeof data === 'object' && ('status_code' in data || 'message' in data || 'id' in data)) {
+      // Mattermost JSON error response — server is reachable, just auth-gated
+      return { status: 'pass', label: `Mattermost: ${baseUrl}`, detail: 'reachable (ping requires auth on this server)' };
+    }
+    return {
+      status: 'warn',
+      label: `Mattermost: ${baseUrl}`,
+      detail: `HTTP ${status} — may be blocked by a CDN/firewall. Will verify with bot token.`,
+    };
+  }
+  return { status: 'fail', label: `Mattermost: ${baseUrl}`, detail: `HTTP ${status}` };
+}
+
+export async function validateBotToken(baseUrl: string, token: string): Promise<{ result: CheckResult; bot?: MattermostBotInfo }> {
+  const { ok, status, data } = await mmFetch(baseUrl, '/users/me', token);
+  if (ok && data?.id) {
+    const bot: MattermostBotInfo = {
+      id: data.id,
+      username: data.username,
+      email: data.email,
+      roles: data.roles,
+      isBot: data.is_bot,
+    };
+    const roleNote = data.roles?.includes('system_admin') ? ', admin' : '';
+    return {
+      result: { status: 'pass', label: `Bot "${data.username}"`, detail: `token valid${roleNote}` },
+      bot,
+    };
+  }
+  if (status === 401) {
+    return { result: { status: 'fail', label: 'Bot token', detail: 'invalid or expired token' } };
+  }
+  if (status === 403) {
+    return { result: { status: 'fail', label: 'Bot token', detail: 'token rejected (403) — check that the token has API access permissions' } };
+  }
+  return { result: { status: 'fail', label: 'Bot token', detail: `HTTP ${status}: ${data?.message || 'unknown error'}` } };
+}
+
+export async function checkChannelAccess(baseUrl: string, token: string, channelId: string, configName?: string): Promise<CheckResult> {
+  const { ok, status, data } = await mmFetch(baseUrl, `/channels/${channelId}`, token);
+  if (ok && data?.id) {
+    const isDM = data.type === 'D' || data.type === 'G';
+    const name = configName
+      || data.display_name
+      || (isDM ? 'DM channel' : null)
+      || data.name
+      || channelId;
+    return { status: 'pass', label: `Channel "${name}"`, detail: isDM ? 'DM, accessible' : 'accessible' };
+  }
+  if (status === 403) {
+    const label = configName || channelId;
+    return { status: 'warn', label: `Channel "${label}"`, detail: 'bot not a member — add manually in Mattermost' };
+  }
+  if (status === 404) {
+    const label = configName || channelId;
+    return { status: 'fail', label: `Channel "${label}"`, detail: 'not found — check the channel ID' };
+  }
+  return { status: 'fail', label: `Channel ${channelId}`, detail: `HTTP ${status}: ${data?.message || 'unknown'}` };
+}
+
+export async function getChannelInfo(baseUrl: string, token: string, channelId: string): Promise<{ name?: string; displayName?: string; teamId?: string } | null> {
+  const { ok, data } = await mmFetch(baseUrl, `/channels/${channelId}`, token);
+  if (ok && data?.id) {
+    return { name: data.name, displayName: data.display_name, teamId: data.team_id };
+  }
+  return null;
+}

package/scripts/lib/output.ts

@@ -0,0 +1,69 @@
+/**
+ * Colored terminal output helpers for init/check CLI commands.
+ * No dependencies — uses ANSI escape codes directly.
+ */
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const RED = '\x1b[31m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const CYAN = '\x1b[36m';
+
+export function success(msg: string): void {
+  console.log(`${GREEN}✅${RESET} ${msg}`);
+}
+
+export function warn(msg: string): void {
+  console.log(`${YELLOW}⚠️${RESET}  ${msg}`);
+}
+
+export function fail(msg: string): void {
+  console.log(`${RED}❌${RESET} ${msg}`);
+}
+
+export function info(msg: string): void {
+  console.log(`${CYAN}ℹ️${RESET}  ${msg}`);
+}
+
+export function heading(msg: string): void {
+  console.log(`\n${BOLD}${msg}${RESET}`);
+}
+
+export function dim(msg: string): void {
+  console.log(`${DIM}${msg}${RESET}`);
+}
+
+export function blank(): void {
+  console.log();
+}
+
+export interface CheckResult {
+  status: 'pass' | 'warn' | 'fail';
+  label: string;
+  detail?: string;
+}
+
+export function printCheck(result: CheckResult): void {
+  const fn = result.status === 'pass' ? success
+    : result.status === 'warn' ? warn
+    : fail;
+  const detail = result.detail ? ` ${DIM}(${result.detail})${RESET}` : '';
+  fn(`${result.label}${detail}`);
+}
+
+export function printSummary(results: CheckResult[]): void {
+  const passes = results.filter(r => r.status === 'pass').length;
+  const warns = results.filter(r => r.status === 'warn').length;
+  const fails = results.filter(r => r.status === 'fail').length;
+
+  blank();
+  if (fails === 0 && warns === 0) {
+    console.log(`${GREEN}${BOLD}All ${passes} checks passed!${RESET}`);
+  } else if (fails === 0) {
+    console.log(`${YELLOW}${BOLD}${passes} passed, ${warns} warning(s)${RESET}`);
+  } else {
+    console.log(`${RED}${BOLD}${passes} passed, ${warns} warning(s), ${fails} failed${RESET}`);
+  }
+}