@zap-js/client 0.0.7 → 0.0.9

package/dist/cli/commands/build.js

@@ -2,6 +2,7 @@ import { execSync } from 'child_process';
 import { join, resolve } from 'path';
 import { existsSync, mkdirSync, copyFileSync, readdirSync, statSync, rmSync, writeFileSync } from 'fs';
 import { cliLogger } from '../utils/logger.js';
+import { resolveBinary } from '../utils/binary-resolver.js';
 /**
  * Build for production
  */
@@ -188,22 +189,24 @@ async function typeCheck() {
 }
 async function runCodegen() {
     const projectDir = process.cwd();
-    // Find codegen binary using same logic as codegen command
-    const possiblePaths = [
-        join(projectDir, 'bin', 'zap-codegen'),
-        join(projectDir, '../../target/release/zap-codegen'),
-        join(projectDir, '../../target/aarch64-apple-darwin/release/zap-codegen'),
-        join(projectDir, '../../target/x86_64-unknown-linux-gnu/release/zap-codegen'),
-        join(projectDir, 'target/release/zap-codegen'),
-    ];
-    let codegenBinary = null;
-    for (const path of possiblePaths) {
-        if (existsSync(path)) {
-            codegenBinary = path;
-            break;
+    // Try to resolve codegen binary using binary resolver
+    let codegenBinary = resolveBinary('zap-codegen', projectDir);
+    // If not found, try workspace target locations (for development)
+    if (!codegenBinary) {
+        const possiblePaths = [
+            join(projectDir, '../../target/release/zap-codegen'),
+            join(projectDir, '../../target/aarch64-apple-darwin/release/zap-codegen'),
+            join(projectDir, '../../target/x86_64-unknown-linux-gnu/release/zap-codegen'),
+            join(projectDir, 'target/release/zap-codegen'),
+        ];
+        for (const path of possiblePaths) {
+            if (existsSync(path)) {
+                codegenBinary = path;
+                break;
+            }
         }
     }
-    // Try global zap-codegen as fallback
+    // Try global zap-codegen as final fallback
     if (!codegenBinary) {
         try {
             execSync('which zap-codegen', { stdio: 'pipe' });

package/dist/cli/commands/dev.js

@@ -1,33 +1,6 @@
-import path from 'path';
-import { existsSync } from 'fs';
 import { DevServer } from '../../dev-server/index.js';
 import { cliLogger } from '../utils/logger.js';
-/**
- * Auto-detect pre-built binaries in bin/ directory
- */
-function detectBinaries(projectDir) {
-    const binDir = path.join(projectDir, 'bin');
-    const result = {};
-    // Check for zap binary
-    const zapBinary = path.join(binDir, 'zap');
-    const zapBinaryExe = path.join(binDir, 'zap.exe');
-    if (existsSync(zapBinary)) {
-        result.binaryPath = zapBinary;
-    }
-    else if (existsSync(zapBinaryExe)) {
-        result.binaryPath = zapBinaryExe;
-    }
-    // Check for zap-codegen binary
-    const codegenBinary = path.join(binDir, 'zap-codegen');
-    const codegenBinaryExe = path.join(binDir, 'zap-codegen.exe');
-    if (existsSync(codegenBinary)) {
-        result.codegenBinaryPath = codegenBinary;
-    }
-    else if (existsSync(codegenBinaryExe)) {
-        result.codegenBinaryPath = codegenBinaryExe;
-    }
-    return result;
-}
+import { detectBinaries, getPlatformIdentifier } from '../utils/binary-resolver.js';
 /**
  * Start development server with hot reload
  *
@@ -54,7 +27,8 @@ export async function devCommand(options) {
     };
     // Log if using pre-built binaries
     if (config.binaryPath) {
-        cliLogger.info('Using pre-built binary', config.binaryPath);
+        const platformId = getPlatformIdentifier();
+        cliLogger.info(`Using pre-built binary for ${platformId}`, config.binaryPath);
     }
     const server = new DevServer(config);
     // Handle graceful shutdown

package/dist/cli/utils/binary-resolver.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Resolves the path to a ZapJS binary using multiple strategies:
+ * 1. Platform-specific npm package (@zap-js/darwin-arm64, etc.)
+ * 2. Local bin/ directory in user's project (for development/custom builds)
+ * 3. Returns null to trigger cargo build fallback
+ */
+export declare function resolveBinary(binaryName: 'zap' | 'zap-codegen', projectDir?: string): string | null;
+/**
+ * Detects both zap and zap-codegen binaries
+ */
+export declare function detectBinaries(projectDir: string): {
+    binaryPath?: string;
+    codegenBinaryPath?: string;
+};
+/**
+ * Gets the platform identifier (e.g., "darwin-arm64")
+ */
+export declare function getPlatformIdentifier(): string;
+/**
+ * Checks if a platform-specific package is installed
+ */
+export declare function isPlatformPackageInstalled(): boolean;

package/dist/cli/utils/binary-resolver.js

@@ -0,0 +1,71 @@
+import path from 'path';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Resolves the path to a ZapJS binary using multiple strategies:
+ * 1. Platform-specific npm package (@zap-js/darwin-arm64, etc.)
+ * 2. Local bin/ directory in user's project (for development/custom builds)
+ * 3. Returns null to trigger cargo build fallback
+ */
+export function resolveBinary(binaryName, projectDir) {
+    const platform = process.platform;
+    const arch = process.arch;
+    // Strategy 1: Try platform-specific npm package
+    const platformPkg = `@zap-js/${platform}-${arch}`;
+    try {
+        // Try to resolve the platform package
+        const pkgPath = require.resolve(`${platformPkg}/package.json`);
+        const binPath = path.join(path.dirname(pkgPath), 'bin', binaryName);
+        if (existsSync(binPath)) {
+            return binPath;
+        }
+    }
+    catch (err) {
+        // Platform package not installed, continue to next strategy
+    }
+    // Strategy 2: Check local bin/ directory in user's project
+    if (projectDir) {
+        const localBin = path.join(projectDir, 'bin', binaryName);
+        const localBinExe = path.join(projectDir, 'bin', `${binaryName}.exe`);
+        if (existsSync(localBin)) {
+            return localBin;
+        }
+        if (existsSync(localBinExe)) {
+            return localBinExe;
+        }
+    }
+    // Strategy 3: Return null (will trigger cargo build)
+    return null;
+}
+/**
+ * Detects both zap and zap-codegen binaries
+ */
+export function detectBinaries(projectDir) {
+    const binaryPath = resolveBinary('zap', projectDir);
+    const codegenBinaryPath = resolveBinary('zap-codegen', projectDir);
+    return {
+        binaryPath: binaryPath || undefined,
+        codegenBinaryPath: codegenBinaryPath || undefined,
+    };
+}
+/**
+ * Gets the platform identifier (e.g., "darwin-arm64")
+ */
+export function getPlatformIdentifier() {
+    return `${process.platform}-${process.arch}`;
+}
+/**
+ * Checks if a platform-specific package is installed
+ */
+export function isPlatformPackageInstalled() {
+    const platformPkg = `@zap-js/${getPlatformIdentifier()}`;
+    try {
+        require.resolve(`${platformPkg}/package.json`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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.9",
   "description": "High-performance fullstack React framework - Client package",
   "homepage": "https://github.com/saint0x/zapjs",
   "repository": {
@@ -24,8 +24,7 @@
     "zap": "./dist/cli/index.js"
   },
   "files": [
-    "dist",
-    "bin"
+    "dist"
   ],
   "scripts": {
     "build": "tsc",
@@ -49,10 +48,16 @@
     "ora": "^6.0.0",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
+    "strip-ansi": "^7.0.0",
     "tsx": "^4.21.0",
     "vite": "^5.0.0",
     "ws": "^8.16.0"
   },
+  "optionalDependencies": {
+    "@zap-js/darwin-arm64": "0.0.9",
+    "@zap-js/darwin-x64": "0.0.9",
+    "@zap-js/linux-x64": "0.0.9"
+  },
   "peerDependencies": {
     "react": "^18.0.0",
     "react-dom": "^18.0.0"