@qvac/sdk 0.6.0 → 0.7.0

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

@@ -0,0 +1,3 @@
+export function handlePing() {
+    return { type: "pong", number: Math.random() * 100 };
+}

package/dist/server/rpc/handlers/plugin-dispatch.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Dispatches a request to a plugin handler and returns a Promise.
+ * Use for non-streaming (reply) handlers.
+ *
+ * @throws PluginHandlerTypeMismatchError if the handler is streaming
+ */
+export declare function dispatchPluginReply<TRequest, TResponse>(modelId: string, handlerName: string, request: TRequest): Promise<TResponse>;
+/**
+ * Dispatches a request to a plugin handler and returns an AsyncGenerator.
+ * Use for streaming handlers.
+ *
+ * @throws PluginHandlerTypeMismatchError if the handler is not streaming
+ */
+export declare function dispatchPluginStream<TRequest, TResponse>(modelId: string, handlerName: string, request: TRequest): AsyncGenerator<TResponse>;
+//# sourceMappingURL=plugin-dispatch.d.ts.map

package/dist/server/rpc/handlers/plugin-dispatch.js

@@ -0,0 +1,54 @@
+import { getModelEntry } from "../../bare/registry/model-registry.js";
+import { getPlugin } from "../../plugins/index.js";
+import { ModelNotFoundError, ModelIsDelegatedError, PluginNotFoundError, PluginHandlerNotFoundError, PluginHandlerTypeMismatchError, } from "../../../utils/errors-server.js";
+/**
+ * Resolves the plugin handler and returns both the result and streaming flag.
+ */
+function resolvePluginHandler(modelId, handlerName, request) {
+    const entry = getModelEntry(modelId);
+    if (!entry) {
+        throw new ModelNotFoundError(modelId);
+    }
+    if (entry.isDelegated || !entry.local) {
+        throw new ModelIsDelegatedError(modelId);
+    }
+    const plugin = getPlugin(entry.local.modelType);
+    if (!plugin) {
+        throw new PluginNotFoundError(entry.local.modelType);
+    }
+    const handlerDef = plugin.handlers[handlerName];
+    if (!handlerDef) {
+        const availableHandlers = Object.keys(plugin.handlers);
+        throw new PluginHandlerNotFoundError(entry.local.modelType, handlerName, availableHandlers);
+    }
+    return {
+        result: handlerDef.handler(request),
+        streaming: handlerDef.streaming,
+    };
+}
+/**
+ * Dispatches a request to a plugin handler and returns a Promise.
+ * Use for non-streaming (reply) handlers.
+ *
+ * @throws PluginHandlerTypeMismatchError if the handler is streaming
+ */
+export async function dispatchPluginReply(modelId, handlerName, request) {
+    const { result, streaming } = resolvePluginHandler(modelId, handlerName, request);
+    if (streaming) {
+        throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
+    }
+    return result;
+}
+/**
+ * Dispatches a request to a plugin handler and returns an AsyncGenerator.
+ * Use for streaming handlers.
+ *
+ * @throws PluginHandlerTypeMismatchError if the handler is not streaming
+ */
+export async function* dispatchPluginStream(modelId, handlerName, request) {
+    const { result, streaming } = resolvePluginHandler(modelId, handlerName, request);
+    if (!streaming) {
+        throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
+    }
+    yield* result;
+}

package/dist/server/rpc/handlers/plugin-invoke.d.ts

@@ -0,0 +1,4 @@
+import type { PluginInvokeRequest, PluginInvokeResponse, PluginInvokeStreamRequest, PluginInvokeStreamResponse } from "../../../schemas/plugin";
+export declare function handlePluginInvoke(request: PluginInvokeRequest): Promise<PluginInvokeResponse>;
+export declare function handlePluginInvokeStream(request: PluginInvokeStreamRequest): AsyncGenerator<PluginInvokeStreamResponse>;
+//# sourceMappingURL=plugin-invoke.d.ts.map

package/dist/server/rpc/handlers/plugin-invoke.js

@@ -0,0 +1,87 @@
+import { getModelEntry } from "../../bare/registry/model-registry.js";
+import { getPlugin, getPluginHandler } from "../../plugins/index.js";
+import { PluginNotFoundError, PluginHandlerNotFoundError, PluginHandlerTypeMismatchError, PluginRequestValidationFailedError, PluginResponseValidationFailedError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
+function resolvePluginHandler(modelId, handlerName) {
+    const modelEntry = getModelEntry(modelId);
+    if (!modelEntry) {
+        throw new ModelNotFoundError(modelId);
+    }
+    if (modelEntry.isDelegated || !modelEntry.local) {
+        throw new ModelIsDelegatedError(modelId);
+    }
+    const modelType = modelEntry.local.modelType;
+    const plugin = getPlugin(modelType);
+    if (!plugin) {
+        throw new PluginNotFoundError(modelType);
+    }
+    const handlerDef = getPluginHandler(modelType, handlerName);
+    if (!handlerDef) {
+        const availableHandlers = Object.keys(plugin.handlers);
+        throw new PluginHandlerNotFoundError(modelType, handlerName, availableHandlers);
+    }
+    return { modelType, plugin, handlerDef };
+}
+export async function handlePluginInvoke(request) {
+    const { modelId, handler: handlerName, params } = request;
+    logger.debug(`[pluginInvoke] modelId=${modelId} handler=${handlerName}`);
+    const { handlerDef } = resolvePluginHandler(modelId, handlerName);
+    if (handlerDef.streaming) {
+        throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
+    }
+    const parseResult = handlerDef.requestSchema.safeParse(params);
+    if (!parseResult.success) {
+        const details = parseResult.error.issues
+            .map((i) => `${String(i.path.join("."))}: ${i.message}`)
+            .join(", ");
+        throw new PluginRequestValidationFailedError(handlerName, details);
+    }
+    const result = await handlerDef.handler(parseResult.data);
+    const responseParseResult = handlerDef.responseSchema.safeParse(result);
+    if (!responseParseResult.success) {
+        const details = responseParseResult.error.issues
+            .map((i) => `${String(i.path.join("."))}: ${i.message}`)
+            .join(", ");
+        throw new PluginResponseValidationFailedError(handlerName, details);
+    }
+    return {
+        type: "pluginInvoke",
+        result: responseParseResult.data,
+    };
+}
+export async function* handlePluginInvokeStream(request) {
+    const { modelId, handler: handlerName, params } = request;
+    logger.debug(`[pluginInvokeStream] modelId=${modelId} handler=${handlerName}`);
+    const { handlerDef } = resolvePluginHandler(modelId, handlerName);
+    if (!handlerDef.streaming) {
+        throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
+    }
+    const parseResult = handlerDef.requestSchema.safeParse(params);
+    if (!parseResult.success) {
+        const details = parseResult.error.issues
+            .map((i) => `${String(i.path.join("."))}: ${i.message}`)
+            .join(", ");
+        throw new PluginRequestValidationFailedError(handlerName, details);
+    }
+    const generator = handlerDef.handler(parseResult.data);
+    for await (const chunk of generator) {
+        const responseParseResult = handlerDef.responseSchema.safeParse(chunk);
+        if (!responseParseResult.success) {
+            const details = responseParseResult.error.issues
+                .map((i) => `${String(i.path.join("."))}: ${i.message}`)
+                .join(", ");
+            throw new PluginResponseValidationFailedError(handlerName, details);
+        }
+        yield {
+            type: "pluginInvokeStream",
+            result: responseParseResult.data,
+            done: false,
+        };
+    }
+    yield {
+        type: "pluginInvokeStream",
+        result: null,
+        done: true,
+    };
+}

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

@@ -0,0 +1,5 @@
+import type { ModelRegistryListResponse, ModelRegistrySearchRequest, ModelRegistrySearchResponse, ModelRegistryGetModelRequest, ModelRegistryGetModelResponse } from "../../../schemas/index";
+export declare function handleModelRegistryList(): Promise<ModelRegistryListResponse>;
+export declare function handleModelRegistrySearch(request: ModelRegistrySearchRequest): Promise<ModelRegistrySearchResponse>;
+export declare function handleModelRegistryGetModel(request: ModelRegistryGetModelRequest): Promise<ModelRegistryGetModelResponse>;
+//# sourceMappingURL=registry.d.ts.map

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

@@ -0,0 +1,157 @@
+import { REGISTRY_ERROR_CODES } from "../../../schemas/sdk-errors-registry.js";
+import { getAddonFromEngine, resolveCanonicalEngine, } from "../../../schemas/engine-addon-map.js";
+import { getRegistryClient } from "../../bare/registry/registry-client.js";
+import { getServerLogger } from "../../../logging/index.js";
+import { ModelRegistryQueryFailedError } from "../../../utils/errors-server.js";
+const logger = getServerLogger();
+function toHexString(value) {
+    if (!value)
+        return "";
+    if (Buffer.isBuffer(value))
+        return value.toString("hex");
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "object" && "data" in value) {
+        return Buffer.from(value.data).toString("hex");
+    }
+    return "";
+}
+function processRegistryModel(model) {
+    const engine = resolveCanonicalEngine(model.engine || "");
+    if (!engine) {
+        logger.warn(`Skipping model with unknown engine "${model.engine}": ${model.path}`);
+        return null;
+    }
+    const filename = model.path.split("/").pop() || model.path;
+    const blobBinding = model.blobBinding;
+    const blobCoreKey = toHexString(blobBinding?.coreKey);
+    const blobBlockOffset = blobBinding?.blockOffset ?? 0;
+    const blobBlockLength = blobBinding?.blockLength ?? 0;
+    const blobByteOffset = blobBinding?.byteOffset ?? 0;
+    const expectedSize = blobBinding?.byteLength ?? 0;
+    // sha256 lives on blobBinding at runtime (per hyperschema), fall back to top-level
+    const sha256Checksum = blobBinding?.["sha256"] ||
+        model.sha256 ||
+        "";
+    const addon = getAddonFromEngine(engine);
+    // Use the filename without extension as the display name
+    const name = filename.replace(/\.\w+$/, "");
+    return {
+        name,
+        registryPath: model.path,
+        registrySource: model.source,
+        blobCoreKey,
+        blobBlockOffset,
+        blobBlockLength,
+        blobByteOffset,
+        modelId: filename,
+        addon,
+        expectedSize,
+        sha256Checksum,
+        engine,
+        quantization: model.quantization || "",
+        params: model.params || "",
+    };
+}
+export async function handleModelRegistryList() {
+    logger.debug("Handling QVAC model registry list request");
+    try {
+        const client = await getRegistryClient();
+        const registryModels = await client.findBy();
+        const models = registryModels
+            .map(processRegistryModel)
+            .filter((m) => m !== null);
+        logger.debug(`QVAC model registry list returned ${models.length} models`);
+        return {
+            type: "modelRegistryList",
+            success: true,
+            models,
+        };
+    }
+    catch (error) {
+        logger.error("QVAC model registry list failed:", error);
+        // Re-throw registry client errors directly (19001-19003)
+        const qvacError = error;
+        if (qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CONNECT ||
+            qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CLOSE ||
+            qvacError.code === REGISTRY_ERROR_CODES.MODEL_NOT_FOUND) {
+            throw error;
+        }
+        // Wrap unknown errors in SDK error
+        throw new ModelRegistryQueryFailedError(error instanceof Error ? error.message : "Unknown error", error);
+    }
+}
+export async function handleModelRegistrySearch(request) {
+    logger.debug("Handling QVAC model registry search request", request);
+    try {
+        const client = await getRegistryClient();
+        const registryModels = await client.findBy({
+            ...(request.quantization && { quantization: request.quantization }),
+        });
+        let models = registryModels
+            .map(processRegistryModel)
+            .filter((m) => m !== null);
+        if (request.engine) {
+            const canonicalEngine = resolveCanonicalEngine(request.engine);
+            models = models.filter((m) => m.engine === (canonicalEngine ?? request.engine));
+        }
+        if (request.filter) {
+            const filterLower = request.filter.toLowerCase();
+            models = models.filter((m) => m.name.toLowerCase().includes(filterLower) ||
+                m.registryPath.toLowerCase().includes(filterLower) ||
+                m.addon.toLowerCase().includes(filterLower) ||
+                m.engine.toLowerCase().includes(filterLower));
+        }
+        if (request.addon) {
+            models = models.filter((m) => m.addon === request.addon);
+        }
+        logger.debug(`QVAC model registry search returned ${models.length} models`);
+        return {
+            type: "modelRegistrySearch",
+            success: true,
+            models,
+        };
+    }
+    catch (error) {
+        logger.error("QVAC model registry search failed:", error);
+        // Re-throw registry client errors directly (19001-19003)
+        const qvacError = error;
+        if (qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CONNECT ||
+            qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CLOSE ||
+            qvacError.code === REGISTRY_ERROR_CODES.MODEL_NOT_FOUND) {
+            throw error;
+        }
+        throw new ModelRegistryQueryFailedError(error instanceof Error ? error.message : "Unknown error", error);
+    }
+}
+export async function handleModelRegistryGetModel(request) {
+    logger.debug("Handling QVAC model registry get model request", request);
+    try {
+        const client = await getRegistryClient();
+        const rawModel = await client.getModel(request.registryPath, request.registrySource);
+        if (!rawModel) {
+            throw new ModelRegistryQueryFailedError(`Model not found: ${request.registrySource}/${request.registryPath}`);
+        }
+        const model = processRegistryModel(rawModel);
+        if (!model) {
+            throw new ModelRegistryQueryFailedError(`Model has unknown engine "${rawModel.engine}": ${request.registryPath}`);
+        }
+        logger.debug("QVAC model registry get model found:", model.name);
+        return {
+            type: "modelRegistryGetModel",
+            success: true,
+            model,
+        };
+    }
+    catch (error) {
+        logger.error("QVAC model registry get model failed:", error);
+        // Re-throw registry client errors directly (19001-19003)
+        const qvacError = error;
+        if (qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CONNECT ||
+            qvacError.code === REGISTRY_ERROR_CODES.FAILED_TO_CLOSE ||
+            qvacError.code === REGISTRY_ERROR_CODES.MODEL_NOT_FOUND) {
+            throw error;
+        }
+        throw new ModelRegistryQueryFailedError(error instanceof Error ? error.message : "Unknown error", error);
+    }
+}

package/dist/server/rpc/handlers/text-to-speech.js

@@ -1,7 +1,4 @@
-import { textToSpeech } from "../../bare/addons/onnx-tts/index.js";
+import { dispatchPluginStream } from "./plugin-dispatch.js";
 export async function* handleTextToSpeech(request) {
-    const stream = textToSpeech(request);
-    for await (const response of stream) {
-        yield response;
-    }
+    yield* dispatchPluginStream(request.modelId, "textToSpeech", request);
 }

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

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

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

@@ -1,44 +1,4 @@
-import { translate } from "../../bare/addons/nmtcpp-translation/index.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
+import { dispatchPluginStream } from "./plugin-dispatch.js";
 export async function* handleTranslate(request) {
-    try {
-        // Remove the 'type' field from request and pass the rest to translate
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { type, ...translateParams } = request;
-        const generator = translate(translateParams);
-        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 (translateParams.stream) {
-                    yield {
-                        type: "translate",
-                        token: result.value,
-                    };
-                }
-            }
-        }
-        yield {
-            type: "translate",
-            token: buffer,
-            done: true,
-            stats,
-        };
-    }
-    catch (error) {
-        logger.error("Error during translation:", error);
-        yield {
-            type: "translate",
-            token: "",
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
+    yield* dispatchPluginStream(request.modelId, "translate", request);
 }

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

@@ -1,4 +1,4 @@
-import { unloadModel } from "../../bare/addons/index.js";
+import { unloadModel } from "../../bare/ops/unload-model.js";
 import { getRegistryStats } from "../../bare/registry/model-registry.js";
 import { hasActiveProviders } from "../../bare/hyperswarm.js";
 import { getServerLogger } from "../../../logging/index.js";

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

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

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

@@ -1,3 +1,4 @@
 export declare function isArchiveUrl(url: string): boolean;
+export declare function extractTarStream(archivePath: string, extractDir: string, useGunzip: boolean, signal?: AbortSignal): Promise<void>;
 export declare function extractAndValidateShardedArchive(archivePath: string, extractDir: string, signal?: AbortSignal): Promise<string>;
 //# sourceMappingURL=archive.d.ts.map

package/dist/server/utils/archive.js

@@ -5,6 +5,7 @@ import { createGunzip } from "bare-zlib";
 import tarStream from "tar-stream";
 import { detectShardedModel, generateShardFilenames, extractTensorsFromShards, validateShardedModelCache, } from "./shard-utils.js";
 import { ModelLoadFailedError, ArchiveExtractionFailedError, ArchiveUnsupportedTypeError, ArchiveMissingShardsError, DownloadCancelledError, } from "../../utils/errors-server.js";
+import { isPathWithinBase } from "./path-security.js";
 import { getServerLogger } from "../../logging/index.js";
 import { SUPPORTED_ARCHIVE_EXTENSIONS, filenameToArchiveTypeSchema, } from "../../schemas/archive.js";
 const logger = getServerLogger();
@@ -63,7 +64,7 @@ async function extractArchive(archivePath, extractDir, signal) {
     await fsPromises.mkdir(extractDir, { recursive: true });
     await extractTarStream(archivePath, extractDir, isGzipped, signal);
 }
-async function extractTarStream(archivePath, extractDir, useGunzip, signal) {
+export async function extractTarStream(archivePath, extractDir, useGunzip, signal) {
     const extract = tarStream.extract();
     const gunzip = useGunzip ? createGunzip() : null;
     return new Promise((resolve, reject) => {
@@ -91,7 +92,14 @@ async function extractTarStream(archivePath, extractDir, useGunzip, signal) {
                 next();
                 return;
             }
-            const filePath = path.join(extractDir, header.name);
+            // Prevent zip-slip: reject entries that escape extractDir (CWE-22)
+            const filePath = path.resolve(path.join(extractDir, header.name));
+            if (!isPathWithinBase(extractDir, filePath)) {
+                logger.warn(`⚠️ Skipping archive entry with path traversal: ${header.name}`);
+                stream.resume();
+                next();
+                return;
+            }
             if (header.type === "file") {
                 const dir = path.dirname(filePath);
                 fs.mkdirSync(dir, { recursive: true });

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

@@ -7,6 +7,11 @@ export declare function getKVCacheDir(): string;
  * Returns: cache/sharded/<hyperdriveKey>/
  */
 export declare function getShardedModelCacheDir(hyperdriveKey: string): string;
+/**
+ * Get full path to ONNX file in cache
+ * Returns: cache/onnx/<cacheKey>/<filename>
+ */
+export declare function getOnnxModelPath(cacheKey: string, filename: string): string;
 /**
  * Get full path to specific shard file
  * Returns: cache/sharded/<hyperdriveKey>/<shardFilename>

package/dist/server/utils/cache.js

@@ -1,8 +1,9 @@
 import fs, { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
-import { getEnv } from "../worker.js";
+import { getEnv } from "../env.js";
 import { getConfiguredCacheDir } from "../bare/registry/config-registry.js";
 import { calculateFileChecksum } from "./checksum.js";
+import { validateAndJoinPath } from "./path-security.js";
 import { getServerLogger } from "../../logging/index.js";
 const logger = getServerLogger();
 export function getCacheDir(subDir) {
@@ -44,13 +45,36 @@ export function getShardedModelCacheDir(hyperdriveKey) {
     }
     return shardDir;
 }
+/**
+ * Get cache directory for ONNX model with external data
+ * Returns: cache/onnx/<cacheKey>/
+ */
+function getOnnxModelCacheDir(cacheKey) {
+    const baseCache = getModelsCacheDir();
+    const onnxDir = validateAndJoinPath(baseCache, "onnx", cacheKey);
+    try {
+        fs.mkdirSync(onnxDir, { recursive: true });
+    }
+    catch (error) {
+        logger.error(`Error creating ONNX model cache directory:`, error instanceof Error ? error.message : String(error));
+    }
+    return onnxDir;
+}
+/**
+ * Get full path to ONNX file in cache
+ * Returns: cache/onnx/<cacheKey>/<filename>
+ */
+export function getOnnxModelPath(cacheKey, filename) {
+    const onnxDir = getOnnxModelCacheDir(cacheKey);
+    return validateAndJoinPath(onnxDir, filename);
+}
 /**
  * Get full path to specific shard file
  * Returns: cache/sharded/<hyperdriveKey>/<shardFilename>
  */
 export function getShardPath(hyperdriveKey, shardFilename) {
     const shardDir = getShardedModelCacheDir(hyperdriveKey);
-    return path.join(shardDir, shardFilename);
+    return validateAndJoinPath(shardDir, shardFilename);
 }
 /**
  * Check if all shards exist and are valid (size + checksum check)

package/dist/server/utils/gguf-tensor-extractor.js

@@ -1,7 +1,7 @@
 import { promises as fsPromises, createReadStream } from "bare-fs";
-import path from "bare-path";
 import { getServerLogger } from "../../logging/index.js";
 import { ModelLoadFailedError } from "../../utils/errors-server.js";
+import { validateAndJoinPath } from "./path-security.js";
 const logger = getServerLogger();
 // GGUF value types
 const GGUF_TYPE = {
@@ -253,7 +253,7 @@ async function extractTensorNamesFromHeader(filePath) {
  * @throws ModelLoadFailedError if any shard fails extraction
  */
 export async function extractAndWriteTensorsFile(shardDir, shardFilenames, baseFilename) {
-    const tensorsFilePath = path.join(shardDir, `${baseFilename}.tensors.txt`);
+    const tensorsFilePath = validateAndJoinPath(shardDir, `${baseFilename}.tensors.txt`);
     try {
         await fsPromises.access(tensorsFilePath);
         logger.info(`Tensors file already exists: ${tensorsFilePath}`);
@@ -266,7 +266,7 @@ export async function extractAndWriteTensorsFile(shardDir, shardFilenames, baseF
     const allTensorNames = new Set();
     const failedShards = [];
     for (const filename of shardFilenames) {
-        const shardPath = path.join(shardDir, filename);
+        const shardPath = validateAndJoinPath(shardDir, filename);
         try {
             logger.debug(`Extracting tensors from ${filename}...`);
             const tensorNames = await extractTensorNamesFromHeader(shardPath);

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

@@ -1,10 +1,10 @@
 export * from "./archive";
-export * from "./audio/decoder";
 export * from "./cache";
 export * from "./checksum";
 export * from "./config-transform";
 export * from "./formatting";
 export * from "./gguf-tensor-extractor";
 export * from "./model-path";
+export * from "./path-security";
 export * from "./shard-utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/utils/index.js

@@ -1,9 +1,9 @@
 export * from "./archive.js";
-export * from "./audio/decoder.js";
 export * from "./cache.js";
 export * from "./checksum.js";
 export * from "./config-transform.js";
 export * from "./formatting.js";
 export * from "./gguf-tensor-extractor.js";
 export * from "./model-path.js";
+export * from "./path-security.js";
 export * from "./shard-utils.js";

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

@@ -0,0 +1,12 @@
+export { sanitizePathComponent } from "../../utils/path-sanitize";
+/**
+ * Check whether a target path is contained within a base directory.
+ * Both paths are resolved to absolute before comparison.
+ */
+export declare function isPathWithinBase(basePath: string, targetPath: string): boolean;
+/**
+ * Sanitize components, join them to a base path, and verify the result
+ * stays within the base directory. Throws PathTraversalError on escape.
+ */
+export declare function validateAndJoinPath(basePath: string, ...components: string[]): string;
+//# sourceMappingURL=path-security.d.ts.map

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

@@ -0,0 +1,25 @@
+import path from "bare-path";
+import { PathTraversalError } from "../../utils/errors-server.js";
+import { sanitizePathComponent, checkPathWithinBase, } from "../../utils/path-sanitize.js";
+// Re-export sanitizePathComponent unchanged
+export { sanitizePathComponent } from "../../utils/path-sanitize.js";
+/**
+ * Check whether a target path is contained within a base directory.
+ * Both paths are resolved to absolute before comparison.
+ */
+export function isPathWithinBase(basePath, targetPath) {
+    return checkPathWithinBase(basePath, targetPath, path.resolve, path.sep || "/");
+}
+/**
+ * Sanitize components, join them to a base path, and verify the result
+ * stays within the base directory. Throws PathTraversalError on escape.
+ */
+export function validateAndJoinPath(basePath, ...components) {
+    const sanitized = components.map((c) => sanitizePathComponent(c));
+    const joined = path.join(basePath, ...sanitized);
+    const resolved = path.resolve(joined);
+    if (!isPathWithinBase(basePath, resolved)) {
+        throw new PathTraversalError(components.join("/"), basePath);
+    }
+    return resolved;
+}