chore: consolidate new foundation and archive v1 (#1495)

v1/apps/gateway/src/plugin/discord-replay-protector.ts

@@ -0,0 +1,40 @@
+/**
+ * Bounded replay cache for Discord's globally unique native message IDs.
+ * Durable ingress idempotency is added with Tess's canonical inbox/outbox work.
+ */
+export class DiscordReplayProtector {
+  private readonly claimedAt = new Map<string, number>();
+
+  constructor(
+    private readonly ttlMs = 15 * 60 * 1000,
+    private readonly maxEntries = 10_000,
+  ) {}
+
+  get size(): number {
+    return this.claimedAt.size;
+  }
+
+  /** Claims an ID exactly once within its bounded retention window. */
+  claim(messageId: string, now = Date.now()): boolean {
+    this.prune(now);
+    if (this.claimedAt.has(messageId)) return false;
+
+    this.claimedAt.set(messageId, now);
+    this.evictOverflow();
+    return true;
+  }
+
+  private prune(now: number): void {
+    for (const [messageId, claimedAt] of this.claimedAt) {
+      if (now - claimedAt >= this.ttlMs) this.claimedAt.delete(messageId);
+    }
+  }
+
+  private evictOverflow(): void {
+    while (this.claimedAt.size > this.maxEntries) {
+      const oldestMessageId = this.claimedAt.keys().next().value;
+      if (oldestMessageId === undefined) return;
+      this.claimedAt.delete(oldestMessageId);
+    }
+  }
+}

v1/apps/gateway/src/plugin/plugin.interface.ts

@@ -0,0 +1,11 @@
+export interface IChannelPlugin {
+  readonly name: string;
+  start(): Promise<void>;
+  stop(): Promise<void>;
+  /** Called when a new project is bootstrapped. Return channelId if a channel was created. */
+  onProjectCreated?(project: {
+    id: string;
+    name: string;
+    description?: string;
+  }): Promise<{ channelId: string } | null>;
+}

v1/apps/gateway/src/plugin/plugin.module.ts

@@ -0,0 +1,156 @@
+import {
+  Global,
+  Inject,
+  Logger,
+  Module,
+  type OnModuleDestroy,
+  type OnModuleInit,
+} from '@nestjs/common';
+import { DiscordPlugin, parseDiscordInteractionBindings } from '@mosaicstack/discord-plugin';
+import { TelegramPlugin } from '@mosaicstack/telegram-plugin';
+import { PluginService } from './plugin.service.js';
+import type { IChannelPlugin } from './plugin.interface.js';
+import { PLUGIN_REGISTRY } from './plugin.tokens.js';
+
+class DiscordChannelPluginAdapter implements IChannelPlugin {
+  readonly name = 'discord';
+
+  constructor(private readonly plugin: DiscordPlugin) {}
+
+  async start(): Promise<void> {
+    await this.plugin.start();
+  }
+
+  async stop(): Promise<void> {
+    await this.plugin.stop();
+  }
+
+  async onProjectCreated(project: {
+    id: string;
+    name: string;
+    description?: string;
+  }): Promise<{ channelId: string } | null> {
+    return this.plugin.createProjectChannel(project);
+  }
+}
+
+class TelegramChannelPluginAdapter implements IChannelPlugin {
+  readonly name = 'telegram';
+
+  constructor(private readonly plugin: TelegramPlugin) {}
+
+  async start(): Promise<void> {
+    await this.plugin.start();
+  }
+
+  async stop(): Promise<void> {
+    await this.plugin.stop();
+  }
+}
+
+const DEFAULT_GATEWAY_URL = 'http://localhost:14242';
+
+function requiredDiscordAllowlist(name: string): string[] {
+  const value = process.env[name]
+    ?.split(',')
+    .map((id: string): string => id.trim())
+    .filter((id: string): boolean => id.length > 0);
+  if (!value || value.length === 0) {
+    throw new Error(`${name} is required when DISCORD_BOT_TOKEN is configured`);
+  }
+  return value;
+}
+
+function optionalPositiveInteger(name: string): number | undefined {
+  const raw = process.env[name];
+  if (raw === undefined) return undefined;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer when configured`);
+  }
+  return value;
+}
+
+function createPluginRegistry(): IChannelPlugin[] {
+  const plugins: IChannelPlugin[] = [];
+  const discordToken = process.env['DISCORD_BOT_TOKEN'];
+  const discordGuildId = process.env['DISCORD_GUILD_ID'];
+  const discordGatewayUrl = process.env['DISCORD_GATEWAY_URL'] ?? DEFAULT_GATEWAY_URL;
+  const discordServiceToken = process.env['DISCORD_SERVICE_TOKEN'];
+  const discordServiceUserId = process.env['DISCORD_SERVICE_USER_ID'];
+
+  if (discordToken) {
+    if (!discordServiceToken || !discordServiceUserId) {
+      throw new Error(
+        'DISCORD_SERVICE_TOKEN and DISCORD_SERVICE_USER_ID are required when DISCORD_BOT_TOKEN is configured',
+      );
+    }
+    plugins.push(
+      new DiscordChannelPluginAdapter(
+        new DiscordPlugin({
+          token: discordToken,
+          guildId: discordGuildId,
+          gatewayUrl: discordGatewayUrl,
+          serviceToken: discordServiceToken,
+          messageRateLimitPerMinute: optionalPositiveInteger(
+            'DISCORD_MESSAGE_RATE_LIMIT_PER_MINUTE',
+          ),
+          threadRateLimitPerMinute: optionalPositiveInteger('DISCORD_THREAD_RATE_LIMIT_PER_MINUTE'),
+          allowedGuildIds: requiredDiscordAllowlist('DISCORD_ALLOWED_GUILD_IDS'),
+          allowedChannelIds: requiredDiscordAllowlist('DISCORD_ALLOWED_CHANNEL_IDS'),
+          allowedUserIds: requiredDiscordAllowlist('DISCORD_ALLOWED_USER_IDS'),
+          interactionBindings: parseDiscordInteractionBindings(
+            process.env['DISCORD_INTERACTION_BINDINGS'],
+          ),
+        }),
+      ),
+    );
+  }
+
+  const telegramToken = process.env['TELEGRAM_BOT_TOKEN'];
+  const telegramGatewayUrl = process.env['TELEGRAM_GATEWAY_URL'] ?? DEFAULT_GATEWAY_URL;
+
+  if (telegramToken) {
+    plugins.push(
+      new TelegramChannelPluginAdapter(
+        new TelegramPlugin({
+          token: telegramToken,
+          gatewayUrl: telegramGatewayUrl,
+        }),
+      ),
+    );
+  }
+
+  return plugins;
+}
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: PLUGIN_REGISTRY,
+      useFactory: (): IChannelPlugin[] => createPluginRegistry(),
+    },
+    PluginService,
+  ],
+  exports: [PluginService, PLUGIN_REGISTRY],
+})
+export class PluginModule implements OnModuleInit, OnModuleDestroy {
+  private readonly logger = new Logger(PluginModule.name);
+
+  constructor(@Inject(PLUGIN_REGISTRY) private readonly plugins: IChannelPlugin[]) {}
+
+  async onModuleInit(): Promise<void> {
+    for (const plugin of this.plugins) {
+      this.logger.log(`Starting plugin: ${plugin.name}`);
+      await plugin.start();
+    }
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    for (const plugin of [...this.plugins].reverse()) {
+      this.logger.log(`Stopping plugin: ${plugin.name}`);
+      await plugin.stop();
+    }
+  }
+}

v1/apps/gateway/src/plugin/plugin.service.ts

@@ -0,0 +1,16 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { PLUGIN_REGISTRY } from './plugin.tokens.js';
+import type { IChannelPlugin } from './plugin.interface.js';
+
+@Injectable()
+export class PluginService {
+  constructor(@Inject(PLUGIN_REGISTRY) private readonly plugins: IChannelPlugin[]) {}
+
+  getPlugins(): IChannelPlugin[] {
+    return this.plugins;
+  }
+
+  getPlugin(name: string): IChannelPlugin | undefined {
+    return this.plugins.find((plugin: IChannelPlugin) => plugin.name === name);
+  }
+}

v1/apps/gateway/src/plugin/plugin.tokens.ts

@@ -0,0 +1 @@
+export const PLUGIN_REGISTRY = Symbol('PLUGIN_REGISTRY');