vigthoria-cli 1.13.20 → 1.13.23

package/dist/utils/runtime-temp.js

@@ -0,0 +1,492 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+const MIB = 1024 * 1024;
+const DEFAULT_MAX_BYTES = 1024 * MIB;
+const DEFAULT_MIN_FREE_BYTES = 128 * MIB;
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const CLEANUP_LOCK_MAX_AGE_MS = 10 * 60 * 1000;
+const MAX_SCAN_ENTRIES = 100_000;
+const LEASE_FILE = '.vigthoria-temp-lease.json';
+const CLEANUP_LOCK = '.vigthoria-temp-cleanup.lock';
+const ROOT_MARKER = '.vigthoria-temp-root.json';
+const LEGACY_CLEANUP_MARKER = '.vigthoria-legacy-temp-cleanup-v1';
+const LEGACY_PREFIXES = [
+    'vigthoria-pull-',
+    'vigthoria-pull-inline-',
+    'vigthoria-update-',
+    'vigthoria-cli-install-',
+    'puppeteer_dev_chrome_profile-',
+];
+export class RuntimeTempError extends Error {
+    code;
+    details;
+    constructor(message, code, details = {}) {
+        super(message);
+        this.name = 'RuntimeTempError';
+        this.code = code;
+        this.details = details;
+    }
+}
+function numericSetting(name, value, fallback, minimum, maximum) {
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed < minimum || parsed > maximum) {
+        throw new RuntimeTempError(`${name} must be a number between ${minimum} and ${maximum}.`, 'TEMP_SETTING_INVALID', {
+            setting: name,
+        });
+    }
+    return Math.floor(parsed);
+}
+function pathIsContained(root, candidate, pathApi) {
+    const relative = pathApi.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${pathApi.sep}`) && relative !== '..' && !pathApi.isAbsolute(relative));
+}
+function rejectUnsafeWindowsPath(value) {
+    const normalized = value.replace(/\//g, '\\');
+    if (/^\\\\[?.]\\/i.test(normalized) || /^\\\\/.test(normalized)) {
+        throw new RuntimeTempError('VIGTHORIA_TEMP_DIR cannot use a UNC or Windows device path.', 'TEMP_ROOT_UNSAFE');
+    }
+}
+function isKnownSharedPosixTemp(value) {
+    const normalized = path.posix.resolve(value);
+    return normalized === '/tmp' || normalized === '/var/tmp' || normalized === '/usr/tmp';
+}
+function pathsEqual(left, right, platform) {
+    const pathApi = platform === 'win32' ? path.win32 : path.posix;
+    const normalize = (value) => {
+        const resolved = pathApi.resolve(value);
+        return platform === 'win32' ? resolved.toLocaleLowerCase('en-US') : resolved;
+    };
+    return normalize(left) === normalize(right);
+}
+export function resolveRuntimeTempRoot(options = {}) {
+    const environment = options.environment || process.env;
+    const platform = options.platform || process.platform;
+    const pathApi = platform === 'win32' ? path.win32 : path.posix;
+    const homeDirectory = options.homeDirectory || os.homedir();
+    const override = String(environment.VIGTHORIA_TEMP_DIR || '').trim();
+    if (override.includes('\0'))
+        throw new RuntimeTempError('VIGTHORIA_TEMP_DIR contains a null byte.', 'TEMP_ROOT_UNSAFE');
+    if (platform === 'win32' && override)
+        rejectUnsafeWindowsPath(override);
+    if (override && !pathApi.isAbsolute(override)) {
+        throw new RuntimeTempError('VIGTHORIA_TEMP_DIR must be an absolute local path.', 'TEMP_ROOT_UNSAFE');
+    }
+    const root = pathApi.resolve(override || pathApi.join(homeDirectory, '.vigthoria', 'tmp'));
+    if (root === pathApi.parse(root).root) {
+        throw new RuntimeTempError('The filesystem root cannot be used for Vigthoria temporary storage.', 'TEMP_ROOT_UNSAFE');
+    }
+    return { root, source: override ? 'explicit-override' : 'per-user-default' };
+}
+function defaultProcessAlive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code === 'EPERM';
+    }
+}
+export class RuntimeTempManager {
+    environment;
+    platform;
+    homeDirectory;
+    now;
+    pid;
+    isProcessAlive;
+    systemTempRoot;
+    configuredRoot;
+    source;
+    maxBytes;
+    minimumFreeBytes;
+    ttlMs;
+    initializedRoot = null;
+    initializedIdentity = null;
+    initializationError = null;
+    lastCleanup = {
+        removedEntries: 0,
+        removedBytes: 0,
+        skippedActiveEntries: 0,
+        legacyRemovedEntries: 0,
+        legacyRemovedBytes: 0,
+    };
+    constructor(options = {}) {
+        this.environment = options.environment || process.env;
+        this.platform = options.platform || process.platform;
+        this.homeDirectory = options.homeDirectory || os.homedir();
+        this.now = options.now || Date.now;
+        this.pid = options.pid || process.pid;
+        this.isProcessAlive = options.isProcessAlive || defaultProcessAlive;
+        this.systemTempRoot = options.systemTempDirectory || os.tmpdir();
+        const resolved = resolveRuntimeTempRoot({ ...options, environment: this.environment, platform: this.platform, homeDirectory: this.homeDirectory });
+        this.configuredRoot = resolved.root;
+        this.source = resolved.source;
+        this.maxBytes = numericSetting('VIGTHORIA_TEMP_MAX_BYTES', this.environment.VIGTHORIA_TEMP_MAX_BYTES, DEFAULT_MAX_BYTES, 64 * MIB, 64 * 1024 * MIB);
+        this.minimumFreeBytes = numericSetting('VIGTHORIA_TEMP_MIN_FREE_BYTES', this.environment.VIGTHORIA_TEMP_MIN_FREE_BYTES, DEFAULT_MIN_FREE_BYTES, 64 * MIB, 64 * 1024 * MIB);
+        const ttlHours = numericSetting('VIGTHORIA_TEMP_TTL_HOURS', this.environment.VIGTHORIA_TEMP_TTL_HOURS, DEFAULT_TTL_MS / 3_600_000, 1, 720);
+        this.ttlMs = ttlHours * 3_600_000;
+    }
+    initialize() {
+        if (this.initializedRoot || this.initializationError)
+            return this.status();
+        try {
+            if (this.source === 'per-user-default' && !fs.existsSync(this.homeDirectory)) {
+                throw new RuntimeTempError('The user home directory does not exist; managed temporary storage cannot be initialized.', 'TEMP_HOME_UNAVAILABLE');
+            }
+            const existed = fs.existsSync(this.configuredRoot);
+            if (existed && fs.lstatSync(this.configuredRoot).isSymbolicLink()) {
+                throw new RuntimeTempError('Vigthoria temporary storage root cannot be a symbolic link or junction.', 'TEMP_ROOT_SYMLINK');
+            }
+            fs.mkdirSync(this.configuredRoot, { recursive: true, mode: 0o700 });
+            if (fs.lstatSync(this.configuredRoot).isSymbolicLink()) {
+                throw new RuntimeTempError('Vigthoria temporary storage root cannot be a symbolic link or junction.', 'TEMP_ROOT_SYMLINK');
+            }
+            const realRoot = fs.realpathSync(this.configuredRoot);
+            const markerPath = path.join(realRoot, ROOT_MARKER);
+            if (this.source === 'explicit-override' && existed && !fs.existsSync(markerPath)) {
+                const existingEntries = fs.readdirSync(realRoot);
+                if (existingEntries.length > 0) {
+                    throw new RuntimeTempError('Explicit temporary storage must be empty or already marked as Vigthoria-managed.', 'TEMP_ROOT_NOT_DEDICATED');
+                }
+            }
+            const pathApi = this.platform === 'win32' ? path.win32 : path.posix;
+            if (pathsEqual(realRoot, this.systemTempRoot, this.platform)
+                || (this.platform !== 'win32' && isKnownSharedPosixTemp(realRoot))) {
+                throw new RuntimeTempError('The shared operating-system temporary directory cannot be used for Vigthoria runtime storage.', 'TEMP_ROOT_SHARED');
+            }
+            if (this.source === 'per-user-default') {
+                const realHome = fs.realpathSync(this.homeDirectory);
+                if (!pathIsContained(realHome, realRoot, pathApi)) {
+                    throw new RuntimeTempError('Default temporary storage escaped the user home through a link.', 'TEMP_ROOT_ESCAPE');
+                }
+            }
+            if (this.platform !== 'win32')
+                fs.chmodSync(realRoot, 0o700);
+            if (!fs.existsSync(markerPath)) {
+                try {
+                    fs.writeFileSync(markerPath, `${JSON.stringify({ schemaVersion: 1, owner: 'vigthoria-cli', createdAt: new Date(this.now()).toISOString() })}\n`, {
+                        flag: 'wx',
+                        mode: 0o600,
+                    });
+                }
+                catch (error) {
+                    if (error?.code !== 'EEXIST')
+                        throw error;
+                }
+            }
+            const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+            if (marker.schemaVersion !== 1 || marker.owner !== 'vigthoria-cli') {
+                throw new RuntimeTempError('Temporary storage ownership marker is invalid.', 'TEMP_ROOT_MARKER_INVALID');
+            }
+            const rootStat = fs.statSync(realRoot, { bigint: true });
+            const probe = path.join(realRoot, `.write-probe-${this.pid}-${this.now()}`);
+            fs.writeFileSync(probe, '', { flag: 'wx', mode: 0o600 });
+            fs.unlinkSync(probe);
+            this.initializedRoot = realRoot;
+            this.initializedIdentity = { dev: rootStat.dev, ino: rootStat.ino };
+            this.environment.TMPDIR = realRoot;
+            this.environment.TMP = realRoot;
+            this.environment.TEMP = realRoot;
+            this.lastCleanup = this.scavenge({ includeLegacy: true });
+        }
+        catch (error) {
+            this.initializationError = error instanceof Error ? error.message : String(error);
+        }
+        return this.status();
+    }
+    createDirectory(prefix = 'run-') {
+        this.initialize();
+        const root = this.requireRoot();
+        if (!/^[a-z0-9][a-z0-9-]{0,47}-$/i.test(prefix)) {
+            throw new RuntimeTempError('Temporary directory prefix is invalid.', 'TEMP_PREFIX_INVALID');
+        }
+        this.lastCleanup = this.scavenge({ includeLegacy: false });
+        const before = this.measure(root);
+        if (before.usedBytes >= this.maxBytes || (before.freeBytes !== null && before.freeBytes < this.minimumFreeBytes)) {
+            throw new RuntimeTempError('Vigthoria temporary storage has insufficient capacity after cleanup.', 'TEMP_CAPACITY_EXHAUSTED', {
+                root,
+                usedBytes: before.usedBytes,
+                maxBytes: this.maxBytes,
+                freeBytes: before.freeBytes,
+                minimumFreeBytes: this.minimumFreeBytes,
+            });
+        }
+        const directory = fs.mkdtempSync(path.join(root, prefix));
+        if (this.platform !== 'win32')
+            fs.chmodSync(directory, 0o700);
+        fs.writeFileSync(path.join(directory, LEASE_FILE), `${JSON.stringify({ schemaVersion: 1, pid: this.pid, createdAt: new Date(this.now()).toISOString() })}\n`, {
+            flag: 'wx',
+            mode: 0o600,
+        });
+        return directory;
+    }
+    removeDirectory(directory) {
+        const root = this.requireRoot();
+        const absolute = path.resolve(directory);
+        if (path.dirname(absolute) !== root || absolute === root) {
+            throw new RuntimeTempError('Refusing to remove a path outside the Vigthoria temporary root.', 'TEMP_CLEANUP_ESCAPE');
+        }
+        fs.rmSync(absolute, { recursive: true, force: true });
+    }
+    scavenge(options = {}) {
+        const root = this.requireRoot();
+        const result = {
+            removedEntries: 0,
+            removedBytes: 0,
+            skippedActiveEntries: 0,
+            legacyRemovedEntries: 0,
+            legacyRemovedBytes: 0,
+        };
+        const lockPath = path.join(root, CLEANUP_LOCK);
+        let lock = null;
+        try {
+            for (let attempt = 0; attempt < 3 && lock === null; attempt += 1) {
+                try {
+                    lock = fs.openSync(lockPath, 'wx', 0o600);
+                }
+                catch (error) {
+                    if (error?.code !== 'EEXIST')
+                        throw error;
+                    let lockAge = 0;
+                    try {
+                        lockAge = this.now() - fs.statSync(lockPath).mtimeMs;
+                    }
+                    catch (statError) {
+                        if (statError?.code === 'ENOENT')
+                            continue;
+                        throw statError;
+                    }
+                    if (lockAge <= CLEANUP_LOCK_MAX_AGE_MS)
+                        return result;
+                    try {
+                        fs.unlinkSync(lockPath);
+                    }
+                    catch (unlinkError) {
+                        if (unlinkError?.code !== 'ENOENT')
+                            throw unlinkError;
+                    }
+                }
+            }
+            if (lock === null)
+                return result;
+            fs.writeFileSync(lock, `${this.pid}\n`);
+            let entries = this.readEntries(root);
+            for (const entry of entries) {
+                if (entry.active) {
+                    result.skippedActiveEntries += 1;
+                    continue;
+                }
+                if (this.now() - entry.modifiedAt > this.ttlMs)
+                    this.removeEntry(entry, result);
+            }
+            entries = this.readEntries(root);
+            let measurement = this.measure(root, entries);
+            for (const entry of entries.filter((candidate) => !candidate.active).sort((left, right) => left.modifiedAt - right.modifiedAt)) {
+                if (measurement.usedBytes <= this.maxBytes && (measurement.freeBytes === null || measurement.freeBytes >= this.minimumFreeBytes))
+                    break;
+                this.removeEntry(entry, result);
+                measurement = this.measure(root);
+            }
+            if (options.includeLegacy && !fs.existsSync(path.join(root, LEGACY_CLEANUP_MARKER))) {
+                this.cleanupLegacySystemTemp(result);
+                try {
+                    fs.writeFileSync(path.join(root, LEGACY_CLEANUP_MARKER), `${new Date(this.now()).toISOString()}\n`, { flag: 'wx', mode: 0o600 });
+                }
+                catch (error) {
+                    if (error?.code !== 'EEXIST')
+                        throw error;
+                }
+            }
+            return result;
+        }
+        finally {
+            if (lock !== null) {
+                fs.closeSync(lock);
+                try {
+                    fs.unlinkSync(lockPath);
+                }
+                catch { /* another process may have recovered a stale lock */ }
+            }
+        }
+    }
+    status() {
+        const root = this.initializedRoot || this.configuredRoot;
+        let measurement = { usedBytes: 0, entryCount: 0, freeBytes: null };
+        let runtimeError = this.initializationError;
+        if (this.initializedRoot) {
+            try {
+                measurement = this.measure(this.requireRoot());
+            }
+            catch (error) {
+                runtimeError = error instanceof Error ? error.message : String(error);
+            }
+        }
+        return {
+            root,
+            source: this.source,
+            writable: Boolean(this.initializedRoot) && !runtimeError,
+            sharedSystemTemp: this.initializedRoot ? pathsEqual(this.initializedRoot, this.systemTempRoot, this.platform) : false,
+            maxBytes: this.maxBytes,
+            minimumFreeBytes: this.minimumFreeBytes,
+            ttlHours: this.ttlMs / 3_600_000,
+            usedBytes: measurement.usedBytes,
+            entryCount: measurement.entryCount,
+            freeBytes: measurement.freeBytes,
+            error: runtimeError,
+            ...this.lastCleanup,
+        };
+    }
+    requireRoot() {
+        if (!this.initializedRoot) {
+            throw new RuntimeTempError(this.initializationError || 'Vigthoria temporary storage is unavailable.', 'TEMP_STORAGE_UNAVAILABLE', {
+                root: this.configuredRoot,
+            });
+        }
+        try {
+            const stat = fs.lstatSync(this.initializedRoot);
+            const identity = fs.statSync(this.initializedRoot, { bigint: true });
+            if (stat.isSymbolicLink()
+                || fs.realpathSync(this.initializedRoot) !== this.initializedRoot
+                || !this.initializedIdentity
+                || identity.dev !== this.initializedIdentity.dev
+                || identity.ino !== this.initializedIdentity.ino) {
+                throw new Error('root identity changed');
+            }
+        }
+        catch {
+            throw new RuntimeTempError('Vigthoria temporary storage root changed after initialization.', 'TEMP_ROOT_CHANGED', {
+                root: this.initializedRoot,
+            });
+        }
+        return this.initializedRoot;
+    }
+    readEntries(root) {
+        const entries = [];
+        for (const name of fs.readdirSync(root)) {
+            if (name === CLEANUP_LOCK || name === ROOT_MARKER || name === LEGACY_CLEANUP_MARKER)
+                continue;
+            const absolutePath = path.join(root, name);
+            let stat;
+            try {
+                stat = fs.lstatSync(absolutePath);
+            }
+            catch (error) {
+                if (error?.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            let active = false;
+            if (stat.isDirectory() && !stat.isSymbolicLink()) {
+                const leasePath = path.join(absolutePath, LEASE_FILE);
+                try {
+                    const lease = JSON.parse(fs.readFileSync(leasePath, 'utf8'));
+                    active = typeof lease.pid === 'number' && this.isProcessAlive(lease.pid);
+                }
+                catch { /* third-party and abandoned directories have no live lease */ }
+            }
+            entries.push({ absolutePath, name, bytes: this.entrySize(absolutePath), modifiedAt: stat.mtimeMs, active });
+        }
+        return entries;
+    }
+    entrySize(entryPath) {
+        let bytes = 0;
+        let visited = 0;
+        const walk = (candidate) => {
+            visited += 1;
+            if (visited > MAX_SCAN_ENTRIES) {
+                bytes = Math.max(bytes, this.maxBytes + 1);
+                return;
+            }
+            const stat = fs.lstatSync(candidate);
+            bytes += stat.size;
+            if (!stat.isDirectory() || stat.isSymbolicLink())
+                return;
+            for (const name of fs.readdirSync(candidate))
+                walk(path.join(candidate, name));
+        };
+        try {
+            walk(entryPath);
+        }
+        catch {
+            return this.maxBytes + 1;
+        }
+        return bytes;
+    }
+    freeBytes(root) {
+        try {
+            const stat = fs.statfsSync(root);
+            return Number(stat.bavail) * Number(stat.bsize);
+        }
+        catch {
+            return null;
+        }
+    }
+    measure(root, entries = this.readEntries(root)) {
+        return {
+            usedBytes: entries.reduce((total, entry) => total + entry.bytes, 0),
+            entryCount: entries.length,
+            freeBytes: this.freeBytes(root),
+        };
+    }
+    removeEntry(entry, result) {
+        if (path.dirname(entry.absolutePath) !== this.requireRoot()) {
+            throw new RuntimeTempError('Temporary cleanup target escaped its root.', 'TEMP_CLEANUP_ESCAPE');
+        }
+        fs.rmSync(entry.absolutePath, { recursive: true, force: true });
+        result.removedEntries += 1;
+        result.removedBytes += entry.bytes;
+    }
+    cleanupLegacySystemTemp(result) {
+        const legacyRoot = this.systemTempRoot;
+        if (!fs.existsSync(legacyRoot) || path.resolve(legacyRoot) === this.requireRoot())
+            return;
+        const currentUid = typeof process.getuid === 'function' ? process.getuid() : null;
+        if (currentUid === null)
+            return;
+        let scanned = 0;
+        for (const name of fs.readdirSync(legacyRoot)) {
+            scanned += 1;
+            if (scanned > MAX_SCAN_ENTRIES)
+                break;
+            if (!LEGACY_PREFIXES.some((prefix) => name.startsWith(prefix)))
+                continue;
+            const candidate = path.join(legacyRoot, name);
+            let stat;
+            try {
+                stat = fs.lstatSync(candidate);
+            }
+            catch {
+                continue;
+            }
+            if (currentUid !== null && stat.uid !== currentUid)
+                continue;
+            if (this.now() - stat.mtimeMs <= this.ttlMs)
+                continue;
+            const bytes = this.entrySize(candidate);
+            fs.rmSync(candidate, { recursive: true, force: true });
+            result.legacyRemovedEntries += 1;
+            result.legacyRemovedBytes += bytes;
+        }
+    }
+}
+let defaultManager = null;
+export function getRuntimeTempManager() {
+    defaultManager ||= new RuntimeTempManager();
+    return defaultManager;
+}
+export function initializeRuntimeTempStorage() {
+    return getRuntimeTempManager().initialize();
+}
+export function runtimeTempStatus() {
+    return getRuntimeTempManager().initialize();
+}
+export function createRuntimeTempDirectory(prefix) {
+    return getRuntimeTempManager().createDirectory(prefix);
+}
+export function removeRuntimeTempDirectory(directory) {
+    getRuntimeTempManager().removeDirectory(directory);
+}

package/dist/utils/secret-policy.d.ts

@@ -0,0 +1,20 @@
+export interface OutboundScanResult<T> {
+    value: T;
+    findings: string[];
+}
+export declare class OutboundContextError extends Error {
+    readonly findings: string[];
+    constructor(findings: string[]);
+}
+export declare function isSensitivePath(pathValue: string): boolean;
+export declare function containsHighConfidenceSecret(input: string): boolean;
+export declare function redactSensitiveText(input: string): string;
+export declare function redactSensitiveValue(value: unknown, seen?: WeakSet<object>): unknown;
+/**
+ * Final production-output guard. Commands should still redact at their own
+ * boundaries, but this prevents an overlooked remote error or JSON object
+ * from writing credentials directly to stdout/stderr.
+ */
+export declare function installConsoleRedaction(): void;
+export declare function scanOutboundContext<T>(input: T): OutboundScanResult<T>;
+export declare function safeChildProcessEnv(source?: NodeJS.ProcessEnv, additions?: Record<string, string>): NodeJS.ProcessEnv;

package/dist/utils/secret-policy.js

@@ -0,0 +1,160 @@
+const REDACTED = '[REDACTED]';
+const SENSITIVE_SEGMENTS = new Set([
+    '.git', '.ssh', '.aws', '.azure', '.kube', '.gnupg', '.vigthoria',
+    'credentials', 'credential', 'secrets', 'secret',
+]);
+const SENSITIVE_BASENAMES = new Set([
+    '.env', '.npmrc', '.pypirc', '.netrc', '.git-credentials',
+    'credentials.json', 'credential.json', 'secrets.json', 'secret.json',
+    'auth.json', 'session.json', 'tokens.json', 'token.json',
+    'id_rsa', 'id_dsa', 'id_ecdsa', 'id_ed25519',
+]);
+const SENSITIVE_EXTENSIONS = new Set([
+    '.pem', '.key', '.p12', '.pfx', '.jks', '.keystore', '.crtkey', '.ovpn',
+]);
+const SECRET_PATTERNS = [
+    /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/i,
+    /\bAKIA[0-9A-Z]{16}\b/,
+    /\b(?:ghp|gho|ghu|ghs|github_pat)_[A-Za-z0-9_]{20,}\b/,
+    /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/,
+    /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/,
+    /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/,
+    /\b(?:password|passwd|pwd|client_secret|private_key|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token)\s*[:=]\s*["']?[A-Za-z0-9_./+=:-]{8,}/i,
+];
+const SENSITIVE_KEY = /(?:^|[_-])(?:authorization|cookie|password|passwd|pwd|secret|private[_-]?key|api[_-]?key|access[_-]?token|refresh[_-]?token|auth[_-]?token|session)(?:$|[_-])/i;
+const SENSITIVE_ENV_KEY = /(?:TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|COOKIE|SESSION|PRIVATE_KEY|API_KEY|AUTH|AWS_|AZURE_|GITHUB_|GITLAB_|NPM_|SSH_)/i;
+export class OutboundContextError extends Error {
+    findings;
+    constructor(findings) {
+        super(`Outbound context contains prohibited secret material (${findings.join(', ')})`);
+        this.name = 'OutboundContextError';
+        this.findings = findings;
+    }
+}
+export function isSensitivePath(pathValue) {
+    const normalized = String(pathValue || '').replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase();
+    if (!normalized)
+        return false;
+    const segments = normalized.split('/').filter(Boolean);
+    const basename = segments.at(-1) || '';
+    if (segments.some((segment) => SENSITIVE_SEGMENTS.has(segment)))
+        return true;
+    if (SENSITIVE_BASENAMES.has(basename))
+        return true;
+    if (basename.startsWith('.env.') || basename.endsWith('.env'))
+        return true;
+    if (/^(?:credentials?|secrets?)[._-]/.test(basename))
+        return true;
+    if (/^(?:tokens?|auth|sessions?)\.(?:json|db|sqlite|sqlite3|yaml|yml)$/i.test(basename))
+        return true;
+    return SENSITIVE_EXTENSIONS.has(basename.slice(basename.lastIndexOf('.')));
+}
+export function containsHighConfidenceSecret(input) {
+    const value = String(input || '').replace(/\[REDACTED\]/g, '');
+    return SECRET_PATTERNS.some((pattern) => pattern.test(value));
+}
+export function redactSensitiveText(input) {
+    return String(input || '')
+        .replace(/-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/gi, REDACTED)
+        .replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/gi, `Bearer ${REDACTED}`)
+        .replace(/\bAKIA[0-9A-Z]{16}\b/g, REDACTED)
+        .replace(/\b(?:ghp|gho|ghu|ghs|github_pat)_[A-Za-z0-9_]{20,}\b/g, REDACTED)
+        .replace(/\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, REDACTED)
+        .replace(/\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g, REDACTED)
+        .replace(/\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g, REDACTED)
+        .replace(/([?&](?:token|access_token|refresh_token|api_key|apikey|key|secret|signature)=)[^&#\s]+/gi, `$1${REDACTED}`)
+        .replace(/\b((?:password|passwd|pwd|token|access_token|refresh_token|api_key|apikey|client_secret|private_key|secret|signature)\s*[:=]\s*)["']?[^,;\s"']+["']?/gi, `$1${REDACTED}`)
+        .replace(/((?:authorization|cookie|x-api-key|x-service-key)\s*[:=]\s*)[^,;\s]+/gi, `$1${REDACTED}`)
+        .replace(/(vigthoria-auth-token=)[^;\s]+/gi, `$1${REDACTED}`);
+}
+export function redactSensitiveValue(value, seen = new WeakSet()) {
+    if (typeof value === 'string')
+        return redactSensitiveText(value);
+    if (value instanceof Error)
+        return `${value.name}: ${redactSensitiveText(value.message)}`;
+    if (!value || typeof value !== 'object')
+        return value;
+    if (seen.has(value))
+        return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.map((entry) => redactSensitiveValue(entry, seen));
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) {
+        output[key] = SENSITIVE_KEY.test(key) ? REDACTED : redactSensitiveValue(entry, seen);
+    }
+    return output;
+}
+let consoleRedactionInstalled = false;
+/**
+ * Final production-output guard. Commands should still redact at their own
+ * boundaries, but this prevents an overlooked remote error or JSON object
+ * from writing credentials directly to stdout/stderr.
+ */
+export function installConsoleRedaction() {
+    if (consoleRedactionInstalled)
+        return;
+    consoleRedactionInstalled = true;
+    for (const method of ['log', 'info', 'warn', 'error', 'debug']) {
+        const original = console[method].bind(console);
+        console[method] = ((...args) => {
+            original(...args.map((value) => redactSensitiveValue(value)));
+        });
+    }
+}
+export function scanOutboundContext(input) {
+    const findings = new Set();
+    const seen = new WeakSet();
+    const visit = (value, location, depth) => {
+        if (depth > 24)
+            throw new OutboundContextError([`${location}: depth limit exceeded`]);
+        if (typeof value === 'string') {
+            if (!/\s/.test(value) && isSensitivePath(value)) {
+                findings.add(`${location}: sensitive path value excluded`);
+                return REDACTED;
+            }
+            if (containsHighConfidenceSecret(value))
+                findings.add(`${location}: secret value redacted`);
+            return redactSensitiveText(value);
+        }
+        if (!value || typeof value !== 'object')
+            return value;
+        if (seen.has(value))
+            throw new OutboundContextError([`${location}: cyclic value`]);
+        seen.add(value);
+        if (Array.isArray(value))
+            return value.map((entry, index) => visit(entry, `${location}[${index}]`, depth + 1));
+        const output = {};
+        for (const [key, entry] of Object.entries(value)) {
+            const child = `${location}.${key}`;
+            if (isSensitivePath(key)) {
+                findings.add(`${child}: sensitive path excluded`);
+                continue;
+            }
+            if (SENSITIVE_KEY.test(key)) {
+                findings.add(`${child}: credential field redacted`);
+                output[key] = REDACTED;
+                continue;
+            }
+            output[key] = visit(entry, child, depth + 1);
+        }
+        return output;
+    };
+    const value = visit(input, '$', 0);
+    if (containsHighConfidenceSecret(JSON.stringify(value))) {
+        throw new OutboundContextError(['residual secret after redaction']);
+    }
+    return { value, findings: [...findings].sort() };
+}
+export function safeChildProcessEnv(source = process.env, additions = {}) {
+    const output = {};
+    for (const [key, value] of Object.entries(source)) {
+        if (value !== undefined && !SENSITIVE_ENV_KEY.test(key))
+            output[key] = value;
+    }
+    for (const [key, value] of Object.entries(additions)) {
+        if (!SENSITIVE_ENV_KEY.test(key))
+            output[key] = value;
+    }
+    return output;
+}