imcp 0.0.14 → 0.0.16

package/dist/utils/adoUtils.js

@@ -0,0 +1,252 @@
+import { SETTINGS_DIR } from '../core/constants.js';
+import { Logger } from './logger.js';
+import { exec } from 'child_process';
+import util from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+const execAsync = util.promisify(exec);
+/**
+ * Sets up the NPM credential provider.
+ * Installs @microsoft/artifacts-npm-credprovider if not already installed.
+ * @private
+ */
+async function _setupNpmCredentialProvider() {
+    Logger.debug('Setting up NPM credential provider...');
+    const credProviderCommand = 'artifacts-npm-credprovider';
+    // Check if artifacts-npm-credprovider is installed by trying to get its version or a known command.
+    // A more robust check might involve checking a specific version or path.
+    let installed = false;
+    try {
+        // Attempt to get help output as a basic check for presence
+        const { stdout, stderr } = await execAsync(`${credProviderCommand} --help`);
+        Logger.debug(`${credProviderCommand} --help stdout: ${stdout}`);
+        if (stderr)
+            Logger.debug(`${credProviderCommand} --help stderr: ${stderr}`);
+        installed = true;
+        Logger.debug(`${credProviderCommand} appears to be installed.`);
+    }
+    catch (e) {
+        Logger.debug(`${credProviderCommand} not found or --help failed, attempting installation. Error: ${e}`);
+    }
+    if (!installed) {
+        Logger.log(`Installing @microsoft/artifacts-npm-credprovider...`);
+        try {
+            const installCommand = `npm install -g @microsoft/artifacts-npm-credprovider --registry https://pkgs.dev.azure.com/mseng/226da8e7-b1c0-4167-9678-53f461e07706/_packaging/AzureArtifacts/npm/registry/`;
+            const { stdout: installStdout, stderr: installStderr } = await execAsync(installCommand);
+            Logger.debug(`@microsoft/artifacts-npm-credprovider install stdout: ${installStdout}`);
+            if (installStderr)
+                Logger.debug(`@microsoft/artifacts-npm-credprovider install stderr: ${installStderr}`);
+            Logger.log('@microsoft/artifacts-npm-credprovider installed successfully.');
+        }
+        catch (error) {
+            Logger.error('Failed to install @microsoft/artifacts-npm-credprovider', error);
+            throw new Error(`Failed to install @microsoft/artifacts-npm-credprovider: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}
+/**
+ * Installs pip requirements: keyring and artifacts-keyring.
+ * @param pythonCommand The python command to use (e.g., 'python' or 'python3').
+ * @private
+ */
+async function _installPipRequirements(pythonCommand) {
+    Logger.debug(`Installing pip requirements: keyring, artifacts-keyring using ${pythonCommand}`);
+    try {
+        const command = `${pythonCommand} -m pip install keyring artifacts-keyring`;
+        const { stdout, stderr } = await execAsync(command);
+        Logger.debug(`pip install keyring artifacts-keyring stdout: ${stdout}`);
+        if (stderr)
+            Logger.debug(`pip install keyring artifacts-keyring stderr: ${stderr}`);
+        Logger.log('Successfully installed keyring and artifacts-keyring.');
+    }
+    catch (error) {
+        Logger.error('Failed to install pip requirements (keyring, artifacts-keyring)', error);
+        throw new Error(`Failed to install pip requirements: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Configures NPM authentication for Azure DevOps Artifacts in a specified directory.
+ * This includes setting up the credential provider, creating an .npmrc file,
+ * and running the credential provider.
+ * @param execPromise The promise-based exec function.
+ * @param registry The Azure DevOps artifacts registry configuration.
+ * @param directoryPath The directory where .npmrc will be created and commands will be executed.
+ * @private
+ */
+async function _configureNpmAdoAuthInDirectory(execPromise, registry, directoryPath) {
+    if (!registry || !registry.registryUrl || !registry.registryName) {
+        throw new Error('Registry name and URL are required for NPM ADO auth configuration.');
+    }
+    await _setupNpmCredentialProvider();
+    const npmrcContent = `@${registry.registryName}:registry=${registry.registryUrl}\nalways-auth=true`;
+    const npmrcPath = path.join(directoryPath, '.npmrc');
+    await fs.writeFile(npmrcPath, npmrcContent.trim());
+    Logger.debug(`Created/Updated .npmrc file at: ${npmrcPath}`);
+    const env = { ...process.env, NUGET_CREDENTIALPROVIDER_VSTS_TOKENTYPE: 'SelfDescribing' };
+    Logger.debug(`Running artifacts-npm-credprovider in ${directoryPath}`);
+    const { stdout: credProviderStdout, stderr: credProviderStderr } = await execPromise('artifacts-npm-credprovider', { cwd: directoryPath, env });
+    Logger.debug(`artifacts-npm-credprovider stdout: ${credProviderStdout}`);
+    if (credProviderStderr)
+        Logger.debug(`artifacts-npm-credprovider stderr: ${credProviderStderr}`);
+    Logger.log(`Successfully ran artifacts-npm-credprovider in ${directoryPath}`);
+}
+/**
+ * Handles fetching and setting up an Azure DevOps artifact.
+ * @param requirement The requirement configuration.
+ * @param registry The Azure DevOps artifacts registry configuration.
+ * @param pythonCommand Optional Python command (e.g., 'python', 'python3') for pip operations.
+ * @param targetDir Optional target directory for npm artifact setup. If not provided, a default will be used.
+ * @returns A promise that resolves with the artifact details.
+ */
+export async function handleArtifact(requirement, registry, pythonCommand = 'python', // Default to 'python' if not provided
+targetDir // Optional target directory for npm
+) {
+    if (!registry) {
+        throw new Error('Azure DevOps artifacts registry configuration is required.');
+    }
+    if (!registry.registryName || !registry.registryUrl) {
+        throw new Error('Registry name and URL are required for Azure DevOps artifacts.');
+    }
+    Logger.debug(`Handling ADO artifact for requirement: ${requirement.name}, type: ${requirement.type}`);
+    if (requirement.type === 'npm') {
+        const requirementDir = targetDir || path.join(SETTINGS_DIR, 'requirements', requirement.name, requirement.version);
+        await fs.mkdir(requirementDir, { recursive: true });
+        Logger.debug(`Ensured directory for npm requirement: ${requirementDir}`);
+        try {
+            await _configureNpmAdoAuthInDirectory(execAsync, registry, requirementDir);
+            Logger.log(`Successfully configured ADO NPM auth for ${requirement.name} in ${requirementDir}`);
+            const version = requirement.version.includes('latest') ? 'latest' : requirement.version;
+            return {
+                folderPath: requirementDir,
+                type: 'npm',
+                package: `@${registry.registryName}/${requirement.name}`,
+                registryUrl: registry.registryUrl,
+                version: version
+            };
+        }
+        catch (error) {
+            Logger.error(`Failed to configure ADO NPM auth for ${requirement.name} in ${requirementDir}`, error);
+            throw new Error(`ADO NPM auth configuration failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    else if (requirement.type === 'pip') {
+        await _installPipRequirements(pythonCommand);
+        const packageName = requirement.version.toLowerCase().includes('latest')
+            ? `${requirement.name} --upgrade`
+            : `${requirement.name}==${requirement.version}`;
+        Logger.log(`Pip requirement ${packageName} configured with registry ${registry.registryUrl}`);
+        return {
+            type: 'pip',
+            package: packageName,
+            registryUrl: registry.registryUrl,
+            version: requirement.version
+        };
+    }
+    else {
+        throw new Error(`Unsupported requirement type for ADO artifact: ${requirement.type}`);
+    }
+}
+/**
+ * Get the latest version of an artifact from Azure DevOps.
+ * This is a simplified implementation and might require further enhancements for robust authentication and error handling.
+ * @param execPromise The promise-based exec function.
+ * @param requirement The requirement configuration.
+ * @param registry The Azure DevOps artifacts registry configuration.
+ * @param options Optional server install options (e.g., for pythonCommand).
+ * @returns The latest version string, or undefined if not found or an error occurs.
+ */
+export async function getArtifactLatestVersion(requirement, registry, options, // Added import for ServerInstallOptions
+targetDir // Optional target directory for npm
+) {
+    if (!registry || !registry.registryUrl) {
+        Logger.error('ADO Artifact registry URL is missing for fetching latest version.');
+        return undefined;
+    }
+    Logger.debug(`Attempting to fetch latest version for ADO artifact: ${requirement.name} of type ${requirement.type}`);
+    if (requirement.type === 'npm') {
+        if (!registry.registryName) { // Ensure registryName is present
+            Logger.error('NPM ADO Artifact registry name is missing for fetching latest version.');
+            return undefined;
+        }
+        const requirementDir = targetDir || path.join(SETTINGS_DIR, 'requirements', requirement.name, requirement.version);
+        try {
+            await fs.mkdir(requirementDir, { recursive: true });
+            Logger.debug(`Ensured directory for NPM ADO version check: ${requirementDir}`);
+            // Configure auth within the requirementDir
+            await _configureNpmAdoAuthInDirectory(execAsync, registry, requirementDir);
+            Logger.log(`Successfully configured ADO NPM auth for version check of ${requirement.name} in ${requirementDir}`);
+            const fullPackageName = `@${registry.registryName}/${requirement.name}`;
+            const command = `npm view ${fullPackageName} version --registry ${registry.registryUrl}`;
+            Logger.debug(`Executing for NPM ADO latest version: ${command} in ${requirementDir}`);
+            const { stdout, stderr } = await execAsync(command, { cwd: requirementDir });
+            if (stderr && !stdout.trim()) {
+                Logger.error(`Error fetching NPM ADO version for ${fullPackageName} via npm view: ${stderr}`);
+                return undefined;
+            }
+            const version = stdout.trim();
+            if (version) {
+                Logger.debug(`Found latest NPM ADO version for ${fullPackageName}: ${version}`);
+                return version;
+            }
+            else {
+                Logger.log(`Could not parse latest NPM version from ADO for ${fullPackageName} from output: '${stdout}'`);
+                return undefined;
+            }
+        }
+        catch (error) {
+            Logger.error(`Exception fetching latest NPM version from ADO for ${requirement.name} in ${requirementDir}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+    else if (requirement.type === 'pip') {
+        try {
+            const pythonCmd = options?.settings?.pythonEnv || 'python';
+            const pipCmd = `${pythonCmd} -m pip`;
+            // Ensure keyring and artifacts-keyring are installed.
+            // This is usually handled by `handleArtifact` during install.
+            // For a standalone version check, we might need to ensure they exist.
+            // Consider calling _installPipRequirements(pythonCmd) if necessary, but it has side effects.
+            // For now, assume they are present if ADO pip artifacts are being used.
+            const command = `${pipCmd} index versions ${requirement.name} --extra-index-url ${registry.registryUrl}`;
+            Logger.debug(`Executing for Pip ADO latest version: ${command}`);
+            const { stdout, stderr } = await execAsync(command);
+            if (stderr && !stdout.trim()) { // If there's stderr and no significant stdout, it's likely an error
+                Logger.error(`Error fetching Pip ADO version for ${requirement.name}: ${stderr}`);
+                return undefined;
+            }
+            // Parse output like:
+            // mypackage (1.0.0)
+            // Available versions: 1.0.0, 0.9.0
+            // LATEST:          1.0.0
+            // Or:
+            // mypackage
+            // VERSIONS: 1.0.0, 0.9.0
+            // Latest: 1.0.0
+            const latestMatch = stdout.match(/(?:LATEST|Latest):\s*([^\s]+)/);
+            if (latestMatch && latestMatch[1]) {
+                Logger.debug(`Found latest Pip ADO version via LATEST line: ${latestMatch[1]}`);
+                return latestMatch[1];
+            }
+            // Fallback: try to parse from "Available versions" or "VERSIONS"
+            const versionsMatch = stdout.match(/(?:Available versions|VERSIONS):\s*([^\n]+)/);
+            if (versionsMatch && versionsMatch[1]) {
+                const versions = versionsMatch[1].split(',').map(v => v.trim()).filter(v => v);
+                if (versions.length > 0) {
+                    // This is a naive approach, assumes the first listed is relevant or latest.
+                    // Proper sorting (e.g. semver) would be better.
+                    Logger.debug(`Found Pip ADO versions: ${versions.join(', ')}. Taking the first one: ${versions[0]}`);
+                    return versions[0];
+                }
+            }
+            Logger.log(`Could not parse latest Pip version from ADO for ${requirement.name} from output: ${stdout}`); // Changed Logger.warn to Logger.log
+            return undefined;
+        }
+        catch (error) {
+            Logger.error(`Exception fetching latest Pip version from ADO for ${requirement.name}: ${error instanceof Error ? error.message : String(error)}`);
+            return undefined;
+        }
+    }
+    Logger.log(`getArtifactLatestVersion not implemented for type '${requirement.type}' or encountered an issue.`); // Changed Logger.warn to Logger.log
+    return undefined;
+}
+//# sourceMappingURL=adoUtils.js.map

package/dist/utils/clientUtils.d.ts

@@ -7,13 +7,6 @@
 export declare function extractZipFile(zipPath: string, options: {
     dir: string;
 }): Promise<void>;
-/**
- * Resolves the path to an NPM module, replacing template variables
- * First checks if the module path exists under NVM-controlled Node, then falls back to global npm
- * @param pathString The path string potentially containing template variables
- * @returns The resolved path
- */
-export declare function resolveNpmModulePath(pathString: string): string;
 export declare function readJsonFile(filePath: string, createIfNotExist?: boolean): Promise<any>;
 /**
  * Writes content to a JSON file

package/dist/utils/clientUtils.js

@@ -1,9 +1,6 @@
 import fs from 'fs/promises';
-import * as fsSync from 'fs';
 import * as path from 'path';
-import { execSync } from 'child_process';
 import extractZipModule from 'extract-zip';
-import { Logger } from './logger.js';
 /**
  * Extract a zip file to a directory
  * @param zipPath The path to the zip file
@@ -32,45 +29,6 @@ export async function extractZipFile(zipPath, options) {
         throw new Error(`Failed to extract zip file ${zipPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
-/**
- * Resolves the path to an NPM module, replacing template variables
- * First checks if the module path exists under NVM-controlled Node, then falls back to global npm
- * @param pathString The path string potentially containing template variables
- * @returns The resolved path
- */
-export function resolveNpmModulePath(pathString) {
-    // If the path doesn't contain the ${NPMPATH} template, return it as is
-    if (!pathString.includes('${NPMPATH}')) {
-        return pathString;
-    }
-    // First try to get NVM-controlled npm path
-    const nvmHome = process.env.NVM_HOME;
-    if (nvmHome) {
-        try {
-            // Get current node version
-            const nodeVersion = execSync('node -v').toString().trim();
-            // Construct the path to npm in the NVM directory
-            const nvmNodePath = path.join(nvmHome, nodeVersion);
-            const resolvedPath = pathString.replace('${NPMPATH}', nvmNodePath);
-            // Check if this path exists
-            try {
-                fsSync.accessSync(resolvedPath);
-                return resolvedPath;
-            }
-            catch (error) {
-                Logger.debug(`NVM controlled path doesn't exist: ${resolvedPath}, will try global npm`);
-                // Path doesn't exist, will fall back to global npm
-            }
-        }
-        catch (error) {
-            Logger.debug(`Error determining Node version: ${error}, will use global npm`);
-            // Error getting node version, will fall back to global npm
-        }
-    }
-    // Fall back to global npm path
-    const globalNpmPath = execSync('npm root -g').toString().trim();
-    return pathString.replace('${NPMPATH}', globalNpmPath);
-}
 /**
  * Reads a JSON file and parses its content
  * @param filePath Path to the JSON file

package/dist/utils/githubUtils.d.ts

@@ -1,4 +1,14 @@
 import { RegistryConfig, RequirementConfig } from '../core/types.js';
+/**
+ * Get the latest version available for a GitHub repository
+ * @param execPromise The promise-based exec function
+ * @param repository The GitHub repository in format 'owner/repo'
+ * @returns The latest version or tag
+ */
+export declare function getGitHubLatestVersion(execPromise: (command: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>, repository: string): Promise<string>;
 interface DownloadGithubReleaseResult {
     version: string;
     downloadPath: string;

package/dist/utils/githubUtils.js

@@ -5,6 +5,28 @@ import path from 'path';
 import { extractZipFile } from './clientUtils.js';
 import { SETTINGS_DIR } from '../core/constants.js';
 const execAsync = util.promisify(exec);
+/**
+ * Get the latest version available for a GitHub repository
+ * @param execPromise The promise-based exec function
+ * @param repository The GitHub repository in format 'owner/repo'
+ * @returns The latest version or tag
+ */
+export async function getGitHubLatestVersion(execPromise, repository) {
+    try {
+        // Use GitHub CLI to get the latest release
+        const { stdout } = await execPromise(`gh release view --repo ${repository} --json tagName --jq .tagName`);
+        const latestTag = stdout.trim();
+        // Remove 'v' prefix if present
+        return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+    }
+    catch (error) {
+        // If gh command fails, try to get the latest tag
+        const { stdout } = await execPromise(`git ls-remote --tags --refs https://github.com/${repository}.git | sort -t '/' -k 3 -V | tail -n 1 | awk -F/ '{print $3}'`);
+        let latestTag = stdout.trim();
+        // Remove 'v' prefix if present
+        return latestTag.startsWith('v') ? latestTag.substring(1) : latestTag;
+    }
+}
 /**
  * Downloads a GitHub release asset
  * @param repo GitHub repository in format owner/repo

package/dist/utils/macroExpressionUtils.d.ts

@@ -0,0 +1,38 @@
+import { ServerInstallOptions } from '../core/types.js';
+export declare const MACRO_EXPRESSIONS: {
+    readonly PYTHON_PACKAGE: "${PYTHON_PACKAGE}";
+    readonly NPMPATH: "${NPMPATH}";
+    readonly BROWSER_PATH: "${BROWSER_PATH}";
+};
+export declare const MacroResolverFunctions: {
+    [key: string]: (finalConfig: any, options: ServerInstallOptions) => Promise<string | undefined>;
+};
+/**
+ * Resolves the path for the ${PYTHON_PACKAGE} macro.
+ * It considers the pythonEnv setting and falls back to system Python.
+ * Also updates finalConfig.command if it's 'python' and pythonEnv is used.
+ * @param finalConfig The configuration object (mutated for command).
+ * @param options Server installation options.
+ * @returns The resolved Python package path or undefined.
+ */
+export declare function resolvePythonPackageMacro(finalConfig: any, options: ServerInstallOptions): Promise<string | undefined>;
+/**
+ * Resolves the actual NPM module path.
+ * It checks a provided path, then NVM, then global npm.
+ * @param providedNpmPath An optional, pre-configured NPM path.
+ * @returns The resolved NPM module path or undefined if an error occurs.
+ */
+export declare function resolveNpmModulePath(providedNpmPath: string | undefined): string;
+/**
+ * Resolves the path to an NPM module for the ${NPMPATH} macro.
+ * Uses the resolveNpmModulePath function.
+ * @param _finalConfig Not used by this resolver.
+ * @param options Server installation options, may contain npmPath.
+ * @returns The resolved NPM path or undefined if an error occurs.
+ */
+export declare function resolveNpmPathMacro(_finalConfig: any, options: ServerInstallOptions): Promise<string | undefined>;
+/**
+ * Resolves the path for the ${BROWSER_PATH} macro.
+ * @returns The system's browser path or undefined.
+ */
+export declare function resolveBrowserPathMacro(): Promise<string | undefined>;

package/dist/utils/macroExpressionUtils.js

@@ -0,0 +1,116 @@
+import { Logger } from './logger.js';
+import { getPythonPackagePath, getSystemPythonPackageDirectory, GetBrowserPath } from './osUtils.js';
+import * as fsSync from 'fs';
+import * as path from 'path';
+import { execSync } from 'child_process';
+export const MACRO_EXPRESSIONS = {
+    PYTHON_PACKAGE: '${PYTHON_PACKAGE}',
+    NPMPATH: '${NPMPATH}',
+    BROWSER_PATH: '${BROWSER_PATH}',
+};
+// Define a map for macro keys to their resolver functions
+export const MacroResolverFunctions = {
+    [MACRO_EXPRESSIONS.PYTHON_PACKAGE]: resolvePythonPackageMacro,
+    [MACRO_EXPRESSIONS.NPMPATH]: resolveNpmPathMacro,
+    [MACRO_EXPRESSIONS.BROWSER_PATH]: resolveBrowserPathMacro,
+};
+/**
+ * Resolves the path for the ${PYTHON_PACKAGE} macro.
+ * It considers the pythonEnv setting and falls back to system Python.
+ * Also updates finalConfig.command if it's 'python' and pythonEnv is used.
+ * @param finalConfig The configuration object (mutated for command).
+ * @param options Server installation options.
+ * @returns The resolved Python package path or undefined.
+ */
+export async function resolvePythonPackageMacro(finalConfig, options) {
+    const pythonEnv = options.settings?.pythonEnv;
+    if (pythonEnv) {
+        Logger.debug(`Python environment specified for ${MACRO_EXPRESSIONS.PYTHON_PACKAGE}: ${pythonEnv}`);
+        const pythonDir = getPythonPackagePath(pythonEnv);
+        if (pythonDir) {
+            if (finalConfig.command === 'python') {
+                Logger.debug(`Replacing command 'python' with specified pythonEnv: ${pythonEnv} due to ${MACRO_EXPRESSIONS.PYTHON_PACKAGE} resolution`);
+                finalConfig.command = pythonEnv;
+            }
+            return pythonDir;
+        }
+        Logger.debug(`Could not determine directory for pythonEnv: ${pythonEnv}. ${MACRO_EXPRESSIONS.PYTHON_PACKAGE} will not be replaced using this path.`);
+        return undefined;
+    }
+    else {
+        Logger.debug(`No Python environment specified. Attempting to find system Python for ${MACRO_EXPRESSIONS.PYTHON_PACKAGE}.`);
+        const pythonDir = await getSystemPythonPackageDirectory();
+        if (pythonDir) {
+            return pythonDir;
+        }
+        Logger.debug(`Could not find system Python directory for ${MACRO_EXPRESSIONS.PYTHON_PACKAGE}.`);
+        return undefined;
+    }
+}
+/**
+ * Resolves the actual NPM module path.
+ * It checks a provided path, then NVM, then global npm.
+ * @param providedNpmPath An optional, pre-configured NPM path.
+ * @returns The resolved NPM module path or undefined if an error occurs.
+ */
+export function resolveNpmModulePath(providedNpmPath) {
+    if (providedNpmPath) {
+        return `${providedNpmPath}/node_modules`;
+    }
+    const nvmHome = process.env.NVM_HOME;
+    if (nvmHome) {
+        try {
+            const nodeVersion = execSync('node -v').toString().trim();
+            const nvmNodePath = path.join(nvmHome, nodeVersion);
+            // Check if this path exists
+            try {
+                fsSync.accessSync(nvmNodePath);
+                Logger.debug(`Resolved ${MACRO_EXPRESSIONS.NPMPATH} via NVM to: ${nvmNodePath}`);
+                return nvmNodePath;
+            }
+            catch (error) {
+                Logger.debug(`NVM controlled path doesn't exist: ${nvmNodePath}, will try global npm`);
+            }
+        }
+        catch (error) {
+            Logger.debug(`Error determining Node version for NVM: ${error}, will use global npm`);
+        }
+    }
+    const globalNpmPath = execSync('npm root -g').toString().trim();
+    Logger.debug(`Resolved ${MACRO_EXPRESSIONS.NPMPATH} via global npm to: ${globalNpmPath}`);
+    return globalNpmPath;
+}
+/**
+ * Resolves the path to an NPM module for the ${NPMPATH} macro.
+ * Uses the resolveNpmModulePath function.
+ * @param _finalConfig Not used by this resolver.
+ * @param options Server installation options, may contain npmPath.
+ * @returns The resolved NPM path or undefined if an error occurs.
+ */
+export async function resolveNpmPathMacro(_finalConfig, options) {
+    Logger.debug(`Resolving ${MACRO_EXPRESSIONS.NPMPATH}. Provided npmPath from settings: ${options.settings?.npmPath}`);
+    try {
+        return resolveNpmModulePath(options.settings?.npmPath);
+    }
+    catch (error) {
+        Logger.error(`Failed to resolve ${MACRO_EXPRESSIONS.NPMPATH}:`, error);
+        return undefined;
+    }
+}
+/**
+ * Resolves the path for the ${BROWSER_PATH} macro.
+ * @returns The system's browser path or undefined.
+ */
+export async function resolveBrowserPathMacro() {
+    Logger.debug(`Resolving ${MACRO_EXPRESSIONS.BROWSER_PATH}`);
+    try {
+        const browserPath = await GetBrowserPath();
+        Logger.debug(`Resolved ${MACRO_EXPRESSIONS.BROWSER_PATH} to: ${browserPath}`);
+        return browserPath;
+    }
+    catch (error) {
+        Logger.error(`Failed to get system browser path for ${MACRO_EXPRESSIONS.BROWSER_PATH}:`, error);
+        return undefined;
+    }
+}
+//# sourceMappingURL=macroExpressionUtils.js.map

package/dist/utils/osUtils.d.ts

@@ -3,31 +3,15 @@ export declare function getOSType(): OSType;
 export declare function installCLI(tool: 'gh' | 'git'): Promise<void>;
 /**
  * Refreshes the PATH environment variable for the current Node.js process
- * This is necessary because when tools are installed using package managers,
- * they update the system PATH but the current Node process doesn't see those changes.
  */
 export declare function refreshPathEnv(): Promise<void>;
-export declare function isToolInstalled(tool: 'gh' | 'git', retries?: number): Promise<boolean>;
 /**
- * Opens a URL in the default browser
- * @param url The URL to open
- * @returns A promise that resolves when the browser is launched
+ * Check if a command is available on the system
+ * Handles special cases for VS Code on different platforms
  */
+export declare function isCommandAvailable(command: string): Promise<boolean>;
+export declare function isToolInstalled(tool: 'gh' | 'git', retries?: number): Promise<boolean>;
 export declare function openBrowser(url: string): Promise<void>;
-/**
- * Gets the directory containing Python packages (site-packages) based on Python executable path.
- * Handles different Python installations (system, venv, conda) across different OS platforms.
- * @param pythonExecutablePath The full path to the Python executable
- * @returns The site-packages directory path
- */
 export declare function getPythonPackagePath(pythonExecutablePath: string): string;
-/**
- * Finds the directory of the system's default Python installation.
- * @returns The directory path or null if not found.
- */
 export declare function getSystemPythonPackageDirectory(): Promise<string | null>;
-/**
- * Gets the path of the system's default browser.
- * @returns The path to the default browser executable.
- */
 export declare function GetBrowserPath(): Promise<string>;