@open-mercato/channel-smtp 0.0.0-stage → 0.10.1-develop.7749.1.ea3edf75e3

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+[build:channel-smtp] found 16 entry points
+[build:channel-smtp] 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-smtp' })

package/dist/index.js

@@ -0,0 +1,5 @@
+import { metadata } from "./modules/channel_smtp/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_smtp/index'\n"],
+  "mappings": "AAAA,SAAS,gBAAgB;",
+  "names": []
+}

package/dist/modules/channel_smtp/__integration__/TC-CHANNEL-SMTP-001.spec.js

@@ -0,0 +1,97 @@
+import { expect, test } from "@playwright/test";
+import { getAuthToken } from "@open-mercato/core/helpers/integration/authFixtures";
+import { apiRequest } from "@open-mercato/core/helpers/integration/api";
+import { readJsonSafe } from "@open-mercato/core/helpers/integration/generalFixtures";
+const TENANT_CONNECT = "/api/communication_channels/channels/connect/tenant-credentials";
+const PER_USER_CONNECT = "/api/communication_channels/channels/connect/credentials";
+const validRelay = {
+  host: "smtp.example.com",
+  port: 587,
+  tls: "starttls",
+  user: "mailer",
+  password: "not-a-real-password",
+  fromAddress: "no-reply@example.com"
+};
+test.describe("TC-CHANNEL-SMTP-001: SMTP provider registration and safety refusals", () => {
+  test("per-user connect with providerKey=smtp is refused (403, tenant-scoped)", async ({
+    request
+  }) => {
+    const token = await getAuthToken(request);
+    const response = await apiRequest(request, "POST", PER_USER_CONNECT, {
+      token,
+      data: {
+        providerKey: "smtp",
+        displayName: "SMTP \u2014 per-user (should be refused)",
+        credentials: validRelay
+      }
+    });
+    expect(response.status(), "route should not 5xx").toBeLessThan(500);
+    expect(response.status(), "authenticated request should not 401").not.toBe(401);
+    expect(response.status()).toBe(403);
+    const body = await readJsonSafe(response);
+    expect(body?.code).toBe("provider_is_tenant_scoped");
+  });
+  test("tenant connect with empty credentials reaches validateCredentials (422)", async ({
+    request
+  }) => {
+    const token = await getAuthToken(request);
+    const response = await apiRequest(request, "POST", TENANT_CONNECT, {
+      token,
+      data: { providerKey: "smtp", displayName: "SMTP \u2014 tenant connect", credentials: {} }
+    });
+    expect(response.status(), "route should not 5xx").toBeLessThan(500);
+    expect(response.status(), "authenticated request should not 401").not.toBe(401);
+    expect(response.status(), "registered adapter should reject empty credentials").toBe(422);
+    const body = await readJsonSafe(response);
+    expect(Object.keys(body?.fieldErrors ?? {})).toEqual(
+      expect.arrayContaining(["host", "user", "password", "fromAddress"])
+    );
+  });
+  test("tenant connect refuses a loopback relay host before persisting anything", async ({
+    request
+  }) => {
+    const token = await getAuthToken(request);
+    const response = await apiRequest(request, "POST", TENANT_CONNECT, {
+      token,
+      data: {
+        providerKey: "smtp",
+        displayName: "SMTP \u2014 loopback relay (should be refused)",
+        credentials: { ...validRelay, host: "127.0.0.1" }
+      }
+    });
+    expect(response.status(), "route should not 5xx").toBeLessThan(500);
+    expect(response.status(), "a loopback relay host must be refused at save time").toBe(422);
+    const body = await readJsonSafe(response);
+    expect(body?.fieldErrors?.host, "the refusal must name the host field").toMatch(
+      /private or loopback/i
+    );
+  });
+  test("tenant connect refuses cleartext transport without the operator opt-in", async ({
+    request
+  }) => {
+    const token = await getAuthToken(request);
+    const response = await apiRequest(request, "POST", TENANT_CONNECT, {
+      token,
+      data: {
+        providerKey: "smtp",
+        displayName: "SMTP \u2014 cleartext (should be refused)",
+        credentials: { ...validRelay, tls: "none", port: 25 }
+      }
+    });
+    expect(response.status(), "route should not 5xx").toBeLessThan(500);
+    expect(response.status(), "cleartext must be refused unless opted in").toBe(422);
+    const body = await readJsonSafe(response);
+    expect(body?.fieldErrors?.tls).toMatch(/OM_CHANNEL_SMTP_ALLOW_INSECURE_TRANSPORT/);
+  });
+  test("both connect routes reject unauthenticated callers", async ({ request }) => {
+    for (const url of [PER_USER_CONNECT, TENANT_CONNECT]) {
+      const response = await apiRequest(request, "POST", url, {
+        // Intentionally empty token — this asserts the 401 unauth path.
+        token: "",
+        data: { providerKey: "smtp", displayName: "SMTP", credentials: validRelay }
+      });
+      expect(response.status(), `${url} must require authentication`).toBe(401);
+    }
+  });
+});
+//# sourceMappingURL=TC-CHANNEL-SMTP-001.spec.js.map

package/dist/modules/channel_smtp/__integration__/TC-CHANNEL-SMTP-001.spec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_smtp/__integration__/TC-CHANNEL-SMTP-001.spec.ts"],
+  "sourcesContent": ["import { expect, test } from '@playwright/test'\nimport { getAuthToken } from '@open-mercato/core/helpers/integration/authFixtures'\nimport { apiRequest } from '@open-mercato/core/helpers/integration/api'\nimport { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures'\n\n/**\n * TC-CHANNEL-SMTP-001 \u2014 SMTP provider registration, tenant scope and the\n * save-time safety refusals.\n *\n * `@open-mercato/channel-smtp` registers the `smtp` email `ChannelAdapter` with\n * `channelScope: 'tenant'`. That declaration is load-bearing: `sendSystemEmail`\n * only ever resolves tenant-wide rows, so a per-user SMTP channel would be\n * invisible to system email. The credential-connect routes are where both the\n * registration and the scope become observable:\n *\n *  - the **per-user** route short-circuits tenant-scoped providers with 403\n *    (`provider_is_tenant_scoped`) before touching credentials \u2014 403 rather than\n *    404 (`no_adapter`) proves the adapter is registered, and it stops a\n *    non-admin minting a tenant-wide relay;\n *  - the **tenant** route runs the adapter's own `validateCredentials`, so the\n *    relay host is an operator-supplied SSRF surface that must be refused at\n *    save time, not merely at send time.\n *\n * Every case here fails validation, so no channel is created and there is\n * nothing to clean up. The relay round-trip (rendering, replyTo, attachments,\n * the raw-string recipient the hub test-send route passes, and partial\n * recipient rejection) is covered network-free in\n * `lib/__tests__/adapter.test.ts` and `lib/__tests__/validate-credentials.test.ts`.\n */\nconst TENANT_CONNECT = '/api/communication_channels/channels/connect/tenant-credentials'\nconst PER_USER_CONNECT = '/api/communication_channels/channels/connect/credentials'\n\nconst validRelay = {\n  host: 'smtp.example.com',\n  port: 587,\n  tls: 'starttls',\n  user: 'mailer',\n  password: 'not-a-real-password',\n  fromAddress: 'no-reply@example.com',\n}\n\ntest.describe('TC-CHANNEL-SMTP-001: SMTP provider registration and safety refusals', () => {\n  test('per-user connect with providerKey=smtp is refused (403, tenant-scoped)', async ({\n    request,\n  }) => {\n    const token = await getAuthToken(request)\n    const response = await apiRequest(request, 'POST', PER_USER_CONNECT, {\n      token,\n      data: {\n        providerKey: 'smtp',\n        displayName: 'SMTP \u2014 per-user (should be refused)',\n        credentials: validRelay,\n      },\n    })\n\n    expect(response.status(), 'route should not 5xx').toBeLessThan(500)\n    expect(response.status(), 'authenticated request should not 401').not.toBe(401)\n    expect(response.status()).toBe(403)\n    const body = await readJsonSafe<{ code?: string }>(response)\n    expect(body?.code).toBe('provider_is_tenant_scoped')\n  })\n\n  test('tenant connect with empty credentials reaches validateCredentials (422)', async ({\n    request,\n  }) => {\n    const token = await getAuthToken(request)\n    const response = await apiRequest(request, 'POST', TENANT_CONNECT, {\n      token,\n      data: { providerKey: 'smtp', displayName: 'SMTP \u2014 tenant connect', credentials: {} },\n    })\n\n    expect(response.status(), 'route should not 5xx').toBeLessThan(500)\n    // Asserting 422 (not merely \"not 404\") proves the request authenticated AND\n    // reached the adapter \u2014 a 401 auth misconfig would let this pass vacuously.\n    expect(response.status(), 'authenticated request should not 401').not.toBe(401)\n    expect(response.status(), 'registered adapter should reject empty credentials').toBe(422)\n    const body = await readJsonSafe<{ fieldErrors?: Record<string, string> }>(response)\n    expect(Object.keys(body?.fieldErrors ?? {})).toEqual(\n      expect.arrayContaining(['host', 'user', 'password', 'fromAddress']),\n    )\n  })\n\n  test('tenant connect refuses a loopback relay host before persisting anything', async ({\n    request,\n  }) => {\n    const token = await getAuthToken(request)\n    const response = await apiRequest(request, 'POST', TENANT_CONNECT, {\n      token,\n      data: {\n        providerKey: 'smtp',\n        displayName: 'SMTP \u2014 loopback relay (should be refused)',\n        credentials: { ...validRelay, host: '127.0.0.1' },\n      },\n    })\n\n    expect(response.status(), 'route should not 5xx').toBeLessThan(500)\n    expect(response.status(), 'a loopback relay host must be refused at save time').toBe(422)\n    const body = await readJsonSafe<{ fieldErrors?: Record<string, string> }>(response)\n    expect(body?.fieldErrors?.host, 'the refusal must name the host field').toMatch(\n      /private or loopback/i,\n    )\n  })\n\n  test('tenant connect refuses cleartext transport without the operator opt-in', async ({\n    request,\n  }) => {\n    const token = await getAuthToken(request)\n    const response = await apiRequest(request, 'POST', TENANT_CONNECT, {\n      token,\n      data: {\n        providerKey: 'smtp',\n        displayName: 'SMTP \u2014 cleartext (should be refused)',\n        credentials: { ...validRelay, tls: 'none', port: 25 },\n      },\n    })\n\n    expect(response.status(), 'route should not 5xx').toBeLessThan(500)\n    expect(response.status(), 'cleartext must be refused unless opted in').toBe(422)\n    const body = await readJsonSafe<{ fieldErrors?: Record<string, string> }>(response)\n    expect(body?.fieldErrors?.tls).toMatch(/OM_CHANNEL_SMTP_ALLOW_INSECURE_TRANSPORT/)\n  })\n\n  test('both connect routes reject unauthenticated callers', async ({ request }) => {\n    for (const url of [PER_USER_CONNECT, TENANT_CONNECT]) {\n      const response = await apiRequest(request, 'POST', url, {\n        // Intentionally empty token \u2014 this asserts the 401 unauth path.\n        token: '',\n        data: { providerKey: 'smtp', displayName: 'SMTP', credentials: validRelay },\n      })\n      expect(response.status(), `${url} must require authentication`).toBe(401)\n    }\n  })\n})\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/channel_smtp/__integration__/meta.js

@@ -0,0 +1,10 @@
+const integrationMeta = {
+  description: "SMTP outbound email provider integration coverage (TC-CHANNEL-SMTP-001)",
+  dependsOnModules: ["communication_channels", "channel_smtp"]
+};
+var meta_default = integrationMeta;
+export {
+  meta_default as default,
+  integrationMeta
+};
+//# sourceMappingURL=meta.js.map

package/dist/modules/channel_smtp/__integration__/meta.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_smtp/__integration__/meta.ts"],
+  "sourcesContent": ["export const integrationMeta = {\n  description: 'SMTP outbound email provider integration coverage (TC-CHANNEL-SMTP-001)',\n  dependsOnModules: ['communication_channels', 'channel_smtp'],\n}\n\nexport default integrationMeta\n"],
+  "mappings": "AAAO,MAAM,kBAAkB;AAAA,EAC7B,aAAa;AAAA,EACb,kBAAkB,CAAC,0BAA0B,cAAc;AAC7D;AAEA,IAAO,eAAQ;",
+  "names": []
+}

package/dist/modules/channel_smtp/acl.js

@@ -0,0 +1,10 @@
+const features = [
+  { id: "channel_smtp.view", title: "View SMTP channel configuration", module: "channel_smtp" },
+  { id: "channel_smtp.configure", title: "Configure SMTP channel defaults", module: "channel_smtp" }
+];
+var acl_default = features;
+export {
+  acl_default as default,
+  features
+};
+//# sourceMappingURL=acl.js.map

package/dist/modules/channel_smtp/acl.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/modules/channel_smtp/acl.ts"],
+  "sourcesContent": ["export const features = [\n  { id: 'channel_smtp.view', title: 'View SMTP channel configuration', module: 'channel_smtp' },\n  { id: 'channel_smtp.configure', title: 'Configure SMTP channel defaults', module: 'channel_smtp' },\n]\n\nexport default features\n"],
+  "mappings": "AAAO,MAAM,WAAW;AAAA,EACtB,EAAE,IAAI,qBAAqB,OAAO,mCAAmC,QAAQ,eAAe;AAAA,EAC5F,EAAE,IAAI,0BAA0B,OAAO,mCAAmC,QAAQ,eAAe;AACnG;AAEA,IAAO,cAAQ;",
+  "names": []
+}

package/dist/modules/channel_smtp/capabilities.js

@@ -0,0 +1,10 @@
+import { baseEmailCapabilities } from "@open-mercato/core/modules/communication_channels/lib/email-capabilities";
+const smtpCapabilities = {
+  ...baseEmailCapabilities,
+  fileSharing: false,
+  conversationHistory: false
+};
+export {
+  smtpCapabilities
+};
+//# sourceMappingURL=capabilities.js.map

package/dist/modules/channel_smtp/capabilities.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/modules/channel_smtp/capabilities.ts"],
+  "sourcesContent": ["import { baseEmailCapabilities } from '@open-mercato/core/modules/communication_channels/lib/email-capabilities'\nimport type { ChannelCapabilities } from '@open-mercato/core/modules/communication_channels/lib/adapter'\n\nexport const smtpCapabilities: ChannelCapabilities = {\n  ...baseEmailCapabilities,\n  fileSharing: false,\n  conversationHistory: false,\n}\n"],
+  "mappings": "AAAA,SAAS,6BAA6B;AAG/B,MAAM,mBAAwC;AAAA,EACnD,GAAG;AAAA,EACH,aAAa;AAAA,EACb,qBAAqB;AACvB;",
+  "names": []
+}

package/dist/modules/channel_smtp/di.js

@@ -0,0 +1,22 @@
+import { asValue } from "awilix";
+import {
+  hasChannelAdapter,
+  registerChannelAdapter
+} from "@open-mercato/core/modules/communication_channels/lib/adapter-registry-singleton";
+import { getSmtpChannelAdapter } from "./lib/adapter.js";
+import { registerSmtpSystemEmailConfigResolver } from "./lib/system-email-config.js";
+import { channelSmtpHealthCheck } from "./lib/health.js";
+function register(container) {
+  registerSmtpSystemEmailConfigResolver();
+  if (!hasChannelAdapter("smtp")) {
+    registerChannelAdapter(getSmtpChannelAdapter());
+  }
+  container.register({
+    channelSmtpAdapter: asValue(getSmtpChannelAdapter()),
+    channelSmtpHealthCheck: asValue(channelSmtpHealthCheck)
+  });
+}
+export {
+  register
+};
+//# sourceMappingURL=di.js.map

package/dist/modules/channel_smtp/di.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/modules/channel_smtp/di.ts"],
+  "sourcesContent": ["import { asValue } from 'awilix'\nimport type { AppContainer } from '@open-mercato/shared/lib/di/container'\nimport {\n  hasChannelAdapter,\n  registerChannelAdapter,\n} from '@open-mercato/core/modules/communication_channels/lib/adapter-registry-singleton'\nimport { getSmtpChannelAdapter } from './lib/adapter'\nimport { registerSmtpSystemEmailConfigResolver } from './lib/system-email-config'\nimport { channelSmtpHealthCheck } from './lib/health'\n\nexport function register(container: AppContainer): void {\n  registerSmtpSystemEmailConfigResolver()\n  if (!hasChannelAdapter('smtp')) {\n    registerChannelAdapter(getSmtpChannelAdapter())\n  }\n  container.register({\n    channelSmtpAdapter: asValue(getSmtpChannelAdapter()),\n    channelSmtpHealthCheck: asValue(channelSmtpHealthCheck),\n  })\n}\n"],
+  "mappings": "AAAA,SAAS,eAAe;AAExB;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,6BAA6B;AACtC,SAAS,6CAA6C;AACtD,SAAS,8BAA8B;AAEhC,SAAS,SAAS,WAA+B;AACtD,wCAAsC;AACtC,MAAI,CAAC,kBAAkB,MAAM,GAAG;AAC9B,2BAAuB,sBAAsB,CAAC;AAAA,EAChD;AACA,YAAU,SAAS;AAAA,IACjB,oBAAoB,QAAQ,sBAAsB,CAAC;AAAA,IACnD,wBAAwB,QAAQ,sBAAsB;AAAA,EACxD,CAAC;AACH;",
+  "names": []
+}

package/dist/modules/channel_smtp/index.js

@@ -0,0 +1,13 @@
+const metadata = {
+  id: "channel_smtp",
+  name: "SMTP Email Channel",
+  description: "Outbound SMTP relay email channel provider for the Communications Hub.",
+  version: "0.1.0",
+  requires: ["communication_channels", "integrations"]
+};
+var channel_smtp_default = metadata;
+export {
+  channel_smtp_default as default,
+  metadata
+};
+//# sourceMappingURL=index.js.map

package/dist/modules/channel_smtp/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/modules/channel_smtp/index.ts"],
+  "sourcesContent": ["export const metadata = {\n  id: 'channel_smtp',\n  name: 'SMTP Email Channel',\n  description: 'Outbound SMTP relay email channel provider for the Communications Hub.',\n  version: '0.1.0',\n  requires: ['communication_channels', 'integrations'],\n}\n\nexport default metadata\n"],
+  "mappings": "AAAO,MAAM,WAAW;AAAA,EACtB,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,aAAa;AAAA,EACb,SAAS;AAAA,EACT,UAAU,CAAC,0BAA0B,cAAc;AACrD;AAEA,IAAO,uBAAQ;",
+  "names": []
+}

package/dist/modules/channel_smtp/integration.js

@@ -0,0 +1,96 @@
+import { buildIntegrationDetailWidgetSpotId } from "@open-mercato/shared/modules/integrations/types";
+const channelSmtpDetailWidgetSpotId = buildIntegrationDetailWidgetSpotId("channel_smtp");
+const integration = {
+  id: "channel_smtp",
+  title: "SMTP Email",
+  description: "Send transactional email through any SMTP relay using the Communications Hub.",
+  category: "communication",
+  hub: "communication_channels",
+  providerKey: "smtp",
+  icon: "mail",
+  docsUrl: "https://nodemailer.com/smtp/",
+  package: "@open-mercato/channel-smtp",
+  version: "0.1.0",
+  author: "Open Mercato Team",
+  company: "Open Mercato",
+  license: "MIT",
+  tags: ["email", "smtp", "relay", "transactional", "communication"],
+  detailPage: {
+    widgetSpotId: channelSmtpDetailWidgetSpotId
+  },
+  apiVersions: [
+    {
+      id: "smtp",
+      label: "SMTP (RFC 5321)",
+      status: "stable",
+      default: true,
+      changelog: "Initial outbound transactional email adapter."
+    }
+  ],
+  healthCheck: { service: "channelSmtpHealthCheck" },
+  credentials: {
+    fields: [
+      {
+        key: "host",
+        label: "SMTP host",
+        type: "text",
+        required: true,
+        placeholder: "smtp.example.com",
+        helpText: "Hostname of the SMTP relay. Private and loopback addresses are rejected."
+      },
+      {
+        key: "port",
+        label: "SMTP port",
+        type: "text",
+        required: true,
+        placeholder: "587",
+        helpText: "Usually 587 for STARTTLS or 465 for implicit TLS."
+      },
+      {
+        key: "tls",
+        label: "Transport security",
+        type: "select",
+        required: true,
+        options: [
+          { value: "starttls", label: "STARTTLS (usually port 587)" },
+          { value: "tls", label: "Implicit TLS (usually port 465)" },
+          { value: "none", label: "Cleartext (requires an operator opt-in)" }
+        ],
+        helpText: "Cleartext is refused unless OM_CHANNEL_SMTP_ALLOW_INSECURE_TRANSPORT is set."
+      },
+      {
+        key: "user",
+        label: "Username",
+        type: "text",
+        required: true,
+        helpText: "SMTP AUTH username issued by the relay."
+      },
+      {
+        key: "password",
+        label: "Password",
+        type: "secret",
+        required: true,
+        helpText: "SMTP AUTH password or app-specific password."
+      },
+      {
+        key: "fromAddress",
+        label: "From address",
+        type: "text",
+        required: true,
+        placeholder: "no-reply@example.com",
+        helpText: "Sender address the relay is authorized to send for."
+      }
+    ]
+  }
+};
+const integrations = [integration];
+const bundles = [];
+const bundle = void 0;
+export {
+  bundle,
+  bundles,
+  channelSmtpDetailWidgetSpotId,
+  integration,
+  integrations
+};
+//# sourceMappingURL=integration.js.map

package/dist/modules/channel_smtp/integration.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/modules/channel_smtp/integration.ts"],
+  "sourcesContent": ["import { buildIntegrationDetailWidgetSpotId, type IntegrationBundle, type IntegrationDefinition } from '@open-mercato/shared/modules/integrations/types'\n\nexport const channelSmtpDetailWidgetSpotId = buildIntegrationDetailWidgetSpotId('channel_smtp')\n\nexport const integration: IntegrationDefinition = {\n  id: 'channel_smtp',\n  title: 'SMTP Email',\n  description: 'Send transactional email through any SMTP relay using the Communications Hub.',\n  category: 'communication',\n  hub: 'communication_channels',\n  providerKey: 'smtp',\n  icon: 'mail',\n  docsUrl: 'https://nodemailer.com/smtp/',\n  package: '@open-mercato/channel-smtp',\n  version: '0.1.0',\n  author: 'Open Mercato Team',\n  company: 'Open Mercato',\n  license: 'MIT',\n  tags: ['email', 'smtp', 'relay', 'transactional', 'communication'],\n  detailPage: {\n    widgetSpotId: channelSmtpDetailWidgetSpotId,\n  },\n  apiVersions: [\n    {\n      id: 'smtp',\n      label: 'SMTP (RFC 5321)',\n      status: 'stable',\n      default: true,\n      changelog: 'Initial outbound transactional email adapter.',\n    },\n  ],\n  healthCheck: { service: 'channelSmtpHealthCheck' },\n  credentials: {\n    fields: [\n      {\n        key: 'host',\n        label: 'SMTP host',\n        type: 'text',\n        required: true,\n        placeholder: 'smtp.example.com',\n        helpText: 'Hostname of the SMTP relay. Private and loopback addresses are rejected.',\n      },\n      {\n        key: 'port',\n        label: 'SMTP port',\n        type: 'text',\n        required: true,\n        placeholder: '587',\n        helpText: 'Usually 587 for STARTTLS or 465 for implicit TLS.',\n      },\n      {\n        key: 'tls',\n        label: 'Transport security',\n        type: 'select',\n        required: true,\n        options: [\n          { value: 'starttls', label: 'STARTTLS (usually port 587)' },\n          { value: 'tls', label: 'Implicit TLS (usually port 465)' },\n          { value: 'none', label: 'Cleartext (requires an operator opt-in)' },\n        ],\n        helpText: 'Cleartext is refused unless OM_CHANNEL_SMTP_ALLOW_INSECURE_TRANSPORT is set.',\n      },\n      {\n        key: 'user',\n        label: 'Username',\n        type: 'text',\n        required: true,\n        helpText: 'SMTP AUTH username issued by the relay.',\n      },\n      {\n        key: 'password',\n        label: 'Password',\n        type: 'secret',\n        required: true,\n        helpText: 'SMTP AUTH password or app-specific password.',\n      },\n      {\n        key: 'fromAddress',\n        label: 'From address',\n        type: 'text',\n        required: true,\n        placeholder: 'no-reply@example.com',\n        helpText: 'Sender address the relay is authorized to send for.',\n      },\n    ],\n  },\n}\n\nexport const integrations: IntegrationDefinition[] = [integration]\nexport const bundles: IntegrationBundle[] = []\nexport const bundle: IntegrationBundle | undefined = undefined\n"],
+  "mappings": "AAAA,SAAS,0CAA8F;AAEhG,MAAM,gCAAgC,mCAAmC,cAAc;AAEvF,MAAM,cAAqC;AAAA,EAChD,IAAI;AAAA,EACJ,OAAO;AAAA,EACP,aAAa;AAAA,EACb,UAAU;AAAA,EACV,KAAK;AAAA,EACL,aAAa;AAAA,EACb,MAAM;AAAA,EACN,SAAS;AAAA,EACT,SAAS;AAAA,EACT,SAAS;AAAA,EACT,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,SAAS;AAAA,EACT,MAAM,CAAC,SAAS,QAAQ,SAAS,iBAAiB,eAAe;AAAA,EACjE,YAAY;AAAA,IACV,cAAc;AAAA,EAChB;AAAA,EACA,aAAa;AAAA,IACX;AAAA,MACE,IAAI;AAAA,MACJ,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,WAAW;AAAA,IACb;AAAA,EACF;AAAA,EACA,aAAa,EAAE,SAAS,yBAAyB;AAAA,EACjD,aAAa;AAAA,IACX,QAAQ;AAAA,MACN;AAAA,QACE,KAAK;AAAA,QACL,OAAO;AAAA,QACP,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,QACb,UAAU;AAAA,MACZ;AAAA,MACA;AAAA,QACE,KAAK;AAAA,QACL,OAAO;AAAA,QACP,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,QACb,UAAU;AAAA,MACZ;AAAA,MACA;AAAA,QACE,KAAK;AAAA,QACL,OAAO;AAAA,QACP,MAAM;AAAA,QACN,UAAU;AAAA,QACV,SAAS;AAAA,UACP,EAAE,OAAO,YAAY,OAAO,8BAA8B;AAAA,UAC1D,EAAE,OAAO,OAAO,OAAO,kCAAkC;AAAA,UACzD,EAAE,OAAO,QAAQ,OAAO,0CAA0C;AAAA,QACpE;AAAA,QACA,UAAU;AAAA,MACZ;AAAA,MACA;AAAA,QACE,KAAK;AAAA,QACL,OAAO;AAAA,QACP,MAAM;AAAA,QACN,UAAU;AAAA,QACV,UAAU;AAAA,MACZ;AAAA,MACA;AAAA,QACE,KAAK;AAAA,QACL,OAAO;AAAA,QACP,MAAM;AAAA,QACN,UAAU;AAAA,QACV,UAAU;AAAA,MACZ;AAAA,MACA;AAAA,QACE,KAAK;AAAA,QACL,OAAO;AAAA,QACP,MAAM;AAAA,QACN,UAAU;AAAA,QACV,aAAa;AAAA,QACb,UAAU;AAAA,MACZ;AAAA,IACF;AAAA,EACF;AACF;AAEO,MAAM,eAAwC,CAAC,WAAW;AAC1D,MAAM,UAA+B,CAAC;AACtC,MAAM,SAAwC;",
+  "names": []
+}

package/dist/modules/channel_smtp/lib/adapter.js

@@ -0,0 +1,127 @@
+import {
+  htmlToText,
+  sanitizeHeaderValue,
+  stringOrUndefined,
+  toAddressList
+} from "@open-mercato/core/modules/communication_channels/lib/email-mime";
+import { smtpCapabilities } from "../capabilities.js";
+import { smtpCredentialsSchema } from "./credentials.js";
+import { credentialsToConnection, getSmtpTransport } from "./transport.js";
+import { validateSmtpCredentials } from "./validate-credentials.js";
+function attachmentsFromMeta(value) {
+  if (!Array.isArray(value)) return void 0;
+  const attachments = value.flatMap((item) => {
+    if (!item || typeof item !== "object") return [];
+    const record = item;
+    const filename = stringOrUndefined(record.filename);
+    const content = stringOrUndefined(record.content);
+    if (!filename || !content) return [];
+    const contentType = stringOrUndefined(record.contentType);
+    return [{
+      filename,
+      content,
+      encoding: "base64",
+      ...contentType ? { contentType } : {}
+    }];
+  });
+  return attachments.length ? attachments : void 0;
+}
+class SmtpChannelAdapter {
+  constructor() {
+    this.providerKey = "smtp";
+    this.channelType = "email";
+    this.channelScope = "tenant";
+    this.capabilities = smtpCapabilities;
+  }
+  async sendMessage(input) {
+    const credentials = smtpCredentialsSchema.parse(input.credentials);
+    const meta = input.metadata ?? {};
+    const to = toAddressList(meta.to).map(sanitizeHeaderValue);
+    if (to.length === 0) {
+      return { externalMessageId: "", status: "failed", error: "[internal] Email send requires at least one recipient" };
+    }
+    const subject = stringOrUndefined(meta.subject);
+    if (!subject) {
+      return { externalMessageId: "", status: "failed", error: "[internal] Email send requires a subject" };
+    }
+    const attachments = attachmentsFromMeta(meta.attachments);
+    try {
+      const info = await getSmtpTransport().send(credentialsToConnection(credentials), {
+        from: stringOrUndefined(meta.from) ?? credentials.fromAddress,
+        to,
+        subject,
+        ...input.content.text ? { text: input.content.text } : {},
+        ...input.content.html ? { html: input.content.html } : {},
+        ...stringOrUndefined(meta.replyTo) ? { replyTo: stringOrUndefined(meta.replyTo) } : {},
+        ...attachments?.length ? { attachments } : {}
+      });
+      const externalMessageId = info.messageId || `smtp:${Date.now()}`;
+      const accepted = info.accepted ?? [];
+      const rejected = info.rejected ?? [];
+      const metadata = {
+        ...info.response ? { response: info.response } : {},
+        ...info.accepted ? { accepted } : {},
+        ...rejected.length ? { rejected } : {}
+      };
+      if (rejected.length > 0) {
+        return {
+          externalMessageId,
+          conversationId: input.conversationId,
+          status: "failed",
+          error: `SMTP_SEND_PARTIALLY_REJECTED: relay rejected ${rejected.join(", ")}`,
+          metadata
+        };
+      }
+      return {
+        externalMessageId,
+        conversationId: input.conversationId,
+        status: "sent",
+        metadata: Object.keys(metadata).length ? metadata : void 0
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return { externalMessageId: "", status: "failed", error: `SMTP_SEND_FAILED: ${message}` };
+    }
+  }
+  async validateCredentials(input) {
+    return validateSmtpCredentials(input.credentials);
+  }
+  async verifyWebhook(_input) {
+    return { raw: {}, eventType: "other", metadata: { reason: "smtp-system-email-outbound-only" } };
+  }
+  async getStatus(_input) {
+    return { status: "sent" };
+  }
+  async normalizeInbound(_raw) {
+    throw new Error("[internal] SMTP system email adapter is outbound-only");
+  }
+  async convertOutbound(input) {
+    const meta = input.channelMetadata ?? {};
+    const to = toAddressList(meta.to).map(sanitizeHeaderValue);
+    const subject = stringOrUndefined(meta.subject);
+    const html = input.bodyFormat === "html" ? input.body : void 0;
+    const text = input.bodyFormat === "html" ? htmlToText(input.body) : input.body;
+    return {
+      content: {
+        text,
+        html,
+        bodyFormat: input.bodyFormat
+      },
+      metadata: {
+        to,
+        subject,
+        from: stringOrUndefined(meta.from),
+        replyTo: stringOrUndefined(meta.replyTo),
+        attachments: attachmentsFromMeta(meta.attachments)
+      }
+    };
+  }
+}
+const adapter = new SmtpChannelAdapter();
+function getSmtpChannelAdapter() {
+  return adapter;
+}
+export {
+  getSmtpChannelAdapter
+};
+//# sourceMappingURL=adapter.js.map

package/dist/modules/channel_smtp/lib/adapter.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_smtp/lib/adapter.ts"],
+  "sourcesContent": ["import type {\n  ChannelAdapter,\n  ChannelNativeContent,\n  ConvertOutboundInput,\n  GetMessageStatusInput,\n  InboundMessage,\n  MessageStatus,\n  NormalizedInboundMessage,\n  SendMessageInput,\n  SendMessageResult,\n  ValidateCredentialsInput,\n  ValidateCredentialsResult,\n  VerifyWebhookInput,\n} from '@open-mercato/core/modules/communication_channels/lib/adapter'\nimport {\n  htmlToText,\n  sanitizeHeaderValue,\n  stringOrUndefined,\n  toAddressList,\n} from '@open-mercato/core/modules/communication_channels/lib/email-mime'\nimport { smtpCapabilities } from '../capabilities'\nimport { smtpCredentialsSchema } from './credentials'\nimport { credentialsToConnection, getSmtpTransport, type SmtpAttachment } from './transport'\nimport { validateSmtpCredentials } from './validate-credentials'\n\nfunction attachmentsFromMeta(value: unknown): SmtpAttachment[] | undefined {\n  if (!Array.isArray(value)) return undefined\n  const attachments = value.flatMap((item): SmtpAttachment[] => {\n    if (!item || typeof item !== 'object') return []\n    const record = item as Record<string, unknown>\n    const filename = stringOrUndefined(record.filename)\n    const content = stringOrUndefined(record.content)\n    if (!filename || !content) return []\n    const contentType = stringOrUndefined(record.contentType)\n    return [{\n      filename,\n      content,\n      encoding: 'base64',\n      ...(contentType ? { contentType } : {}),\n    }]\n  })\n  return attachments.length ? attachments : undefined\n}\n\nclass SmtpChannelAdapter implements ChannelAdapter {\n  readonly providerKey = 'smtp'\n  readonly channelType = 'email'\n  readonly channelScope = 'tenant' as const\n  readonly capabilities = smtpCapabilities\n\n  async sendMessage(input: SendMessageInput): Promise<SendMessageResult> {\n    const credentials = smtpCredentialsSchema.parse(input.credentials)\n    const meta = (input.metadata ?? {}) as Record<string, unknown>\n    // `convertOutbound` hands us an array, but the hub's test-send route calls\n    // `sendMessage` directly with the operator's raw `to` string. Normalizing\n    // here keeps both callers working; `toAddressList` also splits the\n    // comma/semicolon-separated form system email supports.\n    const to = toAddressList(meta.to).map(sanitizeHeaderValue)\n    if (to.length === 0) {\n      return { externalMessageId: '', status: 'failed', error: '[internal] Email send requires at least one recipient' }\n    }\n    const subject = stringOrUndefined(meta.subject)\n    if (!subject) {\n      return { externalMessageId: '', status: 'failed', error: '[internal] Email send requires a subject' }\n    }\n\n    const attachments = attachmentsFromMeta(meta.attachments)\n    try {\n      const info = await getSmtpTransport().send(credentialsToConnection(credentials), {\n        from: stringOrUndefined(meta.from) ?? credentials.fromAddress,\n        to,\n        subject,\n        ...(input.content.text ? { text: input.content.text } : {}),\n        ...(input.content.html ? { html: input.content.html } : {}),\n        ...(stringOrUndefined(meta.replyTo) ? { replyTo: stringOrUndefined(meta.replyTo) } : {}),\n        ...(attachments?.length ? { attachments } : {}),\n      })\n      const externalMessageId = info.messageId || `smtp:${Date.now()}`\n      const accepted = info.accepted ?? []\n      const rejected = info.rejected ?? []\n      const metadata = {\n        ...(info.response ? { response: info.response } : {}),\n        ...(info.accepted ? { accepted } : {}),\n        ...(rejected.length ? { rejected } : {}),\n      }\n      // The relay resolves the send once it accepts *any* recipient, so a\n      // partial rejection would otherwise be reported as an unqualified\n      // success and silently drop mail. Report it as a failure carrying the\n      // message identity and the accepted/rejected split, so a retry can skip\n      // the recipients that already landed instead of resending to everyone.\n      if (rejected.length > 0) {\n        return {\n          externalMessageId,\n          conversationId: input.conversationId,\n          status: 'failed',\n          error: `SMTP_SEND_PARTIALLY_REJECTED: relay rejected ${rejected.join(', ')}`,\n          metadata,\n        }\n      }\n      return {\n        externalMessageId,\n        conversationId: input.conversationId,\n        status: 'sent',\n        metadata: Object.keys(metadata).length ? metadata : undefined,\n      }\n    } catch (error) {\n      const message = error instanceof Error ? error.message : 'Unknown error'\n      return { externalMessageId: '', status: 'failed', error: `SMTP_SEND_FAILED: ${message}` }\n    }\n  }\n\n  async validateCredentials(input: ValidateCredentialsInput): Promise<ValidateCredentialsResult> {\n    return validateSmtpCredentials(input.credentials)\n  }\n\n  async verifyWebhook(_input: VerifyWebhookInput): Promise<InboundMessage> {\n    return { raw: {}, eventType: 'other', metadata: { reason: 'smtp-system-email-outbound-only' } }\n  }\n\n  async getStatus(_input: GetMessageStatusInput): Promise<MessageStatus> {\n    return { status: 'sent' }\n  }\n\n  async normalizeInbound(_raw: InboundMessage): Promise<NormalizedInboundMessage> {\n    throw new Error('[internal] SMTP system email adapter is outbound-only')\n  }\n\n  async convertOutbound(input: ConvertOutboundInput): Promise<ChannelNativeContent> {\n    const meta = (input.channelMetadata ?? {}) as Record<string, unknown>\n    const to = toAddressList(meta.to).map(sanitizeHeaderValue)\n    const subject = stringOrUndefined(meta.subject)\n    const html = input.bodyFormat === 'html' ? input.body : undefined\n    const text = input.bodyFormat === 'html' ? htmlToText(input.body) : input.body\n    return {\n      content: {\n        text,\n        html,\n        bodyFormat: input.bodyFormat,\n      },\n      metadata: {\n        to,\n        subject,\n        from: stringOrUndefined(meta.from),\n        replyTo: stringOrUndefined(meta.replyTo),\n        attachments: attachmentsFromMeta(meta.attachments),\n      },\n    }\n  }\n}\n\nconst adapter = new SmtpChannelAdapter()\n\nexport function getSmtpChannelAdapter(): ChannelAdapter {\n  return adapter\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/modules/channel_smtp/lib/credentials.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { parseBooleanWithDefault } from "@open-mercato/shared/lib/boolean";
+import { isInternalHost } from "@open-mercato/shared/lib/host-pinning";
+const SMTP_TLS_MODES = ["tls", "starttls", "none"];
+function allowsInternalHosts() {
+  return parseBooleanWithDefault(process.env.OM_CHANNEL_SMTP_ALLOW_INTERNAL_HOSTS, false);
+}
+function allowsInsecureTransport() {
+  return parseBooleanWithDefault(process.env.OM_CHANNEL_SMTP_ALLOW_INSECURE_TRANSPORT, false);
+}
+const INTERNAL_HOST_MESSAGE = "Host resolves to a private or loopback address. If this is intentional, an operator must set OM_CHANNEL_SMTP_ALLOW_INTERNAL_HOSTS=true.";
+const UNRESOLVABLE_HOST_MESSAGE = "SMTP host did not resolve to any address.";
+const INSECURE_TRANSPORT_MESSAGE = "Cleartext SMTP sends the password and the message over the wire unencrypted. Use starttls or tls, or set OM_CHANNEL_SMTP_ALLOW_INSECURE_TRANSPORT=true.";
+const hostSchema = z.string().trim().min(1, "SMTP host required").max(253, "SMTP host too long").superRefine((value, ctx) => {
+  if (allowsInternalHosts()) return;
+  if (isInternalHost(value)) {
+    ctx.addIssue({
+      code: "custom",
+      message: "SMTP host appears to point at a private or loopback address. If this is intentional, an operator must set OM_CHANNEL_SMTP_ALLOW_INTERNAL_HOSTS=true."
+    });
+  }
+});
+const smtpCredentialsSchema = z.object({
+  host: hostSchema,
+  port: z.coerce.number().int().min(1, "SMTP port must be a positive integer").max(65535, "SMTP port must be <= 65535"),
+  tls: z.enum(SMTP_TLS_MODES).superRefine((value, ctx) => {
+    if (value !== "none") return;
+    if (allowsInsecureTransport()) return;
+    ctx.addIssue({ code: "custom", message: INSECURE_TRANSPORT_MESSAGE });
+  }),
+  user: z.string().min(1, "SMTP username required"),
+  password: z.string().min(1, "SMTP password required"),
+  fromAddress: z.string().email("From address must be a valid email")
+}).passthrough();
+export {
+  INSECURE_TRANSPORT_MESSAGE,
+  INTERNAL_HOST_MESSAGE,
+  SMTP_TLS_MODES,
+  UNRESOLVABLE_HOST_MESSAGE,
+  allowsInsecureTransport,
+  allowsInternalHosts,
+  smtpCredentialsSchema
+};
+//# sourceMappingURL=credentials.js.map

package/dist/modules/channel_smtp/lib/credentials.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/channel_smtp/lib/credentials.ts"],
+  "sourcesContent": ["import { z } from 'zod'\nimport { parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'\nimport { isInternalHost } from '@open-mercato/shared/lib/host-pinning'\n\nexport const SMTP_TLS_MODES = ['tls', 'starttls', 'none'] as const\n\nexport type SmtpTlsMode = (typeof SMTP_TLS_MODES)[number]\n\nexport function allowsInternalHosts(): boolean {\n  return parseBooleanWithDefault(process.env.OM_CHANNEL_SMTP_ALLOW_INTERNAL_HOSTS, false)\n}\n\nexport function allowsInsecureTransport(): boolean {\n  return parseBooleanWithDefault(process.env.OM_CHANNEL_SMTP_ALLOW_INSECURE_TRANSPORT, false)\n}\n\nexport const INTERNAL_HOST_MESSAGE =\n  'Host resolves to a private or loopback address. If this is intentional, an operator must set OM_CHANNEL_SMTP_ALLOW_INTERNAL_HOSTS=true.'\n\nexport const UNRESOLVABLE_HOST_MESSAGE = 'SMTP host did not resolve to any address.'\n\nexport const INSECURE_TRANSPORT_MESSAGE =\n  'Cleartext SMTP sends the password and the message over the wire unencrypted. Use starttls or tls, or set OM_CHANNEL_SMTP_ALLOW_INSECURE_TRANSPORT=true.'\n\n/**\n * The relay host is operator-supplied and dialled as a raw socket, so it gets the\n * same two-layer SSRF treatment as IMAP: this cheap string check at save time, and\n * DNS-rebinding-safe pinning at connect time in `transport.ts`. Both layers live in\n * `@open-mercato/shared/lib/host-pinning`.\n */\nconst hostSchema = z\n  .string()\n  .trim()\n  .min(1, 'SMTP host required')\n  .max(253, 'SMTP host too long')\n  .superRefine((value, ctx) => {\n    if (allowsInternalHosts()) return\n    if (isInternalHost(value)) {\n      ctx.addIssue({\n        code: 'custom',\n        message:\n          'SMTP host appears to point at a private or loopback address. If this is intentional, an operator must set OM_CHANNEL_SMTP_ALLOW_INTERNAL_HOSTS=true.',\n      })\n    }\n  })\n\n/**\n * Tenant-wide SMTP relay credentials. Persisted inside\n * `IntegrationCredentials.credentials` (encrypted at rest) and re-parsed before\n * every send, so a relay reconfigured to cleartext behind our back is rejected on\n * the next send rather than only at setup time.\n *\n * Never log credential values.\n */\nexport const smtpCredentialsSchema = z\n  .object({\n    host: hostSchema,\n    port: z.coerce\n      .number()\n      .int()\n      .min(1, 'SMTP port must be a positive integer')\n      .max(65535, 'SMTP port must be <= 65535'),\n    tls: z.enum(SMTP_TLS_MODES).superRefine((value, ctx) => {\n      if (value !== 'none') return\n      if (allowsInsecureTransport()) return\n      ctx.addIssue({ code: 'custom', message: INSECURE_TRANSPORT_MESSAGE })\n    }),\n    user: z.string().min(1, 'SMTP username required'),\n    password: z.string().min(1, 'SMTP password required'),\n    fromAddress: z.string().email('From address must be a valid email'),\n  })\n  // `.passthrough()` rather than `.strict()`: the integrations credential store\n  // stashes bookkeeping keys alongside the operator-entered fields, and a strict\n  // schema would reject the blob it just persisted.\n  .passthrough()\n\nexport type SmtpCredentials = z.infer<typeof smtpCredentialsSchema>\n"],
+  "mappings": "AAAA,SAAS,SAAS;AAClB,SAAS,+BAA+B;AACxC,SAAS,sBAAsB;AAExB,MAAM,iBAAiB,CAAC,OAAO,YAAY,MAAM;AAIjD,SAAS,sBAA+B;AAC7C,SAAO,wBAAwB,QAAQ,IAAI,sCAAsC,KAAK;AACxF;AAEO,SAAS,0BAAmC;AACjD,SAAO,wBAAwB,QAAQ,IAAI,0CAA0C,KAAK;AAC5F;AAEO,MAAM,wBACX;AAEK,MAAM,4BAA4B;AAElC,MAAM,6BACX;AAQF,MAAM,aAAa,EAChB,OAAO,EACP,KAAK,EACL,IAAI,GAAG,oBAAoB,EAC3B,IAAI,KAAK,oBAAoB,EAC7B,YAAY,CAAC,OAAO,QAAQ;AAC3B,MAAI,oBAAoB,EAAG;AAC3B,MAAI,eAAe,KAAK,GAAG;AACzB,QAAI,SAAS;AAAA,MACX,MAAM;AAAA,MACN,SACE;AAAA,IACJ,CAAC;AAAA,EACH;AACF,CAAC;AAUI,MAAM,wBAAwB,EAClC,OAAO;AAAA,EACN,MAAM;AAAA,EACN,MAAM,EAAE,OACL,OAAO,EACP,IAAI,EACJ,IAAI,GAAG,sCAAsC,EAC7C,IAAI,OAAO,4BAA4B;AAAA,EAC1C,KAAK,EAAE,KAAK,cAAc,EAAE,YAAY,CAAC,OAAO,QAAQ;AACtD,QAAI,UAAU,OAAQ;AACtB,QAAI,wBAAwB,EAAG;AAC/B,QAAI,SAAS,EAAE,MAAM,UAAU,SAAS,2BAA2B,CAAC;AAAA,EACtE,CAAC;AAAA,EACD,MAAM,EAAE,OAAO,EAAE,IAAI,GAAG,wBAAwB;AAAA,EAChD,UAAU,EAAE,OAAO,EAAE,IAAI,GAAG,wBAAwB;AAAA,EACpD,aAAa,EAAE,OAAO,EAAE,MAAM,oCAAoC;AACpE,CAAC,EAIA,YAAY;",
+  "names": []
+}

package/dist/modules/channel_smtp/lib/health.js

@@ -0,0 +1,35 @@
+import { smtpCredentialsSchema } from "./credentials.js";
+import { credentialsToConnection, getSmtpTransport } from "./transport.js";
+const PROBE_TIMEOUT_MS = 8e3;
+const channelSmtpHealthCheck = {
+  async check(credentials, _scope) {
+    const parsed = smtpCredentialsSchema.safeParse(credentials ?? {});
+    if (!parsed.success) {
+      return {
+        status: "unhealthy",
+        message: `SMTP credentials invalid: ${parsed.error.issues[0]?.message ?? "unknown validation error"}`,
+        details: { reason: "invalid_credentials" }
+      };
+    }
+    const connection = { ...credentialsToConnection(parsed.data), timeoutMs: PROBE_TIMEOUT_MS };
+    try {
+      await getSmtpTransport().verify(connection);
+      return {
+        status: "healthy",
+        message: "SMTP relay accepted the credentials",
+        details: { host: connection.host, port: connection.port, tls: connection.tls }
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "SMTP connection failed";
+      return {
+        status: "unhealthy",
+        message: `SMTP health check failed: ${message}`,
+        details: { reason: "connection_failed", host: connection.host, port: connection.port }
+      };
+    }
+  }
+};
+export {
+  channelSmtpHealthCheck
+};
+//# sourceMappingURL=health.js.map