comparing 9c84fca1ea91c06eb50f10584ee1def9ff7a449e and main on dunkirk.sh/irc-slack-bridge

+16 -1

.env.example

···

       2
       2
        
       SLACK_BOT_TOKEN=xoxb-your-bot-token-here

     

       3
       3
        
       SLACK_SIGNING_SECRET=your-signing-secret-here

     

       4
       4
        
       

     

       5
       5
       +
       # Slack workspace URL (for admin API calls)

     

       6
       6
       +
       SLACK_API_URL=https://hackclub.enterprise.slack.com

     

       7
       7
       +
       

     

       8
       8
       +
       # Optional: For channel manager permission checks

     

       9
       9
       +
       SLACK_USER_COOKIE=your-slack-cookie-here

     

       10
       10
       +
       SLACK_USER_TOKEN=your-user-token-here

     

       11
       11
       +
       

     

       12
       12
       +
       # Optional: Enable Cachet API for user lookups (recommended for better performance)

     

       13
       13
       +
       CACHET_ENABLED=true

     

       14
       14
       +
       

     

       5
       15
        
       # IRC Configuration

     

       6
       16
        
       IRC_NICK=slackbridge

     

       17
       17
       +
       NICKSERV_PASSWORD=your-nickserv-password-here

     

       18
       18
       +
       NICKSERV_EMAIL=your-email@example.com

     

       7
       19
        
       

     

       8
       20
        
       # Admin users (comma-separated Slack user IDs)

     

       9
       9
       -
       ADMINS=U1234567890

     

       21
       21
       +
       ADMINS=U1234567890,U0987654321

     

       22
       22
       +
       

     

       23
       23
       +
       # Hack Club CDN Token (for file uploads)

     

       24
       24
       +
       CDN_TOKEN=your-cdn-token-here

     

       10
       25
        
       

     

       11
       26
        
       # Server Configuration (optional)

     

       12
       27
        
       PORT=3000

+97 -3

README.md

···

       13
       13
        
       bun dev

     

       14
       14
        
       ```

     

       15
       15
        
       

     

       16
       16
       +
       To run tests:

     

       17
       17
       +
       ```bash

     

       18
       18
       +
       bun test

     

       19
       19
       +
       ```

     

       20
       20
       +
       

     

       16
       21
        
       ### Slack App Setup

     

       17
       22
        
       

     

       18
       23
        
       1. Go to [api.slack.com/apps](https://api.slack.com/apps) and create a new app

     
···

       31
       36
        
       SLACK_BOT_TOKEN=xoxb-your-bot-token-here

     

       32
       37
        
       SLACK_SIGNING_SECRET=your-signing-secret-here

     

       33
       38
        
       

     

       39
       39
       +
       # Slack workspace URL (for admin API calls)

     

       40
       40
       +
       SLACK_API_URL=https://hackclub.enterprise.slack.com

     

       41
       41
       +
       

     

       42
       42
       +
       # Optional: For channel manager permission checks

     

       43
       43
       +
       SLACK_USER_COOKIE=your-slack-cookie-here

     

       44
       44
       +
       SLACK_USER_TOKEN=your-user-token-here

     

       45
       45
       +
       

     

       46
       46
       +
       # Optional: Enable Cachet API for user lookups (recommended for better performance)

     

       47
       47
       +
       CACHET_ENABLED=true

     

       48
       48
       +
       

     

       34
       49
        
       # IRC Configuration

     

       35
       50
        
       IRC_NICK=slackbridge

     

       51
       51
       +
       NICKSERV_PASSWORD=your-nickserv-password-here

     

       52
       52
       +
       NICKSERV_EMAIL=your-email@example.com

     

       36
       53
        
       

     

       37
       54
        
       # Admin users (comma-separated Slack user IDs)

     

       38
       38
       -
       ADMINS=U1234567890

     

       55
       55
       +
       ADMINS=U1234567890,U0987654321

     

       56
       56
       +
       

     

       57
       57
       +
       # Hack Club CDN Token (for file uploads)

     

       58
       58
       +
       CDN_TOKEN=your-cdn-token-here

     

       39
       59
        
       

     

       40
       60
        
       # Server Configuration (optional)

     

       41
       61
        
       PORT=3000

     

       62
       62
       +
       

     

       63
       63
       +
       # Note: Channel and user mappings are now stored in the SQLite database (bridge.db)

     

       64
       64
       +
       # Use the API or database tools to manage mappings

     

       42
       65
        
       ```

     

       43
       66
        
       

     

       44
       67
        
       See `.env.example` for a template.

     

       45
       68
        
       

     

       69
       69
       +
       ### Slash Commands

     

       70
       70
       +
       

     

       71
       71
       +
       The bridge provides interactive slash commands for managing mappings:

     

       72
       72
       +
       

     

       73
       73
       +
       - `/irc-bridge-channel` - Bridge current Slack channel to an IRC channel

     

       74
       74
       +
       - `/irc-unbridge-channel` - Remove bridge from current channel

     

       75
       75
       +
       - `/irc-bridge-user` - Link your Slack account to an IRC nickname

     

       76
       76
       +
       - `/irc-unbridge-user` - Remove your IRC nickname link

     

       77
       77
       +
       - `/irc-bridge-list` - List all channel and user bridges

     

       78
       78
       +
       

     

       46
       79
        
       ### Managing Channel and User Mappings

     

       47
       80
        
       

     

       48
       81
        
       Channel and user mappings are stored in a SQLite database (`bridge.db`). You can manage them through:

     
···

       50
       83
        
       **Using Bun REPL:**

     

       51
       84
        
       ```bash

     

       52
       85
        
       bun repl

     

       53
       53
       -
       > import { channelMappings, userMappings } from "./src/db"

     

       86
       86
       +
       > import { channelMappings, userMappings } from "./src/lib/db"

     

       54
       87
        
       > channelMappings.create("C1234567890", "#general")

     

       55
       88
        
       > userMappings.create("U1234567890", "myircnick")

     

       56
       89
        
       > channelMappings.getAll()

     
···

       67
       100
        
       

     

       68
       101
        
       The bridge connects to `irc.hackclub.com:6667` (no TLS) and forwards messages bidirectionally based on channel mappings:

     

       69
       102
        
       

     

       103
       103
       +
       - **NickServ Authentication**: If `NICKSERV_PASSWORD` is configured, the bridge authenticates on connect

     

       104
       104
       +
         - Waits for NickServ confirmation before joining channels

     

       105
       105
       +
         - Auto-registers the nick if not registered (requires `NICKSERV_EMAIL`)

     

       106
       106
       +
         - Prevents "No external channel messages" errors by ensuring proper authentication

     

       70
       107
        
       - **IRC → Slack**: Messages from mapped IRC channels appear in their corresponding Slack channels

     

       108
       108
       +
         - Image URLs are automatically displayed as inline attachments

     

       109
       109
       +
         - IRC mentions (`@nick` or `nick:`) are converted to Slack mentions for mapped users

     

       110
       110
       +
         - IRC formatting codes are converted to Slack markdown

     

       111
       111
       +
         - IRC `/me` actions are displayed in a context block with the user's avatar

     

       112
       112
       +
         - Thread replies: Use `@xxxxx` (5-char thread ID) to reply to a Slack thread from IRC

     

       71
       113
        
       - **Slack → IRC**: Messages from mapped Slack channels are sent to their corresponding IRC channels

     

       72
       72
       -
       - User mappings allow custom IRC nicknames for specific Slack users

     

       114
       114
       +
         - User display names: Uses name from Slack event if available, otherwise Cachet API (if `CACHET_ENABLED=true`), then Slack API fallback

     

       115
       115
       +
         - All lookups are cached locally (1 hour TTL) to reduce API calls

     

       116
       116
       +
         - Slack mentions are converted to mapped IRC nicks, or looked up via the above priority

     

       117
       117
       +
         - Slack markdown is converted to IRC formatting codes

     

       118
       118
       +
         - File attachments are uploaded to Hack Club CDN and URLs are shared

     

       119
       119
       +
         - Thread messages are prefixed with `@xxxxx` (5-char thread ID) to show they're part of a thread

     

       120
       120
       +
         - First reply in a thread includes a quote of the parent message

     

       121
       121
       +
       - **User mappings** allow custom IRC nicknames for specific Slack users and enable proper mentions both ways

     

       122
       122
       +
       - **Permissions**: Only channel creators, channel managers, or global admins can bridge/unbridge channels

     

       123
       123
       +
       

     

       124
       124
       +
       #### Thread Support

     

       125
       125
       +
       

     

       126
       126
       +
       The bridge supports Slack threads with a simple IRC-friendly syntax:

     

       127
       127
       +
       

     

       128
       128
       +
       - **Slack → IRC**: Thread messages appear with a `@xxxxx` prefix (5-character thread ID)

     

       129
       129
       +
         - First reply in a thread includes a quote: `<user> @xxxxx > original message`

     

       130
       130
       +
         - Subsequent replies: `<user> @xxxxx message text`

     

       131
       131
       +
       - **IRC → Slack**: Reply to a thread by including the thread ID in your message

     

       132
       132
       +
         - Example: `@abc12 this is my reply`

     

       133
       133
       +
         - The bridge removes the `@xxxxx` prefix and sends your message to the correct thread

     

       134
       134
       +
         - Thread IDs are unique per thread and persist across restarts (stored in SQLite)

     

       73
       135
        
       

     

       74
       136
        
       The bridge ignores its own messages and bot messages to prevent loops.

     

       137
       137
       +
       

     

       138
       138
       +
       ### Architecture

     

       139
       139
       +
       

     

       140
       140
       +
       The bridge consists of several modules:

     

       141
       141
       +
       

     

       142
       142
       +
       - **`src/index.ts`** - Main application entry point with IRC/Slack event handlers

     

       143
       143
       +
       - **`src/commands.ts`** - Slash command handlers for managing bridges

     

       144
       144
       +
       - **`src/lib/db.ts`** - SQLite database layer for channel/user/thread mappings

     

       145
       145
       +
       - **`src/lib/parser.ts`** - Bidirectional message formatting conversion (IRC ↔ Slack)

     

       146
       146
       +
       - **`src/lib/mentions.ts`** - User mention conversion with Cachet integration

     

       147
       147
       +
       - **`src/lib/threads.ts`** - Thread tracking and ID generation

     

       148
       148
       +
       - **`src/lib/user-cache.ts`** - Cached Slack user info lookups (1-hour TTL)

     

       149
       149
       +
       - **`src/lib/permissions.ts`** - Channel management permission checks

     

       150
       150
       +
       - **`src/lib/avatars.ts`** - Stable avatar URL generation for IRC users

     

       151
       151
       +
       - **`src/lib/cdn.ts`** - File upload integration with Hack Club CDN

     

       152
       152
       +
       - **`src/lib/cachet.ts`** - User profile lookups from Cachet API

     

       153
       153
       +
       

     

       154
       154
       +
       ### Testing

     

       155
       155
       +
       

     

       156
       156
       +
       The project includes comprehensive unit tests covering all core functionality:

     

       157
       157
       +
       

     

       158
       158
       +
       ```bash

     

       159
       159
       +
       bun test

     

       160
       160
       +
       ```

     

       161
       161
       +
       

     

       162
       162
       +
       Tests cover:

     

       163
       163
       +
       - Message format parsing (IRC ↔ Slack)

     

       164
       164
       +
       - User mention conversion

     

       165
       165
       +
       - Thread ID generation and tracking

     

       166
       166
       +
       - User info caching

     

       167
       167
       +
       - Database operations

     

       168
       168
       +
       - Avatar generation

     

       75
       169
        
       

     

       76
       170
        
       If you want to report an issue the main repo is [the tangled repo](https://tangled.org/dunkirk.sh/irc-slack-bridge) and the github is just a mirror.

     

       77
       171

+37

biome.json

···

       1
       1
       +
       {

     

       2
       2
       +
       	"$schema": "https://biomejs.dev/schemas/2.3.5/schema.json",

     

       3
       3
       +
       	"vcs": {

     

       4
       4
       +
       		"enabled": true,

     

       5
       5
       +
       		"clientKind": "git",

     

       6
       6
       +
       		"useIgnoreFile": true

     

       7
       7
       +
       	},

     

       8
       8
       +
       	"files": {

     

       9
       9
       +
       		"ignoreUnknown": false

     

       10
       10
       +
       	},

     

       11
       11
       +
       	"formatter": {

     

       12
       12
       +
       		"enabled": true,

     

       13
       13
       +
       		"indentStyle": "tab"

     

       14
       14
       +
       	},

     

       15
       15
       +
       	"linter": {

     

       16
       16
       +
       		"enabled": true,

     

       17
       17
       +
       		"rules": {

     

       18
       18
       +
       			"recommended": true,

     

       19
       19
       +
       			"suspicious": {

     

       20
       20
       +
       				"noControlCharactersInRegex": "off"

     

       21
       21
       +
       			}

     

       22
       22
       +
       		}

     

       23
       23
       +
       	},

     

       24
       24
       +
       	"javascript": {

     

       25
       25
       +
       		"formatter": {

     

       26
       26
       +
       			"quoteStyle": "double"

     

       27
       27
       +
       		}

     

       28
       28
       +
       	},

     

       29
       29
       +
       	"assist": {

     

       30
       30
       +
       		"enabled": true,

     

       31
       31
       +
       		"actions": {

     

       32
       32
       +
       			"source": {

     

       33
       33
       +
       				"organizeImports": "on"

     

       34
       34
       +
       			}

     

       35
       35
       +
       		}

     

       36
       36
       +
       	}

     

       37
       37
       +
       }

+21 -21

package.json

···

       1
       1
        
       {

     

       2
       2
       -
         "name": "irc-slack-bridge",

     

       3
       3
       -
         "version": "0.0.1",

     

       4
       4
       -
         "module": "src/index.ts",

     

       5
       5
       -
         "type": "module",

     

       6
       6
       -
         "private": true,

     

       7
       7
       -
         "scripts": {

     

       8
       8
       -
           "dev": "bun src/index.ts",

     

       9
       9
       -
           "start": "bun src/index.ts",

     

       10
       10
       -
           "ngrok": "ngrok http 3000 --domain casual-renewing-reptile.ngrok-free.app"

     

       11
       11
       -
         },

     

       12
       12
       -
         "devDependencies": {

     

       13
       13
       -
           "@types/bun": "latest",

     

       14
       14
       -
           "@types/irc": "^0.5.4"

     

       15
       15
       -
         },

     

       16
       16
       -
         "peerDependencies": {

     

       17
       17
       -
           "typescript": "^5"

     

       18
       18
       -
         },

     

       19
       19
       -
         "dependencies": {

     

       20
       20
       -
           "irc": "^0.5.2",

     

       21
       21
       -
           "slack-edge": "^1.3.12"

     

       22
       22
       -
         }

     

       2
       2
       +
       	"name": "irc-slack-bridge",

     

       3
       3
       +
       	"version": "0.0.1",

     

       4
       4
       +
       	"module": "src/index.ts",

     

       5
       5
       +
       	"type": "module",

     

       6
       6
       +
       	"private": true,

     

       7
       7
       +
       	"scripts": {

     

       8
       8
       +
       		"dev": "bun src/index.ts",

     

       9
       9
       +
       		"start": "bun src/index.ts",

     

       10
       10
       +
       		"ngrok": "ngrok http 3000 --domain casual-renewing-reptile.ngrok-free.app"

     

       11
       11
       +
       	},

     

       12
       12
       +
       	"devDependencies": {

     

       13
       13
       +
       		"@types/bun": "latest",

     

       14
       14
       +
       		"@types/irc": "^0.5.4"

     

       15
       15
       +
       	},

     

       16
       16
       +
       	"peerDependencies": {

     

       17
       17
       +
       		"typescript": "^5"

     

       18
       18
       +
       	},

     

       19
       19
       +
       	"dependencies": {

     

       20
       20
       +
       		"irc": "^0.5.2",

     

       21
       21
       +
       		"slack-edge": "^1.3.12"

     

       22
       22
       +
       	}

     

       23
       23
        
       }

+5 -1

slack-manifest.yaml

···

       19
       19
        
           - command: /irc-bridge-user

     

       20
       20
        
             url: https://casual-renewing-reptile.ngrok-free.app/slack

     

       21
       21
        
             description: Link your Slack account to an IRC nickname

     

       22
       22
       -
             usage_hint: "irc-nick"

     

       22
       22
       +
             usage_hint: irc-nick

     

       23
       23
        
             should_escape: true

     

       24
       24
        
           - command: /irc-unbridge-user

     

       25
       25
        
             url: https://casual-renewing-reptile.ngrok-free.app/slack

     
···

       40
       40
        
             - chat:write.public

     

       41
       41
        
             - chat:write.customize

     

       42
       42
        
             - commands

     

       43
       43
       +
             - files:read

     

       43
       44
        
             - groups:read

     

       44
       45
        
             - groups:write

     

       45
       46
        
             - mpim:write

     
···

       50
       51
        
           request_url: https://casual-renewing-reptile.ngrok-free.app/slack

     

       51
       52
        
           bot_events:

     

       52
       53
        
             - message.channels

     

       54
       54
       +
         interactivity:

     

       55
       55
       +
           is_enabled: true

     

       56
       56
       +
           request_url: https://casual-renewing-reptile.ngrok-free.app/slack

     

       53
       57
        
         org_deploy_enabled: false

     

       54
       58
        
         socket_mode_enabled: false

     

       55
       59
        
         token_rotation_enabled: false

+96

src/commands.test.ts

···

       1
       1
       +
       import { describe, expect, test, beforeEach } from "bun:test";

     

       2
       2
       +
       import { channelMappings, userMappings } from "./lib/db";

     

       3
       3
       +
       

     

       4
       4
       +
       describe("channel mappings uniqueness", () => {

     

       5
       5
       +
       	beforeEach(() => {

     

       6
       6
       +
       		// Clean up mappings before each test

     

       7
       7
       +
       		const channels = channelMappings.getAll();

     

       8
       8
       +
       		for (const channel of channels) {

     

       9
       9
       +
       			channelMappings.delete(channel.slack_channel_id);

     

       10
       10
       +
       		}

     

       11
       11
       +
       	});

     

       12
       12
       +
       

     

       13
       13
       +
       	test("prevents duplicate IRC channel mappings", () => {

     

       14
       14
       +
       		channelMappings.create("C001", "#test");

     

       15
       15
       +
       		

     

       16
       16
       +
       		const existing = channelMappings.getByIrcChannel("#test");

     

       17
       17
       +
       		expect(existing).not.toBeNull();

     

       18
       18
       +
       		expect(existing?.slack_channel_id).toBe("C001");

     

       19
       19
       +
       

     

       20
       20
       +
       		// Trying to map a different Slack channel to the same IRC channel should be prevented

     

       21
       21
       +
       		const duplicate = channelMappings.getByIrcChannel("#test");

     

       22
       22
       +
       		expect(duplicate).not.toBeNull();

     

       23
       23
       +
       		expect(duplicate?.slack_channel_id).toBe("C001");

     

       24
       24
       +
       	});

     

       25
       25
       +
       

     

       26
       26
       +
       	test("prevents duplicate Slack channel mappings", () => {

     

       27
       27
       +
       		channelMappings.create("C001", "#test");

     

       28
       28
       +
       		

     

       29
       29
       +
       		const existing = channelMappings.getBySlackChannel("C001");

     

       30
       30
       +
       		expect(existing).not.toBeNull();

     

       31
       31
       +
       		expect(existing?.irc_channel).toBe("#test");

     

       32
       32
       +
       

     

       33
       33
       +
       		// The same Slack channel should keep its original mapping

     

       34
       34
       +
       		channelMappings.create("C001", "#new");

     

       35
       35
       +
       		const updated = channelMappings.getBySlackChannel("C001");

     

       36
       36
       +
       		expect(updated?.irc_channel).toBe("#new");

     

       37
       37
       +
       	});

     

       38
       38
       +
       

     

       39
       39
       +
       	test("allows different channels to map to different IRC channels", () => {

     

       40
       40
       +
       		channelMappings.create("C001", "#test1");

     

       41
       41
       +
       		channelMappings.create("C002", "#test2");

     

       42
       42
       +
       

     

       43
       43
       +
       		const mapping1 = channelMappings.getBySlackChannel("C001");

     

       44
       44
       +
       		const mapping2 = channelMappings.getBySlackChannel("C002");

     

       45
       45
       +
       

     

       46
       46
       +
       		expect(mapping1?.irc_channel).toBe("#test1");

     

       47
       47
       +
       		expect(mapping2?.irc_channel).toBe("#test2");

     

       48
       48
       +
       	});

     

       49
       49
       +
       });

     

       50
       50
       +
       

     

       51
       51
       +
       describe("user mappings uniqueness", () => {

     

       52
       52
       +
       	beforeEach(() => {

     

       53
       53
       +
       		// Clean up mappings before each test

     

       54
       54
       +
       		const users = userMappings.getAll();

     

       55
       55
       +
       		for (const user of users) {

     

       56
       56
       +
       			userMappings.delete(user.slack_user_id);

     

       57
       57
       +
       		}

     

       58
       58
       +
       	});

     

       59
       59
       +
       

     

       60
       60
       +
       	test("prevents duplicate IRC nick mappings", () => {

     

       61
       61
       +
       		userMappings.create("U001", "testnick");

     

       62
       62
       +
       		

     

       63
       63
       +
       		const existing = userMappings.getByIrcNick("testnick");

     

       64
       64
       +
       		expect(existing).not.toBeNull();

     

       65
       65
       +
       		expect(existing?.slack_user_id).toBe("U001");

     

       66
       66
       +
       

     

       67
       67
       +
       		// Trying to map a different Slack user to the same IRC nick should be prevented

     

       68
       68
       +
       		const duplicate = userMappings.getByIrcNick("testnick");

     

       69
       69
       +
       		expect(duplicate).not.toBeNull();

     

       70
       70
       +
       		expect(duplicate?.slack_user_id).toBe("U001");

     

       71
       71
       +
       	});

     

       72
       72
       +
       

     

       73
       73
       +
       	test("prevents duplicate Slack user mappings", () => {

     

       74
       74
       +
       		userMappings.create("U001", "testnick");

     

       75
       75
       +
       		

     

       76
       76
       +
       		const existing = userMappings.getBySlackUser("U001");

     

       77
       77
       +
       		expect(existing).not.toBeNull();

     

       78
       78
       +
       		expect(existing?.irc_nick).toBe("testnick");

     

       79
       79
       +
       

     

       80
       80
       +
       		// The same Slack user should keep its original mapping

     

       81
       81
       +
       		userMappings.create("U001", "newnick");

     

       82
       82
       +
       		const updated = userMappings.getBySlackUser("U001");

     

       83
       83
       +
       		expect(updated?.irc_nick).toBe("newnick");

     

       84
       84
       +
       	});

     

       85
       85
       +
       

     

       86
       86
       +
       	test("allows different users to map to different IRC nicks", () => {

     

       87
       87
       +
       		userMappings.create("U001", "nick1");

     

       88
       88
       +
       		userMappings.create("U002", "nick2");

     

       89
       89
       +
       

     

       90
       90
       +
       		const mapping1 = userMappings.getBySlackUser("U001");

     

       91
       91
       +
       		const mapping2 = userMappings.getBySlackUser("U002");

     

       92
       92
       +
       

     

       93
       93
       +
       		expect(mapping1?.irc_nick).toBe("nick1");

     

       94
       94
       +
       		expect(mapping2?.irc_nick).toBe("nick2");

     

       95
       95
       +
       	});

     

       96
       96
       +
       });

+502 -120

src/commands.ts

···

       1
       1
       -
       import { channelMappings, userMappings } from "./db";

     

       2
       2
       -
       import { slackApp, ircClient } from "./index";

     

       1
       1
       +
       import type { AnyMessageBlock } from "slack-edge";

     

       2
       2
       +
       import { ircClient, slackApp } from "./index";

     

       3
       3
       +
       import { channelMappings, userMappings } from "./lib/db";

     

       4
       4
       +
       import { canManageChannel } from "./lib/permissions";

     

       3
       5
        
       

     

       4
       6
        
       export function registerCommands() {

     

       5
       5
       -
         // Link Slack channel to IRC channel

     

       6
       6
       -
         slackApp.command("/irc-bridge-channel", async ({ payload, context }) => {

     

       7
       7
       -
           const args = payload.text.trim().split(/\s+/);

     

       8
       8
       -
           const ircChannel = args[0];

     

       7
       7
       +
       	// Link Slack channel to IRC channel

     

       8
       8
       +
       	slackApp.command("/irc-bridge-channel", async ({ payload, context }) => {

     

       9
       9
       +
       		context.respond({

     

       10
       10
       +
       			response_type: "ephemeral",

     

       11
       11
       +
       			text: "Bridge channel command received",

     

       12
       12
       +
       			blocks: [

     

       13
       13
       +
       				{

     

       14
       14
       +
       					type: "input",

     

       15
       15
       +
       					block_id: "irc_channel_input",

     

       16
       16
       +
       					element: {

     

       17
       17
       +
       						type: "plain_text_input",

     

       18
       18
       +
       						action_id: "irc_channel",

     

       19
       19
       +
       						placeholder: {

     

       20
       20
       +
       							type: "plain_text",

     

       21
       21
       +
       							text: "#lounge",

     

       22
       22
       +
       						},

     

       23
       23
       +
       					},

     

       24
       24
       +
       					label: {

     

       25
       25
       +
       						type: "plain_text",

     

       26
       26
       +
       						text: "IRC Channel",

     

       27
       27
       +
       					},

     

       28
       28
       +
       				},

     

       29
       29
       +
       				{

     

       30
       30
       +
       					type: "actions",

     

       31
       31
       +
       					elements: [

     

       32
       32
       +
       						{

     

       33
       33
       +
       							type: "button",

     

       34
       34
       +
       							text: {

     

       35
       35
       +
       								type: "plain_text",

     

       36
       36
       +
       								text: "Bridge Channel",

     

       37
       37
       +
       							},

     

       38
       38
       +
       							style: "primary",

     

       39
       39
       +
       							action_id: "bridge_channel_submit",

     

       40
       40
       +
       							value: payload.channel_id,

     

       41
       41
       +
       						},

     

       42
       42
       +
       						{

     

       43
       43
       +
       							type: "button",

     

       44
       44
       +
       							text: {

     

       45
       45
       +
       								type: "plain_text",

     

       46
       46
       +
       								text: "Cancel",

     

       47
       47
       +
       							},

     

       48
       48
       +
       							action_id: "cancel",

     

       49
       49
       +
       						},

     

       50
       50
       +
       					],

     

       51
       51
       +
       				},

     

       52
       52
       +
       			],

     

       53
       53
       +
       			replace_original: true,

     

       54
       54
       +
       		});

     

       55
       55
       +
       	});

     

       9
       56
        
       

     

       10
       10
       -
           if (!ircChannel || !ircChannel.startsWith("#")) {

     

       11
       11
       -
             return {

     

       12
       12
       -
               text: "Usage: `/irc-bridge-channel #irc-channel`\nExample: `/irc-bridge-channel #lounge`",

     

       13
       13
       -
             };

     

       14
       14
       -
           }

     

       57
       57
       +
       	// Handle bridge channel submission

     

       58
       58
       +
       	slackApp.action("bridge_channel_submit", async ({ payload, context }) => {

     

       59
       59
       +
       		const stateValues = payload.state?.values;

     

       60
       60
       +
       		const ircChannel = stateValues?.irc_channel_input?.irc_channel?.value;

     

       61
       61
       +
       		// @ts-expect-error

     

       62
       62
       +
       		const slackChannelId = payload.actions?.[0]?.value;

     

       63
       63
       +
       		const userId = payload.user?.id;

     

       15
       64
        
       

     

       16
       16
       -
           const slackChannelId = payload.channel_id;

     

       65
       65
       +
       		if (!context.respond) {

     

       66
       66
       +
       			return;

     

       67
       67
       +
       		}

     

       17
       68
        
       

     

       18
       18
       -
           try {

     

       19
       19
       -
             // Create the mapping

     

       20
       20
       -
             channelMappings.create(slackChannelId, ircChannel);

     

       69
       69
       +
       		if (!ircChannel || !ircChannel.startsWith("#")) {

     

       70
       70
       +
       			context.respond({

     

       71
       71
       +
       				response_type: "ephemeral",

     

       72
       72
       +
       				text: "❌ IRC channel must start with #",

     

       73
       73
       +
       				replace_original: true,

     

       74
       74
       +
       			});

     

       75
       75
       +
       			return;

     

       76
       76
       +
       		}

     

       21
       77
        
       

     

       22
       22
       -
             // Join the IRC channel

     

       23
       23
       -
             ircClient.join(ircChannel);

     

       78
       78
       +
       		// Check if user has permission to manage this channel

     

       79
       79
       +
       		if (!userId || !(await canManageChannel(userId, slackChannelId))) {

     

       80
       80
       +
       			context.respond({

     

       81
       81
       +
       				response_type: "ephemeral",

     

       82
       82
       +
       				text: "❌ You don't have permission to manage this channel. You must be the channel creator, a channel manager, or an admin.",

     

       83
       83
       +
       				replace_original: true,

     

       84
       84
       +
       			});

     

       85
       85
       +
       			return;

     

       86
       86
       +
       		}

     

       24
       87
        
       

     

       25
       25
       -
             // Join the Slack channel if not already in it

     

       26
       26
       -
             await context.client.conversations.join({

     

       27
       27
       -
               channel: slackChannelId,

     

       28
       28
       -
             });

     

       88
       88
       +
       		try {

     

       89
       89
       +
       			// Check if IRC channel is already linked

     

       90
       90
       +
       			const existingIrcMapping = channelMappings.getByIrcChannel(ircChannel);

     

       91
       91
       +
       			if (existingIrcMapping) {

     

       92
       92
       +
       				context.respond({

     

       93
       93
       +
       					response_type: "ephemeral",

     

       94
       94
       +
       					text: `❌ IRC channel ${ircChannel} is already bridged to <#${existingIrcMapping.slack_channel_id}>`,

     

       95
       95
       +
       					replace_original: true,

     

       96
       96
       +
       				});

     

       97
       97
       +
       				return;

     

       98
       98
       +
       			}

     

       29
       99
        
       

     

       30
       30
       -
             return {

     

       31
       31
       -
               text: `✅ Successfully bridged this channel to ${ircChannel}`,

     

       32
       32
       -
             };

     

       33
       33
       -
           } catch (error) {

     

       34
       34
       -
             console.error("Error creating channel mapping:", error);

     

       35
       35
       -
             return {

     

       36
       36
       -
               text: `❌ Failed to bridge channel: ${error}`,

     

       37
       37
       -
             };

     

       38
       38
       -
           }

     

       39
       39
       -
         });

     

       100
       100
       +
       			// Check if Slack channel is already linked

     

       101
       101
       +
       			const existingSlackMapping = channelMappings.getBySlackChannel(slackChannelId);

     

       102
       102
       +
       			if (existingSlackMapping) {

     

       103
       103
       +
       				context.respond({

     

       104
       104
       +
       					response_type: "ephemeral",

     

       105
       105
       +
       					text: `❌ This channel is already bridged to ${existingSlackMapping.irc_channel}`,

     

       106
       106
       +
       					replace_original: true,

     

       107
       107
       +
       				});

     

       108
       108
       +
       				return;

     

       109
       109
       +
       			}

     

       40
       110
        
       

     

       41
       41
       -
         // Unlink Slack channel from IRC

     

       42
       42
       -
         slackApp.command("/irc-unbridge-channel", async ({ payload }) => {

     

       43
       43
       -
           const slackChannelId = payload.channel_id;

     

       111
       111
       +
       			channelMappings.create(slackChannelId, ircChannel);

     

       112
       112
       +
       			ircClient.join(ircChannel);

     

       44
       113
        
       

     

       45
       45
       -
           try {

     

       46
       46
       -
             const mapping = channelMappings.getBySlackChannel(slackChannelId);

     

       47
       47
       -
             if (!mapping) {

     

       48
       48
       -
               return {

     

       49
       49
       -
                 text: "❌ This channel is not bridged to IRC",

     

       50
       50
       -
               };

     

       51
       51
       -
             }

     

       114
       114
       +
       			await context.client.conversations.join({

     

       115
       115
       +
       				channel: slackChannelId,

     

       116
       116
       +
       			});

     

       52
       117
        
       

     

       53
       53
       -
             channelMappings.delete(slackChannelId);

     

       118
       118
       +
       			console.log(

     

       119
       119
       +
       				`Created channel mapping: ${slackChannelId} -> ${ircChannel}`,

     

       120
       120
       +
       			);

     

       54
       121
        
       

     

       55
       55
       -
             return {

     

       56
       56
       -
               text: `✅ Removed bridge to ${mapping.irc_channel}`,

     

       57
       57
       -
             };

     

       58
       58
       -
           } catch (error) {

     

       59
       59
       -
             console.error("Error removing channel mapping:", error);

     

       60
       60
       -
             return {

     

       61
       61
       -
               text: `❌ Failed to remove bridge: ${error}`,

     

       62
       62
       -
             };

     

       63
       63
       -
           }

     

       64
       64
       -
         });

     

       122
       122
       +
       			context.respond({

     

       123
       123
       +
       				response_type: "ephemeral",

     

       124
       124
       +
       				text: `✅ Successfully bridged <#${slackChannelId}> to ${ircChannel}`,

     

       125
       125
       +
       				replace_original: true,

     

       126
       126
       +
       			});

     

       127
       127
       +
       		} catch (error) {

     

       128
       128
       +
       			console.error("Error creating channel mapping:", error);

     

       129
       129
       +
       			context.respond({

     

       130
       130
       +
       				response_type: "ephemeral",

     

       131
       131
       +
       				text: `❌ Failed to bridge channel: ${error}`,

     

       132
       132
       +
       				replace_original: true,

     

       133
       133
       +
       			});

     

       134
       134
       +
       		}

     

       135
       135
       +
       	});

     

       65
       136
        
       

     

       66
       66
       -
         // Link Slack user to IRC nick

     

       67
       67
       -
         slackApp.command("/irc-bridge-user", async ({ payload }) => {

     

       68
       68
       -
           const args = payload.text.trim().split(/\s+/);

     

       69
       69
       -
           const ircNick = args[0];

     

       137
       137
       +
       	// Unlink Slack channel from IRC

     

       138
       138
       +
       	slackApp.command("/irc-unbridge-channel", async ({ payload, context }) => {

     

       139
       139
       +
       		const slackChannelId = payload.channel_id;

     

       140
       140
       +
       		const userId = payload.user_id;

     

       141
       141
       +
       		const mapping = channelMappings.getBySlackChannel(slackChannelId);

     

       70
       142
        
       

     

       71
       71
       -
           if (!ircNick) {

     

       72
       72
       -
             return {

     

       73
       73
       -
               text: "Usage: `/irc-bridge-user <irc-nick>`\nExample: `/irc-bridge-user myircnick`",

     

       74
       74
       -
             };

     

       75
       75
       -
           }

     

       143
       143
       +
       		if (!mapping) {

     

       144
       144
       +
       			context.respond({

     

       145
       145
       +
       				response_type: "ephemeral",

     

       146
       146
       +
       				text: "❌ This channel is not bridged to IRC",

     

       147
       147
       +
       			});

     

       148
       148
       +
       			return;

     

       149
       149
       +
       		}

     

       76
       150
        
       

     

       77
       77
       -
           const slackUserId = payload.user_id;

     

       151
       151
       +
       		// Check if user has permission to manage this channel

     

       152
       152
       +
       		if (!(await canManageChannel(userId, slackChannelId))) {

     

       153
       153
       +
       			context.respond({

     

       154
       154
       +
       				response_type: "ephemeral",

     

       155
       155
       +
       				text: "❌ You don't have permission to manage this channel. You must be the channel creator, a channel manager, or an admin.",

     

       156
       156
       +
       			});

     

       157
       157
       +
       			return;

     

       158
       158
       +
       		}

     

       78
       159
        
       

     

       79
       79
       -
           try {

     

       80
       80
       -
             userMappings.create(slackUserId, ircNick);

     

       81
       81
       -
             console.log(`Created user mapping: ${slackUserId} -> ${ircNick}`);

     

       160
       160
       +
       		context.respond({

     

       161
       161
       +
       			response_type: "ephemeral",

     

       162
       162
       +
       			text: `Are you sure you want to remove the bridge to *${mapping.irc_channel}*?`,

     

       163
       163
       +
       			blocks: [

     

       164
       164
       +
       				{

     

       165
       165
       +
       					type: "section",

     

       166
       166
       +
       					text: {

     

       167
       167
       +
       						type: "mrkdwn",

     

       168
       168
       +
       						text: `Are you sure you want to remove the bridge to *${mapping.irc_channel}*?`,

     

       169
       169
       +
       					},

     

       170
       170
       +
       				},

     

       171
       171
       +
       				{

     

       172
       172
       +
       					type: "actions",

     

       173
       173
       +
       					elements: [

     

       174
       174
       +
       						{

     

       175
       175
       +
       							type: "button",

     

       176
       176
       +
       							text: {

     

       177
       177
       +
       								type: "plain_text",

     

       178
       178
       +
       								text: "Remove Bridge",

     

       179
       179
       +
       							},

     

       180
       180
       +
       							style: "danger",

     

       181
       181
       +
       							action_id: "unbridge_channel_confirm",

     

       182
       182
       +
       							value: slackChannelId,

     

       183
       183
       +
       						},

     

       184
       184
       +
       						{

     

       185
       185
       +
       							type: "button",

     

       186
       186
       +
       							text: {

     

       187
       187
       +
       								type: "plain_text",

     

       188
       188
       +
       								text: "Cancel",

     

       189
       189
       +
       							},

     

       190
       190
       +
       							action_id: "cancel",

     

       191
       191
       +
       						},

     

       192
       192
       +
       					],

     

       193
       193
       +
       				},

     

       194
       194
       +
       			],

     

       195
       195
       +
       		});

     

       196
       196
       +
       	});

     

       82
       197
        
       

     

       83
       83
       -
             return {

     

       84
       84
       -
               text: `✅ Successfully linked your account to IRC nick: ${ircNick}`,

     

       85
       85
       -
             };

     

       86
       86
       -
           } catch (error) {

     

       87
       87
       -
             console.error("Error creating user mapping:", error);

     

       88
       88
       -
             return {

     

       89
       89
       -
               text: `❌ Failed to link user: ${error}`,

     

       90
       90
       -
             };

     

       91
       91
       -
           }

     

       92
       92
       -
         });

     

       198
       198
       +
       	// Handle unbridge confirmation

     

       199
       199
       +
       	slackApp.action("unbridge_channel_confirm", async ({ payload, context }) => {

     

       200
       200
       +
       		// @ts-expect-error

     

       201
       201
       +
       		const slackChannelId = payload.actions?.[0]?.value;

     

       202
       202
       +
       		if (!context.respond) return;

     

       93
       203
        
       

     

       94
       94
       -
         // Unlink Slack user from IRC

     

       95
       95
       -
         slackApp.command("/irc-unbridge-user", async ({ payload }) => {

     

       96
       96
       -
           const slackUserId = payload.user_id;

     

       204
       204
       +
       		try {

     

       205
       205
       +
       			const mapping = channelMappings.getBySlackChannel(slackChannelId);

     

       206
       206
       +
       			if (!mapping) {

     

       207
       207
       +
       				context.respond({

     

       208
       208
       +
       					response_type: "ephemeral",

     

       209
       209
       +
       					text: "❌ This channel is not bridged to IRC",

     

       210
       210
       +
       					replace_original: true,

     

       211
       211
       +
       				});

     

       212
       212
       +
       				return;

     

       213
       213
       +
       			}

     

       97
       214
        
       

     

       98
       98
       -
           try {

     

       99
       99
       -
             const mapping = userMappings.getBySlackUser(slackUserId);

     

       100
       100
       -
             if (!mapping) {

     

       101
       101
       -
               return {

     

       102
       102
       -
                 text: "❌ You don't have an IRC nick mapping",

     

       103
       103
       -
               };

     

       104
       104
       -
             }

     

       215
       215
       +
       			channelMappings.delete(slackChannelId);

     

       216
       216
       +
       			console.log(

     

       217
       217
       +
       				`Removed channel mapping: ${slackChannelId} -> ${mapping.irc_channel}`,

     

       218
       218
       +
       			);

     

       105
       219
        
       

     

       106
       106
       -
             userMappings.delete(slackUserId);

     

       220
       220
       +
       			context.respond({

     

       221
       221
       +
       				response_type: "ephemeral",

     

       222
       222
       +
       				text: `✅ Removed bridge to ${mapping.irc_channel}`,

     

       223
       223
       +
       				replace_original: true,

     

       224
       224
       +
       			});

     

       225
       225
       +
       		} catch (error) {

     

       226
       226
       +
       			console.error("Error removing channel mapping:", error);

     

       227
       227
       +
       			context.respond({

     

       228
       228
       +
       				response_type: "ephemeral",

     

       229
       229
       +
       				text: `❌ Failed to remove bridge: ${error}`,

     

       230
       230
       +
       				replace_original: true,

     

       231
       231
       +
       			});

     

       232
       232
       +
       		}

     

       233
       233
       +
       	});

     

       107
       234
        
       

     

       108
       108
       -
             return {

     

       109
       109
       -
               text: `✅ Removed link to IRC nick: ${mapping.irc_nick}`,

     

       110
       110
       -
             };

     

       111
       111
       -
           } catch (error) {

     

       112
       112
       -
             console.error("Error removing user mapping:", error);

     

       113
       113
       -
             return {

     

       114
       114
       -
               text: `❌ Failed to remove link: ${error}`,

     

       115
       115
       -
             };

     

       116
       116
       -
           }

     

       117
       117
       -
         });

     

       235
       235
       +
       	// Link Slack user to IRC nick

     

       236
       236
       +
       	slackApp.command("/irc-bridge-user", async ({ payload, context }) => {

     

       237
       237
       +
       		context.respond({

     

       238
       238
       +
       			response_type: "ephemeral",

     

       239
       239
       +
       			text: "Enter your IRC nickname",

     

       240
       240
       +
       			blocks: [

     

       241
       241
       +
       				{

     

       242
       242
       +
       					type: "input",

     

       243
       243
       +
       					block_id: "irc_nick_input",

     

       244
       244
       +
       					element: {

     

       245
       245
       +
       						type: "plain_text_input",

     

       246
       246
       +
       						action_id: "irc_nick",

     

       247
       247
       +
       						placeholder: {

     

       248
       248
       +
       							type: "plain_text",

     

       249
       249
       +
       							text: "myircnick",

     

       250
       250
       +
       						},

     

       251
       251
       +
       					},

     

       252
       252
       +
       					label: {

     

       253
       253
       +
       						type: "plain_text",

     

       254
       254
       +
       						text: "IRC Nickname",

     

       255
       255
       +
       					},

     

       256
       256
       +
       				},

     

       257
       257
       +
       				{

     

       258
       258
       +
       					type: "actions",

     

       259
       259
       +
       					elements: [

     

       260
       260
       +
       						{

     

       261
       261
       +
       							type: "button",

     

       262
       262
       +
       							text: {

     

       263
       263
       +
       								type: "plain_text",

     

       264
       264
       +
       								text: "Link Account",

     

       265
       265
       +
       							},

     

       266
       266
       +
       							style: "primary",

     

       267
       267
       +
       							action_id: "bridge_user_submit",

     

       268
       268
       +
       							value: payload.user_id,

     

       269
       269
       +
       						},

     

       270
       270
       +
       						{

     

       271
       271
       +
       							type: "button",

     

       272
       272
       +
       							text: {

     

       273
       273
       +
       								type: "plain_text",

     

       274
       274
       +
       								text: "Cancel",

     

       275
       275
       +
       							},

     

       276
       276
       +
       							action_id: "cancel",

     

       277
       277
       +
       						},

     

       278
       278
       +
       					],

     

       279
       279
       +
       				},

     

       280
       280
       +
       			],

     

       281
       281
       +
       			replace_original: true,

     

       282
       282
       +
       		});

     

       283
       283
       +
       	});

     

       118
       284
        
       

     

       119
       119
       -
         // List channel mappings

     

       120
       120
       -
         slackApp.command("/irc-bridge-list", async ({ payload }) => {

     

       121
       121
       -
           const channelMaps = channelMappings.getAll();

     

       122
       122
       -
           const userMaps = userMappings.getAll();

     

       285
       285
       +
       	// Handle bridge user submission

     

       286
       286
       +
       	slackApp.action("bridge_user_submit", async ({ payload, context }) => {

     

       287
       287
       +
       		const stateValues = payload.state?.values;

     

       288
       288
       +
       		const ircNick = stateValues?.irc_nick_input?.irc_nick?.value;

     

       289
       289
       +
       		// @ts-expect-error

     

       290
       290
       +
       		const slackUserId = payload.actions?.[0]?.value;

     

       291
       291
       +
       		if (!context.respond) {

     

       292
       292
       +
       			return;

     

       293
       293
       +
       		}

     

       294
       294
       +
       

     

       295
       295
       +
       		if (!ircNick) {

     

       296
       296
       +
       			context.respond({

     

       297
       297
       +
       				response_type: "ephemeral",

     

       298
       298
       +
       				text: "❌ IRC nickname is required",

     

       299
       299
       +
       				replace_original: true,

     

       300
       300
       +
       			});

     

       301
       301
       +
       			return;

     

       302
       302
       +
       		}

     

       303
       303
       +
       

     

       304
       304
       +
       		try {

     

       305
       305
       +
       			// Check if IRC nick is already linked

     

       306
       306
       +
       			const existingIrcMapping = userMappings.getByIrcNick(ircNick);

     

       307
       307
       +
       			if (existingIrcMapping) {

     

       308
       308
       +
       				context.respond({

     

       309
       309
       +
       					response_type: "ephemeral",

     

       310
       310
       +
       					text: `❌ IRC nick *${ircNick}* is already linked to <@${existingIrcMapping.slack_user_id}>`,

     

       311
       311
       +
       					replace_original: true,

     

       312
       312
       +
       				});

     

       313
       313
       +
       				return;

     

       314
       314
       +
       			}

     

       315
       315
       +
       

     

       316
       316
       +
       			// Check if Slack user is already linked

     

       317
       317
       +
       			const existingSlackMapping = userMappings.getBySlackUser(slackUserId);

     

       318
       318
       +
       			if (existingSlackMapping) {

     

       319
       319
       +
       				context.respond({

     

       320
       320
       +
       					response_type: "ephemeral",

     

       321
       321
       +
       					text: `❌ You are already linked to IRC nick *${existingSlackMapping.irc_nick}*`,

     

       322
       322
       +
       					replace_original: true,

     

       323
       323
       +
       				});

     

       324
       324
       +
       				return;

     

       325
       325
       +
       			}

     

       326
       326
       +
       

     

       327
       327
       +
       			userMappings.create(slackUserId, ircNick);

     

       328
       328
       +
       			console.log(`Created user mapping: ${slackUserId} -> ${ircNick}`);

     

       329
       329
       +
       

     

       330
       330
       +
       			context.respond({

     

       331
       331
       +
       				response_type: "ephemeral",

     

       332
       332
       +
       				text: `✅ Successfully linked your account to IRC nick: *${ircNick}*`,

     

       333
       333
       +
       				replace_original: true,

     

       334
       334
       +
       			});

     

       335
       335
       +
       		} catch (error) {

     

       336
       336
       +
       			console.error("Error creating user mapping:", error);

     

       337
       337
       +
       			context.respond({

     

       338
       338
       +
       				response_type: "ephemeral",

     

       339
       339
       +
       				text: `❌ Failed to link user: ${error}`,

     

       340
       340
       +
       				replace_original: true,

     

       341
       341
       +
       			});

     

       342
       342
       +
       		}

     

       343
       343
       +
       	});

     

       344
       344
       +
       

     

       345
       345
       +
       	// Unlink Slack user from IRC

     

       346
       346
       +
       	slackApp.command("/irc-unbridge-user", async ({ payload, context }) => {

     

       347
       347
       +
       		const slackUserId = payload.user_id;

     

       348
       348
       +
       		const mapping = userMappings.getBySlackUser(slackUserId);

     

       349
       349
       +
       

     

       350
       350
       +
       		if (!mapping) {

     

       351
       351
       +
       			context.respond({

     

       352
       352
       +
       				response_type: "ephemeral",

     

       353
       353
       +
       				text: "❌ You don't have an IRC nick mapping",

     

       354
       354
       +
       			});

     

       355
       355
       +
       			return;

     

       356
       356
       +
       		}

     

       357
       357
       +
       

     

       358
       358
       +
       		context.respond({

     

       359
       359
       +
       			response_type: "ephemeral",

     

       360
       360
       +
       			text: `Are you sure you want to remove your link to IRC nick *${mapping.irc_nick}*?`,

     

       361
       361
       +
       			blocks: [

     

       362
       362
       +
       				{

     

       363
       363
       +
       					type: "section",

     

       364
       364
       +
       					text: {

     

       365
       365
       +
       						type: "mrkdwn",

     

       366
       366
       +
       						text: `Are you sure you want to remove your link to IRC nick *${mapping.irc_nick}*?`,

     

       367
       367
       +
       					},

     

       368
       368
       +
       				},

     

       369
       369
       +
       				{

     

       370
       370
       +
       					type: "actions",

     

       371
       371
       +
       					elements: [

     

       372
       372
       +
       						{

     

       373
       373
       +
       							type: "button",

     

       374
       374
       +
       							text: {

     

       375
       375
       +
       								type: "plain_text",

     

       376
       376
       +
       								text: "Remove Link",

     

       377
       377
       +
       							},

     

       378
       378
       +
       							style: "danger",

     

       379
       379
       +
       							action_id: "unbridge_user_confirm",

     

       380
       380
       +
       							value: slackUserId,

     

       381
       381
       +
       						},

     

       382
       382
       +
       						{

     

       383
       383
       +
       							type: "button",

     

       384
       384
       +
       							text: {

     

       385
       385
       +
       								type: "plain_text",

     

       386
       386
       +
       								text: "Cancel",

     

       387
       387
       +
       							},

     

       388
       388
       +
       							action_id: "cancel",

     

       389
       389
       +
       						},

     

       390
       390
       +
       					],

     

       391
       391
       +
       				},

     

       392
       392
       +
       			],

     

       393
       393
       +
       			replace_original: true,

     

       394
       394
       +
       		});

     

       395
       395
       +
       	});

     

       396
       396
       +
       

     

       397
       397
       +
       	// Handle unbridge user confirmation

     

       398
       398
       +
       	slackApp.action("unbridge_user_confirm", async ({ payload, context }) => {

     

       399
       399
       +
       		// @ts-expect-error

     

       400
       400
       +
       		const slackUserId = payload.actions?.[0]?.value;

     

       401
       401
       +
       		if (!context.respond) {

     

       402
       402
       +
       			return;

     

       403
       403
       +
       		}

     

       404
       404
       +
       

     

       405
       405
       +
       		try {

     

       406
       406
       +
       			const mapping = userMappings.getBySlackUser(slackUserId);

     

       407
       407
       +
       			if (!mapping) {

     

       408
       408
       +
       				context.respond({

     

       409
       409
       +
       					response_type: "ephemeral",

     

       410
       410
       +
       					text: "❌ You don't have an IRC nick mapping",

     

       411
       411
       +
       					replace_original: true,

     

       412
       412
       +
       				});

     

       413
       413
       +
       				return;

     

       414
       414
       +
       			}

     

       415
       415
       +
       

     

       416
       416
       +
       			userMappings.delete(slackUserId);

     

       417
       417
       +
       			console.log(

     

       418
       418
       +
       				`Removed user mapping: ${slackUserId} -> ${mapping.irc_nick}`,

     

       419
       419
       +
       			);

     

       420
       420
       +
       

     

       421
       421
       +
       			context.respond({

     

       422
       422
       +
       				response_type: "ephemeral",

     

       423
       423
       +
       				text: `✅ Removed link to IRC nick: ${mapping.irc_nick}`,

     

       424
       424
       +
       				replace_original: true,

     

       425
       425
       +
       			});

     

       426
       426
       +
       		} catch (error) {

     

       427
       427
       +
       			console.error("Error removing user mapping:", error);

     

       428
       428
       +
       			context.respond({

     

       429
       429
       +
       				response_type: "ephemeral",

     

       430
       430
       +
       				text: `❌ Failed to remove link: ${error}`,

     

       431
       431
       +
       				replace_original: true,

     

       432
       432
       +
       			});

     

       433
       433
       +
       		}

     

       434
       434
       +
       	});

     

       435
       435
       +
       

     

       436
       436
       +
       	// Handle cancel button

     

       437
       437
       +
       	slackApp.action("cancel", async ({ context }) => {

     

       438
       438
       +
       		if (!context.respond) return;

     

       439
       439
       +
       

     

       440
       440
       +
       		context.respond({

     

       441
       441
       +
       			response_type: "ephemeral",

     

       442
       442
       +
       			delete_original: true,

     

       443
       443
       +
       		});

     

       444
       444
       +
       	});

     

       445
       445
       +
       

     

       446
       446
       +
       	// List channel mappings

     

       447
       447
       +
       	slackApp.command("/irc-bridge-list", async ({ context }) => {

     

       448
       448
       +
       		const channelMaps = channelMappings.getAll();

     

       449
       449
       +
       		const userMaps = userMappings.getAll();

     

       450
       450
       +
       

     

       451
       451
       +
       		const blocks: AnyMessageBlock[] = [

     

       452
       452
       +
       			{

     

       453
       453
       +
       				type: "header",

     

       454
       454
       +
       				text: {

     

       455
       455
       +
       					type: "plain_text",

     

       456
       456
       +
       					text: "IRC Bridge Status",

     

       457
       457
       +
       				},

     

       458
       458
       +
       			},

     

       459
       459
       +
       			{

     

       460
       460
       +
       				type: "section",

     

       461
       461
       +
       				text: {

     

       462
       462
       +
       					type: "mrkdwn",

     

       463
       463
       +
       					text: "*Channel Bridges:*",

     

       464
       464
       +
       				},

     

       465
       465
       +
       			},

     

       466
       466
       +
       		];

     

       467
       467
       +
       

     

       468
       468
       +
       		if (channelMaps.length === 0) {

     

       469
       469
       +
       			blocks.push({

     

       470
       470
       +
       				type: "section",

     

       471
       471
       +
       				text: {

     

       472
       472
       +
       					type: "mrkdwn",

     

       473
       473
       +
       					text: "_No channel bridges configured_",

     

       474
       474
       +
       				},

     

       475
       475
       +
       			});

     

       476
       476
       +
       		} else {

     

       477
       477
       +
       			for (const map of channelMaps) {

     

       478
       478
       +
       				blocks.push({

     

       479
       479
       +
       					type: "section",

     

       480
       480
       +
       					text: {

     

       481
       481
       +
       						type: "mrkdwn",

     

       482
       482
       +
       						text: `• <#${map.slack_channel_id}> ↔️ *${map.irc_channel}*`,

     

       483
       483
       +
       					},

     

       484
       484
       +
       				});

     

       485
       485
       +
       			}

     

       486
       486
       +
       		}

     

       123
       487
        
       

     

       124
       124
       -
           let text = "*Channel Bridges:*\n";

     

       125
       125
       -
           if (channelMaps.length === 0) {

     

       126
       126
       -
             text += "None\n";

     

       127
       127
       -
           } else {

     

       128
       128
       -
             for (const map of channelMaps) {

     

       129
       129
       -
               text += `• <#${map.slack_channel_id}> ↔️ ${map.irc_channel}\n`;

     

       130
       130
       -
             }

     

       131
       131
       -
           }

     

       488
       488
       +
       		blocks.push(

     

       489
       489
       +
       			{

     

       490
       490
       +
       				type: "divider",

     

       491
       491
       +
       			},

     

       492
       492
       +
       			{

     

       493
       493
       +
       				type: "section",

     

       494
       494
       +
       				text: {

     

       495
       495
       +
       					type: "mrkdwn",

     

       496
       496
       +
       					text: "*User Mappings:*",

     

       497
       497
       +
       				},

     

       498
       498
       +
       			},

     

       499
       499
       +
       		);

     

       132
       500
        
       

     

       133
       133
       -
           text += "\n*User Mappings:*\n";

     

       134
       134
       -
           if (userMaps.length === 0) {

     

       135
       135
       -
             text += "None\n";

     

       136
       136
       -
           } else {

     

       137
       137
       -
             for (const map of userMaps) {

     

       138
       138
       -
               text += `• <@${map.slack_user_id}> ↔️ ${map.irc_nick}\n`;

     

       139
       139
       -
             }

     

       140
       140
       -
           }

     

       501
       501
       +
       		if (userMaps.length === 0) {

     

       502
       502
       +
       			blocks.push({

     

       503
       503
       +
       				type: "section",

     

       504
       504
       +
       				text: {

     

       505
       505
       +
       					type: "mrkdwn",

     

       506
       506
       +
       					text: "_No user mappings configured_",

     

       507
       507
       +
       				},

     

       508
       508
       +
       			});

     

       509
       509
       +
       		} else {

     

       510
       510
       +
       			for (const map of userMaps) {

     

       511
       511
       +
       				blocks.push({

     

       512
       512
       +
       					type: "section",

     

       513
       513
       +
       					text: {

     

       514
       514
       +
       						type: "mrkdwn",

     

       515
       515
       +
       						text: `• <@${map.slack_user_id}> ↔️ *${map.irc_nick}*`,

     

       516
       516
       +
       					},

     

       517
       517
       +
       				});

     

       518
       518
       +
       			}

     

       519
       519
       +
       		}

     

       141
       520
        
       

     

       142
       142
       -
           return {

     

       143
       143
       -
             text,

     

       144
       144
       -
           };

     

       145
       145
       -
         });

     

       521
       521
       +
       		context.respond({

     

       522
       522
       +
       			response_type: "ephemeral",

     

       523
       523
       +
       			text: "IRC mapping list",

     

       524
       524
       +
       			blocks,

     

       525
       525
       +
       			replace_original: true,

     

       526
       526
       +
       		});

     

       527
       527
       +
       	});

     

       146
       528
        
       }

-87

src/db.ts

···

       1
       1
       -
       import { Database } from "bun:sqlite";

     

       2
       2
       -
       

     

       3
       3
       -
       const db = new Database("bridge.db");

     

       4
       4
       -
       

     

       5
       5
       -
       db.run(`

     

       6
       6
       -
         CREATE TABLE IF NOT EXISTS channel_mappings (

     

       7
       7
       -
           id INTEGER PRIMARY KEY AUTOINCREMENT,

     

       8
       8
       -
           slack_channel_id TEXT NOT NULL UNIQUE,

     

       9
       9
       -
           irc_channel TEXT NOT NULL,

     

       10
       10
       -
           created_at INTEGER DEFAULT (strftime('%s', 'now'))

     

       11
       11
       -
         )

     

       12
       12
       -
       `);

     

       13
       13
       -
       

     

       14
       14
       -
       db.run(`

     

       15
       15
       -
         CREATE TABLE IF NOT EXISTS user_mappings (

     

       16
       16
       -
           id INTEGER PRIMARY KEY AUTOINCREMENT,

     

       17
       17
       -
           slack_user_id TEXT NOT NULL UNIQUE,

     

       18
       18
       -
           irc_nick TEXT NOT NULL,

     

       19
       19
       -
           created_at INTEGER DEFAULT (strftime('%s', 'now'))

     

       20
       20
       -
         )

     

       21
       21
       -
       `);

     

       22
       22
       -
       

     

       23
       23
       -
       export interface ChannelMapping {

     

       24
       24
       -
       	id?: number;

     

       25
       25
       -
       	slack_channel_id: string;

     

       26
       26
       -
       	irc_channel: string;

     

       27
       27
       -
       	created_at?: number;

     

       28
       28
       -
       }

     

       29
       29
       -
       

     

       30
       30
       -
       export interface UserMapping {

     

       31
       31
       -
       	id?: number;

     

       32
       32
       -
       	slack_user_id: string;

     

       33
       33
       -
       	irc_nick: string;

     

       34
       34
       -
       	created_at?: number;

     

       35
       35
       -
       }

     

       36
       36
       -
       

     

       37
       37
       -
       export const channelMappings = {

     

       38
       38
       -
       	getAll(): ChannelMapping[] {

     

       39
       39
       -
       		return db.query("SELECT * FROM channel_mappings").all() as ChannelMapping[];

     

       40
       40
       -
       	},

     

       41
       41
       -
       

     

       42
       42
       -
       	getBySlackChannel(slackChannelId: string): ChannelMapping | null {

     

       43
       43
       -
       		return db.query("SELECT * FROM channel_mappings WHERE slack_channel_id = ?").get(slackChannelId) as ChannelMapping | null;

     

       44
       44
       -
       	},

     

       45
       45
       -
       

     

       46
       46
       -
       	getByIrcChannel(ircChannel: string): ChannelMapping | null {

     

       47
       47
       -
       		return db.query("SELECT * FROM channel_mappings WHERE irc_channel = ?").get(ircChannel) as ChannelMapping | null;

     

       48
       48
       -
       	},

     

       49
       49
       -
       

     

       50
       50
       -
       	create(slackChannelId: string, ircChannel: string): void {

     

       51
       51
       -
       		db.run(

     

       52
       52
       -
       			"INSERT OR REPLACE INTO channel_mappings (slack_channel_id, irc_channel) VALUES (?, ?)",

     

       53
       53
       -
       			[slackChannelId, ircChannel]

     

       54
       54
       -
       		);

     

       55
       55
       -
       	},

     

       56
       56
       -
       

     

       57
       57
       -
       	delete(slackChannelId: string): void {

     

       58
       58
       -
       		db.run("DELETE FROM channel_mappings WHERE slack_channel_id = ?", [slackChannelId]);

     

       59
       59
       -
       	},

     

       60
       60
       -
       };

     

       61
       61
       -
       

     

       62
       62
       -
       export const userMappings = {

     

       63
       63
       -
       	getAll(): UserMapping[] {

     

       64
       64
       -
       		return db.query("SELECT * FROM user_mappings").all() as UserMapping[];

     

       65
       65
       -
       	},

     

       66
       66
       -
       

     

       67
       67
       -
       	getBySlackUser(slackUserId: string): UserMapping | null {

     

       68
       68
       -
       		return db.query("SELECT * FROM user_mappings WHERE slack_user_id = ?").get(slackUserId) as UserMapping | null;

     

       69
       69
       -
       	},

     

       70
       70
       -
       

     

       71
       71
       -
       	getByIrcNick(ircNick: string): UserMapping | null {

     

       72
       72
       -
       		return db.query("SELECT * FROM user_mappings WHERE irc_nick = ?").get(ircNick) as UserMapping | null;

     

       73
       73
       -
       	},

     

       74
       74
       -
       

     

       75
       75
       -
       	create(slackUserId: string, ircNick: string): void {

     

       76
       76
       -
       		db.run(

     

       77
       77
       -
       			"INSERT OR REPLACE INTO user_mappings (slack_user_id, irc_nick) VALUES (?, ?)",

     

       78
       78
       -
       			[slackUserId, ircNick]

     

       79
       79
       -
       		);

     

       80
       80
       -
       	},

     

       81
       81
       -
       

     

       82
       82
       -
       	delete(slackUserId: string): void {

     

       83
       83
       -
       		db.run("DELETE FROM user_mappings WHERE slack_user_id = ?", [slackUserId]);

     

       84
       84
       -
       	},

     

       85
       85
       -
       };

     

       86
       86
       -
       

     

       87
       87
       -
       export default db;

+385 -147

src/index.ts

···

       2
       2
        
       import { SlackApp } from "slack-edge";

     

       3
       3
        
       import { version } from "../package.json";

     

       4
       4
        
       import { registerCommands } from "./commands";

     

       5
       5
       -
       import { channelMappings, userMappings } from "./db";

     

       6
       6
       -
       import { parseIRCFormatting, parseSlackMarkdown } from "./parser";

     

       7
       7
       -
       import type { CachetUser } from "./types";

     

       5
       5
       +
       import { getAvatarForNick } from "./lib/avatars";

     

       6
       6
       +
       import { uploadToCDN } from "./lib/cdn";

     

       7
       7
       +
       import { channelMappings, userMappings } from "./lib/db";

     

       8
       8
       +
       import {

     

       9
       9
       +
       	convertIrcMentionsToSlack,

     

       10
       10
       +
       	convertSlackMentionsToIrc,

     

       11
       11
       +
       } from "./lib/mentions";

     

       12
       12
       +
       import { parseIRCFormatting, parseSlackMarkdown } from "./lib/parser";

     

       13
       13
       +
       import {

     

       14
       14
       +
       	cleanupOldThreads,

     

       15
       15
       +
       	getThreadByThreadId,

     

       16
       16
       +
       	isFirstThreadMessage,

     

       17
       17
       +
       	updateThreadTimestamp,

     

       18
       18
       +
       } from "./lib/threads";

     

       19
       19
       +
       import { cleanupUserCache, getUserInfo } from "./lib/user-cache";

     

       8
       20
        
       

     

       9
       21
        
       const missingEnvVars = [];

     

       10
       22
        
       if (!process.env.SLACK_BOT_TOKEN) missingEnvVars.push("SLACK_BOT_TOKEN");

     

       11
       23
        
       if (!process.env.SLACK_SIGNING_SECRET)

     

       12
       12
       -
         missingEnvVars.push("SLACK_SIGNING_SECRET");

     

       24
       24
       +
       	missingEnvVars.push("SLACK_SIGNING_SECRET");

     

       13
       25
        
       if (!process.env.ADMINS) missingEnvVars.push("ADMINS");

     

       14
       26
        
       if (!process.env.IRC_NICK) missingEnvVars.push("IRC_NICK");

     

       15
       27
        
       

     

       16
       28
        
       if (missingEnvVars.length > 0) {

     

       17
       17
       -
         throw new Error(

     

       18
       18
       -
           `Missing required environment variables: ${missingEnvVars.join(", ")}`,

     

       19
       19
       -
         );

     

       29
       29
       +
       	throw new Error(

     

       30
       30
       +
       		`Missing required environment variables: ${missingEnvVars.join(", ")}`,

     

       31
       31
       +
       	);

     

       20
       32
        
       }

     

       21
       33
        
       

     

       22
       34
        
       const slackApp = new SlackApp({

     

       23
       23
       -
         env: {

     

       24
       24
       -
           SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN as string,

     

       25
       25
       -
           SLACK_SIGNING_SECRET: process.env.SLACK_SIGNING_SECRET as string,

     

       26
       26
       -
           SLACK_LOGGING_LEVEL: "INFO",

     

       27
       27
       -
         },

     

       28
       28
       -
         startLazyListenerAfterAck: true,

     

       35
       35
       +
       	env: {

     

       36
       36
       +
       		SLACK_BOT_TOKEN: process.env.SLACK_BOT_TOKEN as string,

     

       37
       37
       +
       		SLACK_SIGNING_SECRET: process.env.SLACK_SIGNING_SECRET as string,

     

       38
       38
       +
       		SLACK_LOGGING_LEVEL: "INFO",

     

       39
       39
       +
       	},

     

       40
       40
       +
       	startLazyListenerAfterAck: true,

     

       29
       41
        
       });

     

       30
       42
        
       const slackClient = slackApp.client;

     

       31
       43
        
       

     

       32
       44
        
       // Get bot user ID

     

       33
       45
        
       let botUserId: string | undefined;

     

       34
       46
        
       slackClient.auth

     

       35
       35
       -
         .test({

     

       36
       36
       -
           token: process.env.SLACK_BOT_TOKEN,

     

       37
       37
       -
         })

     

       38
       38
       -
         .then((result) => {

     

       39
       39
       -
           botUserId = result.user_id;

     

       40
       40
       -
           console.log(`Bot user ID: ${botUserId}`);

     

       41
       41
       -
         });

     

       47
       47
       +
       	.test({

     

       48
       48
       +
       		token: process.env.SLACK_BOT_TOKEN,

     

       49
       49
       +
       	})

     

       50
       50
       +
       	.then((result) => {

     

       51
       51
       +
       		botUserId = result.user_id;

     

       52
       52
       +
       		console.log(`Bot user ID: ${botUserId}`);

     

       53
       53
       +
       	});

     

       42
       54
        
       

     

       43
       55
        
       // IRC client setup

     

       44
       56
        
       const ircClient = new irc.Client(

     

       45
       45
       -
         "irc.hackclub.com",

     

       46
       46
       -
         process.env.IRC_NICK || "slackbridge",

     

       47
       47
       -
         {

     

       48
       48
       -
           port: 6667,

     

       49
       49
       -
           autoRejoin: true,

     

       50
       50
       -
           autoConnect: true,

     

       51
       51
       -
           channels: [],

     

       52
       52
       -
           secure: false,

     

       53
       53
       -
           userName: process.env.IRC_NICK,

     

       54
       54
       -
           realName: "Slack IRC Bridge",

     

       55
       55
       -
         },

     

       57
       57
       +
       	"irc.hackclub.com",

     

       58
       58
       +
       	process.env.IRC_NICK || "slackbridge",

     

       59
       59
       +
       	{

     

       60
       60
       +
       		port: 6667,

     

       61
       61
       +
       		autoRejoin: true,

     

       62
       62
       +
       		autoConnect: true,

     

       63
       63
       +
       		channels: [],

     

       64
       64
       +
       		secure: false,

     

       65
       65
       +
       		userName: process.env.IRC_NICK,

     

       66
       66
       +
       		realName: "Slack IRC Bridge",

     

       67
       67
       +
       	},

     

       56
       68
        
       );

     

       57
       69
        
       

     

       58
       70
        
       // Clean up IRC connection on hot reload or exit

     

       59
       71
        
       process.on("beforeExit", () => {

     

       60
       60
       -
         ircClient.disconnect("Reloading", () => {

     

       61
       61
       -
           console.log("IRC client disconnected");

     

       62
       62
       -
         });

     

       72
       72
       +
       	ircClient.disconnect("Reloading", () => {

     

       73
       73
       +
       		console.log("IRC client disconnected");

     

       74
       74
       +
       	});

     

       63
       75
        
       });

     

       64
       76
        
       

     

       65
       77
        
       // Register slash commands

     

       66
       78
        
       registerCommands();

     

       67
       79
        
       

     

       80
       80
       +
       // Periodic cleanup of old thread timestamps (every hour)

     

       81
       81
       +
       setInterval(

     

       82
       82
       +
       	() => {

     

       83
       83
       +
       		cleanupOldThreads();

     

       84
       84
       +
       		cleanupUserCache();

     

       85
       85
       +
       	},

     

       86
       86
       +
       	60 * 60 * 1000,

     

       87
       87
       +
       );

     

       88
       88
       +
       

     

       89
       89
       +
       // Track NickServ authentication state

     

       90
       90
       +
       let nickServAuthAttempted = false;

     

       91
       91
       +
       let _isAuthenticated = false;

     

       92
       92
       +
       

     

       68
       93
        
       // Join all mapped IRC channels on connect

     

       69
       94
        
       ircClient.addListener("registered", async () => {

     

       70
       70
       -
         console.log("Connected to IRC server");

     

       71
       71
       -
         const mappings = channelMappings.getAll();

     

       72
       72
       -
         for (const mapping of mappings) {

     

       73
       73
       -
           ircClient.join(mapping.irc_channel);

     

       74
       74
       -
         }

     

       95
       95
       +
       	console.log("Connected to IRC server");

     

       96
       96
       +
       

     

       97
       97
       +
       	// Authenticate with NickServ if password is provided

     

       98
       98
       +
       	if (process.env.NICKSERV_PASSWORD && !nickServAuthAttempted) {

     

       99
       99
       +
       		nickServAuthAttempted = true;

     

       100
       100
       +
       		console.log("Authenticating with NickServ...");

     

       101
       101
       +
       		ircClient.say("NickServ", `IDENTIFY ${process.env.NICKSERV_PASSWORD}`);

     

       102
       102
       +
       		// Don't join channels yet - wait for NickServ response

     

       103
       103
       +
       	} else if (!process.env.NICKSERV_PASSWORD) {

     

       104
       104
       +
       		// No auth needed, join immediately

     

       105
       105
       +
       		const mappings = channelMappings.getAll();

     

       106
       106
       +
       		for (const mapping of mappings) {

     

       107
       107
       +
       			ircClient.join(mapping.irc_channel);

     

       108
       108
       +
       		}

     

       109
       109
       +
       	}

     

       75
       110
        
       });

     

       76
       111
        
       

     

       77
       112
        
       ircClient.addListener("join", (channel: string, nick: string) => {

     

       78
       78
       -
         if (nick === process.env.IRC_NICK) {

     

       79
       79
       -
           console.log(`Joined IRC channel: ${channel}`);

     

       80
       80
       -
         }

     

       113
       113
       +
       	if (nick === process.env.IRC_NICK) {

     

       114
       114
       +
       		console.log(`Joined IRC channel: ${channel}`);

     

       115
       115
       +
       	}

     

       81
       116
        
       });

     

       82
       117
        
       

     

       118
       118
       +
       // Handle NickServ notices

     

       83
       119
        
       ircClient.addListener(

     

       84
       84
       -
         "message",

     

       85
       85
       -
         async (nick: string, to: string, text: string) => {

     

       86
       86
       -
           // Ignore messages from our own bot (with or without numbers suffix)

     

       87
       87
       -
           const botNickPattern = new RegExp(`^${process.env.IRC_NICK}\\d*$`);

     

       88
       88
       -
           if (botNickPattern.test(nick)) return;

     

       89
       89
       -
           if (nick === "****") return;

     

       120
       120
       +
       	"notice",

     

       121
       121
       +
       	async (nick: string, _to: string, text: string) => {

     

       122
       122
       +
       		if (nick !== "NickServ") return;

     

       90
       123
        
       

     

       91
       91
       -
           // Find Slack channel mapping for this IRC channel

     

       92
       92
       -
           const mapping = channelMappings.getByIrcChannel(to);

     

       93
       93
       -
           if (!mapping) return;

     

       124
       124
       +
       		console.log(`NickServ: ${text}`);

     

       94
       125
        
       

     

       95
       95
       -
           // Check if this IRC nick is mapped to a Slack user

     

       96
       96
       -
           const userMapping = userMappings.getByIrcNick(nick);

     

       126
       126
       +
       		// Check for successful authentication

     

       127
       127
       +
       		if (

     

       128
       128
       +
       			text.includes("You are now identified") ||

     

       129
       129
       +
       			text.includes("Password accepted")

     

       130
       130
       +
       		) {

     

       131
       131
       +
       			console.log("✓ Successfully authenticated with NickServ");

     

       132
       132
       +
       			_isAuthenticated = true;

     

       133
       133
       +
       

     

       134
       134
       +
       			// Join channels after successful auth

     

       135
       135
       +
       			const mappings = channelMappings.getAll();

     

       136
       136
       +
       			for (const mapping of mappings) {

     

       137
       137
       +
       				ircClient.join(mapping.irc_channel);

     

       138
       138
       +
       			}

     

       139
       139
       +
       		}

     

       140
       140
       +
       		// Check if nick is not registered

     

       141
       141
       +
       		else if (

     

       142
       142
       +
       			text.includes("isn't registered") ||

     

       143
       143
       +
       			text.includes("not registered")

     

       144
       144
       +
       		) {

     

       145
       145
       +
       			console.log("Nick not registered, registering with NickServ...");

     

       146
       146
       +
       			if (process.env.NICKSERV_PASSWORD && process.env.NICKSERV_EMAIL) {

     

       147
       147
       +
       				ircClient.say(

     

       148
       148
       +
       					"NickServ",

     

       149
       149
       +
       					`REGISTER ${process.env.NICKSERV_PASSWORD} ${process.env.NICKSERV_EMAIL}`,

     

       150
       150
       +
       				);

     

       151
       151
       +
       			} else {

     

       152
       152
       +
       				console.error("Cannot register: NICKSERV_EMAIL not configured");

     

       153
       153
       +
       			}

     

       154
       154
       +
       		}

     

       155
       155
       +
       		// Check for failed authentication

     

       156
       156
       +
       		else if (

     

       157
       157
       +
       			text.includes("Invalid password") ||

     

       158
       158
       +
       			text.includes("Access denied")

     

       159
       159
       +
       		) {

     

       160
       160
       +
       			console.error("✗ NickServ authentication failed: Invalid password");

     

       161
       161
       +
       		}

     

       162
       162
       +
       	},

     

       163
       163
       +
       );

     

       164
       164
       +
       

     

       165
       165
       +
       ircClient.addListener(

     

       166
       166
       +
       	"message",

     

       167
       167
       +
       	async (nick: string, to: string, text: string) => {

     

       168
       168
       +
       		// Ignore messages from our own bot (with or without numbers suffix)

     

       169
       169
       +
       		const botNickPattern = new RegExp(`^${process.env.IRC_NICK}\\d*$`);

     

       170
       170
       +
       		if (botNickPattern.test(nick)) return;

     

       171
       171
       +
       		if (nick === "****") return;

     

       172
       172
       +
       

     

       173
       173
       +
       		// Find Slack channel mapping for this IRC channel

     

       174
       174
       +
       		const mapping = channelMappings.getByIrcChannel(to);

     

       175
       175
       +
       		if (!mapping) return;

     

       176
       176
       +
       

     

       177
       177
       +
       		// Check if this IRC nick is mapped to a Slack user

     

       178
       178
       +
       		const userMapping = userMappings.getByIrcNick(nick);

     

       179
       179
       +
       

     

       180
       180
       +
       		const displayName = `${nick} <irc>`;

     

       181
       181
       +
       		let iconUrl: string;

     

       182
       182
       +
       

     

       183
       183
       +
       		if (userMapping) {

     

       184
       184
       +
       			iconUrl = `https://cachet.dunkirk.sh/users/${userMapping.slack_user_id}/r`;

     

       185
       185
       +
       		} else {

     

       186
       186
       +
       			// Use stable random avatar for unmapped users

     

       187
       187
       +
       			iconUrl = getAvatarForNick(nick);

     

       188
       188
       +
       		}

     

       189
       189
       +
       

     

       190
       190
       +
       		// Parse IRC mentions and convert to Slack mentions

     

       191
       191
       +
       		let messageText = parseIRCFormatting(text);

     

       192
       192
       +
       

     

       193
       193
       +
       		// Check for @xxxxx mentions to reply to threads

     

       194
       194
       +
       		const threadMentionPattern = /@([a-z0-9]{5})\b/i;

     

       195
       195
       +
       		const threadMatch = messageText.match(threadMentionPattern);

     

       196
       196
       +
       		let threadTs: string | undefined;

     

       97
       197
        
       

     

       98
       98
       -
           const displayName = `${nick} <irc>`;

     

       99
       99
       -
           let iconUrl: string | undefined;

     

       198
       198
       +
       		if (threadMatch) {

     

       199
       199
       +
       			const threadId = threadMatch[1];

     

       200
       200
       +
       			const threadInfo = getThreadByThreadId(threadId);

     

       201
       201
       +
       			if (

     

       202
       202
       +
       				threadInfo &&

     

       203
       203
       +
       				threadInfo.slack_channel_id === mapping.slack_channel_id

     

       204
       204
       +
       			) {

     

       205
       205
       +
       				threadTs = threadInfo.thread_ts;

     

       206
       206
       +
       				// Remove the @xxxxx from the message

     

       207
       207
       +
       				messageText = messageText.replace(threadMentionPattern, "").trim();

     

       208
       208
       +
       			}

     

       209
       209
       +
       		}

     

       100
       210
        
       

     

       101
       101
       -
           if (userMapping) {

     

       102
       102
       -
             try {

     

       103
       103
       -
               iconUrl = `https://cachet.dunkirk.sh/users/${userMapping.slack_user_id}/r`;

     

       104
       104
       -
             } catch (error) {

     

       105
       105
       -
               console.error("Error fetching user info:", error);

     

       106
       106
       -
             }

     

       107
       107
       -
           }

     

       211
       211
       +
       		// Extract image URLs from the message

     

       212
       212
       +
       		const imagePattern =

     

       213
       213
       +
       			/https?:\/\/[^\s]+\.(?:png|jpg|jpeg|gif|webp|bmp|svg)(?:\?[^\s]*)?/gi;

     

       214
       214
       +
       		const imageUrls = Array.from(messageText.matchAll(imagePattern));

     

       108
       215
        
       

     

       109
       109
       -
           try {

     

       110
       110
       -
             await slackClient.chat.postMessage({

     

       111
       111
       -
               token: process.env.SLACK_BOT_TOKEN,

     

       112
       112
       -
               channel: mapping.slack_channel_id,

     

       113
       113
       -
               text: parseIRCFormatting(text),

     

       114
       114
       -
               username: displayName,

     

       115
       115
       -
               icon_url: iconUrl,

     

       116
       116
       -
               unfurl_links: false,

     

       117
       117
       -
               unfurl_media: false,

     

       118
       118
       -
             });

     

       119
       119
       -
             console.log(`IRC → Slack: <${nick}> ${text}`);

     

       120
       120
       -
           } catch (error) {

     

       121
       121
       -
             console.error("Error posting to Slack:", error);

     

       122
       122
       -
           }

     

       123
       123
       -
         },

     

       216
       216
       +
       		messageText = convertIrcMentionsToSlack(messageText);

     

       217
       217
       +
       

     

       218
       218
       +
       		try {

     

       219
       219
       +
       			// If there are image URLs, send them as attachments

     

       220
       220
       +
       			if (imageUrls.length > 0) {

     

       221
       221
       +
       				const attachments = imageUrls.map((match) => ({

     

       222
       222
       +
       					image_url: match[0],

     

       223
       223
       +
       					fallback: match[0],

     

       224
       224
       +
       				}));

     

       225
       225
       +
       

     

       226
       226
       +
       				await slackClient.chat.postMessage({

     

       227
       227
       +
       					token: process.env.SLACK_BOT_TOKEN,

     

       228
       228
       +
       					channel: mapping.slack_channel_id,

     

       229
       229
       +
       					text: messageText,

     

       230
       230
       +
       					username: displayName,

     

       231
       231
       +
       					icon_url: iconUrl,

     

       232
       232
       +
       					attachments: attachments,

     

       233
       233
       +
       					unfurl_links: false,

     

       234
       234
       +
       					unfurl_media: false,

     

       235
       235
       +
       					thread_ts: threadTs,

     

       236
       236
       +
       				});

     

       237
       237
       +
       			} else {

     

       238
       238
       +
       				await slackClient.chat.postMessage({

     

       239
       239
       +
       					token: process.env.SLACK_BOT_TOKEN,

     

       240
       240
       +
       					channel: mapping.slack_channel_id,

     

       241
       241
       +
       					text: messageText,

     

       242
       242
       +
       					username: displayName,

     

       243
       243
       +
       					icon_url: iconUrl,

     

       244
       244
       +
       					unfurl_links: true,

     

       245
       245
       +
       					unfurl_media: true,

     

       246
       246
       +
       					thread_ts: threadTs,

     

       247
       247
       +
       				});

     

       248
       248
       +
       			}

     

       249
       249
       +
       			console.log(`IRC (${to}) → Slack: <${nick}> ${text}`);

     

       250
       250
       +
       		} catch (error) {

     

       251
       251
       +
       			console.error("Error posting to Slack:", error);

     

       252
       252
       +
       		}

     

       253
       253
       +
       	},

     

       124
       254
        
       );

     

       125
       255
        
       

     

       126
       256
        
       ircClient.addListener("error", (error: string) => {

     

       127
       127
       -
         console.error("IRC error:", error);

     

       257
       257
       +
       	console.error("IRC error:", error);

     

       128
       258
        
       });

     

       129
       259
        
       

     

       260
       260
       +
       // Handle IRC /me actions

     

       261
       261
       +
       ircClient.addListener(

     

       262
       262
       +
       	"action",

     

       263
       263
       +
       	async (nick: string, to: string, text: string) => {

     

       264
       264
       +
       		// Ignore messages from our own bot

     

       265
       265
       +
       		const botNickPattern = new RegExp(`^${process.env.IRC_NICK}\\d*$`);

     

       266
       266
       +
       		if (botNickPattern.test(nick)) return;

     

       267
       267
       +
       		if (nick === "****") return;

     

       268
       268
       +
       

     

       269
       269
       +
       		// Find Slack channel mapping for this IRC channel

     

       270
       270
       +
       		const mapping = channelMappings.getByIrcChannel(to);

     

       271
       271
       +
       		if (!mapping) return;

     

       272
       272
       +
       

     

       273
       273
       +
       		// Check if this IRC nick is mapped to a Slack user

     

       274
       274
       +
       		const userMapping = userMappings.getByIrcNick(nick);

     

       275
       275
       +
       

     

       276
       276
       +
       		let iconUrl: string;

     

       277
       277
       +
       		if (userMapping) {

     

       278
       278
       +
       			iconUrl = `https://cachet.dunkirk.sh/users/${userMapping.slack_user_id}/r`;

     

       279
       279
       +
       		} else {

     

       280
       280
       +
       			iconUrl = getAvatarForNick(nick);

     

       281
       281
       +
       		}

     

       282
       282
       +
       

     

       283
       283
       +
       		// Parse IRC formatting and mentions

     

       284
       284
       +
       		let messageText = parseIRCFormatting(text);

     

       285
       285
       +
       		messageText = convertIrcMentionsToSlack(messageText);

     

       286
       286
       +
       

     

       287
       287
       +
       		// Format as action message with context block

     

       288
       288
       +
       		const actionText = `${nick} ${messageText}`;

     

       289
       289
       +
       

     

       290
       290
       +
       		await slackClient.chat.postMessage({

     

       291
       291
       +
       			token: process.env.SLACK_BOT_TOKEN,

     

       292
       292
       +
       			channel: mapping.slack_channel_id,

     

       293
       293
       +
       			text: actionText,

     

       294
       294
       +
       			blocks: [

     

       295
       295
       +
       				{

     

       296
       296
       +
       					type: "context",

     

       297
       297
       +
       					elements: [

     

       298
       298
       +
       						{

     

       299
       299
       +
       							type: "image",

     

       300
       300
       +
       							image_url: iconUrl,

     

       301
       301
       +
       							alt_text: nick,

     

       302
       302
       +
       						},

     

       303
       303
       +
       						{

     

       304
       304
       +
       							type: "mrkdwn",

     

       305
       305
       +
       							text: actionText,

     

       306
       306
       +
       						},

     

       307
       307
       +
       					],

     

       308
       308
       +
       				},

     

       309
       309
       +
       			],

     

       310
       310
       +
       		});

     

       311
       311
       +
       

     

       312
       312
       +
       		console.log(`IRC (${to}) → Slack (action): ${actionText}`);

     

       313
       313
       +
       	},

     

       314
       314
       +
       );

     

       315
       315
       +
       

     

       130
       316
        
       // Slack event handlers

     

       131
       317
        
       slackApp.event("message", async ({ payload }) => {

     

       132
       132
       -
         if (payload.subtype) return;

     

       133
       133
       -
         if (payload.bot_id) return;

     

       134
       134
       -
         if (payload.user === botUserId) return;

     

       318
       318
       +
       	// Ignore bot messages

     

       319
       319
       +
       	if (payload.subtype && payload.subtype !== "file_share") return;

     

       320
       320
       +
       	if (payload.bot_id) return;

     

       321
       321
       +
       	if (payload.user === botUserId) return;

     

       135
       322
        
       

     

       136
       136
       -
         // Find IRC channel mapping for this Slack channel

     

       137
       137
       -
         const mapping = channelMappings.getBySlackChannel(payload.channel);

     

       138
       138
       -
         if (!mapping) {

     

       139
       139
       -
           console.log(

     

       140
       140
       -
             `No IRC channel mapping found for Slack channel ${payload.channel}`,

     

       141
       141
       -
           );

     

       142
       142
       -
           slackClient.conversations.leave({

     

       143
       143
       -
             channel: payload.channel,

     

       144
       144
       -
           });

     

       145
       145
       -
           return;

     

       146
       146
       -
         }

     

       323
       323
       +
       	// Find IRC channel mapping for this Slack channel

     

       324
       324
       +
       	const mapping = channelMappings.getBySlackChannel(payload.channel);

     

       325
       325
       +
       	if (!mapping) {

     

       326
       326
       +
       		console.log(

     

       327
       327
       +
       			`No IRC channel mapping found for Slack channel ${payload.channel}`,

     

       328
       328
       +
       		);

     

       329
       329
       +
       		slackClient.conversations.leave({

     

       330
       330
       +
       			channel: payload.channel,

     

       331
       331
       +
       		});

     

       332
       332
       +
       		return;

     

       333
       333
       +
       	}

     

       147
       334
        
       

     

       148
       148
       -
         try {

     

       149
       149
       -
           const userInfo = await slackClient.users.info({

     

       150
       150
       -
             token: process.env.SLACK_BOT_TOKEN,

     

       151
       151
       -
             user: payload.user,

     

       152
       152
       -
           });

     

       335
       335
       +
       	try {

     

       336
       336
       +
       		// Get display name from payload if available, otherwise fetch from API

     

       337
       337
       +
       		const displayNameFromEvent =

     

       338
       338
       +
       			(payload as any).user_profile?.display_name ||

     

       339
       339
       +
       			(payload as any).user_profile?.real_name ||

     

       340
       340
       +
       			(payload as any).username;

     

       153
       341
        
       

     

       154
       154
       -
           // Check for user mapping, otherwise use Slack name

     

       155
       155
       -
           const userMapping = userMappings.getBySlackUser(payload.user);

     

       156
       156
       -
           const username =

     

       157
       157
       -
             userMapping?.irc_nick ||

     

       158
       158
       -
             userInfo.user?.real_name ||

     

       159
       159
       -
             userInfo.user?.name ||

     

       160
       160
       -
             "Unknown";

     

       342
       342
       +
       		const userInfo = await getUserInfo(

     

       343
       343
       +
       			payload.user,

     

       344
       344
       +
       			slackClient,

     

       345
       345
       +
       			displayNameFromEvent,

     

       346
       346
       +
       		);

     

       161
       347
        
       

     

       162
       162
       -
           // Parse Slack mentions and replace with display names

     

       163
       163
       -
           let messageText = payload.text;

     

       164
       164
       -
           const mentionRegex = /<@(U[A-Z0-9]+)>/g;

     

       165
       165
       -
           const mentions = Array.from(messageText.matchAll(mentionRegex));

     

       348
       348
       +
       		// Check for user mapping, otherwise use Slack name

     

       349
       349
       +
       		const userMapping = userMappings.getBySlackUser(payload.user);

     

       350
       350
       +
       		const username =

     

       351
       351
       +
       			userMapping?.irc_nick ||

     

       352
       352
       +
       			userInfo?.realName ||

     

       353
       353
       +
       			userInfo?.name ||

     

       354
       354
       +
       			"Unknown";

     

       166
       355
        
       

     

       167
       167
       -
           for (const match of mentions) {

     

       168
       168
       -
             const userId = match[1];

     

       169
       169
       -
             try {

     

       170
       170
       -
               const response = await fetch(

     

       171
       171
       -
                 `https://cachet.dunkirk.sh/users/${userId}`,

     

       172
       172
       -
               );

     

       173
       173
       -
               if (response.ok) {

     

       174
       174
       -
                 const data = (await response.json()) as CachetUser;

     

       175
       175
       -
                 messageText = messageText.replace(match[0], `@${data.displayName}`);

     

       176
       176
       -
               }

     

       177
       177
       -
             } catch (error) {

     

       178
       178
       -
               console.error(`Error fetching user ${userId} from cachet:`, error);

     

       179
       179
       -
             }

     

       180
       180
       -
           }

     

       356
       356
       +
       		// Parse Slack mentions and replace with IRC nicks or display names

     

       357
       357
       +
       		let messageText = await convertSlackMentionsToIrc(payload.text);

     

       358
       358
       +
       

     

       359
       359
       +
       		// Parse Slack markdown formatting

     

       360
       360
       +
       		messageText = parseSlackMarkdown(messageText);

     

       361
       361
       +
       

     

       362
       362
       +
       		let threadId: string | undefined;

     

       363
       363
       +
       

     

       364
       364
       +
       		// Handle thread messages

     

       365
       365
       +
       		if (payload.thread_ts) {

     

       366
       366
       +
       			const threadTs = payload.thread_ts;

     

       367
       367
       +
       			const isFirstReply = isFirstThreadMessage(threadTs);

     

       368
       368
       +
       			threadId = updateThreadTimestamp(threadTs, payload.channel);

     

       369
       369
       +
       

     

       370
       370
       +
       			if (isFirstReply) {

     

       371
       371
       +
       				// First reply to thread, fetch and quote the parent message

     

       372
       372
       +
       				try {

     

       373
       373
       +
       					const parentResult = await slackClient.conversations.history({

     

       374
       374
       +
       						token: process.env.SLACK_BOT_TOKEN,

     

       375
       375
       +
       						channel: payload.channel,

     

       376
       376
       +
       						latest: threadTs,

     

       377
       377
       +
       						inclusive: true,

     

       378
       378
       +
       						limit: 1,

     

       379
       379
       +
       					});

     

       380
       380
       +
       

     

       381
       381
       +
       					if (parentResult.messages && parentResult.messages.length > 0) {

     

       382
       382
       +
       						const parentMessage = parentResult.messages[0];

     

       383
       383
       +
       						let parentText = await convertSlackMentionsToIrc(

     

       384
       384
       +
       							parentMessage.text || "",

     

       385
       385
       +
       						);

     

       386
       386
       +
       						parentText = parseSlackMarkdown(parentText);

     

       387
       387
       +
       

     

       388
       388
       +
       						// Send the quoted parent message with thread ID

     

       389
       389
       +
       						const quotedMessage = `<${username}> @${threadId} > ${parentText}`;

     

       390
       390
       +
       						ircClient.say(mapping.irc_channel, quotedMessage);

     

       391
       391
       +
       						console.log(`Slack → IRC (thread quote): ${quotedMessage}`);

     

       392
       392
       +
       					}

     

       393
       393
       +
       				} catch (error) {

     

       394
       394
       +
       					console.error("Error fetching parent message:", error);

     

       395
       395
       +
       				}

     

       396
       396
       +
       			}

     

       397
       397
       +
       

     

       398
       398
       +
       			// Add thread ID to message

     

       399
       399
       +
       			if (messageText.trim()) {

     

       400
       400
       +
       				messageText = `@${threadId} ${messageText}`;

     

       401
       401
       +
       			}

     

       402
       402
       +
       		}

     

       181
       403
        
       

     

       182
       182
       -
           // Parse Slack markdown formatting

     

       183
       183
       -
           messageText = parseSlackMarkdown(messageText);

     

       404
       404
       +
       		// Send message only if there's text content

     

       405
       405
       +
       		if (messageText.trim()) {

     

       406
       406
       +
       			const message = `<${username}> ${messageText}`;

     

       407
       407
       +
       			ircClient.say(mapping.irc_channel, message);

     

       408
       408
       +
       			console.log(`Slack → IRC: ${message}`);

     

       409
       409
       +
       		}

     

       184
       410
        
       

     

       185
       185
       -
           const message = `<${username}> ${messageText}`;

     

       411
       411
       +
       		// Handle file uploads

     

       412
       412
       +
       		if (payload.files && payload.files.length > 0) {

     

       413
       413
       +
       			try {

     

       414
       414
       +
       				const fileUrls = payload.files.map((file) => file.url_private);

     

       415
       415
       +
       				const data = await uploadToCDN(fileUrls);

     

       186
       416
        
       

     

       187
       187
       -
           ircClient.say(mapping.irc_channel, message);

     

       188
       188
       -
           console.log(`Slack → IRC: ${message}`);

     

       189
       189
       -
         } catch (error) {

     

       190
       190
       -
           console.error("Error handling Slack message:", error);

     

       191
       191
       -
         }

     

       417
       417
       +
       				for (const file of data.files) {

     

       418
       418
       +
       					const threadPrefix = threadId ? `@${threadId} ` : "";

     

       419
       419
       +
       					const fileMessage = `<${username}> ${threadPrefix}${file.deployedUrl}`;

     

       420
       420
       +
       					ircClient.say(mapping.irc_channel, fileMessage);

     

       421
       421
       +
       					console.log(`Slack → IRC (file): ${fileMessage}`);

     

       422
       422
       +
       				}

     

       423
       423
       +
       			} catch (error) {

     

       424
       424
       +
       				console.error("Error uploading files to CDN:", error);

     

       425
       425
       +
       			}

     

       426
       426
       +
       		}

     

       427
       427
       +
       	} catch (error) {

     

       428
       428
       +
       		console.error("Error handling Slack message:", error);

     

       429
       429
       +
       	}

     

       192
       430
        
       });

     

       193
       431
        
       

     

       194
       432
        
       export default {

     

       195
       195
       -
         port: process.env.PORT || 3000,

     

       196
       196
       -
         async fetch(request: Request) {

     

       197
       197
       -
           const url = new URL(request.url);

     

       198
       198
       -
           const path = url.pathname;

     

       433
       433
       +
       	port: process.env.PORT || 3000,

     

       434
       434
       +
       	async fetch(request: Request) {

     

       435
       435
       +
       		const url = new URL(request.url);

     

       436
       436
       +
       		const path = url.pathname;

     

       199
       437
        
       

     

       200
       200
       -
           switch (path) {

     

       201
       201
       -
             case "/":

     

       202
       202
       -
               return new Response(`Hello World from irc-slack-bridge@${version}`);

     

       203
       203
       -
             case "/health":

     

       204
       204
       -
               return new Response("OK");

     

       205
       205
       -
             case "/slack":

     

       206
       206
       -
               return slackApp.run(request);

     

       207
       207
       -
             default:

     

       208
       208
       -
               return new Response("404 Not Found", { status: 404 });

     

       209
       209
       -
           }

     

       210
       210
       -
         },

     

       438
       438
       +
       		switch (path) {

     

       439
       439
       +
       			case "/":

     

       440
       440
       +
       				return new Response(`Hello World from irc-slack-bridge@${version}`);

     

       441
       441
       +
       			case "/health":

     

       442
       442
       +
       				return new Response("OK");

     

       443
       443
       +
       			case "/slack":

     

       444
       444
       +
       				return slackApp.run(request);

     

       445
       445
       +
       			default:

     

       446
       446
       +
       				return new Response("404 Not Found", { status: 404 });

     

       447
       447
       +
       		}

     

       448
       448
       +
       	},

     

       211
       449
        
       };

     

       212
       450
        
       

     

       213
       451
        
       console.log(

     

       214
       214
       -
         `🚀 Server Started in ${Bun.nanoseconds() / 1000000} milliseconds on version: ${version}!\n\n----------------------------------\n`,

     

       452
       452
       +
       	`🚀 Server Started in ${Bun.nanoseconds() / 1000000} milliseconds on version: ${version}!\n\n----------------------------------\n`,

     

       215
       453
        
       );

     

       216
       454
        
       console.log(

     

       217
       217
       -
         `Connecting to IRC: irc.hackclub.com:6667 as ${process.env.IRC_NICK}`,

     

       455
       455
       +
       	`Connecting to IRC: irc.hackclub.com:6667 as ${process.env.IRC_NICK}`,

     

       218
       456
        
       );

     

       219
       457
        
       console.log(`Channel mappings: ${channelMappings.getAll().length}`);

     

       220
       458
        
       console.log(`User mappings: ${userMappings.getAll().length}`);

+44

src/lib/avatars.test.ts

···

       1
       1
       +
       import { describe, expect, test } from "bun:test";

     

       2
       2
       +
       import { getAvatarForNick } from "./avatars";

     

       3
       3
       +
       

     

       4
       4
       +
       describe("getAvatarForNick", () => {

     

       5
       5
       +
       	test("returns a valid URL", () => {

     

       6
       6
       +
       		const avatar = getAvatarForNick("testnick");

     

       7
       7
       +
       		expect(avatar).toBeString();

     

       8
       8
       +
       		expect(avatar).toStartWith("https://");

     

       9
       9
       +
       	});

     

       10
       10
       +
       

     

       11
       11
       +
       	test("returns consistent avatar for same nick", () => {

     

       12
       12
       +
       		const avatar1 = getAvatarForNick("alice");

     

       13
       13
       +
       		const avatar2 = getAvatarForNick("alice");

     

       14
       14
       +
       		expect(avatar1).toBe(avatar2);

     

       15
       15
       +
       	});

     

       16
       16
       +
       

     

       17
       17
       +
       	test("returns different avatars for different nicks", () => {

     

       18
       18
       +
       		const avatar1 = getAvatarForNick("alice");

     

       19
       19
       +
       		const avatar2 = getAvatarForNick("bob");

     

       20
       20
       +
       

     

       21
       21
       +
       		// They might occasionally be the same due to hash collisions,

     

       22
       22
       +
       		// but let's test they can be different

     

       23
       23
       +
       		expect(avatar1).toBeString();

     

       24
       24
       +
       		expect(avatar2).toBeString();

     

       25
       25
       +
       	});

     

       26
       26
       +
       

     

       27
       27
       +
       	test("handles empty string", () => {

     

       28
       28
       +
       		const avatar = getAvatarForNick("");

     

       29
       29
       +
       		expect(avatar).toBeString();

     

       30
       30
       +
       		expect(avatar).toStartWith("https://");

     

       31
       31
       +
       	});

     

       32
       32
       +
       

     

       33
       33
       +
       	test("handles special characters", () => {

     

       34
       34
       +
       		const avatar = getAvatarForNick("user-123_test");

     

       35
       35
       +
       		expect(avatar).toBeString();

     

       36
       36
       +
       		expect(avatar).toStartWith("https://");

     

       37
       37
       +
       	});

     

       38
       38
       +
       

     

       39
       39
       +
       	test("handles unicode characters", () => {

     

       40
       40
       +
       		const avatar = getAvatarForNick("用户名");

     

       41
       41
       +
       		expect(avatar).toBeString();

     

       42
       42
       +
       		expect(avatar).toStartWith("https://");

     

       43
       43
       +
       	});

     

       44
       44
       +
       });

+19

src/lib/avatars.ts

···

       1
       1
       +
       const DEFAULT_AVATARS = [

     

       2
       2
       +
       	"https://hc-cdn.hel1.your-objectstorage.com/s/v3/4183627c4d26c56c915e104a8a7374f43acd1733_pfp__1_.png",

     

       3
       3
       +
       	"https://hc-cdn.hel1.your-objectstorage.com/s/v3/389b1e6bd4248a7e5dd88e14c1adb8eb01267080_pfp__2_.png",

     

       4
       4
       +
       	"https://hc-cdn.hel1.your-objectstorage.com/s/v3/03011a5e59548191de058f33ccd1d1cb1d64f2a0_pfp__3_.png",

     

       5
       5
       +
       	"https://hc-cdn.hel1.your-objectstorage.com/s/v3/f9c57b88fbd4633114c1864bcc2968db555dbd2a_pfp__4_.png",

     

       6
       6
       +
       	"https://hc-cdn.hel1.your-objectstorage.com/s/v3/e61a8cabee5a749588125242747b65122fb94205_pfp.png",

     

       7
       7
       +
       ];

     

       8
       8
       +
       

     

       9
       9
       +
       /**

     

       10
       10
       +
        * Returns a stable avatar URL for an IRC nick based on hash

     

       11
       11
       +
        */

     

       12
       12
       +
       export function getAvatarForNick(nick: string): string {

     

       13
       13
       +
       	let hash = 0;

     

       14
       14
       +
       	for (let i = 0; i < nick.length; i++) {

     

       15
       15
       +
       		hash = (hash << 5) - hash + nick.charCodeAt(i);

     

       16
       16
       +
       		hash = hash & hash; // Convert to 32bit integer

     

       17
       17
       +
       	}

     

       18
       18
       +
       	return DEFAULT_AVATARS[Math.abs(hash) % DEFAULT_AVATARS.length] as string;

     

       19
       19
       +
       }

+21

src/lib/cachet.ts

···

       1
       1
       +
       import type { CachetUser } from "../types";

     

       2
       2
       +
       

     

       3
       3
       +
       /**

     

       4
       4
       +
        * Fetches user information from Cachet API

     

       5
       5
       +
        */

     

       6
       6
       +
       export async function getCachetUser(

     

       7
       7
       +
       	userId: string,

     

       8
       8
       +
       ): Promise<CachetUser | null> {

     

       9
       9
       +
       	try {

     

       10
       10
       +
       		const response = await fetch(`https://cachet.dunkirk.sh/users/${userId}`, {

     

       11
       11
       +
       			tls: { rejectUnauthorized: false },

     

       12
       12
       +
       		});

     

       13
       13
       +
       		if (response.ok) {

     

       14
       14
       +
       			return (await response.json()) as CachetUser;

     

       15
       15
       +
       		}

     

       16
       16
       +
       		return null;

     

       17
       17
       +
       	} catch (error) {

     

       18
       18
       +
       		console.error(`Error fetching user ${userId} from cachet:`, error);

     

       19
       19
       +
       		return null;

     

       20
       20
       +
       	}

     

       21
       21
       +
       }

+21

src/lib/cdn.ts

···

       1
       1
       +
       import type { CDNUploadResponse } from "../types";

     

       2
       2
       +
       

     

       3
       3
       +
       export async function uploadToCDN(

     

       4
       4
       +
       	fileUrls: string[],

     

       5
       5
       +
       ): Promise<CDNUploadResponse> {

     

       6
       6
       +
       	const response = await fetch("https://cdn.hackclub.com/api/v3/new", {

     

       7
       7
       +
       		method: "POST",

     

       8
       8
       +
       		headers: {

     

       9
       9
       +
       			Authorization: `Bearer ${process.env.CDN_TOKEN}`,

     

       10
       10
       +
       			"X-Download-Authorization": `Bearer ${process.env.SLACK_BOT_TOKEN}`,

     

       11
       11
       +
       			"Content-Type": "application/json",

     

       12
       12
       +
       		},

     

       13
       13
       +
       		body: JSON.stringify(fileUrls),

     

       14
       14
       +
       	});

     

       15
       15
       +
       

     

       16
       16
       +
       	if (!response.ok) {

     

       17
       17
       +
       		throw new Error(`CDN upload failed: ${response.statusText}`);

     

       18
       18
       +
       	}

     

       19
       19
       +
       

     

       20
       20
       +
       	return (await response.json()) as CDNUploadResponse;

     

       21
       21
       +
       }

+160

src/lib/db.test.ts

···

       1
       1
       +
       import { afterEach, describe, expect, test } from "bun:test";

     

       2
       2
       +
       import { channelMappings, userMappings } from "./db";

     

       3
       3
       +
       

     

       4
       4
       +
       describe("channelMappings", () => {

     

       5
       5
       +
       	const testSlackChannel = "C123TEST";

     

       6
       6
       +
       	const testIrcChannel = "#test-channel";

     

       7
       7
       +
       

     

       8
       8
       +
       	afterEach(() => {

     

       9
       9
       +
       		// Cleanup test data

     

       10
       10
       +
       		try {

     

       11
       11
       +
       			channelMappings.delete(testSlackChannel);

     

       12
       12
       +
       		} catch {

     

       13
       13
       +
       			// Ignore if doesn't exist

     

       14
       14
       +
       		}

     

       15
       15
       +
       	});

     

       16
       16
       +
       

     

       17
       17
       +
       	test("creates a channel mapping", () => {

     

       18
       18
       +
       		channelMappings.create(testSlackChannel, testIrcChannel);

     

       19
       19
       +
       		const mapping = channelMappings.getBySlackChannel(testSlackChannel);

     

       20
       20
       +
       

     

       21
       21
       +
       		expect(mapping).toBeDefined();

     

       22
       22
       +
       		expect(mapping?.slack_channel_id).toBe(testSlackChannel);

     

       23
       23
       +
       		expect(mapping?.irc_channel).toBe(testIrcChannel);

     

       24
       24
       +
       	});

     

       25
       25
       +
       

     

       26
       26
       +
       	test("retrieves mapping by Slack channel ID", () => {

     

       27
       27
       +
       		channelMappings.create(testSlackChannel, testIrcChannel);

     

       28
       28
       +
       		const mapping = channelMappings.getBySlackChannel(testSlackChannel);

     

       29
       29
       +
       

     

       30
       30
       +
       		expect(mapping).not.toBeNull();

     

       31
       31
       +
       		expect(mapping?.irc_channel).toBe(testIrcChannel);

     

       32
       32
       +
       	});

     

       33
       33
       +
       

     

       34
       34
       +
       	test("retrieves mapping by IRC channel", () => {

     

       35
       35
       +
       		channelMappings.create(testSlackChannel, testIrcChannel);

     

       36
       36
       +
       		const mapping = channelMappings.getByIrcChannel(testIrcChannel);

     

       37
       37
       +
       

     

       38
       38
       +
       		expect(mapping).not.toBeNull();

     

       39
       39
       +
       		expect(mapping?.slack_channel_id).toBe(testSlackChannel);

     

       40
       40
       +
       	});

     

       41
       41
       +
       

     

       42
       42
       +
       	test("returns null for non-existent mapping", () => {

     

       43
       43
       +
       		const mapping = channelMappings.getBySlackChannel("C999NOTFOUND");

     

       44
       44
       +
       		expect(mapping).toBeNull();

     

       45
       45
       +
       	});

     

       46
       46
       +
       

     

       47
       47
       +
       	test("deletes a channel mapping", () => {

     

       48
       48
       +
       		channelMappings.create(testSlackChannel, testIrcChannel);

     

       49
       49
       +
       		channelMappings.delete(testSlackChannel);

     

       50
       50
       +
       

     

       51
       51
       +
       		const mapping = channelMappings.getBySlackChannel(testSlackChannel);

     

       52
       52
       +
       		expect(mapping).toBeNull();

     

       53
       53
       +
       	});

     

       54
       54
       +
       

     

       55
       55
       +
       	test("replaces existing mapping on create", () => {

     

       56
       56
       +
       		channelMappings.create(testSlackChannel, "#old-channel");

     

       57
       57
       +
       		channelMappings.create(testSlackChannel, testIrcChannel);

     

       58
       58
       +
       

     

       59
       59
       +
       		const mapping = channelMappings.getBySlackChannel(testSlackChannel);

     

       60
       60
       +
       		expect(mapping?.irc_channel).toBe(testIrcChannel);

     

       61
       61
       +
       	});

     

       62
       62
       +
       

     

       63
       63
       +
       	test("getAll returns all mappings", () => {

     

       64
       64
       +
       		const testChannel2 = "C456TEST";

     

       65
       65
       +
       		const testIrc2 = "#another-channel";

     

       66
       66
       +
       

     

       67
       67
       +
       		channelMappings.create(testSlackChannel, testIrcChannel);

     

       68
       68
       +
       		channelMappings.create(testChannel2, testIrc2);

     

       69
       69
       +
       

     

       70
       70
       +
       		const all = channelMappings.getAll();

     

       71
       71
       +
       		const testMappings = all.filter(

     

       72
       72
       +
       			(m) =>

     

       73
       73
       +
       				m.slack_channel_id === testSlackChannel ||

     

       74
       74
       +
       				m.slack_channel_id === testChannel2,

     

       75
       75
       +
       		);

     

       76
       76
       +
       

     

       77
       77
       +
       		expect(testMappings.length).toBeGreaterThanOrEqual(2);

     

       78
       78
       +
       

     

       79
       79
       +
       		// Cleanup

     

       80
       80
       +
       		channelMappings.delete(testChannel2);

     

       81
       81
       +
       	});

     

       82
       82
       +
       });

     

       83
       83
       +
       

     

       84
       84
       +
       describe("userMappings", () => {

     

       85
       85
       +
       	const testSlackUser = "U123TEST";

     

       86
       86
       +
       	const testIrcNick = "testnick";

     

       87
       87
       +
       

     

       88
       88
       +
       	afterEach(() => {

     

       89
       89
       +
       		// Cleanup test data

     

       90
       90
       +
       		try {

     

       91
       91
       +
       			userMappings.delete(testSlackUser);

     

       92
       92
       +
       		} catch {

     

       93
       93
       +
       			// Ignore if doesn't exist

     

       94
       94
       +
       		}

     

       95
       95
       +
       	});

     

       96
       96
       +
       

     

       97
       97
       +
       	test("creates a user mapping", () => {

     

       98
       98
       +
       		userMappings.create(testSlackUser, testIrcNick);

     

       99
       99
       +
       		const mapping = userMappings.getBySlackUser(testSlackUser);

     

       100
       100
       +
       

     

       101
       101
       +
       		expect(mapping).toBeDefined();

     

       102
       102
       +
       		expect(mapping?.slack_user_id).toBe(testSlackUser);

     

       103
       103
       +
       		expect(mapping?.irc_nick).toBe(testIrcNick);

     

       104
       104
       +
       	});

     

       105
       105
       +
       

     

       106
       106
       +
       	test("retrieves mapping by Slack user ID", () => {

     

       107
       107
       +
       		userMappings.create(testSlackUser, testIrcNick);

     

       108
       108
       +
       		const mapping = userMappings.getBySlackUser(testSlackUser);

     

       109
       109
       +
       

     

       110
       110
       +
       		expect(mapping).not.toBeNull();

     

       111
       111
       +
       		expect(mapping?.irc_nick).toBe(testIrcNick);

     

       112
       112
       +
       	});

     

       113
       113
       +
       

     

       114
       114
       +
       	test("retrieves mapping by IRC nick", () => {

     

       115
       115
       +
       		userMappings.create(testSlackUser, testIrcNick);

     

       116
       116
       +
       		const mapping = userMappings.getByIrcNick(testIrcNick);

     

       117
       117
       +
       

     

       118
       118
       +
       		expect(mapping).not.toBeNull();

     

       119
       119
       +
       		expect(mapping?.slack_user_id).toBe(testSlackUser);

     

       120
       120
       +
       	});

     

       121
       121
       +
       

     

       122
       122
       +
       	test("returns null for non-existent mapping", () => {

     

       123
       123
       +
       		const mapping = userMappings.getBySlackUser("U999NOTFOUND");

     

       124
       124
       +
       		expect(mapping).toBeNull();

     

       125
       125
       +
       	});

     

       126
       126
       +
       

     

       127
       127
       +
       	test("deletes a user mapping", () => {

     

       128
       128
       +
       		userMappings.create(testSlackUser, testIrcNick);

     

       129
       129
       +
       		userMappings.delete(testSlackUser);

     

       130
       130
       +
       

     

       131
       131
       +
       		const mapping = userMappings.getBySlackUser(testSlackUser);

     

       132
       132
       +
       		expect(mapping).toBeNull();

     

       133
       133
       +
       	});

     

       134
       134
       +
       

     

       135
       135
       +
       	test("replaces existing mapping on create", () => {

     

       136
       136
       +
       		userMappings.create(testSlackUser, "oldnick");

     

       137
       137
       +
       		userMappings.create(testSlackUser, testIrcNick);

     

       138
       138
       +
       

     

       139
       139
       +
       		const mapping = userMappings.getBySlackUser(testSlackUser);

     

       140
       140
       +
       		expect(mapping?.irc_nick).toBe(testIrcNick);

     

       141
       141
       +
       	});

     

       142
       142
       +
       

     

       143
       143
       +
       	test("getAll returns all mappings", () => {

     

       144
       144
       +
       		const testUser2 = "U456TEST";

     

       145
       145
       +
       		const testNick2 = "anothernick";

     

       146
       146
       +
       

     

       147
       147
       +
       		userMappings.create(testSlackUser, testIrcNick);

     

       148
       148
       +
       		userMappings.create(testUser2, testNick2);

     

       149
       149
       +
       

     

       150
       150
       +
       		const all = userMappings.getAll();

     

       151
       151
       +
       		const testMappings = all.filter(

     

       152
       152
       +
       			(m) => m.slack_user_id === testSlackUser || m.slack_user_id === testUser2,

     

       153
       153
       +
       		);

     

       154
       154
       +
       

     

       155
       155
       +
       		expect(testMappings.length).toBeGreaterThanOrEqual(2);

     

       156
       156
       +
       

     

       157
       157
       +
       		// Cleanup

     

       158
       158
       +
       		userMappings.delete(testUser2);

     

       159
       159
       +
       	});

     

       160
       160
       +
       });

+255

src/lib/db.ts

···

       1
       1
       +
       import { Database } from "bun:sqlite";

     

       2
       2
       +
       

     

       3
       3
       +
       const db = new Database("bridge.db");

     

       4
       4
       +
       

     

       5
       5
       +
       db.run(`

     

       6
       6
       +
         CREATE TABLE IF NOT EXISTS channel_mappings (

     

       7
       7
       +
           id INTEGER PRIMARY KEY AUTOINCREMENT,

     

       8
       8
       +
           slack_channel_id TEXT NOT NULL UNIQUE,

     

       9
       9
       +
           irc_channel TEXT NOT NULL UNIQUE,

     

       10
       10
       +
           created_at INTEGER DEFAULT (strftime('%s', 'now'))

     

       11
       11
       +
         )

     

       12
       12
       +
       `);

     

       13
       13
       +
       

     

       14
       14
       +
       db.run(`

     

       15
       15
       +
         CREATE TABLE IF NOT EXISTS user_mappings (

     

       16
       16
       +
           id INTEGER PRIMARY KEY AUTOINCREMENT,

     

       17
       17
       +
           slack_user_id TEXT NOT NULL UNIQUE,

     

       18
       18
       +
           irc_nick TEXT NOT NULL UNIQUE,

     

       19
       19
       +
           created_at INTEGER DEFAULT (strftime('%s', 'now'))

     

       20
       20
       +
         )

     

       21
       21
       +
       `);

     

       22
       22
       +
       

     

       23
       23
       +
       // Migration: Add unique constraints if they don't exist

     

       24
       24
       +
       // SQLite doesn't support ALTER TABLE to add constraints, so we need to recreate the table

     

       25
       25
       +
       function migrateSchema() {

     

       26
       26
       +
       	// Check if irc_channel has unique constraint by examining table schema

     

       27
       27
       +
       	const channelSchema = db

     

       28
       28
       +
       		.query("SELECT sql FROM sqlite_master WHERE type='table' AND name='channel_mappings'")

     

       29
       29
       +
       		.get() as { sql: string } | null;

     

       30
       30
       +
       	

     

       31
       31
       +
       	const hasIrcChannelUnique = channelSchema?.sql?.includes("irc_channel TEXT NOT NULL UNIQUE") ?? false;

     

       32
       32
       +
       

     

       33
       33
       +
       	if (!hasIrcChannelUnique && channelSchema) {

     

       34
       34
       +
       		// Check if table has any data with duplicate irc_channel values

     

       35
       35
       +
       		const duplicates = db.query(

     

       36
       36
       +
       			"SELECT irc_channel, COUNT(*) as count FROM channel_mappings GROUP BY irc_channel HAVING count > 1",

     

       37
       37
       +
       		).all();

     

       38
       38
       +
       

     

       39
       39
       +
       		if (duplicates.length > 0) {

     

       40
       40
       +
       			console.warn(

     

       41
       41
       +
       				"Warning: Found duplicate IRC channel mappings. Keeping only the most recent mapping for each IRC channel.",

     

       42
       42
       +
       			);

     

       43
       43
       +
       			for (const dup of duplicates as { irc_channel: string }[]) {

     

       44
       44
       +
       				// Delete all but the most recent mapping for this IRC channel

     

       45
       45
       +
       				db.run(

     

       46
       46
       +
       					`DELETE FROM channel_mappings 

     

       47
       47
       +
       					 WHERE irc_channel = ? 

     

       48
       48
       +
       					 AND id NOT IN (

     

       49
       49
       +
       					   SELECT id FROM channel_mappings 

     

       50
       50
       +
       					   WHERE irc_channel = ? 

     

       51
       51
       +
       					   ORDER BY created_at DESC 

     

       52
       52
       +
       					   LIMIT 1

     

       53
       53
       +
       					 )`,

     

       54
       54
       +
       					[dup.irc_channel, dup.irc_channel],

     

       55
       55
       +
       				);

     

       56
       56
       +
       			}

     

       57
       57
       +
       		}

     

       58
       58
       +
       

     

       59
       59
       +
       		// Recreate the table with unique constraint

     

       60
       60
       +
       		db.run(`

     

       61
       61
       +
       			CREATE TABLE channel_mappings_new (

     

       62
       62
       +
       				id INTEGER PRIMARY KEY AUTOINCREMENT,

     

       63
       63
       +
       				slack_channel_id TEXT NOT NULL UNIQUE,

     

       64
       64
       +
       				irc_channel TEXT NOT NULL UNIQUE,

     

       65
       65
       +
       				created_at INTEGER DEFAULT (strftime('%s', 'now'))

     

       66
       66
       +
       			)

     

       67
       67
       +
       		`);

     

       68
       68
       +
       

     

       69
       69
       +
       		db.run(

     

       70
       70
       +
       			"INSERT INTO channel_mappings_new SELECT * FROM channel_mappings",

     

       71
       71
       +
       		);

     

       72
       72
       +
       		db.run("DROP TABLE channel_mappings");

     

       73
       73
       +
       		db.run("ALTER TABLE channel_mappings_new RENAME TO channel_mappings");

     

       74
       74
       +
       		console.log("Migrated channel_mappings table to add unique constraint on irc_channel");

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

       77
       77
       +
       	// Check if irc_nick has unique constraint by examining table schema

     

       78
       78
       +
       	const userSchema = db

     

       79
       79
       +
       		.query("SELECT sql FROM sqlite_master WHERE type='table' AND name='user_mappings'")

     

       80
       80
       +
       		.get() as { sql: string } | null;

     

       81
       81
       +
       	

     

       82
       82
       +
       	const hasIrcNickUnique = userSchema?.sql?.includes("irc_nick TEXT NOT NULL UNIQUE") ?? false;

     

       83
       83
       +
       

     

       84
       84
       +
       	if (!hasIrcNickUnique && userSchema) {

     

       85
       85
       +
       		// Check if table has any data with duplicate irc_nick values

     

       86
       86
       +
       		const duplicates = db.query(

     

       87
       87
       +
       			"SELECT irc_nick, COUNT(*) as count FROM user_mappings GROUP BY irc_nick HAVING count > 1",

     

       88
       88
       +
       		).all();

     

       89
       89
       +
       

     

       90
       90
       +
       		if (duplicates.length > 0) {

     

       91
       91
       +
       			console.warn(

     

       92
       92
       +
       				"Warning: Found duplicate IRC nick mappings. Keeping only the most recent mapping for each IRC nick.",

     

       93
       93
       +
       			);

     

       94
       94
       +
       			for (const dup of duplicates as { irc_nick: string }[]) {

     

       95
       95
       +
       				// Delete all but the most recent mapping for this IRC nick

     

       96
       96
       +
       				db.run(

     

       97
       97
       +
       					`DELETE FROM user_mappings 

     

       98
       98
       +
       					 WHERE irc_nick = ? 

     

       99
       99
       +
       					 AND id NOT IN (

     

       100
       100
       +
       					   SELECT id FROM user_mappings 

     

       101
       101
       +
       					   WHERE irc_nick = ? 

     

       102
       102
       +
       					   ORDER BY created_at DESC 

     

       103
       103
       +
       					   LIMIT 1

     

       104
       104
       +
       					 )`,

     

       105
       105
       +
       					[dup.irc_nick, dup.irc_nick],

     

       106
       106
       +
       				);

     

       107
       107
       +
       			}

     

       108
       108
       +
       		}

     

       109
       109
       +
       

     

       110
       110
       +
       		// Recreate the table with unique constraint

     

       111
       111
       +
       		db.run(`

     

       112
       112
       +
       			CREATE TABLE user_mappings_new (

     

       113
       113
       +
       				id INTEGER PRIMARY KEY AUTOINCREMENT,

     

       114
       114
       +
       				slack_user_id TEXT NOT NULL UNIQUE,

     

       115
       115
       +
       				irc_nick TEXT NOT NULL UNIQUE,

     

       116
       116
       +
       				created_at INTEGER DEFAULT (strftime('%s', 'now'))

     

       117
       117
       +
       			)

     

       118
       118
       +
       		`);

     

       119
       119
       +
       

     

       120
       120
       +
       		db.run("INSERT INTO user_mappings_new SELECT * FROM user_mappings");

     

       121
       121
       +
       		db.run("DROP TABLE user_mappings");

     

       122
       122
       +
       		db.run("ALTER TABLE user_mappings_new RENAME TO user_mappings");

     

       123
       123
       +
       		console.log("Migrated user_mappings table to add unique constraint on irc_nick");

     

       124
       124
       +
       	}

     

       125
       125
       +
       }

     

       126
       126
       +
       

     

       127
       127
       +
       migrateSchema();

     

       128
       128
       +
       

     

       129
       129
       +
       db.run(`

     

       130
       130
       +
         CREATE TABLE IF NOT EXISTS thread_timestamps (

     

       131
       131
       +
           thread_ts TEXT PRIMARY KEY,

     

       132
       132
       +
           thread_id TEXT NOT NULL UNIQUE,

     

       133
       133
       +
           slack_channel_id TEXT NOT NULL,

     

       134
       134
       +
           last_message_time INTEGER NOT NULL

     

       135
       135
       +
         )

     

       136
       136
       +
       `);

     

       137
       137
       +
       

     

       138
       138
       +
       db.run(`

     

       139
       139
       +
         CREATE INDEX IF NOT EXISTS idx_thread_id ON thread_timestamps(thread_id)

     

       140
       140
       +
       `);

     

       141
       141
       +
       

     

       142
       142
       +
       export interface ChannelMapping {

     

       143
       143
       +
       	id?: number;

     

       144
       144
       +
       	slack_channel_id: string;

     

       145
       145
       +
       	irc_channel: string;

     

       146
       146
       +
       	created_at?: number;

     

       147
       147
       +
       }

     

       148
       148
       +
       

     

       149
       149
       +
       export interface UserMapping {

     

       150
       150
       +
       	id?: number;

     

       151
       151
       +
       	slack_user_id: string;

     

       152
       152
       +
       	irc_nick: string;

     

       153
       153
       +
       	created_at?: number;

     

       154
       154
       +
       }

     

       155
       155
       +
       

     

       156
       156
       +
       export const channelMappings = {

     

       157
       157
       +
       	getAll(): ChannelMapping[] {

     

       158
       158
       +
       		return db.query("SELECT * FROM channel_mappings").all() as ChannelMapping[];

     

       159
       159
       +
       	},

     

       160
       160
       +
       

     

       161
       161
       +
       	getBySlackChannel(slackChannelId: string): ChannelMapping | null {

     

       162
       162
       +
       		return db

     

       163
       163
       +
       			.query("SELECT * FROM channel_mappings WHERE slack_channel_id = ?")

     

       164
       164
       +
       			.get(slackChannelId) as ChannelMapping | null;

     

       165
       165
       +
       	},

     

       166
       166
       +
       

     

       167
       167
       +
       	getByIrcChannel(ircChannel: string): ChannelMapping | null {

     

       168
       168
       +
       		return db

     

       169
       169
       +
       			.query("SELECT * FROM channel_mappings WHERE irc_channel = ?")

     

       170
       170
       +
       			.get(ircChannel) as ChannelMapping | null;

     

       171
       171
       +
       	},

     

       172
       172
       +
       

     

       173
       173
       +
       	create(slackChannelId: string, ircChannel: string): void {

     

       174
       174
       +
       		db.run(

     

       175
       175
       +
       			"INSERT OR REPLACE INTO channel_mappings (slack_channel_id, irc_channel) VALUES (?, ?)",

     

       176
       176
       +
       			[slackChannelId, ircChannel],

     

       177
       177
       +
       		);

     

       178
       178
       +
       	},

     

       179
       179
       +
       

     

       180
       180
       +
       	delete(slackChannelId: string): void {

     

       181
       181
       +
       		db.run("DELETE FROM channel_mappings WHERE slack_channel_id = ?", [

     

       182
       182
       +
       			slackChannelId,

     

       183
       183
       +
       		]);

     

       184
       184
       +
       	},

     

       185
       185
       +
       };

     

       186
       186
       +
       

     

       187
       187
       +
       export const userMappings = {

     

       188
       188
       +
       	getAll(): UserMapping[] {

     

       189
       189
       +
       		return db.query("SELECT * FROM user_mappings").all() as UserMapping[];

     

       190
       190
       +
       	},

     

       191
       191
       +
       

     

       192
       192
       +
       	getBySlackUser(slackUserId: string): UserMapping | null {

     

       193
       193
       +
       		return db

     

       194
       194
       +
       			.query("SELECT * FROM user_mappings WHERE slack_user_id = ?")

     

       195
       195
       +
       			.get(slackUserId) as UserMapping | null;

     

       196
       196
       +
       	},

     

       197
       197
       +
       

     

       198
       198
       +
       	getByIrcNick(ircNick: string): UserMapping | null {

     

       199
       199
       +
       		return db

     

       200
       200
       +
       			.query("SELECT * FROM user_mappings WHERE irc_nick = ?")

     

       201
       201
       +
       			.get(ircNick) as UserMapping | null;

     

       202
       202
       +
       	},

     

       203
       203
       +
       

     

       204
       204
       +
       	create(slackUserId: string, ircNick: string): void {

     

       205
       205
       +
       		db.run(

     

       206
       206
       +
       			"INSERT OR REPLACE INTO user_mappings (slack_user_id, irc_nick) VALUES (?, ?)",

     

       207
       207
       +
       			[slackUserId, ircNick],

     

       208
       208
       +
       		);

     

       209
       209
       +
       	},

     

       210
       210
       +
       

     

       211
       211
       +
       	delete(slackUserId: string): void {

     

       212
       212
       +
       		db.run("DELETE FROM user_mappings WHERE slack_user_id = ?", [slackUserId]);

     

       213
       213
       +
       	},

     

       214
       214
       +
       };

     

       215
       215
       +
       

     

       216
       216
       +
       export interface ThreadInfo {

     

       217
       217
       +
       	thread_ts: string;

     

       218
       218
       +
       	thread_id: string;

     

       219
       219
       +
       	slack_channel_id: string;

     

       220
       220
       +
       	last_message_time: number;

     

       221
       221
       +
       }

     

       222
       222
       +
       

     

       223
       223
       +
       export const threadTimestamps = {

     

       224
       224
       +
       	get(threadTs: string): ThreadInfo | null {

     

       225
       225
       +
       		return db

     

       226
       226
       +
       			.query("SELECT * FROM thread_timestamps WHERE thread_ts = ?")

     

       227
       227
       +
       			.get(threadTs) as ThreadInfo | null;

     

       228
       228
       +
       	},

     

       229
       229
       +
       

     

       230
       230
       +
       	getByThreadId(threadId: string): ThreadInfo | null {

     

       231
       231
       +
       		return db

     

       232
       232
       +
       			.query("SELECT * FROM thread_timestamps WHERE thread_id = ?")

     

       233
       233
       +
       			.get(threadId) as ThreadInfo | null;

     

       234
       234
       +
       	},

     

       235
       235
       +
       

     

       236
       236
       +
       	update(

     

       237
       237
       +
       		threadTs: string,

     

       238
       238
       +
       		threadId: string,

     

       239
       239
       +
       		slackChannelId: string,

     

       240
       240
       +
       		timestamp: number,

     

       241
       241
       +
       	): void {

     

       242
       242
       +
       		db.run(

     

       243
       243
       +
       			"INSERT OR REPLACE INTO thread_timestamps (thread_ts, thread_id, slack_channel_id, last_message_time) VALUES (?, ?, ?, ?)",

     

       244
       244
       +
       			[threadTs, threadId, slackChannelId, timestamp],

     

       245
       245
       +
       		);

     

       246
       246
       +
       	},

     

       247
       247
       +
       

     

       248
       248
       +
       	cleanup(olderThan: number): void {

     

       249
       249
       +
       		db.run("DELETE FROM thread_timestamps WHERE last_message_time < ?", [

     

       250
       250
       +
       			olderThan,

     

       251
       251
       +
       		]);

     

       252
       252
       +
       	},

     

       253
       253
       +
       };

     

       254
       254
       +
       

     

       255
       255
       +
       export default db;

+56

src/lib/mentions.test.ts

···

       1
       1
       +
       import { describe, expect, test } from "bun:test";

     

       2
       2
       +
       import { convertIrcMentionsToSlack } from "./mentions";

     

       3
       3
       +
       import { userMappings } from "./db";

     

       4
       4
       +
       

     

       5
       5
       +
       describe("convertIrcMentionsToSlack", () => {

     

       6
       6
       +
       	test("converts @mention when user mapping exists", () => {

     

       7
       7
       +
       		// Setup test data

     

       8
       8
       +
       		userMappings.create("U123", "testuser");

     

       9
       9
       +
       

     

       10
       10
       +
       		const result = convertIrcMentionsToSlack("Hey @testuser how are you?");

     

       11
       11
       +
       		expect(result).toBe("Hey <@U123> how are you?");

     

       12
       12
       +
       

     

       13
       13
       +
       		// Cleanup

     

       14
       14
       +
       		userMappings.delete("U123");

     

       15
       15
       +
       	});

     

       16
       16
       +
       

     

       17
       17
       +
       	test("leaves @mention unchanged when no mapping exists", () => {

     

       18
       18
       +
       		const result = convertIrcMentionsToSlack("Hey @unknownuser");

     

       19
       19
       +
       		expect(result).toBe("Hey @unknownuser");

     

       20
       20
       +
       	});

     

       21
       21
       +
       

     

       22
       22
       +
       	test("converts nick: mention when user mapping exists", () => {

     

       23
       23
       +
       		userMappings.create("U456", "alice");

     

       24
       24
       +
       

     

       25
       25
       +
       		const result = convertIrcMentionsToSlack("alice: hello");

     

       26
       26
       +
       		expect(result).toBe("<@U456>: hello");

     

       27
       27
       +
       

     

       28
       28
       +
       		userMappings.delete("U456");

     

       29
       29
       +
       	});

     

       30
       30
       +
       

     

       31
       31
       +
       	test("leaves nick: unchanged when no mapping exists", () => {

     

       32
       32
       +
       		const result = convertIrcMentionsToSlack("bob: hello");

     

       33
       33
       +
       		expect(result).toBe("bob: hello");

     

       34
       34
       +
       	});

     

       35
       35
       +
       

     

       36
       36
       +
       	test("handles multiple mentions", () => {

     

       37
       37
       +
       		userMappings.create("U123", "alice");

     

       38
       38
       +
       		userMappings.create("U456", "bob");

     

       39
       39
       +
       

     

       40
       40
       +
       		const result = convertIrcMentionsToSlack("@alice and bob: hello!");

     

       41
       41
       +
       		expect(result).toBe("<@U123> and <@U456>: hello!");

     

       42
       42
       +
       

     

       43
       43
       +
       		userMappings.delete("U123");

     

       44
       44
       +
       		userMappings.delete("U456");

     

       45
       45
       +
       	});

     

       46
       46
       +
       

     

       47
       47
       +
       	test("handles mixed mapped and unmapped mentions", () => {

     

       48
       48
       +
       		userMappings.create("U123", "alice");

     

       49
       49
       +
       

     

       50
       50
       +
       		const result = convertIrcMentionsToSlack("@alice and @unknown user");

     

       51
       51
       +
       		expect(result).toContain("<@U123>");

     

       52
       52
       +
       		expect(result).toContain("@unknown");

     

       53
       53
       +
       

     

       54
       54
       +
       		userMappings.delete("U123");

     

       55
       55
       +
       	});

     

       56
       56
       +
       });

+79

src/lib/mentions.ts

···

       1
       1
       +
       import { getCachetUser } from "./cachet";

     

       2
       2
       +
       import { userMappings } from "./db";

     

       3
       3
       +
       

     

       4
       4
       +
       /**

     

       5
       5
       +
        * Converts IRC @mentions and nick: mentions to Slack user mentions

     

       6
       6
       +
        */

     

       7
       7
       +
       export function convertIrcMentionsToSlack(messageText: string): string {

     

       8
       8
       +
       	let result = messageText;

     

       9
       9
       +
       

     

       10
       10
       +
       	// Find all @mentions and nick: mentions in the IRC message

     

       11
       11
       +
       	const atMentionPattern = /@(\w+)/g;

     

       12
       12
       +
       	const nickMentionPattern = /(\w+):/g;

     

       13
       13
       +
       

     

       14
       14
       +
       	const atMentions = Array.from(result.matchAll(atMentionPattern));

     

       15
       15
       +
       	const nickMentions = Array.from(result.matchAll(nickMentionPattern));

     

       16
       16
       +
       

     

       17
       17
       +
       	for (const match of atMentions) {

     

       18
       18
       +
       		const mentionedNick = match[1] as string;

     

       19
       19
       +
       		const mentionedUserMapping = userMappings.getByIrcNick(mentionedNick);

     

       20
       20
       +
       		if (mentionedUserMapping) {

     

       21
       21
       +
       			result = result.replace(

     

       22
       22
       +
       				match[0],

     

       23
       23
       +
       				`<@${mentionedUserMapping.slack_user_id}>`,

     

       24
       24
       +
       			);

     

       25
       25
       +
       		}

     

       26
       26
       +
       	}

     

       27
       27
       +
       

     

       28
       28
       +
       	for (const match of nickMentions) {

     

       29
       29
       +
       		const mentionedNick = match[1] as string;

     

       30
       30
       +
       		const mentionedUserMapping = userMappings.getByIrcNick(mentionedNick);

     

       31
       31
       +
       		if (mentionedUserMapping) {

     

       32
       32
       +
       			result = result.replace(

     

       33
       33
       +
       				match[0],

     

       34
       34
       +
       				`<@${mentionedUserMapping.slack_user_id}>:`,

     

       35
       35
       +
       			);

     

       36
       36
       +
       		}

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	return result;

     

       40
       40
       +
       }

     

       41
       41
       +
       

     

       42
       42
       +
       /**

     

       43
       43
       +
        * Converts Slack user mentions to IRC @mentions

     

       44
       44
       +
        * Priority: user mappings > display name from mention > Cachet lookup

     

       45
       45
       +
        */

     

       46
       46
       +
       export async function convertSlackMentionsToIrc(

     

       47
       47
       +
       	messageText: string,

     

       48
       48
       +
       ): Promise<string> {

     

       49
       49
       +
       	let result = messageText;

     

       50
       50
       +
       	const mentionRegex = /<@(U[A-Z0-9]+)(\|([^>]+))?>/g;

     

       51
       51
       +
       	const mentions = Array.from(result.matchAll(mentionRegex));

     

       52
       52
       +
       

     

       53
       53
       +
       	for (const match of mentions) {

     

       54
       54
       +
       		const userId = match[1] as string;

     

       55
       55
       +
       		const displayName = match[3] as string; // The name part after |

     

       56
       56
       +
       

     

       57
       57
       +
       		// Check if user has a mapped IRC nick

     

       58
       58
       +
       		const mentionedUserMapping = userMappings.getBySlackUser(userId);

     

       59
       59
       +
       		if (mentionedUserMapping) {

     

       60
       60
       +
       			result = result.replace(match[0], `@${mentionedUserMapping.irc_nick}`);

     

       61
       61
       +
       		} else {

     

       62
       62
       +
       			// Try Cachet lookup if enabled

     

       63
       63
       +
       			if (process.env.CACHET_ENABLED === "true") {

     

       64
       64
       +
       				const data = await getCachetUser(userId);

     

       65
       65
       +
       				if (data) {

     

       66
       66
       +
       					result = result.replace(match[0], `@${data.displayName}`);

     

       67
       67
       +
       					continue;

     

       68
       68
       +
       				}

     

       69
       69
       +
       			}

     

       70
       70
       +
       

     

       71
       71
       +
       			// Fallback to display name from the mention format <@U123|name>

     

       72
       72
       +
       			if (displayName) {

     

       73
       73
       +
       				result = result.replace(match[0], `@${displayName}`);

     

       74
       74
       +
       			}

     

       75
       75
       +
       		}

     

       76
       76
       +
       	}

     

       77
       77
       +
       

     

       78
       78
       +
       	return result;

     

       79
       79
       +
       }

+137

src/lib/parser.test.ts

···

       1
       1
       +
       import { describe, expect, test } from "bun:test";

     

       2
       2
       +
       import { parseIRCFormatting, parseSlackMarkdown } from "./parser";

     

       3
       3
       +
       

     

       4
       4
       +
       describe("parseSlackMarkdown", () => {

     

       5
       5
       +
       	test("converts channel mentions with name", () => {

     

       6
       6
       +
       		const result = parseSlackMarkdown("Check out <#C123ABC|general>");

     

       7
       7
       +
       		expect(result).toBe("Check out #general");

     

       8
       8
       +
       	});

     

       9
       9
       +
       

     

       10
       10
       +
       	test("converts channel mentions without name", () => {

     

       11
       11
       +
       		const result = parseSlackMarkdown("Check out <#C123ABC>");

     

       12
       12
       +
       		expect(result).toBe("Check out #channel");

     

       13
       13
       +
       	});

     

       14
       14
       +
       

     

       15
       15
       +
       	test("converts links with text", () => {

     

       16
       16
       +
       		const result = parseSlackMarkdown(

     

       17
       17
       +
       			"Visit <https://example.com|Example Site>",

     

       18
       18
       +
       		);

     

       19
       19
       +
       		expect(result).toBe("Visit Example Site (https://example.com)");

     

       20
       20
       +
       	});

     

       21
       21
       +
       

     

       22
       22
       +
       	test("converts links without text", () => {

     

       23
       23
       +
       		const result = parseSlackMarkdown("Visit <https://example.com>");

     

       24
       24
       +
       		expect(result).toBe("Visit https://example.com");

     

       25
       25
       +
       	});

     

       26
       26
       +
       

     

       27
       27
       +
       	test("converts mailto links", () => {

     

       28
       28
       +
       		const result = parseSlackMarkdown(

     

       29
       29
       +
       			"Email <mailto:test@example.com|Support>",

     

       30
       30
       +
       		);

     

       31
       31
       +
       		expect(result).toBe("Email Support <test@example.com>");

     

       32
       32
       +
       	});

     

       33
       33
       +
       

     

       34
       34
       +
       	test("converts special mentions", () => {

     

       35
       35
       +
       		expect(parseSlackMarkdown("<!here> everyone")).toBe("@here everyone");

     

       36
       36
       +
       		expect(parseSlackMarkdown("<!channel> announcement")).toBe(

     

       37
       37
       +
       			"@channel announcement",

     

       38
       38
       +
       		);

     

       39
       39
       +
       		expect(parseSlackMarkdown("<!everyone> alert")).toBe("@everyone alert");

     

       40
       40
       +
       	});

     

       41
       41
       +
       

     

       42
       42
       +
       	test("converts user group mentions", () => {

     

       43
       43
       +
       		const result = parseSlackMarkdown("Hey <!subteam^GROUP123|developers>");

     

       44
       44
       +
       		expect(result).toBe("Hey @developers");

     

       45
       45
       +
       	});

     

       46
       46
       +
       

     

       47
       47
       +
       	test("converts bold formatting", () => {

     

       48
       48
       +
       		const result = parseSlackMarkdown("This is *bold* text");

     

       49
       49
       +
       		expect(result).toBe("This is \x02bold\x02 text");

     

       50
       50
       +
       	});

     

       51
       51
       +
       

     

       52
       52
       +
       	test("converts italic formatting", () => {

     

       53
       53
       +
       		const result = parseSlackMarkdown("This is _italic_ text");

     

       54
       54
       +
       		expect(result).toBe("This is \x1Ditalic\x1D text");

     

       55
       55
       +
       	});

     

       56
       56
       +
       

     

       57
       57
       +
       	test("strips strikethrough formatting", () => {

     

       58
       58
       +
       		const result = parseSlackMarkdown("This is ~strikethrough~ text");

     

       59
       59
       +
       		expect(result).toBe("This is strikethrough text");

     

       60
       60
       +
       	});

     

       61
       61
       +
       

     

       62
       62
       +
       	test("strips code blocks", () => {

     

       63
       63
       +
       		const result = parseSlackMarkdown("Code: ```const x = 1;```");

     

       64
       64
       +
       		expect(result).toBe("Code: const x = 1;");

     

       65
       65
       +
       	});

     

       66
       66
       +
       

     

       67
       67
       +
       	test("strips inline code", () => {

     

       68
       68
       +
       		const result = parseSlackMarkdown("Run `npm install` to start");

     

       69
       69
       +
       		expect(result).toBe("Run npm install to start");

     

       70
       70
       +
       	});

     

       71
       71
       +
       

     

       72
       72
       +
       	test("unescapes HTML entities", () => {

     

       73
       73
       +
       		const result = parseSlackMarkdown("a &lt; b &amp;&amp; c &gt; d");

     

       74
       74
       +
       		expect(result).toBe("a < b && c > d");

     

       75
       75
       +
       	});

     

       76
       76
       +
       

     

       77
       77
       +
       	test("handles mixed formatting", () => {

     

       78
       78
       +
       		const result = parseSlackMarkdown(

     

       79
       79
       +
       			"*Bold* and _italic_ with <https://example.com|link>",

     

       80
       80
       +
       		);

     

       81
       81
       +
       		expect(result).toBe(

     

       82
       82
       +
       			"\x02Bold\x02 and \x1Ditalic\x1D with link (https://example.com)",

     

       83
       83
       +
       		);

     

       84
       84
       +
       	});

     

       85
       85
       +
       });

     

       86
       86
       +
       

     

       87
       87
       +
       describe("parseIRCFormatting", () => {

     

       88
       88
       +
       	test("strips IRC color codes", () => {

     

       89
       89
       +
       		const result = parseIRCFormatting("\x0304red text\x03 normal");

     

       90
       90
       +
       		expect(result).toBe("red text normal");

     

       91
       91
       +
       	});

     

       92
       92
       +
       

     

       93
       93
       +
       	test("converts bold formatting", () => {

     

       94
       94
       +
       		const result = parseIRCFormatting("This is \x02bold\x02 text");

     

       95
       95
       +
       		expect(result).toBe("This is *bold* text");

     

       96
       96
       +
       	});

     

       97
       97
       +
       

     

       98
       98
       +
       	test("converts italic formatting", () => {

     

       99
       99
       +
       		const result = parseIRCFormatting("This is \x1Ditalic\x1D text");

     

       100
       100
       +
       		expect(result).toBe("This is _italic_ text");

     

       101
       101
       +
       	});

     

       102
       102
       +
       

     

       103
       103
       +
       	test("converts underline to italic", () => {

     

       104
       104
       +
       		const result = parseIRCFormatting("This is \x1Funderline\x1F text");

     

       105
       105
       +
       		expect(result).toBe("This is _underline_ text");

     

       106
       106
       +
       	});

     

       107
       107
       +
       

     

       108
       108
       +
       	test("strips reverse/inverse formatting", () => {

     

       109
       109
       +
       		const result = parseIRCFormatting("Normal \x16reversed\x16 normal");

     

       110
       110
       +
       		expect(result).toBe("Normal reversed normal");

     

       111
       111
       +
       	});

     

       112
       112
       +
       

     

       113
       113
       +
       	test("strips reset formatting", () => {

     

       114
       114
       +
       		const result = parseIRCFormatting("Text\x0F reset");

     

       115
       115
       +
       		expect(result).toBe("Text reset");

     

       116
       116
       +
       	});

     

       117
       117
       +
       

     

       118
       118
       +
       	test("escapes special Slack characters", () => {

     

       119
       119
       +
       		const result = parseIRCFormatting("a < b & c > d");

     

       120
       120
       +
       		expect(result).toBe("a &lt; b &amp; c &gt; d");

     

       121
       121
       +
       	});

     

       122
       122
       +
       

     

       123
       123
       +
       	test("handles mixed formatting", () => {

     

       124
       124
       +
       		const result = parseIRCFormatting("\x02Bold\x02 and \x1Ditalic\x1D");

     

       125
       125
       +
       		expect(result).toBe("*Bold* and _italic_");

     

       126
       126
       +
       	});

     

       127
       127
       +
       

     

       128
       128
       +
       	test("handles nested formatting codes", () => {

     

       129
       129
       +
       		const result = parseIRCFormatting("\x02\x1Dbold italic\x1D\x02");

     

       130
       130
       +
       		expect(result).toBe("*_bold italic_*");

     

       131
       131
       +
       	});

     

       132
       132
       +
       

     

       133
       133
       +
       	test("handles color codes with background", () => {

     

       134
       134
       +
       		const result = parseIRCFormatting("\x0304,08red on yellow\x03");

     

       135
       135
       +
       		expect(result).toBe("red on yellow");

     

       136
       136
       +
       	});

     

       137
       137
       +
       });

+88

src/lib/parser.ts

···

       1
       1
       +
       /**

     

       2
       2
       +
        * Parse Slack mrkdwn formatting and convert to IRC-friendly plain text

     

       3
       3
       +
        */

     

       4
       4
       +
       export function parseSlackMarkdown(text: string): string {

     

       5
       5
       +
       	let parsed = text;

     

       6
       6
       +
       

     

       7
       7
       +
       	// Replace channel mentions <#C123ABC|channel-name> or <#C123ABC>

     

       8
       8
       +
       	parsed = parsed.replace(/<#[A-Z0-9]+\|([^>]+)>/g, "#$1");

     

       9
       9
       +
       	parsed = parsed.replace(/<#[A-Z0-9]+>/g, "#channel");

     

       10
       10
       +
       

     

       11
       11
       +
       	// Replace links <http://example.com|text> or <http://example.com>

     

       12
       12
       +
       	parsed = parsed.replace(/<(https?:\/\/[^|>]+)\|([^>]+)>/g, "$2 ($1)");

     

       13
       13
       +
       	parsed = parsed.replace(/<(https?:\/\/[^>]+)>/g, "$1");

     

       14
       14
       +
       

     

       15
       15
       +
       	// Replace mailto links <mailto:email|text>

     

       16
       16
       +
       	parsed = parsed.replace(/<mailto:([^|>]+)\|([^>]+)>/g, "$2 <$1>");

     

       17
       17
       +
       	parsed = parsed.replace(/<mailto:([^>]+)>/g, "$1");

     

       18
       18
       +
       

     

       19
       19
       +
       	// Replace special mentions

     

       20
       20
       +
       	parsed = parsed.replace(/<!here>/g, "@here");

     

       21
       21
       +
       	parsed = parsed.replace(/<!channel>/g, "@channel");

     

       22
       22
       +
       	parsed = parsed.replace(/<!everyone>/g, "@everyone");

     

       23
       23
       +
       

     

       24
       24
       +
       	// Replace user group mentions <!subteam^GROUP_ID|handle>

     

       25
       25
       +
       	parsed = parsed.replace(/<!subteam\^[A-Z0-9]+\|([^>]+)>/g, "@$1");

     

       26
       26
       +
       	parsed = parsed.replace(/<!subteam\^[A-Z0-9]+>/g, "@group");

     

       27
       27
       +
       

     

       28
       28
       +
       	// Date formatting - just use fallback text

     

       29
       29
       +
       	parsed = parsed.replace(/<!date\^[0-9]+\^[^|]+\|([^>]+)>/g, "$1");

     

       30
       30
       +
       

     

       31
       31
       +
       	// Replace Slack bold *text* with IRC bold \x02text\x02

     

       32
       32
       +
       	parsed = parsed.replace(/\*((?:[^*]|\\\*)+)\*/g, "\x02$1\x02");

     

       33
       33
       +
       

     

       34
       34
       +
       	// Replace Slack italic _text_ with IRC italic \x1Dtext\x1D

     

       35
       35
       +
       	parsed = parsed.replace(/_((?:[^_]|\\_)+)_/g, "\x1D$1\x1D");

     

       36
       36
       +
       

     

       37
       37
       +
       	// Replace Slack strikethrough ~text~ with plain text (IRC doesn't support strikethrough well)

     

       38
       38
       +
       	parsed = parsed.replace(/~((?:[^~]|\\~)+)~/g, "$1");

     

       39
       39
       +
       

     

       40
       40
       +
       	// Replace code blocks ```code``` with plain text

     

       41
       41
       +
       	parsed = parsed.replace(/```([^`]+)```/g, "$1");

     

       42
       42
       +
       

     

       43
       43
       +
       	// Replace inline code `code` with plain text

     

       44
       44
       +
       	parsed = parsed.replace(/`([^`]+)`/g, "$1");

     

       45
       45
       +
       

     

       46
       46
       +
       	// Handle block quotes - prefix with >

     

       47
       47
       +
       	parsed = parsed.replace(/^>/gm, ">");

     

       48
       48
       +
       

     

       49
       49
       +
       	// Unescape HTML entities

     

       50
       50
       +
       	parsed = parsed.replace(/&amp;/g, "&");

     

       51
       51
       +
       	parsed = parsed.replace(/&lt;/g, "<");

     

       52
       52
       +
       	parsed = parsed.replace(/&gt;/g, ">");

     

       53
       53
       +
       

     

       54
       54
       +
       	return parsed;

     

       55
       55
       +
       }

     

       56
       56
       +
       

     

       57
       57
       +
       /**

     

       58
       58
       +
        * Parse IRC formatting codes and convert to Slack mrkdwn

     

       59
       59
       +
        */

     

       60
       60
       +
       export function parseIRCFormatting(text: string): string {

     

       61
       61
       +
       	let parsed = text;

     

       62
       62
       +
       

     

       63
       63
       +
       	// IRC color codes - strip them (Slack doesn't support colors in the same way)

     

       64
       64
       +
       	// \x03 followed by optional color codes

     

       65
       65
       +
       	parsed = parsed.replace(/\x03(\d{1,2}(,\d{1,2})?)?/g, "");

     

       66
       66
       +
       

     

       67
       67
       +
       	// IRC bold \x02text\x02 -> Slack bold *text*

     

       68
       68
       +
       	parsed = parsed.replace(/\x02([^\x02]*)\x02/g, "*$1*");

     

       69
       69
       +
       

     

       70
       70
       +
       	// IRC italic \x1D text\x1D -> Slack italic _text_

     

       71
       71
       +
       	parsed = parsed.replace(/\x1D([^\x1D]*)\x1D/g, "_$1_");

     

       72
       72
       +
       

     

       73
       73
       +
       	// IRC underline \x1F text\x1F -> Slack doesn't have underline, use italic instead

     

       74
       74
       +
       	parsed = parsed.replace(/\x1F([^\x1F]*)\x1F/g, "_$1_");

     

       75
       75
       +
       

     

       76
       76
       +
       	// IRC reverse/inverse \x16 - strip it (Slack doesn't support)

     

       77
       77
       +
       	parsed = parsed.replace(/\x16/g, "");

     

       78
       78
       +
       

     

       79
       79
       +
       	// IRC reset \x0F - strip it

     

       80
       80
       +
       	parsed = parsed.replace(/\x0F/g, "");

     

       81
       81
       +
       

     

       82
       82
       +
       	// Escape special Slack characters that would be interpreted as formatting

     

       83
       83
       +
       	parsed = parsed.replace(/&/g, "&amp;");

     

       84
       84
       +
       	parsed = parsed.replace(/</g, "&lt;");

     

       85
       85
       +
       	parsed = parsed.replace(/>/g, "&gt;");

     

       86
       86
       +
       

     

       87
       87
       +
       	return parsed;

     

       88
       88
       +
       }

+99

src/lib/permissions.ts

···

       1
       1
       +
       interface SlackChannel {

     

       2
       2
       +
       	id: string;

     

       3
       3
       +
       	created: number;

     

       4
       4
       +
       	creator: string;

     

       5
       5
       +
       	name: string;

     

       6
       6
       +
       	is_channel: boolean;

     

       7
       7
       +
       	is_private: boolean;

     

       8
       8
       +
       	is_archived: boolean;

     

       9
       9
       +
       	[key: string]: unknown;

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       interface ConversationsInfoResponse {

     

       13
       13
       +
       	ok: boolean;

     

       14
       14
       +
       	channel?: SlackChannel;

     

       15
       15
       +
       	error?: string;

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       interface RoleAssignmentsResponse {

     

       19
       19
       +
       	ok: boolean;

     

       20
       20
       +
       	role_assignments?: Array<{

     

       21
       21
       +
       		users: string[];

     

       22
       22
       +
       	}>;

     

       23
       23
       +
       	error?: string;

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       /**

     

       27
       27
       +
        * Check if a user has permission to manage a Slack channel

     

       28
       28
       +
        * Returns true if the user is:

     

       29
       29
       +
        * - A global admin (in ADMINS env var)

     

       30
       30
       +
        * - The channel creator

     

       31
       31
       +
        * - A channel manager

     

       32
       32
       +
        */

     

       33
       33
       +
       export async function canManageChannel(

     

       34
       34
       +
       	userId: string,

     

       35
       35
       +
       	channelId: string,

     

       36
       36
       +
       ): Promise<boolean> {

     

       37
       37
       +
       	// Check if user is a global admin

     

       38
       38
       +
       	const admins = process.env.ADMINS?.split(",").map((id) => id.trim()) || [];

     

       39
       39
       +
       	if (admins.includes(userId)) {

     

       40
       40
       +
       		return true;

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

       43
       43
       +
       	try {

     

       44
       44
       +
       		// Check if user is channel creator

     

       45
       45
       +
       		const formdata = new FormData();

     

       46
       46
       +
       		formdata.append("channel", channelId);

     

       47
       47
       +
       

     

       48
       48
       +
       		const channelInfo: ConversationsInfoResponse = (await fetch(

     

       49
       49
       +
       			"https://slack.com/api/conversations.info",

     

       50
       50
       +
       			{

     

       51
       51
       +
       				method: "POST",

     

       52
       52
       +
       				headers: {

     

       53
       53
       +
       					Authorization: `Bearer ${process.env.SLACK_BOT_TOKEN}`,

     

       54
       54
       +
       				},

     

       55
       55
       +
       				body: formdata,

     

       56
       56
       +
       			},

     

       57
       57
       +
       		).then((res) => res.json())) as ConversationsInfoResponse;

     

       58
       58
       +
       

     

       59
       59
       +
       		if (channelInfo.ok && channelInfo.channel?.creator === userId) {

     

       60
       60
       +
       			return true;

     

       61
       61
       +
       		}

     

       62
       62
       +
       

     

       63
       63
       +
       		// Check if user is a channel manager

     

       64
       64
       +
       		if (

     

       65
       65
       +
       			process.env.SLACK_USER_COOKIE &&

     

       66
       66
       +
       			process.env.SLACK_USER_TOKEN &&

     

       67
       67
       +
       			process.env.SLACK_API_URL

     

       68
       68
       +
       		) {

     

       69
       69
       +
       			const formdata = new FormData();

     

       70
       70
       +
       			formdata.append("token", process.env.SLACK_USER_TOKEN);

     

       71
       71
       +
       			formdata.append("entity_id", channelId);

     

       72
       72
       +
       

     

       73
       73
       +
       			const response = await fetch(

     

       74
       74
       +
       				`${process.env.SLACK_API_URL}/api/admin.roles.entity.listAssignments`,

     

       75
       75
       +
       				{

     

       76
       76
       +
       					method: "POST",

     

       77
       77
       +
       					headers: {

     

       78
       78
       +
       						Cookie: process.env.SLACK_USER_COOKIE,

     

       79
       79
       +
       					},

     

       80
       80
       +
       					body: formdata,

     

       81
       81
       +
       				},

     

       82
       82
       +
       			);

     

       83
       83
       +
       

     

       84
       84
       +
       			const json: RoleAssignmentsResponse =

     

       85
       85
       +
       				(await response.json()) as RoleAssignmentsResponse;

     

       86
       86
       +
       

     

       87
       87
       +
       			if (json.ok) {

     

       88
       88
       +
       				const managers = json.role_assignments?.[0]?.users || [];

     

       89
       89
       +
       				if (managers.includes(userId)) {

     

       90
       90
       +
       					return true;

     

       91
       91
       +
       				}

     

       92
       92
       +
       			}

     

       93
       93
       +
       		}

     

       94
       94
       +
       	} catch (error) {

     

       95
       95
       +
       		console.error("Error checking channel permissions:", error);

     

       96
       96
       +
       	}

     

       97
       97
       +
       

     

       98
       98
       +
       	return false;

     

       99
       99
       +
       }

+106

src/lib/threads.test.ts

···

       1
       1
       +
       import { afterEach, beforeEach, describe, expect, test } from "bun:test";

     

       2
       2
       +
       import {

     

       3
       3
       +
       	generateThreadId,

     

       4
       4
       +
       	getThreadByThreadId,

     

       5
       5
       +
       	isFirstThreadMessage,

     

       6
       6
       +
       	updateThreadTimestamp,

     

       7
       7
       +
       } from "./threads";

     

       8
       8
       +
       import { threadTimestamps } from "./db";

     

       9
       9
       +
       

     

       10
       10
       +
       describe("threads", () => {

     

       11
       11
       +
       	const testChannelId = "C123TEST";

     

       12
       12
       +
       	const testThreadTs = "1234567890.123456";

     

       13
       13
       +
       

     

       14
       14
       +
       	afterEach(() => {

     

       15
       15
       +
       		// Clean up test data

     

       16
       16
       +
       		const thread = threadTimestamps.get(testThreadTs);

     

       17
       17
       +
       		if (thread) {

     

       18
       18
       +
       			threadTimestamps.cleanup(Date.now() + 1000);

     

       19
       19
       +
       		}

     

       20
       20
       +
       	});

     

       21
       21
       +
       

     

       22
       22
       +
       	describe("generateThreadId", () => {

     

       23
       23
       +
       		test("generates a 5-character thread ID", () => {

     

       24
       24
       +
       			const threadId = generateThreadId(testThreadTs);

     

       25
       25
       +
       			expect(threadId).toBeString();

     

       26
       26
       +
       			expect(threadId.length).toBe(5);

     

       27
       27
       +
       		});

     

       28
       28
       +
       

     

       29
       29
       +
       		test("generates consistent IDs for same input", () => {

     

       30
       30
       +
       			const id1 = generateThreadId(testThreadTs);

     

       31
       31
       +
       			const id2 = generateThreadId(testThreadTs);

     

       32
       32
       +
       			expect(id1).toBe(id2);

     

       33
       33
       +
       		});

     

       34
       34
       +
       

     

       35
       35
       +
       		test("generates different IDs for different inputs", () => {

     

       36
       36
       +
       			const id1 = generateThreadId("1234567890.123456");

     

       37
       37
       +
       			const id2 = generateThreadId("9876543210.654321");

     

       38
       38
       +
       			expect(id1).not.toBe(id2);

     

       39
       39
       +
       		});

     

       40
       40
       +
       

     

       41
       41
       +
       		test("generates alphanumeric IDs", () => {

     

       42
       42
       +
       			const threadId = generateThreadId(testThreadTs);

     

       43
       43
       +
       			expect(threadId).toMatch(/^[a-z0-9]{5}$/);

     

       44
       44
       +
       		});

     

       45
       45
       +
       	});

     

       46
       46
       +
       

     

       47
       47
       +
       	describe("isFirstThreadMessage", () => {

     

       48
       48
       +
       		test("returns true for new thread", () => {

     

       49
       49
       +
       			const result = isFirstThreadMessage(testThreadTs);

     

       50
       50
       +
       			expect(result).toBe(true);

     

       51
       51
       +
       		});

     

       52
       52
       +
       

     

       53
       53
       +
       		test("returns false for existing thread", () => {

     

       54
       54
       +
       			updateThreadTimestamp(testThreadTs, testChannelId);

     

       55
       55
       +
       			const result = isFirstThreadMessage(testThreadTs);

     

       56
       56
       +
       			expect(result).toBe(false);

     

       57
       57
       +
       		});

     

       58
       58
       +
       	});

     

       59
       59
       +
       

     

       60
       60
       +
       	describe("updateThreadTimestamp", () => {

     

       61
       61
       +
       		test("creates new thread entry", () => {

     

       62
       62
       +
       			const threadId = updateThreadTimestamp(testThreadTs, testChannelId);

     

       63
       63
       +
       

     

       64
       64
       +
       			expect(threadId).toBeString();

     

       65
       65
       +
       			expect(threadId.length).toBe(5);

     

       66
       66
       +
       

     

       67
       67
       +
       			const thread = threadTimestamps.get(testThreadTs);

     

       68
       68
       +
       			expect(thread).toBeDefined();

     

       69
       69
       +
       			expect(thread?.thread_id).toBe(threadId);

     

       70
       70
       +
       			expect(thread?.slack_channel_id).toBe(testChannelId);

     

       71
       71
       +
       		});

     

       72
       72
       +
       

     

       73
       73
       +
       		test("updates existing thread timestamp", () => {

     

       74
       74
       +
       			const threadId1 = updateThreadTimestamp(testThreadTs, testChannelId);

     

       75
       75
       +
       			const thread1 = threadTimestamps.get(testThreadTs);

     

       76
       76
       +
       			const timestamp1 = thread1?.last_message_time;

     

       77
       77
       +
       

     

       78
       78
       +
       			// Wait a bit to ensure timestamp changes

     

       79
       79
       +
       			Bun.sleepSync(10);

     

       80
       80
       +
       

     

       81
       81
       +
       			const threadId2 = updateThreadTimestamp(testThreadTs, testChannelId);

     

       82
       82
       +
       			const thread2 = threadTimestamps.get(testThreadTs);

     

       83
       83
       +
       			const timestamp2 = thread2?.last_message_time;

     

       84
       84
       +
       

     

       85
       85
       +
       			expect(threadId1).toBe(threadId2);

     

       86
       86
       +
       			expect(timestamp2).toBeGreaterThan(timestamp1!);

     

       87
       87
       +
       		});

     

       88
       88
       +
       	});

     

       89
       89
       +
       

     

       90
       90
       +
       	describe("getThreadByThreadId", () => {

     

       91
       91
       +
       		test("retrieves thread by thread ID", () => {

     

       92
       92
       +
       			const threadId = updateThreadTimestamp(testThreadTs, testChannelId);

     

       93
       93
       +
       			const thread = getThreadByThreadId(threadId);

     

       94
       94
       +
       

     

       95
       95
       +
       			expect(thread).toBeDefined();

     

       96
       96
       +
       			expect(thread?.thread_ts).toBe(testThreadTs);

     

       97
       97
       +
       			expect(thread?.thread_id).toBe(threadId);

     

       98
       98
       +
       			expect(thread?.slack_channel_id).toBe(testChannelId);

     

       99
       99
       +
       		});

     

       100
       100
       +
       

     

       101
       101
       +
       		test("returns null for non-existent thread ID", () => {

     

       102
       102
       +
       			const thread = getThreadByThreadId("xxxxx");

     

       103
       103
       +
       			expect(thread).toBeNull();

     

       104
       104
       +
       		});

     

       105
       105
       +
       	});

     

       106
       106
       +
       });

+51

src/lib/threads.ts

···

       1
       1
       +
       import { threadTimestamps } from "./db";

     

       2
       2
       +
       

     

       3
       3
       +
       const THREAD_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes

     

       4
       4
       +
       

     

       5
       5
       +
       /**

     

       6
       6
       +
        * Generate a short 5-character thread ID from thread_ts

     

       7
       7
       +
        */

     

       8
       8
       +
       export function generateThreadId(threadTs: string): string {

     

       9
       9
       +
       	let hash = 0;

     

       10
       10
       +
       	for (let i = 0; i < threadTs.length; i++) {

     

       11
       11
       +
       		hash = (hash << 5) - hash + threadTs.charCodeAt(i);

     

       12
       12
       +
       		hash = hash & hash;

     

       13
       13
       +
       	}

     

       14
       14
       +
       	// Convert to base36 and take first 5 characters

     

       15
       15
       +
       	return Math.abs(hash).toString(36).substring(0, 5);

     

       16
       16
       +
       }

     

       17
       17
       +
       

     

       18
       18
       +
       /**

     

       19
       19
       +
        * Check if this is the first message in a thread (thread doesn't exist in DB yet)

     

       20
       20
       +
        */

     

       21
       21
       +
       export function isFirstThreadMessage(threadTs: string): boolean {

     

       22
       22
       +
       	const thread = threadTimestamps.get(threadTs);

     

       23
       23
       +
       	return !thread;

     

       24
       24
       +
       }

     

       25
       25
       +
       

     

       26
       26
       +
       /**

     

       27
       27
       +
        * Get thread info by thread ID

     

       28
       28
       +
        */

     

       29
       29
       +
       export function getThreadByThreadId(threadId: string) {

     

       30
       30
       +
       	return threadTimestamps.getByThreadId(threadId);

     

       31
       31
       +
       }

     

       32
       32
       +
       

     

       33
       33
       +
       /**

     

       34
       34
       +
        * Update the last message time for a thread

     

       35
       35
       +
        */

     

       36
       36
       +
       export function updateThreadTimestamp(

     

       37
       37
       +
       	threadTs: string,

     

       38
       38
       +
       	slackChannelId: string,

     

       39
       39
       +
       ): string {

     

       40
       40
       +
       	const threadId = generateThreadId(threadTs);

     

       41
       41
       +
       	threadTimestamps.update(threadTs, threadId, slackChannelId, Date.now());

     

       42
       42
       +
       	return threadId;

     

       43
       43
       +
       }

     

       44
       44
       +
       

     

       45
       45
       +
       /**

     

       46
       46
       +
        * Clean up old thread entries (optional, for memory management)

     

       47
       47
       +
        */

     

       48
       48
       +
       export function cleanupOldThreads(): void {

     

       49
       49
       +
       	const cutoff = Date.now() - THREAD_TIMEOUT_MS * 2;

     

       50
       50
       +
       	threadTimestamps.cleanup(cutoff);

     

       51
       51
       +
       }

+168

src/lib/user-cache.test.ts

···

       1
       1
       +
       import { afterEach, describe, expect, mock, test } from "bun:test";

     

       2
       2
       +
       import { cleanupUserCache, getUserInfo } from "./user-cache";

     

       3
       3
       +
       

     

       4
       4
       +
       describe("user-cache", () => {

     

       5
       5
       +
       	const mockSlackClient = {

     

       6
       6
       +
       		users: {

     

       7
       7
       +
       			info: mock(async () => ({

     

       8
       8
       +
       				user: {

     

       9
       9
       +
       					name: "testuser",

     

       10
       10
       +
       					real_name: "Test User",

     

       11
       11
       +
       				},

     

       12
       12
       +
       			})),

     

       13
       13
       +
       		},

     

       14
       14
       +
       	};

     

       15
       15
       +
       

     

       16
       16
       +
       	afterEach(() => {

     

       17
       17
       +
       		cleanupUserCache();

     

       18
       18
       +
       		mockSlackClient.users.info.mockClear();

     

       19
       19
       +
       		mockSlackClient.users.info.mockReset();

     

       20
       20
       +
       	});

     

       21
       21
       +
       

     

       22
       22
       +
       	describe("getUserInfo", () => {

     

       23
       23
       +
       		test("uses display name from event if provided", async () => {

     

       24
       24
       +
       			const client = {

     

       25
       25
       +
       				users: {

     

       26
       26
       +
       					info: mock(async () => ({

     

       27
       27
       +
       						user: {

     

       28
       28
       +
       							name: "testuser",

     

       29
       29
       +
       							real_name: "Test User",

     

       30
       30
       +
       						},

     

       31
       31
       +
       					})),

     

       32
       32
       +
       				},

     

       33
       33
       +
       			};

     

       34
       34
       +
       

     

       35
       35
       +
       			const result = await getUserInfo("U123", client, "Event Display Name");

     

       36
       36
       +
       

     

       37
       37
       +
       			expect(result).toEqual({

     

       38
       38
       +
       				name: "Event Display Name",

     

       39
       39
       +
       				realName: "Event Display Name",

     

       40
       40
       +
       			});

     

       41
       41
       +
       			// Should not call API when display name provided

     

       42
       42
       +
       			expect(client.users.info).toHaveBeenCalledTimes(0);

     

       43
       43
       +
       		});

     

       44
       44
       +
       

     

       45
       45
       +
       		test("fetches user info from Slack on cache miss", async () => {

     

       46
       46
       +
       			const client = {

     

       47
       47
       +
       				users: {

     

       48
       48
       +
       					info: mock(async () => ({

     

       49
       49
       +
       						user: {

     

       50
       50
       +
       							name: "testuser",

     

       51
       51
       +
       							real_name: "Test User",

     

       52
       52
       +
       						},

     

       53
       53
       +
       					})),

     

       54
       54
       +
       				},

     

       55
       55
       +
       			};

     

       56
       56
       +
       

     

       57
       57
       +
       			const result = await getUserInfo("U125", client);

     

       58
       58
       +
       

     

       59
       59
       +
       			expect(result).toEqual({

     

       60
       60
       +
       				name: "testuser",

     

       61
       61
       +
       				realName: "Test User",

     

       62
       62
       +
       			});

     

       63
       63
       +
       			expect(client.users.info).toHaveBeenCalledTimes(1);

     

       64
       64
       +
       		});

     

       65
       65
       +
       

     

       66
       66
       +
       		test("returns cached data on cache hit", async () => {

     

       67
       67
       +
       			const client = {

     

       68
       68
       +
       				users: {

     

       69
       69
       +
       					info: mock(async () => ({

     

       70
       70
       +
       						user: {

     

       71
       71
       +
       							name: "testuser",

     

       72
       72
       +
       							real_name: "Test User",

     

       73
       73
       +
       						},

     

       74
       74
       +
       					})),

     

       75
       75
       +
       				},

     

       76
       76
       +
       			};

     

       77
       77
       +
       

     

       78
       78
       +
       			// First call - cache miss

     

       79
       79
       +
       			await getUserInfo("U124", client);

     

       80
       80
       +
       			expect(client.users.info).toHaveBeenCalledTimes(1);

     

       81
       81
       +
       

     

       82
       82
       +
       			// Second call - cache hit

     

       83
       83
       +
       			const result = await getUserInfo("U124", client);

     

       84
       84
       +
       			expect(result).toEqual({

     

       85
       85
       +
       				name: "testuser",

     

       86
       86
       +
       				realName: "Test User",

     

       87
       87
       +
       			});

     

       88
       88
       +
       			expect(client.users.info).toHaveBeenCalledTimes(1); // Still 1

     

       89
       89
       +
       		});

     

       90
       90
       +
       

     

       91
       91
       +
       		test("uses name as fallback for real_name", async () => {

     

       92
       92
       +
       			const client = {

     

       93
       93
       +
       				users: {

     

       94
       94
       +
       					info: mock(async () => ({

     

       95
       95
       +
       						user: {

     

       96
       96
       +
       							name: "testuser",

     

       97
       97
       +
       						},

     

       98
       98
       +
       					})),

     

       99
       99
       +
       				},

     

       100
       100
       +
       			};

     

       101
       101
       +
       

     

       102
       102
       +
       			const result = await getUserInfo("U456", client);

     

       103
       103
       +
       			expect(result).toEqual({

     

       104
       104
       +
       				name: "testuser",

     

       105
       105
       +
       				realName: "testuser",

     

       106
       106
       +
       			});

     

       107
       107
       +
       		});

     

       108
       108
       +
       

     

       109
       109
       +
       		test("handles missing user data gracefully", async () => {

     

       110
       110
       +
       			const client = {

     

       111
       111
       +
       				users: {

     

       112
       112
       +
       					info: mock(async () => ({})),

     

       113
       113
       +
       				},

     

       114
       114
       +
       			};

     

       115
       115
       +
       

     

       116
       116
       +
       			const result = await getUserInfo("U789", client);

     

       117
       117
       +
       			expect(result).toEqual({

     

       118
       118
       +
       				name: "Unknown",

     

       119
       119
       +
       				realName: "Unknown",

     

       120
       120
       +
       			});

     

       121
       121
       +
       		});

     

       122
       122
       +
       

     

       123
       123
       +
       		test("handles Slack API errors", async () => {

     

       124
       124
       +
       			const client = {

     

       125
       125
       +
       				users: {

     

       126
       126
       +
       					info: mock(async () => {

     

       127
       127
       +
       						throw new Error("API Error");

     

       128
       128
       +
       					}),

     

       129
       129
       +
       				},

     

       130
       130
       +
       			};

     

       131
       131
       +
       

     

       132
       132
       +
       			const result = await getUserInfo("U999", client);

     

       133
       133
       +
       			expect(result).toBeNull();

     

       134
       134
       +
       		});

     

       135
       135
       +
       

     

       136
       136
       +
       		test("caches different users separately", async () => {

     

       137
       137
       +
       			const client = {

     

       138
       138
       +
       				users: {

     

       139
       139
       +
       					info: mock(async ({ user }: { user: string }) => {

     

       140
       140
       +
       						if (user === "U111") {

     

       141
       141
       +
       							return { user: { name: "alice", real_name: "Alice" } };

     

       142
       142
       +
       						}

     

       143
       143
       +
       						return { user: { name: "bob", real_name: "Bob" } };

     

       144
       144
       +
       					}),

     

       145
       145
       +
       				},

     

       146
       146
       +
       			};

     

       147
       147
       +
       

     

       148
       148
       +
       			const result1 = await getUserInfo("U111", client);

     

       149
       149
       +
       			const result2 = await getUserInfo("U222", client);

     

       150
       150
       +
       

     

       151
       151
       +
       			expect(result1?.name).toBe("alice");

     

       152
       152
       +
       			expect(result2?.name).toBe("bob");

     

       153
       153
       +
       			expect(client.users.info).toHaveBeenCalledTimes(2);

     

       154
       154
       +
       

     

       155
       155
       +
       			// Both should be cached now

     

       156
       156
       +
       			await getUserInfo("U111", client);

     

       157
       157
       +
       			await getUserInfo("U222", client);

     

       158
       158
       +
       			expect(client.users.info).toHaveBeenCalledTimes(2); // Still 2

     

       159
       159
       +
       		});

     

       160
       160
       +
       	});

     

       161
       161
       +
       

     

       162
       162
       +
       	describe("cleanupUserCache", () => {

     

       163
       163
       +
       		test("cleanup runs without errors", () => {

     

       164
       164
       +
       			// Just test that cleanup doesn't throw

     

       165
       165
       +
       			expect(() => cleanupUserCache()).not.toThrow();

     

       166
       166
       +
       		});

     

       167
       167
       +
       	});

     

       168
       168
       +
       });

+104

src/lib/user-cache.ts

···

       1
       1
       +
       import { getCachetUser } from "./cachet";

     

       2
       2
       +
       

     

       3
       3
       +
       interface CachedUserInfo {

     

       4
       4
       +
       	name: string;

     

       5
       5
       +
       	realName: string;

     

       6
       6
       +
       	timestamp: number;

     

       7
       7
       +
       }

     

       8
       8
       +
       

     

       9
       9
       +
       interface SlackClient {

     

       10
       10
       +
       	users: {

     

       11
       11
       +
       		info: (params: { token: string; user: string }) => Promise<{

     

       12
       12
       +
       			user?: {

     

       13
       13
       +
       				name?: string;

     

       14
       14
       +
       				real_name?: string;

     

       15
       15
       +
       			};

     

       16
       16
       +
       		}>;

     

       17
       17
       +
       	};

     

       18
       18
       +
       }

     

       19
       19
       +
       

     

       20
       20
       +
       const userCache = new Map<string, CachedUserInfo>();

     

       21
       21
       +
       const CACHE_TTL = 60 * 60 * 1000; // 1 hour

     

       22
       22
       +
       

     

       23
       23
       +
       /**

     

       24
       24
       +
        * Get user info from cache or fetch from Cachet (if enabled) or Slack API

     

       25
       25
       +
        * If displayName is provided (from Slack event), use that directly and cache it

     

       26
       26
       +
        */

     

       27
       27
       +
       export async function getUserInfo(

     

       28
       28
       +
       	userId: string,

     

       29
       29
       +
       	slackClient: SlackClient,

     

       30
       30
       +
       	displayName?: string,

     

       31
       31
       +
       ): Promise<{ name: string; realName: string } | null> {

     

       32
       32
       +
       	const cached = userCache.get(userId);

     

       33
       33
       +
       	const now = Date.now();

     

       34
       34
       +
       

     

       35
       35
       +
       	if (cached && now - cached.timestamp < CACHE_TTL) {

     

       36
       36
       +
       		return { name: cached.name, realName: cached.realName };

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

       39
       39
       +
       	// If we have a display name from the event, use it directly

     

       40
       40
       +
       	if (displayName) {

     

       41
       41
       +
       		userCache.set(userId, {

     

       42
       42
       +
       			name: displayName,

     

       43
       43
       +
       			realName: displayName,

     

       44
       44
       +
       			timestamp: now,

     

       45
       45
       +
       		});

     

       46
       46
       +
       

     

       47
       47
       +
       		return { name: displayName, realName: displayName };

     

       48
       48
       +
       	}

     

       49
       49
       +
       

     

       50
       50
       +
       	// Try Cachet first if enabled (it has its own caching)

     

       51
       51
       +
       	if (process.env.CACHET_ENABLED === "true") {

     

       52
       52
       +
       		try {

     

       53
       53
       +
       			const cachetUser = await getCachetUser(userId);

     

       54
       54
       +
       			if (cachetUser) {

     

       55
       55
       +
       				const name = cachetUser.displayName || "Unknown";

     

       56
       56
       +
       				const realName = cachetUser.displayName || "Unknown";

     

       57
       57
       +
       

     

       58
       58
       +
       				userCache.set(userId, {

     

       59
       59
       +
       					name,

     

       60
       60
       +
       					realName,

     

       61
       61
       +
       					timestamp: now,

     

       62
       62
       +
       				});

     

       63
       63
       +
       

     

       64
       64
       +
       				return { name, realName };

     

       65
       65
       +
       			}

     

       66
       66
       +
       		} catch (error) {

     

       67
       67
       +
       			console.error(`Error fetching user from Cachet for ${userId}:`, error);

     

       68
       68
       +
       		}

     

       69
       69
       +
       	}

     

       70
       70
       +
       

     

       71
       71
       +
       	// Fallback to Slack API

     

       72
       72
       +
       	try {

     

       73
       73
       +
       		const userInfo = await slackClient.users.info({

     

       74
       74
       +
       			token: process.env.SLACK_BOT_TOKEN,

     

       75
       75
       +
       			user: userId,

     

       76
       76
       +
       		});

     

       77
       77
       +
       

     

       78
       78
       +
       		const name = userInfo.user?.name || "Unknown";

     

       79
       79
       +
       		const realName = userInfo.user?.real_name || name;

     

       80
       80
       +
       

     

       81
       81
       +
       		userCache.set(userId, {

     

       82
       82
       +
       			name,

     

       83
       83
       +
       			realName,

     

       84
       84
       +
       			timestamp: now,

     

       85
       85
       +
       		});

     

       86
       86
       +
       

     

       87
       87
       +
       		return { name, realName };

     

       88
       88
       +
       	} catch (error) {

     

       89
       89
       +
       		console.error(`Error fetching user info for ${userId}:`, error);

     

       90
       90
       +
       		return null;

     

       91
       91
       +
       	}

     

       92
       92
       +
       }

     

       93
       93
       +
       

     

       94
       94
       +
       /**

     

       95
       95
       +
        * Clear expired entries from cache

     

       96
       96
       +
        */

     

       97
       97
       +
       export function cleanupUserCache(): void {

     

       98
       98
       +
       	const now = Date.now();

     

       99
       99
       +
       	for (const [userId, info] of userCache.entries()) {

     

       100
       100
       +
       		if (now - info.timestamp > CACHE_TTL) {

     

       101
       101
       +
       			userCache.delete(userId);

     

       102
       102
       +
       		}

     

       103
       103
       +
       	}

     

       104
       104
       +
       }

-89

src/parser.ts

···

       1
       1
       -
       /**

     

       2
       2
       -
        * Parse Slack mrkdwn formatting and convert to IRC-friendly plain text

     

       3
       3
       -
        */

     

       4
       4
       -
       export function parseSlackMarkdown(text: string): string {

     

       5
       5
       -
       	let parsed = text;

     

       6
       6
       -
       

     

       7
       7
       -
       	// Replace channel mentions <#C123ABC|channel-name> or <#C123ABC>

     

       8
       8
       -
       	parsed = parsed.replace(/<#[A-Z0-9]+\|([^>]+)>/g, "#$1");

     

       9
       9
       -
       	parsed = parsed.replace(/<#[A-Z0-9]+>/g, "#channel");

     

       10
       10
       -
       

     

       11
       11
       -
       	// Replace links <http://example.com|text> or <http://example.com>

     

       12
       12
       -
       	parsed = parsed.replace(/<(https?:\/\/[^|>]+)\|([^>]+)>/g, "$2 ($1)");

     

       13
       13
       -
       	parsed = parsed.replace(/<(https?:\/\/[^>]+)>/g, "$1");

     

       14
       14
       -
       

     

       15
       15
       -
       	// Replace mailto links <mailto:email|text>

     

       16
       16
       -
       	parsed = parsed.replace(/<mailto:([^|>]+)\|([^>]+)>/g, "$2 <$1>");

     

       17
       17
       -
       	parsed = parsed.replace(/<mailto:([^>]+)>/g, "$1");

     

       18
       18
       -
       

     

       19
       19
       -
       	// Replace special mentions

     

       20
       20
       -
       	parsed = parsed.replace(/<!here>/g, "@here");

     

       21
       21
       -
       	parsed = parsed.replace(/<!channel>/g, "@channel");

     

       22
       22
       -
       	parsed = parsed.replace(/<!everyone>/g, "@everyone");

     

       23
       23
       -
       

     

       24
       24
       -
       	// Replace user group mentions <!subteam^GROUP_ID|handle>

     

       25
       25
       -
       	parsed = parsed.replace(/<!subteam\^[A-Z0-9]+\|([^>]+)>/g, "@$1");

     

       26
       26
       -
       	parsed = parsed.replace(/<!subteam\^[A-Z0-9]+>/g, "@group");

     

       27
       27
       -
       

     

       28
       28
       -
       	// Date formatting - just use fallback text

     

       29
       29
       -
       	parsed = parsed.replace(/<!date\^[0-9]+\^[^|]+\|([^>]+)>/g, "$1");

     

       30
       30
       -
       

     

       31
       31
       -
       	// Replace Slack bold *text* with IRC bold \x02text\x02

     

       32
       32
       -
       	parsed = parsed.replace(/\*((?:[^\*]|\\\*)+)\*/g, "\x02$1\x02");

     

       33
       33
       -
       

     

       34
       34
       -
       	// Replace Slack italic _text_ with IRC italic \x1Dtext\x1D

     

       35
       35
       -
       	parsed = parsed.replace(/_((?:[^_]|\\_)+)_/g, "\x1D$1\x1D");

     

       36
       36
       -
       

     

       37
       37
       -
       	// Replace Slack strikethrough ~text~ with plain text (IRC doesn't support strikethrough well)

     

       38
       38
       -
       	parsed = parsed.replace(/~((?:[^~]|\\~)+)~/g, "$1");

     

       39
       39
       -
       

     

       40
       40
       -
       	// Replace code blocks ```code``` with plain text

     

       41
       41
       -
       	parsed = parsed.replace(/```([^`]+)```/g, "$1");

     

       42
       42
       -
       

     

       43
       43
       -
       	// Replace inline code `code` with plain text

     

       44
       44
       -
       	parsed = parsed.replace(/`([^`]+)`/g, "$1");

     

       45
       45
       -
       

     

       46
       46
       -
       	// Handle block quotes - prefix with >

     

       47
       47
       -
       	parsed = parsed.replace(/^>/gm, ">");

     

       48
       48
       -
       

     

       49
       49
       -
       	// Unescape HTML entities

     

       50
       50
       -
       	parsed = parsed.replace(/&amp;/g, "&");

     

       51
       51
       -
       	parsed = parsed.replace(/&lt;/g, "<");

     

       52
       52
       -
       	parsed = parsed.replace(/&gt;/g, ">");

     

       53
       53
       -
       

     

       54
       54
       -
       	return parsed;

     

       55
       55
       -
       }

     

       56
       56
       -
       

     

       57
       57
       -
       /**

     

       58
       58
       -
        * Parse IRC formatting codes and convert to Slack mrkdwn

     

       59
       59
       -
        */

     

       60
       60
       -
       export function parseIRCFormatting(text: string): string {

     

       61
       61
       -
       	let parsed = text;

     

       62
       62
       -
       

     

       63
       63
       -
       	// IRC color codes - strip them (Slack doesn't support colors in the same way)

     

       64
       64
       -
       	// \x03 followed by optional color codes

     

       65
       65
       -
       	parsed = parsed.replace(/\x03(\d{1,2}(,\d{1,2})?)?/g, "");

     

       66
       66
       -
       

     

       67
       67
       -
       	// IRC bold \x02text\x02 -> Slack bold *text*

     

       68
       68
       -
       	parsed = parsed.replace(/\x02([^\x02]*)\x02/g, "*$1*");

     

       69
       69
       -
       

     

       70
       70
       -
       	// IRC italic \x1D text\x1D -> Slack italic _text_

     

       71
       71
       -
       	parsed = parsed.replace(/\x1D([^\x1D]*)\x1D/g, "_$1_");

     

       72
       72
       -
       

     

       73
       73
       -
       	// IRC underline \x1F text\x1F -> Slack doesn't have underline, use italic instead

     

       74
       74
       -
       	parsed = parsed.replace(/\x1F([^\x1F]*)\x1F/g, "_$1_");

     

       75
       75
       -
       

     

       76
       76
       -
       	// IRC reverse/inverse \x16 - strip it (Slack doesn't support)

     

       77
       77
       -
       	parsed = parsed.replace(/\x16/g, "");

     

       78
       78
       -
       

     

       79
       79
       -
       	// IRC reset \x0F - strip it

     

       80
       80
       -
       	parsed = parsed.replace(/\x0F/g, "");

     

       81
       81
       -
       

     

       82
       82
       -
       	// Escape special Slack characters that would be interpreted as formatting

     

       83
       83
       -
       	parsed = parsed.replace(/&/g, "&amp;");

     

       84
       84
       -
       	parsed = parsed.replace(/</g, "&lt;");

     

       85
       85
       -
       	parsed = parsed.replace(/>/g, "&gt;");

     

       86
       86
       -
       

     

       87
       87
       -
       	return parsed;

     

       88
       88
       -
       }

     

       89
       89
       -

src/types.ts

···

       7
       7
        
       	imageUrl: string;

     

       8
       8
        
       	expiration: string;

     

       9
       9
        
       }

     

       10
       10
       +
       

     

       11
       11
       +
       export interface CDNUploadResponse {

     

       12
       12
       +
       	files: Array<{

     

       13
       13
       +
       		deployedUrl: string;

     

       14
       14
       +
       		originalUrl: string;

     

       15
       15
       +
       	}>;

     

       16
       16
       +
       }

+24 -24

tsconfig.json

···

       1
       1
        
       {

     

       2
       2
       -
         "compilerOptions": {

     

       3
       3
       -
           // Environment setup & latest features

     

       4
       4
       -
           "lib": ["ESNext"],

     

       5
       5
       -
           "target": "ESNext",

     

       6
       6
       -
           "module": "Preserve",

     

       7
       7
       -
           "moduleDetection": "force",

     

       8
       8
       -
           "jsx": "react-jsx",

     

       9
       9
       -
           "allowJs": true,

     

       2
       2
       +
       	"compilerOptions": {

     

       3
       3
       +
       		// Environment setup & latest features

     

       4
       4
       +
       		"lib": ["ESNext"],

     

       5
       5
       +
       		"target": "ESNext",

     

       6
       6
       +
       		"module": "Preserve",

     

       7
       7
       +
       		"moduleDetection": "force",

     

       8
       8
       +
       		"jsx": "react-jsx",

     

       9
       9
       +
       		"allowJs": true,

     

       10
       10
        
       

     

       11
       11
       -
           // Bundler mode

     

       12
       12
       -
           "moduleResolution": "bundler",

     

       13
       13
       -
           "allowImportingTsExtensions": true,

     

       14
       14
       -
           "verbatimModuleSyntax": true,

     

       15
       15
       -
           "noEmit": true,

     

       11
       11
       +
       		// Bundler mode

     

       12
       12
       +
       		"moduleResolution": "bundler",

     

       13
       13
       +
       		"allowImportingTsExtensions": true,

     

       14
       14
       +
       		"verbatimModuleSyntax": true,

     

       15
       15
       +
       		"noEmit": true,

     

       16
       16
        
       

     

       17
       17
       -
           // Best practices

     

       18
       18
       -
           "strict": true,

     

       19
       19
       -
           "skipLibCheck": true,

     

       20
       20
       -
           "noFallthroughCasesInSwitch": true,

     

       21
       21
       -
           "noUncheckedIndexedAccess": true,

     

       22
       22
       -
           "noImplicitOverride": true,

     

       17
       17
       +
       		// Best practices

     

       18
       18
       +
       		"strict": true,

     

       19
       19
       +
       		"skipLibCheck": true,

     

       20
       20
       +
       		"noFallthroughCasesInSwitch": true,

     

       21
       21
       +
       		"noUncheckedIndexedAccess": true,

     

       22
       22
       +
       		"noImplicitOverride": true,

     

       23
       23
        
       

     

       24
       24
       -
           // Some stricter flags (disabled by default)

     

       25
       25
       -
           "noUnusedLocals": false,

     

       26
       26
       -
           "noUnusedParameters": false,

     

       27
       27
       -
           "noPropertyAccessFromIndexSignature": false

     

       28
       28
       -
         }

     

       24
       24
       +
       		// Some stricter flags (disabled by default)

     

       25
       25
       +
       		"noUnusedLocals": false,

     

       26
       26
       +
       		"noUnusedParameters": false,

     

       27
       27
       +
       		"noPropertyAccessFromIndexSignature": false

     

       28
       28
       +
       	}

     

       29
       29
        
       }

Compare changes