@shepai/cli 1.181.0 → 1.182.0-pr512.369be8e

package/dist/packages/core/src/infrastructure/services/messaging/notification-emitter.js

@@ -0,0 +1,79 @@
+/**
+ * Messaging Notification Emitter
+ *
+ * Subscribes to Shep's existing NotificationEventBus and pushes
+ * events through the Gateway tunnel for delivery to messaging apps.
+ *
+ * Features:
+ * - Debouncing: events for the same feature+type are collapsed within
+ *   a configurable window (default 5s) to avoid flooding
+ * - Content sanitization: all messages are scrubbed of paths, code, and secrets
+ * - Gate events are never debounced — delivered immediately
+ */
+import { sanitizeForMessaging } from './content-sanitizer.js';
+const DEFAULT_DEBOUNCE_MS = 5_000;
+/**
+ * Subscribes to the notification event bus and forwards events
+ * to the messaging tunnel for delivery to the user's phone.
+ */
+export class MessagingNotificationEmitter {
+    sender;
+    notificationBus;
+    debounceMs;
+    debounceTimers = new Map();
+    listening = false;
+    handler = null;
+    constructor(sender, notificationBus, debounceMs = DEFAULT_DEBOUNCE_MS) {
+        this.sender = sender;
+        this.notificationBus = notificationBus;
+        this.debounceMs = debounceMs;
+    }
+    /** Start listening for notification events */
+    start() {
+        if (this.listening)
+            return;
+        this.handler = (event) => {
+            const notification = {
+                event: event.eventType,
+                featureId: event.featureId,
+                title: event.featureName,
+                message: sanitizeForMessaging(event.message),
+            };
+            // Gate/approval events are always delivered immediately
+            if (event.eventType === 'waiting_approval') {
+                void this.sender.send(notification);
+                return;
+            }
+            this.emitDebounced(event.featureId, event.eventType, notification);
+        };
+        this.notificationBus.on('notification', this.handler);
+        this.listening = true;
+    }
+    /** Stop listening for notification events */
+    stop() {
+        if (!this.listening)
+            return;
+        if (this.handler) {
+            this.notificationBus.off('notification', this.handler);
+            this.handler = null;
+        }
+        // Clear all pending debounce timers
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+        this.listening = false;
+    }
+    emitDebounced(featureId, eventType, notification) {
+        const key = `${featureId}:${eventType}`;
+        const existing = this.debounceTimers.get(key);
+        if (existing)
+            clearTimeout(existing);
+        const timer = setTimeout(() => {
+            void this.sender.send(notification);
+            this.debounceTimers.delete(key);
+        }, this.debounceMs);
+        timer.unref();
+        this.debounceTimers.set(key, timer);
+    }
+}

package/dist/packages/core/src/infrastructure/services/messaging/stub-gateway.client.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Stub Gateway Client
+ *
+ * Returns deterministic fake responses for E2E tests where no real
+ * Commands.com Gateway is available. Activated via SHEP_MOCK_GATEWAY=1.
+ */
+import type { IGatewayClient, FetchTokenInput, GatewayOAuthToken, CreateIntegrationRouteInput, GatewayIntegrationRoute } from '../../../application/ports/output/services/gateway-client.interface.js';
+export declare class StubGatewayClient implements IGatewayClient {
+    fetchAccessToken(_input: FetchTokenInput): Promise<GatewayOAuthToken>;
+    createIntegrationRoute(gatewayUrl: string, _accessToken: string, input: CreateIntegrationRouteInput): Promise<GatewayIntegrationRoute>;
+}
+//# sourceMappingURL=stub-gateway.client.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/stub-gateway.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stub-gateway.client.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/stub-gateway.client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,2BAA2B,EAC3B,uBAAuB,EACxB,MAAM,wEAAwE,CAAC;AAEhF,qBAAa,iBAAkB,YAAW,cAAc;IAChD,gBAAgB,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAQrE,sBAAsB,CAC1B,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,2BAA2B,GACjC,OAAO,CAAC,uBAAuB,CAAC;CAWpC"}

package/dist/packages/core/src/infrastructure/services/messaging/stub-gateway.client.js

@@ -0,0 +1,26 @@
+/**
+ * Stub Gateway Client
+ *
+ * Returns deterministic fake responses for E2E tests where no real
+ * Commands.com Gateway is available. Activated via SHEP_MOCK_GATEWAY=1.
+ */
+export class StubGatewayClient {
+    async fetchAccessToken(_input) {
+        return {
+            accessToken: 'stub-access-token',
+            tokenType: 'Bearer',
+            expiresAt: Date.now() + 3600 * 1000,
+        };
+    }
+    async createIntegrationRoute(gatewayUrl, _accessToken, input) {
+        const routeId = `stub-route-${input.interfaceType}`;
+        const routeToken = `stub-token-${Date.now()}`;
+        return {
+            routeId,
+            routeToken,
+            publicUrl: `${gatewayUrl}/integrations/${routeId}/${routeToken}`,
+            deviceId: input.deviceId,
+            interfaceType: input.interfaceType,
+        };
+    }
+}

package/dist/packages/core/src/infrastructure/services/messaging/telegram-message-sender.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Telegram Message Sender
+ *
+ * Concrete IMessageSender that delivers notifications to a paired Telegram
+ * chat via the Telegram Bot API. Looks up the bot token + chat id from the
+ * messaging config on every send so that pairing changes propagate without
+ * restarting the daemon.
+ *
+ * This sender silently no-ops when Telegram is not paired — callers don't
+ * need to guard individually.
+ */
+import type { IMessageSender } from '../../../application/ports/output/services/message-sender.interface.js';
+import type { ITelegramClient } from '../../../application/ports/output/services/telegram-client.interface.js';
+import type { MessagingNotification } from '../../../domain/generated/output.js';
+export interface TelegramMessageSenderConfig {
+    botToken: string;
+    chatId: string;
+}
+export type TelegramConfigResolver = () => TelegramMessageSenderConfig | null;
+export declare class TelegramMessageSender implements IMessageSender {
+    private readonly telegramClient;
+    private readonly resolveConfig;
+    constructor(telegramClient: ITelegramClient, resolveConfig: TelegramConfigResolver);
+    send(notification: MessagingNotification): Promise<void>;
+}
+//# sourceMappingURL=telegram-message-sender.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/telegram-message-sender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram-message-sender.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/telegram-message-sender.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wEAAwE,CAAC;AAC7G,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yEAAyE,CAAC;AAC/G,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAEjF,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,sBAAsB,GAAG,MAAM,2BAA2B,GAAG,IAAI,CAAC;AAU9E,qBAAa,qBAAsB,YAAW,cAAc;IAExD,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,aAAa;gBADb,cAAc,EAAE,eAAe,EAC/B,aAAa,EAAE,sBAAsB;IAGlD,IAAI,CAAC,YAAY,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;CAmB/D"}

package/dist/packages/core/src/infrastructure/services/messaging/telegram-message-sender.js

@@ -0,0 +1,49 @@
+/**
+ * Telegram Message Sender
+ *
+ * Concrete IMessageSender that delivers notifications to a paired Telegram
+ * chat via the Telegram Bot API. Looks up the bot token + chat id from the
+ * messaging config on every send so that pairing changes propagate without
+ * restarting the daemon.
+ *
+ * This sender silently no-ops when Telegram is not paired — callers don't
+ * need to guard individually.
+ */
+function formatNotification(notification) {
+    const lines = [];
+    if (notification.title)
+        lines.push(`*${notification.title}*`);
+    if (notification.message)
+        lines.push(notification.message);
+    if (notification.event && !notification.title)
+        lines.push(`[${notification.event}]`);
+    return lines.join('\n');
+}
+export class TelegramMessageSender {
+    telegramClient;
+    resolveConfig;
+    constructor(telegramClient, resolveConfig) {
+        this.telegramClient = telegramClient;
+        this.resolveConfig = resolveConfig;
+    }
+    async send(notification) {
+        const config = this.resolveConfig();
+        if (!config?.botToken || !config.chatId)
+            return;
+        const text = formatNotification(notification);
+        if (!text.trim())
+            return;
+        try {
+            await this.telegramClient.sendMessage({
+                botToken: config.botToken,
+                chatId: config.chatId,
+                text,
+                parseMode: 'Markdown',
+            });
+        }
+        catch {
+            // Delivery failures are non-fatal — the daemon keeps running and
+            // future notifications will retry on their own cadence.
+        }
+    }
+}

package/dist/packages/core/src/infrastructure/services/messaging/telegram-webhook.parser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Telegram Webhook Parser
+ *
+ * Converts a raw Telegram `Update` object (posted to our webhook ingress URL)
+ * into a domain-level ChatMessage that the messaging service can dispatch.
+ *
+ * Reference: https://core.telegram.org/bots/api#update
+ *
+ * We only care about the `message` variant for now — inline queries,
+ * callback queries, edited messages, and channel posts are all ignored and
+ * return `null`, which causes the tunnel adapter to reply 200 without
+ * further side effects.
+ */
+export interface ParsedTelegramMessage {
+    chatId: string;
+    /** Telegram user ID of the sender. */
+    senderId?: string;
+    /** Username without leading @. */
+    senderUsername?: string;
+    text: string;
+}
+export declare function parseTelegramUpdate(rawBody: string): ParsedTelegramMessage | null;
+export interface PairCommand {
+    code: string;
+}
+/** Match `/pair 123456` (with optional `@botname` suffix). */
+export declare function parsePairCommand(text: string): PairCommand | null;
+//# sourceMappingURL=telegram-webhook.parser.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/telegram-webhook.parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram-webhook.parser.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/telegram-webhook.parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kCAAkC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;CACd;AAYD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAuBjF;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;CACd;AAID,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAIjE"}

package/dist/packages/core/src/infrastructure/services/messaging/telegram-webhook.parser.js

@@ -0,0 +1,45 @@
+/**
+ * Telegram Webhook Parser
+ *
+ * Converts a raw Telegram `Update` object (posted to our webhook ingress URL)
+ * into a domain-level ChatMessage that the messaging service can dispatch.
+ *
+ * Reference: https://core.telegram.org/bots/api#update
+ *
+ * We only care about the `message` variant for now — inline queries,
+ * callback queries, edited messages, and channel posts are all ignored and
+ * return `null`, which causes the tunnel adapter to reply 200 without
+ * further side effects.
+ */
+export function parseTelegramUpdate(rawBody) {
+    if (!rawBody)
+        return null;
+    let update;
+    try {
+        update = JSON.parse(rawBody);
+    }
+    catch {
+        return null;
+    }
+    const message = update.message;
+    if (!message)
+        return null;
+    const chatId = message.chat?.id !== undefined ? String(message.chat.id) : undefined;
+    const text = typeof message.text === 'string' ? message.text : '';
+    if (!chatId || !text)
+        return null;
+    return {
+        chatId,
+        senderId: message.from?.id !== undefined ? String(message.from.id) : undefined,
+        senderUsername: message.from?.username,
+        text,
+    };
+}
+const PAIR_REGEX = /^\/pair(?:@\w+)?\s+(\d{6})\b/;
+/** Match `/pair 123456` (with optional `@botname` suffix). */
+export function parsePairCommand(text) {
+    const match = text.trim().match(PAIR_REGEX);
+    if (!match)
+        return null;
+    return { code: match[1] };
+}

package/dist/packages/core/src/infrastructure/services/messaging/tunnel-protocol.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Commands.com Gateway tunnel protocol types.
+ *
+ * Matches the frame shapes sent and received by the Go implementation at
+ * https://github.com/Commands-com/gateway/blob/main/internal/gateway/integrations_tunnel.go
+ *
+ * Frame flow:
+ *   server → client: tunnel.connected              (after WebSocket open)
+ *   client → server: tunnel.activate               (claim a route)
+ *   server → client: tunnel.activate.result        (ok / error)
+ *   server → client: tunnel.request                (forwarded webhook)
+ *   client → server: tunnel.response               (reply to forwarded webhook)
+ *   server → client: tunnel.route_deactivated      (route revoked)
+ *   server → client: tunnel.error                  (any protocol error)
+ */
+export interface TunnelConnectedFrame {
+    type: 'tunnel.connected';
+    device_id: string;
+    at?: string;
+}
+/**
+ * Client → server: claim one or more routes on the live tunnel.
+ *
+ * The gateway's frame shape (see
+ * internal/gateway/integrations_tunnel.go:handleTunnelActivate) expects
+ * a `routes` array of route_id strings (or objects with `route_id`), NOT
+ * a single `route_id` field. An earlier Shep build sent the singular form
+ * and the gateway silently ignored it, which is why no routes were ever
+ * activated and every public webhook returned 503.
+ */
+export interface TunnelActivateFrame {
+    type: 'tunnel.activate';
+    request_id?: string;
+    routes: string[];
+}
+/**
+ * Server → client: per-route activation results.
+ *
+ * Again the real gateway returns a `results` array (one entry per route),
+ * not a flat `{ route_id, ok }` pair.
+ */
+export interface TunnelActivateResultEntry {
+    route_id: string;
+    status: string;
+    /** Present when status === "rejected". */
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface TunnelActivateResultFrame {
+    type: 'tunnel.activate.result';
+    request_id?: string;
+    results: TunnelActivateResultEntry[];
+}
+export interface TunnelRequestFrame {
+    type: 'tunnel.request';
+    request_id: string;
+    route_id: string;
+    method: string;
+    path: string;
+    /** HTTP headers as [name, value] pairs. */
+    headers?: [string, string][];
+    /** Base64-encoded request body. */
+    body_base64?: string;
+}
+export interface TunnelResponseFrame {
+    type: 'tunnel.response';
+    request_id: string;
+    status: number;
+    headers?: [string, string][];
+    /** Base64-encoded response body. */
+    body_base64?: string;
+}
+export interface TunnelRouteDeactivatedFrame {
+    type: 'tunnel.route_deactivated';
+    route_id: string;
+    reason?: string;
+}
+export interface TunnelErrorFrame {
+    type: 'tunnel.error';
+    error: string;
+}
+export type TunnelInboundFrame = TunnelConnectedFrame | TunnelActivateResultFrame | TunnelRequestFrame | TunnelRouteDeactivatedFrame | TunnelErrorFrame;
+export type TunnelOutboundFrame = TunnelActivateFrame | TunnelResponseFrame;
+/** Higher-level, decoded request presented to the consuming handler. */
+export interface DecodedTunnelRequest {
+    requestId: string;
+    routeId: string;
+    method: string;
+    path: string;
+    headers: Record<string, string>;
+    /** Decoded UTF-8 body; empty string if no body. */
+    body: string;
+}
+/** Response returned by the handler for a decoded request. */
+export interface TunnelRequestResponse {
+    status: number;
+    headers?: Record<string, string>;
+    body?: string;
+}
+//# sourceMappingURL=tunnel-protocol.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/tunnel-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tunnel-protocol.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/tunnel-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,kBAAkB,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,yBAAyB,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,gBAAgB,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAC7B,mCAAmC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,iBAAiB,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;IAC7B,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,0BAA0B,CAAC;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,cAAc,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,kBAAkB,GAC1B,oBAAoB,GACpB,yBAAyB,GACzB,kBAAkB,GAClB,2BAA2B,GAC3B,gBAAgB,CAAC;AAErB,MAAM,MAAM,mBAAmB,GAAG,mBAAmB,GAAG,mBAAmB,CAAC;AAE5E,wEAAwE;AACxE,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,8DAA8D;AAC9D,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/packages/core/src/infrastructure/services/messaging/tunnel-protocol.js

@@ -0,0 +1,16 @@
+/**
+ * Commands.com Gateway tunnel protocol types.
+ *
+ * Matches the frame shapes sent and received by the Go implementation at
+ * https://github.com/Commands-com/gateway/blob/main/internal/gateway/integrations_tunnel.go
+ *
+ * Frame flow:
+ *   server → client: tunnel.connected              (after WebSocket open)
+ *   client → server: tunnel.activate               (claim a route)
+ *   server → client: tunnel.activate.result        (ok / error)
+ *   server → client: tunnel.request                (forwarded webhook)
+ *   client → server: tunnel.response               (reply to forwarded webhook)
+ *   server → client: tunnel.route_deactivated      (route revoked)
+ *   server → client: tunnel.error                  (any protocol error)
+ */
+export {};

package/dist/packages/core/src/infrastructure/services/messaging/whatsapp-webhook.parser.d.ts

@@ -0,0 +1,39 @@
+/**
+ * WhatsApp Cloud API Webhook Parser
+ *
+ * Converts a raw WhatsApp Business Cloud webhook payload into a domain-level
+ * ChatMessage, matching the same contract as the Telegram parser so the
+ * messaging service can dispatch both uniformly.
+ *
+ * Reference: https://developers.facebook.com/docs/whatsapp/cloud-api/webhooks/payload-examples
+ *
+ * A minimal incoming text message looks like:
+ *
+ *   {
+ *     "object": "whatsapp_business_account",
+ *     "entry": [{
+ *       "changes": [{
+ *         "value": {
+ *           "messages": [{
+ *             "from": "15551234567",
+ *             "id": "wamid.xxx",
+ *             "timestamp": "1234567890",
+ *             "type": "text",
+ *             "text": { "body": "hello" }
+ *           }]
+ *         }
+ *       }]
+ *     }]
+ *   }
+ *
+ * We only parse the first text message in the first change. Status updates
+ * (delivery receipts, read receipts) and non-text types are ignored and
+ * return null.
+ */
+export interface ParsedWhatsAppMessage {
+    chatId: string;
+    senderId?: string;
+    text: string;
+}
+export declare function parseWhatsAppUpdate(rawBody: string): ParsedWhatsAppMessage | null;
+//# sourceMappingURL=whatsapp-webhook.parser.d.ts.map

package/dist/packages/core/src/infrastructure/services/messaging/whatsapp-webhook.parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whatsapp-webhook.parser.d.ts","sourceRoot":"","sources":["../../../../../../../packages/core/src/infrastructure/services/messaging/whatsapp-webhook.parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd;AAoBD,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAuBjF"}

package/dist/packages/core/src/infrastructure/services/messaging/whatsapp-webhook.parser.js

@@ -0,0 +1,56 @@
+/**
+ * WhatsApp Cloud API Webhook Parser
+ *
+ * Converts a raw WhatsApp Business Cloud webhook payload into a domain-level
+ * ChatMessage, matching the same contract as the Telegram parser so the
+ * messaging service can dispatch both uniformly.
+ *
+ * Reference: https://developers.facebook.com/docs/whatsapp/cloud-api/webhooks/payload-examples
+ *
+ * A minimal incoming text message looks like:
+ *
+ *   {
+ *     "object": "whatsapp_business_account",
+ *     "entry": [{
+ *       "changes": [{
+ *         "value": {
+ *           "messages": [{
+ *             "from": "15551234567",
+ *             "id": "wamid.xxx",
+ *             "timestamp": "1234567890",
+ *             "type": "text",
+ *             "text": { "body": "hello" }
+ *           }]
+ *         }
+ *       }]
+ *     }]
+ *   }
+ *
+ * We only parse the first text message in the first change. Status updates
+ * (delivery receipts, read receipts) and non-text types are ignored and
+ * return null.
+ */
+export function parseWhatsAppUpdate(rawBody) {
+    if (!rawBody)
+        return null;
+    let update;
+    try {
+        update = JSON.parse(rawBody);
+    }
+    catch {
+        return null;
+    }
+    const change = update.entry?.[0]?.changes?.[0]?.value;
+    const message = change?.messages?.[0];
+    if (message?.type !== 'text')
+        return null;
+    const text = message.text?.body;
+    const from = message.from;
+    if (!text || !from)
+        return null;
+    return {
+        chatId: from,
+        senderId: from,
+        text,
+    };
+}

package/dist/src/presentation/cli/commands/_serve.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"_serve.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/_serve.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AA6B1D;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAgE5C"}
+{"version":3,"file":"_serve.command.d.ts","sourceRoot":"","sources":["../../../../../src/presentation/cli/commands/_serve.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AA8B1D;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAuE5C"}

package/dist/src/presentation/cli/commands/_serve.command.js

@@ -68,6 +68,11 @@ export function createServeCommand() {
             // Start auto-archive watcher
             initializeAutoArchiveWatcher(featureRepo);
             getAutoArchiveWatcher().start();
+            // Start messaging service if configured
+            const messagingService = container.resolve('IMessagingService');
+            if (messagingService.isConfigured()) {
+                await messagingService.start();
+            }
             // Graceful shutdown handler — identical pattern to ui.command.ts
             let isShuttingDown = false;
             const shutdown = async () => {
@@ -79,6 +84,7 @@ export function createServeCommand() {
                 forceExit.unref();
                 getNotificationWatcher().stop();
                 getAutoArchiveWatcher().stop();
+                await messagingService.stop();
                 const deploymentService = container.resolve('IDeploymentService');
                 deploymentService.stopAll();
                 await service.stop();

package/dist/src/presentation/cli/commands/app/del.command.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Application Delete Command
+ *
+ * Soft-deletes an application and stops any active session.
+ *
+ * Usage: shep app del <id> [--force]
+ *
+ * @example
+ * $ shep app del a1b2c3d4
+ * $ shep app del a1b2c3d4 --force
+ */
+import { Command } from 'commander';
+export declare function createDelCommand(): Command;
+//# sourceMappingURL=del.command.d.ts.map

package/dist/src/presentation/cli/commands/app/del.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"del.command.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/app/del.command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,wBAAgB,gBAAgB,IAAI,OAAO,CAyC1C"}

package/dist/src/presentation/cli/commands/app/del.command.js

@@ -0,0 +1,58 @@
+/**
+ * Application Delete Command
+ *
+ * Soft-deletes an application and stops any active session.
+ *
+ * Usage: shep app del <id> [--force]
+ *
+ * @example
+ * $ shep app del a1b2c3d4
+ * $ shep app del a1b2c3d4 --force
+ */
+import { Command } from 'commander';
+import { container } from '../../../../../packages/core/src/infrastructure/di/container.js';
+import { DeleteApplicationUseCase } from '../../../../../packages/core/src/application/use-cases/applications/delete-application.use-case.js';
+import { colors, messages } from '../../ui/index.js';
+import { confirm } from '@inquirer/prompts';
+import { resolveApplication } from './resolve-application.js';
+import { getCliI18n } from '../../i18n.js';
+export function createDelCommand() {
+    const t = getCliI18n().t;
+    return new Command('del')
+        .description(t('cli:commands.app.del.description'))
+        .argument('<id>', t('cli:commands.app.del.idArgument'))
+        .option('-f, --force', t('cli:commands.app.del.forceOption'))
+        .action(async (id, options) => {
+        try {
+            const resolved = await resolveApplication(id);
+            if ('error' in resolved) {
+                messages.error(resolved.error);
+                process.exitCode = 1;
+                return;
+            }
+            const app = resolved.application;
+            if (!options.force) {
+                const confirmed = await confirm({
+                    message: t('cli:commands.app.del.confirmDelete', { name: app.name }),
+                    default: false,
+                });
+                if (!confirmed) {
+                    messages.info(t('cli:commands.app.del.cancelled'));
+                    return;
+                }
+            }
+            const deleteUseCase = container.resolve(DeleteApplicationUseCase);
+            await deleteUseCase.execute(app.id);
+            messages.newline();
+            messages.success(t('cli:commands.app.del.appDeleted'));
+            console.log(`  ${colors.muted(t('cli:commands.app.del.nameLabel'))} ${app.name}`);
+            console.log(`  ${colors.muted(t('cli:commands.app.del.slugLabel'))} ${app.slug}`);
+            messages.newline();
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            messages.error(t('cli:commands.app.del.failedToDelete'), err);
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/src/presentation/cli/commands/app/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * App Command
+ *
+ * Top-level app command with subcommands for managing applications.
+ *
+ * Usage:
+ *   shep app [subcommand]
+ *
+ * Subcommands:
+ *   shep app ls             List applications
+ *   shep app show <id>      Display details of an application
+ *   shep app new <desc>     Create a new application
+ *   shep app del <id>       Delete an application
+ */
+import { Command } from 'commander';
+/**
+ * Create the app command with all subcommands
+ */
+export declare function createAppCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/presentation/cli/commands/app/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/presentation/cli/commands/app/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAU1C"}