@chrisromp/copilot-bridge 0.7.0-dev.16 → 0.8.0

package/scripts/init.ts

@@ -9,12 +9,34 @@
 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 { askRequired, askSecret, confirm, choose, pressEnter, 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 { buildConfig, writeConfig, configExists, getConfigPath, getConfigDir, readExistingConfig, mergeConfig, type BotEntry, type ChannelEntry, type ConfigDefaults } from './lib/config-gen.js';
+import { generateManifestUrl, validateSlackToken, validateAppToken, resolveSlackUser } from './lib/slack.js';
 import { detectPlatform, getServiceStatus } from './lib/service.js';
 
+async function promptAllowlist(botName: string): Promise<{ mode: 'allowlist'; users: string[] } | undefined> {
+  info(`\nAccess control: who can use "${botName}"?`);
+  dim('By default, only users you list here can interact with this bot.\n');
+
+  let yourHandle = await askRequired('Your username (you\'ll be added to the allowlist)');
+  yourHandle = yourHandle.replace(/^@/, '').trim();
+  const users = [yourHandle];
+
+  const extra = await confirm('Add more users to the allowlist?', false);
+  if (extra) {
+    const moreRaw = await askRequired('Additional usernames (comma-separated)');
+    for (const u of moreRaw.split(',')) {
+      const trimmed = u.replace(/^@/, '').trim();
+      if (trimmed.length > 0) users.push(trimmed);
+    }
+  }
+
+  success(`Allowlist: ${users.join(', ')}`);
+  return { mode: 'allowlist', users };
+}
+
 async function main() {
   const isCli = process.env.COPILOT_BRIDGE_CLI === '1';
   console.log();
@@ -47,164 +69,344 @@ async function main() {
   }
 
   // --- Check for existing config ---
-  if (configExists()) {
+  let existingConfig = configExists() ? readExistingConfig() : null;
+  let mergeMode = false;
+
+  if (existingConfig) {
     blank();
     warn(`Existing config found at ${getConfigPath()}`);
-    if (!await confirm('Overwrite with a new config?', false)) {
+    const existingPlatforms = Object.keys(existingConfig.platforms ?? {});
+    info(`Current platforms: ${existingPlatforms.join(', ') || 'none'}`);
+
+    const action = await choose('What would you like to do?', [
+      'Add a platform (keep existing config)',
+      'Start fresh (overwrite)',
+      'Cancel',
+    ]);
+
+    if (action === 2) {
       info(isCli
         ? 'Run "copilot-bridge check" to validate your existing config.'
         : 'Run "npm run check" to validate your existing config.');
       closePrompts();
       process.exit(0);
     }
+    mergeMode = action === 0;
+    if (!mergeMode) existingConfig = null;
   }
 
-  // --- 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');
+  // --- Step 2: Platform selection ---
+  heading('Step 2: Platform');
 
-  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;
+  let useMattermost = false;
+  let useSlack = false;
+
+  if (mergeMode && existingConfig) {
+    // In merge mode, only offer platforms not yet configured
+    const hasMattermost = !!existingConfig.platforms?.mattermost;
+    const hasSlack = !!existingConfig.platforms?.slack;
+    const available: string[] = [];
+    if (!hasMattermost) available.push('Mattermost');
+    if (!hasSlack) available.push('Slack');
+
+    if (available.length === 0) {
+      info('Both platforms are already configured.');
+      closePrompts();
+      process.exit(0);
+    } else if (available.length === 1) {
+      info(`Adding ${available[0]} to your existing config.`);
+      useMattermost = available[0] === 'Mattermost';
+      useSlack = available[0] === 'Slack';
+    } else {
+      const idx = await choose('Which platform to add?', [...available, 'Both']);
+      if (idx === available.length) {
+        useMattermost = true;
+        useSlack = true;
+      } else {
+        useMattermost = available[idx] === 'Mattermost';
+        useSlack = available[idx] === 'Slack';
+      }
     }
+  } else {
+    const platformChoice = await choose('Which chat platform(s)?', [
+      'Mattermost',
+      'Slack',
+      'Both',
+    ]);
+    useMattermost = platformChoice === 0 || platformChoice === 2;
+    useSlack = platformChoice === 1 || platformChoice === 2;
   }
 
-  // --- Step 3: Bot configuration ---
-  heading('Step 3: Bot Configuration');
-
+  // --- Step 3: Platform-specific setup ---
+  let mmUrl = '';
   const bots: BotEntry[] = [];
-  let addMore = true;
+  const slackBots: BotEntry[] = [];
+  const channels: ChannelEntry[] = [];
+
+  // ── Mattermost ──────────────────────────────────────────
+  if (useMattermost) {
+    heading('Step 3a: 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');
+
+    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;
+      }
+    }
+
+    heading('Mattermost Bots');
+    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)' : ''}`);
+        const access = await promptAllowlist(validation.bot.username);
+        if (access) bots[bots.length - 1].access = access;
+      } else {
+        warn(isCli
+          ? 'Token validation failed. The token was still added — verify it later with "copilot-bridge check".'
+          : '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 });
+        const access = await promptAllowlist(name);
+        if (access) bots[bots.length - 1].access = access;
+      }
 
-  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');
+      if (bots.length >= 1) {
+        addMore = await confirm('Add another bot?', false);
+      }
     }
 
-    const token = await askSecret(`Bot token${bots.length > 0 ? ' (for next bot)' : ''}`);
-    const validation = await validateBotToken(mmUrl, token);
-    printCheck(validation.result);
+    // Mattermost channels
+    heading('Mattermost Channels');
+    info('Direct messages work automatically — no config needed.');
+    info('Group channels need their channel ID and a working directory.\n');
 
-    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);
+    let addChannels = await confirm('Configure group channels now?', false);
+    while (addChannels) {
+      const channelId = await askRequired('Channel ID (from Mattermost channel settings → View Info)');
 
-      bots.push({
-        name: validation.bot.username,
-        token,
-        admin: !!isAdmin,
+      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)');
+      if (!fs.existsSync(workDir)) {
+        if (await confirm(`Directory "${workDir}" doesn't exist. Create it?`)) {
+          fs.mkdirSync(workDir, { recursive: true });
+          success(`Created ${workDir}`);
+        }
+      }
+
+      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;
+      }
+
+      const triggerIdx = await choose('Trigger mode for this channel?', [
+        'mention — respond only when @mentioned (recommended)',
+        'all — respond to every message',
+      ]);
+      const triggerMode = triggerIdx === 0 ? 'mention' as const : 'all' as const;
+      const threadedReplies = await confirm('Reply in threads?', true);
+
+      channels.push({
+        id: channelId,
+        name: channelName,
+        platform: 'mattermost',
+        bot: botName,
+        workingDirectory: workDir,
+        triggerMode,
+        threadedReplies,
       });
-      success(`Added bot "${validation.bot.username}"${isAdmin ? ' (admin)' : ''}`);
-    } else {
-      warn(isCli
-        ? 'Token validation failed. The token was still added — verify it later with "copilot-bridge check".'
-        : '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 });
+      success(`Added channel${channelName ? ` "${channelName}"` : ''}`);
+      addChannels = await confirm('Add another channel?', false);
     }
 
-    if (bots.length >= 1) {
-      addMore = await confirm('Add another bot?', false);
+    if (channels.length === 0) {
+      info('No group channels configured. DMs will still work automatically.');
     }
   }
 
-  // --- 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');
+  // ── Slack ───────────────────────────────────────────────
+  if (useSlack) {
+    heading(useMattermost ? 'Step 3b: Slack Connection' : 'Step 3: Slack Connection');
+    info('We\'ll create a Slack app with the right permissions via a manifest URL.');
+    blank();
 
-  const channels: ChannelEntry[] = [];
-  let addChannels = await confirm('Configure group channels now?', false);
+    const botDisplayName = await askRequired('Bot display name for Slack (e.g., copilot)');
+    const manifestUrl = generateManifestUrl(botDisplayName);
 
-  while (addChannels) {
-    const channelId = await askRequired('Channel ID (from Mattermost channel settings → View Info)');
+    info('Open this URL in your browser to create the Slack app:');
+    blank();
+    console.log(`  ${manifestUrl}`);
+    blank();
+    dim('Steps in Slack:');
+    dim('  1. Click the link above → review the manifest → Create');
+    dim('  2. On the app page, go to "OAuth & Permissions" → Install to Workspace');
+    dim('  3. Copy the "Bot User OAuth Token" (starts with xoxb-)');
+    dim('  4. Go to "Basic Information" → "App-Level Tokens" → Generate Token');
+    dim('     Name it anything, add the "connections:write" scope, then Generate');
+    dim('  5. Copy the app-level token (starts with xapp-)');
+    blank();
+
+    await pressEnter('Press Enter when you\'re ready to paste the tokens...');
 
-    // Validate channel access
-    const primaryBot = bots[0];
-    const access = await checkChannelAccess(mmUrl, primaryBot.token, channelId);
-    printCheck(access);
+    // Bot token
+    const botToken = await askSecret('Bot User OAuth Token (xoxb-...)');
+    const tokenResult = await validateSlackToken(botToken);
+    if (tokenResult.ok) {
+      success(`Authenticated as @${tokenResult.botName} in ${tokenResult.teamName}`);
+    } else {
+      warn(`Token validation failed: ${tokenResult.error}. Added anyway — verify later.`);
+    }
 
-    let channelName: string | undefined;
-    if (access.status === 'pass') {
-      const chInfo = await getChannelInfo(mmUrl, primaryBot.token, channelId);
-      channelName = chInfo?.displayName || chInfo?.name;
+    // App token
+    const appToken = await askSecret('App-Level Token (xapp-...)');
+    const appResult = await validateAppToken(appToken);
+    if (appResult.ok) {
+      success('Socket Mode connection verified');
+    } else {
+      warn(`App token validation failed: ${appResult.error}. Added anyway — verify later.`);
     }
 
-    const workDir = await askRequired('Working directory (absolute path for this channel\'s workspace)');
+    const slackBotName = tokenResult.botName ?? botDisplayName;
+    const isAdmin = await confirm(`Is "${slackBotName}" an admin bot?`, false);
 
-    // 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}`);
+    slackBots.push({
+      name: slackBotName,
+      token: botToken,
+      appToken,
+      admin: isAdmin,
+    });
+    success(`Added Slack bot "${slackBotName}"${isAdmin ? ' (admin)' : ''}`);
+
+    // Allowlist — resolve Slack handles to UIDs
+    const access = await promptAllowlist(slackBotName);
+    if (access) {
+      const resolvedUsers: string[] = [];
+      for (const handle of access.users) {
+        const result = await resolveSlackUser(botToken, handle);
+        if (result.userId) {
+          success(`  Resolved "${handle}" → ${result.userId}${result.displayName ? ` (${result.displayName})` : ''}`);
+          resolvedUsers.push(result.userId);
+        } else {
+          warn(`  Could not resolve "${handle}"${result.error ? `: ${result.error}` : ''} — storing as-is`);
+          resolvedUsers.push(handle);
+        }
       }
+      slackBots[slackBots.length - 1].access = { mode: 'allowlist', users: resolvedUsers };
     }
+    // Slack channels (DMs auto-discovered, channels optional)
+    blank();
+    info('Slack DMs work automatically. You can optionally configure specific channels.');
+    let addSlackChannels = await confirm('Configure Slack channels now?', false);
+    while (addSlackChannels) {
+      const channelId = await askRequired('Slack channel ID (right-click channel → View channel details → copy ID at bottom)');
+      const workDir = await askRequired('Working directory (absolute path for this channel\'s workspace)');
+      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;
+      const triggerIdx = await choose('Trigger mode for this channel?', [
+        'mention — respond only when @mentioned (recommended)',
+        'all — respond to every message',
+      ]);
+      const triggerMode = triggerIdx === 0 ? 'mention' as const : 'all' as const;
+      const threadedReplies = await confirm('Reply in threads?', true);
+
+      channels.push({
+        id: channelId,
+        platform: 'slack',
+        bot: slackBotName,
+        workingDirectory: workDir,
+        triggerMode,
+        threadedReplies,
+      });
+      success('Added Slack channel');
+      addSlackChannels = await confirm('Add another Slack channel?', false);
     }
+  }
 
-    channels.push({
-      id: channelId,
-      name: channelName,
-      platform: 'mattermost',
-      bot: botName,
-      workingDirectory: workDir,
-    });
-    success(`Added channel${channelName ? ` "${channelName}"` : ''}`);
+  // --- Step 4: Defaults (skip in merge mode — existing config has them) ---
+  const defaults: ConfigDefaults = {};
 
-    addChannels = await confirm('Add another channel?', false);
-  }
+  if (!mergeMode) {
+    heading('Step 4: Defaults');
+    dim('These can be changed later in config.json or via chat commands.\n');
+
+    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];
+    }
 
-  if (channels.length === 0) {
-    info('No group channels configured. DMs will still work automatically.');
+    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 5: Defaults ---
-  heading('Step 5: Defaults');
-  dim('These can be changed later in config.json or via chat commands.\n');
+  // --- Step 5: Generate config ---
+  heading('Step 5: Generate Config');
 
-  const defaults: ConfigDefaults = {};
+  let finalConfig = buildConfig({ mmUrl: mmUrl || undefined, bots, channels, defaults, slackBots });
 
-  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];
+  // Merge with existing config if in merge mode
+  if (mergeMode && existingConfig) {
+    finalConfig = mergeConfig(existingConfig, finalConfig);
+    info('Merged new platform into existing config.');
   }
 
-  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);
+  if (configExists()) {
+    dim('Backing up existing config before writing...');
+  }
+  const configPath = writeConfig(finalConfig);
   success(`Config written to ${configPath}`);
 
   // Ensure workspaces dir exists
@@ -213,8 +415,8 @@ async function main() {
     fs.mkdirSync(workspacesDir, { recursive: true });
   }
 
-  // --- Step 7: Service setup ---
-  heading('Step 7: Service Setup (Optional)');
+  // --- Step 6: Service Setup (Optional) ---
+  heading('Step 6: Service Setup (Optional)');
 
   const osPlatform = detectPlatform();
   if (osPlatform === 'macos') {
@@ -235,7 +437,10 @@ async function main() {
   heading('✅ Setup Complete');
   blank();
   info(`Config: ${configPath}`);
-  info(`Bots: ${bots.map(b => b.name).join(', ')}`);
+  const allBotNames = [...bots.map(b => b.name), ...slackBots.map(b => b.name)];
+  info(`Bots: ${allBotNames.join(', ')}`);
+  const platforms = [useMattermost ? 'Mattermost' : null, useSlack ? 'Slack' : null].filter(Boolean);
+  info(`Platforms: ${platforms.join(', ')}`);
   if (channels.length > 0) info(`Channels: ${channels.length} configured`);
   info('DMs: enabled automatically');
   blank();

package/scripts/lib/config-gen.ts

@@ -12,6 +12,8 @@ export interface BotEntry {
   token: string;
   admin: boolean;
   agent?: string;
+  appToken?: string; // Slack Socket Mode app-level token
+  access?: { mode: 'allowlist' | 'blocklist' | 'open'; users?: string[] };
 }
 
 export interface ChannelEntry {
@@ -20,6 +22,8 @@ export interface ChannelEntry {
   platform: string;
   bot: string;
   workingDirectory: string;
+  triggerMode?: 'all' | 'mention';
+  threadedReplies?: boolean;
 }
 
 export interface ConfigDefaults {
@@ -31,9 +35,12 @@ export interface ConfigDefaults {
 
 export interface GeneratedConfig {
   platforms: {
-    mattermost: {
+    mattermost?: {
       url: string;
-      bots?: Record<string, { token: string; admin?: boolean; agent?: string }>;
+      bots?: Record<string, { token: string; admin?: boolean; agent?: string; access?: { mode: string; users: string[] } }>;
+    };
+    slack?: {
+      bots?: Record<string, { token: string; appToken: string; admin?: boolean; agent?: string; access?: { mode: string; users: string[] } }>;
     };
   };
   channels: Array<{
@@ -42,33 +49,51 @@ export interface GeneratedConfig {
     platform: string;
     bot?: string;
     workingDirectory: string;
+    triggerMode?: string;
+    threadedReplies?: boolean;
   }>;
   defaults?: ConfigDefaults;
 }
 
 export function buildConfig(opts: {
-  mmUrl: string;
+  mmUrl?: string;
   bots: BotEntry[];
   channels: ChannelEntry[];
   defaults?: ConfigDefaults;
+  slackBots?: BotEntry[];
 }): GeneratedConfig {
   const config: GeneratedConfig = {
-    platforms: {
-      mattermost: {
-        url: opts.mmUrl,
-      },
-    },
+    platforms: {},
     channels: [],
   };
 
-  // Always use named bots object (clearer schema, supports admin flag and multi-bot)
-  if (opts.bots.length > 0) {
+  // Mattermost platform
+  if (opts.mmUrl && opts.bots.length > 0) {
+    config.platforms.mattermost = { url: opts.mmUrl };
     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 } : {}),
+        ...(bot.access ? { access: bot.access } : {}),
+      };
+    }
+  }
+
+  // Slack platform
+  if (opts.slackBots && opts.slackBots.length > 0) {
+    config.platforms.slack = { bots: {} };
+    for (const bot of opts.slackBots) {
+      if (!bot.appToken) {
+        throw new Error(`Slack bot "${bot.name}" is missing required appToken`);
+      }
+      config.platforms.slack!.bots![bot.name] = {
+        token: bot.token,
+        appToken: bot.appToken,
+        ...(bot.admin ? { admin: true } : {}),
+        ...(bot.agent ? { agent: bot.agent } : {}),
+        ...(bot.access ? { access: bot.access } : {}),
       };
     }
   }
@@ -80,6 +105,8 @@ export function buildConfig(opts: {
       platform: ch.platform,
       bot: ch.bot,
       workingDirectory: ch.workingDirectory,
+      ...(ch.triggerMode ? { triggerMode: ch.triggerMode } : {}),
+      ...(ch.threadedReplies !== undefined ? { threadedReplies: ch.threadedReplies } : {}),
     });
   }
 
@@ -111,6 +138,14 @@ export function writeConfig(config: GeneratedConfig): string {
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 
   const configPath = getConfigPath();
+
+  // Back up existing config before overwriting
+  if (fs.existsSync(configPath)) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const backupPath = `${configPath}.${timestamp}.bak`;
+    fs.copyFileSync(configPath, backupPath);
+  }
+
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
   return configPath;
 }
@@ -124,3 +159,32 @@ export function readExistingConfig(): GeneratedConfig | null {
     return null;
   }
 }
+
+/**
+ * Merge a new platform's config into an existing config.
+ * Preserves all existing platforms, channels, and defaults.
+ */
+export function mergeConfig(existing: GeneratedConfig, addition: GeneratedConfig): GeneratedConfig {
+  const merged: GeneratedConfig = {
+    platforms: { ...existing.platforms },
+    channels: [...(existing.channels ?? [])],
+    defaults: existing.defaults ?? addition.defaults,
+  };
+
+  // Merge new platforms (don't overwrite existing ones)
+  for (const [name, config] of Object.entries(addition.platforms)) {
+    if (!merged.platforms[name as keyof typeof merged.platforms]) {
+      (merged.platforms as any)[name] = config;
+    }
+  }
+
+  // Append new channels (skip duplicates by id)
+  const existingIds = new Set(merged.channels.map(c => c.id));
+  for (const ch of addition.channels ?? []) {
+    if (!existingIds.has(ch.id)) {
+      merged.channels.push(ch);
+    }
+  }
+
+  return merged;
+}