@lesliechan721/aw 0.1.0-beta.10 → 0.1.0-beta.12

package/dist/src/utils/plugin-scripts.js

@@ -3,16 +3,24 @@ import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 import fs from 'fs-extra';
 import { redactString } from '../output/redact.js';
-import { observeProcessTree, terminateProcessTree } from './process-tree.js';
+import { createWindowsJobInvocation, observeProcessTree, terminateProcessTree, } from './process-tree.js';
 import { resolveAwHome } from './paths.js';
 import { resolveEffectivePluginConfig } from './plugin-config.js';
 import { assertTestWritablePath } from './test-path-fence.js';
+import { attachSafeOperationError } from './safe-operation-diagnostic.js';
+import { collectSensitiveTokenRepresentations, containsBlockedSensitiveToken, } from './sensitive-content.js';
 export { calculateFileDigest } from './bundle-integrity.js';
-export const PLUGIN_SCRIPT_TIMEOUT_DEFAULT_MS = 30_000;
+export const PLUGIN_SCRIPT_TIMEOUT_DEFAULT_MS = 300_000;
 export const PLUGIN_SCRIPT_TIMEOUT_MIN_MS = 1_000;
-export const PLUGIN_SCRIPT_TIMEOUT_MAX_MS = 300_000;
+export const PLUGIN_SCRIPT_TIMEOUT_MAX_MS = 1_800_000;
 const OUTPUT_LIMIT = 64 * 1024;
-const TOKEN_BOUNDARY_LOOKAHEAD = 2;
+const WINDOWS_JOB_CLOSE_TIMEOUT_MS = 4_500;
+class PluginProcessInputError extends Error {
+    constructor(cause) {
+        super('Plugin process input could not be sent.', { cause });
+        this.name = 'PluginProcessInputError';
+    }
+}
 export async function resolveBundledPluginFilePath(options) {
     const bundleRoot = await fs.realpath(options.bundleRoot);
     const relativePath = options.pluginRelativePath.startsWith('./') ? options.pluginRelativePath.slice(2) : options.pluginRelativePath;
@@ -83,32 +91,47 @@ export function collectSensitivePluginConfigValues(manifest, values) {
         });
     });
 }
+export function assertNoSensitiveConfigValues(value, sensitiveValues, message) {
+    const strings = [];
+    const visit = (entry) => {
+        if (typeof entry === 'string') {
+            strings.push(entry);
+            return;
+        }
+        if (Array.isArray(entry)) {
+            entry.forEach(visit);
+            return;
+        }
+        if (entry !== null && typeof entry === 'object') {
+            Object.entries(entry).forEach(([key, child]) => {
+                strings.push(key);
+                visit(child);
+            });
+        }
+    };
+    visit(value);
+    if (strings.some((entry) => containsBlockedSensitiveToken(entry, sensitiveValues))) {
+        throw new Error(message);
+    }
+}
+export function assertNoSensitiveConfigInFiles(files, sensitiveValues, message) {
+    assertNoSensitiveConfigValues(Object.entries(files).map(([relativePath, content]) => ({
+        relativePath,
+        content: content.toString('utf8'),
+    })), sensitiveValues, message);
+}
 function findSensitiveTokenMatches(value, sensitiveValue, startLimit) {
     if (sensitiveValue === '')
         return [];
-    if (sensitiveValue.length >= 8 && !/^(?:true|false|-?\d+(?:\.\d+)?)$/u.test(sensitiveValue)) {
-        const matches = [];
-        for (let start = value.indexOf(sensitiveValue); start >= 0 && start < startLimit; start = value.indexOf(sensitiveValue, start + 1)) {
-            matches.push({ start, end: start + sensitiveValue.length });
-        }
-        return matches;
-    }
-    const escaped = sensitiveValue.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
-    const numeric = /^-?\d+(?:\.\d+)?$/u.test(sensitiveValue);
-    const boundary = numeric ? '\\p{L}\\p{N}_.+-' : '\\p{L}\\p{N}_';
-    const pattern = new RegExp(`(?<![${boundary}])${escaped}(?![${boundary}])`, 'uy');
     const matches = [];
     for (let start = value.indexOf(sensitiveValue); start >= 0 && start < startLimit; start = value.indexOf(sensitiveValue, start + 1)) {
-        pattern.lastIndex = start;
-        if (pattern.test(value))
-            matches.push({ start, end: start + sensitiveValue.length });
+        matches.push({ start, end: start + sensitiveValue.length });
     }
     return matches;
 }
 function collectMergedSensitiveTokenMatches(value, sensitiveValues, startLimit) {
-    const matches = [...new Set(sensitiveValues)]
-        .filter((sensitiveValue) => sensitiveValue !== '')
-        .flatMap((sensitiveValue) => findSensitiveTokenMatches(value, sensitiveValue, startLimit))
+    const matches = collectSensitiveTokenRepresentations(sensitiveValues)
+        .flatMap((representation) => findSensitiveTokenMatches(value, representation, startLimit))
         .sort((left, right) => left.start - right.start || right.end - left.end);
     const merged = [];
     for (const match of matches) {
@@ -141,113 +164,365 @@ export function truncatePluginScriptOutput(value) {
 export function summarizePluginScriptOutput(value, sensitiveValues) {
     return redactString(redactSensitiveTokenWindow(value, sensitiveValues, Math.min(value.length, OUTPUT_LIMIT))).trim();
 }
+function summarizePreApplyFailureOutput(value, roots, sensitiveValues) {
+    const summary = redactString(sanitizePreApplyErrorMessage(value, roots, sensitiveValues, Math.min(value.length, OUTPUT_LIMIT))).trim();
+    const lines = summary.split('\n').map((line) => line.trim()).filter(Boolean);
+    const includesRuntimeStack = lines.some((line) => line.startsWith('file://')
+        || line.startsWith('at ')
+        || /^Node\.js v/u.test(line));
+    if (!includesRuntimeStack)
+        return summary;
+    return lines.find((line) => /^(?:[A-Za-z]*Error|Error):/u.test(line)) ?? '';
+}
 function resolveOutputCaptureLimit(sensitiveValues) {
-    const maxSensitiveTokenLength = sensitiveValues.reduce((maximum, value) => Math.max(maximum, value.length), 0);
-    // One Unicode code point can require two UTF-16 code units for the trailing token-boundary check.
-    return OUTPUT_LIMIT + maxSensitiveTokenLength + TOKEN_BOUNDARY_LOOKAHEAD;
-}
-export const defaultPluginProcessRunner = {
-    run(invocation, options) {
-        return new Promise((resolve, reject) => {
-            options.signal?.throwIfAborted();
-            const marker = randomUUID();
-            const child = spawn(invocation.command, invocation.args, { cwd: invocation.cwd, env: { ...invocation.env, AW_NATIVE_CLI_PROCESS_MARKER: marker }, shell: false, stdio: ['pipe', 'pipe', 'pipe'] });
-            child.stdin?.end(invocation.stdin ?? '');
-            let stdout = '';
-            let stderr = '';
-            let timedOut = false;
-            let aborted = false;
-            let settled = false;
-            let terminating = false;
-            const outputCaptureLimit = resolveOutputCaptureLimit(options.sensitiveValues ?? []);
-            let observation;
-            if (child.pid !== undefined)
-                observation = observeProcessTree(child.pid, marker);
-            const timer = setTimeout(() => { timedOut = true; terminate(); }, options.timeoutMs);
-            const abort = () => { aborted = true; terminate(); };
-            const cleanup = () => { clearTimeout(timer); options.signal?.removeEventListener('abort', abort); observation?.dispose(); };
-            const settle = () => { if (settled)
-                return; settled = true; cleanup(); if (aborted) {
-                try {
-                    options.signal?.throwIfAborted();
-                }
-                catch (error) {
+    const maxSensitiveTokenLength = collectSensitiveTokenRepresentations(sensitiveValues).reduce((maximum, value) => Math.max(maximum, value.length), 0);
+    return OUTPUT_LIMIT + maxSensitiveTokenLength;
+}
+function privateRootVariants(root) {
+    const normalized = path.resolve(root);
+    return [...new Set([
+            normalized,
+            normalized.replaceAll('\\', '/'),
+            ...(normalized.startsWith('/var/') ? [`/private${normalized}`] : []),
+            ...(normalized.startsWith('/private/var/') ? [normalized.slice('/private'.length)] : []),
+        ])];
+}
+function sanitizePreApplyErrorMessage(value, roots, sensitiveValues, windowEnd = value.length) {
+    const matches = [
+        ...roots
+            .filter(({ root }) => root.trim() !== '')
+            .flatMap(({ root, replacement }) => privateRootVariants(root)
+            .flatMap((variant) => findSensitiveTokenMatches(value, variant, windowEnd)
+            .map((match) => ({ ...match, replacement })))),
+        ...collectSensitiveTokenRepresentations(sensitiveValues)
+            .flatMap((representation) => findSensitiveTokenMatches(value, representation, windowEnd)
+            .map((match) => ({ ...match, replacement: '[REDACTED]' }))),
+    ].sort((left, right) => left.start - right.start || right.end - left.end);
+    const merged = [];
+    for (const match of matches) {
+        const previous = merged.at(-1);
+        if (previous && match.start < previous.end) {
+            previous.end = Math.max(previous.end, match.end);
+        }
+        else {
+            merged.push({ ...match, replacement: match.replacement ?? '[REDACTED]' });
+        }
+    }
+    let output = '';
+    let offset = 0;
+    for (const match of merged) {
+        output += `${value.slice(offset, match.start)}${match.replacement}`;
+        offset = Math.min(match.end, windowEnd);
+    }
+    return output + value.slice(offset, windowEnd);
+}
+export function createDefaultPluginProcessRunner(dependencies = {}) {
+    const platform = dependencies.platform ?? process.platform;
+    const spawnImpl = dependencies.spawn ?? spawn;
+    const observeProcessTreeImpl = dependencies.observeProcessTree ?? observeProcessTree;
+    const terminateProcessTreeImpl = dependencies.terminateProcessTree ?? terminateProcessTree;
+    const createWindowsJobInvocationImpl = dependencies.createWindowsJobInvocation ??
+        (dependencies.spawn ? undefined : createWindowsJobInvocation);
+    return {
+        run(invocation, options) {
+            return new Promise((resolve, reject) => {
+                options.signal?.throwIfAborted();
+                const marker = randomUUID();
+                const windowsJobInvocation = platform === 'win32' && createWindowsJobInvocationImpl
+                    ? createWindowsJobInvocationImpl(invocation.command, invocation.args)
+                    : undefined;
+                const child = spawnImpl(windowsJobInvocation?.command ?? invocation.command, windowsJobInvocation?.args ?? invocation.args, { cwd: invocation.cwd, env: { ...invocation.env, AW_NATIVE_CLI_PROCESS_MARKER: marker }, shell: false, stdio: ['pipe', 'pipe', 'pipe'], detached: platform !== 'win32' });
+                let stdout = '';
+                let stderr = '';
+                let timedOut = false;
+                let aborted = false;
+                let settled = false;
+                let terminating = false;
+                let inputCompleted = child.stdin === null;
+                let inputError;
+                let childExited = false;
+                let cleanupCompleted = false;
+                let completedExitCode = null;
+                let completedSignal = null;
+                let windowsJobCloseTimer;
+                const outputCaptureLimit = resolveOutputCaptureLimit(options.sensitiveValues ?? []);
+                let observation;
+                if (!windowsJobInvocation && child.pid !== undefined)
+                    observation = observeProcessTreeImpl(child.pid, marker);
+                const timer = setTimeout(() => { timedOut = true; terminate(); }, options.timeoutMs);
+                const abort = () => { aborted = true; terminate(); };
+                const cleanup = () => { clearTimeout(timer); if (windowsJobCloseTimer)
+                    clearTimeout(windowsJobCloseTimer); options.signal?.removeEventListener('abort', abort); observation?.dispose(); };
+                const result = () => ({ exitCode: completedExitCode, signal: completedSignal, stdout, stderr, timedOut });
+                const settleImmediately = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
                     reject(error);
-                    return;
+                };
+                const settleIfComplete = () => {
+                    if (settled || !childExited || !cleanupCompleted || !inputCompleted)
+                        return;
+                    settled = true;
+                    cleanup();
+                    if (aborted) {
+                        try {
+                            options.signal?.throwIfAborted();
+                        }
+                        catch (error) {
+                            reject(error);
+                            return;
+                        }
+                    }
+                    if (inputError && !(inputError.code === 'EPIPE'
+                        && completedExitCode === 0
+                        && completedSignal === null) && !timedOut && completedExitCode === 0 && completedSignal === null) {
+                        reject(new PluginProcessInputError(inputError));
+                        return;
+                    }
+                    resolve(result());
+                };
+                function terminate(requireConfirmedCleanup = false, allowUnobservedWindowsProcessOnNormalCompletion = false) {
+                    if (settled || terminating)
+                        return;
+                    terminating = true;
+                    clearTimeout(timer);
+                    const direct = (signal) => { if (child.exitCode === null && child.signalCode === null)
+                        child.kill(signal); };
+                    if (windowsJobInvocation) {
+                        try {
+                            if (child.exitCode === null && child.signalCode === null && child.kill('SIGKILL') === false) {
+                                throw new Error('Windows Job helper did not accept termination.');
+                            }
+                        }
+                        catch (error) {
+                            settleImmediately(error);
+                            return;
+                        }
+                        windowsJobCloseTimer = setTimeout(() => settleImmediately(new Error('Windows Job helper exit could not be confirmed.')), WINDOWS_JOB_CLOSE_TIMEOUT_MS);
+                        windowsJobCloseTimer.unref();
+                        return;
+                    }
+                    const termination = child.pid === undefined
+                        ? Promise.resolve(direct('SIGKILL'))
+                        : terminateProcessTreeImpl(child.pid, direct, {}, {
+                            observation,
+                            requireConfirmedCleanup,
+                            ...(allowUnobservedWindowsProcessOnNormalCompletion
+                                ? { allowUnobservedWindowsProcessOnNormalCompletion: true }
+                                : {}),
+                        });
+                    void Promise.resolve(termination).then(() => { cleanupCompleted = true; settleIfComplete(); }, (error) => settleImmediately(error));
                 }
-            } resolve({ exitCode: child.exitCode, signal: child.signalCode, stdout, stderr, timedOut }); };
-            function terminate() {
-                if (settled || terminating)
-                    return;
-                terminating = true;
-                const direct = (signal) => { if (child.exitCode === null && child.signalCode === null)
-                    child.kill(signal); };
-                const termination = child.pid === undefined ? Promise.resolve(direct('SIGKILL')) : terminateProcessTree(child.pid, direct, {}, { observation });
-                void Promise.resolve(termination).then(settle, settle);
-            }
-            child.stdout?.setEncoding('utf8');
-            child.stderr?.setEncoding('utf8');
-            child.stdout?.on('data', (chunk) => { if (stdout.length < outputCaptureLimit)
-                stdout += chunk.slice(0, outputCaptureLimit - stdout.length); });
-            child.stderr?.on('data', (chunk) => { if (stderr.length < outputCaptureLimit)
-                stderr += chunk.slice(0, outputCaptureLimit - stderr.length); });
-            child.on('error', (error) => { if (!settled && !terminating) {
-                settled = true;
-                cleanup();
-                reject(error);
-            } });
-            child.on('close', (exitCode, signal) => { if (!settled && !terminating) {
-                settled = true;
-                cleanup();
-                resolve({ exitCode, signal, stdout, stderr, timedOut });
-            } });
-            options.signal?.addEventListener('abort', abort, { once: true });
-            if (options.signal?.aborted)
-                abort();
-        });
-    },
-};
-export async function runPostApplyScript(options) {
-    const declaration = options.plugin.manifest.scripts?.postApply;
+                child.stdout?.setEncoding('utf8');
+                child.stderr?.setEncoding('utf8');
+                child.stdout?.on('data', (chunk) => { if (stdout.length < outputCaptureLimit)
+                    stdout += chunk.slice(0, outputCaptureLimit - stdout.length); });
+                child.stderr?.on('data', (chunk) => { if (stderr.length < outputCaptureLimit)
+                    stderr += chunk.slice(0, outputCaptureLimit - stderr.length); });
+                child.on('error', (error) => { if (!settled && (!terminating || windowsJobInvocation))
+                    settleImmediately(error); });
+                const complete = (exitCode, signal) => {
+                    if (settled)
+                        return;
+                    childExited = true;
+                    completedExitCode = exitCode;
+                    completedSignal = signal;
+                    if (windowsJobInvocation) {
+                        cleanupCompleted = true;
+                        settleIfComplete();
+                        return;
+                    }
+                    if (terminating) {
+                        settleIfComplete();
+                        return;
+                    }
+                    terminate(true, platform === 'win32' && exitCode === 0 && signal === null);
+                };
+                child.on(platform === 'win32' ? 'close' : 'exit', complete);
+                if (child.stdin) {
+                    const completeInput = (error) => {
+                        if (error !== undefined && error !== null)
+                            inputError = error;
+                        inputCompleted = true;
+                        settleIfComplete();
+                    };
+                    child.stdin.once('error', completeInput);
+                    child.stdin.once('finish', completeInput);
+                    try {
+                        child.stdin.end(invocation.stdin ?? '', completeInput);
+                    }
+                    catch (error) {
+                        completeInput(error);
+                    }
+                }
+                options.signal?.addEventListener('abort', abort, { once: true });
+                if (options.signal?.aborted)
+                    abort();
+            });
+        },
+    };
+}
+export const defaultPluginProcessRunner = createDefaultPluginProcessRunner();
+export async function runPreApplyScript(options) {
+    const declaration = options.plugin.manifest.scripts?.preApply;
     if (!declaration)
         return;
-    const entryPath = await resolveBundledPluginFilePath({ bundleRoot: options.plugin.rootDir, pluginRelativePath: declaration.path, fieldName: 'postApply script' });
-    const effective = options.plugin.manifest.config?.fields
-        ? await resolveEffectivePluginConfig({ sourceId: options.plugin.sourceId, sourceIdentity: options.plugin.sourceIdentity, pluginName: options.plugin.manifest.name, manifest: options.plugin.manifest, targetScope: options.scope, cwd: options.cwd, env: options.context.env })
-        : { values: {}, issues: [] };
-    if (effective.issues.length > 0)
-        throw new Error(`postApply config is invalid for ${options.plugin.manifest.name}.`);
-    const payload = {
-        schemaVersion: 1,
-        plugin: { pluginId: options.plugin.pluginId ?? `${options.plugin.sourceId}/${options.plugin.manifest.name}`, name: options.plugin.manifest.name, version: options.plugin.manifest.version, rootDir: options.plugin.rootDir },
-        target: { platform: options.platform, scope: options.scope, ...(options.scope === 'project' ? { projectRoot: options.cwd } : {}) },
-        config: { values: effective.values },
-        components: options.components ?? (options.artifacts.length === 0
-            ? [{ kind: 'target', key: `${options.platform}:${options.scope}`, outcome: 'unchanged' }]
-            : options.artifacts.map((artifact) => ({ kind: artifact.kind, key: artifact.artifactKey ?? artifact.id ?? artifact.path, outcome: artifact.state === 'disabled' ? 'removed' : 'updated' }))),
-    };
-    const tempRoot = assertTestWritablePath(path.join(resolveAwHome(options.context.env), 'tmp'), 'postApply temp root');
-    await fs.ensureDir(tempRoot);
-    const tempDir = await fs.mkdtemp(path.join(tempRoot, 'plugin-post-apply-'));
+    const awHome = resolveAwHome(options.context.env);
+    const codexHome = options.context.env.AW_CODEX_HOME || path.join(awHome, 'isolated-codex-home');
+    const claudeHome = options.context.env.AW_CLAUDE_HOME || path.join(awHome, 'isolated-claude-home');
+    let tempDir;
+    let interruptSignal;
+    let interruptReason;
+    let sensitiveValues = [];
+    let runnerCleanupConfirmed = false;
+    let removeInterruptListeners;
+    const privateRoots = () => [
+        ...(tempDir ? [
+            { root: path.join(tempDir, 'home'), replacement: '[temporary-home]' },
+            { root: path.join(tempDir, 'tmp'), replacement: '[temporary]' },
+            { root: tempDir, replacement: '[temporary]' },
+        ] : []),
+        { root: codexHome, replacement: '[codex-home]' },
+        { root: claudeHome, replacement: '[claude-home]' },
+        { root: awHome, replacement: '[aw-home]' },
+        { root: options.plugin.rootDir, replacement: '[plugin-root]' },
+        { root: options.cwd, replacement: '[project-root]' },
+    ];
     try {
+        const entryPath = await resolveBundledPluginFilePath({ bundleRoot: options.plugin.rootDir, pluginRelativePath: declaration.path, fieldName: 'preApply script' });
+        const effective = options.plugin.manifest.config?.fields
+            ? await resolveEffectivePluginConfig({ sourceId: options.plugin.sourceId, sourceIdentity: options.plugin.sourceIdentity, logicalIdentity: options.plugin.catalogLogicalIdentity, pluginName: options.plugin.manifest.name, manifest: options.plugin.manifest, targetScope: options.scope, cwd: options.cwd, env: options.context.env })
+            : { values: {}, issues: [] };
+        if (effective.issues.length > 0)
+            throw new Error(`preApply config is invalid for ${options.plugin.manifest.name}.`);
+        const payload = {
+            schemaVersion: 1,
+            plugin: { pluginId: options.plugin.pluginId ?? `${options.plugin.sourceId}/${options.plugin.manifest.name}`, name: options.plugin.manifest.name, version: options.plugin.manifest.version, rootDir: options.plugin.rootDir },
+            target: { platform: options.platform, scope: options.scope, ...(options.scope === 'project' ? { projectRoot: options.cwd } : {}) },
+            config: { values: effective.values },
+        };
+        const tempRoot = assertTestWritablePath(path.join(awHome, 'tmp'), 'preApply temp root');
+        await fs.ensureDir(tempRoot);
+        tempDir = await fs.mkdtemp(path.join(tempRoot, 'plugin-pre-apply-'));
         await fs.ensureDir(path.join(tempDir, 'home'));
         await fs.ensureDir(path.join(tempDir, 'tmp'));
-        const env = buildPluginScriptSpawnEnv({ commandEnv: options.context.env, contextPath: '', tempDir, plugin: payload.plugin, event: 'postApply', platform: options.platform, scope: options.scope, bundleRoot: options.plugin.rootDir });
+        const env = buildPluginScriptSpawnEnv({ commandEnv: options.context.env, contextPath: '', tempDir, plugin: payload.plugin, event: 'preApply', platform: options.platform, scope: options.scope, bundleRoot: options.plugin.rootDir });
         delete env.AW_PLUGIN_CONTEXT;
-        const sensitiveValues = collectSensitivePluginConfigValues(options.plugin.manifest, effective.values);
+        sensitiveValues = collectSensitivePluginConfigValues(options.plugin.manifest, effective.values);
         const invocation = buildNodeScriptInvocation({ entryPath, cwd: options.plugin.rootDir, env, stdin: `${JSON.stringify(payload)}\n` });
         const runOptions = { timeoutMs: resolvePluginScriptTimeoutMs({ cliTimeoutMs: options.scriptTimeoutMs, manifestTimeoutMs: declaration.timeoutMs }) };
-        const result = options.runner
-            ? await options.runner.run(invocation, runOptions)
-            : await defaultPluginProcessRunner.run(invocation, { ...runOptions, sensitiveValues });
-        const stderr = summarizePluginScriptOutput(result.stderr, sensitiveValues);
+        const interruptController = new AbortController();
+        const handleInterrupt = (signal) => {
+            if (interruptSignal)
+                return;
+            interruptSignal = signal;
+            interruptReason = new Error(`preApply interrupted by ${signal}.`);
+            interruptController.abort(interruptReason);
+        };
+        const handleSigint = () => handleInterrupt('SIGINT');
+        const handleSigterm = () => handleInterrupt('SIGTERM');
+        process.on('SIGINT', handleSigint);
+        process.on('SIGTERM', handleSigterm);
+        removeInterruptListeners = () => {
+            process.removeListener('SIGINT', handleSigint);
+            process.removeListener('SIGTERM', handleSigterm);
+        };
+        let result;
+        try {
+            result = options.runner
+                ? await options.runner.run(invocation, { ...runOptions, signal: interruptController.signal })
+                : await defaultPluginProcessRunner.run(invocation, { ...runOptions, sensitiveValues, signal: interruptController.signal });
+            runnerCleanupConfirmed = true;
+        }
+        catch (error) {
+            if (interruptSignal && error === interruptReason) {
+                runnerCleanupConfirmed = true;
+            }
+            else if (interruptSignal) {
+                throw new Error(`preApply process cleanup failed after ${interruptSignal}.`);
+            }
+            else if (error instanceof PluginProcessInputError) {
+                throw attachSafeOperationError(new Error('preApply input could not be sent.'), {
+                    code: 'preApplyInputFailed',
+                    stage: 'preApply',
+                    safeMessage: 'The preApply context could not be sent to the process.',
+                });
+            }
+            else {
+                const causeCode = error && typeof error === 'object' && 'code' in error
+                    && typeof error.code === 'string' ? error.code : undefined;
+                const safeCauseCode = causeCode === 'ENOENT' || causeCode === 'EACCES' || causeCode === 'EPERM'
+                    ? causeCode : undefined;
+                throw attachSafeOperationError(new Error('preApply could not start.'), {
+                    code: safeCauseCode === 'ENOENT' ? 'preApplyExecutableMissing' : 'preApplyStartFailed',
+                    stage: 'preApply',
+                    safeMessage: causeCode === 'ENOENT'
+                        ? 'The preApply executable is not available.'
+                        : 'The preApply process could not start.',
+                    ...(safeCauseCode ? {
+                        cause: { code: safeCauseCode, safeMessage: `Process start failed (${safeCauseCode}).` },
+                    } : {}),
+                });
+            }
+        }
+        if (!result)
+            return;
+        const stdout = summarizePreApplyFailureOutput(result.stdout, privateRoots(), sensitiveValues);
+        const stderr = summarizePreApplyFailureOutput(result.stderr, privateRoots(), sensitiveValues);
+        const output = [
+            ...(stdout ? [`stdout: ${stdout}`] : []),
+            ...(stderr ? [`stderr: ${stderr}`] : []),
+        ].join('; ');
         if (result.timedOut)
-            throw new Error(`postApply timed out. stderr: ${stderr}`);
-        if (result.exitCode !== 0)
-            throw new Error(`postApply failed with exit code ${result.exitCode}. stderr: ${stderr}`);
+            throw attachSafeOperationError(new Error(`preApply timed out.${output ? ` ${output}` : ''}`), {
+                code: 'preApplyTimedOut',
+                stage: 'preApply',
+                safeMessage: 'The preApply process timed out.',
+                exitCode: 124,
+            });
+        if (result.exitCode !== 0) {
+            throw attachSafeOperationError(new Error(`preApply failed with exit code ${result.exitCode}.${output ? ` ${output}` : ''}`), {
+                code: 'preApplyExited',
+                stage: 'preApply',
+                safeMessage: 'The preApply process exited unsuccessfully.',
+                ...(result.exitCode === null ? {} : { exitCode: result.exitCode }),
+            });
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const failure = new Error(redactString(sanitizePreApplyErrorMessage(message, privateRoots(), sensitiveValues)));
+        const diagnostic = error && typeof error === 'object' && 'operationDiagnostic' in error
+            ? error.operationDiagnostic
+            : undefined;
+        throw diagnostic ? Object.assign(failure, { operationDiagnostic: diagnostic }) : failure;
     }
     finally {
-        await fs.remove(tempDir);
+        let tempCleanupError;
+        try {
+            if (tempDir)
+                await fs.remove(tempDir);
+        }
+        catch (error) {
+            tempCleanupError = error;
+        }
+        removeInterruptListeners?.();
+        if (interruptSignal) {
+            if (tempCleanupError) {
+                process.stderr.write(`preApply temporary directory cleanup failed after ${interruptSignal}.\n`);
+                process.exit(1);
+            }
+            if (!runnerCleanupConfirmed) {
+                process.stderr.write(`preApply process cleanup failed after ${interruptSignal}.\n`);
+                process.exit(1);
+            }
+            process.exit(interruptSignal === 'SIGINT' ? 130 : 143);
+        }
+        if (tempCleanupError) {
+            throw tempCleanupError;
+        }
     }
 }
 //# sourceMappingURL=plugin-scripts.js.map