@qvac/sdk 0.4.1 → 0.5.0

package/dist/client/config-loader/resolve-config.bare.js

@@ -0,0 +1,87 @@
+/**
+ * Config loader for Bare runtime
+ * Uses bare-fs and bare-path modules
+ */
+import fs from "bare-fs";
+import path from "bare-path";
+import process from "bare-process";
+import { validateConfig, parseJsonConfig, } from "./config-utils.js";
+import { ConfigFileParseFailedError } from "../../utils/errors-client.js";
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
+function findProjectRoot() {
+    return process.cwd();
+}
+function fileExists(filePath) {
+    return fs.existsSync(filePath);
+}
+function readFile(filePath) {
+    const result = fs.readFileSync(filePath, "utf-8");
+    return typeof result === "string" ? result : result.toString("utf-8");
+}
+function loadJsonConfig(filePath) {
+    const content = readFile(filePath);
+    const parsed = parseJsonConfig(content, filePath);
+    return validateConfig(parsed);
+}
+async function loadJsConfig(filePath) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const configModule = await import(filePath);
+        return validateConfig(configModule.default || configModule);
+    }
+    catch (error) {
+        throw new ConfigFileParseFailedError(filePath, error instanceof Error ? error.message : String(error), error);
+    }
+}
+function findConfigFile(searchDir) {
+    const configFiles = [
+        { name: "qvac.config.ts", type: "ts" },
+        { name: "qvac.config.js", type: "js" },
+        { name: "qvac.config.json", type: "json" },
+    ];
+    for (const { name, type } of configFiles) {
+        const filePath = path.resolve(searchDir, name);
+        if (fileExists(filePath)) {
+            return { path: filePath, type };
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolution order for Bare:
+ * 1. QVAC_CONFIG_PATH environment variable
+ * 2. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
+ * 3. SDK defaults
+ */
+export async function resolveConfig() {
+    const configPath = process.env["QVAC_CONFIG_PATH"];
+    if (configPath) {
+        const normalizedPath = path.resolve(configPath);
+        if (fileExists(normalizedPath)) {
+            const ext = normalizedPath.endsWith(".json")
+                ? "json"
+                : normalizedPath.endsWith(".ts")
+                    ? "ts"
+                    : "js";
+            const config = ext === "json"
+                ? loadJsonConfig(normalizedPath)
+                : await loadJsConfig(normalizedPath);
+            logger.info(`✅ Loaded config from: ${normalizedPath}`);
+            return config;
+        }
+    }
+    const projectRoot = findProjectRoot();
+    if (projectRoot) {
+        const configFile = findConfigFile(projectRoot);
+        if (configFile) {
+            const config = configFile.type === "json"
+                ? loadJsonConfig(configFile.path)
+                : await loadJsConfig(configFile.path);
+            logger.info(`✅ Loaded config from: ${configFile.path}`);
+            return config;
+        }
+    }
+    logger.info("ℹ️ No config file found, using SDK defaults");
+    return undefined;
+}

package/dist/client/config-loader/resolve-config.expo.d.ts

@@ -0,0 +1,11 @@
+import { type QvacConfig } from "./config-utils";
+/**
+ * Resolution order for Expo:
+ * 1. QVAC_CONFIG_PATH environment variable (if set)
+ * 2. Default Expo path: ${Paths.document.uri}qvac.config.json
+ * 3. SDK defaults
+ *
+ * Note: Only JSON config files are supported in React Native
+ */
+export declare function resolveConfig(): Promise<QvacConfig | undefined>;
+//# sourceMappingURL=resolve-config.expo.d.ts.map

package/dist/client/config-loader/resolve-config.expo.js

@@ -0,0 +1,62 @@
+/**
+ * Config loader for Expo/React Native runtime
+ * Only uses expo-file-system - no Node.js or Bare imports
+ */
+import { File, Paths } from "expo-file-system";
+import { validateConfig, parseJsonConfig, } from "./config-utils.js";
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
+function fileExists(filePath) {
+    try {
+        const file = new File(filePath);
+        return file.exists;
+    }
+    catch {
+        return false;
+    }
+}
+async function readFile(filePath) {
+    const file = new File(filePath);
+    return await file.text();
+}
+async function loadJsonConfig(filePath) {
+    const content = await readFile(filePath);
+    const parsed = parseJsonConfig(content, filePath);
+    return validateConfig(parsed);
+}
+/**
+ * Resolution order for Expo:
+ * 1. QVAC_CONFIG_PATH environment variable (if set)
+ * 2. Default Expo path: ${Paths.document.uri}qvac.config.json
+ * 3. SDK defaults
+ *
+ * Note: Only JSON config files are supported in React Native
+ */
+export async function resolveConfig() {
+    // Check environment variable first
+    const configPath = typeof process !== "undefined"
+        ? process.env?.["QVAC_CONFIG_PATH"]
+        : undefined;
+    if (configPath) {
+        if (fileExists(configPath)) {
+            logger.info(`✅ Loaded config from: ${configPath}`);
+            return await loadJsonConfig(configPath);
+        }
+    }
+    // Try default Expo document directory path
+    try {
+        const documentDir = Paths.document.uri;
+        if (documentDir) {
+            const defaultExpoConfigPath = `${documentDir}qvac.config.json`;
+            if (fileExists(defaultExpoConfigPath)) {
+                logger.info(`✅ Loaded config from: ${defaultExpoConfigPath}`);
+                return await loadJsonConfig(defaultExpoConfigPath);
+            }
+        }
+    }
+    catch {
+        // Paths not available
+    }
+    logger.info("ℹ️ No config file found, using SDK defaults");
+    return undefined;
+}

package/dist/client/config-loader/resolve-config.node.d.ts

@@ -0,0 +1,9 @@
+import { type QvacConfig } from "./config-utils";
+/**
+ * Resolution order for Node.js:
+ * 1. QVAC_CONFIG_PATH environment variable
+ * 2. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
+ * 3. SDK defaults
+ */
+export declare function resolveConfig(): Promise<QvacConfig | undefined>;
+//# sourceMappingURL=resolve-config.node.d.ts.map

package/dist/client/config-loader/resolve-config.node.js

@@ -0,0 +1,118 @@
+/**
+ * Config loader for Node.js runtime
+ * Uses Node.js fs/promises and path modules
+ */
+import { promises as fs } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { validateConfig, parseJsonConfig, } from "./config-utils.js";
+import { ConfigFileParseFailedError } from "../../utils/errors-client.js";
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
+async function findProjectRoot() {
+    try {
+        let currentDir = path.resolve(process.cwd());
+        const root = path.parse(currentDir).root;
+        while (currentDir !== root) {
+            try {
+                const packageJsonPath = path.join(currentDir, "package.json");
+                await fs.access(packageJsonPath);
+                return currentDir;
+            }
+            catch {
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir) {
+                    break;
+                }
+                currentDir = parentDir;
+            }
+        }
+    }
+    catch {
+        // Fall through
+    }
+    return process.cwd();
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readFile(filePath) {
+    return await fs.readFile(filePath, { encoding: "utf-8" });
+}
+async function loadJsonConfig(filePath) {
+    const content = await readFile(filePath);
+    const parsed = parseJsonConfig(content, filePath);
+    return validateConfig(parsed);
+}
+async function loadJsConfig(filePath) {
+    try {
+        let importPath = filePath;
+        // Windows requires file:// URLs for dynamic imports
+        if (process.platform === "win32" && !process.env["JEST_WORKER_ID"]) {
+            importPath = pathToFileURL(filePath).toString();
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const configModule = await import(importPath);
+        return validateConfig(configModule.default || configModule);
+    }
+    catch (error) {
+        throw new ConfigFileParseFailedError(filePath, error instanceof Error ? error.message : String(error), error);
+    }
+}
+async function findConfigFile(searchDir) {
+    const configFiles = [
+        { name: "qvac.config.ts", type: "ts" },
+        { name: "qvac.config.js", type: "js" },
+        { name: "qvac.config.json", type: "json" },
+    ];
+    for (const { name, type } of configFiles) {
+        const filePath = path.resolve(searchDir, name);
+        if (await fileExists(filePath)) {
+            return { path: filePath, type };
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolution order for Node.js:
+ * 1. QVAC_CONFIG_PATH environment variable
+ * 2. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
+ * 3. SDK defaults
+ */
+export async function resolveConfig() {
+    const configPath = process.env["QVAC_CONFIG_PATH"];
+    if (configPath) {
+        const normalizedPath = path.resolve(configPath);
+        if (await fileExists(normalizedPath)) {
+            const ext = normalizedPath.endsWith(".json")
+                ? "json"
+                : normalizedPath.endsWith(".ts")
+                    ? "ts"
+                    : "js";
+            const config = ext === "json"
+                ? await loadJsonConfig(normalizedPath)
+                : await loadJsConfig(normalizedPath);
+            logger.info(`✅ Loaded config from: ${normalizedPath}`);
+            return config;
+        }
+    }
+    const projectRoot = await findProjectRoot();
+    if (projectRoot) {
+        const configFile = await findConfigFile(projectRoot);
+        if (configFile) {
+            const config = configFile.type === "json"
+                ? await loadJsonConfig(configFile.path)
+                : await loadJsConfig(configFile.path);
+            logger.info(`✅ Loaded config from: ${configFile.path}`);
+            return config;
+        }
+    }
+    logger.info("ℹ️ No config file found, using SDK defaults");
+    return undefined;
+}

package/dist/client/init-hooks.d.ts

@@ -1,6 +1,20 @@
+import type { QvacConfig } from "../schemas/index";
+type ResolveConfigFn = () => Promise<QvacConfig | undefined>;
+interface RPCClient {
+    request(command: number): any;
+}
 /**
- * Replays cached configuration to the worker after initialization.
- * This ensures config persists across worker restarts.
+ * Loads configuration from file and sends it to the worker during initialization.
+ * Config is loaded once and becomes immutable on the worker side.
+ *
+ * @param rpc - The RPC client instance
+ * @param resolveConfig - Runtime-specific config resolver function
  */
-export declare const replayConfigIfCached: (rpc: any) => Promise<void>;
+export declare function initializeConfig(rpc: RPCClient, resolveConfig: ResolveConfigFn): Promise<void>;
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use initializeConfig instead
+ */
+export declare function replayConfigIfCached(): void;
+export {};
 //# sourceMappingURL=init-hooks.d.ts.map

package/dist/client/init-hooks.js

@@ -1,37 +1,56 @@
-import { getCachedConfig } from "./config-manager.js";
+import { getClientLogger, setGlobalLogLevel, setGlobalConsoleOutput, } from "../logging/index.js";
+const logger = getClientLogger();
 /**
- * Replays cached configuration to the worker after initialization.
- * This ensures config persists across worker restarts.
+ * Loads configuration from file and sends it to the worker during initialization.
+ * Config is loaded once and becomes immutable on the worker side.
+ *
+ * @param rpc - The RPC client instance
+ * @param resolveConfig - Runtime-specific config resolver function
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const replayConfigIfCached = async (rpc) => {
-    const config = getCachedConfig();
+export async function initializeConfig(rpc, resolveConfig) {
+    const config = await resolveConfig();
     if (!config) {
-        console.log("No cached config to replay");
+        // No config found - worker will use defaults
         return;
     }
-    console.log("🔄 Replaying cached config to worker:", config);
+    // Apply logger settings on client
+    if (config.loggerLevel !== undefined) {
+        setGlobalLogLevel(config.loggerLevel);
+    }
+    if (config.loggerConsoleOutput !== undefined) {
+        setGlobalConsoleOutput(config.loggerConsoleOutput);
+    }
+    logger.info("📦 Initializing config:", config);
     try {
-        const request = {
-            type: "setConfig",
+        // Send config to worker via internal init message
+        // This bypasses the normal RPC flow since it's part of initialization
+        const initMessage = {
+            type: "__init_config",
             config,
         };
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
         const req = rpc.request(1);
         // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        req.send(JSON.stringify(request), "utf8");
+        req.send(JSON.stringify(initMessage), "utf8");
         // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
         const response = await req.reply("utf8");
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
         const parsed = JSON.parse(response.toString());
-        if (parsed.type !== "setConfig" || !parsed.success) {
-            console.error("Failed to replay config:", parsed.error);
+        if (!parsed.success) {
+            logger.error("❌ Failed to initialize config:", parsed.error);
         }
         else {
-            console.log("✅ Config successfully replayed to worker");
+            logger.info("✅ Config successfully initialized");
         }
     }
     catch (error) {
-        console.error("Error replaying config:", error);
+        logger.error("❌ Error initializing config:", error);
     }
-};
+}
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use initializeConfig instead
+ */
+export function replayConfigIfCached() {
+    logger.warn("⚠️ replayConfigIfCached is deprecated and has no effect. Config is now loaded from file during initialization.");
+}

package/dist/client/logging-stream-registry.d.ts

@@ -1,5 +1,5 @@
 import { type Logger } from "../logging/index";
-export declare function startLoggingStreamForModel(modelId: string, logger: Logger): void;
+export declare function startLoggingStreamForModel(modelId: string, modelLogger: Logger): void;
 export declare function stopLoggingStreamForModel(modelId: string): void;
 export declare function hasActiveStreamForModel(modelId: string): boolean;
 //# sourceMappingURL=logging-stream-registry.d.ts.map

package/dist/client/logging-stream-registry.js

@@ -1,13 +1,14 @@
-import {} from "../logging/index.js";
+import { getClientLogger } from "../logging/index.js";
 import { loggingStream } from "./api/logging-stream.js";
+const logger = getClientLogger();
 const activeStreams = new Map();
-export function startLoggingStreamForModel(modelId, logger) {
+export function startLoggingStreamForModel(modelId, modelLogger) {
     if (activeStreams.has(modelId)) {
-        console.warn(`Logging stream already active for model ${modelId}`);
+        logger.warn(`Logging stream already active for model ${modelId}`);
         return;
     }
-    const streamIterator = loggingStream({ modelId });
-    activeStreams.set(modelId, { logger, streamIterator });
+    const streamIterator = loggingStream({ id: modelId });
+    activeStreams.set(modelId, { logger: modelLogger, streamIterator });
     try {
         void (async () => {
             try {
@@ -15,24 +16,24 @@ export function startLoggingStreamForModel(modelId, logger) {
                     const logLevel = logMessage.level;
                     switch (logLevel) {
                         case "error":
-                            logger.error(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.error(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         case "warn":
-                            logger.warn(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.warn(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         case "info":
-                            logger.info(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.info(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         case "debug":
-                            logger.debug(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.debug(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         default:
-                            logger.info(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.info(`[${logMessage.namespace}]`, logMessage.message);
                     }
                 }
             }
             catch (error) {
-                console.error(`Logging stream error for model ${modelId}:`, error);
+                logger.error(`Logging stream error for model ${modelId}:`, error);
             }
             finally {
                 activeStreams.delete(modelId);
@@ -40,7 +41,7 @@ export function startLoggingStreamForModel(modelId, logger) {
         })();
     }
     catch (error) {
-        console.error(`Failed to start logging stream for model ${modelId}:`, error);
+        logger.error(`Failed to start logging stream for model ${modelId}:`, error);
         activeStreams.delete(modelId);
         throw error;
     }
@@ -52,7 +53,7 @@ export function stopLoggingStreamForModel(modelId) {
         // Terminate the stream iterator - this will close the RPC connection
         // and the server-side async generator will automatically terminate
         void stream.streamIterator.return(undefined);
-        console.debug(`Stopped logging stream for model ${modelId}`);
+        logger.debug(`Stopped logging stream for model ${modelId}`);
     }
 }
 export function hasActiveStreamForModel(modelId) {

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

@@ -44,6 +44,11 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
     type: "textToSpeech";
     buffer: number[];
     done: boolean;
+} | {
+    type: "loadModel";
+    success: boolean;
+    modelId?: string | undefined;
+    error?: string | undefined;
 } | {
     type: "modelProgress";
     downloaded: number;
@@ -58,11 +63,6 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
         overallTotal: number;
         overallPercentage: number;
     } | undefined;
-} | {
-    type: "loadModel";
-    success: boolean;
-    modelId?: string | undefined;
-    error?: string | undefined;
 } | {
     type: "downloadAsset";
     success: boolean;
@@ -71,11 +71,11 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
 } | {
     type: "embed";
     success: boolean;
-    embedding: number[];
+    embedding: number[] | number[][];
     error?: string | undefined;
 } | {
     type: "loggingStream";
-    modelId: string;
+    id: string;
     level: "error" | "warn" | "info" | "debug" | "off";
     namespace: string;
     message: string;
@@ -146,10 +146,6 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
     success: boolean;
     operation: "deleteEmbeddings";
     error?: string | undefined;
-} | {
-    type: "setConfig";
-    success: boolean;
-    error?: string | undefined;
 } | {
     type: "getModelInfo";
     modelInfo: {
@@ -159,7 +155,7 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
         hyperbeeKey: string;
         expectedSize: number;
         sha256Checksum: string;
-        addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts";
+        addon: "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "vad";
         isCached: boolean;
         isLoaded: boolean;
         cacheFiles: {
@@ -180,11 +176,11 @@ export declare function stream<T extends Request>(request: T): AsyncGenerator<{
         }[] | undefined;
     };
 }, void, any>;
-export declare function getRPC(): {
+export declare function getRPC(): Promise<{
     request(): {
         send(payload: string): void;
         reply(): Promise<Buffer<ArrayBuffer>>;
         createResponseStream(): AsyncGenerator<Buffer<ArrayBuffer>, void, unknown>;
     };
-};
+}>;
 //# sourceMappingURL=bare-client.d.ts.map

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

@@ -1,5 +1,8 @@
 import { handlers } from "../../server/rpc/handlers/index.js";
 import { RPCNoHandlerError, RPCRequestNotSentError, } from "../../utils/errors-client.js";
+import { initializeConfig } from "../init-hooks.js";
+import { setSDKConfig } from "../../server/bare/registry/config-registry.js";
+import { resolveConfig } from "../config-loader/resolve-config.bare.js";
 // Get the handler for a request type
 const getHandler = (type) => {
     const handler = handlers[type];
@@ -97,6 +100,22 @@ const createMockRPCRequest = () => {
             if (!requestData) {
                 throw new RPCRequestNotSentError();
             }
+            // Handle special internal config initialization message
+            if (typeof requestData === "object" &&
+                "type" in requestData &&
+                requestData.type === "__init_config") {
+                try {
+                    const configData = requestData;
+                    setSDKConfig(configData.config);
+                    return Buffer.from(JSON.stringify({ success: true }));
+                }
+                catch (error) {
+                    return Buffer.from(JSON.stringify({
+                        success: false,
+                        error: error instanceof Error ? error.message : String(error),
+                    }));
+                }
+            }
             const response = await send(requestData);
             return Buffer.from(JSON.stringify(response));
         },
@@ -110,10 +129,17 @@ const createMockRPCRequest = () => {
         },
     };
 };
-export function getRPC() {
-    return {
+let configInitialized = false;
+export async function getRPC() {
+    const mockRPC = {
         request() {
             return createMockRPCRequest();
         },
     };
+    // Initialize config once on first call
+    if (!configInitialized) {
+        await initializeConfig(mockRPC, resolveConfig);
+        configInitialized = true;
+    }
+    return mockRPC;
 }

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

@@ -1,4 +1,4 @@
 import RPC from "bare-rpc";
 export declare function getRPC(): Promise<RPC>;
-export declare const cleanup: () => void;
+export declare function cleanup(): void;
 //# sourceMappingURL=bare-rpc-client.d.ts.map