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

.env.example

···

       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
       +
       

     

       12
       15
        
       # IRC Configuration

     

       13
       16
        
       IRC_NICK=slackbridge

     

       14
       17
        
       NICKSERV_PASSWORD=your-nickserv-password-here

+61 -2

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

     
···

       37
       42
        
       # Optional: For channel manager permission checks

     

       38
       43
        
       SLACK_USER_COOKIE=your-slack-cookie-here

     

       39
       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

     

       40
       48
        
       

     

       41
       49
        
       # IRC Configuration

     

       42
       50
        
       IRC_NICK=slackbridge

     
···

       75
       83
        
       **Using Bun REPL:**

     

       76
       84
        
       ```bash

     

       77
       85
        
       bun repl

     

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

     

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

     

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

     

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

     

       81
       89
        
       > channelMappings.getAll()

     
···

       100
       108
        
         - Image URLs are automatically displayed as inline attachments

     

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

     

       102
       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

     

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

     

       104
       104
       -
         - Slack mentions are converted to mapped IRC nicks, or the display name from `<@U123|name>` format

     

       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

     

       105
       117
        
         - Slack markdown is converted to IRC formatting codes

     

       106
       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

     

       107
       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)

     

       108
       135
        
       

     

       109
       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

     

       110
       169
        
       

     

       111
       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.

     

       112
       171

+4 -1

biome.json

···

       15
       15
        
       	"linter": {

     

       16
       16
        
       		"enabled": true,

     

       17
       17
        
       		"rules": {

     

       18
       18
       -
       			"recommended": true

     

       18
       18
       +
       			"recommended": true,

     

       19
       19
       +
       			"suspicious": {

     

       20
       20
       +
       				"noControlCharactersInRegex": "off"

     

       21
       21
       +
       			}

     

       19
       22
        
       		}

     

       20
       23
        
       	},

     

       21
       24
        
       	"javascript": {

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

+51 -7

src/commands.ts

···

       1
       1
       -
       import type { AnyMessageBlock, Block, BlockElement } from "slack-edge";

     

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

     

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

     

       4
       4
       -
       import { canManageChannel } from "./permissions";

     

       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";

     

       5
       5
        
       

     

       6
       6
        
       export function registerCommands() {

     

       7
       7
        
       	// Link Slack channel to IRC channel

     
···

       86
       86
        
       		}

     

       87
       87
        
       

     

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

     

       99
       99
       +
       

     

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

     

       110
       110
       +
       

     

       89
       111
        
       			channelMappings.create(slackChannelId, ircChannel);

     

       90
       112
        
       			ircClient.join(ircChannel);

     

       91
       113
        
       

     
···

       137
       159
        
       

     

       138
       160
        
       		context.respond({

     

       139
       161
        
       			response_type: "ephemeral",

     

       140
       140
       -
       			text: "Are you sure you want to remove the bridge to *${mapping.irc_channel}*?",

     

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

     

       141
       163
        
       			blocks: [

     

       142
       164
        
       				{

     

       143
       165
        
       					type: "section",

     
···

       280
       302
        
       		}

     

       281
       303
        
       

     

       282
       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
       +
       

     

       283
       327
        
       			userMappings.create(slackUserId, ircNick);

     

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

     

       285
       329
        
       

     
···

       313
       357
        
       

     

       314
       358
        
       		context.respond({

     

       315
       359
        
       			response_type: "ephemeral",

     

       316
       316
       -
       			text: "Are you sure you want to remove your link to IRC nick *${mapping.irc_nick}*?",

     

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

     

       317
       361
        
       			blocks: [

     

       318
       362
        
       				{

     

       319
       363
        
       					type: "section",

     
···

       400
       444
        
       	});

     

       401
       445
        
       

     

       402
       446
        
       	// List channel mappings

     

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

     

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

     

       404
       448
        
       		const channelMaps = channelMappings.getAll();

     

       405
       449
        
       		const userMaps = userMappings.getAll();

     

       406
       450

-97

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

     

       44
       44
       -
       			.query("SELECT * FROM channel_mappings WHERE slack_channel_id = ?")

     

       45
       45
       -
       			.get(slackChannelId) as ChannelMapping | null;

     

       46
       46
       -
       	},

     

       47
       47
       -
       

     

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

     

       49
       49
       -
       		return db

     

       50
       50
       -
       			.query("SELECT * FROM channel_mappings WHERE irc_channel = ?")

     

       51
       51
       -
       			.get(ircChannel) as ChannelMapping | null;

     

       52
       52
       -
       	},

     

       53
       53
       -
       

     

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

     

       55
       55
       -
       		db.run(

     

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

     

       57
       57
       -
       			[slackChannelId, ircChannel],

     

       58
       58
       -
       		);

     

       59
       59
       -
       	},

     

       60
       60
       -
       

     

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

     

       62
       62
       -
       		db.run("DELETE FROM channel_mappings WHERE slack_channel_id = ?", [

     

       63
       63
       -
       			slackChannelId,

     

       64
       64
       -
       		]);

     

       65
       65
       -
       	},

     

       66
       66
       -
       };

     

       67
       67
       -
       

     

       68
       68
       -
       export const userMappings = {

     

       69
       69
       -
       	getAll(): UserMapping[] {

     

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

     

       71
       71
       -
       	},

     

       72
       72
       -
       

     

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

     

       74
       74
       -
       		return db

     

       75
       75
       -
       			.query("SELECT * FROM user_mappings WHERE slack_user_id = ?")

     

       76
       76
       -
       			.get(slackUserId) as UserMapping | null;

     

       77
       77
       -
       	},

     

       78
       78
       -
       

     

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

     

       80
       80
       -
       		return db

     

       81
       81
       -
       			.query("SELECT * FROM user_mappings WHERE irc_nick = ?")

     

       82
       82
       -
       			.get(ircNick) as UserMapping | null;

     

       83
       83
       -
       	},

     

       84
       84
       -
       

     

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

     

       86
       86
       -
       		db.run(

     

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

     

       88
       88
       -
       			[slackUserId, ircNick],

     

       89
       89
       -
       		);

     

       90
       90
       -
       	},

     

       91
       91
       -
       

     

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

     

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

     

       94
       94
       -
       	},

     

       95
       95
       -
       };

     

       96
       96
       -
       

     

       97
       97
       -
       export default db;

+209 -145

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";

     

       8
       8
       -
       

     

       9
       9
       -
       // Default profile pictures for unmapped IRC users

     

       10
       10
       -
       const DEFAULT_AVATARS = [

     

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

     

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

     

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

     

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

     

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

     

       16
       16
       -
       ];

     

       17
       17
       -
       

     

       18
       18
       -
       // Hash function for stable avatar selection

     

       19
       19
       -
       function getAvatarForNick(nick: string): string {

     

       20
       20
       -
       	let hash = 0;

     

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

     

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

     

       23
       23
       -
       		hash = hash & hash; // Convert to 32bit integer

     

       24
       24
       -
       	}

     

       25
       25
       -
       	return DEFAULT_AVATARS[Math.abs(hash) % DEFAULT_AVATARS.length];

     

       26
       26
       -
       }

     

       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";

     

       27
       20
        
       

     

       28
       21
        
       const missingEnvVars = [];

     

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

     
···

       84
       77
        
       // Register slash commands

     

       85
       78
        
       registerCommands();

     

       86
       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
       +
       

     

       87
       89
        
       // Track NickServ authentication state

     

       88
       90
        
       let nickServAuthAttempted = false;

     

       89
       89
       -
       let isAuthenticated = false;

     

       91
       91
       +
       let _isAuthenticated = false;

     

       90
       92
        
       

     

       91
       93
        
       // Join all mapped IRC channels on connect

     

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

     

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

     

       94
       94
       -
       	

     

       96
       96
       +
       

     

       95
       97
        
       	// Authenticate with NickServ if password is provided

     

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

     

       97
       99
        
       		nickServAuthAttempted = true;

     
···

       114
       116
        
       });

     

       115
       117
        
       

     

       116
       118
        
       // Handle NickServ notices

     

       117
       117
       -
       ircClient.addListener("notice", async (nick: string, to: string, text: string) => {

     

       118
       118
       -
       	if (nick !== "NickServ") return;

     

       119
       119
       -
       	

     

       120
       120
       -
       	console.log(`NickServ: ${text}`);

     

       121
       121
       -
       	

     

       122
       122
       -
       	// Check for successful authentication

     

       123
       123
       -
       	if (text.includes("You are now identified") || text.includes("Password accepted")) {

     

       124
       124
       -
       		console.log("✓ Successfully authenticated with NickServ");

     

       125
       125
       -
       		isAuthenticated = true;

     

       126
       126
       -
       		

     

       127
       127
       -
       		// Join channels after successful auth

     

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

     

       129
       129
       -
       		for (const mapping of mappings) {

     

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

     

       119
       119
       +
       ircClient.addListener(

     

       120
       120
       +
       	"notice",

     

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

     

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

     

       123
       123
       +
       

     

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

     

       125
       125
       +
       

     

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

     

       131
       154
        
       		}

     

       132
       132
       -
       	}

     

       133
       133
       -
       	// Check if nick is not registered

     

       134
       134
       -
       	else if (text.includes("isn't registered") || text.includes("not registered")) {

     

       135
       135
       -
       		console.log("Nick not registered, registering with NickServ...");

     

       136
       136
       -
       		if (process.env.NICKSERV_PASSWORD && process.env.NICKSERV_EMAIL) {

     

       137
       137
       -
       			ircClient.say("NickServ", `REGISTER ${process.env.NICKSERV_PASSWORD} ${process.env.NICKSERV_EMAIL}`);

     

       138
       138
       -
       		} else {

     

       139
       139
       -
       			console.error("Cannot register: NICKSERV_EMAIL not configured");

     

       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");

     

       140
       161
        
       		}

     

       141
       141
       -
       	}

     

       142
       142
       -
       	// Check for failed authentication

     

       143
       143
       -
       	else if (text.includes("Invalid password") || text.includes("Access denied")) {

     

       144
       144
       -
       		console.error("✗ NickServ authentication failed: Invalid password");

     

       145
       145
       -
       	}

     

       146
       146
       -
       });

     

       162
       162
       +
       	},

     

       163
       163
       +
       );

     

       147
       164
        
       

     

       148
       165
        
       ircClient.addListener(

     

       149
       166
        
       	"message",

     
···

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

     

       174
       191
        
       		let messageText = parseIRCFormatting(text);

     

       175
       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;

     

       197
       197
       +
       

     

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

     

       210
       210
       +
       

     

       176
       211
        
       		// Extract image URLs from the message

     

       177
       212
        
       		const imagePattern =

     

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

     

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

     

       180
       215
        
       

     

       181
       181
       -
       		// Find all @mentions and nick: mentions in the IRC message

     

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

     

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

     

       184
       184
       -
       

     

       185
       185
       -
       		const atMentions = Array.from(messageText.matchAll(atMentionPattern));

     

       186
       186
       -
       		const nickMentions = Array.from(messageText.matchAll(nickMentionPattern));

     

       187
       187
       -
       

     

       188
       188
       -
       		for (const match of atMentions) {

     

       189
       189
       -
       			const mentionedNick = match[1] as string;

     

       190
       190
       -
       			const mentionedUserMapping = userMappings.getByIrcNick(mentionedNick);

     

       191
       191
       -
       			if (mentionedUserMapping) {

     

       192
       192
       -
       				messageText = messageText.replace(

     

       193
       193
       -
       					match[0],

     

       194
       194
       -
       					`<@${mentionedUserMapping.slack_user_id}>`,

     

       195
       195
       -
       				);

     

       196
       196
       -
       			}

     

       197
       197
       -
       		}

     

       198
       198
       -
       

     

       199
       199
       -
       		for (const match of nickMentions) {

     

       200
       200
       -
       			const mentionedNick = match[1] as string;

     

       201
       201
       -
       			const mentionedUserMapping = userMappings.getByIrcNick(mentionedNick);

     

       202
       202
       -
       			if (mentionedUserMapping) {

     

       203
       203
       -
       				messageText = messageText.replace(

     

       204
       204
       -
       					match[0],

     

       205
       205
       -
       					`<@${mentionedUserMapping.slack_user_id}>:`,

     

       206
       206
       -
       				);

     

       207
       207
       -
       			}

     

       208
       208
       -
       		}

     

       216
       216
       +
       		messageText = convertIrcMentionsToSlack(messageText);

     

       209
       217
        
       

     

       210
       218
        
       		try {

     

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

     
···

       224
       232
        
       					attachments: attachments,

     

       225
       233
        
       					unfurl_links: false,

     

       226
       234
        
       					unfurl_media: false,

     

       235
       235
       +
       					thread_ts: threadTs,

     

       227
       236
        
       				});

     

       228
       237
        
       			} else {

     

       229
       238
        
       				await slackClient.chat.postMessage({

     
···

       232
       241
        
       					text: messageText,

     

       233
       242
        
       					username: displayName,

     

       234
       243
        
       					icon_url: iconUrl,

     

       235
       235
       -
       					unfurl_links: false,

     

       236
       236
       -
       					unfurl_media: false,

     

       244
       244
       +
       					unfurl_links: true,

     

       245
       245
       +
       					unfurl_media: true,

     

       246
       246
       +
       					thread_ts: threadTs,

     

       237
       247
        
       				});

     

       238
       248
        
       			}

     

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

     

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

     

       240
       250
        
       		} catch (error) {

     

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

     

       242
       252
        
       		}

     
···

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

     

       248
       258
        
       });

     

       249
       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
       +
       

     

       250
       316
        
       // Slack event handlers

     

       251
       251
       -
       slackApp.event("message", async ({ payload, context }) => {

     

       252
       252
       -
       	// Ignore bot messages and threaded messages

     

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

     

       318
       318
       +
       	// Ignore bot messages

     

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

     

       254
       320
        
       	if (payload.bot_id) return;

     

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

     

       256
       256
       -
       	if (payload.thread_ts) return;

     

       257
       322
        
       

     

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

     

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

     
···

       268
       333
        
       	}

     

       269
       334
        
       

     

       270
       335
        
       	try {

     

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

     

       272
       272
       -
       			token: process.env.SLACK_BOT_TOKEN,

     

       273
       273
       -
       			user: payload.user,

     

       274
       274
       -
       		});

     

       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;

     

       341
       341
       +
       

     

       342
       342
       +
       		const userInfo = await getUserInfo(

     

       343
       343
       +
       			payload.user,

     

       344
       344
       +
       			slackClient,

     

       345
       345
       +
       			displayNameFromEvent,

     

       346
       346
       +
       		);

     

       275
       347
        
       

     

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

     

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

     

       278
       350
        
       		const username =

     

       279
       351
        
       			userMapping?.irc_nick ||

     

       280
       280
       -
       			userInfo.user?.real_name ||

     

       281
       281
       -
       			userInfo.user?.name ||

     

       352
       352
       +
       			userInfo?.realName ||

     

       353
       353
       +
       			userInfo?.name ||

     

       282
       354
        
       			"Unknown";

     

       283
       355
        
       

     

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

     

       285
       285
       -
       		let messageText = payload.text;

     

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

     

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

     

       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);

     

       288
       369
        
       

     

       289
       289
       -
       		for (const match of mentions) {

     

       290
       290
       -
       			const userId = match[1];

     

       291
       291
       -
       			const displayName = match[3]; // The name part after |

     

       292
       292
       -
       			

     

       293
       293
       -
       			// Check if user has a mapped IRC nick

     

       294
       294
       -
       			const mentionedUserMapping = userMappings.getBySlackUser(userId);

     

       295
       295
       -
       			if (mentionedUserMapping) {

     

       296
       296
       -
       				messageText = messageText.replace(match[0], `@${mentionedUserMapping.irc_nick}`);

     

       297
       297
       -
       			} else if (displayName) {

     

       298
       298
       -
       				// Use the display name from the mention format <@U123|name>

     

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

     

       300
       300
       -
       			} else {

     

       301
       301
       -
       				// Fallback to Cachet lookup

     

       370
       370
       +
       			if (isFirstReply) {

     

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

     

       302
       372
        
       				try {

     

       303
       303
       -
       					const response = await fetch(

     

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

     

       305
       305
       -
       						{

     

       306
       306
       -
       							// @ts-ignore - Bun specific option

     

       307
       307
       -
       							tls: { rejectUnauthorized: false },

     

       308
       308
       -
       						},

     

       309
       309
       -
       					);

     

       310
       310
       -
       					if (response.ok) {

     

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

     

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

     

       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}`);

     

       313
       392
        
       					}

     

       314
       393
        
       				} catch (error) {

     

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

     

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

     

       316
       395
        
       				}

     

       317
       396
        
       			}

     

       318
       318
       -
       		}

     

       319
       397
        
       

     

       320
       320
       -
       		// Parse Slack markdown formatting

     

       321
       321
       -
       		messageText = parseSlackMarkdown(messageText);

     

       398
       398
       +
       			// Add thread ID to message

     

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

     

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

     

       401
       401
       +
       			}

     

       402
       402
       +
       		}

     

       322
       403
        
       

     

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

     

       324
       405
        
       		if (messageText.trim()) {

     
···

       330
       411
        
       		// Handle file uploads

     

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

     

       332
       413
        
       			try {

     

       333
       333
       -
       				// Extract private file URLs

     

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

     

       335
       335
       -
       

     

       336
       336
       -
       				// Upload to Hack Club CDN

     

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

     

       338
       338
       -
       					method: "POST",

     

       339
       339
       -
       					headers: {

     

       340
       340
       -
       						Authorization: `Bearer ${process.env.CDN_TOKEN}`,

     

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

     

       342
       342
       -
       						"Content-Type": "application/json",

     

       343
       343
       -
       					},

     

       344
       344
       -
       					body: JSON.stringify(fileUrls),

     

       345
       345
       -
       				});

     

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

     

       346
       416
        
       

     

       347
       347
       -
       				if (response.ok) {

     

       348
       348
       -
       					const data = await response.json();

     

       349
       349
       -
       

     

       350
       350
       -
       					// Send each uploaded file URL to IRC

     

       351
       351
       -
       					for (const file of data.files) {

     

       352
       352
       -
       						const fileMessage = `<${username}> ${file.deployedUrl}`;

     

       353
       353
       -
       						ircClient.say(mapping.irc_channel, fileMessage);

     

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

     

       355
       355
       -
       					}

     

       356
       356
       -
       				} else {

     

       357
       357
       -
       					console.error("Failed to upload files to CDN:", response.statusText);

     

       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}`);

     

       358
       422
        
       				}

     

       359
       423
        
       			} catch (error) {

     

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

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

-88

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

-71

src/permissions.ts

···

       1
       1
       -
       /**

     

       2
       2
       -
        * Check if a user has permission to manage a Slack channel

     

       3
       3
       -
        * Returns true if the user is:

     

       4
       4
       -
        * - A global admin (in ADMINS env var)

     

       5
       5
       -
        * - The channel creator

     

       6
       6
       -
        * - A channel manager

     

       7
       7
       -
        */

     

       8
       8
       -
       export async function canManageChannel(

     

       9
       9
       -
       	userId: string,

     

       10
       10
       -
       	channelId: string,

     

       11
       11
       -
       ): Promise<boolean> {

     

       12
       12
       -
       	// Check if user is a global admin

     

       13
       13
       -
       	const admins = process.env.ADMINS?.split(",").map((id) => id.trim()) || [];

     

       14
       14
       -
       	if (admins.includes(userId)) {

     

       15
       15
       -
       		return true;

     

       16
       16
       -
       	}

     

       17
       17
       -
       

     

       18
       18
       -
       	try {

     

       19
       19
       -
       		// Check if user is channel creator

     

       20
       20
       -
       		const channelInfo = await fetch(

     

       21
       21
       -
       			"https://slack.com/api/conversations.info",

     

       22
       22
       -
       			{

     

       23
       23
       -
       				method: "POST",

     

       24
       24
       -
       				headers: {

     

       25
       25
       -
       					"Content-Type": "application/json",

     

       26
       26
       -
       					Authorization: `Bearer ${process.env.SLACK_BOT_TOKEN}`,

     

       27
       27
       -
       				},

     

       28
       28
       -
       				body: JSON.stringify({ channel: channelId }),

     

       29
       29
       -
       			},

     

       30
       30
       -
       		).then((res) => res.json());

     

       31
       31
       -
       

     

       32
       32
       -
       		if (channelInfo.ok && channelInfo.channel?.creator === userId) {

     

       33
       33
       -
       			return true;

     

       34
       34
       -
       		}

     

       35
       35
       -
       

     

       36
       36
       -
       		// Check if user is a channel manager

     

       37
       37
       -
       		if (

     

       38
       38
       -
       			process.env.SLACK_USER_COOKIE &&

     

       39
       39
       -
       			process.env.SLACK_USER_TOKEN &&

     

       40
       40
       -
       			process.env.SLACK_API_URL

     

       41
       41
       -
       		) {

     

       42
       42
       -
       			const formdata = new FormData();

     

       43
       43
       -
       			formdata.append("token", process.env.SLACK_USER_TOKEN);

     

       44
       44
       -
       			formdata.append("entity_id", channelId);

     

       45
       45
       -
       

     

       46
       46
       -
       			const response = await fetch(

     

       47
       47
       -
       				`${process.env.SLACK_API_URL}/api/admin.roles.entity.listAssignments`,

     

       48
       48
       -
       				{

     

       49
       49
       -
       					method: "POST",

     

       50
       50
       -
       					headers: {

     

       51
       51
       -
       						Cookie: process.env.SLACK_USER_COOKIE,

     

       52
       52
       -
       					},

     

       53
       53
       -
       					body: formdata,

     

       54
       54
       -
       				},

     

       55
       55
       -
       			);

     

       56
       56
       -
       

     

       57
       57
       -
       			const json = await response.json();

     

       58
       58
       -
       

     

       59
       59
       -
       			if (json.ok) {

     

       60
       60
       -
       				const managers = json.role_assignments?.[0]?.users || [];

     

       61
       61
       -
       				if (managers.includes(userId)) {

     

       62
       62
       -
       					return true;

     

       63
       63
       -
       				}

     

       64
       64
       -
       			}

     

       65
       65
       -
       		}

     

       66
       66
       -
       	} catch (error) {

     

       67
       67
       -
       		console.error("Error checking channel permissions:", error);

     

       68
       68
       -
       	}

     

       69
       69
       -
       

     

       70
       70
       -
       	return false;

     

       71
       71
       -
       }

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

Compare changes