@iaforged/context-code 1.0.63 → 1.0.67

package/dist/src/utils/errors.js

@@ -1,207 +0,0 @@
-import { APIUserAbortError } from '@anthropic-ai/sdk';
-export class ClaudeError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = this.constructor.name;
-    }
-}
-export class MalformedCommandError extends Error {
-}
-export class AbortError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'AbortError';
-    }
-}
-/**
- * True iff `e` is any of the abort-shaped errors the codebase encounters:
- * our AbortError class, a DOMException from AbortController.abort()
- * (.name === 'AbortError'), or the SDK's APIUserAbortError. The SDK class
- * is checked via instanceof because minified builds mangle class names —
- * constructor.name becomes something like 'nJT' and the SDK never sets
- * this.name, so string matching silently fails in production.
- */
-export function isAbortError(e) {
-    return (e instanceof AbortError ||
-        e instanceof APIUserAbortError ||
-        (e instanceof Error && e.name === 'AbortError'));
-}
-/**
- * Custom error class for configuration file parsing errors
- * Includes the file path and the default configuration that should be used
- */
-export class ConfigParseError extends Error {
-    filePath;
-    defaultConfig;
-    constructor(message, filePath, defaultConfig) {
-        super(message);
-        this.name = 'ConfigParseError';
-        this.filePath = filePath;
-        this.defaultConfig = defaultConfig;
-    }
-}
-export class ShellError extends Error {
-    stdout;
-    stderr;
-    code;
-    interrupted;
-    constructor(stdout, stderr, code, interrupted) {
-        super('Shell command failed');
-        this.stdout = stdout;
-        this.stderr = stderr;
-        this.code = code;
-        this.interrupted = interrupted;
-        this.name = 'ShellError';
-    }
-}
-export class TeleportOperationError extends Error {
-    formattedMessage;
-    constructor(message, formattedMessage) {
-        super(message);
-        this.formattedMessage = formattedMessage;
-        this.name = 'TeleportOperationError';
-    }
-}
-/**
- * Error with a message that is safe to log to telemetry.
- * Use the long name to confirm you've verified the message contains no
- * sensitive data (file paths, URLs, code snippets).
- *
- * Single-arg: same message for user and telemetry
- * Two-arg: different messages (e.g., full message has file path, telemetry doesn't)
- *
- * @example
- * // Same message for both
- * throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(
- *   'MCP server "slack" connection timed out'
- * )
- *
- * // Different messages
- * throw new TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS(
- *   `MCP tool timed out after ${ms}ms`,  // Full message for logs/user
- *   'MCP tool timed out'                  // Telemetry message
- * )
- */
-export class TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS extends Error {
-    telemetryMessage;
-    constructor(message, telemetryMessage) {
-        super(message);
-        this.name = 'TelemetrySafeError';
-        this.telemetryMessage = telemetryMessage ?? message;
-    }
-}
-export function hasExactErrorMessage(error, message) {
-    return error instanceof Error && error.message === message;
-}
-/**
- * Normalize an unknown value into an Error.
- * Use at catch-site boundaries when you need an Error instance.
- */
-export function toError(e) {
-    return e instanceof Error ? e : new Error(String(e));
-}
-/**
- * Extract a string message from an unknown error-like value.
- * Use when you only need the message (e.g., for logging or display).
- */
-export function errorMessage(e) {
-    return e instanceof Error ? e.message : String(e);
-}
-/**
- * Extract the errno code (e.g., 'ENOENT', 'EACCES') from a caught error.
- * Returns undefined if the error has no code or is not an ErrnoException.
- * Replaces the `(e as NodeJS.ErrnoException).code` cast pattern.
- */
-export function getErrnoCode(e) {
-    if (e && typeof e === 'object' && 'code' in e && typeof e.code === 'string') {
-        return e.code;
-    }
-    return undefined;
-}
-/**
- * True if the error is ENOENT (file or directory does not exist).
- * Replaces `(e as NodeJS.ErrnoException).code === 'ENOENT'`.
- */
-export function isENOENT(e) {
-    return getErrnoCode(e) === 'ENOENT';
-}
-/**
- * Extract the errno path (the filesystem path that triggered the error)
- * from a caught error. Returns undefined if the error has no path.
- * Replaces the `(e as NodeJS.ErrnoException).path` cast pattern.
- */
-export function getErrnoPath(e) {
-    if (e && typeof e === 'object' && 'path' in e && typeof e.path === 'string') {
-        return e.path;
-    }
-    return undefined;
-}
-/**
- * Extract error message + top N stack frames from an unknown error.
- * Use when the error flows to the model as a tool_result — full stack
- * traces are ~500-2000 chars of mostly-irrelevant internal frames and
- * waste context tokens. Keep the full stack in debug logs instead.
- */
-export function shortErrorStack(e, maxFrames = 5) {
-    if (!(e instanceof Error))
-        return String(e);
-    if (!e.stack)
-        return e.message;
-    // V8/Bun stack format: "Name: message\n    at frame1\n    at frame2..."
-    // First line is the message; subsequent "    at " lines are frames.
-    const lines = e.stack.split('\n');
-    const header = lines[0] ?? e.message;
-    const frames = lines.slice(1).filter(l => l.trim().startsWith('at '));
-    if (frames.length <= maxFrames)
-        return e.stack;
-    return [header, ...frames.slice(0, maxFrames)].join('\n');
-}
-/**
- * True if the error means the path is missing, inaccessible, or
- * structurally unreachable — use in catch blocks after fs operations to
- * distinguish expected "nothing there / no access" from unexpected errors.
- *
- * Covers:
- *  ENOENT    — path does not exist
- *  EACCES    — permission denied
- *  EPERM     — operation not permitted
- *  ENOTDIR   — a path component is not a directory (e.g. a file named
- *              `.claude` exists where a directory is expected)
- *  ELOOP     — too many symlink levels (circular symlinks)
- */
-export function isFsInaccessible(e) {
-    const code = getErrnoCode(e);
-    return (code === 'ENOENT' ||
-        code === 'EACCES' ||
-        code === 'EPERM' ||
-        code === 'ENOTDIR' ||
-        code === 'ELOOP');
-}
-/**
- * Classify a caught error from an axios request into one of a few buckets.
- * Replaces the ~20-line isAxiosError → 401/403 → ECONNABORTED → ECONNREFUSED
- * chain duplicated across sync-style services (settingsSync, policyLimits,
- * remoteManagedSettings, teamMemorySync).
- *
- * Checks the `.isAxiosError` marker property directly (same as
- * axios.isAxiosError()) to keep this module dependency-free.
- */
-export function classifyAxiosError(e) {
-    const message = errorMessage(e);
-    if (!e ||
-        typeof e !== 'object' ||
-        !('isAxiosError' in e) ||
-        !e.isAxiosError) {
-        return { kind: 'other', message };
-    }
-    const err = e;
-    const status = err.response?.status;
-    if (status === 401 || status === 403)
-        return { kind: 'auth', status, message };
-    if (err.code === 'ECONNABORTED')
-        return { kind: 'timeout', status, message };
-    if (err.code === 'ECONNREFUSED' || err.code === 'ENOTFOUND') {
-        return { kind: 'network', status, message };
-    }
-    return { kind: 'http', status, message };
-}

package/dist/src/utils/eventLoopStallDetector.js

@@ -1,16 +0,0 @@
-export default null;
-export const defaultExport = null;
-export async function daemonMain() { }
-export async function runDaemonWorker() { }
-export async function environmentRunnerMain() { }
-export async function selfHostedRunnerMain() { }
-export async function connectHeadless() { }
-export async function startServer() { }
-export async function launchAssistantInstallWizard() { return null; }
-export async function launchAssistantSessionChooser() { return null; }
-export async function discoverAssistantSessions() { return []; }
-export async function createSSHSession() { throw new Error('Recovery stub: createSSHSession not implemented'); }
-export function createLocalSSHSession() { throw new Error('Recovery stub: createLocalSSHSession not implemented'); }
-export class SSHSessionError extends Error {
-}
-export function clearSkillIndexCache() { }

package/dist/src/utils/exampleCommands.js

@@ -1,165 +0,0 @@
-import memoize from 'lodash-es/memoize.js';
-import sample from 'lodash-es/sample.js';
-import { getCwd } from '../utils/cwd.js';
-import { getCurrentProjectConfig, saveCurrentProjectConfig } from './config.js';
-import { env } from './env.js';
-import { execFileNoThrowWithCwd } from './execFileNoThrow.js';
-import { getIsGit, gitExe } from './git.js';
-import { logError } from './log.js';
-import { getGitEmail } from './user.js';
-// Patterns that mark a file as non-core (auto-generated, dependency, or config).
-// Used to filter example-command filename suggestions deterministically
-// instead of shelling out to Haiku.
-const NON_CORE_PATTERNS = [
-    // lock / dependency manifests
-    /(?:^|\/)(?:package-lock\.json|yarn\.lock|bun\.lock|bun\.lockb|pnpm-lock\.yaml|Pipfile\.lock|poetry\.lock|Cargo\.lock|Gemfile\.lock|go\.sum|composer\.lock|uv\.lock)$/,
-    // generated / build artifacts
-    /\.generated\./,
-    /(?:^|\/)(?:dist|build|out|target|node_modules|\.next|__pycache__)\//,
-    /\.(?:min\.js|min\.css|map|pyc|pyo)$/,
-    // data / docs / config extensions (not "write a test for" material)
-    /\.(?:json|ya?ml|toml|xml|ini|cfg|conf|env|lock|txt|md|mdx|rst|csv|log|svg)$/i,
-    // configuration / metadata
-    /(?:^|\/)\.?(?:eslintrc|prettierrc|babelrc|editorconfig|gitignore|gitattributes|dockerignore|npmrc)/,
-    /(?:^|\/)(?:tsconfig|jsconfig|biome|vitest\.config|jest\.config|webpack\.config|vite\.config|rollup\.config)\.[a-z]+$/,
-    /(?:^|\/)\.(?:github|vscode|idea|claude)\//,
-    // docs / changelogs (not "how does X work" material)
-    /(?:^|\/)(?:CHANGELOG|LICENSE|CONTRIBUTING|CODEOWNERS|README)(?:\.[a-z]+)?$/i,
-];
-function isCoreFile(path) {
-    return !NON_CORE_PATTERNS.some(p => p.test(path));
-}
-/**
- * Counts occurrences of items in an array and returns the top N items
- * sorted by count in descending order, formatted as a string.
- */
-export function countAndSortItems(items, topN = 20) {
-    const counts = new Map();
-    for (const item of items) {
-        counts.set(item, (counts.get(item) || 0) + 1);
-    }
-    return Array.from(counts.entries())
-        .sort((a, b) => b[1] - a[1])
-        .slice(0, topN)
-        .map(([item, count]) => `${count.toString().padStart(6)} ${item}`)
-        .join('\n');
-}
-/**
- * Picks up to `want` basenames from a frequency-sorted list of paths,
- * skipping non-core files and spreading across different directories.
- * Returns empty array if fewer than `want` core files are available.
- */
-export function pickDiverseCoreFiles(sortedPaths, want) {
-    const picked = [];
-    const seenBasenames = new Set();
-    const dirTally = new Map();
-    // Greedy: on each pass allow +1 file per directory. Keeps the
-    // top-5 from collapsing into a single hot folder while still
-    // letting a dominant folder contribute multiple files if the
-    // repo is narrow.
-    for (let cap = 1; picked.length < want && cap <= want; cap++) {
-        for (const p of sortedPaths) {
-            if (picked.length >= want)
-                break;
-            if (!isCoreFile(p))
-                continue;
-            const lastSep = Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
-            const base = lastSep >= 0 ? p.slice(lastSep + 1) : p;
-            if (!base || seenBasenames.has(base))
-                continue;
-            const dir = lastSep >= 0 ? p.slice(0, lastSep) : '.';
-            if ((dirTally.get(dir) ?? 0) >= cap)
-                continue;
-            picked.push(base);
-            seenBasenames.add(base);
-            dirTally.set(dir, (dirTally.get(dir) ?? 0) + 1);
-        }
-    }
-    return picked.length >= want ? picked : [];
-}
-async function getFrequentlyModifiedFiles() {
-    if (process.env.NODE_ENV === 'test')
-        return [];
-    if (env.platform === 'win32')
-        return [];
-    if (!(await getIsGit()))
-        return [];
-    try {
-        // Collect frequently-modified files, preferring the user's own commits.
-        const userEmail = await getGitEmail();
-        const logArgs = [
-            'log',
-            '-n',
-            '1000',
-            '--pretty=format:',
-            '--name-only',
-            '--diff-filter=M',
-        ];
-        const counts = new Map();
-        const tallyInto = (stdout) => {
-            for (const line of stdout.split('\n')) {
-                const f = line.trim();
-                if (f)
-                    counts.set(f, (counts.get(f) ?? 0) + 1);
-            }
-        };
-        if (userEmail) {
-            const { stdout } = await execFileNoThrowWithCwd('git', [...logArgs, `--author=${userEmail}`], { cwd: getCwd() });
-            tallyInto(stdout);
-        }
-        // Fall back to all authors if the user's own history is thin.
-        if (counts.size < 10) {
-            const { stdout } = await execFileNoThrowWithCwd(gitExe(), logArgs, {
-                cwd: getCwd(),
-            });
-            tallyInto(stdout);
-        }
-        const sorted = Array.from(counts.entries())
-            .sort((a, b) => b[1] - a[1])
-            .map(([p]) => p);
-        return pickDiverseCoreFiles(sorted, 5);
-    }
-    catch (err) {
-        logError(err);
-        return [];
-    }
-}
-const ONE_WEEK_IN_MS = 7 * 24 * 60 * 60 * 1000;
-export const getExampleCommandFromCache = memoize(() => {
-    const projectConfig = getCurrentProjectConfig();
-    const frequentFile = projectConfig.exampleFiles?.length
-        ? sample(projectConfig.exampleFiles)
-        : '<filepath>';
-    const commands = [
-        'fix lint errors',
-        'fix typecheck errors',
-        `how does ${frequentFile} work?`,
-        `refactor ${frequentFile}`,
-        'how do I log an error?',
-        `edit ${frequentFile} to...`,
-        `write a test for ${frequentFile}`,
-        'create a util logging.py that...',
-    ];
-    return `Try "${sample(commands)}"`;
-});
-export const refreshExampleCommands = memoize(async () => {
-    const projectConfig = getCurrentProjectConfig();
-    const now = Date.now();
-    const lastGenerated = projectConfig.exampleFilesGeneratedAt ?? 0;
-    // Regenerate examples if they're over a week old
-    if (now - lastGenerated > ONE_WEEK_IN_MS) {
-        projectConfig.exampleFiles = [];
-    }
-    // If no example files cached, kickstart fetch in background
-    if (!projectConfig.exampleFiles?.length) {
-        void getFrequentlyModifiedFiles().then(files => {
-            if (files.length) {
-                saveCurrentProjectConfig(current => ({
-                    ...current,
-                    exampleFiles: files,
-                    exampleFilesGeneratedAt: Date.now(),
-                }));
-            }
-        });
-    }
-});

package/dist/src/utils/execFileNoThrow.js

@@ -1,93 +0,0 @@
-// This file represents useful wrappers over node:child_process
-// These wrappers ease error handling and cross-platform compatbility
-// By using execa, Windows automatically gets shell escaping + BAT / CMD handling
-import { execa } from 'execa';
-import { getCwd } from '../utils/cwd.js';
-import { logError } from './log.js';
-export { execSyncWithDefaults_DEPRECATED } from './execFileNoThrowPortable.js';
-const MS_IN_SECOND = 1000;
-const SECONDS_IN_MINUTE = 60;
-export function execFileNoThrow(file, args, options = {
-    timeout: 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
-    preserveOutputOnError: true,
-    useCwd: true,
-}) {
-    return execFileNoThrowWithCwd(file, args, {
-        abortSignal: options.abortSignal,
-        timeout: options.timeout,
-        preserveOutputOnError: options.preserveOutputOnError,
-        cwd: options.useCwd ? getCwd() : undefined,
-        env: options.env,
-        stdin: options.stdin,
-        input: options.input,
-    });
-}
-/**
- * Extracts a human-readable error message from an execa result.
- *
- * Priority order:
- * 1. shortMessage - execa's human-readable error (e.g., "Command failed with exit code 1: ...")
- *    This is preferred because it already includes signal info when a process is killed,
- *    making it more informative than just the signal name.
- * 2. signal - the signal that killed the process (e.g., "SIGTERM")
- * 3. errorCode - fallback to just the numeric exit code
- */
-function getErrorMessage(result, errorCode) {
-    if (result.shortMessage) {
-        return result.shortMessage;
-    }
-    if (typeof result.signal === 'string') {
-        return result.signal;
-    }
-    return String(errorCode);
-}
-/**
- * execFile, but always resolves (never throws)
- */
-export function execFileNoThrowWithCwd(file, args, { abortSignal, timeout: finalTimeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND, preserveOutputOnError: finalPreserveOutput = true, cwd: finalCwd, env: finalEnv, maxBuffer, shell, stdin: finalStdin, input: finalInput, } = {
-    timeout: 10 * SECONDS_IN_MINUTE * MS_IN_SECOND,
-    preserveOutputOnError: true,
-    maxBuffer: 1_000_000,
-}) {
-    return new Promise(resolve => {
-        // Use execa for cross-platform .bat/.cmd compatibility on Windows
-        execa(file, args, {
-            maxBuffer,
-            signal: abortSignal,
-            timeout: finalTimeout,
-            cwd: finalCwd,
-            env: finalEnv,
-            shell,
-            stdin: finalStdin,
-            input: finalInput,
-            reject: false, // Don't throw on non-zero exit codes
-        })
-            .then(result => {
-            if (result.failed) {
-                if (finalPreserveOutput) {
-                    const errorCode = result.exitCode ?? 1;
-                    void resolve({
-                        stdout: result.stdout || '',
-                        stderr: result.stderr || '',
-                        code: errorCode,
-                        error: getErrorMessage(result, errorCode),
-                    });
-                }
-                else {
-                    void resolve({ stdout: '', stderr: '', code: result.exitCode ?? 1 });
-                }
-            }
-            else {
-                void resolve({
-                    stdout: result.stdout,
-                    stderr: result.stderr,
-                    code: 0,
-                });
-            }
-        })
-            .catch((error) => {
-            logError(error);
-            void resolve({ stdout: '', stderr: '', code: 1 });
-        });
-    });
-}

package/dist/src/utils/execFileNoThrowPortable.js

@@ -1,111 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { execaSync } from 'execa';
-import { getCwd } from '../utils/cwd.js';
-import { slowLogging } from './slowOperations.js';
-const MS_IN_SECOND = 1000;
-const SECONDS_IN_MINUTE = 60;
-/**
- * @deprecated Use `execa` directly with `{ shell: true, reject: false }` for non-blocking execution.
- * Sync exec calls block the event loop and cause performance issues.
- */
-export function execSyncWithDefaults_DEPRECATED(command, optionsOrAbortSignal, timeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        let options;
-        if (optionsOrAbortSignal === undefined) {
-            // No second argument - use defaults
-            options = {};
-        }
-        else if (optionsOrAbortSignal instanceof AbortSignal) {
-            // Old signature - second argument is AbortSignal
-            options = {
-                abortSignal: optionsOrAbortSignal,
-                timeout,
-            };
-        }
-        else {
-            // New signature - second argument is options object
-            options = optionsOrAbortSignal;
-        }
-        const { abortSignal, timeout: finalTimeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND, input, stdio = ['ignore', 'pipe', 'pipe'], } = options;
-        abortSignal?.throwIfAborted();
-        const _ = __addDisposableResource(env_1, slowLogging `exec: ${command.slice(0, 200)}`, false);
-        try {
-            const result = execaSync(command, {
-                env: process.env,
-                maxBuffer: 1_000_000,
-                timeout: finalTimeout,
-                cwd: getCwd(),
-                stdio,
-                shell: true, // execSync typically runs shell commands
-                reject: false, // Don't throw on non-zero exit codes
-                input,
-            });
-            if (!result.stdout) {
-                return null;
-            }
-            return result.stdout.trim() || null;
-        }
-        catch {
-            return null;
-        }
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        __disposeResources(env_1);
-    }
-}

package/dist/src/utils/execSyncWrapper.js

@@ -1,68 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { execSync as nodeExecSync, } from 'child_process';
-import { slowLogging } from './slowOperations.js';
-export function execSync_DEPRECATED(command, options) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const _ = __addDisposableResource(env_1, slowLogging `execSync: ${command.slice(0, 100)}`, false);
-        return nodeExecSync(command, options);
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        __disposeResources(env_1);
-    }
-}