terminal

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.registerArchiveTools = registerArchiveTools;
const sdk_1 = require("@lmstudio/sdk");
const zod_1 = require("zod");
const fileUtilities_1 = require("../fileUtilities");
const securityEnhanced_1 = require("../securityEnhanced");
async function registerArchiveTools() {
    const tools = [];
    tools.push((0, sdk_1.tool)({
        name: "zip_create",
        description: "Create a .zip archive.",
        parameters: {
            entries: zod_1.z.array(zod_1.z.object({
                source: zod_1.z.string().describe("Source path"),
                name: zod_1.z.string().describe("Name in archive"),
            })).describe("List of files/directories"),
            output_path: zod_1.z.string().describe("Output .zip path"),
        },
        implementation: async ({ entries, output_path }) => {
            // Validate output path with system protection
            const outValidation = (0, securityEnhanced_1.validateWritePath)(output_path);
            if (!outValidation.valid) {
                return { success: false, output_path, files_count: 0, total_uncompressed_size: 0, compressed_size: 0, compression_ratio: "0%", error: outValidation.error };
            }
            // Validate each source entry (read-only, use sanitizeFilePath)
            for (const entry of entries) {
                const srcValidation = (0, securityEnhanced_1.sanitizeFilePath)(entry.source);
                if (!srcValidation.valid) {
                    return { success: false, output_path, files_count: 0, total_uncompressed_size: 0, compressed_size: 0, compression_ratio: "0%", error: `Source file '${entry.source}': ${srcValidation.error}` };
                }
            }
            const result = (0, fileUtilities_1.zipCreate)(entries, outValidation.sanitized);
            return {
                success: result.success,
                output_path: result.outputPath,
                files_count: result.filesCount,
                total_uncompressed_size: result.totalUncompressedSize,
                compressed_size: result.compressedSize,
                compression_ratio: result.totalUncompressedSize > 0
                    ? ((1 - result.compressedSize / result.totalUncompressedSize) * 100).toFixed(2) + "%"
                    : "0%",
                error: result.error,
            };
        },
    }));
    tools.push((0, sdk_1.tool)({
        name: "zip_extract",
        description: "Extract a .zip archive.",
        parameters: {
            zip_path: zod_1.z.string().describe("Path to zip"),
            dest_dir: zod_1.z.string().describe("Destination directory"),
        },
        implementation: async ({ zip_path, dest_dir }) => {
            const zipValidation = (0, securityEnhanced_1.sanitizeFilePath)(zip_path);
            if (!zipValidation.valid) {
                return { success: false, extracted_files: [], files_count: 0, error: zipValidation.error };
            }
            const destValidation = (0, securityEnhanced_1.validateWritePath)(dest_dir);
            if (!destValidation.valid) {
                return { success: false, extracted_files: [], files_count: 0, error: destValidation.error };
            }
            const result = (0, fileUtilities_1.zipExtract)(zipValidation.sanitized, destValidation.sanitized);
            return {
                success: result.success,
                extracted_files: result.extractedFiles,
                files_count: result.extractedFiles.length,
                error: result.error,
            };
        },
    }));
    tools.push((0, sdk_1.tool)({
        name: "zip_list",
        description: "List contents of a .zip archive.",
        parameters: { zip_path: zod_1.z.string().describe("Path to zip") },
        implementation: async ({ zip_path }) => {
            const validation = (0, securityEnhanced_1.sanitizeFilePath)(zip_path);
            if (!validation.valid) {
                return { success: false, entries: [], entry_count: 0, total_compressed_size: 0, total_uncompressed_size: 0, overall_compression_ratio: "0%", error: validation.error };
            }
            const result = (0, fileUtilities_1.zipList)(validation.sanitized);
            if (!result.success)
                return { success: false, entries: [], entry_count: 0, total_compressed_size: 0, total_uncompressed_size: 0, overall_compression_ratio: "0%", error: result.error };
            const entries = result.entries.map((e) => ({
                name: e.name,
                compressed_size: e.compressedSize,
                uncompressed_size: e.uncompressedSize,
                is_directory: e.isDirectory,
                compression_ratio: e.uncompressedSize > 0
                    ? (((1 - e.compressedSize / e.uncompressedSize) * 100).toFixed(2) + "%")
                    : "N/A",
            }));
            const totalCompressed = result.entries.reduce((s, e) => s + e.compressedSize, 0);
            const totalUncompressed = result.entries.reduce((s, e) => s + e.uncompressedSize, 0);
            return {
                success: true,
                entries,
                entry_count: result.entries.length,
                total_compressed_size: totalCompressed,
                total_uncompressed_size: totalUncompressed,
                overall_compression_ratio: totalUncompressed > 0
                    ? ((1 - totalCompressed / totalUncompressed) * 100).toFixed(2) + "%"
                    : "0%",
            };
        },
    }));
    return tools;
}
//# sourceMappingURL=archive_tools.js.map