@qvac/sdk 0.1.0-dev.1760648187.328e967

package/dist/server/rpc/handlers/provideHandler/connection.js

@@ -0,0 +1,25 @@
+import RPC from "bare-rpc";
+import { createRpcProxy } from "./proxy.js";
+export function setupConnectionHandlers(swarm) {
+    console.log("👂 Setting up connection listener...");
+    swarm.on("close", () => {
+        console.log("🔗 Connection closed!");
+    });
+    swarm.on("connection", (conn) => {
+        console.log("🔗 Connection event triggered!");
+        const peerPubkey = conn.remotePublicKey?.toString("hex");
+        console.log(`📡 New connection established from: ${peerPubkey?.substring(0, 16)}...`);
+        console.log("🔐 Full peer public key:", peerPubkey);
+        // Create RPC instance for this connection (as server)
+        console.log("⚙️ Creating RPC instance for connection...");
+        new RPC(conn, createRpcProxy());
+        console.log("✅ RPC instance created successfully");
+        conn.on("close", () => {
+            console.log(`🔌 Connection closed for peer: ${peerPubkey?.substring(0, 16)}`);
+        });
+        conn.on("error", (err) => {
+            console.error(`❌ Connection error for peer ${peerPubkey?.substring(0, 16)}:`, err);
+        });
+    });
+    console.log("✅ Connection listener set up");
+}

package/dist/server/rpc/handlers/provideHandler/handler.d.ts

@@ -0,0 +1,3 @@
+import type { ProvideRequest, ProvideResponse } from "../../../../schemas/provide";
+export declare function provideHandler(request: ProvideRequest): Promise<ProvideResponse>;
+//# sourceMappingURL=handler.d.ts.map

package/dist/server/rpc/handlers/provideHandler/handler.js

@@ -0,0 +1,50 @@
+import { getSwarm } from "../../../bare/hyperswarm.js";
+import { setupConnectionHandlers } from "./connection.js";
+export async function provideHandler(request) {
+    const swarm = getSwarm({
+        firewallConfig: request.firewall,
+    });
+    console.log("🚀 Provide request received:", request);
+    console.log("🔍 Swarm keyPair exists:", !!swarm.keyPair);
+    console.log("🔍 Swarm publicKey:", swarm.keyPair?.publicKey?.toString("hex")?.substring(0, 16));
+    try {
+        console.log("⚡ Starting provide handler execution");
+        const pubKey = swarm.keyPair.publicKey;
+        console.log("🔑 Got public key:", pubKey.toString("hex"));
+        // Use provided topic from hex string
+        const topic = Buffer.from(request.topic, "hex");
+        // Join topic as server (provider)
+        console.log("🌐 Joining topic as server...");
+        const discovery = swarm.join(topic, { server: true, client: false });
+        console.log("📡 Discovery object created:", !!discovery);
+        // Wait for the topic to be fully announced on the DHT
+        console.log("⏳ Waiting for topic announcement...");
+        await discovery.flushed();
+        console.log(`✅ Topic announced: ${topic.toString("hex")}`);
+        // Wait for connections
+        console.log("⏳ Waiting for swarm flush...");
+        await swarm.flush();
+        console.log(`🎯 Ready to accept connections on topic: ${topic.toString("hex").substring(0, 16)}...`);
+        // Handle incoming connections
+        setupConnectionHandlers(swarm);
+        console.log("🏁 About to return success response...");
+        const response = {
+            type: "provide",
+            success: true,
+            publicKey: pubKey.toString("hex"),
+        };
+        console.log("📤 Returning response:", response);
+        return response;
+    }
+    catch (error) {
+        console.error("❌ Error in provide handler:", error);
+        console.error("❌ Error stack:", error instanceof Error ? error.stack : "No stack trace");
+        const errorResponse = {
+            type: "provide",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+        console.log("📤 Returning error response:", errorResponse);
+        return errorResponse;
+    }
+}

package/dist/server/rpc/handlers/provideHandler/proxy.d.ts

@@ -0,0 +1,3 @@
+import type RPC from "bare-rpc";
+export declare function createRpcProxy(): (rpcRequest: RPC.IncomingRequest) => Promise<void>;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/server/rpc/handlers/provideHandler/proxy.js

@@ -0,0 +1,22 @@
+import { handleRequest } from "../../handle-request.js";
+// Proxies RPC requests to the main handler: handleRequest
+export function createRpcProxy() {
+    return async (rpcRequest) => {
+        console.log("📬 RPC request callback triggered!");
+        console.log("📦 Raw RPC request data:", rpcRequest.data?.toString());
+        try {
+            console.log("🚀 Calling handleRequest...");
+            await handleRequest(rpcRequest);
+            console.log("✅ handleRequest completed successfully");
+        }
+        catch (error) {
+            console.error("❌ Error:", error instanceof Error ? error.message : error);
+            const errorResponse = JSON.stringify({
+                type: "error",
+                error: error instanceof Error ? error.message : "Unknown error",
+            });
+            console.log("📤 Sending error response:", errorResponse);
+            rpcRequest.reply(errorResponse, "utf-8");
+        }
+    };
+}

package/dist/server/rpc/handlers/provideHandler.d.ts

@@ -0,0 +1,2 @@
+export { provideHandler } from "./provideHandler/handler";
+//# sourceMappingURL=provideHandler.d.ts.map

package/dist/server/rpc/handlers/provideHandler.js

@@ -0,0 +1,2 @@
+// Re-export the provideHandler from the refactored provideHandler modules
+export { provideHandler } from "./provideHandler/handler.js";

package/dist/server/rpc/handlers/rag.d.ts

@@ -0,0 +1,3 @@
+import type { RagRequest, RagResponse } from "../../../schemas/index";
+export declare function handleRag(request: RagRequest): Promise<RagResponse>;
+//# sourceMappingURL=rag.d.ts.map

package/dist/server/rpc/handlers/rag.js

@@ -0,0 +1,67 @@
+import { saveEmbeddings, search, deleteEmbeddings, } from "../../bare/rag-hyperdb/index.js";
+export async function handleRag(request) {
+    try {
+        switch (request.operation) {
+            case "saveEmbeddings": {
+                const result = await saveEmbeddings(request);
+                return {
+                    type: "rag",
+                    operation: request.operation,
+                    success: true,
+                    processed: result.processed,
+                    droppedIndices: result.droppedIndices,
+                };
+            }
+            case "search": {
+                const results = await search(request);
+                return {
+                    type: "rag",
+                    operation: request.operation,
+                    success: true,
+                    results,
+                };
+            }
+            case "deleteEmbeddings": {
+                const success = await deleteEmbeddings(request);
+                return {
+                    type: "rag",
+                    operation: request.operation,
+                    success,
+                };
+            }
+            default: {
+                throw new Error(`Unknown RAG operation`);
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error in RAG handler:", error);
+        const baseError = {
+            type: "rag",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+        switch (request.operation) {
+            case "saveEmbeddings":
+                return {
+                    ...baseError,
+                    operation: request.operation,
+                    processed: [],
+                    droppedIndices: [],
+                };
+            case "search":
+                return {
+                    ...baseError,
+                    operation: request.operation,
+                    results: [],
+                };
+            case "deleteEmbeddings":
+                return {
+                    ...baseError,
+                    operation: request.operation,
+                };
+            default:
+                throw error;
+        }
+    }
+}

package/dist/server/rpc/handlers/transcribe-stream.d.ts

@@ -0,0 +1,3 @@
+import type { TranscribeStreamRequest, TranscribeStreamResponse } from "../../../schemas/index";
+export declare function handleTranscribeStream(request: TranscribeStreamRequest): AsyncGenerator<TranscribeStreamResponse>;
+//# sourceMappingURL=transcribe-stream.d.ts.map

package/dist/server/rpc/handlers/transcribe-stream.js

@@ -0,0 +1,26 @@
+import { transcribeStream } from "../../bare/addons/whispercpp/index.js";
+export async function* handleTranscribeStream(request) {
+    const { modelId, audioChunk } = request;
+    try {
+        // Stream transcription results in real-time
+        for await (const textChunk of transcribeStream({ audioChunk, modelId })) {
+            yield {
+                type: "transcribeStream",
+                text: textChunk,
+            };
+        }
+        // Signal completion
+        yield {
+            type: "transcribeStream",
+            done: true,
+        };
+    }
+    catch (error) {
+        console.error("Error during transcription:", error);
+        yield {
+            type: "transcribeStream",
+            text: "",
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

package/dist/server/rpc/handlers/translate.d.ts

@@ -0,0 +1,3 @@
+import type { TranslateRequest, TranslateResponse } from "../../../schemas/index";
+export declare function handleTranslate(request: TranslateRequest): AsyncGenerator<TranslateResponse>;
+//# sourceMappingURL=translate.d.ts.map

package/dist/server/rpc/handlers/translate.js

@@ -0,0 +1,51 @@
+import { translate } from "../../bare/addons/translation/index.js";
+export async function* handleTranslate(request) {
+    const { modelId, text, stream, modelType } = request;
+    const from = request.modelType === "llm" ? request.from : undefined;
+    const to = request.modelType === "llm" ? request.to : undefined;
+    const context = request.modelType === "llm" ? request.context : undefined;
+    try {
+        const generator = translate({
+            modelId,
+            text,
+            from,
+            to: to,
+            stream,
+            modelType,
+            context,
+        });
+        let stats;
+        let done = false;
+        let buffer = "";
+        while (!done) {
+            const result = await generator.next();
+            if (result.done) {
+                stats = result.value;
+                done = true;
+            }
+            else {
+                buffer += result.value;
+                if (stream) {
+                    yield {
+                        type: "translate",
+                        token: result.value,
+                    };
+                }
+            }
+        }
+        yield {
+            type: "translate",
+            token: buffer,
+            done: true,
+            stats,
+        };
+    }
+    catch (error) {
+        console.error("Error during translation:", error);
+        yield {
+            type: "translate",
+            token: "",
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

package/dist/server/rpc/handlers/unload-model.d.ts

@@ -0,0 +1,3 @@
+import type { UnloadModelRequest, UnloadModelResponse } from "../../../schemas/index";
+export declare function handleUnloadModel(request: UnloadModelRequest): Promise<UnloadModelResponse>;
+//# sourceMappingURL=unload-model.d.ts.map

package/dist/server/rpc/handlers/unload-model.js

@@ -0,0 +1,20 @@
+import { unloadModel } from "../../bare/addons/index.js";
+export async function handleUnloadModel(request) {
+    const { modelId, clearStorage } = request;
+    try {
+        console.log("Unloading model", modelId);
+        await unloadModel({ modelId, clearStorage });
+        return {
+            type: "unloadModel",
+            success: true,
+        };
+    }
+    catch (error) {
+        console.error("Error during model unload:", error);
+        return {
+            type: "unloadModel",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}

package/dist/server/rpc/index.d.ts

@@ -0,0 +1,3 @@
+export { createBareKitRPCServer, createIPCClient } from "./create-server";
+export { handleRequest, type BareRPCRequest } from "./handle-request";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/rpc/index.js

@@ -0,0 +1,2 @@
+export { createBareKitRPCServer, createIPCClient } from "./create-server.js";
+export { handleRequest } from "./handle-request.js";

package/dist/server/utils/audio/decoder.d.ts

@@ -0,0 +1,4 @@
+import { Readable } from "bare-stream";
+export declare function needsDecoding(filePath: string): boolean;
+export declare function decodeAudioToStream(inputPath: string): Promise<Readable>;
+//# sourceMappingURL=decoder.d.ts.map

package/dist/server/utils/audio/decoder.js

@@ -0,0 +1,41 @@
+import fs from "bare-fs";
+import path from "bare-path";
+import GSTDecoder from "@qvac/decoder-audio";
+import { Readable } from "bare-stream";
+import { FORMATS_NEEDING_DECODE } from "../../../constants/audio.js";
+export function needsDecoding(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return FORMATS_NEEDING_DECODE.includes(ext);
+}
+export async function decodeAudioToStream(inputPath) {
+    const decoder = new GSTDecoder({
+        config: {
+            audioFormat: "encoded",
+        },
+    });
+    try {
+        await decoder.load();
+        const audioStream = fs.createReadStream(inputPath);
+        const response = await decoder.run(audioStream);
+        const outputStream = new Readable({
+            read() { },
+        });
+        response
+            .onUpdate((output) => {
+            const bytes = new Uint8Array(output.outputArray);
+            outputStream.push(Buffer.from(bytes));
+        })
+            .onFinish(() => {
+            outputStream.push(null);
+        })
+            .await()
+            .catch((error) => {
+            outputStream.destroy(error instanceof Error ? error : new Error(String(error)));
+        });
+        return outputStream;
+    }
+    catch (error) {
+        console.error("Decoding failed:", error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+}

package/dist/server/utils/cache.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Creates and returns cache directory path for the specified subdirectory
+ * @param subDir - Subdirectory name (e.g., "models", "kv-cache")
+ * @returns Full path to the cache directory
+ */
+export declare function getCacheDir(subDir: string): string;
+/**
+ * Legacy function for backward compatibility - gets models cache directory
+ */
+export declare function getModelsCacheDir(): string;
+/**
+ * Gets KV cache directory
+ */
+export declare function getKVCacheDir(): string;
+//# sourceMappingURL=cache.d.ts.map

package/dist/server/utils/cache.js

@@ -0,0 +1,32 @@
+import fs from "bare-fs";
+import path from "bare-path";
+import { getEnv } from "../worker.js";
+/**
+ * Creates and returns cache directory path for the specified subdirectory
+ * @param subDir - Subdirectory name (e.g., "models", "kv-cache")
+ * @returns Full path to the cache directory
+ */
+export function getCacheDir(subDir) {
+    const homeDir = getEnv().HOME_DIR;
+    const cacheDir = path.join(homeDir, ".qvac", subDir);
+    // Ensure cache directory exists
+    try {
+        fs.mkdirSync(cacheDir, { recursive: true });
+    }
+    catch (error) {
+        console.error(`Error creating cache directory (${subDir}):`, error instanceof Error ? error.message : String(error));
+    }
+    return cacheDir;
+}
+/**
+ * Legacy function for backward compatibility - gets models cache directory
+ */
+export function getModelsCacheDir() {
+    return getCacheDir("models");
+}
+/**
+ * Gets KV cache directory
+ */
+export function getKVCacheDir() {
+    return getCacheDir("kv-cache");
+}

package/dist/server/utils/hash.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generate a short hash (16 characters) from any input string
+ */
+export declare function generateShortHash(input: string): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/server/utils/hash.js

@@ -0,0 +1,11 @@
+import crypto from "bare-crypto";
+/**
+ * Generate a short hash (16 characters) from any input string
+ */
+export function generateShortHash(input) {
+    const hash = crypto
+        .createHash("sha256")
+        .update(Buffer.from(input, "utf8"))
+        .digest("hex");
+    return hash.substring(0, 16);
+}

package/dist/server/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./audio/decoder";
+export * from "./cache";
+export * from "./hash";
+export * from "./model-path";
+//# sourceMappingURL=index.d.ts.map

package/dist/server/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./audio/decoder.js";
+export * from "./cache.js";
+export * from "./hash.js";
+export * from "./model-path.js";

package/dist/server/utils/model-path.d.ts

@@ -0,0 +1,5 @@
+export declare function parseModelPath(modelPath: string): {
+    dirPath: string;
+    basePath: string;
+};
+//# sourceMappingURL=model-path.d.ts.map

package/dist/server/utils/model-path.js

@@ -0,0 +1,7 @@
+import path from "bare-path";
+export function parseModelPath(modelPath) {
+    return {
+        dirPath: path.dirname(modelPath),
+        basePath: path.basename(modelPath),
+    };
+}

package/dist/server/worker.d.ts

@@ -0,0 +1,6 @@
+export declare function getEnv(): {
+    HOME_DIR: string;
+    QVAC_IPC_SOCKET_PATH?: string | undefined;
+};
+export declare function ensureRPCSetup(): void;
+//# sourceMappingURL=worker.d.ts.map

package/dist/server/worker.js

@@ -0,0 +1,77 @@
+import process from "bare-process";
+import { createBareKitRPCServer, createIPCClient, } from "./rpc/create-server.js";
+import { z } from "zod";
+import { destroySwarm } from "./bare/hyperswarm.js";
+console.log("🐻 Hello from Bare");
+console.log("Arguments to worker:", process.argv);
+const defaultHomeDir = process.env["HOME"] || process.env["USERPROFILE"] || "/tmp";
+let envConfig = { HOME_DIR: defaultHomeDir };
+let hasRPCConfig = false;
+// Try to parse any argument as JSON config (fail gracefully)
+if (process.argv[2]) {
+    try {
+        const rpcArgs = JSON.parse(process.argv[2]);
+        envConfig = { ...envConfig, ...rpcArgs };
+        hasRPCConfig = true;
+        console.log("Parsed RPC configuration from arguments");
+    }
+    catch {
+        // Not JSON or invalid - use defaults (direct mode)
+        console.log("Using default configuration (direct mode)");
+    }
+}
+const validatedEnv = z
+    .object({
+    QVAC_IPC_SOCKET_PATH: z.string().optional(),
+    HOME_DIR: z.string(),
+})
+    .parse(envConfig);
+export function getEnv() {
+    return {
+        ...process.env,
+        ...validatedEnv,
+    };
+}
+let rpcInitialized = false;
+export function ensureRPCSetup() {
+    if (rpcInitialized)
+        return;
+    try {
+        const ipcSocketPath = validatedEnv.QVAC_IPC_SOCKET_PATH;
+        if (ipcSocketPath) {
+            console.log(`Running in desktop mode, connecting to IPC socket: ${ipcSocketPath}`);
+            // Connect to the IPC server (Named Pipe or Unix Socket)
+            const rpc = createIPCClient(ipcSocketPath);
+            console.log("Desktop IPC client created?", !!rpc);
+        }
+        else {
+            console.log("Running in BareKit IPC mode");
+            // Start the standard RPC server with BareKit IPC for mobile
+            createBareKitRPCServer();
+        }
+        console.log("Bare worker started and listening for RPC requests");
+        console.log("Working directory:", process.cwd());
+        rpcInitialized = true;
+    }
+    catch (error) {
+        console.error("Worker error:", error);
+        process.exit(1);
+    }
+}
+// Auto-setup RPC only if we successfully parsed RPC configuration
+if (hasRPCConfig) {
+    ensureRPCSetup();
+}
+else {
+    console.log("Running in direct mode - RPC setup will be lazy");
+}
+process.on("SIGTERM", () => {
+    console.log("🐻 Bare worker SIGTERM received, cleaning up...");
+    destroySwarm()
+        .then(() => {
+        process.exit(0);
+    })
+        .catch((err) => {
+        throw err;
+    });
+});

package/dist/utils/withTimeout.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wraps a promise with an optional timeout
+ * If no timeout is provided, returns the original promise unchanged
+ */
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs?: number): Promise<T>;
+/**
+ * Wraps an async generator with optional timeout per iteration
+ * If no timeout is provided, returns the original generator unchanged
+ */
+export declare function withTimeoutStream<T>(generator: AsyncGenerator<T>, timeoutMs?: number): AsyncGenerator<T>;
+//# sourceMappingURL=withTimeout.d.ts.map

package/dist/utils/withTimeout.js

@@ -0,0 +1,37 @@
+/**
+ * Creates a timeout promise that rejects after the specified duration
+ */
+function createTimeoutPromise(timeoutMs) {
+    return new Promise((_, reject) => {
+        setTimeout(() => {
+            reject(new Error(`Operation timeout after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+}
+/**
+ * Wraps a promise with an optional timeout
+ * If no timeout is provided, returns the original promise unchanged
+ */
+export async function withTimeout(promise, timeoutMs) {
+    if (timeoutMs === undefined) {
+        return promise;
+    }
+    const timeoutPromise = createTimeoutPromise(timeoutMs);
+    return Promise.race([promise, timeoutPromise]);
+}
+/**
+ * Wraps an async generator with optional timeout per iteration
+ * If no timeout is provided, returns the original generator unchanged
+ */
+export async function* withTimeoutStream(generator, timeoutMs) {
+    if (timeoutMs === undefined) {
+        yield* generator;
+        return;
+    }
+    for await (const item of generator) {
+        const itemPromise = Promise.resolve(item);
+        const timeoutPromise = createTimeoutPromise(timeoutMs);
+        const result = await Promise.race([itemPromise, timeoutPromise]);
+        yield result;
+    }
+}