Added some basic IPC (#1)

Signed-off-by: Matías Insaurralde <[email protected]>

Author: matiasinsaurralde

src/main/main.ts

@@ -12,9 +12,18 @@ import path from 'path';
 import { app, BrowserWindow, shell, ipcMain } from 'electron';
 import { autoUpdater } from 'electron-updater';
 import log from 'electron-log';
+import { spawn, ChildProcess } from 'child_process';
+import fs from 'fs';
 import MenuBuilder from './menu';
 import { resolveHtmlPath } from './util';
 
+// === IPC SOCKET CONFIGURATION ===
+// The Electron app will create a Unix domain socket at this path for Go backend IPC.
+// Update your Go backend to listen on this socket:
+//   os.Getenv("CROWDLLAMA_SOCKET")
+// Example: /tmp/crowdllama.sock
+const CROWDLLAMA_SOCKET_PATH = '/tmp/crowdllama.sock';
+
 class AppUpdater {
   constructor() {
     log.transports.file.level = 'info';
@@ -24,13 +33,231 @@ class AppUpdater {
 }
 
 let mainWindow: BrowserWindow | null = null;
+let goBackendProcess: ChildProcess | null = null;
+let pingInterval: ReturnType<typeof setInterval> | null = null;
+let ipcClient: any = null;
+let ipcClientBuffer = '';
+
+// Connect to Go backend IPC socket (persistent connection)
+const connectIPC = () => {
+  if (ipcClient) {
+    return; // Already connected
+  }
+  const net = require('net');
+  ipcClient = new net.Socket();
+  ipcClient.setEncoding('utf8');
+
+  ipcClient.connect(CROWDLLAMA_SOCKET_PATH, () => {
+    console.log('Connected to Go backend socket (persistent)');
+  });
+
+  ipcClient.on('data', (data: string) => {
+    ipcClientBuffer += data;
+    let index;
+    while ((index = ipcClientBuffer.indexOf('\n')) !== -1) {
+      const message = ipcClientBuffer.slice(0, index);
+      ipcClientBuffer = ipcClientBuffer.slice(index + 1);
+      if (message.trim()) {
+        try {
+          const parsed = JSON.parse(message);
+          console.log('Received from backend:', parsed);
+          // TODO: handle parsed message (route to renderer, etc)
+        } catch (err) {
+          console.log('Failed to parse backend message:', message);
+        }
+      }
+    }
+  });
+
+  ipcClient.on('error', (err: any) => {
+    console.log('IPC socket error:', err.message);
+    // Optionally, try to reconnect or clean up
+    ipcClient = null;
+  });
+
+  ipcClient.on('close', () => {
+    console.log('IPC socket closed');
+    ipcClient = null;
+  });
+};
+
+// Send a message over the persistent IPC connection
+const sendIPCMessage = (msg: object) => {
+  if (ipcClient && !ipcClient.destroyed) {
+    ipcClient.write(JSON.stringify(msg) + '\n');
+  } else {
+    console.log('IPC client not connected, cannot send message');
+  }
+};
 
+// Send ping to Go backend via persistent socket
+const pingBackend = async () => {
+  try {
+    if (!ipcClient || ipcClient.destroyed) {
+      console.log('IPC client not connected, reconnecting...');
+      connectIPC();
+      // Wait a moment for connection
+      setTimeout(() => sendIPCMessage({ type: 'ping', timestamp: Date.now() }), 200);
+      return;
+    }
+    sendIPCMessage({ type: 'ping', timestamp: Date.now() });
+  } catch (error) {
+    console.error('Error sending ping:', error);
+  }
+};
+
+// Start ping interval
+const startPingInterval = () => {
+  // Clear any existing interval
+  if (pingInterval) {
+    clearInterval(pingInterval);
+  }
+
+  // Start new ping interval (every 1 minute = 60000ms)
+  pingInterval = setInterval(pingBackend, 60000);
+  console.log('Started ping interval (every 1 minute)');
+
+  // Send initial ping immediately
+  pingBackend();
+};
+
+// Start Go backend process
+const startGoBackend = () => {
+  try {
+    const goBackendPath = '/Users/matias/go/src/github.com/crowdllama/crowdllama';
+    const goBackendCommand = '/opt/homebrew/bin/go';
+    const goBackendArgs = ['run', 'cmd/crowdllama/main.go', 'start'];
+
+    // Remove the socket file if it exists
+    try {
+      if (fs.existsSync(CROWDLLAMA_SOCKET_PATH)) {
+        fs.unlinkSync(CROWDLLAMA_SOCKET_PATH);
+      }
+    } catch (err) {
+      console.error('Error removing old socket file:', err);
+    }
+
+    console.log('Starting Go backend process...');
+    console.log(`Command: ${goBackendCommand} ${goBackendArgs.join(' ')}`);
+    console.log(`Working directory: ${goBackendPath}`);
+    console.log(`Socket path: ${CROWDLLAMA_SOCKET_PATH}`);
+
+    goBackendProcess = spawn(goBackendCommand, goBackendArgs, {
+      cwd: goBackendPath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: false,
+      env: {
+        ...process.env,
+        CROWDLLAMA_SOCKET: CROWDLLAMA_SOCKET_PATH,
+      },
+    });
+
+    goBackendProcess.stdout?.on('data', (data) => {
+      console.log('Go backend stdout:', data.toString());
+    });
+
+    goBackendProcess.stderr?.on('data', (data) => {
+      console.log('Go backend stderr:', data.toString());
+    });
+
+    goBackendProcess.on('error', (error) => {
+      console.error('Failed to start Go backend process:', error);
+    });
+
+    goBackendProcess.on('close', (code) => {
+      console.log(`Go backend process exited with code ${code}`);
+      goBackendProcess = null;
+      // Clean up IPC client
+      if (ipcClient) {
+        ipcClient.destroy();
+        ipcClient = null;
+      }
+    });
+
+    console.log('Go backend process started successfully');
+
+    // Start ping interval after a short delay to allow backend to initialize
+    setTimeout(() => {
+      connectIPC();
+      startPingInterval();
+    }, 2000);
+  } catch (error) {
+    console.error('Error starting Go backend process:', error);
+  }
+};
+
+// Stop Go backend process
+const stopGoBackend = () => {
+  if (goBackendProcess) {
+    console.log('Stopping Go backend process...');
+    goBackendProcess.kill('SIGTERM');
+    goBackendProcess = null;
+  }
+
+  // Stop ping interval
+  if (pingInterval) {
+    clearInterval(pingInterval);
+    pingInterval = null;
+  }
+  if (ipcClient) {
+    ipcClient.destroy();
+    ipcClient = null;
+  }
+};
+
+// IPC handlers
 ipcMain.on('ipc-example', async (event, arg) => {
   const msgTemplate = (pingPong: string) => `IPC test: ${pingPong}`;
   console.log(msgTemplate(arg));
   event.reply('ipc-example', msgTemplate('pong'));
 });
 
+ipcMain.handle('start-backend', async () => {
+  try {
+    startGoBackend();
+    return { success: true, message: 'Go backend started successfully' };
+  } catch (error) {
+    console.error('Error starting backend:', error);
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+});
+
+ipcMain.handle('stop-backend', async () => {
+  try {
+    stopGoBackend();
+    return { success: true, message: 'Go backend stopped successfully' };
+  } catch (error) {
+    console.error('Error stopping backend:', error);
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+});
+
+ipcMain.handle('get-backend-status', async () => {
+  return {
+    isRunning: goBackendProcess !== null,
+    pid: goBackendProcess && typeof goBackendProcess.pid === 'number' ? goBackendProcess.pid : null,
+  };
+});
+
+ipcMain.handle('ping-backend', async () => {
+  try {
+    await pingBackend();
+    return { success: true, message: 'Ping sent successfully' };
+  } catch (error) {
+    console.error('Error pinging backend:', error);
+    return {
+      success: false,
+      message: error instanceof Error ? error.message : 'Unknown error',
+    };
+  }
+});
+
 if (process.env.NODE_ENV === 'production') {
   const sourceMapSupport = require('source-map-support');
   sourceMapSupport.install();
@@ -117,17 +344,26 @@ const createWindow = async () => {
  */
 
 app.on('window-all-closed', () => {
+  // Stop Go backend process when app closes
+  stopGoBackend();
   // Respect the OSX convention of having the application in memory even
   // after all windows have been closed
   if (process.platform !== 'darwin') {
     app.quit();
   }
 });
 
+app.on('before-quit', () => {
+  // Ensure Go backend is stopped before quitting
+  stopGoBackend();
+});
+
 app
   .whenReady()
   .then(() => {
     createWindow();
+    // Start Go backend process when app is ready
+    startGoBackend();
     app.on('activate', () => {
       // On macOS it's common to re-create a window in the app when the
       // dock icon is clicked and there are no other windows open.

src/main/preload.ts

@@ -2,7 +2,12 @@
 /* eslint no-unused-vars: off */
 import { contextBridge, ipcRenderer, IpcRendererEvent } from 'electron';
 
-export type Channels = 'ipc-example';
+export type Channels =
+  | 'ipc-example'
+  | 'start-backend'
+  | 'stop-backend'
+  | 'get-backend-status'
+  | 'ping-backend';
 
 const electronHandler = {
   ipcRenderer: {
@@ -22,6 +27,20 @@ const electronHandler = {
       ipcRenderer.once(channel, (_event, ...args) => func(...args));
     },
   },
+  backend: {
+    async startBackend() {
+      return ipcRenderer.invoke('start-backend');
+    },
+    async stopBackend() {
+      return ipcRenderer.invoke('stop-backend');
+    },
+    async getBackendStatus() {
+      return ipcRenderer.invoke('get-backend-status');
+    },
+    async pingBackend() {
+      return ipcRenderer.invoke('ping-backend');
+    },
+  },
 };
 
 contextBridge.exposeInMainWorld('electron', electronHandler);