@zap-js/client 0.0.7 → 0.0.8

package/dist/dev-server/server.d.ts

@@ -71,6 +71,14 @@ export declare class DevServer extends EventEmitter {
      * Run codegen to generate TypeScript bindings
      */
     private runCodegen;
+    /**
+     * Wait for Rust server to be ready by checking for .rpc socket file
+     */
+    private waitForRustServer;
+    /**
+     * Check if a file exists
+     */
+    private fileExists;
     /**
      * Scan routes directory and generate route tree
      */

package/dist/dev-server/server.js

@@ -2,6 +2,7 @@ import { EventEmitter } from 'events';
 import path from 'path';
 import { tmpdir } from 'os';
 import { pathToFileURL } from 'url';
+import { promises as fs } from 'fs';
 import { FileWatcher } from './watcher.js';
 import { RustBuilder } from './rust-builder.js';
 import { ViteProxy } from './vite-proxy.js';
@@ -269,6 +270,36 @@ export class DevServer extends EventEmitter {
             cliLogger.warn('Codegen skipped (binary not found)');
         }
     }
+    /**
+     * Wait for Rust server to be ready by checking for .rpc socket file
+     */
+    async waitForRustServer() {
+        const rpcSocketPath = this.socketPath + '.rpc';
+        const maxWait = 10000; // 10 seconds
+        const checkInterval = 100; // 100ms
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxWait) {
+            // Check if .rpc socket file exists
+            if (await this.fileExists(rpcSocketPath)) {
+                this.log('debug', `RPC socket ready: ${rpcSocketPath}`);
+                return;
+            }
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+        }
+        throw new Error(`RPC server failed to start within ${maxWait}ms`);
+    }
+    /**
+     * Check if a file exists
+     */
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     /**
      * Scan routes directory and generate route tree
      */
@@ -300,11 +331,7 @@ export class DevServer extends EventEmitter {
             this.ipcServer = new IpcServer(this.socketPath);
             await this.ipcServer.start();
             this.log('debug', `IPC server listening on ${this.socketPath}`);
-            // Initialize RPC client for bidirectional IPC communication
-            // This allows TypeScript route handlers to call Rust functions via rpc.call()
-            initRpcClient(this.socketPath + '.rpc');
-            this.log('debug', `RPC client initialized on ${this.socketPath}.rpc`);
-            // Load and register route handlers
+            // Load and register route handlers (before starting Rust)
             const routes = await this.loadRouteHandlers(routeTree);
             console.log(`[dev-server] Loaded ${routes.length} route configurations`);
             // Build Rust server configuration
@@ -318,6 +345,13 @@ export class DevServer extends EventEmitter {
             await this.processManager.start(config, this.config.logLevel || 'info');
             this.state.rustReady = true;
             cliLogger.succeedSpinner('rust-server', `Rust server ready on port ${this.config.rustPort}`);
+            // Wait for Rust RPC server to be ready
+            await this.waitForRustServer();
+            // Initialize RPC client for bidirectional IPC communication
+            // This allows TypeScript route handlers to call Rust functions via rpc.call()
+            this.log('debug', `Initializing RPC client on ${this.socketPath}.rpc`);
+            await initRpcClient(this.socketPath + '.rpc');
+            this.log('debug', `RPC client connected to ${this.socketPath}.rpc`);
         }
         catch (err) {
             cliLogger.failSpinner('rust-server', 'Failed to start Rust server');

package/dist/runtime/ipc-client.d.ts

@@ -116,6 +116,11 @@ export declare class IpcClient extends EventEmitter {
     private frameReader;
     private encoding;
     constructor(socketPath: string, encoding?: IpcEncoding);
+    /**
+     * Ensure the client is connected. If not connected, attempt to connect.
+     * Returns a promise that resolves when connected.
+     */
+    ensureConnected(): Promise<void>;
     /**
      * Connect to the Unix socket
      */

package/dist/runtime/ipc-client.js

@@ -526,7 +526,34 @@ export class IpcClient extends EventEmitter {
         this.frameReader = null;
         this.socketPath = socketPath;
         this.encoding = encoding;
-        this.connect();
+        // Don't connect immediately - wait for explicit ensureConnected() call
+    }
+    /**
+     * Ensure the client is connected. If not connected, attempt to connect.
+     * Returns a promise that resolves when connected.
+     */
+    async ensureConnected() {
+        if (this.connected) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject(new Error(`Failed to connect to ${this.socketPath} after 5s`));
+            }, 5000);
+            this.connect();
+            const onConnect = () => {
+                clearTimeout(timeout);
+                this.removeListener('error', onError);
+                resolve();
+            };
+            const onError = (err) => {
+                clearTimeout(timeout);
+                this.removeListener('connect', onConnect);
+                reject(err);
+            };
+            this.once('connect', onConnect);
+            this.once('error', onError);
+        });
     }
     /**
      * Connect to the Unix socket

package/dist/runtime/rpc-client.d.ts

@@ -12,7 +12,7 @@ export declare class RpcError extends Error {
 /**
  * Initialize the RPC client with a socket path
  */
-export declare function initRpcClient(socketPath: string): void;
+export declare function initRpcClient(socketPath: string): Promise<void>;
 /**
  * Call a Rust server function via RPC
  */

package/dist/runtime/rpc-client.js

@@ -21,7 +21,7 @@ export class RpcError extends Error {
 /**
  * Initialize the RPC client with a socket path
  */
-export function initRpcClient(socketPath) {
+export async function initRpcClient(socketPath) {
     if (ipcClient) {
         throw new Error('RPC client already initialized');
     }
@@ -59,6 +59,23 @@ export function initRpcClient(socketPath) {
         }
         pendingRequests.clear();
     });
+    // Wait for connection with retry logic
+    const maxRetries = 10;
+    const retryDelay = 500; // ms
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            await ipcClient.ensureConnected();
+            console.log(`[RPC] Client connected to ${socketPath}`);
+            return;
+        }
+        catch (err) {
+            if (i === maxRetries - 1) {
+                throw new Error(`Failed to connect RPC client after ${maxRetries} attempts: ${err}`);
+            }
+            console.log(`[RPC] Waiting for server... (attempt ${i + 1}/${maxRetries})`);
+            await new Promise(resolve => setTimeout(resolve, retryDelay));
+        }
+    }
 }
 /**
  * Call a Rust server function via RPC
@@ -67,6 +84,8 @@ export async function rpcCall(functionName, params = {}, timeoutMs = 30000) {
     if (!ipcClient) {
         throw new Error('RPC client not initialized. Call initRpcClient() first.');
     }
+    // Ensure connection before sending
+    await ipcClient.ensureConnected();
     const requestId = `req_${Date.now()}_${requestCounter++}`;
     const message = {
         type: 'rpc_call',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-js/client",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "High-performance fullstack React framework - Client package",
   "homepage": "https://github.com/saint0x/zapjs",
   "repository": {