@cosmicdrift/kumiko-bundled-features 0.339.0 → 0.341.0

package/dist/channel-discord/feature.js

@@ -1,6 +1,6 @@
-import { chatConnectionNameSchema, DELIVERY_CHANNEL_EXTENSION, } from "@cosmicdrift/kumiko-bundled-features/delivery";
+import { chatConnectionNameSchema, chatWebhookUrlSchema, DELIVERY_CHANNEL_EXTENSION, resolveChatWebhookTarget, } from "@cosmicdrift/kumiko-bundled-features/delivery";
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { createDiscordChannel } from "./discord-channel.js";
+import { createDiscordChannel, DISCORD_DEFAULT_ALLOWED_HOSTS, DISCORD_WEBHOOK_PATH_PREFIX, } from "./discord-channel.js";
 export function createChannelDiscordFeature(options = {}) {
     return defineFeature("channel-discord", (r) => {
         r.describe('Posts delivery notifications to a Discord webhook, registered as the `discord` channel in the delivery system. Tenant-owned chat target: reach it only via `ctx.notify(type, { route: { discord: "<connection name>" } })`. The webhook URL is a tenant secret under `channel-discord:webhooks.<connection name>`; only the connection name is logged. Mentions are disabled and content is cut to 2000 characters. Requires `delivery` and `secrets`. Host allowlist (discord.com, discordapp.com, path /api/webhooks/), https-only and the request timeout are app options of `createChannelDiscordFeature(opts)`, never tenant config.');
@@ -11,6 +11,10 @@ export function createChannelDiscordFeature(options = {}) {
         });
         r.requires("delivery");
         r.requires("secrets");
+        const webhookTarget = resolveChatWebhookTarget({
+            defaultAllowedHosts: DISCORD_DEFAULT_ALLOWED_HOSTS,
+            requiredPathPrefix: DISCORD_WEBHOOK_PATH_PREFIX,
+        }, options);
         const webhooks = r.secretNamespace("webhooks", {
             label: { en: "Discord webhooks", de: "Discord-Webhooks", es: "Webhooks de Discord" },
             hint: {
@@ -20,6 +24,7 @@ export function createChannelDiscordFeature(options = {}) {
             },
             scope: "tenant",
             nameSchema: chatConnectionNameSchema,
+            valueSchema: chatWebhookUrlSchema(webhookTarget),
         });
         const channel = createDiscordChannel(options, webhooks.keyFor);
         r.useExtension(DELIVERY_CHANNEL_EXTENSION, "discord", {

package/dist/channel-discord/index.d.ts

@@ -1,2 +1,2 @@
-export { createDiscordChannel, type DiscordChannelOptions } from "./discord-channel.js";
+export { createDiscordChannel, DISCORD_DEFAULT_ALLOWED_HOSTS, DISCORD_SECRET_KEYS, DISCORD_WEBHOOK_PATH_PREFIX, type DiscordChannelOptions, } from "./discord-channel.js";
 export { createChannelDiscordFeature } from "./feature.js";

package/dist/channel-discord/index.js

@@ -1,2 +1,2 @@
-export { createDiscordChannel } from "./discord-channel.js";
+export { createDiscordChannel, DISCORD_DEFAULT_ALLOWED_HOSTS, DISCORD_SECRET_KEYS, DISCORD_WEBHOOK_PATH_PREFIX, } from "./discord-channel.js";
 export { createChannelDiscordFeature } from "./feature.js";

package/dist/channel-email/email-channel.js

@@ -73,6 +73,7 @@ export function createEmailChannel(options) {
         const html = await renderer.render({
             template: message.notificationType,
             variables,
+            locale: message.locale,
         });
         const subject = variables["subject"] ?? message.title; // @cast-boundary dynamic-key
         return { html, subject };

package/dist/channel-slack/feature.js

@@ -1,6 +1,6 @@
-import { chatConnectionNameSchema, DELIVERY_CHANNEL_EXTENSION, } from "@cosmicdrift/kumiko-bundled-features/delivery";
+import { chatConnectionNameSchema, chatWebhookUrlSchema, DELIVERY_CHANNEL_EXTENSION, resolveChatWebhookTarget, } from "@cosmicdrift/kumiko-bundled-features/delivery";
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { createSlackChannel } from "./slack-channel.js";
+import { createSlackChannel, SLACK_DEFAULT_ALLOWED_HOSTS, } from "./slack-channel.js";
 export function createChannelSlackFeature(options = {}) {
     return defineFeature("channel-slack", (r) => {
         r.describe('Posts delivery notifications to a Slack incoming webhook, registered as the `slack` channel in the delivery system. Tenant-owned chat target: reach it only via `ctx.notify(type, { route: { slack: "<connection name>" } })`. The webhook URL is a tenant secret under `channel-slack:webhooks.<connection name>`; only the connection name is logged. Requires `delivery` and `secrets`. Host allowlist (hooks.slack.com), https-only and the request timeout are app options of `createChannelSlackFeature(opts)`, never tenant config.');
@@ -11,6 +11,7 @@ export function createChannelSlackFeature(options = {}) {
         });
         r.requires("delivery");
         r.requires("secrets");
+        const webhookTarget = resolveChatWebhookTarget({ defaultAllowedHosts: SLACK_DEFAULT_ALLOWED_HOSTS }, options);
         const webhooks = r.secretNamespace("webhooks", {
             label: { en: "Slack webhooks", de: "Slack-Webhooks", es: "Webhooks de Slack" },
             hint: {
@@ -20,6 +21,7 @@ export function createChannelSlackFeature(options = {}) {
             },
             scope: "tenant",
             nameSchema: chatConnectionNameSchema,
+            valueSchema: chatWebhookUrlSchema(webhookTarget),
         });
         const channel = createSlackChannel(options, webhooks.keyFor);
         r.useExtension(DELIVERY_CHANNEL_EXTENSION, "slack", {

package/dist/channel-slack/index.d.ts

@@ -1,2 +1,2 @@
 export { createChannelSlackFeature } from "./feature.js";
-export { createSlackChannel, type SlackChannelOptions } from "./slack-channel.js";
+export { createSlackChannel, SLACK_DEFAULT_ALLOWED_HOSTS, SLACK_SECRET_KEYS, type SlackChannelOptions, } from "./slack-channel.js";

package/dist/channel-slack/index.js

@@ -1,2 +1,2 @@
 export { createChannelSlackFeature } from "./feature.js";
-export { createSlackChannel } from "./slack-channel.js";
+export { createSlackChannel, SLACK_DEFAULT_ALLOWED_HOSTS, SLACK_SECRET_KEYS, } from "./slack-channel.js";

package/dist/channel-slack/slack-channel.d.ts

@@ -1,5 +1,9 @@
 import { type ChatWebhookChannelOptions, type DeliveryChannel } from "../delivery/index.js";
 export type SlackChannelOptions = ChatWebhookChannelOptions;
+export declare const SLACK_SECRET_KEYS: {
+    readonly webhookPrefix: "channel-slack:webhooks.";
+    readonly webhookKeyFor: (connection: string) => string;
+};
 export declare const SLACK_DEFAULT_ALLOWED_HOSTS: readonly ["hooks.slack.com"];
 export declare function escapeSlackText(text: string): string;
 export declare function createSlackChannel(options: SlackChannelOptions, keyFor: (connection: string) => string): DeliveryChannel;

package/dist/channel-slack/slack-channel.js

@@ -1,4 +1,8 @@
 import { chatMessageText, createChatWebhookChannel, } from "../delivery/index.js";
+export const SLACK_SECRET_KEYS = {
+    webhookPrefix: "channel-slack:webhooks.",
+    webhookKeyFor: (connection) => `channel-slack:webhooks.${connection}`,
+};
 export const SLACK_DEFAULT_ALLOWED_HOSTS = ["hooks.slack.com"];
 // Slack mrkdwn treats & < > as control characters (links, @-mentions via <!channel>).
 export function escapeSlackText(text) {

package/dist/channel-teams/feature.js

@@ -1,6 +1,6 @@
-import { chatConnectionNameSchema, DELIVERY_CHANNEL_EXTENSION, } from "@cosmicdrift/kumiko-bundled-features/delivery";
+import { chatConnectionNameSchema, chatWebhookUrlSchema, DELIVERY_CHANNEL_EXTENSION, resolveChatWebhookTarget, } from "@cosmicdrift/kumiko-bundled-features/delivery";
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { createTeamsChannel } from "./teams-channel.js";
+import { createTeamsChannel, TEAMS_DEFAULT_ALLOWED_HOSTS, } from "./teams-channel.js";
 export function createChannelTeamsFeature(options = {}) {
     return defineFeature("channel-teams", (r) => {
         r.describe('Posts delivery notifications to a Microsoft Teams webhook (Workflows or connector) as an Adaptive Card, registered as the `teams` channel in the delivery system. Tenant-owned chat target: reach it only via `ctx.notify(type, { route: { teams: "<connection name>" } })`. The webhook URL is a tenant secret under `channel-teams:webhooks.<connection name>`; only the connection name is logged. Requires `delivery` and `secrets`. Host allowlist (.webhook.office.com, .logic.azure.com, .powerplatform.com), https-only and the request timeout are app options of `createChannelTeamsFeature(opts)`, never tenant config.');
@@ -11,6 +11,7 @@ export function createChannelTeamsFeature(options = {}) {
         });
         r.requires("delivery");
         r.requires("secrets");
+        const webhookTarget = resolveChatWebhookTarget({ defaultAllowedHosts: TEAMS_DEFAULT_ALLOWED_HOSTS }, options);
         const webhooks = r.secretNamespace("webhooks", {
             label: {
                 en: "Microsoft Teams webhooks",
@@ -24,6 +25,7 @@ export function createChannelTeamsFeature(options = {}) {
             },
             scope: "tenant",
             nameSchema: chatConnectionNameSchema,
+            valueSchema: chatWebhookUrlSchema(webhookTarget),
         });
         const channel = createTeamsChannel(options, webhooks.keyFor);
         r.useExtension(DELIVERY_CHANNEL_EXTENSION, "teams", {

package/dist/channel-teams/index.d.ts

@@ -1,2 +1,2 @@
 export { createChannelTeamsFeature } from "./feature.js";
-export { createTeamsChannel, type TeamsChannelOptions } from "./teams-channel.js";
+export { createTeamsChannel, TEAMS_DEFAULT_ALLOWED_HOSTS, TEAMS_SECRET_KEYS, type TeamsChannelOptions, } from "./teams-channel.js";

package/dist/channel-teams/index.js

@@ -1,2 +1,2 @@
 export { createChannelTeamsFeature } from "./feature.js";
-export { createTeamsChannel } from "./teams-channel.js";
+export { createTeamsChannel, TEAMS_DEFAULT_ALLOWED_HOSTS, TEAMS_SECRET_KEYS, } from "./teams-channel.js";

package/dist/channel-teams/teams-channel.d.ts

@@ -1,5 +1,9 @@
 import { type ChatWebhookChannelOptions, type DeliveryChannel } from "../delivery/index.js";
 export type TeamsChannelOptions = ChatWebhookChannelOptions;
+export declare const TEAMS_SECRET_KEYS: {
+    readonly webhookPrefix: "channel-teams:webhooks.";
+    readonly webhookKeyFor: (connection: string) => string;
+};
 export declare const TEAMS_DEFAULT_ALLOWED_HOSTS: readonly [".webhook.office.com", ".logic.azure.com", ".powerplatform.com"];
 export declare function buildTeamsAdaptiveCard(title: string, body: string | undefined): unknown;
 export declare function createTeamsChannel(options: TeamsChannelOptions, keyFor: (connection: string) => string): DeliveryChannel;

package/dist/channel-teams/teams-channel.js

@@ -1,4 +1,8 @@
 import { createChatWebhookChannel, } from "../delivery/index.js";
+export const TEAMS_SECRET_KEYS = {
+    webhookPrefix: "channel-teams:webhooks.",
+    webhookKeyFor: (connection) => `channel-teams:webhooks.${connection}`,
+};
 export const TEAMS_DEFAULT_ALLOWED_HOSTS = [
     ".webhook.office.com",
     ".logic.azure.com",

package/dist/channel-telegram/feature.js

@@ -1,9 +1,10 @@
 import { DELIVERY_CHANNEL_EXTENSION } from "@cosmicdrift/kumiko-bundled-features/delivery";
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
-import { createTelegramChannel } from "./telegram-channel.js";
+import * as z from "zod";
+import { createTelegramChannel, isTelegramBotToken, } from "./telegram-channel.js";
 export function createChannelTelegramFeature(options = {}) {
     return defineFeature("channel-telegram", (r) => {
-        r.describe('Sends delivery notifications through the Telegram Bot API (`sendMessage`, plain text), registered as the `telegram` channel in the delivery system. Tenant-owned chat target: reach it only via `ctx.notify(type, { route: { telegram: "<chat id or @channel>" } })`. The bot token is the tenant secret `channel-telegram:secret:bot-token`; the token never reaches logs or delivery attempts. Requires `delivery` and `secrets`. The API base URL and request timeout are app options of `createChannelTelegramFeature(opts)`, never tenant config.');
+        r.describe('Sends delivery notifications through the Telegram Bot API (`sendMessage`, plain text), registered as the `telegram` channel in the delivery system. Tenant-owned chat target: reach it only via `ctx.notify(type, { route: { telegram: "<chat id or @channel>" } })`. The bot token is the tenant secret `channel-telegram:secret:bot-token`; the token never reaches logs or delivery attempts. Requires `delivery` and `secrets`. The API base URL, its host allowlist (`allowedHosts`, default `api.telegram.org`), `requireHttps` (default true; boot fails on a mismatch) and the request timeout are app options of `createChannelTelegramFeature(opts)`, never tenant config.');
         r.uiHints({
             displayLabel: "Telegram Channel",
             category: "notifications",
@@ -18,6 +19,7 @@ export function createChannelTelegramFeature(options = {}) {
             },
             redact: () => "••••••••",
             scope: "tenant",
+            valueSchema: z.string().refine(isTelegramBotToken, "invalid bot token"),
         });
         const channel = createTelegramChannel(options, botToken.name);
         r.useExtension(DELIVERY_CHANNEL_EXTENSION, "telegram", {

package/dist/channel-telegram/index.d.ts

@@ -1,2 +1,2 @@
 export { createChannelTelegramFeature } from "./feature.js";
-export { createTelegramChannel, type TelegramChannelOptions } from "./telegram-channel.js";
+export { createTelegramChannel, isTelegramBotToken, isTelegramChatId, TELEGRAM_DEFAULT_API_BASE_URL, TELEGRAM_SECRET_KEYS, type TelegramChannelOptions, } from "./telegram-channel.js";

package/dist/channel-telegram/index.js

@@ -1,2 +1,2 @@
 export { createChannelTelegramFeature } from "./feature.js";
-export { createTelegramChannel } from "./telegram-channel.js";
+export { createTelegramChannel, isTelegramBotToken, isTelegramChatId, TELEGRAM_DEFAULT_API_BASE_URL, TELEGRAM_SECRET_KEYS, } from "./telegram-channel.js";

package/dist/channel-telegram/telegram-channel.d.ts

@@ -1,8 +1,16 @@
 import { type DeliveryChannel } from "../delivery/index.js";
 export type TelegramChannelOptions = {
     readonly apiBaseUrl?: string;
+    readonly allowedHosts?: readonly string[];
+    readonly requireHttps?: boolean;
     readonly timeoutMs?: number;
 };
 export declare const TELEGRAM_DEFAULT_API_BASE_URL = "https://api.telegram.org";
+export declare const TELEGRAM_DEFAULT_ALLOWED_HOSTS: readonly string[];
 export declare const TELEGRAM_TEXT_MAX_CHARS = 4096;
+export declare const TELEGRAM_SECRET_KEYS: {
+    readonly botToken: "channel-telegram:secret:bot-token";
+};
+export declare function isTelegramChatId(address: string): boolean;
+export declare function isTelegramBotToken(token: string): boolean;
 export declare function createTelegramChannel(options: TelegramChannelOptions, botTokenKey: string): DeliveryChannel;

package/dist/channel-telegram/telegram-channel.js

@@ -1,18 +1,42 @@
 import { SYSTEM_USER_ID } from "@cosmicdrift/kumiko-types/identifiers";
 import { chatMessageText, DEFAULT_CHAT_TIMEOUT_MS, postChatWebhook, toChannelResult, truncateChars, } from "../delivery/index.js";
 export const TELEGRAM_DEFAULT_API_BASE_URL = "https://api.telegram.org";
+export const TELEGRAM_DEFAULT_ALLOWED_HOSTS = ["api.telegram.org"];
 export const TELEGRAM_TEXT_MAX_CHARS = 4096;
+export const TELEGRAM_SECRET_KEYS = { botToken: "channel-telegram:secret:bot-token" };
 // Numeric chat/group id (groups and channels are negative) or a public @channelname.
 const TELEGRAM_CHAT_ID_PATTERN = /^(-?\d{1,20}|@[A-Za-z][A-Za-z0-9_]{3,31})$/;
 // `<bot id>:<secret>`; the token is spliced into the URL path, so only the real shape passes.
 const TELEGRAM_BOT_TOKEN_PATTERN = /^\d{1,20}:[A-Za-z0-9_-]{10,}$/;
+export function isTelegramChatId(address) {
+    return TELEGRAM_CHAT_ID_PATTERN.test(address);
+}
+export function isTelegramBotToken(token) {
+    return TELEGRAM_BOT_TOKEN_PATTERN.test(token);
+}
 export function createTelegramChannel(options, botTokenKey) {
     const apiBaseUrl = options.apiBaseUrl ?? TELEGRAM_DEFAULT_API_BASE_URL;
+    const allowedHosts = options.allowedHosts ?? TELEGRAM_DEFAULT_ALLOWED_HOSTS;
+    const requireHttps = options.requireHttps ?? true;
+    // Fail at boot: a misconfigured base URL must not surface as per-send failures.
+    let parsedBase;
+    try {
+        parsedBase = new URL(apiBaseUrl);
+    }
+    catch {
+        throw new Error("channel-telegram: apiBaseUrl is not a valid URL");
+    }
+    if (!allowedHosts.includes(parsedBase.hostname)) {
+        throw new Error(`channel-telegram: apiBaseUrl host "${parsedBase.hostname}" is not in allowedHosts`);
+    }
+    if (requireHttps && parsedBase.protocol !== "https:") {
+        throw new Error("channel-telegram: apiBaseUrl must use https (set requireHttps: false to opt out)");
+    }
     return {
         name: "telegram",
         mode: "queued",
         async send(address, message, ctx) {
-            if (!TELEGRAM_CHAT_ID_PATTERN.test(address)) {
+            if (!isTelegramChatId(address)) {
                 return toChannelResult(address, { ok: false, code: "invalid_address" });
             }
             let token;
@@ -26,21 +50,13 @@ export function createTelegramChannel(options, botTokenKey) {
             catch {
                 token = undefined;
             }
-            if (!token || !TELEGRAM_BOT_TOKEN_PATTERN.test(token)) {
+            if (!token || !isTelegramBotToken(token)) {
                 return toChannelResult(address, { ok: false, code: "missing_credentials" });
             }
-            // The base URL is the allowlist: only its own host is reachable.
-            let baseHost;
-            try {
-                baseHost = new URL(apiBaseUrl).hostname;
-            }
-            catch {
-                return toChannelResult(address, { ok: false, code: "host_not_allowed" });
-            }
             const result = await postChatWebhook({
                 url: `${apiBaseUrl.replace(/\/+$/, "")}/bot${token}/sendMessage`,
-                allowedHosts: [baseHost],
-                requireHttps: apiBaseUrl.startsWith("https:"),
+                allowedHosts,
+                requireHttps,
                 timeoutMs: options.timeoutMs ?? DEFAULT_CHAT_TIMEOUT_MS,
                 // No parse_mode: Telegram renders the text literally.
                 body: {

package/dist/delivery/chat-webhook-channel.d.ts

@@ -1,4 +1,4 @@
-import { type ChatSendResult } from "./chat-webhook-sender.js";
+import { type ChatSendResult, type ChatWebhookTarget } from "./chat-webhook-sender.js";
 import type { ChannelMessage, ChannelResult, DeliveryChannel } from "./types.js";
 export type ChatWebhookChannelOptions = {
     readonly allowedHosts?: readonly string[];
@@ -7,6 +7,10 @@ export type ChatWebhookChannelOptions = {
 };
 export declare function toChannelResult(address: string, result: ChatSendResult): ChannelResult;
 export declare function chatMessageText(message: ChannelMessage): string;
+export declare function resolveChatWebhookTarget(provider: {
+    readonly defaultAllowedHosts: readonly string[];
+    readonly requiredPathPrefix?: string;
+}, options: ChatWebhookChannelOptions): ChatWebhookTarget;
 export type ChatWebhookChannelSpec = {
     readonly name: string;
     readonly featureName: string;

package/dist/delivery/chat-webhook-channel.js

@@ -8,6 +8,15 @@ export function toChannelResult(address, result) {
 export function chatMessageText(message) {
     return message.body ? `${message.title}\n${message.body}` : message.title;
 }
+export function resolveChatWebhookTarget(provider, options) {
+    return {
+        allowedHosts: options.allowedHosts ?? provider.defaultAllowedHosts,
+        requireHttps: options.requireHttps ?? true,
+        ...(provider.requiredPathPrefix !== undefined && {
+            requiredPathPrefix: provider.requiredPathPrefix,
+        }),
+    };
+}
 // Slack/Discord/Teams: the route address is a tenant-chosen connection name, the
 // webhook URL lives in the secrets store under that name. Route-only (no resolve).
 export function createChatWebhookChannel(spec) {
@@ -34,11 +43,7 @@ export function createChatWebhookChannel(spec) {
                 return toChannelResult(address, { ok: false, code: "missing_credentials" });
             const result = await postChatWebhook({
                 url,
-                allowedHosts: options.allowedHosts ?? spec.defaultAllowedHosts,
-                requireHttps: options.requireHttps ?? true,
-                ...(spec.requiredPathPrefix !== undefined && {
-                    requiredPathPrefix: spec.requiredPathPrefix,
-                }),
+                ...resolveChatWebhookTarget(spec, options),
                 timeoutMs: options.timeoutMs ?? DEFAULT_CHAT_TIMEOUT_MS,
                 body: spec.buildBody(message),
             });

package/dist/delivery/chat-webhook-sender.d.ts

@@ -8,14 +8,18 @@ export type ChatSendResult = {
 };
 export declare const DEFAULT_CHAT_TIMEOUT_MS = 10000;
 export declare const chatConnectionNameSchema: z.ZodString;
-export type ChatWebhookRequest = {
-    readonly url: string;
+export type ChatWebhookTarget = {
     readonly allowedHosts: readonly string[];
     readonly requireHttps: boolean;
     readonly requiredPathPrefix?: string;
+};
+export type ChatWebhookRequest = ChatWebhookTarget & {
+    readonly url: string;
     readonly timeoutMs: number;
     readonly body: unknown;
     readonly send?: (url: string, init: RequestInit) => Promise<Response>;
 };
+export declare function checkChatWebhookTarget(target: ChatWebhookTarget, url: string): URL | undefined;
+export declare function chatWebhookUrlSchema(target: ChatWebhookTarget): z.ZodType<string>;
 export declare function postChatWebhook(request: ChatWebhookRequest): Promise<ChatSendResult>;
 export declare function truncateChars(text: string, maxChars: number): string;

package/dist/delivery/chat-webhook-sender.js

@@ -27,31 +27,36 @@ function hostMatches(hostname, allowedHost) {
 }
 // Allowlist runs on the parsed URL, never on the raw string: userinfo
 // (`https://hooks.slack.com@evil.com`) and look-alike suffixes must not pass.
-function checkTarget(request) {
+export function checkChatWebhookTarget(target, url) {
     let parsed;
     try {
-        parsed = new URL(request.url);
+        parsed = new URL(url);
     }
     catch {
         return undefined;
     }
-    const protocolAllowed = parsed.protocol === "https:" || (!request.requireHttps && parsed.protocol === "http:");
+    const protocolAllowed = parsed.protocol === "https:" || (!target.requireHttps && parsed.protocol === "http:");
     if (!protocolAllowed)
         return undefined;
     // egress() has no port rule; a provider webhook over https never needs a custom port.
-    if (request.requireHttps && parsed.port !== "")
+    if (target.requireHttps && parsed.port !== "")
         return undefined;
     if (parsed.username !== "" || parsed.password !== "")
         return undefined;
     const hostname = parsed.hostname.toLowerCase();
-    if (!request.allowedHosts.some((allowed) => hostMatches(hostname, allowed)))
+    if (!target.allowedHosts.some((allowed) => hostMatches(hostname, allowed)))
         return undefined;
-    if (request.requiredPathPrefix !== undefined &&
-        !parsed.pathname.startsWith(request.requiredPathPrefix)) {
+    if (target.requiredPathPrefix !== undefined &&
+        !parsed.pathname.startsWith(target.requiredPathPrefix)) {
         return undefined;
     }
     return parsed;
 }
+export function chatWebhookUrlSchema(target) {
+    return z
+        .string()
+        .refine((url) => checkChatWebhookTarget(target, url) !== undefined, "invalid webhook url");
+}
 function isTimeout(err) {
     return err instanceof Error && (err.name === "TimeoutError" || err.name === "AbortError");
 }
@@ -71,7 +76,7 @@ function classifyFailure(err) {
 // Never throws and never surfaces the URL: egress/Bun errors can carry it, so
 // every failure is reduced to a code here.
 export async function postChatWebhook(request) {
-    const target = checkTarget(request);
+    const target = checkChatWebhookTarget(request, request.url);
     if (!target)
         return { ok: false, code: "host_not_allowed" };
     let response;

package/dist/delivery/delivery-service.d.ts

@@ -1,8 +1,8 @@
 import type { SseBroker } from "@cosmicdrift/kumiko-framework/api";
 import type { DbConnection } from "@cosmicdrift/kumiko-framework/db";
-import type { EscapeHatchAuditSink, Registry, TenantId } from "@cosmicdrift/kumiko-framework/engine";
-import type { JobRunner } from "@cosmicdrift/kumiko-framework/jobs";
+import type { EscapeHatchAuditSink, NotifyJobDispatcher, Registry, TenantId } from "@cosmicdrift/kumiko-framework/engine";
 import type { Logger } from "@cosmicdrift/kumiko-framework/logging";
+import type { SecretsContext } from "@cosmicdrift/kumiko-framework/secrets";
 import type { Redis } from "ioredis";
 import { type DeliveryChannel, type DeliveryService } from "./types.js";
 export type RateLimitConfig = {
@@ -20,7 +20,8 @@ export type DeliveryServiceOptions = {
     readonly rateLimit?: RateLimitConfig;
     readonly isChannelKilled?: KillSwitchResolver;
     readonly idempotencyRedis?: Redis;
-    readonly jobRunner?: JobRunner;
+    readonly jobRunner?: NotifyJobDispatcher;
+    readonly secrets?: SecretsContext;
     readonly escapeHatchAuditSink?: EscapeHatchAuditSink;
     readonly log?: Logger;
 };