@chrisromp/copilot-bridge 0.7.0 → 0.8.1

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;
+}

package/scripts/lib/prerequisites.ts

@@ -4,6 +4,9 @@
  */
 
 import { execSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import type { CheckResult } from './output.js';
 
 export function checkNodeVersion(): CheckResult {
@@ -64,16 +67,25 @@ export function checkGitHubAuth(): CheckResult {
     return { status: 'pass', label: 'GitHub authenticated', detail: 'via gh CLI' };
   }
 
-  // Check if Copilot CLI has stored credentials
-  const copilotAuth = tryCommand('copilot auth status 2>&1');
-  if (copilotAuth && !copilotAuth.includes('not logged in')) {
-    return { status: 'pass', label: 'GitHub authenticated', detail: 'via Copilot CLI' };
+  // Check if Copilot CLI has stored credentials (~/.copilot/config.json)
+  try {
+    const copilotConfig = join(homedir(), '.copilot', 'config.json');
+    if (existsSync(copilotConfig)) {
+      const data = JSON.parse(readFileSync(copilotConfig, 'utf-8'));
+      const users = data.logged_in_users;
+      if (Array.isArray(users) && users.length > 0) {
+        const login = users[0].login ?? 'unknown';
+        return { status: 'pass', label: 'GitHub authenticated', detail: `via Copilot CLI (${login})` };
+      }
+    }
+  } catch {
+    // Fall through
   }
 
   return {
     status: 'warn',
     label: 'GitHub authentication',
-    detail: 'no token found — set COPILOT_GITHUB_TOKEN, run gh auth login, or run copilot auth login',
+    detail: 'no token found — set COPILOT_GITHUB_TOKEN, run gh auth login, or run copilot login',
   };
 }
 

package/scripts/lib/prompts.ts

@@ -46,6 +46,10 @@ export async function confirm(question: string, defaultYes = true): Promise<bool
   return answer.toLowerCase().startsWith('y');
 }
 
+export async function pressEnter(message = 'Press Enter to continue...'): Promise<void> {
+  await ask(message);
+}
+
 export async function choose(question: string, options: string[], defaultIndex = 0): Promise<number> {
   console.log(`\n${question}`);
   for (let i = 0; i < options.length; i++) {

package/scripts/lib/service.ts

@@ -38,6 +38,10 @@ export function getSystemPath(): string {
   return `${nodeBinDir}:${basePath}`;
 }
 
+export function getLogPath(homePath: string): string {
+  return path.join(homePath, '.copilot-bridge', 'copilot-bridge.log');
+}
+
 // --- launchd (macOS) ---
 
 export interface LaunchdConfig {
@@ -49,6 +53,7 @@ export interface LaunchdConfig {
 export function generateLaunchdPlist(config: LaunchdConfig): string {
   const nodePath = getNodePath();
   const tsxPath = path.join(config.bridgePath, 'node_modules', '.bin', 'tsx');
+  const logPath = getLogPath(config.homePath);
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -83,11 +88,14 @@ export function generateLaunchdPlist(config: LaunchdConfig): string {
     <key>ThrottleInterval</key>
     <integer>10</integer>
 
+    <key>Umask</key>
+    <integer>63</integer>
+
     <key>StandardOutPath</key>
-    <string>/tmp/copilot-bridge.log</string>
+    <string>${logPath}</string>
 
     <key>StandardErrorPath</key>
-    <string>/tmp/copilot-bridge.log</string>
+    <string>${logPath}</string>
 </dict>
 </plist>`;
 }
@@ -111,6 +119,21 @@ export function installLaunchd(plistContent: string): { installed: boolean; path
   }
 }
 
+export function generateNewsyslogConfig(logPath: string, user: string): string {
+  let group = 'staff';
+  try { group = execSync('id -gn', { encoding: 'utf-8' }).trim(); } catch { /* default */ }
+  // N=no signal, C=create new file after rotation, Z=gzip compress
+  // Rotates at 10 MB, keeps 3 archives
+  return `# Copilot Bridge log rotation — installed by copilot-bridge install-service
+# logfilename  owner:group  mode  count  size(KB)  when  flags
+${logPath}  ${user}:${group}  600  3  10240  *  NCZ
+`;
+}
+
+export function getNewsyslogInstallPath(): string {
+  return '/etc/newsyslog.d/copilot-bridge.conf';
+}
+
 // --- systemd (Linux) ---
 
 export interface SystemdConfig {
@@ -129,12 +152,13 @@ After=network.target
 [Service]
 Type=simple
 User=${config.user}
-ExecStart=${nodePath} ${tsxPath} ${config.bridgePath}/dist/index.js
+ExecStart="${nodePath}" "${tsxPath}" "${config.bridgePath}/dist/index.js"
 WorkingDirectory=${config.bridgePath}
 Environment=HOME=${config.homePath}
 Environment=PATH=${getSystemPath()}
 Restart=always
 RestartSec=10
+UMask=0077
 
 [Install]
 WantedBy=multi-user.target`;

package/scripts/lib/slack.ts

@@ -0,0 +1,190 @@
+/**
+ * Slack setup helpers for the init wizard.
+ * Generates app manifests and validates tokens.
+ */
+
+/**
+ * Generate a Slack App Manifest for copilot-bridge.
+ * This pre-configures all required scopes, events, and Socket Mode.
+ */
+export function generateManifest(botName: string): object {
+  return {
+    display_information: {
+      name: botName,
+      description: 'GitHub Copilot bridge for Slack',
+      background_color: '#1a1a2e',
+    },
+    features: {
+      app_home: {
+        messages_tab_enabled: true,
+        messages_tab_read_only_enabled: false,
+      },
+      bot_user: {
+        display_name: botName,
+        always_online: true,
+      },
+    },
+    oauth_config: {
+      scopes: {
+        bot: [
+          'chat:write',
+          'chat:write.public',
+          'channels:history',
+          'channels:read',
+          'groups:read',
+          'groups:history',
+          'im:history',
+          'im:read',
+          'im:write',
+          'files:read',
+          'files:write',
+          'reactions:read',
+          'reactions:write',
+          'users:read',
+        ],
+      },
+    },
+    settings: {
+      event_subscriptions: {
+        bot_events: [
+          'message.channels',
+          'message.groups',
+          'message.im',
+          'reaction_added',
+          'reaction_removed',
+        ],
+      },
+      interactivity: {
+        is_enabled: false,
+      },
+      org_deploy_enabled: false,
+      socket_mode_enabled: true,
+      token_rotation_enabled: false,
+    },
+  };
+}
+
+/**
+ * Generate a URL that opens Slack's "Create App" page with the manifest pre-filled.
+ */
+export function generateManifestUrl(botName: string): string {
+  const manifest = generateManifest(botName);
+  const encoded = encodeURIComponent(JSON.stringify(manifest));
+  return `https://api.slack.com/apps?new_app=1&manifest_json=${encoded}`;
+}
+
+/**
+ * Validate a Slack bot token by calling auth.test.
+ * Returns bot info on success or null on failure.
+ */
+export async function validateSlackToken(token: string): Promise<{
+  ok: boolean;
+  userId?: string;
+  botName?: string;
+  teamName?: string;
+  error?: string;
+}> {
+  try {
+    const resp = await fetch('https://slack.com/api/auth.test', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+    });
+    if (!resp.ok) return { ok: false, error: `HTTP ${resp.status}` };
+
+    const data = await resp.json() as any;
+    if (!data.ok) return { ok: false, error: data.error };
+
+    return {
+      ok: true,
+      userId: data.user_id,
+      botName: data.user,
+      teamName: data.team,
+    };
+  } catch (err: any) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Validate a Slack app-level token by attempting a connections.open.
+ * This confirms Socket Mode will work.
+ */
+export async function validateAppToken(appToken: string): Promise<{
+  ok: boolean;
+  error?: string;
+}> {
+  try {
+    const resp = await fetch('https://slack.com/api/apps.connections.open', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${appToken}`,
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+    });
+    if (!resp.ok) return { ok: false, error: `HTTP ${resp.status}` };
+
+    const data = await resp.json() as any;
+    if (!data.ok) return { ok: false, error: data.error };
+
+    return { ok: true };
+  } catch (err: any) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Resolve a Slack username/handle to a user ID.
+ * Uses the users.list API with pagination to find a matching user.
+ * Handle is case-insensitive with leading @ stripped.
+ */
+export async function resolveSlackUser(botToken: string, handle: string): Promise<{
+  userId: string | null;
+  displayName?: string;
+  error?: string;
+}> {
+  const normalized = handle.replace(/^@/, '').toLowerCase();
+  let cursor: string | undefined;
+
+  try {
+    do {
+      const params = new URLSearchParams({ limit: '200' });
+      if (cursor) params.set('cursor', cursor);
+
+      const resp = await fetch(`https://slack.com/api/users.list?${params}`, {
+        headers: { 'Authorization': `Bearer ${botToken}` },
+      });
+      if (!resp.ok) return { userId: null, error: `HTTP ${resp.status}` };
+
+      const data = await resp.json() as any;
+      if (!data.ok) return { userId: null, error: data.error };
+
+      for (const member of data.members ?? []) {
+        if (member.deleted || member.is_bot) continue;
+        const name = (member.name ?? '').toLowerCase();
+        // Prefer unique handle (member.name) over display/real name for security
+        if (name === normalized) {
+          return { userId: member.id, displayName: member.profile?.display_name || member.real_name || member.name };
+        }
+      }
+
+      // Second pass: try display_name and real_name (less reliable, not unique)
+      for (const member of data.members ?? []) {
+        if (member.deleted || member.is_bot) continue;
+        const displayName = member.profile?.display_name_normalized?.toLowerCase() ?? '';
+        const realName = member.profile?.real_name_normalized?.toLowerCase() ?? '';
+        if (displayName === normalized || realName === normalized) {
+          return { userId: member.id, displayName: member.profile?.display_name || member.real_name || member.name };
+        }
+      }
+
+      cursor = data.response_metadata?.next_cursor || undefined;
+    } while (cursor);
+
+    return { userId: null, error: `User "${handle}" not found` };
+  } catch (err: any) {
+    return { userId: null, error: err.message };
+  }
+}

package/templates/admin/AGENTS.md

@@ -1,6 +1,6 @@
 # Admin Agent — copilot-bridge
 
-You are the **admin agent** for copilot-bridge, a service that bridges GitHub Copilot CLI to messaging platforms (e.g., Mattermost).
+You are the **admin agent** for copilot-bridge, a service that bridges GitHub Copilot CLI to messaging platforms (e.g., Mattermost, Slack).
 
 **Source repo**: https://github.com/ChrisRomp/copilot-bridge
 **Bridge config**: `~/.copilot-bridge/config.json` (resolution: `COPILOT_BRIDGE_CONFIG` env → `~/.copilot-bridge/config.json` → `cwd/config.json`)
@@ -12,7 +12,7 @@ You are a bot — use **it/its** pronouns when referring to yourself or other bo
 
 ## How You Communicate
 
-- You receive messages from a chat platform (Mattermost)
+- You receive messages from a chat platform (e.g., Mattermost, Slack)
 - Your responses are streamed back to the same channel
 - Slash commands (e.g., `/new`, `/model`, `/verbose`) are intercepted by the bridge — you won't see them
 - The user may be on mobile; keep responses concise when possible
@@ -181,9 +181,9 @@ A bridge restart is needed for removals to take effect.
 ## Bridge Architecture (Reference)
 
 ```
-Mattermost Channel → copilot-bridge → @github/copilot-sdk → Copilot CLI
-     ↑                                                          ↓
-     └──────────── streaming response (edit-in-place) ←─────────┘
+Chat Platform (Mattermost/Slack) → copilot-bridge → @github/copilot-sdk → Copilot CLI
+         ↑                                                                    ↓
+         └──────────── streaming response (edit-in-place) ←───────────────────┘
 ```
 
 - Each channel maps to a Copilot session with a working directory, model, and optional agent

package/templates/agents/AGENTS.md

@@ -14,7 +14,7 @@ You are a bot — use **it/its** pronouns when referring to yourself or other bo
 
 ## How You Communicate
 
-- You receive messages from a chat platform (Mattermost)
+- You receive messages from a chat platform (e.g., Mattermost, Slack)
 - Your responses are streamed back to the same channel
 - Slash commands (e.g., `/new`, `/model`, `/verbose`) are intercepted by the bridge — you won't see them
 - The user may be on mobile; keep responses concise when possible