@qvac/sdk 0.8.0 → 1.0.0

package/dist/utils/mcp-adapter.js

@@ -1,103 +0,0 @@
-import { mapValues } from "./object.js";
-const VALID_TYPES = [
-    "string",
-    "number",
-    "integer",
-    "boolean",
-    "object",
-    "array",
-];
-function isValidType(value) {
-    return typeof value === "string" && VALID_TYPES.includes(value);
-}
-function convertMcpToolToTool(mcpTool) {
-    const inputSchema = mcpTool.inputSchema;
-    const properties = inputSchema.properties ?? {};
-    const required = inputSchema.required ?? [];
-    const convertedProperties = mapValues(properties, (prop) => {
-        const { type, description, enum: enumVal } = prop;
-        return {
-            type: isValidType(type) ? type : "string",
-            ...(description && { description }),
-            ...(enumVal && { enum: enumVal }),
-        };
-    });
-    return {
-        type: "function",
-        name: mcpTool.name,
-        description: mcpTool.description ?? "",
-        parameters: {
-            type: "object",
-            properties: convertedProperties,
-            required: required.length > 0 ? required : undefined,
-        },
-    };
-}
-function createMcpToolHandler(client, toolName) {
-    return async (args) => {
-        return client.callTool({ name: toolName, arguments: args });
-    };
-}
-export async function getMcpToolsWithHandlers(clients) {
-    const allTools = [];
-    const handlers = new Map();
-    for (const { client, includeResources } of clients) {
-        const { tools: mcpTools } = await client.listTools();
-        for (const mcpTool of mcpTools) {
-            allTools.push(convertMcpToolToTool(mcpTool));
-            handlers.set(mcpTool.name, createMcpToolHandler(client, mcpTool.name));
-        }
-        if (includeResources !== false && client.listResources) {
-            allTools.push({
-                type: "function",
-                name: "list_resources",
-                description: "List available resources from MCP server",
-                parameters: {
-                    type: "object",
-                    properties: {},
-                },
-            });
-            handlers.set("list_resources", async () => {
-                if (!client.listResources) {
-                    return { resources: [] };
-                }
-                const result = await client.listResources();
-                return {
-                    type: "text",
-                    text: JSON.stringify(result.resources, null, 2),
-                };
-            });
-            if (client.readResource) {
-                allTools.push({
-                    type: "function",
-                    name: "read_resource",
-                    description: "Read content of a specific resource by URI",
-                    parameters: {
-                        type: "object",
-                        properties: {
-                            uri: {
-                                type: "string",
-                                description: "The URI of the resource to read",
-                            },
-                        },
-                        required: ["uri"],
-                    },
-                });
-                handlers.set("read_resource", async (args) => {
-                    if (!client.readResource) {
-                        return { error: "readResource not available" };
-                    }
-                    const result = await client.readResource({
-                        uri: args["uri"],
-                    });
-                    return result.contents[0];
-                });
-            }
-        }
-    }
-    return { tools: allTools, handlers };
-}
-export async function getMcpTools(clients) {
-    const { tools } = await getMcpToolsWithHandlers(clients);
-    return tools;
-}

package/dist/utils/object.d.ts

@@ -1,2 +0,0 @@
-export declare function mapValues<T, U>(obj: Record<string, T>, fn: (value: T, key: string) => U): Record<string, U>;
-//# sourceMappingURL=object.d.ts.map

package/dist/utils/object.js

@@ -1,3 +0,0 @@
-export function mapValues(obj, fn) {
-    return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value, key)]));
-}

package/dist/utils/path-sanitize.d.ts

@@ -1,17 +0,0 @@
-/**
- * Pure string sanitization for path components. No runtime-specific dependencies.
- * Safe to import from both Bare (server) and Bun/Node (tests, client).
- */
-/**
- * Sanitize a path component that will be joined to a base directory.
- * Strips traversal sequences, absolute prefixes, and normalizes separators.
- *
- * Throws on null bytes (literal or URL-encoded).
- */
-export declare function sanitizePathComponent(component: string): string;
-/**
- * Check whether a resolved target path is contained within a base directory.
- * Portable — caller provides the resolve function and separator for their runtime.
- */
-export declare function checkPathWithinBase(basePath: string, targetPath: string, resolveFn: (...args: string[]) => string, sep: string): boolean;
-//# sourceMappingURL=path-sanitize.d.ts.map

package/dist/utils/path-sanitize.js

@@ -1,54 +0,0 @@
-/**
- * Pure string sanitization for path components. No runtime-specific dependencies.
- * Safe to import from both Bare (server) and Bun/Node (tests, client).
- */
-/**
- * Sanitize a path component that will be joined to a base directory.
- * Strips traversal sequences, absolute prefixes, and normalizes separators.
- *
- * Throws on null bytes (literal or URL-encoded).
- */
-export function sanitizePathComponent(component) {
-    if (component === "")
-        return "";
-    // Reject null bytes (literal and URL-encoded)
-    if (component.includes("\0") || component.includes("%00")) {
-        throw new Error(`Path component contains null byte: ${component}`);
-    }
-    let sanitized = component;
-    // Decode common URL-encoded traversal sequences
-    sanitized = sanitized
-        .replace(/%2e/gi, ".")
-        .replace(/%2f/gi, "/")
-        .replace(/%5c/gi, "\\");
-    // Normalize backslashes to forward slashes
-    sanitized = sanitized.replace(/\\/g, "/");
-    // Strip Windows drive letter prefixes (C:/, D:/, etc.)
-    sanitized = sanitized.replace(/^[A-Za-z]:\//, "");
-    // Strip leading slashes (absolute path prefixes)
-    sanitized = sanitized.replace(/^\/+/, "");
-    // Remove all ".." segments (start, middle, end) iteratively until stable
-    let prev = "";
-    while (prev !== sanitized) {
-        prev = sanitized;
-        sanitized = sanitized.replace(/^\.\.\//g, "");
-        sanitized = sanitized.replace(/\/\.\.$/g, "");
-        sanitized = sanitized.replace(/\/\.\.\//g, "/");
-        if (sanitized === "..")
-            sanitized = "";
-    }
-    // Strip any remaining leading slashes produced by stripping
-    sanitized = sanitized.replace(/^\/+/, "");
-    return sanitized;
-}
-/**
- * Check whether a resolved target path is contained within a base directory.
- * Portable — caller provides the resolve function and separator for their runtime.
- */
-export function checkPathWithinBase(basePath, targetPath, resolveFn, sep) {
-    const resolvedBase = resolveFn(basePath);
-    const resolvedTarget = resolveFn(targetPath);
-    if (resolvedTarget === resolvedBase)
-        return true;
-    return resolvedTarget.startsWith(resolvedBase + sep);
-}

package/dist/utils/tool-helpers.d.ts

@@ -1,25 +0,0 @@
-import type { z } from "zod";
-import { type Tool, type ToolCall, type ToolCallWithCall } from "../schemas/tools";
-type ZodObjectType = z.ZodObject<z.ZodRawShape>;
-export type ToolHandler = (args: Record<string, unknown>) => Promise<unknown>;
-export type ToolInput<T extends ZodObjectType = ZodObjectType> = {
-    name: string;
-    description: string;
-    parameters: T;
-    handler?: ToolHandler;
-};
-export declare function convertToolInput(input: ToolInput): Tool;
-export declare function convertTools(inputs: ToolInput[]): Tool[];
-/**
- * Validates and converts tools from either ToolInput (with Zod schemas) or full Tool format.
- * Returns validated Tool[] array.
- */
-export type ToolHandlerMap = Map<string, ToolHandler>;
-export type ValidateToolsResult = {
-    tools: Tool[];
-    handlers: ToolHandlerMap;
-};
-export declare function validateTools(tools: Tool[] | ToolInput[]): ValidateToolsResult;
-export declare function attachHandlersToToolCalls(toolCalls: ToolCall[], handlers: ToolHandlerMap): ToolCallWithCall[];
-export {};
-//# sourceMappingURL=tool-helpers.d.ts.map

package/dist/utils/tool-helpers.js

@@ -1,112 +0,0 @@
-import { toolSchema, } from "../schemas/tools.js";
-import { InvalidToolsArrayError, InvalidToolSchemaError, } from "./errors-client.js";
-function zodTypeToJsonSchemaType(type) {
-    switch (type) {
-        case "string":
-            return "string";
-        case "number":
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "object":
-            return "object";
-        case "array":
-            return "array";
-        case "optional":
-        default:
-            return "string";
-    }
-}
-export function convertToolInput(input) {
-    const zodSchema = input.parameters;
-    // Try both shape and def.shape for Zod v4 compatibility
-    const shape = zodSchema.shape ||
-        (typeof zodSchema.def?.shape === "object" ? zodSchema.def.shape : {});
-    const properties = {};
-    const required = [];
-    for (const [key, value] of Object.entries(shape)) {
-        const field = value;
-        const fieldType = field.type || field.def?.type || "string";
-        const isOptional = fieldType === "optional";
-        let actualType = isOptional ? "string" : fieldType;
-        let actualDescription = field.description;
-        if (isOptional && field.def?.innerType) {
-            const innerType = field.def.innerType;
-            actualType = innerType.type || innerType.def?.type || "string";
-            // Get description from inner type if not on wrapper
-            if (!actualDescription && innerType.description) {
-                actualDescription = innerType.description;
-            }
-        }
-        properties[key] = {
-            type: zodTypeToJsonSchemaType(actualType),
-        };
-        if (actualDescription) {
-            properties[key].description = actualDescription;
-        }
-        if (field.def?.values) {
-            properties[key].enum = field.def.values;
-        }
-        if (!isOptional) {
-            required.push(key);
-        }
-    }
-    const tool = {
-        type: "function",
-        name: input.name,
-        description: input.description,
-        parameters: {
-            type: "object",
-            properties,
-            required: required.length > 0 ? required : undefined,
-        },
-    };
-    return toolSchema.parse(tool);
-}
-export function convertTools(inputs) {
-    return inputs.map(convertToolInput);
-}
-export function validateTools(tools) {
-    if (tools.length === 0) {
-        return { tools: [], handlers: new Map() };
-    }
-    const firstTool = tools[0];
-    if (!firstTool) {
-        throw new InvalidToolsArrayError();
-    }
-    const handlers = new Map();
-    const parseResult = toolSchema.safeParse(firstTool);
-    if (parseResult.success) {
-        const validatedTools = [];
-        for (const tool of tools) {
-            const result = toolSchema.safeParse(tool);
-            if (!result.success) {
-                throw new InvalidToolSchemaError(result.error.message, result.error);
-            }
-            validatedTools.push(result.data);
-        }
-        return { tools: validatedTools, handlers };
-    }
-    else {
-        const toolInputs = tools;
-        const convertedTools = convertTools(toolInputs);
-        for (const toolInput of toolInputs) {
-            if (toolInput.handler) {
-                handlers.set(toolInput.name, toolInput.handler);
-            }
-        }
-        return { tools: convertedTools, handlers };
-    }
-}
-export function attachHandlersToToolCalls(toolCalls, handlers) {
-    return toolCalls.map((toolCall) => {
-        const handler = handlers.get(toolCall.name);
-        if (handler) {
-            return {
-                ...toolCall,
-                invoke: async () => await handler(toolCall.arguments),
-            };
-        }
-        return toolCall;
-    });
-}

package/expo/plugins/patches/android-link.mjs

@@ -1,63 +0,0 @@
-/**
- * Patched android/link.mjs for manifest-aware native addon linking.
- *
- * If qvac/addons.manifest.json exists, only links the allowlisted addons.
- * Otherwise, falls back to linking all installed addons.
- *
- * This file is copied over react-native-bare-kit/android/link.mjs
- * by withMobileBundle.ts during expo prebuild.
- */
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import link from "bare-link";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const projectRoot = path.join(__dirname, "..", "..", "..");
-const addonsDir = path.join(__dirname, "src", "main", "addons");
-
-if (fs.existsSync(addonsDir)) {
-  console.log("[QVAC] Cleaning existing addons directory...");
-  fs.rmSync(addonsDir, { recursive: true, force: true });
-}
-
-const manifestPath = path.join(projectRoot, "qvac", "addons.manifest.json");
-
-let pkg = null;
-if (fs.existsSync(manifestPath)) {
-  try {
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-    const addons = Array.isArray(manifest.addons) ? manifest.addons : [];
-
-    if (addons.length > 0) {
-      console.log(
-        `[QVAC] Using addons manifest (${addons.length} addons): ${addons.join(", ")}`,
-      );
-      pkg = {
-        name: "qvac-addon-linker",
-        version: "0.0.0",
-        dependencies: Object.fromEntries(addons.map((name) => [name, "*"])),
-      };
-    } else {
-      console.log("[QVAC] Addons manifest is empty, linking all addons");
-    }
-  } catch (err) {
-    console.warn(
-      "[QVAC] Failed to parse addons manifest, linking all addons:",
-      err.message,
-    );
-  }
-} else {
-  console.log("[QVAC] No addons manifest found, linking all addons");
-}
-
-for await (const resource of link(
-  projectRoot,
-  {
-    target: ["android-arm64", "android-arm", "android-ia32", "android-x64"],
-    out: addonsDir,
-  },
-  pkg,
-)) {
-  console.log("Wrote", resource);
-}

package/expo/plugins/patches/ios-link.mjs

@@ -1,63 +0,0 @@
-/**
- * Patched ios/link.mjs for manifest-aware native addon linking.
- *
- * If qvac/addons.manifest.json exists, only links the allowlisted addons.
- * Otherwise, falls back to linking all installed addons.
- *
- * This file is copied over react-native-bare-kit/ios/link.mjs
- * by withMobileBundle.ts during expo prebuild.
- */
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import link from "bare-link";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const projectRoot = path.join(__dirname, "..", "..", "..");
-const addonsDir = path.join(__dirname, "addons");
-
-if (fs.existsSync(addonsDir)) {
-  console.log("[QVAC] Cleaning existing addons directory...");
-  fs.rmSync(addonsDir, { recursive: true, force: true });
-}
-
-const manifestPath = path.join(projectRoot, "qvac", "addons.manifest.json");
-
-let pkg = null;
-if (fs.existsSync(manifestPath)) {
-  try {
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
-    const addons = Array.isArray(manifest.addons) ? manifest.addons : [];
-
-    if (addons.length > 0) {
-      console.log(
-        `[QVAC] Using addons manifest (${addons.length} addons): ${addons.join(", ")}`,
-      );
-      pkg = {
-        name: "qvac-addon-linker",
-        version: "0.0.0",
-        dependencies: Object.fromEntries(addons.map((name) => [name, "*"])),
-      };
-    } else {
-      console.log("[QVAC] Addons manifest is empty, linking all addons");
-    }
-  } catch (err) {
-    console.warn(
-      "[QVAC] Failed to parse addons manifest, linking all addons:",
-      err.message,
-    );
-  }
-} else {
-  console.log("[QVAC] No addons manifest found, linking all addons");
-}
-
-for await (const resource of link(
-  projectRoot,
-  {
-    target: ["ios-arm64", "ios-arm64-simulator", "ios-x64-simulator"],
-    out: addonsDir,
-  },
-  pkg,
-)) {
-  console.log("Wrote", resource);
-}