aicm 0.20.1 → 0.20.5

package/dist/utils/hooks.d.ts

@@ -1,50 +0,0 @@
-export type HookType = "beforeShellExecution" | "beforeMCPExecution" | "afterShellExecution" | "afterMCPExecution" | "beforeReadFile" | "afterFileEdit" | "beforeSubmitPrompt" | "stop";
-export interface HookCommand {
-    command: string;
-}
-export interface HooksJson {
-    version: number;
-    hooks: {
-        [K in HookType]?: HookCommand[];
-    };
-}
-export interface HookFile {
-    name: string;
-    basename: string;
-    content: Buffer;
-    sourcePath: string;
-    source: "local" | "preset";
-    presetName?: string;
-}
-/**
- * Load hooks configuration from a root directory
- * The directory should contain hooks.json (sibling to hooks/ directory)
- * All files in the hooks/ subdirectory are copied during installation
- */
-export declare function loadHooksFromDirectory(rootDir: string, source: "local" | "preset", presetName?: string): Promise<{
-    config: HooksJson;
-    files: HookFile[];
-}>;
-/**
- * Merge multiple hooks configurations into one
- * Later configurations override earlier ones for the same hook type
- */
-export declare function mergeHooksConfigs(configs: HooksJson[]): HooksJson;
-/**
- * Rewrite command paths to point to the managed hooks directory (hooks/aicm/)
- * At this point, paths are already namespaced filenames from loadHooksFromDirectory
- */
-export declare function rewriteHooksConfigToManagedDir(hooksConfig: HooksJson): HooksJson;
-/**
- * Count the number of hook entries in a hooks configuration
- */
-export declare function countHooks(hooksConfig: HooksJson): number;
-/**
- * Dedupe hook files by namespaced path, warn on content conflicts
- * Presets are namespaced with directories, so same basename from different presets won't collide
- */
-export declare function dedupeHookFiles(hookFiles: HookFile[]): HookFile[];
-/**
- * Write hooks configuration and files to Cursor target
- */
-export declare function writeHooksToCursor(hooksConfig: HooksJson, hookFiles: HookFile[], cwd: string): void;

package/dist/utils/hooks.js

@@ -1,346 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadHooksFromDirectory = loadHooksFromDirectory;
-exports.mergeHooksConfigs = mergeHooksConfigs;
-exports.rewriteHooksConfigToManagedDir = rewriteHooksConfigToManagedDir;
-exports.countHooks = countHooks;
-exports.dedupeHookFiles = dedupeHookFiles;
-exports.writeHooksToCursor = writeHooksToCursor;
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_path_1 = __importDefault(require("node:path"));
-const config_1 = require("./config");
-/**
- * Validate that a command path points to a file within the hooks directory
- * Commands should be relative paths starting with ./hooks/
- */
-function validateHookPath(commandPath, rootDir, hooksDir) {
-    if (!commandPath.startsWith("./") && !commandPath.startsWith("../")) {
-        return { valid: false };
-    }
-    // Resolve path relative to rootDir (where hooks.json is located)
-    const resolvedPath = node_path_1.default.resolve(rootDir, commandPath);
-    const relativePath = node_path_1.default.relative(hooksDir, resolvedPath);
-    // Check if the file is within hooks directory (not using .. to escape)
-    if (relativePath.startsWith("..") || node_path_1.default.isAbsolute(relativePath)) {
-        return { valid: false };
-    }
-    return { valid: true, relativePath };
-}
-/**
- * Load all files from the hooks directory
- */
-async function loadAllFilesFromDirectory(dir, baseDir = dir) {
-    const files = [];
-    const entries = await fs_extra_1.default.readdir(dir, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = node_path_1.default.join(dir, entry.name);
-        if (entry.isDirectory()) {
-            // Recursively load files from subdirectories
-            const subFiles = await loadAllFilesFromDirectory(fullPath, baseDir);
-            files.push(...subFiles);
-        }
-        else if (entry.isFile() && entry.name !== "hooks.json") {
-            // Skip hooks.json, collect all other files
-            const relativePath = node_path_1.default.relative(baseDir, fullPath);
-            files.push({ relativePath, absolutePath: fullPath });
-        }
-    }
-    return files;
-}
-/**
- * Load hooks configuration from a root directory
- * The directory should contain hooks.json (sibling to hooks/ directory)
- * All files in the hooks/ subdirectory are copied during installation
- */
-async function loadHooksFromDirectory(rootDir, source, presetName) {
-    const hooksFilePath = node_path_1.default.join(rootDir, "hooks.json");
-    const hooksDir = node_path_1.default.join(rootDir, "hooks");
-    if (!fs_extra_1.default.existsSync(hooksFilePath)) {
-        return {
-            config: { version: 1, hooks: {} },
-            files: [],
-        };
-    }
-    const content = await fs_extra_1.default.readFile(hooksFilePath, "utf8");
-    const hooksConfig = JSON.parse(content);
-    // Load all files from hooks/ subdirectory
-    const hookFiles = [];
-    if (fs_extra_1.default.existsSync(hooksDir)) {
-        const allFiles = await loadAllFilesFromDirectory(hooksDir);
-        // Create a map of all files for validation
-        const filePathMap = new Map();
-        for (const file of allFiles) {
-            filePathMap.set(file.relativePath, file.absolutePath);
-        }
-        // Validate that all referenced commands point to files within hooks directory
-        if (hooksConfig.hooks) {
-            for (const hookType of Object.keys(hooksConfig.hooks)) {
-                const hookCommands = hooksConfig.hooks[hookType];
-                if (hookCommands && Array.isArray(hookCommands)) {
-                    for (const hookCommand of hookCommands) {
-                        const commandPath = hookCommand.command;
-                        if (commandPath && typeof commandPath === "string") {
-                            const validation = validateHookPath(commandPath, rootDir, hooksDir);
-                            if (!validation.valid || !validation.relativePath) {
-                                console.warn(`Warning: Hook command "${commandPath}" in hooks.json must reference a file within the hooks/ directory. Skipping.`);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        // Copy all files from the hooks/ directory
-        for (const file of allFiles) {
-            const fileContent = await fs_extra_1.default.readFile(file.absolutePath);
-            const basename = node_path_1.default.basename(file.absolutePath);
-            // Namespace preset files
-            let namespacedPath;
-            if (source === "preset" && presetName) {
-                const namespace = (0, config_1.extractNamespaceFromPresetPath)(presetName);
-                // Use posix paths for consistent cross-platform behavior
-                namespacedPath = node_path_1.default.posix.join(...namespace, file.relativePath.split(node_path_1.default.sep).join(node_path_1.default.posix.sep));
-            }
-            else {
-                // For local files, use the relative path as-is
-                namespacedPath = file.relativePath.split(node_path_1.default.sep).join(node_path_1.default.posix.sep);
-            }
-            hookFiles.push({
-                name: namespacedPath,
-                basename,
-                content: fileContent,
-                sourcePath: file.absolutePath,
-                source,
-                presetName,
-            });
-        }
-    }
-    // Rewrite the config to use namespaced file names
-    const rewrittenConfig = rewriteHooksConfigForNamespace(hooksConfig, hookFiles, rootDir);
-    return { config: rewrittenConfig, files: hookFiles };
-}
-/**
- * Rewrite hooks config to use the namespaced names from the hook files
- */
-function rewriteHooksConfigForNamespace(hooksConfig, hookFiles, rootDir) {
-    // Create a map from sourcePath to the hookFile
-    const sourcePathToFile = new Map();
-    for (const hookFile of hookFiles) {
-        sourcePathToFile.set(hookFile.sourcePath, hookFile);
-    }
-    const rewritten = {
-        version: hooksConfig.version,
-        hooks: {},
-    };
-    if (hooksConfig.hooks) {
-        for (const hookType of Object.keys(hooksConfig.hooks)) {
-            const hookCommands = hooksConfig.hooks[hookType];
-            if (hookCommands && Array.isArray(hookCommands)) {
-                rewritten.hooks[hookType] = hookCommands
-                    .map((hookCommand) => {
-                    const commandPath = hookCommand.command;
-                    if (commandPath &&
-                        typeof commandPath === "string" &&
-                        (commandPath.startsWith("./") || commandPath.startsWith("../"))) {
-                        // Resolve path relative to rootDir (where hooks.json is)
-                        const resolvedPath = node_path_1.default.resolve(rootDir, commandPath);
-                        const hookFile = sourcePathToFile.get(resolvedPath);
-                        if (hookFile) {
-                            // Use the namespaced name
-                            return { command: hookFile.name };
-                        }
-                        // File was invalid or not found, filter it out
-                        return null;
-                    }
-                    return hookCommand;
-                })
-                    .filter((cmd) => cmd !== null);
-            }
-        }
-    }
-    return rewritten;
-}
-/**
- * Merge multiple hooks configurations into one
- * Later configurations override earlier ones for the same hook type
- */
-function mergeHooksConfigs(configs) {
-    const merged = {
-        version: 1,
-        hooks: {},
-    };
-    for (const config of configs) {
-        // Use the latest version
-        if (config.version) {
-            merged.version = config.version;
-        }
-        // Merge hooks - concatenate arrays for each hook type
-        if (config.hooks) {
-            for (const hookType of Object.keys(config.hooks)) {
-                const hookCommands = config.hooks[hookType];
-                if (hookCommands && Array.isArray(hookCommands)) {
-                    if (!merged.hooks[hookType]) {
-                        merged.hooks[hookType] = [];
-                    }
-                    // Concatenate commands (later configs add to the list)
-                    merged.hooks[hookType] = [
-                        ...(merged.hooks[hookType] || []),
-                        ...hookCommands,
-                    ];
-                }
-            }
-        }
-    }
-    return merged;
-}
-/**
- * Rewrite command paths to point to the managed hooks directory (hooks/aicm/)
- * At this point, paths are already namespaced filenames from loadHooksFromDirectory
- */
-function rewriteHooksConfigToManagedDir(hooksConfig) {
-    const rewritten = {
-        version: hooksConfig.version,
-        hooks: {},
-    };
-    if (hooksConfig.hooks) {
-        for (const hookType of Object.keys(hooksConfig.hooks)) {
-            const hookCommands = hooksConfig.hooks[hookType];
-            if (hookCommands && Array.isArray(hookCommands)) {
-                rewritten.hooks[hookType] = hookCommands.map((hookCommand) => {
-                    const commandPath = hookCommand.command;
-                    if (commandPath && typeof commandPath === "string") {
-                        return { command: `./hooks/aicm/${commandPath}` };
-                    }
-                    return hookCommand;
-                });
-            }
-        }
-    }
-    return rewritten;
-}
-/**
- * Count the number of hook entries in a hooks configuration
- */
-function countHooks(hooksConfig) {
-    let count = 0;
-    if (hooksConfig.hooks) {
-        for (const hookType of Object.keys(hooksConfig.hooks)) {
-            const hookCommands = hooksConfig.hooks[hookType];
-            if (hookCommands && Array.isArray(hookCommands)) {
-                count += hookCommands.length;
-            }
-        }
-    }
-    return count;
-}
-/**
- * Dedupe hook files by namespaced path, warn on content conflicts
- * Presets are namespaced with directories, so same basename from different presets won't collide
- */
-function dedupeHookFiles(hookFiles) {
-    const fileMap = new Map();
-    for (const hookFile of hookFiles) {
-        const namespacedPath = hookFile.name;
-        if (fileMap.has(namespacedPath)) {
-            const existing = fileMap.get(namespacedPath);
-            const existingHash = node_crypto_1.default
-                .createHash("md5")
-                .update(existing.content)
-                .digest("hex");
-            const currentHash = node_crypto_1.default
-                .createHash("md5")
-                .update(hookFile.content)
-                .digest("hex");
-            if (existingHash !== currentHash) {
-                const sourceInfo = hookFile.presetName
-                    ? `preset "${hookFile.presetName}"`
-                    : hookFile.source;
-                const existingSourceInfo = existing.presetName
-                    ? `preset "${existing.presetName}"`
-                    : existing.source;
-                console.warn(`Warning: Hook file "${namespacedPath}" has different content from ${existingSourceInfo} and ${sourceInfo}. Using last occurrence.`);
-            }
-            // Last writer wins
-            fileMap.set(namespacedPath, hookFile);
-        }
-        else {
-            fileMap.set(namespacedPath, hookFile);
-        }
-    }
-    return Array.from(fileMap.values());
-}
-/**
- * Write hooks configuration and files to Cursor target
- */
-function writeHooksToCursor(hooksConfig, hookFiles, cwd) {
-    const cursorRoot = node_path_1.default.join(cwd, ".cursor");
-    const hooksJsonPath = node_path_1.default.join(cursorRoot, "hooks.json");
-    const hooksDir = node_path_1.default.join(cursorRoot, "hooks", "aicm");
-    // Dedupe hook files
-    const dedupedHookFiles = dedupeHookFiles(hookFiles);
-    // Create hooks directory and clean it
-    fs_extra_1.default.emptyDirSync(hooksDir);
-    // Copy hook files to managed directory
-    for (const hookFile of dedupedHookFiles) {
-        const targetPath = node_path_1.default.join(hooksDir, hookFile.name);
-        fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(targetPath));
-        fs_extra_1.default.writeFileSync(targetPath, hookFile.content);
-    }
-    // Rewrite paths to point to managed directory
-    const finalConfig = rewriteHooksConfigToManagedDir(hooksConfig);
-    // Read existing hooks.json and preserve user hooks
-    let existingConfig = null;
-    if (fs_extra_1.default.existsSync(hooksJsonPath)) {
-        try {
-            existingConfig = fs_extra_1.default.readJsonSync(hooksJsonPath);
-        }
-        catch (_a) {
-            existingConfig = null;
-        }
-    }
-    // Extract user hooks (non-aicm managed)
-    const userHooks = { version: 1, hooks: {} };
-    if (existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.hooks) {
-        for (const hookType of Object.keys(existingConfig.hooks)) {
-            const commands = existingConfig.hooks[hookType];
-            if (commands && Array.isArray(commands)) {
-                const userCommands = commands.filter((cmd) => { var _a; return !((_a = cmd.command) === null || _a === void 0 ? void 0 : _a.includes("hooks/aicm/")); });
-                if (userCommands.length > 0) {
-                    userHooks.hooks[hookType] = userCommands;
-                }
-            }
-        }
-    }
-    // Merge user hooks with aicm hooks
-    const mergedConfig = {
-        version: finalConfig.version,
-        hooks: {},
-    };
-    // Add user hooks first
-    if (userHooks.hooks) {
-        for (const hookType of Object.keys(userHooks.hooks)) {
-            const commands = userHooks.hooks[hookType];
-            if (commands) {
-                mergedConfig.hooks[hookType] = [...commands];
-            }
-        }
-    }
-    // Then add aicm hooks
-    if (finalConfig.hooks) {
-        for (const hookType of Object.keys(finalConfig.hooks)) {
-            const commands = finalConfig.hooks[hookType];
-            if (commands) {
-                if (!mergedConfig.hooks[hookType]) {
-                    mergedConfig.hooks[hookType] = [];
-                }
-                mergedConfig.hooks[hookType].push(...commands);
-            }
-        }
-    }
-    // Write hooks.json
-    fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(hooksJsonPath));
-    fs_extra_1.default.writeJsonSync(hooksJsonPath, mergedConfig, { spaces: 2 });
-}

package/dist/utils/is-ci.d.ts

@@ -1 +0,0 @@
-export declare const isCIEnvironment: () => boolean;

package/dist/utils/is-ci.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isCIEnvironment = void 0;
-const node_process_1 = require("node:process");
-const isCIEnvironment = () => (node_process_1.env.CI !== "0" && node_process_1.env.CI !== "false" && "CI" in node_process_1.env) ||
-    "CONTINUOUS_INTEGRATION" in node_process_1.env ||
-    Object.keys(node_process_1.env).some((key) => key.startsWith("CI_"));
-exports.isCIEnvironment = isCIEnvironment;

package/dist/utils/rules-file-writer.d.ts

@@ -1,24 +0,0 @@
-export type RuleMetadata = Record<string, string | boolean | string[]>;
-/**
- * Parse YAML frontmatter blocks from a rule file and return a flat metadata object
- */
-export declare function parseRuleFrontmatter(content: string): RuleMetadata;
-/**
- * Remove the rules block from the content
- */
-export declare function removeRulesBlock(content: string): string;
-/**
- * Write rules to the .windsurfrules file
- * This will update the content between the RULES_BEGIN and RULES_END markers
- * If the file doesn't exist, it will create it
- * If the markers don't exist, it will append them to the existing content
- */
-export declare function writeRulesFile(rulesContent: string, rulesFilePath?: string): void;
-/**
- * Generate the rules file content based on rule files
- */
-export declare function generateRulesFileContent(ruleFiles: {
-    name: string;
-    path: string;
-    metadata: Record<string, string | boolean | string[]>;
-}[]): string;

package/dist/utils/rules-file-writer.js

@@ -1,197 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRuleFrontmatter = parseRuleFrontmatter;
-exports.removeRulesBlock = removeRulesBlock;
-exports.writeRulesFile = writeRulesFile;
-exports.generateRulesFileContent = generateRulesFileContent;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-/**
- * Parse YAML frontmatter blocks from a rule file and return a flat metadata object
- */
-function parseRuleFrontmatter(content) {
-    const metadata = {};
-    // Support both LF and CRLF line endings
-    const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/gm;
-    let match;
-    while ((match = frontmatterRegex.exec(content)) !== null) {
-        const lines = match[1].split("\n");
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed)
-                continue;
-            const [key, ...rest] = trimmed.split(":");
-            if (!key)
-                continue;
-            const raw = rest.join(":").trim();
-            if (raw === "") {
-                metadata[key] = "";
-            }
-            else if (raw === "true" || raw === "false") {
-                metadata[key] = raw === "true";
-            }
-            else if (raw.startsWith("[") && raw.endsWith("]")) {
-                try {
-                    const parsed = JSON.parse(raw.replace(/'/g, '"'));
-                    metadata[key] = parsed;
-                }
-                catch (_a) {
-                    metadata[key] = raw;
-                }
-            }
-            else if ((raw.startsWith('"') && raw.endsWith('"')) ||
-                (raw.startsWith("'") && raw.endsWith("'"))) {
-                metadata[key] = raw.slice(1, -1);
-            }
-            else {
-                metadata[key] = raw;
-            }
-        }
-    }
-    return metadata;
-}
-const RULES_BEGIN = "<!-- AICM:BEGIN -->";
-const RULES_END = "<!-- AICM:END -->";
-const WARNING = "<!-- WARNING: Everything between these markers will be overwritten during installation -->";
-/**
- * Remove the rules block from the content
- */
-function removeRulesBlock(content) {
-    // Check if our markers exist
-    if (content.includes(RULES_BEGIN) && content.includes(RULES_END)) {
-        const parts = content.split(RULES_BEGIN);
-        const beforeMarker = parts[0];
-        const afterParts = parts[1].split(RULES_END);
-        const afterMarker = afterParts.slice(1).join(RULES_END); // In case RULES_END appears multiple times (unlikely but safe)
-        return (beforeMarker + afterMarker).trim();
-    }
-    return content;
-}
-/**
- * Create a formatted block of content with rules markers
- */
-function createRulesBlock(rulesContent) {
-    return `${RULES_BEGIN}
-${WARNING}
-
-${rulesContent}
-
-${RULES_END}`;
-}
-/**
- * Write rules to the .windsurfrules file
- * This will update the content between the RULES_BEGIN and RULES_END markers
- * If the file doesn't exist, it will create it
- * If the markers don't exist, it will append them to the existing content
- */
-function writeRulesFile(rulesContent, rulesFilePath = path_1.default.join(process.cwd(), ".windsurfrules")) {
-    let fileContent;
-    const formattedRulesBlock = createRulesBlock(rulesContent);
-    // Check if file exists
-    if (fs_extra_1.default.existsSync(rulesFilePath)) {
-        const existingContent = fs_extra_1.default.readFileSync(rulesFilePath, "utf8");
-        // Check if our markers exist
-        if (existingContent.includes(RULES_BEGIN) &&
-            existingContent.includes(RULES_END)) {
-            // Replace content between markers
-            const beforeMarker = existingContent.split(RULES_BEGIN)[0];
-            const afterMarker = existingContent.split(RULES_END)[1];
-            fileContent = beforeMarker + formattedRulesBlock + afterMarker;
-        }
-        else {
-            // Preserve the existing content and append markers
-            // Ensure there's proper spacing between existing content and markers
-            let separator = "";
-            if (!existingContent.endsWith("\n")) {
-                separator += "\n";
-            }
-            // Add an extra line if the file doesn't already end with multiple newlines
-            if (!existingContent.endsWith("\n\n")) {
-                separator += "\n";
-            }
-            // Create the new file content with preserved original content
-            fileContent = existingContent + separator + formattedRulesBlock;
-        }
-    }
-    else {
-        // Create new file with markers and content
-        fileContent = formattedRulesBlock;
-    }
-    fs_extra_1.default.writeFileSync(rulesFilePath, fileContent);
-}
-/**
- * Generate the rules file content based on rule files
- */
-function generateRulesFileContent(ruleFiles) {
-    const alwaysRules = [];
-    const autoAttachedRules = [];
-    const agentRequestedRules = [];
-    const manualRules = [];
-    ruleFiles.forEach(({ path, metadata }) => {
-        // Determine rule type based on metadata
-        if (metadata.type === "always" ||
-            metadata.alwaysApply === true ||
-            metadata.alwaysApply === "true") {
-            alwaysRules.push(path);
-        }
-        else if (metadata.type === "auto-attached" || metadata.globs) {
-            const globPattern = typeof metadata.globs === "string" || Array.isArray(metadata.globs)
-                ? Array.isArray(metadata.globs)
-                    ? metadata.globs.join(", ")
-                    : metadata.globs
-                : undefined;
-            if (globPattern !== undefined) {
-                autoAttachedRules.push({ path, glob: globPattern });
-            }
-        }
-        else if (metadata.type === "agent-requested" || metadata.description) {
-            agentRequestedRules.push(path);
-        }
-        else {
-            // Default to manual inclusion
-            manualRules.push(path);
-        }
-    });
-    // Generate the content
-    let content = "";
-    // Always rules
-    if (alwaysRules.length > 0) {
-        content +=
-            "The following rules always apply to all files in the project:\n";
-        alwaysRules.forEach((rule) => {
-            content += `- ${rule}\n`;
-        });
-        content += "\n";
-    }
-    // Auto Attached rules
-    if (autoAttachedRules.length > 0) {
-        content +=
-            "The following rules are automatically attached to matching glob patterns:\n";
-        autoAttachedRules.forEach((rule) => {
-            content += `- [${rule.glob}] ${rule.path}\n`;
-        });
-        content += "\n";
-    }
-    // Agent Requested rules
-    if (agentRequestedRules.length > 0) {
-        content +=
-            "The following rules can be loaded when relevant. Check each file's description:\n";
-        agentRequestedRules.forEach((rule) => {
-            content += `- ${rule}\n`;
-        });
-        content += "\n";
-    }
-    // Manual rules
-    if (manualRules.length > 0) {
-        content +=
-            "The following rules are only included when explicitly referenced:\n";
-        manualRules.forEach((rule) => {
-            content += `- ${rule}\n`;
-        });
-        content += "\n";
-    }
-    return content.trim();
-}

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

@@ -1,10 +0,0 @@
-/**
- * Check if a resolved path is safely within the specified base directory.
- * This prevents path traversal attacks where malicious paths like "../../../etc"
- * or absolute paths could escape the intended directory.
- *
- * @param baseDir - The directory that should contain the path
- * @param relativePath - The potentially untrusted relative path
- * @returns The safely resolved full path, or null if the path would escape baseDir
- */
-export declare function resolveSafePath(baseDir: string, relativePath: string): string | null;

package/dist/utils/safe-path.js

@@ -1,28 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveSafePath = resolveSafePath;
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Check if a resolved path is safely within the specified base directory.
- * This prevents path traversal attacks where malicious paths like "../../../etc"
- * or absolute paths could escape the intended directory.
- *
- * @param baseDir - The directory that should contain the path
- * @param relativePath - The potentially untrusted relative path
- * @returns The safely resolved full path, or null if the path would escape baseDir
- */
-function resolveSafePath(baseDir, relativePath) {
-    // Resolve both to absolute paths
-    const resolvedBase = node_path_1.default.resolve(baseDir);
-    const resolvedTarget = node_path_1.default.resolve(baseDir, relativePath);
-    // The resolved path must start with the base directory + separator
-    // This ensures it's truly inside the directory, not a sibling with similar prefix
-    // e.g., /foo/bar should not match /foo/bar-other
-    if (!resolvedTarget.startsWith(resolvedBase + node_path_1.default.sep)) {
-        return null;
-    }
-    return resolvedTarget;
-}

package/dist/utils/working-directory.d.ts

@@ -1,5 +0,0 @@
-/**
- * Helper function to execute a function within a specific working directory
- * and ensure the original directory is always restored
- */
-export declare function withWorkingDirectory<T>(targetDir: string, fn: () => Promise<T>): Promise<T>;