wagent 1.0.0

package/dist/services/instance-manager.js

@@ -0,0 +1,185 @@
+import { eq } from "drizzle-orm";
+import { randomUUID } from "node:crypto";
+import { db } from "../db/client.js";
+import { instances, authKeys, queueStats } from "../db/schema.js";
+import { BaileysAdapter } from "../channels/baileys/baileys.adapter.js";
+import { INSTANCE_ID_PREFIX } from "../constants.js";
+import { createChildLogger } from "../utils/logger.js";
+const logger = createChildLogger({ service: "instance-manager" });
+export class InstanceManager {
+    adapters = new Map();
+    globalHandlers = new Set();
+    /** Register a global event handler that receives all instance events */
+    onAnyEvent(handler) {
+        this.globalHandlers.add(handler);
+    }
+    /** Initialize: load existing instances from DB and reconnect those with status "open"/connected */
+    async init() {
+        const rows = db.select().from(instances).all();
+        for (const row of rows) {
+            if (row.status === "connected" || row.status === "connecting") {
+                try {
+                    const adapter = this.createAdapter(row.id, row.channel);
+                    this.adapters.set(row.id, { adapter, channel: row.channel });
+                    this.bindAdapterEvents(row.id, adapter);
+                    await adapter.connect();
+                    logger.info({ instanceId: row.id }, "Reconnected instance on startup");
+                }
+                catch (err) {
+                    logger.error({ instanceId: row.id, err }, "Failed to reconnect instance on startup");
+                    db.update(instances)
+                        .set({ status: "disconnected", updatedAt: Date.now() })
+                        .where(eq(instances.id, row.id))
+                        .run();
+                }
+            }
+        }
+    }
+    // ---- Instance CRUD ----
+    async createInstance(name, channel = "baileys") {
+        const id = `${INSTANCE_ID_PREFIX}${randomUUID().slice(0, 8)}`;
+        const now = Date.now();
+        db.insert(instances)
+            .values({
+            id,
+            name,
+            channel,
+            status: "disconnected",
+            createdAt: now,
+            updatedAt: now,
+        })
+            .run();
+        db.insert(queueStats)
+            .values({ instanceId: id, messagesSent: 0, messagesFailed: 0 })
+            .onConflictDoNothing()
+            .run();
+        return this.getInstanceFromDb(id);
+    }
+    async connectInstance(id) {
+        const row = this.getInstanceFromDb(id);
+        let managed = this.adapters.get(id);
+        if (!managed) {
+            const adapter = this.createAdapter(id, row.channel);
+            managed = { adapter, channel: row.channel };
+            this.adapters.set(id, managed);
+            this.bindAdapterEvents(id, adapter);
+        }
+        db.update(instances)
+            .set({ status: "connecting", updatedAt: Date.now() })
+            .where(eq(instances.id, id))
+            .run();
+        await managed.adapter.connect();
+    }
+    async disconnectInstance(id) {
+        const managed = this.adapters.get(id);
+        if (managed) {
+            await managed.adapter.disconnect();
+        }
+        db.update(instances)
+            .set({
+            status: "disconnected",
+            lastDisconnected: Date.now(),
+            updatedAt: Date.now(),
+        })
+            .where(eq(instances.id, id))
+            .run();
+    }
+    async deleteInstance(id) {
+        const managed = this.adapters.get(id);
+        if (managed) {
+            await managed.adapter.disconnect();
+            this.adapters.delete(id);
+        }
+        db.delete(authKeys).where(eq(authKeys.instanceId, id)).run();
+        db.delete(instances).where(eq(instances.id, id)).run();
+    }
+    async restartInstance(id) {
+        await this.disconnectInstance(id);
+        this.adapters.delete(id);
+        await this.connectInstance(id);
+    }
+    // ---- Adapter access ----
+    getAdapter(id) {
+        const managed = this.adapters.get(id);
+        if (!managed) {
+            throw new Error(`Instance ${id} not found or not initialized`);
+        }
+        return managed.adapter;
+    }
+    getInstanceChannel(id) {
+        const managed = this.adapters.get(id);
+        if (managed)
+            return managed.channel;
+        const row = this.getInstanceFromDb(id);
+        return row.channel;
+    }
+    // ---- DB reads ----
+    getAllInstances() {
+        return db.select().from(instances).all();
+    }
+    getInstance(id) {
+        return this.getInstanceFromDb(id);
+    }
+    getInstanceFromDb(id) {
+        const row = db.select().from(instances).where(eq(instances.id, id)).get();
+        if (!row) {
+            throw new Error(`Instance ${id} not found`);
+        }
+        return row;
+    }
+    // ---- Private helpers ----
+    createAdapter(instanceId, channel) {
+        if (channel !== "baileys") {
+            throw new Error(`Only baileys channel is supported in wagent`);
+        }
+        return new BaileysAdapter(instanceId);
+    }
+    bindAdapterEvents(instanceId, adapter) {
+        const events = [
+            "message.received",
+            "message.updated",
+            "message.deleted",
+            "message.reaction",
+            "message.edited",
+            "presence.updated",
+            "chat.updated",
+            "group.updated",
+            "group.participants_changed",
+            "contact.updated",
+            "connection.changed",
+            "call.received",
+        ];
+        for (const event of events) {
+            adapter.on(event, (payload) => {
+                if (event === "connection.changed") {
+                    const connPayload = payload;
+                    const statusMap = {
+                        open: "connected",
+                        close: "disconnected",
+                        connecting: "connecting",
+                    };
+                    const dbStatus = statusMap[connPayload.status] ?? "disconnected";
+                    const updateFields = {
+                        status: dbStatus,
+                        updatedAt: Date.now(),
+                    };
+                    if (connPayload.status === "open") {
+                        updateFields.lastConnected = Date.now();
+                    }
+                    if (connPayload.status === "close") {
+                        updateFields.lastDisconnected = Date.now();
+                    }
+                    db.update(instances).set(updateFields).where(eq(instances.id, instanceId)).run();
+                }
+                for (const handler of this.globalHandlers) {
+                    try {
+                        handler(event, instanceId, payload);
+                    }
+                    catch (err) {
+                        logger.error({ err, event, instanceId }, "Error in global event handler");
+                    }
+                }
+            });
+        }
+    }
+}

package/dist/types/channel.types.js

@@ -0,0 +1,4 @@
+// ============================================================
+// WA MCP — Channel Abstraction Types
+// ============================================================
+export {};

package/dist/types/db.types.js

@@ -0,0 +1,4 @@
+// ============================================================
+// WA MCP — Database Entity Type Helpers
+// ============================================================
+export {};

package/dist/utils/logger.js

@@ -0,0 +1,39 @@
+// ============================================================
+// WA MCP — Structured Logger with Request Tracing
+// ============================================================
+import pino from "pino";
+import { SERVER_NAME, DEFAULT_LOG_LEVEL } from "../constants.js";
+const logLevel = process.argv.includes("--debug")
+    ? "debug"
+    : process.argv.includes("--verbose")
+        ? "info"
+        : DEFAULT_LOG_LEVEL;
+const isStdio = process.env.WA_TRANSPORT === "stdio";
+export const logger = pino({
+    name: SERVER_NAME,
+    level: logLevel,
+    transport: process.env.NODE_ENV !== "production"
+        ? { target: "pino-pretty", options: { colorize: true, destination: isStdio ? 2 : 1 } }
+        : undefined,
+    redact: [
+        "headers.authorization",
+        "*.accessToken",
+        "*.cloudAccessToken",
+        "*.cloud_access_token",
+        "*.apiKey",
+        "params.accessToken",
+        "params.apiKey",
+        "req.headers.authorization",
+        "req.headers['x-api-key']",
+    ],
+}, pino.destination(isStdio ? 2 : 1));
+export function createChildLogger(context) {
+    return logger.child(context);
+}
+export function createRequestLogger(toolName, instanceId) {
+    return logger.child({
+        requestId: crypto.randomUUID(),
+        tool: toolName,
+        ...(instanceId ? { instanceId } : {}),
+    });
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "wagent",
+  "version": "1.0.0",
+  "description": "WhatsApp Agent — AI-powered WhatsApp assistant using WAMCP + Groq",
+  "type": "module",
+  "bin": {
+    "wagent": "./dist/index.js"
+  },
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "wagent": "tsx src/index.ts",
+    "dev": "tsx watch src/index.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@whiskeysockets/baileys": "^7.0.0-rc.9",
+    "better-sqlite3": "^11.8.2",
+    "drizzle-orm": "^0.39.3",
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.0.0",
+    "zod": "^3.24.2",
+    "ai": "^6.0.208",
+    "@ai-sdk/google": "^3.0.70",
+    "@ai-sdk/openai-compatible": "^2.0.51",
+    "qrcode-terminal": "^0.12.0",
+    "@hapi/boom": "^10.0.1"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": ["better-sqlite3", "@whiskeysockets/baileys", "protobufjs", "esbuild"]
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.5",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/hapi__boom": "^9.0.1",
+    "tsx": "^4.19.3",
+    "typescript": "^5.7.3"
+  }
+}