machinaos 0.0.1

package/server/whatsapp-rpc/scripts/clean.cjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// Standalone clean script - no npm dependencies required
+const { existsSync, unlinkSync, readdirSync, rmSync } = require('fs');
+const { join } = require('path');
+const { execSync } = require('child_process');
+
+const ROOT = join(__dirname, '..');
+const BIN = process.platform === 'win32' ? 'whatsapp-rpc-server.exe' : 'whatsapp-rpc-server';
+const BIN_DIR = join(ROOT, 'bin');
+
+const log = (msg, color) => {
+  const colors = { green: '\x1b[32m', blue: '\x1b[34m', yellow: '\x1b[33m', reset: '\x1b[0m' };
+  console.log(`${colors[color] || ''}${msg}${colors.reset}`);
+};
+
+// Kill process on port
+const killPort = (port, name) => {
+  try {
+    if (process.platform === 'win32') {
+      execSync(`for /f "tokens=5" %a in ('netstat -aon ^| findstr :${port} ^| findstr LISTENING') do taskkill /F /PID %a`, { stdio: 'ignore', shell: 'cmd.exe' });
+    } else {
+      execSync(`lsof -ti:${port} | xargs kill -9 2>/dev/null || true`, { stdio: 'ignore' });
+    }
+    log(`${name} stopped`, 'green');
+  } catch { log(`${name} not running`, 'yellow'); }
+};
+
+log('Stopping all processes...', 'blue');
+killPort(9400, 'API');
+killPort(5000, 'Web');
+
+// Remove binary
+const bin = join(BIN_DIR, BIN);
+if (existsSync(bin)) { unlinkSync(bin); log(`Removed ${BIN}`, 'green'); }
+
+// Remove bin directory if empty
+if (existsSync(BIN_DIR) && readdirSync(BIN_DIR).length === 0) {
+  rmSync(BIN_DIR, { recursive: true }); log('Removed bin/', 'green');
+}
+
+// Remove entire data directory (database, QR codes, etc.)
+const dataDir = join(ROOT, 'data');
+if (existsSync(dataDir)) {
+  rmSync(dataDir, { recursive: true });
+  log('Removed data/', 'green');
+}
+
+// Remove any .db files in project root (legacy locations)
+readdirSync(ROOT).filter(f => f.endsWith('.db') || f.endsWith('.db-wal') || f.endsWith('.db-shm')).forEach(f => {
+  unlinkSync(join(ROOT, f));
+  log(`Removed ${f}`, 'green');
+});
+
+// Remove node_modules
+const nodeModules = join(ROOT, 'node_modules');
+if (existsSync(nodeModules)) { rmSync(nodeModules, { recursive: true }); log('Removed node_modules/', 'green'); }
+
+// Remove Python cache
+const pycache = join(ROOT, 'web', '__pycache__');
+if (existsSync(pycache)) { rmSync(pycache, { recursive: true }); log('Removed web/__pycache__/', 'green'); }
+
+// Remove package-lock.json
+const lockFile = join(ROOT, 'package-lock.json');
+if (existsSync(lockFile)) { unlinkSync(lockFile); log('Removed package-lock.json', 'green'); }
+
+log('Clean complete', 'green');

package/server/whatsapp-rpc/scripts/cli.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import killPort from 'kill-port';
+import { Socket } from 'net';
+import { execSync, spawn } from 'child_process';
+import { existsSync, statSync, unlinkSync, readdirSync, rmSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+const API_PORT = 9400, WEB_PORT = 5000;
+const BIN = process.platform === 'win32' ? 'whatsapp-rpc-server.exe' : 'whatsapp-rpc-server';
+const BIN_DIR = join(ROOT, 'bin');
+
+const log = (m, c = 'blue') => console.log(chalk[c](m));
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+const portUp = port => new Promise(r => {
+  const s = new Socket();
+  s.setTimeout(2000);
+  s.on('connect', () => { s.destroy(); r(true); });
+  s.on('timeout', () => { s.destroy(); r(false); });
+  s.on('error', () => r(false));
+  s.connect(port, '127.0.0.1');
+});
+
+const wait = async (port, ms = 10000) => {
+  const t = Date.now();
+  while (Date.now() - t < ms) { if (await portUp(port)) return true; await sleep(500); }
+  return false;
+};
+
+const kill = async (port, name) => {
+  try { await killPort(port); log(`${name} stopped`, 'green'); }
+  catch { log(`${name} not running`, 'yellow'); }
+};
+
+const py = () => {
+  try { execSync('python --version', { stdio: 'ignore' }); return 'python'; }
+  catch { try { execSync('python3 --version', { stdio: 'ignore' }); return 'python3'; } catch { return null; } }
+};
+
+const hasGo = () => {
+  try { execSync('go version', { stdio: 'ignore' }); return true; }
+  catch { return false; }
+};
+
+async function api(foreground = false) {
+  if (await portUp(API_PORT)) { log(`API already on ${API_PORT}`, 'yellow'); return; }
+  const bin = join(BIN_DIR, BIN);
+  if (!existsSync(bin)) {
+    if (!hasGo()) {
+      log('Go is not installed. Please either:', 'red');
+      log('  1. Install Go: https://go.dev/dl/', 'yellow');
+      log('  2. Or run "npm run build" on a machine with Go installed', 'yellow');
+      log('  3. Or copy the pre-built binary to: ' + bin, 'yellow');
+      process.exit(1);
+    }
+    log('Building...', 'yellow');
+    await build();
+  }
+
+  if (foreground) {
+    // Run in foreground - will receive Ctrl+C signals
+    const proc = spawn(bin, [], { cwd: ROOT, stdio: 'inherit' });
+    proc.on('close', (code) => process.exit(code || 0));
+    process.on('SIGINT', () => { proc.kill('SIGINT'); });
+    process.on('SIGTERM', () => { proc.kill('SIGTERM'); });
+    log(`API: ws://localhost:${API_PORT}/ws/rpc`, 'green');
+  } else {
+    // Run detached in background
+    spawn(bin, [], { cwd: ROOT, detached: true, stdio: 'ignore' }).unref();
+    if (await wait(API_PORT)) log(`API: ws://localhost:${API_PORT}/ws/rpc`, 'green');
+    else log('API failed to start', 'red');
+  }
+}
+
+async function web() {
+  if (await portUp(WEB_PORT)) { log(`Web already on ${WEB_PORT}`, 'yellow'); return; }
+  const p = py(); if (!p) { log('Python not found', 'red'); return; }
+  if (!await portUp(API_PORT)) log('Warning: API not running', 'yellow');
+  spawn(p, ['app.py'], { cwd: join(ROOT, 'web'), detached: true, stdio: 'ignore' }).unref();
+  if (await wait(WEB_PORT)) log(`Web: http://localhost:${WEB_PORT}`, 'green');
+  else log('Web failed to start', 'red');
+}
+
+async function start() { await api(); await sleep(1000); await web(); }
+async function stop() { await kill(API_PORT, 'API'); await kill(WEB_PORT, 'Web'); }
+
+async function status() {
+  const a = await portUp(API_PORT), w = await portUp(WEB_PORT);
+  log(`API (${API_PORT}): ${a ? 'UP' : 'DOWN'}`, a ? 'green' : 'red');
+  log(`Web (${WEB_PORT}): ${w ? 'UP' : 'DOWN'}`, w ? 'green' : 'red');
+}
+
+async function build() {
+  if (!hasGo()) {
+    log('Go is not installed. Install from: https://go.dev/dl/', 'red');
+    process.exit(1);
+  }
+  const bin = join(BIN_DIR, BIN);
+  if (!existsSync(BIN_DIR)) { await execa('mkdir', ['-p', BIN_DIR]); }
+  if (existsSync(bin)) unlinkSync(bin);
+  await execa('go', ['build', '-o', bin, './src/go/cmd/server'], { cwd: ROOT, stdio: 'inherit' });
+  log(`Built: ${BIN} (${(statSync(bin).size / 1024 / 1024).toFixed(1)}MB)`, 'green');
+}
+
+async function clean() {
+  log('Stopping all processes...', 'blue');
+  await stop();
+  await sleep(1000);
+
+  // Remove binary
+  const bin = join(BIN_DIR, BIN);
+  if (existsSync(bin)) { unlinkSync(bin); log(`Removed ${BIN}`, 'green'); }
+
+  // Remove bin directory if empty
+  if (existsSync(BIN_DIR) && readdirSync(BIN_DIR).length === 0) {
+    rmSync(BIN_DIR, { recursive: true }); log('Removed bin/', 'green');
+  }
+
+  // Remove entire data directory (database, QR codes, etc.)
+  const dataDir = join(ROOT, 'data');
+  if (existsSync(dataDir)) {
+    rmSync(dataDir, { recursive: true });
+    log('Removed data/', 'green');
+  }
+
+  // Remove any .db files in project root (legacy locations)
+  readdirSync(ROOT).filter(f => f.endsWith('.db') || f.endsWith('.db-wal') || f.endsWith('.db-shm')).forEach(f => {
+    unlinkSync(join(ROOT, f));
+    log(`Removed ${f}`, 'green');
+  });
+
+  // Remove node_modules
+  const nodeModules = join(ROOT, 'node_modules');
+  if (existsSync(nodeModules)) { rmSync(nodeModules, { recursive: true }); log('Removed node_modules/', 'green'); }
+
+  // Remove Python cache
+  const pycache = join(ROOT, 'web', '__pycache__');
+  if (existsSync(pycache)) { rmSync(pycache, { recursive: true }); log('Removed web/__pycache__/', 'green'); }
+
+  // Remove package-lock.json
+  const lockFile = join(ROOT, 'package-lock.json');
+  if (existsSync(lockFile)) { unlinkSync(lockFile); log('Removed package-lock.json', 'green'); }
+
+  log('Clean complete', 'green');
+}
+
+program.name('wa').version('1.0.0');
+program.command('start').description('Start all').action(start);
+program.command('stop').description('Stop all').action(stop);
+program.command('restart').description('Restart all').action(async () => { await stop(); await sleep(1000); await start(); });
+program.command('status').description('Status').action(status);
+program.command('api').description('Start API only').option('-f, --foreground', 'Run in foreground (receive signals)').action((opts) => api(opts.foreground));
+program.command('web').description('Start Web only').action(web);
+program.command('build').description('Build binary').action(build);
+program.command('clean').description('Clean artifacts').action(clean);
+program.parse();

package/server/whatsapp-rpc/src/go/cmd/server/main.go

@@ -0,0 +1,91 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"os"
+	"os/signal"
+	"syscall"
+	"time"
+
+	"github.com/sirupsen/logrus"
+
+	"whatsapp-rpc/src/go/config"
+	server "whatsapp-rpc/src/go/rpc"
+	"whatsapp-rpc/src/go/whatsapp"
+)
+
+func main() {
+	// Initialize logger
+	logger := logrus.New()
+	logger.SetFormatter(&logrus.TextFormatter{
+		FullTimestamp: true,
+	})
+
+	// Load configuration
+	cfg, err := config.Load()
+	if err != nil {
+		logger.Fatalf("Failed to load config: %v", err)
+	}
+
+	// Set log level (5 = Debug, 4 = Info)
+	if cfg.LogLevel >= 5 {
+		logger.SetLevel(logrus.DebugLevel)
+	}
+
+	logger.Info("Starting WhatsApp WebSocket RPC Server")
+
+	// Initialize WhatsApp service
+	whatsappService, err := whatsapp.NewService(cfg.Database, logger)
+	if err != nil {
+		logger.Fatalf("Failed to initialize WhatsApp service: %v", err)
+	}
+
+	// Auto-start if there's an existing session (no need to press Start button)
+	if whatsappService.HasExistingSession() {
+		logger.Info("Existing session found, auto-connecting...")
+		if err := whatsappService.Start(); err != nil {
+			logger.Warnf("Auto-start failed: %v (user can manually start)", err)
+		}
+	} else {
+		logger.Info("No existing session, waiting for user to start pairing")
+	}
+
+	// Create and start server (WebSocket RPC only)
+	srv := server.New(whatsappService, logger)
+	router := srv.SetupRoutes()
+
+	httpServer := &http.Server{
+		Addr:    fmt.Sprintf(":%d", cfg.Server.Port),
+		Handler: router,
+	}
+
+	// Start server in goroutine
+	go func() {
+		logger.Infof("WebSocket RPC server listening on port %d", cfg.Server.Port)
+		logger.Infof("Connect via: ws://localhost:%d/ws/rpc", cfg.Server.Port)
+		if err := httpServer.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+			logger.Fatalf("Server error: %v", err)
+		}
+	}()
+
+	// Wait for interrupt signal
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+	<-quit
+
+	logger.Info("Shutting down server...")
+
+	// Graceful shutdown
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	whatsappService.Shutdown()
+
+	if err := httpServer.Shutdown(ctx); err != nil {
+		logger.Errorf("Server shutdown error: %v", err)
+	}
+
+	logger.Info("Server stopped")
+}

package/server/whatsapp-rpc/src/go/config/config.go

@@ -0,0 +1,49 @@
+package config
+
+import (
+	"github.com/spf13/viper"
+)
+
+type Config struct {
+	Environment string         `mapstructure:"environment"`
+	LogLevel    int            `mapstructure:"log_level"`
+	Server      ServerConfig   `mapstructure:"server"`
+	Database    DatabaseConfig `mapstructure:"database"`
+}
+
+type ServerConfig struct {
+	Port int    `mapstructure:"port"`
+	Host string `mapstructure:"host"`
+}
+
+type DatabaseConfig struct {
+	Path string `mapstructure:"path"`
+}
+
+func Load() (*Config, error) {
+	viper.SetDefault("environment", "development")
+	viper.SetDefault("log_level", 4) // Info level
+	viper.SetDefault("server.port", 9400)
+	viper.SetDefault("server.host", "0.0.0.0")
+	viper.SetDefault("database.path", "data/whatsapp.db")
+
+	// Environment variables
+	viper.SetEnvPrefix("WA")
+	viper.AutomaticEnv()
+
+	// Config file
+	viper.SetConfigName("config")
+	viper.SetConfigType("yaml")
+	viper.AddConfigPath(".")
+	viper.AddConfigPath("./configs")
+
+	// Read config file (optional)
+	viper.ReadInConfig()
+
+	var config Config
+	if err := viper.Unmarshal(&config); err != nil {
+		return nil, err
+	}
+
+	return &config, nil
+}