@open-mercato/channel-discord 0.6.8-develop.7090.1.4dbca7b350

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+[build:channel-discord] found 60 entry points
+[build:channel-discord] built successfully

package/build.mjs

@@ -0,0 +1,7 @@
+import { dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { buildPackage } from '../../scripts/build-package.mjs'
+
+const packageDir = dirname(fileURLToPath(import.meta.url))
+
+await buildPackage(packageDir, { name: 'channel-discord' })

package/dist/index.js

@@ -0,0 +1,5 @@
+import { metadata } from "./modules/channel_discord/index.js";
+export {
+  metadata
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": ["export { metadata } from './modules/channel_discord/index'\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;",
+  "names": []
+}

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-001.spec.js

@@ -0,0 +1,86 @@
+import { expect, test } from "@playwright/test";
+import { apiRequest, getAuthToken } from "@open-mercato/core/helpers/integration/api";
+import { readJsonSafe } from "@open-mercato/core/helpers/integration/generalFixtures";
+test.describe("TC-CHANNEL-DISCORD-001: connect channel via credentials", () => {
+  test("requires authentication", async ({ request }) => {
+    const response = await apiRequest(
+      request,
+      "POST",
+      "/api/communication_channels/channels/connect/credentials",
+      // Intentionally empty token — this assertion is the 401 unauth path.
+      { token: "", data: { providerKey: "discord", displayName: "unauth", credentials: {} } }
+    );
+    expect(response.status(), "connect must reject an unauthenticated caller").toBe(401);
+  });
+  test("the discord adapter is registered and rejects malformed credentials with field errors", async ({
+    request
+  }) => {
+    const token = await getAuthToken(request, "admin");
+    const stamp = Date.now();
+    const unknownProvider = await apiRequest(
+      request,
+      "POST",
+      "/api/communication_channels/channels/connect/credentials",
+      {
+        token,
+        data: {
+          providerKey: `not-a-provider-${stamp}`,
+          displayName: `TC-CHANNEL-DISCORD-001 unknown ${stamp}`,
+          credentials: {}
+        }
+      }
+    );
+    expect(
+      unknownProvider.status(),
+      "an unregistered provider key must resolve to no adapter (404)"
+    ).toBe(404);
+    const discord = await apiRequest(
+      request,
+      "POST",
+      "/api/communication_channels/channels/connect/credentials",
+      {
+        token,
+        data: {
+          providerKey: "discord",
+          displayName: `TC-CHANNEL-DISCORD-001 ${stamp}`,
+          // Missing botToken/applicationId, and a publicKey that is neither hex
+          // nor 32 bytes — all three must come back as field errors.
+          credentials: { publicKey: "not-a-hex-key" }
+        }
+      }
+    );
+    expect(
+      discord.status(),
+      "discord IS registered, so the failure must be credential validation (422), not 404"
+    ).toBe(422);
+    const body = await readJsonSafe(discord);
+    expect(body?.error, "the 422 must report credential validation").toBe("Credential validation failed");
+    const fieldErrors = body?.fieldErrors ?? {};
+    expect(
+      Object.keys(fieldErrors),
+      "every missing/invalid credential field must be reported back to the operator"
+    ).toEqual(expect.arrayContaining(["botToken", "applicationId", "publicKey"]));
+  });
+  test("a rejected connect attempt creates no channel", async ({ request }) => {
+    const token = await getAuthToken(request, "admin");
+    const stamp = Date.now();
+    const displayName = `TC-CHANNEL-DISCORD-001 orphan ${stamp}`;
+    const rejected = await apiRequest(
+      request,
+      "POST",
+      "/api/communication_channels/channels/connect/credentials",
+      { token, data: { providerKey: "discord", displayName, credentials: {} } }
+    );
+    expect(rejected.status(), "malformed credentials must be rejected").toBe(422);
+    const listed = await apiRequest(request, "GET", "/api/communication_channels/me/channels", {
+      token
+    });
+    expect(listed.status(), "GET /me/channels should return 200").toBe(200);
+    const body = await readJsonSafe(listed);
+    const names = (body?.items ?? []).map((item) => item.displayName);
+    expect(names, "a failed validation must not leave a half-connected channel behind").not.toContain(
+      displayName
+    );
+  });
+});
+//# sourceMappingURL=TC-CHANNEL-DISCORD-001.spec.js.map

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-001.spec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-001.spec.ts"],
+  "sourcesContent": ["import { expect, test } from '@playwright/test'\nimport { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api'\nimport { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures'\n\n/**\n * TC-CHANNEL-DISCORD-001 \u2014 connect a Discord channel via credentials.\n * Source: .ai/specs/2026-06-19-discord-communication-channel-integration.md\n *\n * Asserts the two halves of the connect contract through the hub's real route:\n *\n *  1. The `discord` adapter IS registered with the hub \u2014 an unknown provider key\n *     resolves to no adapter and returns 404, `discord` does not.\n *  2. `validateCredentials` is fail-closed and offline \u2014 a malformed credential\n *     blob is rejected with per-field errors (422) by the zod schema BEFORE any\n *     Discord REST call, so this test needs no bot token and no network.\n *\n * The happy path (a real token accepted by `GET /users/@me`) needs live Discord\n * and stays unit-tested with a stubbed REST client in\n * `lib/__tests__/adapter.test.ts`.\n */\ntest.describe('TC-CHANNEL-DISCORD-001: connect channel via credentials', () => {\n  test('requires authentication', async ({ request }) => {\n    const response = await apiRequest(\n      request,\n      'POST',\n      '/api/communication_channels/channels/connect/credentials',\n      // Intentionally empty token \u2014 this assertion is the 401 unauth path.\n      { token: '', data: { providerKey: 'discord', displayName: 'unauth', credentials: {} } },\n    )\n    expect(response.status(), 'connect must reject an unauthenticated caller').toBe(401)\n  })\n\n  test('the discord adapter is registered and rejects malformed credentials with field errors', async ({\n    request,\n  }) => {\n    const token = await getAuthToken(request, 'admin')\n    const stamp = Date.now()\n\n    const unknownProvider = await apiRequest(\n      request,\n      'POST',\n      '/api/communication_channels/channels/connect/credentials',\n      {\n        token,\n        data: {\n          providerKey: `not-a-provider-${stamp}`,\n          displayName: `TC-CHANNEL-DISCORD-001 unknown ${stamp}`,\n          credentials: {},\n        },\n      },\n    )\n    expect(\n      unknownProvider.status(),\n      'an unregistered provider key must resolve to no adapter (404)',\n    ).toBe(404)\n\n    const discord = await apiRequest(\n      request,\n      'POST',\n      '/api/communication_channels/channels/connect/credentials',\n      {\n        token,\n        data: {\n          providerKey: 'discord',\n          displayName: `TC-CHANNEL-DISCORD-001 ${stamp}`,\n          // Missing botToken/applicationId, and a publicKey that is neither hex\n          // nor 32 bytes \u2014 all three must come back as field errors.\n          credentials: { publicKey: 'not-a-hex-key' },\n        },\n      },\n    )\n    expect(\n      discord.status(),\n      'discord IS registered, so the failure must be credential validation (422), not 404',\n    ).toBe(422)\n\n    const body = await readJsonSafe<{ error?: string; fieldErrors?: Record<string, string> }>(discord)\n    expect(body?.error, 'the 422 must report credential validation').toBe('Credential validation failed')\n    const fieldErrors = body?.fieldErrors ?? {}\n    expect(\n      Object.keys(fieldErrors),\n      'every missing/invalid credential field must be reported back to the operator',\n    ).toEqual(expect.arrayContaining(['botToken', 'applicationId', 'publicKey']))\n  })\n\n  test('a rejected connect attempt creates no channel', async ({ request }) => {\n    const token = await getAuthToken(request, 'admin')\n    const stamp = Date.now()\n    const displayName = `TC-CHANNEL-DISCORD-001 orphan ${stamp}`\n\n    const rejected = await apiRequest(\n      request,\n      'POST',\n      '/api/communication_channels/channels/connect/credentials',\n      { token, data: { providerKey: 'discord', displayName, credentials: {} } },\n    )\n    expect(rejected.status(), 'malformed credentials must be rejected').toBe(422)\n\n    const listed = await apiRequest(request, 'GET', '/api/communication_channels/me/channels', {\n      token,\n    })\n    expect(listed.status(), 'GET /me/channels should return 200').toBe(200)\n    const body = await readJsonSafe<{ items?: Array<{ displayName?: string }> }>(listed)\n    const names = (body?.items ?? []).map((item) => item.displayName)\n    expect(names, 'a failed validation must not leave a half-connected channel behind').not.toContain(\n      displayName,\n    )\n  })\n})\n"],
+  "mappings": "AAAA,SAAS,QAAQ,YAAY;AAC7B,SAAS,YAAY,oBAAoB;AACzC,SAAS,oBAAoB;AAkB7B,KAAK,SAAS,2DAA2D,MAAM;AAC7E,OAAK,2BAA2B,OAAO,EAAE,QAAQ,MAAM;AACrD,UAAM,WAAW,MAAM;AAAA,MACrB;AAAA,MACA;AAAA,MACA;AAAA;AAAA,MAEA,EAAE,OAAO,IAAI,MAAM,EAAE,aAAa,WAAW,aAAa,UAAU,aAAa,CAAC,EAAE,EAAE;AAAA,IACxF;AACA,WAAO,SAAS,OAAO,GAAG,+CAA+C,EAAE,KAAK,GAAG;AAAA,EACrF,CAAC;AAED,OAAK,yFAAyF,OAAO;AAAA,IACnG;AAAA,EACF,MAAM;AACJ,UAAM,QAAQ,MAAM,aAAa,SAAS,OAAO;AACjD,UAAM,QAAQ,KAAK,IAAI;AAEvB,UAAM,kBAAkB,MAAM;AAAA,MAC5B;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,QACE;AAAA,QACA,MAAM;AAAA,UACJ,aAAa,kBAAkB,KAAK;AAAA,UACpC,aAAa,kCAAkC,KAAK;AAAA,UACpD,aAAa,CAAC;AAAA,QAChB;AAAA,MACF;AAAA,IACF;AACA;AAAA,MACE,gBAAgB,OAAO;AAAA,MACvB;AAAA,IACF,EAAE,KAAK,GAAG;AAEV,UAAM,UAAU,MAAM;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,QACE;AAAA,QACA,MAAM;AAAA,UACJ,aAAa;AAAA,UACb,aAAa,0BAA0B,KAAK;AAAA;AAAA;AAAA,UAG5C,aAAa,EAAE,WAAW,gBAAgB;AAAA,QAC5C;AAAA,MACF;AAAA,IACF;AACA;AAAA,MACE,QAAQ,OAAO;AAAA,MACf;AAAA,IACF,EAAE,KAAK,GAAG;AAEV,UAAM,OAAO,MAAM,aAAuE,OAAO;AACjG,WAAO,MAAM,OAAO,2CAA2C,EAAE,KAAK,8BAA8B;AACpG,UAAM,cAAc,MAAM,eAAe,CAAC;AAC1C;AAAA,MACE,OAAO,KAAK,WAAW;AAAA,MACvB;AAAA,IACF,EAAE,QAAQ,OAAO,gBAAgB,CAAC,YAAY,iBAAiB,WAAW,CAAC,CAAC;AAAA,EAC9E,CAAC;AAED,OAAK,iDAAiD,OAAO,EAAE,QAAQ,MAAM;AAC3E,UAAM,QAAQ,MAAM,aAAa,SAAS,OAAO;AACjD,UAAM,QAAQ,KAAK,IAAI;AACvB,UAAM,cAAc,iCAAiC,KAAK;AAE1D,UAAM,WAAW,MAAM;AAAA,MACrB;AAAA,MACA;AAAA,MACA;AAAA,MACA,EAAE,OAAO,MAAM,EAAE,aAAa,WAAW,aAAa,aAAa,CAAC,EAAE,EAAE;AAAA,IAC1E;AACA,WAAO,SAAS,OAAO,GAAG,wCAAwC,EAAE,KAAK,GAAG;AAE5E,UAAM,SAAS,MAAM,WAAW,SAAS,OAAO,2CAA2C;AAAA,MACzF;AAAA,IACF,CAAC;AACD,WAAO,OAAO,OAAO,GAAG,oCAAoC,EAAE,KAAK,GAAG;AACtE,UAAM,OAAO,MAAM,aAA0D,MAAM;AACnF,UAAM,SAAS,MAAM,SAAS,CAAC,GAAG,IAAI,CAAC,SAAS,KAAK,WAAW;AAChE,WAAO,OAAO,oEAAoE,EAAE,IAAI;AAAA,MACtF;AAAA,IACF;AAAA,EACF,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-002.spec.js

@@ -0,0 +1,39 @@
+import { expect, test } from "@playwright/test";
+import { apiRequest, getAuthToken } from "@open-mercato/core/helpers/integration/api";
+const UNKNOWN_CHANNEL_ID = "00000000-0000-4000-8000-0000000d1c02";
+test.describe("TC-CHANNEL-DISCORD-002: outbound test-send guards", () => {
+  test("requires authentication", async ({ request }) => {
+    const response = await apiRequest(
+      request,
+      "POST",
+      `/api/communication_channels/channels/${UNKNOWN_CHANNEL_ID}/test-send`,
+      // Intentionally empty token — this assertion is the 401 unauth path.
+      { token: "", data: { to: "integration@example.com" } }
+    );
+    expect(response.status(), "test-send must reject an unauthenticated caller").toBe(401);
+  });
+  test("rejects a malformed channel id before touching any adapter", async ({ request }) => {
+    const token = await getAuthToken(request, "admin");
+    const response = await apiRequest(
+      request,
+      "POST",
+      "/api/communication_channels/channels/not-a-uuid/test-send",
+      { token, data: { to: "integration@example.com" } }
+    );
+    expect(response.status(), "a non-uuid channel id must be a 400, not a 500").toBe(400);
+  });
+  test("rejects a channel the caller does not own", async ({ request }) => {
+    const token = await getAuthToken(request, "admin");
+    const response = await apiRequest(
+      request,
+      "POST",
+      `/api/communication_channels/channels/${UNKNOWN_CHANNEL_ID}/test-send`,
+      { token, data: { to: "integration@example.com" } }
+    );
+    expect(
+      response.status(),
+      "an unknown/foreign channel id must be 404 \u2014 never a send attempt"
+    ).toBe(404);
+  });
+});
+//# sourceMappingURL=TC-CHANNEL-DISCORD-002.spec.js.map

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-002.spec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-002.spec.ts"],
+  "sourcesContent": ["import { expect, test } from '@playwright/test'\nimport { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api'\n\n/**\n * TC-CHANNEL-DISCORD-002 \u2014 outbound test-send routing for a Discord channel.\n * Source: .ai/specs/2026-06-19-discord-communication-channel-integration.md\n *\n * The hub owns the outbound entry point (`POST /channels/[id]/test-send`); the\n * provider only supplies `convertOutbound` + `sendMessage`. This spec pins the\n * route's tenant-safety contract, which is what a provider PR can break: an\n * unauthenticated caller, a malformed id, and an id the caller does not own are\n * all refused BEFORE any adapter is resolved \u2014 so no Discord REST call can be\n * driven by an unauthorized request.\n *\n * The actual Discord payload conversion and REST post are unit-tested against a\n * stubbed client in `lib/__tests__/convert-outbound.test.ts` and\n * `lib/__tests__/adapter.test.ts`; they need a live bot token and are therefore\n * out of scope for CI.\n */\nconst UNKNOWN_CHANNEL_ID = '00000000-0000-4000-8000-0000000d1c02'\n\ntest.describe('TC-CHANNEL-DISCORD-002: outbound test-send guards', () => {\n  test('requires authentication', async ({ request }) => {\n    const response = await apiRequest(\n      request,\n      'POST',\n      `/api/communication_channels/channels/${UNKNOWN_CHANNEL_ID}/test-send`,\n      // Intentionally empty token \u2014 this assertion is the 401 unauth path.\n      { token: '', data: { to: 'integration@example.com' } },\n    )\n    expect(response.status(), 'test-send must reject an unauthenticated caller').toBe(401)\n  })\n\n  test('rejects a malformed channel id before touching any adapter', async ({ request }) => {\n    const token = await getAuthToken(request, 'admin')\n    const response = await apiRequest(\n      request,\n      'POST',\n      '/api/communication_channels/channels/not-a-uuid/test-send',\n      { token, data: { to: 'integration@example.com' } },\n    )\n    expect(response.status(), 'a non-uuid channel id must be a 400, not a 500').toBe(400)\n  })\n\n  test('rejects a channel the caller does not own', async ({ request }) => {\n    const token = await getAuthToken(request, 'admin')\n    const response = await apiRequest(\n      request,\n      'POST',\n      `/api/communication_channels/channels/${UNKNOWN_CHANNEL_ID}/test-send`,\n      { token, data: { to: 'integration@example.com' } },\n    )\n    expect(\n      response.status(),\n      'an unknown/foreign channel id must be 404 \u2014 never a send attempt',\n    ).toBe(404)\n  })\n})\n"],
+  "mappings": "AAAA,SAAS,QAAQ,YAAY;AAC7B,SAAS,YAAY,oBAAoB;AAkBzC,MAAM,qBAAqB;AAE3B,KAAK,SAAS,qDAAqD,MAAM;AACvE,OAAK,2BAA2B,OAAO,EAAE,QAAQ,MAAM;AACrD,UAAM,WAAW,MAAM;AAAA,MACrB;AAAA,MACA;AAAA,MACA,wCAAwC,kBAAkB;AAAA;AAAA,MAE1D,EAAE,OAAO,IAAI,MAAM,EAAE,IAAI,0BAA0B,EAAE;AAAA,IACvD;AACA,WAAO,SAAS,OAAO,GAAG,iDAAiD,EAAE,KAAK,GAAG;AAAA,EACvF,CAAC;AAED,OAAK,8DAA8D,OAAO,EAAE,QAAQ,MAAM;AACxF,UAAM,QAAQ,MAAM,aAAa,SAAS,OAAO;AACjD,UAAM,WAAW,MAAM;AAAA,MACrB;AAAA,MACA;AAAA,MACA;AAAA,MACA,EAAE,OAAO,MAAM,EAAE,IAAI,0BAA0B,EAAE;AAAA,IACnD;AACA,WAAO,SAAS,OAAO,GAAG,gDAAgD,EAAE,KAAK,GAAG;AAAA,EACtF,CAAC;AAED,OAAK,6CAA6C,OAAO,EAAE,QAAQ,MAAM;AACvE,UAAM,QAAQ,MAAM,aAAa,SAAS,OAAO;AACjD,UAAM,WAAW,MAAM;AAAA,MACrB;AAAA,MACA;AAAA,MACA,wCAAwC,kBAAkB;AAAA,MAC1D,EAAE,OAAO,MAAM,EAAE,IAAI,0BAA0B,EAAE;AAAA,IACnD;AACA;AAAA,MACE,SAAS,OAAO;AAAA,MAChB;AAAA,IACF,EAAE,KAAK,GAAG;AAAA,EACZ,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-003.spec.js

@@ -0,0 +1,97 @@
+import { expect, test } from "@playwright/test";
+import { apiRequest, getAuthToken } from "@open-mercato/core/helpers/integration/api";
+import { readJsonSafe } from "@open-mercato/core/helpers/integration/generalFixtures";
+import {
+  deleteChannelIfExists,
+  ingestInboundChatMessage,
+  isChannelSeedingAvailable,
+  seedConnectedChannel
+} from "@open-mercato/core/helpers/integration/communicationChannelsFixtures";
+import { normalizeInboundDiscordMessage } from "../lib/normalize-inbound.js";
+async function readHealth(request, token, channelId) {
+  const response = await apiRequest(
+    request,
+    "GET",
+    `/api/communication_channels/channels/${channelId}/health`,
+    { token }
+  );
+  expect(response.status(), "GET /channels/[id]/health should return 200").toBe(200);
+  return await readJsonSafe(response) ?? {};
+}
+function discordMessageCreateFrame(stamp) {
+  return {
+    id: `1534333813851816${String(stamp).slice(-3)}`,
+    channel_id: "1534331920463433771",
+    guild_id: "1534331919796273152",
+    content: "Kolejna wiadomo\u015B\u0107 testowa!@",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    author: {
+      id: "1499156851487539260",
+      username: "lorakaspak",
+      global_name: "Karol Kapsa",
+      bot: false
+    },
+    attachments: []
+  };
+}
+test.describe("TC-CHANNEL-DISCORD-003: inbound discord message ingest", () => {
+  test("a message shaped the way the Discord gateway actually produces it is ingested", async ({
+    request
+  }) => {
+    test.slow();
+    let token = null;
+    let channelId = null;
+    try {
+      token = await getAuthToken(request, "admin");
+      const seedingAvailable = await isChannelSeedingAvailable(request, token);
+      test.skip(
+        !seedingAvailable,
+        "OM_ENABLE_TEST_CHANNEL_SEEDING is not enabled in this environment; cannot ingest."
+      );
+      const stamp = Date.now();
+      channelId = await seedConnectedChannel(request, token, {
+        displayName: `TC-CHANNEL-DISCORD-003 ${stamp}`,
+        providerFlavor: "chat"
+      });
+      const before = await readHealth(request, token, channelId);
+      const totalBefore = before.totalsLast24h ?? 0;
+      const frame = discordMessageCreateFrame(stamp);
+      const normalized = normalizeInboundDiscordMessage(frame);
+      expect(
+        normalized.senderIdentifier,
+        "the sender must stay the Discord snowflake \u2014 synthesising an address here is what #4975 rejects"
+      ).toBe("1499156851487539260");
+      expect(normalized.externalConversationId).toBe("discord-channel:1534331920463433771");
+      expect(
+        normalized.externalEmail,
+        "the normalizer must not invent an address"
+      ).toBeUndefined();
+      const ingested = await ingestInboundChatMessage(request, token, {
+        channelId,
+        senderIdentifier: normalized.senderIdentifier,
+        senderDisplayName: normalized.senderDisplayName,
+        body: normalized.body,
+        externalMessageId: normalized.externalMessageId,
+        externalConversationId: normalized.externalConversationId
+      });
+      expect(
+        ingested.status,
+        "the hub must accept an inbound message whose sender has no email address"
+      ).toBe("created");
+      expect(ingested.messageId, "a platform message must exist").toBeTruthy();
+      expect(ingested.channelLinkId, "the hub must persist a MessageChannelLink").toBeTruthy();
+      expect(
+        ingested.channelType,
+        "the compose must have been told the originating channel type"
+      ).not.toBe("email");
+      const after = await readHealth(request, token, channelId);
+      expect(
+        after.totalsLast24h ?? 0,
+        "the channel health snapshot must count the ingested message"
+      ).toBeGreaterThan(totalBefore);
+    } finally {
+      if (token && channelId) await deleteChannelIfExists(request, token, channelId);
+    }
+  });
+});
+//# sourceMappingURL=TC-CHANNEL-DISCORD-003.spec.js.map

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-003.spec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-003.spec.ts"],
+  "sourcesContent": ["import { expect, test } from '@playwright/test'\nimport { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api'\nimport { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures'\nimport {\n  deleteChannelIfExists,\n  ingestInboundChatMessage,\n  isChannelSeedingAvailable,\n  seedConnectedChannel,\n} from '@open-mercato/core/helpers/integration/communicationChannelsFixtures'\nimport { normalizeInboundDiscordMessage } from '../lib/normalize-inbound'\n\n/**\n * TC-CHANNEL-DISCORD-003 \u2014 a message shaped the way the Discord gateway\n * actually produces it is ingested end to end.\n * Source: .ai/specs/2026-06-19-discord-communication-channel-integration.md\n *\n * \u26A0\uFE0F HISTORY, because this spec earned the scepticism (QA of #4391, @Kapsik89\n * 2026-08-04 \u2192 #4975).\n *\n * The first version of this spec claimed to prove that \"an inbound Discord\n * message lands in the hub\" and stayed green through three live defects. It fed\n * the hub an invented `\u2026@test-seed.local` address for both the channel\n * identifier and the recipient, because the hub's `composeMessageSchema`\n * demanded `externalEmail` for every public message. A real Discord channel\n * carries `external_identifier = NULL` and a real Discord sender has no address\n * at all, so `normalizeInboundDiscordMessage` never ran on that path \u2014 the spec\n * asserted a landing zone the real provider could never reach.\n *\n * Both halves of that are fixed now:\n *   - #4975 (merged as #5252) made the `externalEmail` requirement conditional\n *     on the originating channel being email-typed, fail-closed.\n *   - the test-seed `ingest-inbound` action drives the real\n *     `ingest_inbound_message` command, which composes through\n *     `messages.messages.compose` \u2014 no SQL shortcut, no seeded rows.\n *\n * So this spec now does what its name always claimed:\n *   1. it starts from a verbatim Discord `MESSAGE_CREATE` frame,\n *   2. runs it through the **real** `normalizeInboundDiscordMessage` \u2014 the same\n *      function the gateway worker calls, not a re-implementation,\n *   3. hands the normalized result to the hub with **no address anywhere**, and\n *   4. asserts a platform message exists at the other end.\n *\n * Ceiling, stated rather than implied: the transport is the chat-flavoured\n * test-seed adapter, because connecting a real Discord channel requires a live\n * bot token and a live credential probe, neither of which exists in CI. What is\n * NOT stubbed is the part that was broken \u2014 the Discord frame, the Discord\n * normalizer, and the hub's compose validation. The socket state machine\n * (identify/resume/backoff, bot-self filtering, replay dedup) is a pure state\n * machine covered by `lib/__tests__/discord-gateway-client.test.ts` and\n * `lib/__tests__/gateway-bridge.test.ts`.\n *\n * Driven via the env-gated test-seed fixture (`OM_ENABLE_TEST_CHANNEL_SEEDING`);\n * skips when the gate is off.\n */\ntype HealthSnapshot = {\n  channelId?: string\n  counts?: Record<string, number>\n  totalsLast24h?: number\n}\n\nasync function readHealth(\n  request: Parameters<typeof apiRequest>[0],\n  token: string,\n  channelId: string,\n): Promise<HealthSnapshot> {\n  const response = await apiRequest(\n    request,\n    'GET',\n    `/api/communication_channels/channels/${channelId}/health`,\n    { token },\n  )\n  expect(response.status(), 'GET /channels/[id]/health should return 200').toBe(200)\n  return (await readJsonSafe<HealthSnapshot>(response)) ?? {}\n}\n\n/**\n * A `MESSAGE_CREATE` frame in the exact shape Discord delivers it. The values\n * are the ones QA captured from a real guild while filing #4975 \u2014 in particular\n * the author id is a genuine snowflake, which is the whole point: there is no\n * address on it, and none is invented anywhere below.\n */\nfunction discordMessageCreateFrame(stamp: number) {\n  return {\n    id: `1534333813851816${String(stamp).slice(-3)}`,\n    channel_id: '1534331920463433771',\n    guild_id: '1534331919796273152',\n    content: 'Kolejna wiadomo\u015B\u0107 testowa!@',\n    timestamp: new Date().toISOString(),\n    author: {\n      id: '1499156851487539260',\n      username: 'lorakaspak',\n      global_name: 'Karol Kapsa',\n      bot: false,\n    },\n    attachments: [],\n  }\n}\n\ntest.describe('TC-CHANNEL-DISCORD-003: inbound discord message ingest', () => {\n  test('a message shaped the way the Discord gateway actually produces it is ingested', async ({\n    request,\n  }) => {\n    test.slow()\n    let token: string | null = null\n    let channelId: string | null = null\n    try {\n      token = await getAuthToken(request, 'admin')\n      const seedingAvailable = await isChannelSeedingAvailable(request, token)\n      test.skip(\n        !seedingAvailable,\n        'OM_ENABLE_TEST_CHANNEL_SEEDING is not enabled in this environment; cannot ingest.',\n      )\n\n      const stamp = Date.now()\n      // `providerFlavor: 'chat'` connects the non-email stub, so the channel row\n      // carries a non-email `channelType` and a NULL `externalIdentifier` \u2014 the\n      // shape a real Discord channel has. No `externalIdentifier` is passed.\n      channelId = await seedConnectedChannel(request, token, {\n        displayName: `TC-CHANNEL-DISCORD-003 ${stamp}`,\n        providerFlavor: 'chat',\n      })\n\n      const before = await readHealth(request, token, channelId)\n      const totalBefore = before.totalsLast24h ?? 0\n\n      // The real normalizer, on a real frame. If Discord's payload shape and the\n      // hub's expectations ever drift apart, this line is where it shows.\n      const frame = discordMessageCreateFrame(stamp)\n      const normalized = normalizeInboundDiscordMessage(frame as never)\n\n      expect(\n        normalized.senderIdentifier,\n        'the sender must stay the Discord snowflake \u2014 synthesising an address here is what #4975 rejects',\n      ).toBe('1499156851487539260')\n      expect(normalized.externalConversationId).toBe('discord-channel:1534331920463433771')\n      expect(\n        (normalized as { externalEmail?: unknown }).externalEmail,\n        'the normalizer must not invent an address',\n      ).toBeUndefined()\n\n      const ingested = await ingestInboundChatMessage(request, token, {\n        channelId,\n        senderIdentifier: normalized.senderIdentifier,\n        senderDisplayName: normalized.senderDisplayName,\n        body: normalized.body,\n        externalMessageId: normalized.externalMessageId,\n        externalConversationId: normalized.externalConversationId,\n      })\n\n      // The assertion the old version could not make: the hub composed a real\n      // platform message from a sender with no address. Before #4975 this step\n      // failed `externalEmail is required when visibility is public`, retried\n      // three times and died in the queue while the channel still read\n      // `Connected`.\n      expect(\n        ingested.status,\n        'the hub must accept an inbound message whose sender has no email address',\n      ).toBe('created')\n      expect(ingested.messageId, 'a platform message must exist').toBeTruthy()\n      expect(ingested.channelLinkId, 'the hub must persist a MessageChannelLink').toBeTruthy()\n      expect(\n        ingested.channelType,\n        'the compose must have been told the originating channel type',\n      ).not.toBe('email')\n\n      const after = await readHealth(request, token, channelId)\n      expect(\n        after.totalsLast24h ?? 0,\n        'the channel health snapshot must count the ingested message',\n      ).toBeGreaterThan(totalBefore)\n    } finally {\n      if (token && channelId) await deleteChannelIfExists(request, token, channelId)\n    }\n  })\n})\n"],
+  "mappings": "AAAA,SAAS,QAAQ,YAAY;AAC7B,SAAS,YAAY,oBAAoB;AACzC,SAAS,oBAAoB;AAC7B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,sCAAsC;AAmD/C,eAAe,WACb,SACA,OACA,WACyB;AACzB,QAAM,WAAW,MAAM;AAAA,IACrB;AAAA,IACA;AAAA,IACA,wCAAwC,SAAS;AAAA,IACjD,EAAE,MAAM;AAAA,EACV;AACA,SAAO,SAAS,OAAO,GAAG,6CAA6C,EAAE,KAAK,GAAG;AACjF,SAAQ,MAAM,aAA6B,QAAQ,KAAM,CAAC;AAC5D;AAQA,SAAS,0BAA0B,OAAe;AAChD,SAAO;AAAA,IACL,IAAI,mBAAmB,OAAO,KAAK,EAAE,MAAM,EAAE,CAAC;AAAA,IAC9C,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,SAAS;AAAA,IACT,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,IAClC,QAAQ;AAAA,MACN,IAAI;AAAA,MACJ,UAAU;AAAA,MACV,aAAa;AAAA,MACb,KAAK;AAAA,IACP;AAAA,IACA,aAAa,CAAC;AAAA,EAChB;AACF;AAEA,KAAK,SAAS,0DAA0D,MAAM;AAC5E,OAAK,iFAAiF,OAAO;AAAA,IAC3F;AAAA,EACF,MAAM;AACJ,SAAK,KAAK;AACV,QAAI,QAAuB;AAC3B,QAAI,YAA2B;AAC/B,QAAI;AACF,cAAQ,MAAM,aAAa,SAAS,OAAO;AAC3C,YAAM,mBAAmB,MAAM,0BAA0B,SAAS,KAAK;AACvE,WAAK;AAAA,QACH,CAAC;AAAA,QACD;AAAA,MACF;AAEA,YAAM,QAAQ,KAAK,IAAI;AAIvB,kBAAY,MAAM,qBAAqB,SAAS,OAAO;AAAA,QACrD,aAAa,0BAA0B,KAAK;AAAA,QAC5C,gBAAgB;AAAA,MAClB,CAAC;AAED,YAAM,SAAS,MAAM,WAAW,SAAS,OAAO,SAAS;AACzD,YAAM,cAAc,OAAO,iBAAiB;AAI5C,YAAM,QAAQ,0BAA0B,KAAK;AAC7C,YAAM,aAAa,+BAA+B,KAAc;AAEhE;AAAA,QACE,WAAW;AAAA,QACX;AAAA,MACF,EAAE,KAAK,qBAAqB;AAC5B,aAAO,WAAW,sBAAsB,EAAE,KAAK,qCAAqC;AACpF;AAAA,QACG,WAA2C;AAAA,QAC5C;AAAA,MACF,EAAE,cAAc;AAEhB,YAAM,WAAW,MAAM,yBAAyB,SAAS,OAAO;AAAA,QAC9D;AAAA,QACA,kBAAkB,WAAW;AAAA,QAC7B,mBAAmB,WAAW;AAAA,QAC9B,MAAM,WAAW;AAAA,QACjB,mBAAmB,WAAW;AAAA,QAC9B,wBAAwB,WAAW;AAAA,MACrC,CAAC;AAOD;AAAA,QACE,SAAS;AAAA,QACT;AAAA,MACF,EAAE,KAAK,SAAS;AAChB,aAAO,SAAS,WAAW,+BAA+B,EAAE,WAAW;AACvE,aAAO,SAAS,eAAe,2CAA2C,EAAE,WAAW;AACvF;AAAA,QACE,SAAS;AAAA,QACT;AAAA,MACF,EAAE,IAAI,KAAK,OAAO;AAElB,YAAM,QAAQ,MAAM,WAAW,SAAS,OAAO,SAAS;AACxD;AAAA,QACE,MAAM,iBAAiB;AAAA,QACvB;AAAA,MACF,EAAE,gBAAgB,WAAW;AAAA,IAC/B,UAAE;AACA,UAAI,SAAS,UAAW,OAAM,sBAAsB,SAAS,OAAO,SAAS;AAAA,IAC/E;AAAA,EACF,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-004.spec.js

@@ -0,0 +1,65 @@
+import { expect, test } from "@playwright/test";
+import { apiRequest, getAuthToken } from "@open-mercato/core/helpers/integration/api";
+import { readJsonSafe } from "@open-mercato/core/helpers/integration/generalFixtures";
+import {
+  deleteChannelIfExists,
+  isChannelSeedingAvailable,
+  seedConnectedChannel,
+  seedInboundMessage
+} from "@open-mercato/core/helpers/integration/communicationChannelsFixtures";
+test.describe("TC-CHANNEL-DISCORD-004: reactions round-trip on a discord message", () => {
+  test("a reaction can be added to and removed from a discord-provider message", async ({
+    request
+  }) => {
+    test.slow();
+    let token = null;
+    let channelId = null;
+    try {
+      token = await getAuthToken(request, "admin");
+      const seedingAvailable = await isChannelSeedingAvailable(request, token);
+      test.skip(
+        !seedingAvailable,
+        "OM_ENABLE_TEST_CHANNEL_SEEDING is not enabled in this environment; cannot emit inbound messages."
+      );
+      const stamp = Date.now();
+      channelId = await seedConnectedChannel(request, token, {
+        displayName: `TC-CHANNEL-DISCORD-004 ${stamp}`,
+        externalIdentifier: `discord-004-${stamp}@test-seed.local`
+      });
+      const seeded = await seedInboundMessage(request, token, {
+        channelId,
+        providerKey: "discord",
+        from: `discord-user-${stamp}`,
+        subject: `Discord reaction target ${stamp}`,
+        bodyText: "react to me",
+        messageId: `discord-message-${stamp}`,
+        // The reaction route resolves the owning channel through this mapping.
+        createThreadMapping: true
+      });
+      const added = await apiRequest(
+        request,
+        "POST",
+        `/api/communication_channels/messages/${seeded.messageId}/reactions`,
+        { token, data: { emoji: "\u{1F44D}" } }
+      );
+      expect(added.status(), "adding a reaction to a discord message should return 201").toBe(201);
+      const addedBody = await readJsonSafe(added);
+      expect(addedBody?.emoji, "the reaction echoes the emoji").toBe("\u{1F44D}");
+      expect(addedBody?.messageId, "the reaction is bound to the seeded discord message").toBe(
+        seeded.messageId
+      );
+      const reactionId = addedBody?.id;
+      expect(reactionId, "the reaction response must carry an id to remove it by").toBeTruthy();
+      const removed = await apiRequest(
+        request,
+        "DELETE",
+        `/api/communication_channels/messages/${seeded.messageId}/reactions/${reactionId}`,
+        { token }
+      );
+      expect(removed.status(), "removing the reaction should return 204").toBe(204);
+    } finally {
+      await deleteChannelIfExists(request, token, channelId);
+    }
+  });
+});
+//# sourceMappingURL=TC-CHANNEL-DISCORD-004.spec.js.map

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-004.spec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-004.spec.ts"],
+  "sourcesContent": ["import { expect, test } from '@playwright/test'\nimport { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api'\nimport { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures'\nimport {\n  deleteChannelIfExists,\n  isChannelSeedingAvailable,\n  seedConnectedChannel,\n  seedInboundMessage,\n} from '@open-mercato/core/helpers/integration/communicationChannelsFixtures'\n\n/**\n * TC-CHANNEL-DISCORD-004 \u2014 reactions on a Discord-provider message.\n * Source: .ai/specs/2026-06-19-discord-communication-channel-integration.md\n *\n * `MESSAGE_REACTION_ADD` / `MESSAGE_REACTION_REMOVE` are bridged into the hub's\n * existing reaction routes, which resolve the owning channel through the\n * `ChannelThreadMapping` an inbound message leaves behind. This spec proves that\n * resolution works when the inbound traffic carries `providerKey: 'discord'` \u2014\n * i.e. the provider needs no reaction storage of its own \u2014 by adding and then\n * removing a reaction on a seeded Discord message.\n *\n * Driven via the env-gated test-seed fixture (`OM_ENABLE_TEST_CHANNEL_SEEDING`);\n * skips when the gate is off.\n */\ntest.describe('TC-CHANNEL-DISCORD-004: reactions round-trip on a discord message', () => {\n  test('a reaction can be added to and removed from a discord-provider message', async ({\n    request,\n  }) => {\n    test.slow()\n    let token: string | null = null\n    let channelId: string | null = null\n    try {\n      token = await getAuthToken(request, 'admin')\n      const seedingAvailable = await isChannelSeedingAvailable(request, token)\n      test.skip(\n        !seedingAvailable,\n        'OM_ENABLE_TEST_CHANNEL_SEEDING is not enabled in this environment; cannot emit inbound messages.',\n      )\n\n      const stamp = Date.now()\n      channelId = await seedConnectedChannel(request, token, {\n        displayName: `TC-CHANNEL-DISCORD-004 ${stamp}`,\n        externalIdentifier: `discord-004-${stamp}@test-seed.local`,\n      })\n\n      const seeded = await seedInboundMessage(request, token, {\n        channelId,\n        providerKey: 'discord',\n        from: `discord-user-${stamp}`,\n        subject: `Discord reaction target ${stamp}`,\n        bodyText: 'react to me',\n        messageId: `discord-message-${stamp}`,\n        // The reaction route resolves the owning channel through this mapping.\n        createThreadMapping: true,\n      })\n\n      const added = await apiRequest(\n        request,\n        'POST',\n        `/api/communication_channels/messages/${seeded.messageId}/reactions`,\n        { token, data: { emoji: '\uD83D\uDC4D' } },\n      )\n      expect(added.status(), 'adding a reaction to a discord message should return 201').toBe(201)\n      const addedBody = await readJsonSafe<{ id?: string; emoji?: string; messageId?: string }>(added)\n      expect(addedBody?.emoji, 'the reaction echoes the emoji').toBe('\uD83D\uDC4D')\n      expect(addedBody?.messageId, 'the reaction is bound to the seeded discord message').toBe(\n        seeded.messageId,\n      )\n\n      const reactionId = addedBody?.id\n      expect(reactionId, 'the reaction response must carry an id to remove it by').toBeTruthy()\n      const removed = await apiRequest(\n        request,\n        'DELETE',\n        `/api/communication_channels/messages/${seeded.messageId}/reactions/${reactionId}`,\n        { token },\n      )\n      expect(removed.status(), 'removing the reaction should return 204').toBe(204)\n    } finally {\n      await deleteChannelIfExists(request, token, channelId)\n    }\n  })\n})\n"],
+  "mappings": "AAAA,SAAS,QAAQ,YAAY;AAC7B,SAAS,YAAY,oBAAoB;AACzC,SAAS,oBAAoB;AAC7B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAgBP,KAAK,SAAS,qEAAqE,MAAM;AACvF,OAAK,0EAA0E,OAAO;AAAA,IACpF;AAAA,EACF,MAAM;AACJ,SAAK,KAAK;AACV,QAAI,QAAuB;AAC3B,QAAI,YAA2B;AAC/B,QAAI;AACF,cAAQ,MAAM,aAAa,SAAS,OAAO;AAC3C,YAAM,mBAAmB,MAAM,0BAA0B,SAAS,KAAK;AACvE,WAAK;AAAA,QACH,CAAC;AAAA,QACD;AAAA,MACF;AAEA,YAAM,QAAQ,KAAK,IAAI;AACvB,kBAAY,MAAM,qBAAqB,SAAS,OAAO;AAAA,QACrD,aAAa,0BAA0B,KAAK;AAAA,QAC5C,oBAAoB,eAAe,KAAK;AAAA,MAC1C,CAAC;AAED,YAAM,SAAS,MAAM,mBAAmB,SAAS,OAAO;AAAA,QACtD;AAAA,QACA,aAAa;AAAA,QACb,MAAM,gBAAgB,KAAK;AAAA,QAC3B,SAAS,2BAA2B,KAAK;AAAA,QACzC,UAAU;AAAA,QACV,WAAW,mBAAmB,KAAK;AAAA;AAAA,QAEnC,qBAAqB;AAAA,MACvB,CAAC;AAED,YAAM,QAAQ,MAAM;AAAA,QAClB;AAAA,QACA;AAAA,QACA,wCAAwC,OAAO,SAAS;AAAA,QACxD,EAAE,OAAO,MAAM,EAAE,OAAO,YAAK,EAAE;AAAA,MACjC;AACA,aAAO,MAAM,OAAO,GAAG,0DAA0D,EAAE,KAAK,GAAG;AAC3F,YAAM,YAAY,MAAM,aAAkE,KAAK;AAC/F,aAAO,WAAW,OAAO,+BAA+B,EAAE,KAAK,WAAI;AACnE,aAAO,WAAW,WAAW,qDAAqD,EAAE;AAAA,QAClF,OAAO;AAAA,MACT;AAEA,YAAM,aAAa,WAAW;AAC9B,aAAO,YAAY,wDAAwD,EAAE,WAAW;AACxF,YAAM,UAAU,MAAM;AAAA,QACpB;AAAA,QACA;AAAA,QACA,wCAAwC,OAAO,SAAS,cAAc,UAAU;AAAA,QAChF,EAAE,MAAM;AAAA,MACV;AACA,aAAO,QAAQ,OAAO,GAAG,yCAAyC,EAAE,KAAK,GAAG;AAAA,IAC9E,UAAE;AACA,YAAM,sBAAsB,SAAS,OAAO,SAAS;AAAA,IACvD;AAAA,EACF,CAAC;AACH,CAAC;",
+  "names": []
+}

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-005.spec.js

@@ -0,0 +1,110 @@
+import { expect, test } from "@playwright/test";
+import {
+  createDiscordSigner,
+  freshTimestamp,
+  interactionsUrl,
+  pingInteractionBody,
+  slashCommandInteractionBody,
+  staleTimestamp
+} from "./helpers/discordSignature.js";
+test.describe("TC-CHANNEL-DISCORD-005: interactions endpoint is fail-closed", () => {
+  test("an unsigned interaction is rejected", async ({ request }) => {
+    const bare = await request.post(interactionsUrl(), {
+      headers: { "content-type": "application/json" },
+      data: pingInteractionBody()
+    });
+    expect(bare.status(), "a request with no signature headers must be rejected").toBe(401);
+    expect(
+      await bare.json(),
+      "with no signed timestamp the freshness guard answers first \u2014 it runs before the signature fan-out"
+    ).toEqual({ error: "stale_timestamp" });
+    const timestamped = await request.post(interactionsUrl(), {
+      headers: { "content-type": "application/json", "x-signature-timestamp": freshTimestamp() },
+      data: pingInteractionBody()
+    });
+    expect(timestamped.status(), "a fresh timestamp with no signature must still be rejected").toBe(401);
+    expect(await timestamped.json(), "the rejection must not leak candidate channels").toEqual({
+      error: "invalid_signature"
+    });
+  });
+  test("a signature from an unknown key is rejected", async ({ request }) => {
+    const signer = createDiscordSigner();
+    const timestamp = freshTimestamp();
+    const body = pingInteractionBody();
+    const response = await request.post(interactionsUrl(), {
+      headers: {
+        "content-type": "application/json",
+        "x-signature-ed25519": signer.sign(timestamp, body),
+        "x-signature-timestamp": timestamp
+      },
+      data: body
+    });
+    expect(
+      response.status(),
+      "a cryptographically valid signature from a key no channel stores must still be rejected"
+    ).toBe(401);
+    expect(await response.json()).toEqual({ error: "invalid_signature" });
+  });
+  test("a body altered after signing is rejected", async ({ request }) => {
+    const signer = createDiscordSigner();
+    const timestamp = freshTimestamp();
+    const signed = pingInteractionBody();
+    const tampered = JSON.stringify({ ...JSON.parse(signed), type: 2 });
+    const response = await request.post(interactionsUrl(), {
+      headers: {
+        "content-type": "application/json",
+        "x-signature-ed25519": signer.sign(timestamp, signed),
+        "x-signature-timestamp": timestamp
+      },
+      data: tampered
+    });
+    expect(response.status(), "a tampered body must be rejected").toBe(401);
+    expect(await response.json()).toEqual({ error: "invalid_signature" });
+  });
+  test("a replayed (stale) timestamp is rejected before the candidate fan-out", async ({
+    request
+  }) => {
+    const signer = createDiscordSigner();
+    const timestamp = staleTimestamp();
+    const body = pingInteractionBody();
+    const response = await request.post(interactionsUrl(), {
+      headers: {
+        "content-type": "application/json",
+        "x-signature-ed25519": signer.sign(timestamp, body),
+        "x-signature-timestamp": timestamp
+      },
+      data: body
+    });
+    expect(response.status(), "a stale signed timestamp must be rejected").toBe(401);
+    expect(
+      await response.json(),
+      "the replay guard must answer before any per-candidate verification"
+    ).toEqual({ error: "stale_timestamp" });
+  });
+  test("an unverified slash command gets no deferred ack and no dispatch", async ({ request }) => {
+    const signer = createDiscordSigner();
+    const timestamp = freshTimestamp();
+    const body = slashCommandInteractionBody();
+    const response = await request.post(interactionsUrl(), {
+      headers: {
+        "content-type": "application/json",
+        "x-signature-ed25519": signer.sign(timestamp, body),
+        "x-signature-timestamp": timestamp
+      },
+      data: body
+    });
+    expect(response.status(), "an unverified slash command must be rejected, not deferred").toBe(401);
+    expect(await response.json()).toEqual({ error: "invalid_signature" });
+  });
+  test("a non-JSON body cannot crash the endpoint", async ({ request }) => {
+    const response = await request.post(interactionsUrl(), {
+      headers: { "content-type": "application/json" },
+      data: "not json at all"
+    });
+    expect(
+      response.status(),
+      "an unsigned garbage body must be refused by the signature gate, never 5xx"
+    ).toBe(401);
+  });
+});
+//# sourceMappingURL=TC-CHANNEL-DISCORD-005.spec.js.map

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-005.spec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-005.spec.ts"],
+  "sourcesContent": ["import { expect, test } from '@playwright/test'\nimport {\n  createDiscordSigner,\n  freshTimestamp,\n  interactionsUrl,\n  pingInteractionBody,\n  slashCommandInteractionBody,\n  staleTimestamp,\n} from './helpers/discordSignature'\n\n/**\n * TC-CHANNEL-DISCORD-005 \u2014 Interactions endpoint security (fail-closed).\n * Source: .ai/specs/2026-06-19-discord-communication-channel-integration.md\n *\n * `POST /api/channel_discord/interactions` is deliberately unauthenticated at\n * the platform layer \u2014 the Ed25519 signature IS the auth. This spec drives the\n * REAL route (DB fan-out over candidate channels included) and asserts it is\n * fail-closed on every rejection path:\n *\n *  - no signature headers at all           \u2192 401\n *  - a syntactically valid but wrong signature \u2192 401\n *  - a body altered after signing          \u2192 401\n *  - a signed timestamp outside the replay window \u2192 401 `stale_timestamp`,\n *    which also proves the freshness guard runs BEFORE the per-candidate\n *    verify fan-out (constant cost for a replayed capture)\n *  - a fully-formed slash command signed by an unknown key \u2192 401, never a\n *    deferred ack: since #4663 a deferred ack promises a hub write and a\n *    follow-up, so it must stay strictly behind the signature gate\n *\n * A rejection must never leak which tenants have Discord channels, so the\n * response body is asserted to carry nothing but the error code.\n *\n * The success paths \u2014 PONG (`{ type: 1 }`) and the dispatched slash command /\n * component (`{ type: 5 }` plus the hub job and the Discord follow-up) \u2014 need a\n * channel whose stored public key matches the signer; connecting one requires a\n * live bot token. That half stays unit-tested, in\n * `lib/__tests__/interactions-handler.test.ts`,\n * `lib/__tests__/interactions-dispatch.test.ts`,\n * `lib/__tests__/capabilities.test.ts` (the capability parity check) and\n * `workers/__tests__/discord-interactions.test.ts`.\n */\ntest.describe('TC-CHANNEL-DISCORD-005: interactions endpoint is fail-closed', () => {\n  test('an unsigned interaction is rejected', async ({ request }) => {\n    const bare = await request.post(interactionsUrl(), {\n      headers: { 'content-type': 'application/json' },\n      data: pingInteractionBody(),\n    })\n    expect(bare.status(), 'a request with no signature headers must be rejected').toBe(401)\n    expect(\n      await bare.json(),\n      'with no signed timestamp the freshness guard answers first \u2014 it runs before the signature fan-out',\n    ).toEqual({ error: 'stale_timestamp' })\n\n    const timestamped = await request.post(interactionsUrl(), {\n      headers: { 'content-type': 'application/json', 'x-signature-timestamp': freshTimestamp() },\n      data: pingInteractionBody(),\n    })\n    expect(timestamped.status(), 'a fresh timestamp with no signature must still be rejected').toBe(401)\n    expect(await timestamped.json(), 'the rejection must not leak candidate channels').toEqual({\n      error: 'invalid_signature',\n    })\n  })\n\n  test('a signature from an unknown key is rejected', async ({ request }) => {\n    const signer = createDiscordSigner()\n    const timestamp = freshTimestamp()\n    const body = pingInteractionBody()\n\n    const response = await request.post(interactionsUrl(), {\n      headers: {\n        'content-type': 'application/json',\n        'x-signature-ed25519': signer.sign(timestamp, body),\n        'x-signature-timestamp': timestamp,\n      },\n      data: body,\n    })\n    expect(\n      response.status(),\n      'a cryptographically valid signature from a key no channel stores must still be rejected',\n    ).toBe(401)\n    expect(await response.json()).toEqual({ error: 'invalid_signature' })\n  })\n\n  test('a body altered after signing is rejected', async ({ request }) => {\n    const signer = createDiscordSigner()\n    const timestamp = freshTimestamp()\n    const signed = pingInteractionBody()\n    const tampered = JSON.stringify({ ...JSON.parse(signed), type: 2 })\n\n    const response = await request.post(interactionsUrl(), {\n      headers: {\n        'content-type': 'application/json',\n        'x-signature-ed25519': signer.sign(timestamp, signed),\n        'x-signature-timestamp': timestamp,\n      },\n      data: tampered,\n    })\n    expect(response.status(), 'a tampered body must be rejected').toBe(401)\n    expect(await response.json()).toEqual({ error: 'invalid_signature' })\n  })\n\n  test('a replayed (stale) timestamp is rejected before the candidate fan-out', async ({\n    request,\n  }) => {\n    const signer = createDiscordSigner()\n    const timestamp = staleTimestamp()\n    const body = pingInteractionBody()\n\n    const response = await request.post(interactionsUrl(), {\n      headers: {\n        'content-type': 'application/json',\n        'x-signature-ed25519': signer.sign(timestamp, body),\n        'x-signature-timestamp': timestamp,\n      },\n      data: body,\n    })\n    expect(response.status(), 'a stale signed timestamp must be rejected').toBe(401)\n    expect(\n      await response.json(),\n      'the replay guard must answer before any per-candidate verification',\n    ).toEqual({ error: 'stale_timestamp' })\n  })\n\n  test('an unverified slash command gets no deferred ack and no dispatch', async ({ request }) => {\n    // The endpoint now DISPATCHES verified commands (issue #4663), which means a\n    // deferred ack is a promise to write into a tenant's hub and post back to\n    // Discord. That promise must stay behind the signature gate: a command\n    // signed by a key no channel stores is rejected exactly like a PING, never\n    // acknowledged with `{ type: 5 }`.\n    const signer = createDiscordSigner()\n    const timestamp = freshTimestamp()\n    const body = slashCommandInteractionBody()\n\n    const response = await request.post(interactionsUrl(), {\n      headers: {\n        'content-type': 'application/json',\n        'x-signature-ed25519': signer.sign(timestamp, body),\n        'x-signature-timestamp': timestamp,\n      },\n      data: body,\n    })\n    expect(response.status(), 'an unverified slash command must be rejected, not deferred').toBe(401)\n    expect(await response.json()).toEqual({ error: 'invalid_signature' })\n  })\n\n  test('a non-JSON body cannot crash the endpoint', async ({ request }) => {\n    const response = await request.post(interactionsUrl(), {\n      headers: { 'content-type': 'application/json' },\n      data: 'not json at all',\n    })\n    expect(\n      response.status(),\n      'an unsigned garbage body must be refused by the signature gate, never 5xx',\n    ).toBe(401)\n  })\n})\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/channel_discord/__integration__/TC-CHANNEL-DISCORD-006.spec.js

@@ -0,0 +1,103 @@
+import { expect, test } from "@playwright/test";
+import { apiRequest, getAuthToken } from "@open-mercato/core/helpers/integration/api";
+import { readJsonSafe } from "@open-mercato/core/helpers/integration/generalFixtures";
+import { deleteEntityIfExists } from "@open-mercato/core/helpers/integration/crmFixtures";
+import {
+  deleteChannelIfExists,
+  isChannelSeedingAvailable,
+  seedConnectedChannel,
+  seedInboundMessage
+} from "@open-mercato/core/helpers/integration/communicationChannelsFixtures";
+import { drainEventsQueue } from "./helpers/eventsQueue.js";
+async function drainAndListInteractions(request, token, personId, timeoutMs = 2e4) {
+  const deadline = Date.now() + timeoutMs;
+  let last = [];
+  while (Date.now() < deadline) {
+    await drainEventsQueue();
+    const response = await apiRequest(
+      request,
+      "GET",
+      `/api/customers/interactions?entityId=${encodeURIComponent(personId)}&interactionType=email`,
+      { token }
+    );
+    if (response.ok()) {
+      const body = await readJsonSafe(response);
+      last = Array.isArray(body?.items) ? body.items : [];
+      if (last.length > 0) return last;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  return last;
+}
+test.describe("TC-CHANNEL-DISCORD-006: inbound discord message resolves to a contact", () => {
+  test("an inbound discord message from a known contact creates exactly one interaction", async ({
+    request
+  }) => {
+    test.slow();
+    let token = null;
+    let personId = null;
+    let channelId = null;
+    let interactionId = null;
+    try {
+      token = await getAuthToken(request, "admin");
+      const seedingAvailable = await isChannelSeedingAvailable(request, token);
+      test.skip(
+        !seedingAvailable,
+        "OM_ENABLE_TEST_CHANNEL_SEEDING is not enabled in this environment; cannot emit inbound messages."
+      );
+      const stamp = Date.now();
+      const senderAddress = `discord-006-sender-${stamp}@example.com`;
+      const person = await apiRequest(request, "POST", "/api/customers/people", {
+        token,
+        data: {
+          firstName: "Discord006",
+          lastName: `Contact${stamp}`,
+          displayName: `Discord006 Contact ${stamp}`,
+          primaryEmail: senderAddress
+        }
+      });
+      expect(person.ok(), "creating the contact fixture should succeed").toBeTruthy();
+      const personBody = await readJsonSafe(person);
+      personId = personBody?.id ?? null;
+      expect(personId, "the person fixture must return an id").toBeTruthy();
+      channelId = await seedConnectedChannel(request, token, {
+        displayName: `TC-CHANNEL-DISCORD-006 ${stamp}`,
+        externalIdentifier: `discord-006-${stamp}@test-seed.local`
+      });
+      const subject = `Discord inbound from a known contact ${stamp}`;
+      const bodyText = "this should land on the CRM timeline";
+      await seedInboundMessage(request, token, {
+        channelId,
+        providerKey: "discord",
+        from: senderAddress,
+        subject,
+        bodyText,
+        messageId: `discord-message-006-${stamp}`
+      });
+      const items = await drainAndListInteractions(request, token, personId);
+      expect(items.length, "exactly one interaction must be linked to the contact").toBe(1);
+      const interaction = items[0];
+      interactionId = interaction.id;
+      expect(interaction.interactionType, "channel messages land as email interactions").toBe("email");
+      expect(interaction.title, "the interaction must carry the discord message subject").toBe(subject);
+      expect(interaction.body, "the interaction must carry the discord message body").toBe(bodyText);
+      expect(
+        interaction.visibility,
+        "a user-owned channel produces a private inbound interaction"
+      ).toBe("private");
+      expect(
+        interaction.authorUserId,
+        "the interaction must be authored by the channel owner, not left unattributed"
+      ).toBeTruthy();
+    } finally {
+      if (token) {
+        await deleteEntityIfExists(request, token, "/api/customers/interactions", interactionId);
+      }
+      await deleteChannelIfExists(request, token, channelId);
+      if (token) {
+        await deleteEntityIfExists(request, token, "/api/customers/people", personId);
+      }
+    }
+  });
+});
+//# sourceMappingURL=TC-CHANNEL-DISCORD-006.spec.js.map