@qvac/sdk 0.8.0 → 1.0.0

package/dist/client/rpc/expo-rpc-client.js

@@ -1,30 +1,8 @@
 import RPC from "bare-rpc";
-import { RPCConnectionFailedError } from "../../utils/errors-client.js";
-import { initializeConfig } from "../init-hooks.js";
-import { resolveConfig } from "../config-loader/resolve-config.expo.js";
-import { getClientLogger } from "../../logging/index.js";
-import { getDeviceInfo } from "./expo-device-info.js";
-const logger = getClientLogger();
 let rpcInstance = null;
 let rpcPromise = null;
-let workletInstance = null;
-let workletInitialized = false;
-let cachedRuntimeContext;
-logger.debug("EXPO RPC Client bundle");
-async function getRuntimeContext() {
-    if (cachedRuntimeContext) {
-        return cachedRuntimeContext;
-    }
-    const { platform, deviceModel, deviceBrand } = await getDeviceInfo();
-    cachedRuntimeContext = {
-        runtime: "react-native",
-        platform,
-        deviceModel,
-        deviceBrand,
-    };
-    return cachedRuntimeContext;
-}
-export async function getRPC() {
+console.log("EXPO RPC Client bundle");
+export const getRPC = async () => {
     if (rpcInstance) {
         return rpcInstance;
     }
@@ -32,38 +10,25 @@ export async function getRPC() {
         return rpcPromise;
     }
     rpcPromise = (async () => {
-        if (workletInstance) {
-            logger.debug("🔄 Reusing existing worklet");
-            rpcInstance = new RPC(workletInstance.IPC, () => { });
-            // Only initialize once per worklet - server state persists
-            if (!workletInitialized) {
-                const runtimeContext = await getRuntimeContext();
-                await initializeConfig(rpcInstance, resolveConfig, runtimeContext);
-                workletInitialized = true;
-            }
-            return rpcInstance;
-        }
         const { Paths } = await import("expo-file-system");
         const bareKitModule = await import("react-native-bare-kit");
         const worklet = new bareKitModule.Worklet();
-        workletInstance = worklet;
-        logger.debug("Starting new worklet");
-        // Load the mobile bundle - generated by expo plugin during prebuild
-        // The expo plugin handles bundle selection:
-        // 1. Uses qvac/worker.bundle.js if exists (user pre-generated)
-        // 2. Generates tree-shaken bundle if qvac.config.* exists
-        // 3. Generates default bundle (all plugins) otherwise
+        console.log("Starting worklet");
+        // Load the mobile bundle - this will be generated by the Expo plugin
+        // using the user's installed bare library versions
         let mobileBundle;
         try {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            mobileBundle = require("@qvac/sdk/worker.mobile.bundle");
+            // We need require here or the contents of the bundle will be interpreted as a module
+            mobileBundle =
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                require("@qvac/sdk/worker.mobile.bundle");
         }
         catch (error) {
             const message = "Failed to load mobile worker bundle. Make sure the QVAC Expo plugin is configured. " +
                 `Add '@qvac/sdk/expo-plugin' to your app.json plugins array. ` +
                 `Error: ${String(error)}`;
-            logger.error(message);
-            throw new RPCConnectionFailedError(message, error instanceof Error ? error : undefined);
+            console.error(message);
+            throw new Error(message);
         }
         worklet.start("worker.bundle", mobileBundle, [
             // Normalize arg number across platforms
@@ -73,28 +38,20 @@ export async function getRPC() {
                 HOME_DIR: Paths.document.uri.replace("file://", ""),
             }),
         ]);
-        logger.info("Worklet started");
+        console.log("Worklet started");
         rpcInstance = new RPC(worklet.IPC, () => {
             // Use this for async callbacks
         });
-        const runtimeContext = await getRuntimeContext();
-        await initializeConfig(rpcInstance, resolveConfig, runtimeContext);
-        workletInitialized = true;
         return rpcInstance;
     })();
     try {
         return await rpcPromise;
     }
     catch (error) {
-        logger.error(`Failed to initialize RPC: ${String(error)}`);
+        console.error(`Failed to initialize RPC: ${String(error)}`);
         throw error;
     }
     finally {
         rpcPromise = null;
     }
-}
-export function close() {
-    logger.info("🧹 Closing RPC client (Expo)");
-    rpcInstance = null;
-    rpcPromise = null;
-}
+};

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

@@ -1,4 +1,9 @@
-import RPC from "bare-rpc";
-export declare function getRPC(): Promise<RPC>;
-export declare function close(): Promise<void>;
+export declare function getRPC(): {
+    request: (command: number) => {
+        send: (data: string, encoding: BufferEncoding) => void;
+        reply: (encoding: BufferEncoding) => Promise<Buffer>;
+        createResponseStream: () => AsyncGenerator<unknown, void, unknown>;
+    };
+};
+export declare const cleanup: () => void;
 //# sourceMappingURL=node-rpc-client.d.ts.map

package/dist/client/rpc/node-rpc-client.js

@@ -1,191 +1,45 @@
 import RPC from "bare-rpc";
 import spawn, {} from "bare-runtime/spawn";
-import { randomBytes } from "node:crypto";
-import { existsSync, unlinkSync } from "node:fs";
 import { createServer } from "node:net";
-import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { initializeConfig } from "../init-hooks.js";
-import { resolveConfig } from "../config-loader/resolve-config.node.js";
-import { getClientLogger } from "../../logging/index.js";
-const logger = getClientLogger();
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 let rpcInstance = null;
 let rpcPromise = null;
 let bareWorkerProc = null;
-let ipcServer = null;
-let currentSocketPath = null;
-let closePromise = null;
-/**
- * Find project root by looking for package.json (sync version)
- * Safe to call at module load time
- */
-function findProjectRootSync() {
-    let dir = process.cwd();
-    const root = path.parse(dir).root;
-    while (dir !== root) {
-        if (fs.existsSync(path.join(dir, "package.json"))) {
-            return dir;
-        }
-        dir = path.dirname(dir);
-    }
-    return undefined;
-}
-function getResourcesPathSync() {
-    const { resourcesPath } = process;
-    return typeof resourcesPath === "string" ? resourcesPath : undefined;
-}
-function resolvePackagedWorkerPath() {
-    const resourcesPath = getResourcesPathSync();
-    if (!resourcesPath)
-        return undefined;
-    const candidates = [
-        path.join(resourcesPath, "app.asar.unpacked", "qvac", "worker.entry.mjs"),
-        path.join(resourcesPath, "app", "qvac", "worker.entry.mjs"),
-        path.join(resourcesPath, "qvac", "worker.entry.mjs"),
-    ];
-    for (const candidate of candidates) {
-        if (fs.existsSync(candidate))
-            return candidate;
-    }
-    return undefined;
-}
-/**
- * Get default worker path from SDK dist
- */
-function getDefaultWorkerPath() {
-    const packagedWorker = path.resolve(__dirname, "../../server/worker.js");
-    if (fs.existsSync(packagedWorker))
-        return packagedWorker;
-    // Dev/source layout fallback
-    return path.resolve(__dirname, "../../dist/server/worker.js");
-}
-/**
- * Resolve worker path with priority:
- * 1. QVAC_WORKER_PATH environment variable
- * 2. Packaged Electron app worker entry
- * 3. qvac/worker.entry.mjs in project root (generated by npx qvac bundle sdk)
- * 4. Default SDK worker
- */
-function resolveWorkerPath() {
-    const envWorkerPath = process.env["QVAC_WORKER_PATH"];
-    if (envWorkerPath) {
-        const normalized = path.resolve(envWorkerPath);
-        if (fs.existsSync(normalized)) {
-            logger.info(`🔧 Using worker entry from QVAC_WORKER_PATH: ${normalized}`);
-            return normalized;
-        }
-        logger.warn(`⚠️ QVAC_WORKER_PATH was set but file was not found: ${normalized}. Falling back.`);
-    }
-    // Prefer packaged worker entry when running as a packaged Electron app.
-    // This avoids accidental coupling to the project's cwd, and ensures the
-    // bare worker reads JS modules from the filesystem (not app.asar).
-    const packagedWorker = resolvePackagedWorkerPath();
-    if (packagedWorker) {
-        logger.info(`🔧 Using packaged worker entry: ${packagedWorker}`);
-        return packagedWorker;
-    }
-    // Check for custom worker entry at project root
-    // Note: We use worker.entry.mjs (unbundled ESM) for desktop because bare can
-    // load ES modules directly. The packed bundle is for mobile only.
-    const projectRoot = findProjectRootSync();
-    if (projectRoot) {
-        const customEntry = path.join(projectRoot, "qvac", "worker.entry.mjs");
-        if (fs.existsSync(customEntry)) {
-            logger.info(`🔧 Using custom worker entry: ${customEntry}`);
-            return customEntry;
-        }
-    }
-    // Fallback to default SDK worker
-    const defaultPath = getDefaultWorkerPath();
-    logger.debug(`🔧 Using default SDK worker: ${defaultPath}`);
-    return defaultPath;
-}
-const WORKER_PATH = resolveWorkerPath();
-function createSocketPath() {
-    const timestamp = Date.now().toString(36);
-    const randomSuffix = randomBytes(2).toString("hex");
-    const socketName = `qvac-worker-${process.pid}-${timestamp}-${randomSuffix}`;
-    return process.platform === "win32"
-        ? `\\\\.\\pipe\\${socketName}`
-        : path.join(os.tmpdir(), `${socketName}.sock`);
-}
-function bestEffortUnlinkSocket(socketPath) {
-    // Windows named pipes are not filesystem paths, so unlink is Unix-only.
-    if (!socketPath || process.platform === "win32")
-        return;
-    try {
-        if (existsSync(socketPath)) {
-            unlinkSync(socketPath);
-        }
-    }
-    catch (error) {
-        logger.debug("Failed to unlink IPC socket path", { socketPath, error });
-    }
+// Smart path resolution for worker
+let WORKER_PATH;
+if (__dirname.includes("/dist/") || __dirname.includes("\\dist\\")) {
+    const distRoot = __dirname.includes("/dist/")
+        ? __dirname.split("/dist/")[0] + "/dist"
+        : __dirname.split("\\dist\\")[0] + "\\dist";
+    WORKER_PATH = path.join(distRoot, "server/worker.js");
 }
-function snapshotAndResetState() {
-    const workerToClose = bareWorkerProc;
-    const serverToClose = ipcServer;
-    const socketPathToClose = currentSocketPath;
-    rpcInstance = null;
-    rpcPromise = null;
-    bareWorkerProc = null;
-    ipcServer = null;
-    currentSocketPath = null;
-    return { workerToClose, serverToClose, socketPathToClose };
-}
-function closeSyncForExit() {
-    const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
-    if (workerToClose) {
-        try {
-            workerToClose.kill("SIGTERM");
-        }
-        catch (error) {
-            logger.debug("Failed to kill bare worker during process exit", { error });
-        }
-    }
-    if (serverToClose) {
-        try {
-            serverToClose.close();
-        }
-        catch (error) {
-            logger.debug("Failed to close IPC server during process exit", { error });
-        }
-    }
-    bestEffortUnlinkSocket(socketPathToClose);
+else {
+    WORKER_PATH = path.resolve(__dirname, "../../dist/server/worker.js");
 }
+const SOCKET_PATH = process.platform === "win32"
+    ? `\\\\.\\pipe\\qvac-worker-${process.pid}`
+    : path.join(os.tmpdir(), `qvac-worker-${process.pid}.sock`);
 async function ensureRPC() {
     if (rpcInstance)
         return rpcInstance;
     if (rpcPromise)
         return rpcPromise;
-    if (closePromise) {
-        await closePromise;
-    }
-    const socketPath = createSocketPath();
-    currentSocketPath = socketPath;
     rpcPromise = new Promise((resolve, reject) => {
-        ipcServer = createServer((socket) => {
+        const server = createServer((socket) => {
             rpcInstance = new RPC(socket, () => { });
             resolve(rpcInstance);
         });
-        ipcServer.on("error", (error) => {
-            rpcPromise = null;
-            rpcInstance = null;
-            bareWorkerProc = null;
-            ipcServer = null;
-            currentSocketPath = null;
-            reject(error);
-        });
-        ipcServer.listen(socketPath, () => {
+        server.on("error", reject);
+        server.listen(SOCKET_PATH, () => {
             bareWorkerProc = spawn("bare", {
                 args: [
                     WORKER_PATH,
                     JSON.stringify({
-                        QVAC_IPC_SOCKET_PATH: socketPath,
+                        QVAC_IPC_SOCKET_PATH: SOCKET_PATH,
                         HOME_DIR: os.homedir(),
                     }),
                 ],
@@ -193,63 +47,53 @@ async function ensureRPC() {
             });
         });
     });
-    const rpc = await rpcPromise;
-    const runtimeContext = {
-        runtime: "node",
-        platform: process.platform,
-    };
-    await initializeConfig(rpc, resolveConfig, runtimeContext);
-    return rpc;
-}
-export async function getRPC() {
-    return ensureRPC();
+    return rpcPromise;
 }
-export async function close() {
-    if (closePromise) {
-        await closePromise;
-        return;
-    }
-    if (!rpcInstance && !rpcPromise && !bareWorkerProc && !ipcServer)
-        return;
-    logger.info("🧹 Closing RPC client");
-    const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
-    closePromise = (async () => {
-        if (workerToClose) {
-            logger.info("🐻🔫 Killing bare worker process");
-            try {
-                workerToClose.kill("SIGTERM");
-            }
-            catch (error) {
-                logger.debug("Failed to kill bare worker process", { error });
-            }
-        }
-        if (serverToClose) {
-            logger.info("🔌 Closing IPC server");
-            await new Promise((resolve) => {
-                try {
-                    serverToClose.close(() => resolve());
+const mockRPC = {
+    request: (command) => {
+        let sentData = null;
+        return {
+            send: (data, encoding) => {
+                sentData = { data, encoding };
+            },
+            reply: async (encoding) => {
+                if (!sentData) {
+                    throw new Error("Must call send() before reply()");
                 }
-                catch (error) {
-                    logger.debug("Failed to close IPC server", { error });
-                    resolve();
+                const rpc = await ensureRPC();
+                const req = rpc.request(command);
+                req.send(sentData.data, sentData.encoding);
+                const response = await req.reply(encoding);
+                return Buffer.isBuffer(response)
+                    ? response
+                    : Buffer.from(typeof response === "string" ? response : "", encoding);
+            },
+            createResponseStream: async function* () {
+                if (!sentData) {
+                    throw new Error("Must call send() before createResponseStream()");
                 }
-            });
-        }
-        bestEffortUnlinkSocket(socketPathToClose);
-    })();
-    try {
-        await closePromise;
-    }
-    finally {
-        closePromise = null;
-    }
-}
-function handleTerminationSignal(signal) {
-    logger.info(`Received ${signal}, closing RPC resources...`);
-    closeSyncForExit();
-    process.kill(process.pid, signal);
+                const rpc = await ensureRPC();
+                const req = rpc.request(command);
+                req.send(sentData.data, sentData.encoding);
+                const stream = req.createResponseStream({
+                    encoding: sentData.encoding,
+                });
+                for await (const chunk of stream) {
+                    yield chunk;
+                }
+            },
+        };
+    },
+};
+export function getRPC() {
+    return mockRPC;
 }
-process.once("SIGINT", () => handleTerminationSignal("SIGINT"));
-process.once("SIGTERM", () => handleTerminationSignal("SIGTERM"));
-process.once("SIGHUP", () => handleTerminationSignal("SIGHUP"));
-process.once("exit", closeSyncForExit);
+export const cleanup = () => {
+    console.log("🧹 Cleaning up RPC client");
+    if (bareWorkerProc) {
+        console.log("🐻🔫 Killing bare worker process");
+        bareWorkerProc.kill("SIGTERM");
+    }
+};
+// Register cleanup handlers for the parent process
+process.once("exit", cleanup);

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

@@ -1,6 +1,5 @@
 import type RPC from "bare-rpc";
 import { type Request, type Response, type RPCOptions } from "../../schemas/index";
-export declare function send<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): Promise<Response>;
-export declare function stream<T extends Request>(request: T, options?: RPCOptions, rpc?: RPC): AsyncGenerator<Response>;
-export declare function close(): Promise<void>;
+export declare function send<T extends Request>(request: T, rpc?: RPC, options?: RPCOptions): Promise<Response>;
+export declare function stream<T extends Request>(request: T, rpc?: RPC, options?: RPCOptions): AsyncGenerator<Response>;
 //# sourceMappingURL=rpc-client.d.ts.map