@daytonaio/sdk 0.17.0-alpha.2 → 0.18.0-alpha.1

package/dist/Image.js

@@ -0,0 +1,557 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Image = void 0;
+const fs = __importStar(require("fs"));
+const fg = __importStar(require("fast-glob"));
+const _path = __importStar(require("path"));
+const shell_quote_1 = require("shell-quote");
+const untildify_1 = __importDefault(require("untildify"));
+const DaytonaError_1 = require("./errors/DaytonaError");
+const ObjectStorage_1 = require("./ObjectStorage");
+const toml_1 = require("@iarna/toml");
+const SUPPORTED_PYTHON_SERIES = ['3.9', '3.10', '3.11', '3.12', '3.13'];
+const LATEST_PYTHON_MICRO_VERSIONS = ['3.9.22', '3.10.17', '3.11.12', '3.12.10', '3.13.3'];
+/**
+ * Represents an image definition for a Daytona sandbox.
+ * Do not construct this class directly. Instead use one of its static factory methods,
+ * such as `Image.base()`, `Image.debianSlim()` or `Image.fromDockerfile()`.
+ *
+ * @class
+ * @property {string} dockerfile - The Dockerfile content.
+ * @property {Context[]} contextList - The list of context files to be added to the image.
+ */
+class Image {
+    constructor() {
+        this._dockerfile = '';
+        this._contextList = [];
+    }
+    get dockerfile() {
+        return this._dockerfile;
+    }
+    get contextList() {
+        return this._contextList;
+    }
+    /**
+     * Adds commands to install packages using pip.
+     *
+     * @param {string | string[]} packages - The packages to install.
+     * @param {Object} options - The options for the pip install command.
+     * @param {string[]} options.findLinks - The find-links to use for the pip install command.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.debianSlim('3.12').pipInstall('numpy', { findLinks: ['https://pypi.org/simple'] })
+     */
+    pipInstall(packages, options) {
+        const pkgs = this.flattenStringArgs('pipInstall', 'packages', packages);
+        if (!pkgs.length)
+            return this;
+        const extraArgs = this.formatPipInstallArgs(options);
+        this._dockerfile += `RUN python -m pip install ${(0, shell_quote_1.quote)(pkgs.sort())}${extraArgs}\n`;
+        return this;
+    }
+    /**
+     * Installs dependencies from a requirements.txt file.
+     *
+     * @param {string} requirementsTxt - The path to the requirements.txt file.
+     * @param {PipInstallOptions} options - The options for the pip install command.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.debianSlim('3.12')
+     * image.pipInstallFromRequirements('requirements.txt', { findLinks: ['https://pypi.org/simple'] })
+     */
+    pipInstallFromRequirements(requirementsTxt, options) {
+        const expandedPath = (0, untildify_1.default)(requirementsTxt);
+        if (!fs.existsSync(expandedPath)) {
+            throw new Error(`Requirements file ${requirementsTxt} does not exist`);
+        }
+        const extraArgs = this.formatPipInstallArgs(options);
+        const archivePath = ObjectStorage_1.ObjectStorage.computeArchiveBasePath(expandedPath);
+        this._contextList.push({ sourcePath: expandedPath, archivePath });
+        this._dockerfile += `COPY ${archivePath} /.requirements.txt\n`;
+        this._dockerfile += `RUN python -m pip install -r /.requirements.txt${extraArgs}\n`;
+        return this;
+    }
+    /**
+     * Installs dependencies from a pyproject.toml file.
+     *
+     * @param {string} pyprojectToml - The path to the pyproject.toml file.
+     * @param {PyprojectOptions} options - The options for the pip install command.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.debianSlim('3.12')
+     * image.pipInstallFromPyproject('pyproject.toml', { optionalDependencies: ['dev'] })
+     */
+    pipInstallFromPyproject(pyprojectToml, options) {
+        const tomlData = (0, toml_1.parse)(fs.readFileSync((0, untildify_1.default)(pyprojectToml), 'utf-8'));
+        const dependencies = [];
+        if (!tomlData || !tomlData.project || !Array.isArray(tomlData.project.dependencies)) {
+            const msg = 'No [project.dependencies] section in pyproject.toml file. ' +
+                'See https://packaging.python.org/en/latest/guides/writing-pyproject-toml ' +
+                'for further file format guidelines.';
+            throw new DaytonaError_1.DaytonaError(msg);
+        }
+        dependencies.push(...tomlData.project.dependencies);
+        if ((options === null || options === void 0 ? void 0 : options.optionalDependencies) && tomlData.project['optional-dependencies']) {
+            const optionalGroups = tomlData.project['optional-dependencies'];
+            for (const group of options.optionalDependencies) {
+                const deps = optionalGroups[group];
+                if (Array.isArray(deps)) {
+                    dependencies.push(...deps);
+                }
+            }
+        }
+        return this.pipInstall(dependencies, options);
+    }
+    /**
+     * Adds a local file to the image.
+     *
+     * @param {string} localPath - The path to the local file.
+     * @param {string} remotePath - The path of the file in the image.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .addLocalFile('requirements.txt', '/home/daytona/requirements.txt')
+     */
+    addLocalFile(localPath, remotePath) {
+        if (remotePath.endsWith('/')) {
+            remotePath = remotePath + _path.basename(localPath);
+        }
+        const expandedPath = (0, untildify_1.default)(localPath);
+        const archivePath = ObjectStorage_1.ObjectStorage.computeArchiveBasePath(expandedPath);
+        this._contextList.push({ sourcePath: expandedPath, archivePath });
+        this._dockerfile += `COPY ${archivePath} ${remotePath}\n`;
+        return this;
+    }
+    /**
+     * Adds a local directory to the image.
+     *
+     * @param {string} localPath - The path to the local directory.
+     * @param {string} remotePath - The path of the directory in the image.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .addLocalDir('src', '/home/daytona/src')
+     */
+    addLocalDir(localPath, remotePath) {
+        const expandedPath = (0, untildify_1.default)(localPath);
+        const archivePath = ObjectStorage_1.ObjectStorage.computeArchiveBasePath(expandedPath);
+        this._contextList.push({ sourcePath: expandedPath, archivePath });
+        this._dockerfile += `COPY ${archivePath} ${remotePath}\n`;
+        return this;
+    }
+    /**
+     * Runs commands in the image.
+     *
+     * @param {string | string[]} commands - The commands to run.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .runCommands('echo "Hello, world!"')
+     */
+    runCommands(...commands) {
+        const cmds = this.flattenStringArgs('runCommands', 'commands', commands);
+        if (!cmds.length)
+            return this;
+        for (const cmd of cmds) {
+            this._dockerfile += `RUN ${cmd}\n`;
+        }
+        return this;
+    }
+    /**
+     * Sets environment variables in the image.
+     *
+     * @param {Record<string, string>} envVars - The environment variables to set.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .env({ FOO: 'bar' })
+     */
+    env(envVars) {
+        const nonStringKeys = Object.entries(envVars)
+            .filter(([, value]) => typeof value !== 'string')
+            .map(([key]) => key);
+        if (nonStringKeys.length) {
+            throw new Error(`Image ENV variables must be strings. Invalid keys: ${nonStringKeys}`);
+        }
+        for (const [key, val] of Object.entries(envVars)) {
+            this._dockerfile += `ENV ${key}=${(0, shell_quote_1.quote)([val])}\n`;
+        }
+        return this;
+    }
+    /**
+     * Sets the working directory in the image.
+     *
+     * @param {string} dirPath - The path to the working directory.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .workdir('/home/daytona')
+     */
+    workdir(dirPath) {
+        this._dockerfile += `WORKDIR ${(0, shell_quote_1.quote)([dirPath])}\n`;
+        return this;
+    }
+    /**
+     * Sets the entrypoint for the image.
+     *
+     * @param {string[]} entrypointCommands - The commands to set as the entrypoint.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .entrypoint(['/bin/bash'])
+     */
+    entrypoint(entrypointCommands) {
+        if (!Array.isArray(entrypointCommands) || !entrypointCommands.every((x) => typeof x === 'string')) {
+            throw new Error('entrypoint_commands must be a list of strings');
+        }
+        const argsStr = entrypointCommands.map((arg) => `"${arg}"`).join(', ');
+        this._dockerfile += `ENTRYPOINT [${argsStr}]\n`;
+        return this;
+    }
+    /**
+     * Sets the default command for the image.
+     *
+     * @param {string[]} cmd - The command to set as the default command.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .cmd(['/bin/bash'])
+     */
+    cmd(cmd) {
+        if (!Array.isArray(cmd) || !cmd.every((x) => typeof x === 'string')) {
+            throw new Error('Image CMD must be a list of strings');
+        }
+        const cmdStr = cmd.map((arg) => `"${arg}"`).join(', ');
+        this._dockerfile += `CMD [${cmdStr}]\n`;
+        return this;
+    }
+    /**
+     * Extends an image with arbitrary Dockerfile-like commands.
+     *
+     * @param {string | string[]} dockerfileCommands - The commands to add to the Dockerfile.
+     * @param {string} contextDir - The path to the context directory.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image
+     *  .debianSlim('3.12')
+     *  .dockerfileCommands(['RUN echo "Hello, world!"'])
+     */
+    dockerfileCommands(dockerfileCommands, contextDir) {
+        const cmds = this.flattenStringArgs('dockerfileCommands', 'dockerfileCommands', dockerfileCommands);
+        if (!cmds.length)
+            return this;
+        if (contextDir) {
+            const expandedPath = (0, untildify_1.default)(contextDir);
+            if (!fs.existsSync(expandedPath) || !fs.statSync(expandedPath).isDirectory()) {
+                throw new Error(`Context directory ${contextDir} does not exist`);
+            }
+        }
+        for (const [contextPath, originalPath] of Image.extractCopySources(cmds.join('\n'), contextDir || '')) {
+            let archiveBasePath = contextPath;
+            if (contextDir && !originalPath.startsWith(contextDir)) {
+                archiveBasePath = contextPath.substring(contextDir.length);
+                // Remove leading separators
+                archiveBasePath = archiveBasePath.replace(/^[\/\\]+/, '');
+            }
+            this._contextList.push({ sourcePath: contextPath, archivePath: archiveBasePath });
+        }
+        this._dockerfile += cmds.join('\n') + '\n';
+        return this;
+    }
+    /**
+     * Creates an Image from an existing Dockerfile.
+     *
+     * @param {string} path - The path to the Dockerfile.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.fromDockerfile('Dockerfile')
+     */
+    static fromDockerfile(path) {
+        const expandedPath = _path.resolve((0, untildify_1.default)(path));
+        if (!fs.existsSync(expandedPath)) {
+            throw new Error(`Dockerfile ${path} does not exist`);
+        }
+        const dockerfileContent = fs.readFileSync(expandedPath, 'utf-8');
+        const img = new Image();
+        img._dockerfile = dockerfileContent;
+        // Remove dockerfile filename from path to get the path prefix
+        const pathPrefix = _path.dirname(expandedPath) + _path.sep;
+        for (const [contextPath, originalPath] of Image.extractCopySources(dockerfileContent, pathPrefix)) {
+            let archiveBasePath = contextPath;
+            if (!originalPath.startsWith(pathPrefix)) {
+                // Remove the path prefix from the context path to get the archive path
+                archiveBasePath = contextPath.substring(pathPrefix.length);
+                // Remove leading separators
+                archiveBasePath = archiveBasePath.replace(/^[\/\\]+/, '');
+            }
+            img._contextList.push({ sourcePath: contextPath, archivePath: archiveBasePath });
+        }
+        return img;
+    }
+    /**
+     * Creates an Image from an existing base image.
+     *
+     * @param {string} image - The base image to use.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.base('python:3.12-slim-bookworm')
+     */
+    static base(image) {
+        const img = new Image();
+        img._dockerfile = `FROM ${image}\n`;
+        return img;
+    }
+    /**
+     * Creates a Debian slim image based on the official Python Docker image.
+     *
+     * @param {string} pythonVersion - The Python version to use.
+     * @returns {Image} The Image instance.
+     *
+     * @example
+     * const image = Image.debianSlim('3.12')
+     */
+    static debianSlim(pythonVersion) {
+        const version = Image.processPythonVersion(pythonVersion);
+        const img = new Image();
+        const commands = [
+            `FROM python:${version}-slim-bookworm`,
+            'RUN apt-get update',
+            'RUN apt-get install -y gcc gfortran build-essential',
+            'RUN pip install --upgrade pip',
+            // Set debian front-end to non-interactive to avoid users getting stuck with input prompts.
+            // eslint-disable-next-line quotes
+            "RUN echo 'debconf debconf/frontend select Noninteractive' | debconf-set-selections",
+        ];
+        img._dockerfile = commands.join('\n') + '\n';
+        return img;
+    }
+    /**
+     * Formats pip install arguments in a single string.
+     *
+     * @param {PipInstallOptions} options - The options for the pip install command.
+     * @returns {string} The formatted pip install arguments.
+     */
+    formatPipInstallArgs(options) {
+        if (!options)
+            return '';
+        let extraArgs = '';
+        if (options.findLinks) {
+            for (const findLink of options.findLinks) {
+                extraArgs += ` --find-links ${(0, shell_quote_1.quote)([findLink])}`;
+            }
+        }
+        if (options.indexUrl) {
+            extraArgs += ` --index-url ${(0, shell_quote_1.quote)([options.indexUrl])}`;
+        }
+        if (options.extraIndexUrls) {
+            for (const extraIndexUrl of options.extraIndexUrls) {
+                extraArgs += ` --extra-index-url ${(0, shell_quote_1.quote)([extraIndexUrl])}`;
+            }
+        }
+        if (options.pre) {
+            extraArgs += ' --pre';
+        }
+        if (options.extraOptions) {
+            extraArgs += ` ${options.extraOptions.trim()}`;
+        }
+        return extraArgs;
+    }
+    /**
+     * Flattens a string argument.
+     *
+     * @param {string} functionName - The name of the function.
+     * @param {string} argName - The name of the argument.
+     * @param {any} args - The argument to flatten.
+     * @returns {string[]} The flattened argument.
+     */
+    flattenStringArgs(functionName, argName, args) {
+        const result = [];
+        const flatten = (arg) => {
+            if (typeof arg === 'string') {
+                result.push(arg);
+            }
+            else if (Array.isArray(arg)) {
+                for (const item of arg) {
+                    flatten(item);
+                }
+            }
+            else {
+                throw new Error(`${functionName}: ${argName} must only contain strings`);
+            }
+        };
+        flatten(args);
+        return result;
+    }
+    /**
+     * Processes the Python version.
+     *
+     * @param {string} pythonVersion - The Python version to use.
+     * @returns {string} The processed Python version.
+     */
+    static processPythonVersion(pythonVersion) {
+        if (!pythonVersion) {
+            // Default to latest
+            pythonVersion = SUPPORTED_PYTHON_SERIES[SUPPORTED_PYTHON_SERIES.length - 1];
+        }
+        if (!SUPPORTED_PYTHON_SERIES.includes(pythonVersion)) {
+            throw new Error(`Unsupported Python version: ${pythonVersion}. ` +
+                `Daytona supports the following series: ${SUPPORTED_PYTHON_SERIES.join(', ')}`);
+        }
+        // Map series to latest micro version
+        const seriesMap = Object.fromEntries(LATEST_PYTHON_MICRO_VERSIONS.map((v) => {
+            const [major, minor, micro] = v.split('.');
+            return [`${major}.${minor}`, micro];
+        }));
+        const micro = seriesMap[pythonVersion];
+        return `${pythonVersion}.${micro}`;
+    }
+    /**
+     * Extracts source files from COPY commands in a Dockerfile.
+     *
+     * @param {string} dockerfileContent - The content of the Dockerfile.
+     * @param {string} pathPrefix - The path prefix to use for the sources.
+     * @returns {Array<[string, string]>} The list of the actual file path and its corresponding COPY-command source path.
+     */
+    static extractCopySources(dockerfileContent, pathPrefix = '') {
+        const sources = [];
+        const lines = dockerfileContent.split('\n');
+        for (const line of lines) {
+            // Skip empty lines and comments
+            if (!line.trim() || line.trim().startsWith('#')) {
+                continue;
+            }
+            // Check if the line contains a COPY command
+            if (/^\s*COPY\s/.test(line)) {
+                const commandParts = this.parseCopyCommand(line);
+                if (commandParts) {
+                    // Get source paths from the parsed command parts
+                    for (const source of commandParts.sources) {
+                        // Handle absolute and relative paths differently
+                        const fullPathPattern = _path.isAbsolute(source) ? source : _path.join(pathPrefix, source);
+                        const matchingFiles = fg.sync([fullPathPattern], { dot: true });
+                        if (matchingFiles.length > 0) {
+                            for (const matchingFile of matchingFiles) {
+                                sources.push([matchingFile, source]);
+                            }
+                        }
+                        else {
+                            sources.push([fullPathPattern, source]);
+                        }
+                    }
+                }
+            }
+        }
+        return sources;
+    }
+    /**
+     * Parses a COPY command to extract sources and destination.
+     *
+     * @param {string} line - The line to parse.
+     * @returns {Object} The parsed sources and destination.
+     */
+    static parseCopyCommand(line) {
+        // Remove initial "COPY" and strip whitespace
+        const parts = line.trim().substring(4).trim();
+        // Handle JSON array format: COPY ["src1", "src2", "dest"]
+        if (parts.startsWith('[')) {
+            try {
+                // Parse the JSON-like array format
+                const elements = (0, shell_quote_1.parse)(parts.replace('[', '').replace(']', '')).filter((x) => typeof x === 'string');
+                if (elements.length < 2) {
+                    return null;
+                }
+                return {
+                    sources: elements.slice(0, -1),
+                    dest: elements[elements.length - 1],
+                };
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        // Handle regular format with possible flags
+        const splitParts = (0, shell_quote_1.parse)(parts).filter((x) => typeof x === 'string');
+        // Extract flags like --chown, --chmod, --from
+        let sourcesStartIdx = 0;
+        for (let i = 0; i < splitParts.length; i++) {
+            const part = splitParts[i];
+            if (part.startsWith('--')) {
+                // Skip the flag and its value if it has one
+                if (!part.includes('=') && i + 1 < splitParts.length && !splitParts[i + 1].startsWith('--')) {
+                    sourcesStartIdx = i + 2;
+                }
+                else {
+                    sourcesStartIdx = i + 1;
+                }
+            }
+            else {
+                break;
+            }
+        }
+        // After skipping flags, we need at least one source and one destination
+        if (splitParts.length - sourcesStartIdx < 2) {
+            return null;
+        }
+        return {
+            sources: splitParts.slice(sourcesStartIdx, -1),
+            dest: splitParts[splitParts.length - 1],
+        };
+    }
+}
+exports.Image = Image;

package/dist/ObjectStorage.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Configuration for the ObjectStorage class.
+ *
+ * @interface
+ * @property {string} endpointUrl - The endpoint URL for the object storage service.
+ * @property {string} accessKeyId - The access key ID for the object storage service.
+ * @property {string} secretAccessKey - The secret access key for the object storage service.
+ * @property {string} [sessionToken] - The session token for the object storage service. Used for temporary credentials.
+ * @property {string} [bucketName] - The name of the bucket to use.
+ */
+export interface ObjectStorageConfig {
+    endpointUrl: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    sessionToken?: string;
+    bucketName?: string;
+}
+/**
+ * ObjectStorage class for interacting with object storage services.
+ *
+ * @class
+ * @param {ObjectStorageConfig} config - The configuration for the object storage service.
+ */
+export declare class ObjectStorage {
+    private bucketName;
+    private s3Client;
+    constructor(config: ObjectStorageConfig);
+    /**
+     * Upload a file or directory to object storage.
+     *
+     * @param {string} path - The path to the file or directory to upload.
+     * @param {string} organizationId - The organization ID to use for the upload.
+     * @param {string} [archiveBasePath] - The base path to use for the archive.
+     * @returns {Promise<string>} The hash of the uploaded file or directory.
+     */
+    upload(path: string, organizationId: string, archiveBasePath?: string): Promise<string>;
+    /**
+     * Compute a hash for a file or directory.
+     *
+     * @param {string} pathStr - The path to the file or directory to hash.
+     * @param {string} [archiveBasePath] - The base path to use for the archive.
+     * @returns {Promise<string>} The hash of the file or directory.
+     */
+    private computeHashForPathMd5;
+    /**
+     * Recursively hash a directory and its contents.
+     *
+     * @param {string} dirPath - The path to the directory to hash.
+     * @param {string} basePath - The base path to use for the hash.
+     * @param {crypto.Hash} hasher - The hasher to use for the hash.
+     * @returns {Promise<void>} A promise that resolves when the directory has been hashed.
+     */
+    private hashDirectory;
+    /**
+     * Hash a file.
+     *
+     * @param {string} filePath - The path to the file to hash.
+     * @param {crypto.Hash} hasher - The hasher to use for the hash.
+     * @returns {Promise<void>} A promise that resolves when the file has been hashed.
+     */
+    private hashFile;
+    /**
+     * Check if a prefix (folder) exists in S3.
+     *
+     * @param {string} prefix - The prefix to check.
+     * @returns {Promise<boolean>} True if the prefix exists, false otherwise.
+     */
+    private folderExistsInS3;
+    /**
+     * Create a tar archive of the specified path and upload it to S3.
+     *
+     * @param {string} s3Key - The key to use for the uploaded file.
+     * @param {string} sourcePath - The path to the file or directory to upload.
+     * @param {string} [archiveBasePath] - The base path to use for the archive.
+     */
+    private uploadAsTar;
+    private extractAwsRegion;
+    /**
+     * Compute the base path for an archive. Returns normalized path without the root (drive letter or leading slash).
+     *
+     * @param {string} pathStr - The path to compute the base path for.
+     * @returns {string} The base path for the archive.
+     */
+    static computeArchiveBasePath(pathStr: string): string;
+}