@enconvo/dxt 0.2.6

package/dist/cli/pack.d.ts

@@ -0,0 +1,7 @@
+interface PackOptions {
+    extensionPath: string;
+    outputPath?: string;
+    silent?: boolean;
+}
+export declare function packExtension({ extensionPath, outputPath, silent, }: PackOptions): Promise<boolean>;
+export {};

package/dist/cli/pack.js

@@ -0,0 +1,194 @@
+import { confirm } from "@inquirer/prompts";
+import { createHash } from "crypto";
+import { zipSync } from "fflate";
+import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync, } from "fs";
+import { basename, join, relative, resolve, sep } from "path";
+import { getAllFilesWithCount, readDxtIgnorePatterns } from "../node/files.js";
+import { validateManifest } from "../node/validate.js";
+import { DxtManifestSchema } from "../schemas.js";
+import { getLogger } from "../shared/log.js";
+import { initExtension } from "./init.js";
+function formatFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes}B`;
+    }
+    else if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)}kB`;
+    }
+    else {
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    }
+}
+function sanitizeNameForFilename(name) {
+    // Replace spaces with hyphens
+    // Remove or replace characters that are problematic in filenames
+    return name
+        .toLowerCase()
+        .replace(/\s+/g, "-") // Replace spaces with hyphens
+        .replace(/[^a-z0-9-_.]/g, "") // Keep only alphanumeric, hyphens, underscores, and dots
+        .replace(/-+/g, "-") // Replace multiple hyphens with single hyphen
+        .replace(/^-+|-+$/g, "") // Remove leading/trailing hyphens
+        .substring(0, 100); // Limit length to 100 characters
+}
+export async function packExtension({ extensionPath, outputPath, silent, }) {
+    const resolvedPath = resolve(extensionPath);
+    const logger = getLogger({ silent });
+    // Check if directory exists
+    if (!existsSync(resolvedPath) || !statSync(resolvedPath).isDirectory()) {
+        logger.error(`ERROR: Directory not found: ${extensionPath}`);
+        return false;
+    }
+    // Check if manifest exists
+    const manifestPath = join(resolvedPath, "manifest.json");
+    if (!existsSync(manifestPath)) {
+        logger.log(`No manifest.json found in ${extensionPath}`);
+        const shouldInit = await confirm({
+            message: "Would you like to create a manifest.json file?",
+            default: true,
+        });
+        if (shouldInit) {
+            const success = await initExtension(extensionPath);
+            if (!success) {
+                logger.error("ERROR: Failed to create manifest");
+                return false;
+            }
+        }
+        else {
+            logger.error("ERROR: Cannot pack extension without manifest.json");
+            return false;
+        }
+    }
+    // Validate manifest first
+    logger.log("Validating manifest...");
+    if (!validateManifest(manifestPath)) {
+        logger.error("ERROR: Cannot pack extension with invalid manifest");
+        return false;
+    }
+    // Read and parse manifest
+    let manifest;
+    try {
+        const manifestContent = readFileSync(manifestPath, "utf-8");
+        const manifestData = JSON.parse(manifestContent);
+        manifest = DxtManifestSchema.parse(manifestData);
+    }
+    catch (error) {
+        logger.error("ERROR: Failed to parse manifest.json");
+        if (error instanceof Error) {
+            logger.error(`  ${error.message}`);
+        }
+        return false;
+    }
+    // Determine output path
+    const extensionName = basename(resolvedPath);
+    const finalOutputPath = outputPath
+        ? resolve(outputPath)
+        : resolve(`${extensionName}.dxt`);
+    // Ensure output directory exists
+    const outputDir = join(finalOutputPath, "..");
+    mkdirSync(outputDir, { recursive: true });
+    try {
+        // Read .dxtignore patterns if present
+        const dxtIgnorePatterns = readDxtIgnorePatterns(resolvedPath);
+        // Get all files in the extension directory
+        const { files, ignoredCount } = getAllFilesWithCount(resolvedPath, resolvedPath, {}, dxtIgnorePatterns);
+        // Print package header
+        logger.log(`\n📦  ${manifest.name}@${manifest.version}`);
+        // Print file list
+        logger.log("Archive Contents");
+        const fileEntries = Object.entries(files);
+        let totalUnpackedSize = 0;
+        // Sort files for consistent output
+        fileEntries.sort(([a], [b]) => a.localeCompare(b));
+        // Group files by directory for deep nesting
+        const directoryGroups = new Map();
+        const shallowFiles = [];
+        for (const [filePath, fileData] of fileEntries) {
+            const relPath = relative(resolvedPath, filePath);
+            const content = fileData.data;
+            const size = typeof content === "string"
+                ? Buffer.byteLength(content, "utf8")
+                : content.length;
+            totalUnpackedSize += size;
+            // Check if file is deeply nested (3+ levels)
+            const parts = relPath.split(sep);
+            if (parts.length > 3) {
+                // Group by the first 3 directory levels
+                const groupKey = parts.slice(0, 3).join("/");
+                if (!directoryGroups.has(groupKey)) {
+                    directoryGroups.set(groupKey, { files: [], totalSize: 0 });
+                }
+                const group = directoryGroups.get(groupKey);
+                group.files.push(relPath);
+                group.totalSize += size;
+            }
+            else {
+                shallowFiles.push({ path: relPath, size });
+            }
+        }
+        // Print shallow files first
+        for (const { path, size } of shallowFiles) {
+            logger.log(`${formatFileSize(size).padStart(8)} ${path}`);
+        }
+        // Print grouped directories
+        for (const [dir, { files, totalSize }] of directoryGroups) {
+            if (files.length === 1) {
+                // If only one file in the group, print it normally
+                const filePath = files[0];
+                const fileSize = totalSize;
+                logger.log(`${formatFileSize(fileSize).padStart(8)} ${filePath}`);
+            }
+            else {
+                // Print directory summary
+                logger.log(`${formatFileSize(totalSize).padStart(8)} ${dir}/ [and ${files.length} more files]`);
+            }
+        }
+        // Create zip with preserved file permissions
+        const zipFiles = {};
+        const isUnix = process.platform !== "win32";
+        for (const [filePath, fileData] of Object.entries(files)) {
+            if (isUnix) {
+                // Set external file attributes to preserve Unix permissions
+                // The mode needs to be shifted to the upper 16 bits for ZIP format
+                zipFiles[filePath] = [
+                    fileData.data,
+                    { os: 3, attrs: (fileData.mode & 0o777) << 16 },
+                ];
+            }
+            else {
+                // On Windows, use default ZIP attributes (no Unix permissions)
+                zipFiles[filePath] = fileData.data;
+            }
+        }
+        const zipData = zipSync(zipFiles, {
+            level: 9, // Maximum compression
+            mtime: new Date(),
+        });
+        // Write zip file
+        writeFileSync(finalOutputPath, zipData);
+        // Calculate SHA sum
+        const shasum = createHash("sha1").update(zipData).digest("hex");
+        // Print archive details
+        const sanitizedName = sanitizeNameForFilename(manifest.name);
+        const archiveName = `${sanitizedName}-${manifest.version}.dxt`;
+        logger.log("\nArchive Details");
+        logger.log(`name: ${manifest.name}`);
+        logger.log(`version: ${manifest.version}`);
+        logger.log(`filename: ${archiveName}`);
+        logger.log(`package size: ${formatFileSize(zipData.length)}`);
+        logger.log(`unpacked size: ${formatFileSize(totalUnpackedSize)}`);
+        logger.log(`shasum: ${shasum}`);
+        logger.log(`total files: ${fileEntries.length}`);
+        logger.log(`ignored (.dxtignore) files: ${ignoredCount}`);
+        logger.log(`\nOutput: ${finalOutputPath}`);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            logger.error(`ERROR: Archive error: ${error.message}`);
+        }
+        else {
+            logger.error("ERROR: Unknown archive error occurred");
+        }
+        return false;
+    }
+}

package/dist/cli/unpack.d.ts

@@ -0,0 +1,7 @@
+interface UnpackOptions {
+    dxtPath: string;
+    outputDir?: string;
+    silent?: boolean;
+}
+export declare function unpackExtension({ dxtPath, outputDir, silent, }: UnpackOptions): Promise<boolean>;
+export {};

package/dist/cli/unpack.js

@@ -0,0 +1,101 @@
+import { unzipSync } from "fflate";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, } from "fs";
+import { join, resolve, sep } from "path";
+import { extractSignatureBlock } from "../node/sign.js";
+import { getLogger } from "../shared/log.js";
+export async function unpackExtension({ dxtPath, outputDir, silent, }) {
+    const logger = getLogger({ silent });
+    const resolvedDxtPath = resolve(dxtPath);
+    if (!existsSync(resolvedDxtPath)) {
+        logger.error(`ERROR: DXT file not found: ${dxtPath}`);
+        return false;
+    }
+    const finalOutputDir = outputDir ? resolve(outputDir) : process.cwd();
+    if (!existsSync(finalOutputDir)) {
+        mkdirSync(finalOutputDir, { recursive: true });
+    }
+    try {
+        const fileContent = readFileSync(resolvedDxtPath);
+        const { originalContent } = extractSignatureBlock(fileContent);
+        // Parse file attributes from ZIP central directory
+        const fileAttributes = new Map();
+        const isUnix = process.platform !== "win32";
+        if (isUnix) {
+            // Parse ZIP central directory to extract file attributes
+            const zipBuffer = originalContent;
+            // Find end of central directory record
+            let eocdOffset = -1;
+            for (let i = zipBuffer.length - 22; i >= 0; i--) {
+                if (zipBuffer.readUInt32LE(i) === 0x06054b50) {
+                    eocdOffset = i;
+                    break;
+                }
+            }
+            if (eocdOffset !== -1) {
+                const centralDirOffset = zipBuffer.readUInt32LE(eocdOffset + 16);
+                const centralDirEntries = zipBuffer.readUInt16LE(eocdOffset + 8);
+                let offset = centralDirOffset;
+                for (let i = 0; i < centralDirEntries; i++) {
+                    if (zipBuffer.readUInt32LE(offset) === 0x02014b50) {
+                        const externalAttrs = zipBuffer.readUInt32LE(offset + 38);
+                        const filenameLength = zipBuffer.readUInt16LE(offset + 28);
+                        const filename = zipBuffer.toString("utf8", offset + 46, offset + 46 + filenameLength);
+                        // Extract Unix permissions from external attributes (upper 16 bits)
+                        const mode = (externalAttrs >> 16) & 0o777;
+                        if (mode > 0) {
+                            fileAttributes.set(filename, mode);
+                        }
+                        const extraFieldLength = zipBuffer.readUInt16LE(offset + 30);
+                        const commentLength = zipBuffer.readUInt16LE(offset + 32);
+                        offset += 46 + filenameLength + extraFieldLength + commentLength;
+                    }
+                    else {
+                        break;
+                    }
+                }
+            }
+        }
+        const decompressed = unzipSync(originalContent);
+        for (const relativePath in decompressed) {
+            if (Object.prototype.hasOwnProperty.call(decompressed, relativePath)) {
+                const data = decompressed[relativePath];
+                const fullPath = join(finalOutputDir, relativePath);
+                // Prevent zip slip attacks by validating the resolved path
+                const normalizedPath = resolve(fullPath);
+                const normalizedOutputDir = resolve(finalOutputDir);
+                if (!normalizedPath.startsWith(normalizedOutputDir + sep) &&
+                    normalizedPath !== normalizedOutputDir) {
+                    throw new Error(`Path traversal attempt detected: ${relativePath}`);
+                }
+                const dir = join(fullPath, "..");
+                if (!existsSync(dir)) {
+                    mkdirSync(dir, { recursive: true });
+                }
+                writeFileSync(fullPath, data);
+                // Restore Unix file permissions if available
+                if (isUnix && fileAttributes.has(relativePath)) {
+                    try {
+                        const mode = fileAttributes.get(relativePath);
+                        if (mode !== undefined) {
+                            chmodSync(fullPath, mode);
+                        }
+                    }
+                    catch (error) {
+                        // Silently ignore permission errors
+                    }
+                }
+            }
+        }
+        logger.log(`Extension unpacked successfully to ${finalOutputDir}`);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            logger.error(`ERROR: Failed to unpack extension: ${error.message}`);
+        }
+        else {
+            logger.error("ERROR: An unknown error occurred during unpacking.");
+        }
+        return false;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+export * from "./cli/init.js";
+export * from "./cli/pack.js";
+export * from "./schemas.js";
+export * from "./shared/config.js";
+export * from "./types.js";
+export * from "./node/files.js";
+export * from "./node/sign.js";
+export * from "./node/validate.js";

package/dist/cli.js

@@ -0,0 +1,11 @@
+// CLI-specific exports
+export * from "./cli/init.js";
+export * from "./cli/pack.js";
+// Include all shared exports
+export * from "./schemas.js";
+export * from "./shared/config.js";
+export * from "./types.js";
+// Include node exports since CLI needs them
+export * from "./node/files.js";
+export * from "./node/sign.js";
+export * from "./node/validate.js";

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./cli/init.js";
+export * from "./cli/pack.js";
+export * from "./cli/unpack.js";
+export * from "./node/files.js";
+export * from "./node/sign.js";
+export * from "./node/validate.js";
+export * from "./schemas.js";
+export * from "./shared/config.js";
+export * from "./types.js";

package/dist/index.js

@@ -0,0 +1,10 @@
+// Default export includes everything (backward compatibility)
+export * from "./cli/init.js";
+export * from "./cli/pack.js";
+export * from "./cli/unpack.js";
+export * from "./node/files.js";
+export * from "./node/sign.js";
+export * from "./node/validate.js";
+export * from "./schemas.js";
+export * from "./shared/config.js";
+export * from "./types.js";

package/dist/node/files.d.ts

@@ -0,0 +1,20 @@
+export declare const EXCLUDE_PATTERNS: string[];
+/**
+ * Read and parse .dxtignore file patterns
+ */
+export declare function readDxtIgnorePatterns(baseDir: string): string[];
+/**
+ * Used for testing, calls the same methods as the other ignore checks
+ */
+export declare function shouldExclude(filePath: string, additionalPatterns?: string[]): boolean;
+export declare function getAllFiles(dirPath: string, baseDir?: string, fileList?: Record<string, Uint8Array>, additionalPatterns?: string[]): Record<string, Uint8Array>;
+interface FileWithPermissions {
+    data: Uint8Array;
+    mode: number;
+}
+export interface GetAllFilesResult {
+    files: Record<string, FileWithPermissions>;
+    ignoredCount: number;
+}
+export declare function getAllFilesWithCount(dirPath: string, baseDir?: string, fileList?: Record<string, FileWithPermissions>, additionalPatterns?: string[], ignoredCount?: number): GetAllFilesResult;
+export {};

package/dist/node/files.js

@@ -0,0 +1,115 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import ignore from "ignore";
+import { join, relative, sep } from "path";
+// Files/patterns to exclude from the package
+export const EXCLUDE_PATTERNS = [
+    ".DS_Store",
+    "Thumbs.db",
+    ".gitignore",
+    ".git",
+    ".dxtignore",
+    "*.log",
+    ".env*",
+    ".npm",
+    ".npmrc",
+    ".yarnrc",
+    ".yarn",
+    ".eslintrc",
+    ".editorconfig",
+    ".prettierrc",
+    ".prettierignore",
+    ".eslintignore",
+    ".nycrc",
+    ".babelrc",
+    ".pnp.*",
+    "node_modules/.cache",
+    "node_modules/.bin",
+    "*.map",
+    ".env.local",
+    ".env.*.local",
+    "npm-debug.log*",
+    "yarn-debug.log*",
+    "yarn-error.log*",
+    "package-lock.json",
+    "yarn.lock",
+    "*.dxt",
+    "*.d.ts",
+    "*.tsbuildinfo",
+    "tsconfig.json",
+];
+/**
+ * Read and parse .dxtignore file patterns
+ */
+export function readDxtIgnorePatterns(baseDir) {
+    const dxtIgnorePath = join(baseDir, ".dxtignore");
+    if (!existsSync(dxtIgnorePath)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(dxtIgnorePath, "utf-8");
+        return content
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith("#"));
+    }
+    catch (error) {
+        console.warn(`Warning: Could not read .dxtignore file: ${error instanceof Error ? error.message : "Unknown error"}`);
+        return [];
+    }
+}
+function buildIgnoreChecker(additionalPatterns) {
+    return ignore().add(EXCLUDE_PATTERNS).add(additionalPatterns);
+}
+/**
+ * Used for testing, calls the same methods as the other ignore checks
+ */
+export function shouldExclude(filePath, additionalPatterns = []) {
+    return buildIgnoreChecker(additionalPatterns).ignores(filePath);
+}
+export function getAllFiles(dirPath, baseDir = dirPath, fileList = {}, additionalPatterns = []) {
+    const files = readdirSync(dirPath);
+    const ignoreChecker = buildIgnoreChecker(additionalPatterns);
+    for (const file of files) {
+        const filePath = join(dirPath, file);
+        const relativePath = relative(baseDir, filePath);
+        if (ignoreChecker.ignores(relativePath)) {
+            continue;
+        }
+        const stat = statSync(filePath);
+        if (stat.isDirectory()) {
+            getAllFiles(filePath, baseDir, fileList, additionalPatterns);
+        }
+        else {
+            // Use forward slashes in zip file paths
+            const zipPath = relativePath.split(sep).join("/");
+            fileList[zipPath] = readFileSync(filePath);
+        }
+    }
+    return fileList;
+}
+export function getAllFilesWithCount(dirPath, baseDir = dirPath, fileList = {}, additionalPatterns = [], ignoredCount = 0) {
+    const files = readdirSync(dirPath);
+    const ignoreChecker = buildIgnoreChecker(additionalPatterns);
+    for (const file of files) {
+        const filePath = join(dirPath, file);
+        const relativePath = relative(baseDir, filePath);
+        if (ignoreChecker.ignores(relativePath)) {
+            ignoredCount++;
+            continue;
+        }
+        const stat = statSync(filePath);
+        if (stat.isDirectory()) {
+            const result = getAllFilesWithCount(filePath, baseDir, fileList, additionalPatterns, ignoredCount);
+            ignoredCount = result.ignoredCount;
+        }
+        else {
+            // Use forward slashes in zip file paths
+            const zipPath = relativePath.split(sep).join("/");
+            fileList[zipPath] = {
+                data: readFileSync(filePath),
+                mode: stat.mode,
+            };
+        }
+    }
+    return { files: fileList, ignoredCount };
+}

package/dist/node/sign.d.ts

@@ -0,0 +1,32 @@
+import type { DxtSignatureInfo } from "../types.js";
+/**
+ * Signs a DXT file with the given certificate and private key using PKCS#7
+ *
+ * @param dxtPath Path to the DXT file to sign
+ * @param certPath Path to the certificate file (PEM format)
+ * @param keyPath Path to the private key file (PEM format)
+ * @param intermediates Optional array of intermediate certificate paths
+ */
+export declare function signDxtFile(dxtPath: string, certPath: string, keyPath: string, intermediates?: string[]): void;
+/**
+ * Verifies a signed DXT file using OS certificate store
+ *
+ * @param dxtPath Path to the signed DXT file
+ * @returns Signature information including verification status
+ */
+export declare function verifyDxtFile(dxtPath: string): Promise<DxtSignatureInfo>;
+/**
+ * Extracts the signature block from a signed DXT file
+ */
+export declare function extractSignatureBlock(fileContent: Buffer): {
+    originalContent: Buffer;
+    pkcs7Signature?: Buffer;
+};
+/**
+ * Verifies certificate chain against OS trust store
+ */
+export declare function verifyCertificateChain(certificate: Buffer, intermediates?: Buffer[]): Promise<boolean>;
+/**
+ * Removes signature from a DXT file
+ */
+export declare function unsignDxtFile(dxtPath: string): void;