@0xmaxma/claude-gateway 1.8.9 → 1.8.11

package/dist/shared/image-optimize.js

@@ -0,0 +1,197 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimizeImage = optimizeImage;
+exports.optimizeImageFile = optimizeImageFile;
+/**
+ * Best-effort image downscaler for OUTBOUND channel attachments.
+ *
+ * Both WhatsApp channels used to hard-fail an oversized image: the Baileys
+ * manager threw `image exceeds N byte cap` and the Cloud MCP tool let Meta
+ * reject the upload. From the agent's point of view that is the worst possible
+ * outcome — it generated a perfectly good chart/screenshot and the reply just
+ * disappears. Shrinking the picture is almost always what the human wanted, so
+ * the send paths now run an over-cap image through `optimizeImage` first.
+ *
+ * Deliberately NOT applied on a document/`asDocument` send: sending as a
+ * document is how the agent asks for the EXACT bytes to arrive (WhatsApp
+ * re-compresses anything sent as a photo — see WhatsAppManager.sendMessage's
+ * forceDocument comment), so recompressing there would defeat the only reason
+ * to pick that mode.
+ *
+ * `sharp` is loaded lazily via dynamic import for two reasons: it is a native
+ * module, so a static top-level import would make EVERY test that transitively
+ * reaches the send paths pay its load cost (and fail outright on a platform
+ * without a prebuilt binary), and a lazy load keeps this module importable —
+ * and therefore mockable — even when sharp itself is unavailable.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Quality sweep, tried at the ORIGINAL dimensions first. Most over-cap images
+ * from an agent are large PNG screenshots whose size is encoding, not pixels —
+ * a JPEG re-encode alone usually gets them under any sane cap while keeping
+ * every pixel of detail, so dimensions are only sacrificed once quality alone
+ * has failed.
+ */
+const QUALITY_STEPS = [80, 60, 40];
+/**
+ * Dimension sweep, applied only after the quality sweep failed, each at the
+ * lowest quality above. Scales (not fixed widths) so the aspect ratio and the
+ * relationship to the source resolution are both preserved.
+ */
+const SCALE_STEPS = [0.75, 0.5, 0.35, 0.25];
+/** The most aggressive quality, reused for every scaled attempt. */
+const MIN_QUALITY = QUALITY_STEPS[QUALITY_STEPS.length - 1];
+let cachedSharp = null;
+/**
+ * Resolve sharp's callable export across the CJS/ESM interop shapes it can
+ * arrive in (a bare function under plain `require`, or under `.default` once
+ * TypeScript's esModuleInterop wraps it). Throws if neither is present — every
+ * caller here treats a throw as "leave the image alone".
+ */
+async function loadSharp() {
+    if (cachedSharp)
+        return cachedSharp;
+    const mod = await Promise.resolve().then(() => __importStar(require('sharp')));
+    const factory = typeof mod === 'function'
+        ? mod
+        : (mod?.default);
+    if (typeof factory !== 'function')
+        throw new Error('sharp: no callable export');
+    cachedSharp = factory;
+    return factory;
+}
+/**
+ * Shrink `buffer` until it fits `maxBytes`, or as close as this can get.
+ *
+ * Contract — never throws, always returns something sendable:
+ *  - already at/under the cap (or an empty/`maxBytes <= 0` input) → the
+ *    ORIGINAL buffer, byte for byte, with sharp never loaded at all;
+ *  - a sweep step lands under the cap → that step's output;
+ *  - every step still exceeds the cap → the SMALLEST attempt seen (which may
+ *    still be over — the caller decides what to do with a best effort that was
+ *    not enough), or the original if no attempt managed to beat it;
+ *  - sharp missing, or the bytes are not a decodable image → the original.
+ *
+ * Output is JPEG. That is a deliberate narrowing rather than format
+ * preservation: JPEG is the only format here with a quality knob that reliably
+ * trades detail for bytes, and both WhatsApp channels re-encode a photo
+ * on their own anyway. Transparency is flattened onto white first, because
+ * JPEG has no alpha channel and sharp's default would composite onto black.
+ */
+async function optimizeImage(buffer, maxBytes) {
+    if (!buffer || buffer.length === 0)
+        return buffer;
+    if (!Number.isFinite(maxBytes) || maxBytes <= 0)
+        return buffer;
+    if (buffer.length <= maxBytes)
+        return buffer;
+    let best = buffer;
+    try {
+        const sharp = await loadSharp();
+        // `rotate()` with no argument applies the EXIF orientation and drops the
+        // tag — without it a re-encoded phone photo can come out sideways.
+        const { width } = await sharp(buffer).metadata();
+        for (const quality of QUALITY_STEPS) {
+            const out = await sharp(buffer)
+                .rotate()
+                .flatten({ background: '#ffffff' })
+                .jpeg({ quality, mozjpeg: true })
+                .toBuffer();
+            if (out.length < best.length)
+                best = out;
+            if (out.length <= maxBytes)
+                return out;
+        }
+        // Quality alone was not enough — start giving up pixels too. Skipped
+        // entirely when the source has no readable width (sharp could not tell us
+        // the dimensions), since there is nothing sane to scale from.
+        if (width && width > 0) {
+            for (const scale of SCALE_STEPS) {
+                const target = Math.max(1, Math.round(width * scale));
+                const out = await sharp(buffer)
+                    .rotate()
+                    .resize({ width: target, withoutEnlargement: true })
+                    .flatten({ background: '#ffffff' })
+                    .jpeg({ quality: MIN_QUALITY, mozjpeg: true })
+                    .toBuffer();
+                if (out.length < best.length)
+                    best = out;
+                if (out.length <= maxBytes)
+                    return out;
+            }
+        }
+    }
+    catch {
+        // sharp unavailable, or these bytes are not a decodable image. Best-effort
+        // by contract: hand back whatever is smallest so the caller's existing
+        // over-cap handling still runs, rather than failing the whole reply here.
+    }
+    return best;
+}
+/**
+ * File-level wrapper for the two send paths: shrink `srcPath` under `maxBytes`
+ * and return a path to the result.
+ *
+ * Returns `srcPath` UNCHANGED whenever nothing was gained — already under the
+ * cap, unreadable, or `optimizeImage` handed back the original — so a caller
+ * can compare identity to know whether a temp file was created. The temp file
+ * lands in the OS temp dir with a `.jpg` extension matching what
+ * `optimizeImage` actually produces, alongside the inbound media temp files
+ * the channel routers already write there.
+ */
+async function optimizeImageFile(srcPath, maxBytes) {
+    let buf;
+    try {
+        buf = fs.readFileSync(srcPath);
+    }
+    catch {
+        return srcPath;
+    }
+    const out = await optimizeImage(buf, maxBytes);
+    if (out === buf || out.length >= buf.length)
+        return srcPath;
+    try {
+        const dest = path.join(os.tmpdir(), `gw-optimized-${Date.now()}-${path.basename(srcPath, path.extname(srcPath)).slice(0, 64)}.jpg`);
+        fs.writeFileSync(dest, out);
+        return dest;
+    }
+    catch {
+        return srcPath;
+    }
+}
+//# sourceMappingURL=image-optimize.js.map

package/dist/shared/image-optimize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-optimize.js","sourceRoot":"","sources":["../../src/shared/image-optimize.ts"],"names":[],"mappings":"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"}

package/dist/shared/image-sniff.d.ts

@@ -12,4 +12,13 @@
  * not send one at all.
  */
 export declare function sniffImageExt(buf: Buffer): string;
+/**
+ * Reduce a sender-controlled id (WhatsApp message id, etc.) to a safe temp
+ * filename component. Callers build paths like
+ * `path.join(os.tmpdir(), \`prefix-${id}.ext\`)` from a value the OTHER
+ * party's client sets, not us — an id containing `../` segments would
+ * otherwise resolve outside the intended directory. Falls back to the
+ * current timestamp when the id is empty/missing or sanitizes to nothing.
+ */
+export declare function sanitizeFilenameId(id: string | undefined | null): string;
 //# sourceMappingURL=image-sniff.d.ts.map

package/dist/shared/image-sniff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-sniff.d.ts","sourceRoot":"","sources":["../../src/shared/image-sniff.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CASjD"}
+{"version":3,"file":"image-sniff.d.ts","sourceRoot":"","sources":["../../src/shared/image-sniff.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CASjD;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAGxE"}

package/dist/shared/image-sniff.js

@@ -7,6 +7,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sniffImageExt = sniffImageExt;
+exports.sanitizeFilenameId = sanitizeFilenameId;
 /**
  * Pick a file extension from an image's magic bytes; default jpg.
  *
@@ -26,4 +27,16 @@ function sniffImageExt(buf) {
         return 'webp';
     return 'jpg';
 }
+/**
+ * Reduce a sender-controlled id (WhatsApp message id, etc.) to a safe temp
+ * filename component. Callers build paths like
+ * `path.join(os.tmpdir(), \`prefix-${id}.ext\`)` from a value the OTHER
+ * party's client sets, not us — an id containing `../` segments would
+ * otherwise resolve outside the intended directory. Falls back to the
+ * current timestamp when the id is empty/missing or sanitizes to nothing.
+ */
+function sanitizeFilenameId(id) {
+    const cleaned = (id ?? '').replace(/[^A-Za-z0-9_-]/g, '_').slice(0, 64);
+    return cleaned || String(Date.now());
+}
 //# sourceMappingURL=image-sniff.js.map

package/dist/shared/image-sniff.js.map

@@ -1 +1 @@
-{"version":3,"file":"image-sniff.js","sourceRoot":"","sources":["../../src/shared/image-sniff.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AASH,sCASC;AAhBD;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,GAAW;IACvC,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC3F,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9G,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC3F,IACE,GAAG,CAAC,MAAM,IAAI,EAAE;QAChB,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC,KAAK,IAAI;QAC1E,OAAO,MAAM,CAAC;IAChB,OAAO,KAAK,CAAC;AACf,CAAC"}
+{"version":3,"file":"image-sniff.js","sourceRoot":"","sources":["../../src/shared/image-sniff.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;AASH,sCASC;AAUD,gDAGC;AA7BD;;;;;;GAMG;AACH,SAAgB,aAAa,CAAC,GAAW;IACvC,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC3F,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9G,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC3F,IACE,GAAG,CAAC,MAAM,IAAI,EAAE;QAChB,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC,KAAK,IAAI;QAC1E,OAAO,MAAM,CAAC;IAChB,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,kBAAkB,CAAC,EAA6B;IAC9D,MAAM,OAAO,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACxE,OAAO,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;AACvC,CAAC"}

package/dist/shared/text-chunk.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Channel-agnostic text chunker.
+ *
+ * Modeled on `src/agent/line-pure.ts`'s `splitForLine` (same paragraph →
+ * newline → space cut-point preference) but WITHOUT LINE's two
+ * platform-specific behaviours:
+ *
+ *  - No 5-bubble cap. LINE can only carry 5 message objects per reply/push
+ *    call, so `splitForLine` stops after 5 chunks and truncates. WhatsApp has
+ *    no such per-request limit (each chunk is its own API call / socket send),
+ *    so this keeps splitting until the whole text is emitted.
+ *  - No ellipsis/truncation. Nothing is ever dropped — the concatenation of
+ *    the returned chunks is the input, modulo whitespace collapsed exactly at
+ *    the cut points.
+ *
+ * Used by both WhatsApp channels (Cloud API's 4096-char text limit, Baileys'
+ * conservative 4000) and safe for any other channel that needs plain splitting.
+ */
+/**
+ * Split `text` into chunks of at most `maxChars` characters.
+ *
+ * `mode`:
+ *  - `'newline'` (default) — prefer to break on the last paragraph break,
+ *    then the last newline, then the last space that falls inside the budget,
+ *    so chunks end at a natural boundary. Whitespace at a cut point is
+ *    trimmed (it would otherwise show up as a leading blank line on the next
+ *    message bubble). Falls back to a hard cut when no boundary sits late
+ *    enough in the budget to be worth using.
+ *  - `'length'` — hard cut at exactly `maxChars`, no boundary search and no
+ *    whitespace trimming. For callers whose limit is a strict byte/char
+ *    budget where losing a space would matter.
+ *
+ * Returns `[]` for empty input and `[text]` when it already fits. A hard cut
+ * (either mode) never splits a surrogate pair — see avoidSurrogateSplit.
+ */
+export declare function chunkText(text: string, maxChars: number, mode?: 'length' | 'newline'): string[];
+//# sourceMappingURL=text-chunk.d.ts.map

package/dist/shared/text-chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-chunk.d.ts","sourceRoot":"","sources":["../../src/shared/text-chunk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAqBH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE,QAAQ,GAAG,SAAqB,GACrC,MAAM,EAAE,CA0CV"}

package/dist/shared/text-chunk.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * Channel-agnostic text chunker.
+ *
+ * Modeled on `src/agent/line-pure.ts`'s `splitForLine` (same paragraph →
+ * newline → space cut-point preference) but WITHOUT LINE's two
+ * platform-specific behaviours:
+ *
+ *  - No 5-bubble cap. LINE can only carry 5 message objects per reply/push
+ *    call, so `splitForLine` stops after 5 chunks and truncates. WhatsApp has
+ *    no such per-request limit (each chunk is its own API call / socket send),
+ *    so this keeps splitting until the whole text is emitted.
+ *  - No ellipsis/truncation. Nothing is ever dropped — the concatenation of
+ *    the returned chunks is the input, modulo whitespace collapsed exactly at
+ *    the cut points.
+ *
+ * Used by both WhatsApp channels (Cloud API's 4096-char text limit, Baileys'
+ * conservative 4000) and safe for any other channel that needs plain splitting.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkText = chunkText;
+/**
+ * A hard cut at `idx` (a UTF-16 code-unit index) can land between the two
+ * code units of a surrogate pair (e.g. most emoji, which sit outside the
+ * BMP) — splitting one across two chunks produces an unpaired surrogate in
+ * each, which renders as U+FFFD / mojibake on the receiving side. Nudges
+ * `idx` back by one so the pair stays together, unless doing so would leave
+ * no room in this chunk at all (`idx <= minIdx`), in which case the split is
+ * accepted rather than looping forever on an impossibly small budget.
+ */
+function avoidSurrogateSplit(text, idx, minIdx = 0) {
+    if (idx <= minIdx || idx >= text.length)
+        return idx;
+    const before = text.charCodeAt(idx - 1);
+    const at = text.charCodeAt(idx);
+    const isHighSurrogate = before >= 0xd800 && before <= 0xdbff;
+    const isLowSurrogate = at >= 0xdc00 && at <= 0xdfff;
+    if (isHighSurrogate && isLowSurrogate && idx - 1 > minIdx)
+        return idx - 1;
+    return idx;
+}
+/**
+ * Split `text` into chunks of at most `maxChars` characters.
+ *
+ * `mode`:
+ *  - `'newline'` (default) — prefer to break on the last paragraph break,
+ *    then the last newline, then the last space that falls inside the budget,
+ *    so chunks end at a natural boundary. Whitespace at a cut point is
+ *    trimmed (it would otherwise show up as a leading blank line on the next
+ *    message bubble). Falls back to a hard cut when no boundary sits late
+ *    enough in the budget to be worth using.
+ *  - `'length'` — hard cut at exactly `maxChars`, no boundary search and no
+ *    whitespace trimming. For callers whose limit is a strict byte/char
+ *    budget where losing a space would matter.
+ *
+ * Returns `[]` for empty input and `[text]` when it already fits. A hard cut
+ * (either mode) never splits a surrogate pair — see avoidSurrogateSplit.
+ */
+function chunkText(text, maxChars, mode = 'newline') {
+    if (!text)
+        return [];
+    // A non-positive budget can never make progress — treat it as "no split"
+    // rather than looping forever.
+    if (!Number.isFinite(maxChars) || maxChars < 1)
+        return [text];
+    if (text.length <= maxChars)
+        return [text];
+    if (mode === 'length') {
+        const chunks = [];
+        let i = 0;
+        while (i < text.length) {
+            const end = avoidSurrogateSplit(text, Math.min(i + maxChars, text.length), i);
+            chunks.push(text.slice(i, end));
+            i = end;
+        }
+        return chunks;
+    }
+    const chunks = [];
+    let remaining = text;
+    // Only accept a boundary in the LATER half of the budget: an earlier one
+    // wastes so much of the chunk that it produces more messages than the text
+    // needs (same heuristic splitForLine uses).
+    const half = Math.floor(maxChars * 0.5);
+    while (remaining) {
+        if (remaining.length <= maxChars) {
+            chunks.push(remaining);
+            break;
+        }
+        let cut = remaining.lastIndexOf('\n\n', maxChars);
+        if (cut < half)
+            cut = remaining.lastIndexOf('\n', maxChars);
+        if (cut < half)
+            cut = remaining.lastIndexOf(' ', maxChars);
+        if (cut <= 0)
+            cut = avoidSurrogateSplit(remaining, maxChars);
+        const piece = remaining.slice(0, cut).replace(/\s+$/, '');
+        // A cut that trims to nothing (a run of whitespace) would push an empty
+        // bubble; skip it, but still advance `remaining` so the loop terminates.
+        if (piece)
+            chunks.push(piece);
+        remaining = remaining.slice(cut).replace(/^\s+/, '');
+    }
+    return chunks;
+}
+//# sourceMappingURL=text-chunk.js.map

package/dist/shared/text-chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-chunk.js","sourceRoot":"","sources":["../../src/shared/text-chunk.ts"],"names":[],"mappings":"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"}

package/dist/shared/whatsapp-ack.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The ack reaction both WhatsApp channels leave on an inbound message while
+ * the agent works on it, cleared once the reply lands (Phase 2 of the
+ * WhatsApp feature-parity plan, ported from Slack's ack reaction).
+ *
+ * Lives here rather than in either channel's client so the Baileys manager
+ * (src/whatsapp/manager.ts) and the Cloud client (src/api/whatsapp-cloud-client.ts)
+ * share ONE value and can never drift into reacting with two different emoji
+ * for the same behaviour. ⏳ is the direct equivalent of the
+ * `hourglass_flowing_sand` Slack reacts with.
+ */
+export declare const WHATSAPP_ACK_EMOJI = "\u23F3";
+//# sourceMappingURL=whatsapp-ack.d.ts.map

package/dist/shared/whatsapp-ack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whatsapp-ack.d.ts","sourceRoot":"","sources":["../../src/shared/whatsapp-ack.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB,WAAM,CAAC"}

package/dist/shared/whatsapp-ack.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WHATSAPP_ACK_EMOJI = void 0;
+/**
+ * The ack reaction both WhatsApp channels leave on an inbound message while
+ * the agent works on it, cleared once the reply lands (Phase 2 of the
+ * WhatsApp feature-parity plan, ported from Slack's ack reaction).
+ *
+ * Lives here rather than in either channel's client so the Baileys manager
+ * (src/whatsapp/manager.ts) and the Cloud client (src/api/whatsapp-cloud-client.ts)
+ * share ONE value and can never drift into reacting with two different emoji
+ * for the same behaviour. ⏳ is the direct equivalent of the
+ * `hourglass_flowing_sand` Slack reacts with.
+ */
+exports.WHATSAPP_ACK_EMOJI = '⏳';
+//# sourceMappingURL=whatsapp-ack.js.map

package/dist/shared/whatsapp-ack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"whatsapp-ack.js","sourceRoot":"","sources":["../../src/shared/whatsapp-ack.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACU,QAAA,kBAAkB,GAAG,GAAG,CAAC"}

package/dist/types.d.ts

@@ -8,6 +8,75 @@ export interface HistoryConfig {
     retentionDays?: number;
     maxHistoryMessages?: number;
 }
+/**
+ * One linked WhatsApp number (Baileys device-link) belonging to an agent.
+ *
+ * Multi-account (Phase 1 of the WhatsApp feature-parity plan): an agent used
+ * to have exactly ONE flat `whatsapp` block; it now has an array of these.
+ * Every access-control field below is per-account — two numbers on the same
+ * agent can run completely different DM/group policies.
+ *
+ * There is still NO credential field here: the "credential" remains the
+ * linked device session on disk. Its location is derived from `id` —
+ * `'default'` keeps the historical bare `<workspace>/.whatsapp-state/`
+ * directory (so upgrading a live gateway never has to move a linked
+ * session), every other account gets `<workspace>/.whatsapp-state/<id>/`.
+ */
+export interface WhatsAppAccountConfig {
+    /**
+     * Stable slug identifying this account. Doubles as the on-disk state
+     * directory suffix and as the `account_id` the `whatsapp_reply` MCP tool
+     * passes back, so it must be filesystem-safe and must never be reused for
+     * a different number. `'default'` is reserved for the pre-multi-account
+     * session (see the class doc above).
+     */
+    id: string;
+    /** Display name shown in the Settings UI (e.g. "Sales line"). Falls back to `id`. */
+    label?: string;
+    /**
+     * DM access policy (mirrors `slack.dmPolicy`/`line.dmPolicy` exactly).
+     * Gates 1:1 conversations (JIDs ending `@s.whatsapp.net`). Necessary
+     * even though the number itself is authenticated via QR/pairing-code
+     * linking: unlike a fresh bot token, a WhatsApp number is typically the
+     * owner's real number that other people already have — without this,
+     * anyone who knows the number could reach the agent once linked.
+     */
+    dmPolicy?: 'open' | 'allowlist' | 'disabled';
+    /** Allowed sender JIDs/numbers (E.164 or bare digits — normalized at the access-gate boundary). */
+    dmAllowlist?: string[];
+    /**
+     * Group access policy (mirrors `slack.groupPolicy`/`line.groupPolicy`).
+     * Gates group JIDs (ending `@g.us`) the linked number is a member of.
+     */
+    groupPolicy?: 'open' | 'allowlist' | 'disabled';
+    /** Allowed group JIDs. */
+    groupAllowlist?: string[];
+    /**
+     * In groups, only respond when the bot is @mentioned (mirrors
+     * `slack.requireMention`/`line.requireMention`). Default true. No
+     * effect on DMs.
+     */
+    requireMention?: boolean;
+    /**
+     * Pairing aid for the allowlist (mirrors `slack.pairing`/`line.pairing`
+     * exactly). Default true (absent ⇒ on). Only has an effect under
+     * `allowlist` (closed-default) for either tier.
+     */
+    pairing?: boolean;
+    /**
+     * Mark inbound messages as read (blue double-ticks) once they pass the
+     * access gate. Default true (absent ⇒ on) — the agent HAS received the
+     * message at that point, so the receipt is honest. Set false for a number
+     * whose owner would rather not advertise that. Phase 2.
+     */
+    sendReadReceipts?: boolean;
+    /**
+     * Ack-reaction level (ported from Slack's ack reaction). `'ack'` (default
+     * when absent) reacts ⏳ on the inbound message at receipt and clears it
+     * once the reply lands; `'off'` skips BOTH the add and the clear. Phase 2.
+     */
+    reactionLevel?: 'off' | 'ack';
+}
 export interface AgentConfig {
     id: string;
     description: string;
@@ -125,6 +194,95 @@ export interface AgentConfig {
          */
         pairing?: boolean;
     };
+    /**
+     * WhatsApp — via WhatsApp Web device linking (the Baileys library), NOT
+     * the official Meta Cloud API. Unlike every other channel, there is NO
+     * credential field here: the "credential" is the linked device session
+     * itself, persisted on disk at `<workspace>/.whatsapp-state/` (Baileys'
+     * `creds.json`, written by `useMultiFileAuthState`), not in this config.
+     * Live link status (unlinked/pending-scan/linked/reconnecting) is
+     * ephemeral runtime state held by WhatsAppManager, never persisted here.
+     *
+     * Unofficial/reverse-engineered protocol — using it violates WhatsApp's
+     * ToS and carries real account-ban risk (elevated further since GetPod
+     * agents run on cloud/datacenter IPs, the exact traffic profile
+     * WhatsApp's abuse detection flags). This is a user-accepted trade-off,
+     * disclosed prominently in the web UI's connect flow — not enforced or
+     * mitigated by this config.
+     */
+    whatsapp?: {
+        /**
+         * The linked numbers for this agent — one entry per WhatsApp account
+         * (Phase 1 of the WhatsApp feature-parity plan replaced the single flat
+         * block that used to live here with this array). Order is meaningful
+         * only for back-compat: `accounts[0]` is what the legacy flat
+         * `whatsapp_*` API response fields are derived from.
+         *
+         * An absent or empty array is treated as `[{ id: 'default' }]` at
+         * runtime (see `resolveWhatsAppAccounts` in src/config/whatsapp-accounts.ts),
+         * so an agent that has never been configured still gets a linkable
+         * 'default' account exactly like it did before multi-account.
+         */
+        accounts: WhatsAppAccountConfig[];
+    };
+    /**
+     * WhatsApp — via the official Meta WhatsApp Business Cloud API (webhook +
+     * bearer-token REST, NOT the unofficial Baileys device-link bridge — see
+     * `whatsapp` above). Real, first-class credentials issued by Meta, so this
+     * channel follows the Slack template (webhook-based with real credentials)
+     * rather than the Baileys `whatsapp` block's on-disk-session pattern.
+     *
+     * DM-only: the Cloud API has no group concept (a WhatsApp Business number
+     * cannot be added to a group chat the way a personal/linked number can),
+     * so there is no groupPolicy/groupAllowlist/requireMention here — every
+     * inbound sender is a bare phone-number string, never a JID.
+     */
+    whatsapp_cloud?: {
+        /** Permanent (or long-lived) access token — Bearer auth for the Graph API. */
+        accessToken: string;
+        /** The WhatsApp Business phone number id (Meta's numeric id, not the phone number itself). */
+        phoneNumberId: string;
+        /** App Secret — verifies X-Hub-Signature-256 (HMAC-SHA256 of the raw request body). */
+        appSecret: string;
+        /** Verify token — compared against `hub.verify_token` on the GET webhook handshake. */
+        verifyToken: string;
+        /**
+         * DM access policy (mirrors `slack.dmPolicy`/`line.dmPolicy` exactly).
+         * Gates inbound senders — a bare phone-number string (e.g. "66812345678"),
+         * NOT a JID. `dmAllowlist` entries must be bare digits.
+         */
+        dmPolicy?: 'open' | 'allowlist' | 'disabled';
+        /** Allowed sender phone numbers — bare digits (E.164 without the leading "+"), never JIDs. */
+        dmAllowlist?: string[];
+        /**
+         * Pairing aid for the allowlist (mirrors `slack.pairing`/`line.pairing`
+         * exactly). Default true (absent ⇒ on). Only has an effect under
+         * `allowlist` (closed-default).
+         */
+        pairing?: boolean;
+        /**
+         * Mark inbound messages as read (blue double-ticks) once they pass the
+         * access gate. Default true (absent ⇒ on). Same field/semantics as the
+         * per-account Baileys `WhatsAppAccountConfig.sendReadReceipts`. Phase 2.
+         */
+        sendReadReceipts?: boolean;
+        /**
+         * Ack-reaction level (ported from Slack's ack reaction). `'ack'` (default
+         * when absent) reacts ⏳ on the inbound message at receipt and clears it
+         * once `whatsapp_cloud_reply` lands; `'off'` skips both. Phase 2.
+         */
+        reactionLevel?: 'off' | 'ack';
+        /**
+         * Allow `whatsapp_cloud_reply` to send pre-approved message TEMPLATES
+         * (Phase 3). Default false — opt-in on purpose, unlike the other Phase 2/3
+         * booleans here which default on: a template is the one send that reaches
+         * a user OUTSIDE WhatsApp's 24h customer-service window, so an agent must
+         * never gain that reach silently just by upgrading the gateway. With this
+         * unset, a template send is refused with an explanatory error rather than
+         * being dropped.
+         */
+        templatesEnabled?: boolean;
+    };
     claude: {
         model: string;
         /** @deprecated --dangerously-skip-permissions is always passed now; this field is ignored. */
@@ -528,6 +686,10 @@ export interface SessionMeta {
      *  can restore the composer selection on reload; the agent's own context is the
      *  functional source of truth. Updated whenever a send carries image_params. */
     imageConfig?: ImageParams;
+    /** Last composer video options sent for this session. Mirrors imageConfig —
+     *  persisted so the web can restore the composer selection on reload. Updated
+     *  whenever a send carries video_params. */
+    videoConfig?: VideoParams;
     /** Real model from Claude stream, updated per turn (e.g. "claude-opus-4-8"). */
     model?: string;
 }
@@ -561,6 +723,27 @@ export type ImageParams = {
     image_refs?: string[];
     n?: number;
 };
+/**
+ * Video-generation options selected in the web composer (per-session), passed
+ * through the chat send body as `video_params` and surfaced to the agent so it
+ * calls the `generate_video` MCP tool with these exact values. Mirrors ImageParams.
+ * Without this bridge the agent receives no composer context for video and invents
+ * duration/aspect (e.g. a non-existent 10s cap, an 8+8 scene split, or a landscape
+ * clip when 9:16 was selected).
+ */
+export type VideoParams = {
+    model?: string;
+    resolution?: string;
+    aspect_ratio?: string;
+    /** Discrete clip length in seconds (model-specific, e.g. 6/10/15). */
+    duration?: number;
+    /**
+     * Source frame for image-to-video, if the composer selected one. A `ref` value
+     * (media-relative path or `artifact:<id>`) passed as the generate_video `image`
+     * argument. When present the source frame's own aspect wins over aspect_ratio.
+     */
+    image_ref?: string;
+};
 export type StreamEvent = {
     type: 'text_delta';
     text: string;