dsh-lark-bot 0.19.12 → 0.19.13

package/dist/plugin.d.ts

@@ -1104,12 +1104,15 @@ declare class PermissionPolicyStore {
     flush(): Promise<void>;
 }
 
-type NotificationEvent = 'completed' | 'failed' | 'approval';
+type NotificationEvent = 'completed' | 'failed' | 'approval' | 'urgent';
 interface NotificationPreference {
     target?: string;
     events: NotificationEvent[];
+    /** Feishu open_ids to @mention in the primary Feishu notification. */
     mentionUserIds: string[];
     approvalReminderMs: number;
+    /** Outbound notification channel ids (see `/channels`) fanned out on top of the Feishu route. */
+    sinks: string[];
 }
 /** Opt-in notification preferences keyed by immutable bridge scope. */
 declare class NotificationPreferenceStore {
@@ -1124,6 +1127,113 @@ declare class NotificationPreferenceStore {
     flush(): Promise<void>;
 }
 
+/** Supported outbound notification-only sink platforms. */
+type SinkType = 'telegram' | 'wecom';
+/**
+ * A configured outbound notification channel. The bridge is the only consumer
+ * of these entries; each channel is a notification-only sink (no inbound).
+ *
+ * Secrets (telegram bot token / wecom webhook key) live in
+ * `<profile>/notification-channels.json` written at mode 0600 and must never
+ * appear in logs, cards, diagnostics or channel output. `mask()` is the single
+ * place that renders a safe, non-echoing description.
+ */
+interface SinkChannel {
+    /** Stable channel id, unique within a profile (admin chosen). */
+    id: string;
+    type: SinkType;
+    /** Human-facing label shown by `/channels` and `/status`. */
+    label: string;
+    /**
+     * Platform destination:
+     * - telegram: target chat_id / @handle that messages are sent to.
+     * - wecom   : the webhook key (the value after `?key=`).
+     */
+    destination: string;
+    /**
+     * Secret credential:
+     * - telegram: the bot token (`<bot_id>:<secret>`).
+     * - wecom   : the webhook key (kept mirrored from `destination` so a single
+     *   redaction helper always covers the credential; only ever read by the
+     *   sink itself, never logged).
+     */
+    secret: string;
+    enabled: boolean;
+    /** Optional feishu user_id -> platform user id mapping for mentions. */
+    mentionMap?: Record<string, string>;
+}
+/** A rendered notification delivered to sinks, independent of any Feishu routing. */
+interface SinkMessage {
+    /** Immutable bridge scope that produced the event. */
+    scope: string;
+    event: NotificationEvent;
+    /** Localized title (zh_cn / en_us) as the sink content headline. */
+    title: {
+        zh: string;
+        en: string;
+    };
+    /** Optional free-form detail appended to the headline. */
+    detail?: string;
+}
+/** An outbound notification sink (mirrors the `AgentAdapter` pluggable seam). */
+interface OutboundSink {
+    readonly type: SinkType;
+    /**
+     * Deliver one notification. Must resolve to `false` — not throw — on a
+     * transport failure so the dispatcher can keep fanning out to the remaining
+     * channels without corrupting the Feishu terminal state.
+     */
+    send(channel: SinkChannel, message: SinkMessage): Promise<boolean>;
+}
+
+/**
+ * Persisted outbound notification channel configuration
+ * (`<profile>/notification-channels.json`, mode 0600). The secrets stored here
+ * are the credential for each push-only sink; they are never echoed by the
+ * `/channels` / `/status` surfaces, the command layer, or the logger.
+ */
+declare class NotificationChannelStore {
+    private readonly path;
+    private data;
+    private saving;
+    constructor(path: string);
+    load(): Promise<void>;
+    list(): SinkChannel[];
+    get(id: string): SinkChannel | undefined;
+    add(channel: SinkChannel): Promise<void>;
+    update(id: string, patch: Partial<Pick<SinkChannel, 'label' | 'enabled' | 'destination' | 'secret' | 'mentionMap'>>): Promise<boolean>;
+    setEnabled(id: string, enabled: boolean): Promise<boolean>;
+    remove(id: string): Promise<boolean>;
+    flush(): Promise<void>;
+    private mutate;
+}
+
+interface BroadcastSummary {
+    /** Number of channels that acknowledged the notification. */
+    delivered: number;
+    /** Channel ids that failed (never the secret). */
+    failures: string[];
+    total: number;
+}
+/**
+ * Builds and owns the concrete sink instances (mirror of the `AgentAdapter`
+ * seam) and fans a notification out to every enabled, configured channel for a
+ * scope. The Feishu path is not part of this registry: it stays the default
+ * first-class route and remains wired through `NotificationDispatcher`.
+ */
+declare class OutboundSinkRegistry {
+    private readonly store;
+    private readonly sinks;
+    constructor(store: NotificationChannelStore, sinks?: OutboundSink[]);
+    /** Resolve only the enabled channels referenced by `channelIds`. */
+    channelsForIds(channelIds: string[]): SinkChannel[];
+    /** Channels currently enabled (for `/status` and `/channels`). */
+    enabledChannels(): SinkChannel[];
+    /** Best-effort fan-out; a failing channel never blocks the others. */
+    broadcast(channelIds: string[], message: SinkMessage): Promise<BroadcastSummary>;
+    private sinkFor;
+}
+
 interface ReplyPolicy {
     mergeWindowMs: number;
     maxBatchSize: number;
@@ -1526,6 +1636,15 @@ interface StartChannelDeps {
     permissionPolicies?: PermissionPolicyStore;
     notificationPreferences?: NotificationPreferenceStore;
     defaultNotificationPreference?: NotificationPreference;
+    /** Configurable push-only outbound notification channels (issue #113). */
+    notificationChannels?: NotificationChannelStore;
+    /** Fan-out registry backed by `notificationChannels` (issue #113). */
+    notificationSinks?: OutboundSinkRegistry;
+    /** Route reconnect / crash / heartbeat fault classes to outbound sinks. */
+    faultNotifier?: (scope: string, title: {
+        zh: string;
+        en: string;
+    }, detail?: string) => Promise<void>;
     replyPolicies?: ReplyPolicyStore;
     executionModes?: ExecutionModeStore;
     languagePolicies?: LanguagePolicyStore;