@iaforged/context-code 1.0.62 → 1.0.65

package/dist/src/utils/settings/validateEditTool.js

@@ -1,34 +0,0 @@
-import { isClaudeSettingsPath } from '../permissions/filesystem.js';
-import { validateSettingsFileContent } from './validation.js';
-/**
- * Validates settings file edits to ensure the result conforms to SettingsSchema.
- * This is used by FileEditTool to avoid code duplication.
- *
- * @param filePath - The file path being edited
- * @param originalContent - The original file content before edits
- * @param getUpdatedContent - A closure that returns the content after applying edits
- * @returns Validation result with error details if validation fails
- */
-export function validateInputForSettingsFileEdit(filePath, originalContent, getUpdatedContent) {
-    // Only validate Claude settings files
-    if (!isClaudeSettingsPath(filePath)) {
-        return null;
-    }
-    // Check if the current file (before edit) conforms to the schema
-    const beforeValidation = validateSettingsFileContent(originalContent);
-    if (!beforeValidation.isValid) {
-        // If the before version is invalid, allow the edit (don't block it)
-        return null;
-    }
-    // If the before version is valid, ensure the after version is also valid
-    const updatedContent = getUpdatedContent();
-    const afterValidation = validateSettingsFileContent(updatedContent);
-    if (!afterValidation.isValid) {
-        return {
-            result: false,
-            message: `Context Code settings.json validation failed after edit:\n${afterValidation.error}\n\nFull schema:\n${afterValidation.fullSchema}\nIMPORTANT: Do not update the env unless explicitly instructed to do so.`,
-            errorCode: 10,
-        };
-    }
-    return null;
-}

package/dist/src/utils/settings/validation.js

@@ -1,192 +0,0 @@
-import { jsonParse } from '../slowOperations.js';
-import { plural } from '../stringUtils.js';
-import { validatePermissionRule } from './permissionValidation.js';
-import { generateSettingsJSONSchema } from './schemaOutput.js';
-import { SettingsSchema } from './types.js';
-import { getValidationTip } from './validationTips.js';
-/**
- * Helper type guards for specific Zod v4 issue types
- * In v4, issue types have different structures than v3
- */
-function isInvalidTypeIssue(issue) {
-    return issue.code === 'invalid_type';
-}
-function isInvalidValueIssue(issue) {
-    return issue.code === 'invalid_value';
-}
-function isUnrecognizedKeysIssue(issue) {
-    return issue.code === 'unrecognized_keys';
-}
-function isTooSmallIssue(issue) {
-    return issue.code === 'too_small';
-}
-/**
- * Format a Zod validation error into human-readable validation errors
- */
-/**
- * Get the type string for an unknown value (for error messages)
- */
-function getReceivedType(value) {
-    if (value === null)
-        return 'null';
-    if (value === undefined)
-        return 'undefined';
-    if (Array.isArray(value))
-        return 'array';
-    return typeof value;
-}
-function extractReceivedFromMessage(msg) {
-    const match = msg.match(/received (\w+)/);
-    return match ? match[1] : undefined;
-}
-export function formatZodError(error, filePath) {
-    return error.issues.map((issue) => {
-        const path = issue.path.map(String).join('.');
-        let message = issue.message;
-        let expected;
-        let enumValues;
-        let expectedValue;
-        let receivedValue;
-        let invalidValue;
-        if (isInvalidValueIssue(issue)) {
-            enumValues = issue.values.map(v => String(v));
-            expectedValue = enumValues.join(' | ');
-            receivedValue = undefined;
-            invalidValue = undefined;
-        }
-        else if (isInvalidTypeIssue(issue)) {
-            expectedValue = issue.expected;
-            const receivedType = extractReceivedFromMessage(issue.message);
-            receivedValue = receivedType ?? getReceivedType(issue.input);
-            invalidValue = receivedType ?? getReceivedType(issue.input);
-        }
-        else if (isTooSmallIssue(issue)) {
-            expectedValue = String(issue.minimum);
-        }
-        else if (issue.code === 'custom' && 'params' in issue) {
-            const params = issue.params;
-            receivedValue = params.received;
-            invalidValue = receivedValue;
-        }
-        const tip = getValidationTip({
-            path,
-            code: issue.code,
-            expected: expectedValue,
-            received: receivedValue,
-            enumValues,
-            message: issue.message,
-            value: receivedValue,
-        });
-        if (isInvalidValueIssue(issue)) {
-            expected = enumValues?.map(v => `"${v}"`).join(', ');
-            message = `Invalid value. Expected one of: ${expected}`;
-        }
-        else if (isInvalidTypeIssue(issue)) {
-            const receivedType = extractReceivedFromMessage(issue.message) ??
-                getReceivedType(issue.input);
-            if (issue.expected === 'object' &&
-                receivedType === 'null' &&
-                path === '') {
-                message = 'Invalid or malformed JSON';
-            }
-            else {
-                message = `Expected ${issue.expected}, but received ${receivedType}`;
-            }
-        }
-        else if (isUnrecognizedKeysIssue(issue)) {
-            const keys = issue.keys.join(', ');
-            message = `Unrecognized ${plural(issue.keys.length, 'field')}: ${keys}`;
-        }
-        else if (isTooSmallIssue(issue)) {
-            message = `Number must be greater than or equal to ${issue.minimum}`;
-            expected = String(issue.minimum);
-        }
-        return {
-            file: filePath,
-            path,
-            message,
-            expected,
-            invalidValue,
-            suggestion: tip?.suggestion,
-            docLink: tip?.docLink,
-        };
-    });
-}
-/**
- * Validates that settings file content conforms to the SettingsSchema.
- * This is used during file edits to ensure the resulting file is valid.
- */
-export function validateSettingsFileContent(content) {
-    try {
-        // Parse the JSON first
-        const jsonData = jsonParse(content);
-        // Validate against SettingsSchema in strict mode
-        const result = SettingsSchema().strict().safeParse(jsonData);
-        if (result.success) {
-            return { isValid: true };
-        }
-        // Format the validation error in a helpful way
-        const errors = formatZodError(result.error, 'settings');
-        const errorMessage = 'Settings validation failed:\n' +
-            errors.map(err => `- ${err.path}: ${err.message}`).join('\n');
-        return {
-            isValid: false,
-            error: errorMessage,
-            fullSchema: generateSettingsJSONSchema(),
-        };
-    }
-    catch (parseError) {
-        return {
-            isValid: false,
-            error: `Invalid JSON: ${parseError instanceof Error ? parseError.message : 'Unknown parsing error'}`,
-            fullSchema: generateSettingsJSONSchema(),
-        };
-    }
-}
-/**
- * Filters invalid permission rules from raw parsed JSON data before schema validation.
- * This prevents one bad rule from poisoning the entire settings file.
- * Returns warnings for each filtered rule.
- */
-export function filterInvalidPermissionRules(data, filePath) {
-    if (!data || typeof data !== 'object')
-        return [];
-    const obj = data;
-    if (!obj.permissions || typeof obj.permissions !== 'object')
-        return [];
-    const perms = obj.permissions;
-    const warnings = [];
-    for (const key of ['allow', 'deny', 'ask']) {
-        const rules = perms[key];
-        if (!Array.isArray(rules))
-            continue;
-        perms[key] = rules.filter(rule => {
-            if (typeof rule !== 'string') {
-                warnings.push({
-                    file: filePath,
-                    path: `permissions.${key}`,
-                    message: `Non-string value in ${key} array was removed`,
-                    invalidValue: rule,
-                });
-                return false;
-            }
-            const result = validatePermissionRule(rule);
-            if (!result.valid) {
-                let message = `Invalid permission rule "${rule}" was skipped`;
-                if (result.error)
-                    message += `: ${result.error}`;
-                if (result.suggestion)
-                    message += `. ${result.suggestion}`;
-                warnings.push({
-                    file: filePath,
-                    path: `permissions.${key}`,
-                    message,
-                    invalidValue: rule,
-                });
-                return false;
-            }
-            return true;
-        });
-    }
-    return warnings;
-}

package/dist/src/utils/settings/validationTips.js

@@ -1,111 +0,0 @@
-const DOCUMENTATION_BASE = 'https://code.claude.com/docs/en';
-const TIP_MATCHERS = [
-    {
-        matches: (ctx) => ctx.path === 'permissions.defaultMode' && ctx.code === 'invalid_value',
-        tip: {
-            suggestion: 'Valid modes: "acceptEdits" (ask before file changes), "plan" (analysis only), "bypassPermissions" (auto-accept all), or "default" (standard behavior)',
-            docLink: `${DOCUMENTATION_BASE}/iam#permission-modes`,
-        },
-    },
-    {
-        matches: (ctx) => ctx.path === 'apiKeyHelper' && ctx.code === 'invalid_type',
-        tip: {
-            suggestion: 'Provide a shell command that outputs your API key to stdout. The script should output only the API key. Example: "/bin/generate_temp_api_key.sh"',
-        },
-    },
-    {
-        matches: (ctx) => ctx.path === 'cleanupPeriodDays' &&
-            ctx.code === 'too_small' &&
-            ctx.expected === '0',
-        tip: {
-            suggestion: 'Must be 0 or greater. Set a positive number for days to retain transcripts (default is 30). Setting 0 disables session persistence entirely: no transcripts are written and existing transcripts are deleted at startup.',
-        },
-    },
-    {
-        matches: (ctx) => ctx.path.startsWith('env.') && ctx.code === 'invalid_type',
-        tip: {
-            suggestion: 'Environment variables must be strings. Wrap numbers and booleans in quotes. Example: "DEBUG": "true", "PORT": "3000"',
-            docLink: `${DOCUMENTATION_BASE}/settings#environment-variables`,
-        },
-    },
-    {
-        matches: (ctx) => (ctx.path === 'permissions.allow' || ctx.path === 'permissions.deny') &&
-            ctx.code === 'invalid_type' &&
-            ctx.expected === 'array',
-        tip: {
-            suggestion: 'Permission rules must be in an array. Format: ["Tool(specifier)"]. Examples: ["Bash(npm run build)", "Edit(docs/**)", "Read(~/.zshrc)"]. Use * for wildcards.',
-        },
-    },
-    {
-        matches: (ctx) => ctx.path.includes('hooks') && ctx.code === 'invalid_type',
-        tip: {
-            suggestion: 
-            // gh-31187 / CC-282: prior example showed {"matcher": {"tools": ["BashTool"]}}
-            // — an object format that never existed in the schema (matcher is z.string(),
-            // always has been). Users copied the tip's example and got the same validation
-            // error again. See matchesPattern() in hooks.ts: matcher is exact-match,
-            // pipe-separated ("Edit|Write"), or regex. Empty/"*" matches all.
-            'Hooks use a matcher + hooks array. The matcher is a string: a tool name ("Bash"), pipe-separated list ("Edit|Write"), or empty to match all. Example: {"PostToolUse": [{"matcher": "Edit|Write", "hooks": [{"type": "command", "command": "echo Done"}]}]}',
-        },
-    },
-    {
-        matches: (ctx) => ctx.code === 'invalid_type' && ctx.expected === 'boolean',
-        tip: {
-            suggestion: 'Use true or false without quotes. Example: "includeCoAuthoredBy": true',
-        },
-    },
-    {
-        matches: (ctx) => ctx.code === 'unrecognized_keys',
-        tip: {
-            suggestion: 'Check for typos or refer to the documentation for valid fields',
-            docLink: `${DOCUMENTATION_BASE}/settings`,
-        },
-    },
-    {
-        matches: (ctx) => ctx.code === 'invalid_value' && ctx.enumValues !== undefined,
-        tip: {
-            suggestion: undefined,
-        },
-    },
-    {
-        matches: (ctx) => ctx.code === 'invalid_type' &&
-            ctx.expected === 'object' &&
-            ctx.received === null &&
-            ctx.path === '',
-        tip: {
-            suggestion: 'Check for missing commas, unmatched brackets, or trailing commas. Use a JSON validator to identify the exact syntax error.',
-        },
-    },
-    {
-        matches: (ctx) => ctx.path === 'permissions.additionalDirectories' &&
-            ctx.code === 'invalid_type',
-        tip: {
-            suggestion: 'Must be an array of directory paths. Example: ["~/projects", "/tmp/workspace"]. You can also use --add-dir flag or /add-dir command',
-            docLink: `${DOCUMENTATION_BASE}/iam#working-directories`,
-        },
-    },
-];
-const PATH_DOC_LINKS = {
-    permissions: `${DOCUMENTATION_BASE}/iam#configuring-permissions`,
-    env: `${DOCUMENTATION_BASE}/settings#environment-variables`,
-    hooks: `${DOCUMENTATION_BASE}/hooks`,
-};
-export function getValidationTip(context) {
-    const matcher = TIP_MATCHERS.find(m => m.matches(context));
-    if (!matcher)
-        return null;
-    const tip = { ...matcher.tip };
-    if (context.code === 'invalid_value' &&
-        context.enumValues &&
-        !tip.suggestion) {
-        tip.suggestion = `Valid values: ${context.enumValues.map(v => `"${v}"`).join(', ')}`;
-    }
-    // Add documentation link based on path prefix
-    if (!tip.docLink && context.path) {
-        const pathPrefix = context.path.split('.')[0];
-        if (pathPrefix) {
-            tip.docLink = PATH_DOC_LINKS[pathPrefix];
-        }
-    }
-    return tip;
-}

package/dist/src/utils/shell/bashProvider.js

@@ -1,202 +0,0 @@
-import { feature } from '../../recovery/bunBundleShim.js';
-import { access } from 'fs/promises';
-import { tmpdir as osTmpdir } from 'os';
-import { join as nativeJoin } from 'path';
-import { join as posixJoin } from 'path/posix';
-import { rearrangePipeCommand } from '../bash/bashPipeCommand.js';
-import { createAndSaveSnapshot } from '../bash/ShellSnapshot.js';
-import { formatShellPrefixCommand } from '../bash/shellPrefix.js';
-import { quote } from '../bash/shellQuote.js';
-import { quoteShellCommand, rewriteWindowsNullRedirect, shouldAddStdinRedirect, } from '../bash/shellQuoting.js';
-import { logForDebugging } from '../debug.js';
-import { getPlatform } from '../platform.js';
-import { getSessionEnvironmentScript } from '../sessionEnvironment.js';
-import { getSessionEnvVars } from '../sessionEnvVars.js';
-import { ensureSocketInitialized, getClaudeTmuxEnv, hasTmuxToolBeenUsed, } from '../tmuxSocket.js';
-import { windowsPathToPosixPath } from '../windowsPaths.js';
-/**
- * Returns a shell command to disable extended glob patterns for security.
- * Extended globs (bash extglob, zsh EXTENDED_GLOB) can be exploited via
- * malicious filenames that expand after our security validation.
- *
- * When CLAUDE_CODE_SHELL_PREFIX is set, the actual executing shell may differ
- * from shellPath (e.g., shellPath is zsh but the wrapper runs bash). In this
- * case, we include commands for BOTH shells. We redirect both stdout and stderr
- * to /dev/null because zsh's command_not_found_handler writes to STDOUT.
- *
- * When no shell prefix is set, we use the appropriate command for the detected shell.
- */
-function getDisableExtglobCommand(shellPath) {
-    // When CLAUDE_CODE_SHELL_PREFIX is set, the wrapper may use a different shell
-    // than shellPath, so we include both bash and zsh commands
-    if (process.env.CLAUDE_CODE_SHELL_PREFIX) {
-        // Redirect both stdout and stderr because zsh's command_not_found_handler
-        // writes to stdout instead of stderr
-        return '{ shopt -u extglob || setopt NO_EXTENDED_GLOB; } >/dev/null 2>&1 || true';
-    }
-    // No shell prefix - use shell-specific command
-    if (shellPath.includes('bash')) {
-        return 'shopt -u extglob 2>/dev/null || true';
-    }
-    else if (shellPath.includes('zsh')) {
-        return 'setopt NO_EXTENDED_GLOB 2>/dev/null || true';
-    }
-    // Unknown shell - do nothing, we don't know the right command
-    return null;
-}
-export async function createBashShellProvider(shellPath, options) {
-    let currentSandboxTmpDir;
-    const snapshotPromise = options?.skipSnapshot
-        ? Promise.resolve(undefined)
-        : createAndSaveSnapshot(shellPath).catch(error => {
-            logForDebugging(`Failed to create shell snapshot: ${error}`);
-            return undefined;
-        });
-    // Track the last resolved snapshot path for use in getSpawnArgs
-    let lastSnapshotFilePath;
-    return {
-        type: 'bash',
-        shellPath,
-        detached: true,
-        async buildExecCommand(command, opts) {
-            let snapshotFilePath = await snapshotPromise;
-            // This access() check is NOT pure TOCTOU — it's the fallback decision
-            // point for getSpawnArgs. When the snapshot disappears mid-session
-            // (tmpdir cleanup), we must clear lastSnapshotFilePath so getSpawnArgs
-            // adds -l and the command gets login-shell init. Without this check,
-            // `source ... || true` silently fails and commands run with NO shell
-            // init (neither snapshot env nor login profile). The `|| true` on source
-            // still guards the race between this check and the spawned shell.
-            if (snapshotFilePath) {
-                try {
-                    await access(snapshotFilePath);
-                }
-                catch {
-                    logForDebugging(`Snapshot file missing, falling back to login shell: ${snapshotFilePath}`);
-                    snapshotFilePath = undefined;
-                }
-            }
-            lastSnapshotFilePath = snapshotFilePath;
-            // Stash sandboxTmpDir for use in getEnvironmentOverrides
-            currentSandboxTmpDir = opts.sandboxTmpDir;
-            const tmpdir = osTmpdir();
-            const isWindows = getPlatform() === 'windows';
-            const shellTmpdir = isWindows ? windowsPathToPosixPath(tmpdir) : tmpdir;
-            // shellCwdFilePath: POSIX path used inside the bash command (pwd -P >| ...)
-            // cwdFilePath: native OS path used by Node.js for readFileSync/unlinkSync
-            // On non-Windows these are identical; on Windows, Git Bash needs POSIX paths
-            // but Node.js needs native Windows paths for file operations.
-            const shellCwdFilePath = opts.useSandbox
-                ? posixJoin(opts.sandboxTmpDir, `cwd-${opts.id}`)
-                : posixJoin(shellTmpdir, `claude-${opts.id}-cwd`);
-            const cwdFilePath = opts.useSandbox
-                ? posixJoin(opts.sandboxTmpDir, `cwd-${opts.id}`)
-                : nativeJoin(tmpdir, `claude-${opts.id}-cwd`);
-            // Defensive rewrite: the model sometimes emits Windows CMD-style `2>nul`
-            // redirects. In POSIX bash (including Git Bash on Windows), this creates a
-            // literal file named `nul` — a reserved device name that breaks git.
-            // See anthropics/claude-code#4928.
-            const normalizedCommand = rewriteWindowsNullRedirect(command);
-            const addStdinRedirect = shouldAddStdinRedirect(normalizedCommand);
-            let quotedCommand = quoteShellCommand(normalizedCommand, addStdinRedirect);
-            // Debug logging for heredoc/multiline commands to trace trailer handling
-            // Only log when commit attribution is enabled to avoid noise
-            if (feature('COMMIT_ATTRIBUTION') &&
-                (command.includes('<<') || command.includes('\n'))) {
-                logForDebugging(`Shell: Command before quoting (first 500 chars):\n${command.slice(0, 500)}`);
-                logForDebugging(`Shell: Quoted command (first 500 chars):\n${quotedCommand.slice(0, 500)}`);
-            }
-            // Special handling for pipes: move stdin redirect after first command
-            // This ensures the redirect applies to the first command, not to eval itself.
-            // Without this, `eval 'rg foo | wc -l' \< /dev/null` becomes
-            // `rg foo | wc -l < /dev/null` — wc reads /dev/null and outputs 0, and
-            // rg (with no path arg) waits on the open spawn stdin pipe forever.
-            // Applies to sandbox mode too: sandbox wraps the assembled commandString,
-            // not the raw command (since PR #9189).
-            if (normalizedCommand.includes('|') && addStdinRedirect) {
-                quotedCommand = rearrangePipeCommand(normalizedCommand);
-            }
-            const commandParts = [];
-            // Source the snapshot file. The `|| true` guards the race between the
-            // access() check above and the spawned shell's `source` — if the file
-            // vanishes in that window, the `&&` chain still continues.
-            if (snapshotFilePath) {
-                const finalPath = getPlatform() === 'windows'
-                    ? windowsPathToPosixPath(snapshotFilePath)
-                    : snapshotFilePath;
-                commandParts.push(`source ${quote([finalPath])} 2>/dev/null || true`);
-            }
-            // Source session environment variables captured from session start hooks
-            const sessionEnvScript = await getSessionEnvironmentScript();
-            if (sessionEnvScript) {
-                commandParts.push(sessionEnvScript);
-            }
-            // Disable extended glob patterns for security (after sourcing user config to override)
-            const disableExtglobCmd = getDisableExtglobCommand(shellPath);
-            if (disableExtglobCmd) {
-                commandParts.push(disableExtglobCmd);
-            }
-            // When sourcing a file with aliases, they won't be expanded in the same command line
-            // because the shell parses the entire line before execution. Using eval after
-            // sourcing causes a second parsing pass where aliases are now available for expansion.
-            commandParts.push(`eval ${quotedCommand}`);
-            // Use `pwd -P` to get the physical path of the current working directory for consistency with `process.cwd()`
-            commandParts.push(`pwd -P >| ${quote([shellCwdFilePath])}`);
-            let commandString = commandParts.join(' && ');
-            // Apply CLAUDE_CODE_SHELL_PREFIX if set
-            if (process.env.CLAUDE_CODE_SHELL_PREFIX) {
-                commandString = formatShellPrefixCommand(process.env.CLAUDE_CODE_SHELL_PREFIX, commandString);
-            }
-            return { commandString, cwdFilePath };
-        },
-        getSpawnArgs(commandString) {
-            const skipLoginShell = lastSnapshotFilePath !== undefined;
-            if (skipLoginShell) {
-                logForDebugging('Spawning shell without login (-l flag skipped)');
-            }
-            return ['-c', ...(skipLoginShell ? [] : ['-l']), commandString];
-        },
-        async getEnvironmentOverrides(command) {
-            // TMUX SOCKET ISOLATION (DEFERRED):
-            // We initialize Claude's tmux socket ONLY AFTER the Tmux tool has been used
-            // at least once, OR if the current command appears to use tmux.
-            // This defers the startup cost until tmux is actually needed.
-            //
-            // Once the Tmux tool is used (or a tmux command runs), all subsequent Bash
-            // commands will use Claude's isolated socket via the TMUX env var override.
-            //
-            // See tmuxSocket.ts for the full isolation architecture documentation.
-            const commandUsesTmux = command.includes('tmux');
-            if (process.env.USER_TYPE === 'ant' &&
-                (hasTmuxToolBeenUsed() || commandUsesTmux)) {
-                await ensureSocketInitialized();
-            }
-            const claudeTmuxEnv = getClaudeTmuxEnv();
-            const env = {};
-            // CRITICAL: Override TMUX to isolate ALL tmux commands to Claude's socket.
-            // This is NOT the user's TMUX value - it points to Claude's isolated socket.
-            // When null (before socket initializes), user's TMUX is preserved.
-            if (claudeTmuxEnv) {
-                env.TMUX = claudeTmuxEnv;
-            }
-            if (currentSandboxTmpDir) {
-                let posixTmpDir = currentSandboxTmpDir;
-                if (getPlatform() === 'windows') {
-                    posixTmpDir = windowsPathToPosixPath(posixTmpDir);
-                }
-                env.TMPDIR = posixTmpDir;
-                env.CLAUDE_CODE_TMPDIR = posixTmpDir;
-                // Zsh uses TMPPREFIX (default /tmp/zsh) for heredoc temp files,
-                // not TMPDIR. Set it to a path inside the sandbox tmp dir so
-                // heredocs work in sandboxed zsh commands.
-                // Safe to set unconditionally — non-zsh shells ignore TMPPREFIX.
-                env.TMPPREFIX = posixJoin(posixTmpDir, 'zsh');
-            }
-            // Apply session env vars set via /env (child processes only, not the REPL)
-            for (const [key, value] of getSessionEnvVars()) {
-                env[key] = value;
-            }
-            return env;
-        },
-    };
-}

package/dist/src/utils/shell/outputLimits.js

@@ -1,7 +0,0 @@
-import { validateBoundedIntEnvVar } from '../envValidation.js';
-export const BASH_MAX_OUTPUT_UPPER_LIMIT = 150_000;
-export const BASH_MAX_OUTPUT_DEFAULT = 30_000;
-export function getMaxOutputLength() {
-    const result = validateBoundedIntEnvVar('BASH_MAX_OUTPUT_LENGTH', process.env.BASH_MAX_OUTPUT_LENGTH, BASH_MAX_OUTPUT_DEFAULT, BASH_MAX_OUTPUT_UPPER_LIMIT);
-    return result.effective;
-}

package/dist/src/utils/shell/powershellDetection.js

@@ -1,96 +0,0 @@
-import { realpath, stat } from 'fs/promises';
-import { getPlatform } from '../platform.js';
-import { which } from '../which.js';
-async function probePath(p) {
-    try {
-        return (await stat(p)).isFile() ? p : null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Attempts to find PowerShell on the system via PATH.
- * Prefers pwsh (PowerShell Core 7+), falls back to powershell (5.1).
- *
- * On Linux, if PATH resolves to a snap launcher (/snap/…) — directly or
- * via a symlink chain like /usr/bin/pwsh → /snap/bin/pwsh — probe known
- * apt/rpm install locations instead: the snap launcher can hang in
- * subprocesses while snapd initializes confinement, but the underlying
- * binary at /opt/microsoft/powershell/7/pwsh is reliable. On
- * Windows/macOS, PATH is sufficient.
- */
-export async function findPowerShell() {
-    const pwshPath = await which('pwsh');
-    if (pwshPath) {
-        // Snap launcher hangs in subprocesses. Prefer the direct binary.
-        // Check both the resolved PATH entry and its symlink target: on
-        // some distros /usr/bin/pwsh is a symlink to /snap/bin/pwsh, which
-        // would bypass a naive startsWith('/snap/') on the which() result.
-        if (getPlatform() === 'linux') {
-            const resolved = await realpath(pwshPath).catch(() => pwshPath);
-            if (pwshPath.startsWith('/snap/') || resolved.startsWith('/snap/')) {
-                const direct = (await probePath('/opt/microsoft/powershell/7/pwsh')) ??
-                    (await probePath('/usr/bin/pwsh'));
-                if (direct) {
-                    const directResolved = await realpath(direct).catch(() => direct);
-                    if (!direct.startsWith('/snap/') &&
-                        !directResolved.startsWith('/snap/')) {
-                        return direct;
-                    }
-                }
-            }
-        }
-        return pwshPath;
-    }
-    const powershellPath = await which('powershell');
-    if (powershellPath) {
-        return powershellPath;
-    }
-    return null;
-}
-let cachedPowerShellPath = null;
-/**
- * Gets the cached PowerShell path. Returns a memoized promise that
- * resolves to the PowerShell executable path or null.
- */
-export function getCachedPowerShellPath() {
-    if (!cachedPowerShellPath) {
-        cachedPowerShellPath = findPowerShell();
-    }
-    return cachedPowerShellPath;
-}
-/**
- * Infers the PowerShell edition from the binary name without spawning.
- * - `pwsh` / `pwsh.exe` → 'core' (PowerShell 7+: supports `&&`, `||`, `?:`, `??`)
- * - `powershell` / `powershell.exe` → 'desktop' (Windows PowerShell 5.1:
- *   no pipeline chain operators, stderr-sets-$? bug, UTF-16 default encoding)
- *
- * PowerShell 6 (also `pwsh`, no `&&`) has been EOL since 2020 and is not
- * a realistic install target, so 'core' safely implies 7+ semantics.
- *
- * Used by the tool prompt to give version-appropriate syntax guidance so
- * the model doesn't emit `cmd1 && cmd2` on 5.1 (parser error) or avoid
- * `&&` on 7+ where it's the correct short-circuiting operator.
- */
-export async function getPowerShellEdition() {
-    const p = await getCachedPowerShellPath();
-    if (!p)
-        return null;
-    // basename without extension, case-insensitive. Covers:
-    //   C:\Program Files\PowerShell\7\pwsh.exe
-    //   /opt/microsoft/powershell/7/pwsh
-    //   C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe
-    const base = p
-        .split(/[/\\]/)
-        .pop()
-        .toLowerCase()
-        .replace(/\.exe$/, '');
-    return base === 'pwsh' ? 'core' : 'desktop';
-}
-/**
- * Resets the cached PowerShell path. Only for testing.
- */
-export function resetPowerShellCache() {
-    cachedPowerShellPath = null;
-}