quidproquo-actionprocessor-node 0.0.256 → 0.0.258

package/lib/esm/dynamicActionProcessor/file/getFileGenerateTemporaryUploadSecureUrlActionProcessor.js

@@ -0,0 +1,29 @@
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import { createSecureUrlToken, getSecureUrlBaseUrl } from './secureUrlUtils';
+import { resolveFilePath } from './utils';
+const getProcessFileGenerateTemporaryUploadSecureUrl = (qpqConfig, config) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async ({ drive, filepath, expirationMs, contentType }) => {
+        try {
+            const expiresAt = Date.now() + expirationMs;
+            // Create a token for upload
+            const token = createSecureUrlToken({
+                fullFilepath: resolveFilePath(config, serviceName, drive, filepath),
+                operation: 'upload',
+                expiresAt,
+                contentType,
+            }, config.secureUrlSecret);
+            // Build the secure URL
+            const baseUrl = getSecureUrlBaseUrl(config);
+            const url = `${baseUrl}/secure-upload?token=${token}`;
+            console.log(`Generated upload URL for ${filepath} in drive ${drive}, expires at ${new Date(expiresAt).toISOString()}`);
+            return actionResult(url);
+        }
+        catch (error) {
+            return actionResultError(ErrorTypeEnum.GenericError, `Unable to generate temporary upload secure URL: ${error.message}`);
+        }
+    };
+};
+export const getFileGenerateTemporaryUploadSecureUrlActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.GenerateTemporaryUploadSecureUrl]: getProcessFileGenerateTemporaryUploadSecureUrl(qpqConfig, config),
+});

package/lib/esm/dynamicActionProcessor/file/getFileIsColdStorageActionProcessor.d.ts

@@ -0,0 +1,3 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const getFileIsColdStorageActionProcessor: (config: FileStorageConfig) => ActionProcessorListResolver;

package/lib/esm/dynamicActionProcessor/file/getFileIsColdStorageActionProcessor.js

@@ -0,0 +1,10 @@
+import { actionResult, FileActionType, } from 'quidproquo-core';
+const getProcessFileIsColdStorage = (config) => (qpqConfig) => {
+    return async ({ drive, filepath }) => {
+        // Local filesystem doesn't have cold storage, always return false
+        return actionResult(false);
+    };
+};
+export const getFileIsColdStorageActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.IsColdStorage]: getProcessFileIsColdStorage(config)(qpqConfig),
+});

package/lib/esm/dynamicActionProcessor/file/getFileListDirectoryActionProcessor.d.ts

@@ -0,0 +1,3 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const getFileListDirectoryActionProcessor: (config: FileStorageConfig) => ActionProcessorListResolver;

package/lib/esm/dynamicActionProcessor/file/getFileListDirectoryActionProcessor.js

@@ -0,0 +1,50 @@
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { resolveFilePath } from './utils';
+const getProcessFileListDirectory = (config) => (qpqConfig) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async ({ drive, folderPath, maxFiles, pageToken }) => {
+        try {
+            const fullPath = resolveFilePath(config, serviceName, drive, folderPath || '');
+            // Read all entries in the directory
+            const entries = await fs.readdir(fullPath, { withFileTypes: true });
+            // Build file info list
+            const allFiles = [];
+            for (const entry of entries) {
+                allFiles.push({
+                    filepath: path.join(folderPath || '', entry.name),
+                    drive: drive,
+                    isDir: entry.isDirectory(),
+                    hashMd5: undefined,
+                });
+            }
+            // Sort by filepath for consistent pagination
+            allFiles.sort((a, b) => a.filepath.localeCompare(b.filepath));
+            // Handle pagination
+            const startIndex = pageToken ? parseInt(pageToken, 10) : 0;
+            const endIndex = Math.min(startIndex + maxFiles, allFiles.length);
+            const paginatedFiles = allFiles.slice(startIndex, endIndex);
+            const result = {
+                fileInfos: paginatedFiles,
+            };
+            // Add page token if there are more files
+            if (endIndex < allFiles.length) {
+                result.pageToken = endIndex.toString();
+            }
+            return actionResult(result);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return actionResultError(ErrorTypeEnum.NotFound, `Directory not found: ${folderPath}`);
+            }
+            if (error.code === 'ENOTDIR') {
+                return actionResultError(ErrorTypeEnum.GenericError, `Path is not a directory: ${folderPath}`);
+            }
+            return actionResultError(ErrorTypeEnum.GenericError, `Error listing directory: ${error.message}`);
+        }
+    };
+};
+export const getFileListDirectoryActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.ListDirectory]: getProcessFileListDirectory(config)(qpqConfig),
+});

package/lib/esm/dynamicActionProcessor/file/getFileReadBinaryContentsActionProcessor.d.ts

@@ -0,0 +1,3 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const getFileReadBinaryContentsActionProcessor: (config: FileStorageConfig) => ActionProcessorListResolver;

package/lib/esm/dynamicActionProcessor/file/getFileReadBinaryContentsActionProcessor.js

@@ -0,0 +1,29 @@
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { resolveFilePath } from './utils';
+const getProcessFileReadBinaryContents = (config) => (qpqConfig) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async ({ drive, filepath }) => {
+        try {
+            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            const buffer = await fs.readFile(fullPath);
+            // Convert Buffer to QPQBinaryData
+            const binaryData = {
+                base64Data: buffer.toString('base64'),
+                filename: path.basename(filepath),
+                mimetype: 'application/octet-stream', // Default mimetype for binary files
+            };
+            return actionResult(binaryData);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return actionResultError(ErrorTypeEnum.NotFound, `File not found: ${filepath}`);
+            }
+            return actionResultError(ErrorTypeEnum.GenericError, `Error reading binary file: ${error.message}`);
+        }
+    };
+};
+export const getFileReadBinaryContentsActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.ReadBinaryContents]: getProcessFileReadBinaryContents(config)(qpqConfig),
+});

package/lib/esm/dynamicActionProcessor/file/getFileReadObjectJsonActionProcessor.d.ts

@@ -0,0 +1,3 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const getFileReadObjectJsonActionProcessor: (config: FileStorageConfig) => ActionProcessorListResolver;

package/lib/esm/dynamicActionProcessor/file/getFileReadObjectJsonActionProcessor.js

@@ -0,0 +1,26 @@
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import * as fs from 'fs/promises';
+import { resolveFilePath } from './utils';
+const getProcessFileReadObjectJson = (config) => (qpqConfig) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async ({ drive, filepath }) => {
+        try {
+            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            const content = await fs.readFile(fullPath, 'utf8');
+            const jsonObject = JSON.parse(content);
+            return actionResult(jsonObject);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return actionResultError(ErrorTypeEnum.NotFound, `File not found: ${filepath}`);
+            }
+            if (error instanceof SyntaxError) {
+                return actionResultError(ErrorTypeEnum.GenericError, `Invalid JSON in file: ${filepath}`);
+            }
+            return actionResultError(ErrorTypeEnum.GenericError, `Error reading JSON file: ${error.message}`);
+        }
+    };
+};
+export const getFileReadObjectJsonActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.ReadObjectJson]: getProcessFileReadObjectJson(config)(qpqConfig),
+});

package/lib/esm/dynamicActionProcessor/file/getFileReadTextContentsActionProcessor.d.ts

@@ -0,0 +1,3 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const getFileReadTextContentsActionProcessor: (config: FileStorageConfig) => ActionProcessorListResolver;

package/lib/esm/dynamicActionProcessor/file/getFileReadTextContentsActionProcessor.js

@@ -0,0 +1,22 @@
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import * as fs from 'fs/promises';
+import { resolveFilePath } from './utils';
+const getProcessFileReadTextContents = (qpqConfig, config) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async ({ drive, filepath }) => {
+        try {
+            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            const content = await fs.readFile(fullPath, 'utf8');
+            return actionResult(content);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return actionResultError(ErrorTypeEnum.NotFound, `File not found: ${filepath}`);
+            }
+            return actionResultError(ErrorTypeEnum.GenericError, `Error reading file: ${error.message}`);
+        }
+    };
+};
+export const getFileReadTextContentsActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.ReadTextContents]: getProcessFileReadTextContents(qpqConfig, config),
+});

package/lib/esm/dynamicActionProcessor/file/getFileWriteBinaryContentsActionProcessor.d.ts

@@ -0,0 +1,3 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const getFileWriteBinaryContentsActionProcessor: (config: FileStorageConfig) => ActionProcessorListResolver;

package/lib/esm/dynamicActionProcessor/file/getFileWriteBinaryContentsActionProcessor.js

@@ -0,0 +1,22 @@
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import * as fs from 'fs/promises';
+import { ensureParentDirectoryExists, resolveFilePath } from './utils';
+const getProcessFileWriteBinaryContents = (config) => (qpqConfig) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async ({ drive, filepath, data }) => {
+        try {
+            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            await ensureParentDirectoryExists(fullPath);
+            // Convert QPQBinaryData to Buffer
+            const buffer = Buffer.from(data.base64Data, 'base64');
+            await fs.writeFile(fullPath, buffer);
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultError(ErrorTypeEnum.GenericError, `Error writing binary file: ${error.message}`);
+        }
+    };
+};
+export const getFileWriteBinaryContentsActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.WriteBinaryContents]: getProcessFileWriteBinaryContents(config)(qpqConfig),
+});

package/lib/esm/dynamicActionProcessor/file/getFileWriteObjectJsonActionProcessor.d.ts

@@ -0,0 +1,3 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const getFileWriteObjectJsonActionProcessor: (config: FileStorageConfig) => ActionProcessorListResolver;

package/lib/esm/dynamicActionProcessor/file/getFileWriteObjectJsonActionProcessor.js

@@ -0,0 +1,21 @@
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import * as fs from 'fs/promises';
+import { ensureParentDirectoryExists, resolveFilePath } from './utils';
+const getProcessFileWriteObjectJson = (config) => (qpqConfig) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async ({ drive, filepath, data }) => {
+        try {
+            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            await ensureParentDirectoryExists(fullPath);
+            const jsonString = JSON.stringify(data, null, 2);
+            await fs.writeFile(fullPath, jsonString, 'utf8');
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultError(ErrorTypeEnum.GenericError, `Error writing JSON file: ${error.message}`);
+        }
+    };
+};
+export const getFileWriteObjectJsonActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.WriteObjectJson]: getProcessFileWriteObjectJson(config)(qpqConfig),
+});

package/lib/esm/dynamicActionProcessor/file/getFileWriteTextContentsActionProcessor.d.ts

@@ -0,0 +1,3 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const getFileWriteTextContentsActionProcessor: (config: FileStorageConfig) => ActionProcessorListResolver;

package/lib/esm/dynamicActionProcessor/file/getFileWriteTextContentsActionProcessor.js

@@ -0,0 +1,20 @@
+import { actionResult, actionResultError, ErrorTypeEnum, FileActionType, qpqCoreUtils, } from 'quidproquo-core';
+import * as fs from 'fs/promises';
+import { ensureParentDirectoryExists, resolveFilePath } from './utils';
+const getProcessFileWriteTextContents = (qpqConfig, config) => {
+    const serviceName = qpqCoreUtils.getApplicationModuleName(qpqConfig);
+    return async ({ drive, filepath, data }) => {
+        try {
+            const fullPath = resolveFilePath(config, serviceName, drive, filepath);
+            await ensureParentDirectoryExists(fullPath);
+            await fs.writeFile(fullPath, data, 'utf8');
+            return actionResult(void 0);
+        }
+        catch (error) {
+            return actionResultError(ErrorTypeEnum.GenericError, `Error writing file: ${error.message}`);
+        }
+    };
+};
+export const getFileWriteTextContentsActionProcessor = (config) => async (qpqConfig) => ({
+    [FileActionType.WriteTextContents]: getProcessFileWriteTextContents(qpqConfig, config),
+});

package/lib/esm/dynamicActionProcessor/file/index.d.ts

@@ -0,0 +1,6 @@
+import { ActionProcessorListResolver } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export * from './types';
+export declare const getFileActionProcessor: (fileStorageConfig: FileStorageConfig) => ActionProcessorListResolver;
+export * from "./secureUrlUtils";
+export * from "./utils";

package/lib/esm/dynamicActionProcessor/file/index.js

@@ -0,0 +1,32 @@
+import { getFileDeleteActionProcessor } from './getFileDeleteActionProcessor';
+import { getFileExistsActionProcessor } from './getFileExistsActionProcessor';
+import { getFileGenerateTemporarySecureUrlActionProcessor } from './getFileGenerateTemporarySecureUrlActionProcessor';
+import { getFileGenerateTemporaryUploadSecureUrlActionProcessor } from './getFileGenerateTemporaryUploadSecureUrlActionProcessor';
+import { getFileIsColdStorageActionProcessor } from './getFileIsColdStorageActionProcessor';
+import { getFileListDirectoryActionProcessor } from './getFileListDirectoryActionProcessor';
+import { getFileReadBinaryContentsActionProcessor } from './getFileReadBinaryContentsActionProcessor';
+import { getFileReadObjectJsonActionProcessor } from './getFileReadObjectJsonActionProcessor';
+import { getFileReadTextContentsActionProcessor } from './getFileReadTextContentsActionProcessor';
+import { getFileWriteBinaryContentsActionProcessor } from './getFileWriteBinaryContentsActionProcessor';
+import { getFileWriteObjectJsonActionProcessor } from './getFileWriteObjectJsonActionProcessor';
+import { getFileWriteTextContentsActionProcessor } from './getFileWriteTextContentsActionProcessor';
+export * from './types';
+// Main export that accepts configuration
+export const getFileActionProcessor = (fileStorageConfig) => {
+    return async (qpqConfig, dynamicModuleLoader) => ({
+        ...(await getFileReadTextContentsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileWriteTextContentsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileReadObjectJsonActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileWriteObjectJsonActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileReadBinaryContentsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileWriteBinaryContentsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileListDirectoryActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileExistsActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileDeleteActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileGenerateTemporarySecureUrlActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileGenerateTemporaryUploadSecureUrlActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+        ...(await getFileIsColdStorageActionProcessor(fileStorageConfig)(qpqConfig, dynamicModuleLoader)),
+    });
+};
+export * from "./secureUrlUtils";
+export * from "./utils";

package/lib/esm/dynamicActionProcessor/file/secureUrlUtils.d.ts

@@ -0,0 +1,10 @@
+import { FileStorageConfig } from './types';
+export interface SecureUrlToken {
+    fullFilepath: string;
+    operation: 'download' | 'upload';
+    expiresAt: number;
+    contentType?: string;
+}
+export declare const createSecureUrlToken: (token: SecureUrlToken, secret: string) => string;
+export declare const verifySecureUrlToken: (tokenString: string, secret: string) => SecureUrlToken | null;
+export declare const getSecureUrlBaseUrl: (config: FileStorageConfig) => string;

package/lib/esm/dynamicActionProcessor/file/secureUrlUtils.js

@@ -0,0 +1,45 @@
+import * as crypto from 'crypto';
+// Create a signed token for secure URLs
+export const createSecureUrlToken = (token, secret) => {
+    const payload = JSON.stringify(token);
+    const payloadBase64 = Buffer.from(payload).toString('base64url');
+    // Create HMAC signature
+    const signature = crypto
+        .createHmac('sha256', secret)
+        .update(payloadBase64)
+        .digest('base64url');
+    // Return token as payload.signature
+    return `${payloadBase64}.${signature}`;
+};
+// Verify and decode a signed token
+export const verifySecureUrlToken = (tokenString, secret) => {
+    try {
+        const [payloadBase64, signature] = tokenString.split('.');
+        if (!payloadBase64 || !signature) {
+            return null;
+        }
+        // Verify signature
+        const expectedSignature = crypto
+            .createHmac('sha256', secret)
+            .update(payloadBase64)
+            .digest('base64url');
+        if (signature !== expectedSignature) {
+            return null;
+        }
+        // Decode payload
+        const payload = Buffer.from(payloadBase64, 'base64url').toString();
+        const token = JSON.parse(payload);
+        // Check expiration
+        if (token.expiresAt < Date.now()) {
+            return null;
+        }
+        return token;
+    }
+    catch (error) {
+        return null;
+    }
+};
+// Get the secure URL base URL
+export const getSecureUrlBaseUrl = (config) => {
+    return `http://${config.secureUrlHost}:${config.secureUrlPort}`;
+};

package/lib/esm/dynamicActionProcessor/file/types.d.ts

@@ -0,0 +1,6 @@
+export interface FileStorageConfig {
+    storagePath: string;
+    secureUrlPort: number;
+    secureUrlHost: string;
+    secureUrlSecret: string;
+}

package/lib/esm/dynamicActionProcessor/file/types.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/dynamicActionProcessor/file/utils.d.ts

@@ -0,0 +1,6 @@
+import { QPQConfig } from 'quidproquo-core';
+import { FileStorageConfig } from './types';
+export declare const isStorageDriveNameValid: (drive: string, qpqConfig: QPQConfig) => boolean;
+export declare function resolveFilePath(fileStorageConfig: FileStorageConfig, service: string, drive: string, filepath: string): string;
+export declare const ensureDirectoryExists: (dirPath: string) => Promise<void>;
+export declare const ensureParentDirectoryExists: (filePath: string) => Promise<void>;

package/lib/esm/dynamicActionProcessor/file/utils.js

@@ -0,0 +1,41 @@
+import { qpqCoreUtils } from 'quidproquo-core';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Resolve a drive name to a filesystem path
+export const isStorageDriveNameValid = (drive, qpqConfig) => {
+    const storageDrive = qpqCoreUtils.getStorageDrives(qpqConfig).find((d) => d.storageDrive === drive);
+    if (!storageDrive) {
+        return false;
+    }
+    return true;
+};
+export function resolveFilePath(fileStorageConfig, service, drive, filepath) {
+    const root = path.resolve(fileStorageConfig.storagePath, service, drive);
+    // Block absolute paths and null bytes outright
+    if (path.isAbsolute(filepath)) {
+        throw new Error('Absolute paths are not allowed.');
+    }
+    // Check for null to prevent directory traversal attacks in native libs
+    if (filepath.includes('\0')) {
+        throw new Error('Invalid path.');
+    }
+    // Normalize user input (collapses ., .., slashes)
+    const cleaned = path.normalize(filepath);
+    // Resolve against the root
+    const target = path.resolve(root, cleaned);
+    // Ensure target stays within root
+    const rel = path.relative(root, target);
+    if (rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))) {
+        return target;
+    }
+    throw new Error('Invalid file path: escapes drive root.');
+}
+// Ensure a directory exists
+export const ensureDirectoryExists = async (dirPath) => {
+    await fs.mkdir(dirPath, { recursive: true });
+};
+// Ensure the parent directory of a file exists
+export const ensureParentDirectoryExists = async (filePath) => {
+    const parentDir = path.dirname(filePath);
+    await ensureDirectoryExists(parentDir);
+};

package/lib/esm/dynamicActionProcessor/index.d.ts

@@ -0,0 +1 @@
+export * from './file';

package/lib/esm/dynamicActionProcessor/index.js

@@ -0,0 +1 @@
+export * from './file';

package/lib/esm/index.d.ts

@@ -1 +1,2 @@
 export * from './actionProcessor';
+export * from './dynamicActionProcessor';

package/lib/esm/index.js

@@ -1 +1,2 @@
 export * from './actionProcessor';
+export * from './dynamicActionProcessor';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quidproquo-actionprocessor-node",
-  "version": "0.0.256",
+  "version": "0.0.258",
   "description": "",
   "main": "./lib/commonjs/index.js",
   "module": "./lib/esm/index.js",
@@ -35,15 +35,15 @@
     "@anthropic-ai/sdk": "^0.19.1",
     "axios": "^1.2.1",
     "mime-types": "^2.1.35",
-    "quidproquo-core": "0.0.256",
-    "quidproquo-webserver": "0.0.256",
+    "quidproquo-core": "0.0.258",
+    "quidproquo-webserver": "0.0.258",
     "uuid": "^9.0.0",
     "uuidv7": "^1.0.1"
   },
   "devDependencies": {
     "@types/mime-types": "^2.1.1",
     "@types/uuid": "^9.0.0",
-    "quidproquo-tsconfig": "0.0.256",
+    "quidproquo-tsconfig": "0.0.258",
     "typescript": "^5.8.2"
   }
 }