@manybot/manybot 5.7.0 → 5.8.0

package/dist/plugins/__manybot_integration__/index.test.js

@@ -0,0 +1,184 @@
+import assert from "node:assert/strict";
+import { after, beforeEach, describe, test } from "node:test";
+const integrationPluginUrl = new URL("../../plugins/__manybot_integration__/index.ts", import.meta.url).href;
+describe("plugins/__manybot_integration__", () => {
+    let mod;
+    beforeEach(async () => {
+        // Use a cache-busting query so each test gets a fresh module
+        // (and therefore a fresh ring buffer + EventEmitter).
+        mod = await import(`${integrationPluginUrl}?t=${Date.now()}-${Math.random()}`);
+    });
+    after(async () => {
+        // Best-effort cleanup; nothing in the plugin subscribes to
+        // process-level resources, but we re-clear the configured
+        // chat so a subsequent suite (e.g. loadIntegrationPlugin.test.ts)
+        // starts blank.
+        process.env.MANYBOT_TEST_CHAT = "";
+    });
+    test("exports default, setup, and api", () => {
+        assert.equal(typeof mod.default, "function");
+        assert.equal(typeof mod.setup, "function");
+        assert.ok(mod.api);
+    });
+    test("api.isTestChat is false before setup() is called", () => {
+        assert.equal(mod.api.isTestChat("5516999999999@s.whatsapp.net"), false);
+        assert.equal(mod.api.isTestChat(null), false);
+    });
+    test("api.recentBodies() starts empty", () => {
+        assert.deepEqual(mod.api.recentBodies(), []);
+    });
+    test("setup() throws when MANYBOT_TEST_CHAT is unset", async () => {
+        delete process.env.MANYBOT_TEST_CHAT;
+        const { ctx } = makeSetupCtx();
+        await assert.rejects(mod.setup(ctx), /MANYBOT_TEST_CHAT/);
+    });
+    test("setup() captures the test chat and isTestChat accepts it", async () => {
+        process.env.MANYBOT_TEST_CHAT = "5516999999999@s.whatsapp.net";
+        const { ctx } = makeSetupCtx();
+        await mod.setup(ctx);
+        assert.equal(mod.api.testChat, "5516999999999@s.whatsapp.net");
+        assert.equal(mod.api.isTestChat("5516999999999@s.whatsapp.net"), true);
+        assert.equal(mod.api.isTestChat("5516000000000@s.whatsapp.net"), false);
+    });
+    test("default() refuses to act on a non-test chat", async () => {
+        process.env.MANYBOT_TEST_CHAT = "5516999999999@s.whatsapp.net";
+        const { ctx: setupCtx } = makeSetupCtx();
+        await mod.setup(setupCtx);
+        const { ctx, replyCalls } = makeMessageCtx("120363012345678@g.us");
+        // Should not throw and should not produce a reply.
+        await mod.default(ctx);
+        assert.equal(replyCalls.length, 0);
+    });
+    test("default() does not act even in the test chat (plugin is passive)", async () => {
+        process.env.MANYBOT_TEST_CHAT = "5516999999999@s.whatsapp.net";
+        const { ctx: setupCtx } = makeSetupCtx();
+        await mod.setup(setupCtx);
+        const { ctx, replyCalls } = makeMessageCtx("5516999999999@s.whatsapp.net");
+        await mod.default(ctx);
+        assert.equal(replyCalls.length, 0);
+    });
+    test("default() before setup() is a no-op, not a crash", async () => {
+        delete process.env.MANYBOT_TEST_CHAT;
+        const { ctx, replyCalls } = makeMessageCtx("5516999999999@s.whatsapp.net");
+        await mod.default(ctx); // must not throw
+        assert.equal(replyCalls.length, 0);
+    });
+    test("waitForMarker resolves when a matching messages.upsert is delivered via setup()", async () => {
+        process.env.MANYBOT_TEST_CHAT = "5516999999999@s.whatsapp.net";
+        const { ctx, handlers } = makeSetupCtx();
+        await mod.setup(ctx);
+        // Fire the wait first, then deliver the event.
+        const pending = mod.api.waitForMarker("PING:", 1000);
+        const handlerList = handlers.get("messages.upsert");
+        assert.ok(handlerList && handlerList.length > 0, "setup() must register a messages.upsert handler");
+        handlerList[0]({
+            messages: [{ chatId: "5516999999999@s.whatsapp.net", body: "PING:hello", from: "5516000000000@s.whatsapp.net" }],
+        });
+        const id = await pending;
+        assert.match(id, /^recent:\d+$/);
+        assert.ok(mod.api.recentBodies().some((b) => b === "PING:hello"));
+    });
+    test("waitForMarker ignores messages from a different chat", async () => {
+        process.env.MANYBOT_TEST_CHAT = "5516999999999@s.whatsapp.net";
+        const { ctx, handlers } = makeSetupCtx();
+        await mod.setup(ctx);
+        const pending = mod.api.waitForMarker("PING:", 200);
+        const handlerList = handlers.get("messages.upsert");
+        assert.ok(handlerList);
+        // Send from a different chat — must not resolve the wait.
+        handlerList[0]({
+            messages: [{ chatId: "120363012345678@g.us", body: "PING:should-not-match", from: "120363012345678@g.us" }],
+        });
+        await assert.rejects(pending, /timed out/);
+    });
+    test("waitForMarker resolves immediately when a matching message is already in the buffer", async () => {
+        process.env.MANYBOT_TEST_CHAT = "5516999999999@s.whatsapp.net";
+        const { ctx, handlers } = makeSetupCtx();
+        await mod.setup(ctx);
+        const handlerList = handlers.get("messages.upsert");
+        assert.ok(handlerList);
+        handlerList[0]({
+            messages: [{ chatId: "5516999999999@s.whatsapp.net", body: "PING:already-here", from: "5516000000000@s.whatsapp.net" }],
+        });
+        const id = await mod.api.waitForMarker("PING:", 200);
+        assert.match(id, /^recent:\d+$/);
+    });
+    test("waitForMarker does not match a body that does not start with the marker", async () => {
+        process.env.MANYBOT_TEST_CHAT = "5516999999999@s.whatsapp.net";
+        const { ctx, handlers } = makeSetupCtx();
+        await mod.setup(ctx);
+        const handlerList = handlers.get("messages.upsert");
+        assert.ok(handlerList);
+        handlerList[0]({
+            messages: [{ chatId: "5516999999999@s.whatsapp.net", body: "PONG:no-match", from: "5516000000000@s.whatsapp.net" }],
+        });
+        await assert.rejects(mod.api.waitForMarker("PING:", 150), /timed out/);
+    });
+    test("setup() respects TEST_CHAT env var when MANYBOT_TEST_CHAT is unset", async () => {
+        delete process.env.MANYBOT_TEST_CHAT;
+        process.env.TEST_CHAT = "5516999998888@s.whatsapp.net";
+        const { ctx } = makeSetupCtx();
+        await mod.setup(ctx);
+        assert.equal(mod.api.testChat, "5516999998888@s.whatsapp.net");
+        assert.equal(mod.api.isTestChat("5516999998888@s.whatsapp.net"), true);
+    });
+    test("setup() throws when given an invalid test chat format", async () => {
+        process.env.MANYBOT_TEST_CHAT = "not_a_valid_jid";
+        const { ctx } = makeSetupCtx();
+        await assert.rejects(mod.setup(ctx), /invalid test chat provided/);
+    });
+    test("ring buffer caps at 50 messages and evicts oldest", async () => {
+        process.env.MANYBOT_TEST_CHAT = "5516999999999@s.whatsapp.net";
+        const { ctx, handlers } = makeSetupCtx();
+        await mod.setup(ctx);
+        const handlerList = handlers.get("messages.upsert");
+        assert.ok(handlerList);
+        // Push 55 messages
+        const messages = Array.from({ length: 55 }, (_, i) => ({
+            chatId: "5516999999999@s.whatsapp.net",
+            body: `MSG_${i}`,
+            from: "5516000000000@s.whatsapp.net",
+        }));
+        handlerList[0]({ messages });
+        const recent = mod.api.recentBodies();
+        assert.equal(recent.length, 50);
+        // Oldest 5 (MSG_0 to MSG_4) should have been evicted
+        assert.equal(recent[0], "MSG_5");
+        assert.equal(recent.at(-1), "MSG_54");
+    });
+});
+function makeSetupCtx() {
+    const handlers = new Map();
+    const mock = {
+        handlers,
+        events: {
+            on(event, handler) {
+                const list = handlers.get(event) ?? [];
+                list.push(handler);
+                handlers.set(event, list);
+                return () => {
+                    const arr = handlers.get(event) ?? [];
+                    const idx = arr.indexOf(handler);
+                    if (idx >= 0)
+                        arr.splice(idx, 1);
+                };
+            },
+        },
+    };
+    // The plugin only touches `events` in setup(); the rest of the
+    // SetupContext surface is unused, so we type-cast through `unknown`
+    // rather than build a full fake.
+    return { ctx: mock, handlers };
+}
+function makeMessageCtx(chatId) {
+    const mock = {
+        chat: {
+            id: chatId,
+            name: "test",
+            isGroup: chatId.endsWith("@g.us"),
+        },
+        msg: { id: "msg-1", body: "hello" },
+        replyCalls: [],
+    };
+    return { ctx: mock, replyCalls: mock.replyCalls };
+}

package/package.json

@@ -5,7 +5,7 @@
     "name": "SyntaxError!",
     "email": "me@stxerr.dev"
   },
-  "version": "5.7.0",
+  "version": "5.8.0",
   "license": "GPL-3.0-only",
   "private": false,
   "engines": {
@@ -25,15 +25,26 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "npm i && tsc && node -e \"fs.mkdirSync('dist/locales', { recursive: true }); fs.cpSync('src/locales', 'dist/locales', { recursive: true }); fs.mkdirSync('dist/drivers/whatsmeow', { recursive: true }); fs.cpSync('src/drivers/whatsmeow/whatsmeow.proto', 'dist/drivers/whatsmeow/whatsmeow.proto');\" && node scripts/build-whatsmeow.mjs",
+    "build": "tsc && node -e \"fs.mkdirSync('dist/locales', { recursive: true }); fs.cpSync('src/locales', 'dist/locales', { recursive: true });\" && npm run build:types",
+    "build:types": "tsc --noEmit -p packages/types/tsconfig.json",
     "start": "node dist/main.js",
-    "typecheck": "tsc --noEmit"
+    "lint": "eslint .",
+    "test": "NODE_ENV=test bash -O globstar -c 'tsx --conditions development --test --experimental-test-coverage src/**/*.test.ts'",
+    "test:integration": "NODE_ENV=test MANYBOT_RUN_WHATSAPP_TESTS=1 bash -O globstar -c 'tsx --conditions development --test src/**/*.integration.test.ts'",
+    "test:integration:local": "NODE_ENV=test MANYBOT_RUN_WHATSAPP_TESTS=1 bash -O globstar -c 'tsx --conditions development --import ./src/main.ts --test src/**/*.integration.test.ts'",
+    "typecheck": "tsc --noEmit",
+    "check": "npm run typecheck && npm run lint && npm run test"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "@types/nodemailer": "^8.0.1",
+    "eslint": "^10.8.1",
+    "eslint-plugin-import-x": "^4.17.1",
     "tsx": "^4.19.2",
-    "typescript": "^5.7.3"
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.67.0"
   },
   "dependencies": {
     "@clack/prompts": "^0.10.1",
@@ -41,6 +52,7 @@
     "@grpc/proto-loader": "^0.7.15",
     "@hapi/boom": "^10.0.1",
     "@whiskeysockets/baileys": "6.7.24",
+    "js-yaml": "^5.2.3",
     "node-cron": "^4.6.0",
     "node-webpmux": "^3.2.1",
     "nodemailer": "^9.0.3",
@@ -49,18 +61,63 @@
     "smol-toml": "^1.7.0"
   },
   "imports": {
-    "#drivers/*": "./dist/drivers/*",
-    "#client/*": "./dist/client/*",
-    "#kernel/*": "./dist/kernel/*",
-    "#manyapi": "./dist/kernel/pluginApi.js",
-    "#settingsdb": "./dist/kernel/settingsDb.js",
-    "#sendguard": "./dist/kernel/sendGuard.js",
-    "#logger": "./dist/logger/logger.js",
-    "#utils/*": "./dist/utils/*",
-    "#i18n": "./dist/i18n/index.js",
-    "#download": "./dist/download/queue.js",
-    "#config": "./dist/config.js",
-    "#main": "./dist/main.js",
-    "#types": "./dist/types.js"
+    "#drivers/*": {
+      "development": "./src/drivers/*",
+      "default": "./dist/drivers/*"
+    },
+    "#client/*": {
+      "development": "./src/client/*",
+      "default": "./dist/client/*"
+    },
+    "#kernel/*": {
+      "development": "./src/kernel/*",
+      "default": "./dist/kernel/*"
+    },
+    "#manyapi": {
+      "development": "./src/kernel/pluginApi.ts",
+      "default": "./dist/kernel/pluginApi.js"
+    },
+    "#settingsdb": {
+      "development": "./src/kernel/settingsDb.ts",
+      "default": "./dist/kernel/settingsDb.js"
+    },
+    "#sendguard": {
+      "development": "./src/kernel/sendGuard.ts",
+      "default": "./dist/kernel/sendGuard.js"
+    },
+    "#logger": {
+      "development": "./src/logger/logger.ts",
+      "default": "./dist/logger/logger.js"
+    },
+    "#utils/*": {
+      "development": "./src/utils/*",
+      "default": "./dist/utils/*"
+    },
+    "#i18n": {
+      "development": "./src/i18n/index.ts",
+      "default": "./dist/i18n/index.js"
+    },
+    "#download": {
+      "development": "./src/download/queue.ts",
+      "default": "./dist/download/queue.js"
+    },
+    "#config": {
+      "development": "./src/config.ts",
+      "default": "./dist/config.js"
+    },
+    "#main": {
+      "development": "./src/main.ts",
+      "default": "./dist/main.js"
+    },
+    "#types": {
+      "development": "./src/types.ts",
+      "default": "./dist/types.js"
+    }
+  },
+  "allowScripts": {
+    "@whiskeysockets/baileys@6.7.24": true,
+    "protobufjs@7.6.5": true,
+    "esbuild@0.28.2": true,
+    "unrs-resolver@1.12.2": true
   }
 }

package/dist/drivers/whatsmeow/client.js

@@ -1,252 +0,0 @@
-import { logger } from "#logger";
-import { CONFIG } from "#config";
-import { t } from "#i18n";
-import * as grpc from "@grpc/grpc-js";
-import * as protoLoader from "@grpc/proto-loader";
-import path from "path";
-import { fileURLToPath } from "node:url";
-import qrcode from "qrcode-terminal";
-/**
- * Whatsmeow gRPC client implementing the WaContract interface.
- *
- * Phase 1 scope: only the send path (sendText) and the
- * verification primitives (getHistory) are fully wired. Every other
- * WaContract method throws "not implemented" — the kernel loads plugins
- * only after `connection.update === "open"`, and a plugin that calls e.g.
- * `groupMetadata` on a whatsmeow-primary bot will surface a clear error
- * to the caller, not a silent no-op.
- *
- * Connects to the address defined in config (default localhost:50051).
- */
-class WhatsmeowClient {
-    name = "whatsmeow";
-    client; // grpc client stub
-    ready = false;
-    handlers = new Map();
-    /**
-     * Resolve the .proto path relative to this compiled module so it works
-     * in ESM (where __dirname doesn't exist), under `node dist/main.js`
-     * (proto is copied to dist/drivers/whatsmeow/whatsmeow.proto by the
-     * build), and under a global npm install (the proto ships alongside
-     * the JS in the package's `dist/` per `files` in package.json). In
-     * dev (`tsx src/main.ts`) the proto already lives next to this source
-     * file, so the same relative path resolves correctly there too.
-     */
-    resolveProtoPath() {
-        const here = path.dirname(fileURLToPath(import.meta.url));
-        return path.resolve(here, "whatsmeow.proto");
-    }
-    loadProto() {
-        const protoPath = this.resolveProtoPath();
-        const packageDef = protoLoader.loadSync(protoPath, {
-            keepCase: true,
-            longs: String,
-            enums: String,
-            defaults: true,
-            oneofs: true,
-        });
-        const grpcObj = grpc.loadPackageDefinition(packageDef);
-        return grpcObj.whatsmeow.WhatsmeowService;
-    }
-    async connect() {
-        const address = CONFIG.drivers.whatsmeow.grpcAddress ?? "localhost:50051";
-        const Service = this.loadProto();
-        this.client = new Service(address, grpc.credentials.createInsecure());
-        // 1. Health check — confirm the gRPC server is up
-        await new Promise((resolve, reject) => {
-            this.client.HealthCheck({}, (err, resp) => {
-                if (err)
-                    return reject(err);
-                this.ready = !!resp?.ready;
-                if (this.ready)
-                    resolve();
-                else
-                    reject(new Error("Whatsmeow service not ready"));
-            });
-        });
-        logger.info("[whatsmeow] gRPC service ready");
-        // 2. Call Connect RPC — initiates WhatsApp auth (QR or reuse existing session)
-        const connectResp = await new Promise((resolve, reject) => {
-            this.client.Connect({}, (err, resp) => {
-                if (err)
-                    return reject(err);
-                resolve(resp);
-            });
-        });
-        const needsAuth = !connectResp.ok;
-        if (needsAuth && connectResp.qrCode) {
-            logger.info(t("system.qrScan"));
-            qrcode.generate(connectResp.qrCode, { small: true });
-        }
-        // 3. Set up auth deferred BEFORE SubscribeEvents to avoid race
-        let authDeferred = null;
-        let authDone = false;
-        const authPromise = needsAuth
-            ? new Promise((resolve, reject) => {
-                authDeferred = { resolve, reject };
-                setTimeout(() => {
-                    if (!authDone) {
-                        authDone = true;
-                        reject(new Error("Whatsmeow auth timeout (2 min)"));
-                    }
-                }, 120_000);
-            })
-            : Promise.resolve();
-        // 4. Open the server-streaming event subscription
-        const stream = this.client.SubscribeEvents({});
-        stream.on("data", (raw) => {
-            // Resolve auth promise when connection opens (QR scanned / session reused)
-            if (!authDone && authDeferred && raw.connState?.state === "open") {
-                authDone = true;
-                authDeferred.resolve();
-                authDeferred = null;
-            }
-            try {
-                if (raw.connState) {
-                    const state = raw.connState.state ?? "connecting";
-                    this.dispatch("connection.update", {
-                        connection: state === "open" ? "open" : state === "close" ? "close" : "connecting",
-                    });
-                }
-                else if (raw.message) {
-                    this.dispatch("messages.upsert", {
-                        messages: [raw.message],
-                        type: "notify",
-                    });
-                }
-            }
-            catch (e) {
-                logger.debug(`[whatsmeow] event dispatch failed: ${e.message}`);
-            }
-        });
-        stream.on("error", (err) => {
-            if (!authDone) {
-                authDone = true;
-                authDeferred?.reject(err);
-                authDeferred = null;
-            }
-            logger.warn(`[whatsmeow] event stream error: ${err.message}`);
-            this.ready = false;
-        });
-        stream.on("end", () => {
-            if (!authDone) {
-                authDone = true;
-                authDeferred?.reject(new Error("Event stream ended before auth completed"));
-                authDeferred = null;
-            }
-            logger.warn(`[whatsmeow] event stream ended`);
-            this.ready = false;
-        });
-        // 5. If not authenticated, wait for connState === "open" from the event stream
-        await authPromise;
-        if (needsAuth) {
-            logger.info("[whatsmeow] authenticated");
-        }
-        this.ready = true;
-    }
-    async disconnect() {
-        if (this.client) {
-            try {
-                await new Promise((resolve) => {
-                    this.client.Disconnect({}, () => resolve());
-                });
-            }
-            catch { }
-            this.client.close();
-        }
-        this.ready = false;
-    }
-    isReady() {
-        return this.ready;
-    }
-    // ── Event fan-out ─────────────────────────────────────────────────────────
-    on(event, handler) {
-        let set = this.handlers.get(event);
-        if (!set) {
-            set = new Set();
-            this.handlers.set(event, set);
-        }
-        set.add(handler);
-        return () => set.delete(handler);
-    }
-    dispatch(event, payload) {
-        const set = this.handlers.get(event);
-        if (!set)
-            return;
-        for (const h of set) {
-            try {
-                h(payload);
-            }
-            catch (e) {
-                logger.debug(`[whatsmeow] handler for "${event}" threw: ${e.message}`);
-            }
-        }
-    }
-    // ── Send ───────────────────────────────────────────────────────────────────
-    // Only sendText is in phase-1 scope. Media fallback is
-    // documented in the interface but explicitly deferred.
-    async sendText(jid, text, opts) {
-        const req = {
-            jid,
-            text,
-            quotedId: opts?.quoted?.id ?? "",
-            mentions: opts?.mentions ?? [],
-        };
-        return new Promise((resolve, reject) => {
-            this.client.SendText(req, (err, resp) => {
-                if (err)
-                    return reject(err);
-                resolve({ id: resp.id, chatId: resp.chatId, timestamp: Number(resp.timestamp) });
-            });
-        });
-    }
-    // ── Verification primitive ─────────────────────────────────────────────────
-    async getHistory(jid, opts) {
-        const req = { jid, limit: opts?.limit ?? 5 };
-        return new Promise((resolve, reject) => {
-            this.client.GetHistory(req, (err, resp) => {
-                if (err)
-                    return reject(err);
-                resolve(resp.messages ?? []);
-            });
-        });
-    }
-    // ── All other WaContract methods: stubbed for now ─────────────────────────
-    // These throw a clear error so a plugin calling them on a whatsmeow-
-    // primary bot fails loudly instead of silently no-op'ing. Coverage will
-    // grow in later phases as the whatsmeow .proto grows.
-    unimplemented(method) {
-        throw new Error(`[whatsmeow] ${method} not implemented in whatsmeow driver yet`);
-    }
-    async resolveLid(_lid) { return null; }
-    async sendImage(_jid, _buffer, _opts) { this.unimplemented("sendImage"); }
-    async sendVideo(_jid, _buffer, _opts) { this.unimplemented("sendVideo"); }
-    async sendAudio(_jid, _buffer, _opts) { this.unimplemented("sendAudio"); }
-    async sendSticker(_jid, _buffer, _opts) { this.unimplemented("sendSticker"); }
-    async sendDocument(_jid, _buffer, _filename, _mimetype, _opts) { this.unimplemented("sendDocument"); }
-    async sendPoll(_jid, _opts) { this.unimplemented("sendPoll"); }
-    async react(_jid, _target, _emoji) { this.unimplemented("react"); }
-    async deleteMessage(_jid, _target, _forEveryone) { this.unimplemented("deleteMessage"); }
-    async editMessage(_jid, _target, _text) { this.unimplemented("editMessage"); }
-    async sendPresenceUpdate(_state, _jid) { this.unimplemented("sendPresenceUpdate"); }
-    async readMessages(_keys) { this.unimplemented("readMessages"); }
-    async onWhatsApp(_jid) { this.unimplemented("onWhatsApp"); }
-    async getBusinessProfile(_jid) { this.unimplemented("getBusinessProfile"); }
-    async profilePictureUrl(_jid) { this.unimplemented("profilePictureUrl"); }
-    async fetchStatus(_jid) { this.unimplemented("fetchStatus"); }
-    async updateBlockStatus(_jid, _action) { this.unimplemented("updateBlockStatus"); }
-    async addOrEditContact(_jid, _info) { this.unimplemented("addOrEditContact"); }
-    async removeContact(_jid) { this.unimplemented("removeContact"); }
-    async groupMetadata(_jid) { this.unimplemented("groupMetadata"); }
-    async groupParticipantsUpdate(_jid, _users, _action) { this.unimplemented("groupParticipantsUpdate"); }
-    async groupUpdateSubject(_jid, _subject) { this.unimplemented("groupUpdateSubject"); }
-    async groupUpdateDescription(_jid, _description) { this.unimplemented("groupUpdateDescription"); }
-    async groupInviteCode(_jid) { this.unimplemented("groupInviteCode"); }
-    async groupRevokeInvite(_jid) { this.unimplemented("groupRevokeInvite"); }
-    async updateProfilePicture(_jid, _buffer) { this.unimplemented("updateProfilePicture"); }
-    async updateProfileName(_name) { this.unimplemented("updateProfileName"); }
-    async updateProfileStatus(_status) { this.unimplemented("updateProfileStatus"); }
-    me() { this.unimplemented("me"); }
-    async downloadMedia(_msg, _opts) { this.unimplemented("downloadMedia"); }
-}
-export const whatsmeowContract = new WhatsmeowClient();

package/dist/drivers/whatsmeow/index.js

@@ -1,79 +0,0 @@
-/**
- * drivers/whatsmeow/index.ts
- *
- * Public surface of the whatsmeow driver:
- *   - whatsmeowContract         : the raw contract (test-only / fallback path)
- *   - wrapWithSupervisor(...)   : returns a contract whose lifecycle
- *                                 methods (connect / disconnect / isReady)
- *                                 are gated on the supervisor state
- *
- * The supervisor is the lifecycle authority for the subprocess; this
- * proxy exists so the DriverManager sees one contract whose `isReady()`
- * never lies — true only when both the gRPC client is up AND the
- * subprocess has answered HealthCheck{ready:true}.
- */
-import { whatsmeowContract } from "./client.js";
-export { whatsmeowContract };
-export { startWhatsmeowSupervisor } from "./supervisor.js";
-/**
- * Wraps a raw whatsmeow contract so its lifecycle methods delegate to
- * the supervisor. Send/event methods still pass through unchanged —
- * the contract already knows how to talk gRPC; the supervisor only
- * owns "is it safe to use right now?".
- */
-export function wrapWithSupervisor(contract, supervisor) {
-    return {
-        name: contract.name,
-        async connect() {
-            await supervisor.whenReady();
-            await contract.connect();
-        },
-        async disconnect() {
-            // Try to stop the subprocess too — disconnecting the contract
-            // alone would leave the Go process running until the bot shuts
-            // down. Idempotent; safe to call multiple times.
-            await Promise.allSettled([
-                contract.disconnect(),
-                supervisor.shutdown(),
-            ]);
-        },
-        isReady: () => supervisor.isReady() && contract.isReady(),
-        on: (...args) => contract.on(...args),
-        resolveLid: contract.resolveLid
-            ? (lid) => contract.resolveLid(lid)
-            : undefined,
-        sendText: (...args) => contract.sendText(...args),
-        sendImage: (...args) => contract.sendImage(...args),
-        sendVideo: (...args) => contract.sendVideo(...args),
-        sendAudio: (...args) => contract.sendAudio(...args),
-        sendSticker: (...args) => contract.sendSticker(...args),
-        sendDocument: (...args) => contract.sendDocument(...args),
-        sendPoll: (...args) => contract.sendPoll(...args),
-        react: (...args) => contract.react(...args),
-        deleteMessage: (...args) => contract.deleteMessage(...args),
-        editMessage: (...args) => contract.editMessage(...args),
-        sendPresenceUpdate: (...args) => contract.sendPresenceUpdate(...args),
-        readMessages: (...args) => contract.readMessages(...args),
-        onWhatsApp: (...args) => contract.onWhatsApp(...args),
-        getBusinessProfile: (...args) => contract.getBusinessProfile(...args),
-        profilePictureUrl: (...args) => contract.profilePictureUrl(...args),
-        fetchStatus: (...args) => contract.fetchStatus(...args),
-        updateBlockStatus: (...args) => contract.updateBlockStatus(...args),
-        addOrEditContact: (...args) => contract.addOrEditContact(...args),
-        removeContact: (...args) => contract.removeContact(...args),
-        groupMetadata: (...args) => contract.groupMetadata(...args),
-        groupParticipantsUpdate: (...args) => contract.groupParticipantsUpdate(...args),
-        groupUpdateSubject: (...args) => contract.groupUpdateSubject(...args),
-        groupUpdateDescription: (...args) => contract.groupUpdateDescription(...args),
-        groupInviteCode: (...args) => contract.groupInviteCode(...args),
-        groupRevokeInvite: (...args) => contract.groupRevokeInvite(...args),
-        updateProfilePicture: (...args) => contract.updateProfilePicture(...args),
-        updateProfileName: (...args) => contract.updateProfileName(...args),
-        updateProfileStatus: (...args) => contract.updateProfileStatus(...args),
-        me: () => contract.me(),
-        downloadMedia: (...args) => contract.downloadMedia(...args),
-        getHistory: contract.getHistory
-            ? (...args) => contract.getHistory(...args)
-            : undefined,
-    };
-}