@plosson/agentio 0.5.8 → 0.5.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plosson/agentio",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "CLI for LLM agents to interact with communication and tracking services",
   "type": "module",
   "license": "MIT",
@@ -57,7 +57,7 @@
     "commander": "^14.0.2",
     "google-auth-library": "^10.0.0",
     "libsodium-wrappers": "^0.8.1",
-    "protobufjs": "^8.0.0",
+    "long": "^5.3.2",
     "qrcode-terminal": "^0.12.0",
     "rss-parser": "^3.13.0"
   }

package/src/commands/gateway.ts

@@ -7,7 +7,7 @@ import { password } from '@inquirer/prompts';
 import { handleError, CliError } from '../utils/errors';
 import { loadConfig, saveConfig } from '../config/config-manager';
 import { startGateway, getGatewayConfig, LOG_FILE } from '../gateway/daemon';
-import { exportWhatsAppAuthState } from '../gateway/store';
+import { initDatabase, closeDatabase, exportWhatsAppAuthState } from '../gateway/store';
 import { isInteractive } from '../utils/interactive';
 import type { Config } from '../types/config';
 
@@ -518,32 +518,40 @@ export function registerGatewayCommands(program: Command): void {
         if (options.service === 'all' || options.service === 'whatsapp') {
           const profiles = config.profiles.whatsapp || [];
 
-          for (const entry of profiles) {
-            const profileName = typeof entry === 'string' ? entry : entry.name;
-            console.log(`  Exporting whatsapp:${profileName}...`);
-            const authState = await exportWhatsAppAuthState(profileName);
+          if (profiles.length > 0) {
+            await initDatabase();
+          }
 
-            if (!authState) {
-              console.log('    No auth state found, skipping');
-              continue;
-            }
+          try {
+            for (const entry of profiles) {
+              const profileName = typeof entry === 'string' ? entry : entry.name;
+              console.log(`  Exporting whatsapp:${profileName}...`);
+              const authState = await exportWhatsAppAuthState(profileName);
 
-            // Send to remote gateway
-            const response = await fetch(`${url}/import/whatsapp/${encodeURIComponent(profileName)}`, {
-              method: 'POST',
-              headers: {
-                'Content-Type': 'application/json',
-                'X-API-Key': key,
-              },
-              body: JSON.stringify(authState),
-            });
-
-            if (!response.ok) {
-              const error = await response.text();
-              throw new CliError('API_ERROR', `Failed to import to remote: ${error}`);
-            }
+              if (!authState) {
+                console.log('    No auth state found, skipping');
+                continue;
+              }
 
-            console.log('    Transferred successfully');
+              // Send to remote gateway
+              const response = await fetch(`${url}/import/whatsapp/${encodeURIComponent(profileName)}`, {
+                method: 'POST',
+                headers: {
+                  'Content-Type': 'application/json',
+                  'X-API-Key': key,
+                },
+                body: JSON.stringify(authState),
+              });
+
+              if (!response.ok) {
+                const error = await response.text();
+                throw new CliError('API_ERROR', `Failed to import to remote: ${error}`);
+              }
+
+              console.log('    Transferred successfully');
+            }
+          } finally {
+            closeDatabase();
           }
         }
 

package/src/gateway/adapters/whatsapp.ts

@@ -75,6 +75,10 @@ export class WhatsAppAdapter extends BaseAdapter {
 
   private profiles: Map<string, ProfileConnection> = new Map();
 
+  hasProfile(profile: string): boolean {
+    return this.profiles.has(profile);
+  }
+
   async connect(profile: string, credentials: unknown): Promise<void> {
     const creds = credentials as WhatsAppCredentials;
 

package/src/gateway/api.ts

@@ -52,13 +52,31 @@ import {
   importWhatsAppAuthState,
   type WhatsAppAuthExport,
 } from './store';
-import type { ServiceAdapter } from './adapters/types';
-import type { WhatsAppAdapter } from './adapters/whatsapp';
+import type { ServiceAdapter, AdapterInboundMessage } from './adapters/types';
+import { WhatsAppAdapter } from './adapters/whatsapp';
 
 let server: Server<unknown> | null = null;
 let apiKey: string = '';
 let startTime: number = 0;
 let adapters: Map<ServiceName, ServiceAdapter> = new Map();
+let onAdapterMessage: ((service: ServiceName, profile: string, message: AdapterInboundMessage) => void) | null = null;
+
+/**
+ * Get or lazily create the WhatsApp adapter
+ */
+function getOrCreateWhatsAppAdapter(): WhatsAppAdapter {
+  let adapter = adapters.get('whatsapp') as WhatsAppAdapter | undefined;
+  if (!adapter) {
+    adapter = new WhatsAppAdapter();
+    adapter.onMessage = (profile, message) => {
+      if (onAdapterMessage) {
+        onAdapterMessage('whatsapp', profile, message);
+      }
+    };
+    adapters.set('whatsapp', adapter);
+  }
+  return adapter;
+}
 
 /**
  * JSON error response helper
@@ -333,19 +351,39 @@ function handleMedia(id: string): Response {
 /**
  * Handle WhatsApp pairing request
  */
-function handleWhatsAppPair(profile: string): Response {
-  const whatsappAdapter = adapters.get('whatsapp') as WhatsAppAdapter | undefined;
+async function handleWhatsAppPair(profile: string): Promise<Response> {
+  const whatsappAdapter = getOrCreateWhatsAppAdapter();
 
-  if (!whatsappAdapter) {
+  // If the profile isn't known to the adapter yet, start connecting it
+  const state = whatsappAdapter.getWhatsAppState(profile);
+  if (!state.connected && !whatsappAdapter.hasProfile(profile)) {
+    try {
+      await whatsappAdapter.connect(profile, { paired: false });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Failed to start pairing';
+      const response: WhatsAppPairResponse = {
+        status: 'connecting',
+        message,
+      };
+      return jsonResponse(response);
+    }
+    // Re-check state after connect
+    const newState = whatsappAdapter.getWhatsAppState(profile);
+    if (newState.qrCode) {
+      const response: WhatsAppPairResponse = {
+        status: 'waiting_qr',
+        qrCode: newState.qrCode,
+        message: 'Scan QR code with WhatsApp on your phone',
+      };
+      return jsonResponse(response);
+    }
     const response: WhatsAppPairResponse = {
-      status: 'not_configured',
-      message: 'WhatsApp is not configured. Add a profile first.',
+      status: 'connecting',
+      message: newState.error || 'Connecting to WhatsApp...',
     };
     return jsonResponse(response);
   }
 
-  const state = whatsappAdapter.getWhatsAppState(profile);
-
   if (state.connected) {
     const response: WhatsAppPairResponse = {
       status: 'connected',
@@ -390,13 +428,14 @@ async function handleWhatsAppImport(profile: string, request: Request): Promise<
     });
 
     // Disconnect and reconnect WhatsApp adapter to use new credentials
-    const whatsappAdapter = adapters.get('whatsapp') as WhatsAppAdapter | undefined;
-    if (whatsappAdapter) {
+    const whatsappAdapter = getOrCreateWhatsAppAdapter();
+    if (whatsappAdapter.hasProfile(profile)) {
       await whatsappAdapter.disconnect(profile);
-      // Note: reconnection will happen on next daemon cycle or manual reload
     }
+    // Reconnect with imported auth state
+    await whatsappAdapter.connect(profile, { paired: true });
 
-    return jsonResponse({ success: true, message: 'Auth state imported. Reload gateway to reconnect.' });
+    return jsonResponse({ success: true, message: 'Auth state imported and reconnecting.' });
   } catch (error) {
     const message = error instanceof Error ? error.message : 'Import failed';
     return jsonError(message, 500);
@@ -753,12 +792,17 @@ async function handleRequest(request: Request): Promise<Response> {
 /**
  * Start the API server
  */
-export function startApiServer(config: GatewayConfig, serviceAdapters: Map<ServiceName, ServiceAdapter>): Server<unknown> {
+export function startApiServer(
+  config: GatewayConfig,
+  serviceAdapters: Map<ServiceName, ServiceAdapter>,
+  messageHandler?: (service: ServiceName, profile: string, message: AdapterInboundMessage) => void,
+): Server<unknown> {
   const port = config?.server?.port ?? DEFAULT_GATEWAY_CONFIG.server.port;
   const host = config?.server?.host ?? DEFAULT_GATEWAY_CONFIG.server.host;
   apiKey = config?.apiKey ?? '';
   startTime = Date.now();
   adapters = serviceAdapters;
+  onAdapterMessage = messageHandler ?? null;
 
   server = Bun.serve({
     port,

package/src/gateway/daemon.ts

@@ -274,7 +274,7 @@ export async function startGateway(): Promise<void> {
     await initializeAdapters();
 
     // Start API server
-    startApiServer(gatewayConfig, adapters);
+    startApiServer(gatewayConfig, adapters, handleInboundMessage);
 
     // Start outbox processor (every 2 seconds)
     outboxInterval = setInterval(processOutbox, 2000);

package/src/polyfills.ts

@@ -2,9 +2,9 @@
 // This must be imported BEFORE any code that uses protobufjs (e.g., Baileys)
 
 import Long from 'long';
-import protobuf from 'protobufjs';
 
-// Fix for protobufjs Long support in Bun native binaries
-// Without this, $util.Long.fromBits is undefined at runtime
-protobuf.util.Long = Long;
-protobuf.configure();
+// Fix for protobufjs Long support in Bun native binaries.
+// protobufjs/minimal uses inquire("long") with eval-based require that fails in Bun bundles.
+// It falls back to checking global.Long (util/minimal.js:181), so we set it on globalThis
+// BEFORE any protobufjs code initializes (WAProto evaluates $util.Long at module load time).
+(globalThis as any).Long = Long;