@lesliechan721/aw 0.1.0-beta.5 → 0.1.0-beta.50

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

@@ -2,225 +2,57 @@ import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import path from 'node:path';
 import fs from 'fs-extra';
-import { inferLifecycleScriptRunnerFromPath, PLUGIN_SCRIPT_TIMEOUT_DEFAULT_MS, PLUGIN_SCRIPT_TIMEOUT_MAX_MS, PLUGIN_SCRIPT_TIMEOUT_MIN_MS, resolveLifecycleScriptForOs, } from './plugin-script-contract.js';
-import { resolveAwHome, } from './paths.js';
-import { resolveEffectivePluginConfig } from './plugin-config.js';
 import { redactString } from '../output/redact.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 { observeProcessTree, terminateProcessTree, } from './process-tree.js';
-export { calculateFileDigest, calculatePluginBundleFingerprint, } from './bundle-integrity.js';
-import { calculateFileDigest } from './bundle-integrity.js';
-function runtimeOs() {
-    return process.platform === 'win32' ? 'win32' : process.platform === 'darwin' ? 'darwin' : 'linux';
-}
-function isInsidePath(childPath, rootPath) {
-    const relative = path.relative(rootPath, childPath);
-    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
-}
-function lifecycleCodexHome(env) {
-    return env.AW_CODEX_HOME || path.join(resolveAwHome(env), 'isolated-codex-home');
-}
-function lifecycleClaudeHome(env) {
-    return env.AW_CLAUDE_HOME || path.join(resolveAwHome(env), 'isolated-claude-home');
-}
-function assertLifecycleStagingPathForTests(targetPath, source) {
-    return assertTestWritablePath(targetPath, source, '用 createIsolatedTestEnv() 生成默认 AW_HOME/TMPDIR，或通过 registerWritableStateRoot() 登记 plugin lifecycle staging 路径。');
-}
-export async function resolveBundledPluginFilePath(options) {
-    const resolvedBundleRoot = await fs.realpath(options.bundleRoot);
-    const resolvedPath = await fs.realpath(path.join(options.bundleRoot, stripDotSlash(options.pluginRelativePath)));
-    if (!isInsidePath(resolvedPath, resolvedBundleRoot)) {
-        throw new Error(`${options.fieldName} "${options.pluginRelativePath}" resolves outside the plugin bundle root.`);
-    }
-    return resolvedPath;
-}
-async function createTargetFromPlugin(options) {
-    const selector = options.plugin.manifest.scripts?.lifecycle?.[options.event];
-    if (!selector) {
-        return {
-            noOp: true,
-            source: options.source,
-            bundleRoot: options.plugin.rootDir,
-            sourceManifest: options.plugin.manifest,
-            manifestPath: options.plugin.manifestPath,
-            manifestDigest: await calculateFileDigest(options.plugin.manifestPath),
-            warnings: options.warnings ?? [],
-        };
-    }
-    const entry = resolveLifecycleScriptForOs(selector, options.runtimeOs);
-    if (!entry) {
-        throw new Error(`Plugin "${options.plugin.manifest.name}" declares "${options.event}" lifecycle scripts, but none support ${options.runtimeOs}.`);
-    }
-    const bundleRoot = await fs.realpath(options.plugin.rootDir);
-    const entryPath = await resolveBundledPluginFilePath({
-        bundleRoot,
-        pluginRelativePath: entry.path,
-        fieldName: 'Lifecycle script',
-    });
-    return {
-        noOp: false,
-        source: options.source,
-        entry,
-        entryPath,
-        bundleRoot,
-        sourceManifest: options.plugin.manifest,
-        manifestPath: options.plugin.manifestPath,
-        manifestDigest: await calculateFileDigest(options.plugin.manifestPath),
-        warnings: options.warnings ?? [],
-    };
-}
-async function resolveCurrentPlugin(_pluginName, currentPlugin, _env) {
-    return currentPlugin;
-}
-function createMissingLifecycleWarning(pluginName, event) {
-    return `No executable ${event} lifecycle script was found for ${pluginName}; continuing cleanup without running a lifecycle script.`;
-}
-export async function resolveLifecycleScriptTarget(options) {
-    const runtime = options.runtimeOs ?? runtimeOs();
-    const warnings = [];
-    const currentPlugin = await resolveCurrentPlugin(options.pluginName, options.currentPlugin, options.env ?? process.env);
-    if (currentPlugin) {
-        return createTargetFromPlugin({
-            event: options.event,
-            plugin: currentPlugin,
-            source: 'currentCatalog',
-            runtimeOs: runtime,
-            warnings,
-        });
-    }
-    if (options.event === 'uninstall') {
-        warnings.push(createMissingLifecycleWarning(options.pluginName, options.event));
-    }
-    return { noOp: true, source: 'none', warnings };
-}
-function stripDotSlash(value) {
-    return value.startsWith('./') ? value.slice(2) : value;
-}
-function resolveAutoRunner(entry) {
-    if (entry.runner !== 'auto') {
-        return entry.runner;
+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 = 300_000;
+export const PLUGIN_SCRIPT_TIMEOUT_MIN_MS = 1_000;
+export const PLUGIN_SCRIPT_TIMEOUT_MAX_MS = 1_800_000;
+const OUTPUT_LIMIT = 64 * 1024;
+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';
     }
-    const runner = inferLifecycleScriptRunnerFromPath(entry.path);
-    if (!runner) {
-        throw new Error(`Unable to infer lifecycle script runner from "${entry.path}".`);
-    }
-    return runner;
 }
-export function quoteCmdArgument(value) {
-    if (value === '') {
-        return '""';
-    }
-    if (!/[ \t"&|<>^()]/.test(value)) {
-        return value;
-    }
-    let escaped = '"';
-    let backslashes = 0;
-    for (const character of value) {
-        if (character === '\\') {
-            backslashes += 1;
-            continue;
-        }
-        if (character === '"') {
-            escaped += '\\'.repeat(backslashes * 2 + 1);
-            escaped += '"';
-            backslashes = 0;
-            continue;
-        }
-        escaped += '\\'.repeat(backslashes);
-        backslashes = 0;
-        escaped += character === '%' ? '%%' : character;
-    }
-    escaped += '\\'.repeat(backslashes * 2);
-    escaped += '"';
-    return escaped;
-}
-export function buildLifecycleScriptInvocation(options) {
-    const runner = resolveAutoRunner(options.entry);
-    const scriptArgs = options.entry.args ?? [];
-    if (!scriptArgs.every((arg) => typeof arg === 'string')) {
-        throw new Error('Lifecycle script args must be strings.');
-    }
-    if (runner === 'node') {
-        return {
-            command: process.execPath,
-            args: [options.entryPath, ...scriptArgs],
-            cwd: options.cwd,
-            env: options.env,
-        };
-    }
-    if (runner === 'sh' || runner === 'bash') {
-        return {
-            command: runner,
-            args: [options.entryPath, ...scriptArgs],
-            cwd: options.cwd,
-            env: options.env,
-        };
-    }
-    if (runner === 'pwsh' || runner === 'powershell') {
-        return {
-            command: runner,
-            args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', options.entryPath, ...scriptArgs],
-            cwd: options.cwd,
-            env: options.env,
-        };
-    }
-    return {
-        command: 'cmd',
-        args: ['/d', '/s', '/c', [options.entryPath, ...scriptArgs].map(quoteCmdArgument).join(' ')],
-        cwd: options.cwd,
-        env: options.env,
-    };
-}
-function validateTimeoutMs(value, source) {
-    if (!Number.isInteger(value) ||
-        value < PLUGIN_SCRIPT_TIMEOUT_MIN_MS ||
-        value > PLUGIN_SCRIPT_TIMEOUT_MAX_MS) {
-        throw new Error(`${source} lifecycle script timeout must be an integer between ${PLUGIN_SCRIPT_TIMEOUT_MIN_MS} and ${PLUGIN_SCRIPT_TIMEOUT_MAX_MS} ms.`);
-    }
-    return value;
+export async function resolveBundledPluginFilePath(options) {
+    const bundleRoot = await fs.realpath(options.bundleRoot);
+    const relativePath = options.pluginRelativePath.startsWith('./') ? options.pluginRelativePath.slice(2) : options.pluginRelativePath;
+    const entryPath = await fs.realpath(path.join(bundleRoot, relativePath));
+    const relative = path.relative(bundleRoot, entryPath);
+    if (relative.startsWith('..') || path.isAbsolute(relative))
+        throw new Error(`${options.fieldName} resolves outside the plugin bundle root.`);
+    return entryPath;
 }
-export function resolveLifecycleScriptTimeoutMs(options) {
-    if (options.cliTimeoutMs !== undefined) {
-        return validateTimeoutMs(options.cliTimeoutMs, 'CLI');
-    }
-    const manifestTimeout = options.manifest?.scripts?.timeoutMs;
-    if (manifestTimeout !== undefined) {
-        return validateTimeoutMs(manifestTimeout, 'Manifest');
-    }
-    return PLUGIN_SCRIPT_TIMEOUT_DEFAULT_MS;
+export function buildNodeScriptInvocation(options) {
+    return { command: process.execPath, args: [options.entryPath, ...(options.args ?? [])], cwd: options.cwd, env: options.env, ...(options.stdin === undefined ? {} : { stdin: options.stdin }) };
 }
 export function buildPluginScriptSpawnEnv(options) {
-    if ((options.platform === undefined) === (options.distribution === undefined)) {
-        throw new Error('Plugin script spawn requires exactly one platform or distribution surface.');
-    }
     const input = options.commandEnv;
-    const runtime = options.runtimeOs ?? runtimeOs();
     const output = {
-        AW_HOME: resolveAwHome(input),
-        AW_CODEX_HOME: lifecycleCodexHome(input),
-        AW_CLAUDE_HOME: lifecycleClaudeHome(input),
-        PATH: input.PATH ?? input.Path ?? '',
-        AW_PLUGIN_CONTEXT: options.contextPath,
-        AW_PLUGIN_ROOT: options.bundleRoot,
-        AW_PLUGIN_NAME: options.plugin.name,
-        AW_PLUGIN_VERSION: options.plugin.version,
-        AW_PLUGIN_EVENT: options.event,
-        AW_PLUGIN_SCOPE: options.scope,
+        AW_HOME: resolveAwHome(input), AW_CODEX_HOME: input.AW_CODEX_HOME || path.join(resolveAwHome(input), 'isolated-codex-home'),
+        AW_CLAUDE_HOME: input.AW_CLAUDE_HOME || path.join(resolveAwHome(input), 'isolated-claude-home'), PATH: input.PATH ?? input.Path ?? '',
+        AW_PLUGIN_CONTEXT: options.contextPath, AW_PLUGIN_ROOT: options.bundleRoot, AW_PLUGIN_NAME: options.plugin.name,
+        AW_PLUGIN_VERSION: options.plugin.version, AW_PLUGIN_EVENT: options.event, AW_PLUGIN_SCOPE: options.scope,
     };
     if (options.platform)
         output.AW_PLUGIN_PLATFORM = options.platform;
     if (options.distribution)
         output.AW_PLUGIN_DISTRIBUTION = options.distribution;
-    if (runtime === 'win32') {
+    if (process.platform === 'win32') {
         output.USERPROFILE = path.join(options.tempDir, 'home');
         output.TEMP = path.join(options.tempDir, 'tmp');
         output.TMP = output.TEMP;
-        if (input.SystemRoot) {
+        if (input.SystemRoot)
             output.SystemRoot = input.SystemRoot;
-        }
-        if (input.ComSpec) {
+        if (input.ComSpec)
             output.ComSpec = input.ComSpec;
-        }
     }
     else {
         output.HOME = path.join(options.tempDir, 'home');
@@ -228,358 +60,486 @@ export function buildPluginScriptSpawnEnv(options) {
     }
     return output;
 }
-export function buildLifecycleSpawnEnv(options) {
-    return buildPluginScriptSpawnEnv(options);
+export function resolvePluginScriptTimeoutMs(options) {
+    const value = options.cliTimeoutMs ?? options.manifestTimeoutMs ?? PLUGIN_SCRIPT_TIMEOUT_DEFAULT_MS;
+    if (!Number.isInteger(value) || value < PLUGIN_SCRIPT_TIMEOUT_MIN_MS || value > PLUGIN_SCRIPT_TIMEOUT_MAX_MS)
+        throw new Error('Plugin script timeout is outside the supported range.');
+    return value;
+}
+function collectScalarLeafTokens(value) {
+    if (typeof value === 'string')
+        return value === '' ? [] : [value];
+    if (typeof value === 'number' || typeof value === 'boolean')
+        return [String(value)];
+    if (value === null || typeof value !== 'object')
+        return [];
+    return Object.values(value).flatMap(collectScalarLeafTokens);
 }
 export function collectSensitivePluginConfigValues(manifest, values) {
-    const schema = manifest.config?.schema ?? {};
-    return Object.entries(schema)
-        .filter(([, field]) => field.sensitive)
-        .map(([key]) => values[key])
-        .filter((value) => value !== undefined)
-        .map((value) => String(value))
-        .filter((value) => value.length > 0);
+    return Object.entries(manifest.config?.fields ?? {}).flatMap(([key, field]) => {
+        const value = values[key];
+        if (value === undefined)
+            return [];
+        if (field.sensitive)
+            return collectScalarLeafTokens(value);
+        if (field.type !== 'object' || typeof value !== 'object')
+            return [];
+        return Object.entries(value).flatMap(([property, childValue]) => {
+            const child = field.properties?.[property]
+                ?? (field.additionalProperties === false ? undefined : field.additionalProperties);
+            return child?.sensitive ? collectScalarLeafTokens(childValue) : [];
+        });
+    });
 }
-export function redactPluginScriptOutput(value, sensitiveValues) {
-    let output = redactString(value);
-    for (const sensitiveValue of sensitiveValues) {
-        output = output.split(sensitiveValue).join('[REDACTED]');
+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);
     }
-    return output;
 }
-export function summarizePluginScriptOutput(value, sensitiveValues) {
-    const normalized = value.trim().slice(0, 4000);
-    return redactPluginScriptOutput(normalized, sensitiveValues);
+export function assertNoSensitiveConfigInFiles(files, sensitiveValues, message) {
+    assertNoSensitiveConfigValues(Object.entries(files).map(([relativePath, content]) => ({
+        relativePath,
+        content: content.toString('utf8'),
+    })), sensitiveValues, message);
 }
-export async function writeLifecycleScriptContext(options) {
-    if ((options.sourceId === undefined) !== (options.sourceIdentity === undefined)) {
-        throw new Error('Lifecycle script context requires a complete source identity.');
-    }
-    if (options.target.noOp || !options.target.entry || !options.target.entryPath || !options.target.bundleRoot || !options.target.sourceManifest || !options.target.manifestPath || !options.target.manifestDigest) {
-        throw new Error('Cannot write lifecycle script context for a no-op target.');
+function findSensitiveTokenMatches(value, sensitiveValue, startLimit) {
+    if (sensitiveValue === '')
+        return [];
+    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 });
     }
-    let config = {
-        schema: options.target.sourceManifest.config?.schema,
-        values: {},
-        sources: {},
-        issues: [],
-    };
-    let configStores;
-    if (options.target.sourceManifest.config?.schema) {
-        const effective = await resolveEffectivePluginConfig({
-            sourceId: options.sourceId,
-            sourceIdentity: options.sourceIdentity,
-            pluginName: options.target.sourceManifest.name,
-            manifest: options.target.sourceManifest,
-            cwd: options.cwd,
-            env: options.commandEnv,
-        });
-        if (effective.issues.length > 0) {
-            throw new Error(`Invalid AW config for ${options.target.sourceManifest.name}: ${effective.issues.map((issue) => `${issue.key} (${issue.type})`).join(', ')}.`);
+    return matches;
+}
+function collectMergedSensitiveTokenMatches(value, sensitiveValues, 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) {
+        const previous = merged.at(-1);
+        if (previous && match.start < previous.end) {
+            previous.end = Math.max(previous.end, match.end);
+        }
+        else {
+            merged.push({ ...match });
         }
-        configStores = {
-            user: effective.stores.user.path,
-            project: effective.stores.project.path,
-            projectLocal: effective.stores.projectLocal.path,
-        };
-        config = {
-            schema: options.target.sourceManifest.config.schema,
-            values: effective.values,
-            sources: effective.sources,
-            issues: effective.issues,
-        };
     }
-    const context = {
-        event: options.event,
-        plugin: {
-            name: options.target.sourceManifest.name,
-            version: options.target.sourceManifest.version,
-            rootDir: options.target.bundleRoot,
-            ...(options.sourceId ? {
-                sourceId: options.sourceId,
-                sourceIdentity: options.sourceIdentity,
-                pluginId: `${options.sourceId}/${options.target.sourceManifest.name}`,
-            } : {}),
-        },
-        platform: options.platform,
-        scope: options.scope,
-        cwd: options.cwd,
-        paths: {
-            awHome: resolveAwHome(options.commandEnv),
-            codexHome: lifecycleCodexHome(options.commandEnv),
-            claudeHome: lifecycleClaudeHome(options.commandEnv),
-            manifestPath: options.target.manifestPath,
-            ...(configStores ? { configStores } : {}),
-        },
-        config,
-        script: {
-            runner: options.target.entry.runner,
-            path: options.target.entryPath,
-            args: options.target.entry.args ?? [],
-            source: options.target.source,
-            manifestDigest: options.target.manifestDigest,
-        },
-        artifacts: options.artifacts ?? [],
-    };
-    const tempRoot = assertLifecycleStagingPathForTests(path.join(resolveAwHome(options.commandEnv), 'tmp'), 'plugin lifecycle temp root');
-    await fs.ensureDir(tempRoot);
-    const tempDir = await fs.mkdtemp(assertLifecycleStagingPathForTests(path.join(tempRoot, 'plugin-script-'), 'plugin lifecycle context temp dir'));
-    const contextPath = assertLifecycleStagingPathForTests(path.join(tempDir, 'context.json'), 'plugin lifecycle context file');
-    await fs.writeJson(contextPath, context, { spaces: 2 });
-    try {
-        await fs.chmod(contextPath, 0o600);
+    return merged;
+}
+function redactSensitiveTokenWindow(value, sensitiveValues, windowEnd) {
+    const matches = collectMergedSensitiveTokenMatches(value, sensitiveValues, windowEnd);
+    let output = '';
+    let offset = 0;
+    for (const match of matches) {
+        output += `${value.slice(offset, match.start)}[REDACTED]`;
+        offset = Math.min(match.end, windowEnd);
+    }
+    return output + value.slice(offset, windowEnd);
+}
+export function redactPluginScriptOutput(value, sensitiveValues) {
+    return redactString(redactSensitiveTokenWindow(value, sensitiveValues, value.length));
+}
+export function truncatePluginScriptOutput(value) {
+    return value.slice(0, OUTPUT_LIMIT);
+}
+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 = 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]' });
+        }
     }
-    catch {
-        // Best effort on non-POSIX filesystems.
+    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 {
-        context,
-        contextPath,
-        tempDir,
-        sensitiveValues: collectSensitivePluginConfigValues(options.target.sourceManifest, config.values),
-        cleanup: async () => {
-            await fs.remove(tempDir);
-        },
-    };
+    return output + value.slice(offset, windowEnd);
 }
-export const defaultPluginProcessRunner = {
-    run(invocation, options) {
-        return new Promise((resolve, reject) => {
-            options.signal?.throwIfAborted();
-            const processMarker = randomUUID();
-            const child = spawn(invocation.command, invocation.args, {
-                cwd: invocation.cwd,
-                env: {
-                    ...invocation.env,
-                    AW_NATIVE_CLI_PROCESS_MARKER: processMarker,
-                },
-                shell: false,
-                stdio: ['ignore', 'pipe', 'pipe'],
-            });
-            let stdout = '';
-            let stderr = '';
-            let timedOut = false;
-            let aborted = false;
-            let settled = false;
-            let terminating = false;
-            let processTreeObservation;
-            if (child.pid !== undefined) {
-                processTreeObservation = observeProcessTree(child.pid, processMarker);
-            }
-            const timer = setTimeout(() => {
-                timedOut = true;
-                terminate();
-            }, options.timeoutMs);
-            const abort = () => {
-                aborted = true;
-                terminate();
-            };
-            const cleanup = () => {
-                clearTimeout(timer);
-                options.signal?.removeEventListener('abort', abort);
-                processTreeObservation?.dispose();
-            };
-            const settleAfterTermination = () => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                child.stdout?.destroy();
-                child.stderr?.destroy();
-                if (aborted) {
-                    try {
-                        options.signal?.throwIfAborted();
+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;
+                // Keep long Catalog snapshot directories accessible to libuv's Windows cwd resolution.
+                const cwd = platform === 'win32' ? path.win32.toNamespacedPath(invocation.cwd) : invocation.cwd;
+                const child = spawnImpl(windowsJobInvocation?.command ?? invocation.command, windowsJobInvocation?.args ?? invocation.args, { 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 stdoutBytes = 0;
+                let stdoutTruncated = 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, ...(stdoutTruncated ? { stdoutTruncated: true } : {}) });
+                const settleImmediately = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    reject(error);
+                };
+                const settleIfComplete = () => {
+                    if (settled || !childExited || !cleanupCompleted || !inputCompleted)
+                        return;
+                    settled = true;
+                    cleanup();
+                    if (aborted) {
+                        try {
+                            options.signal?.throwIfAborted();
+                        }
+                        catch (error) {
+                            reject(error);
+                            return;
+                        }
                     }
-                    catch (error) {
-                        reject(error);
+                    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,
+                child.stdout?.setEncoding('utf8');
+                child.stderr?.setEncoding('utf8');
+                child.stdout?.on('data', (chunk) => {
+                    if (options.maxStdoutBytes === undefined) {
+                        if (stdout.length < outputCaptureLimit)
+                            stdout += chunk.slice(0, outputCaptureLimit - stdout.length);
+                        return;
+                    }
+                    const bytes = Buffer.from(chunk, 'utf8');
+                    const remaining = Math.max(0, options.maxStdoutBytes - stdoutBytes);
+                    stdout += bytes.subarray(0, remaining).toString('utf8');
+                    stdoutBytes += bytes.length;
+                    if (stdoutBytes > options.maxStdoutBytes) {
+                        stdoutTruncated = true;
+                        terminate(true);
+                    }
                 });
-            };
-            function terminate() {
-                if (settled || terminating)
-                    return;
-                terminating = true;
-                clearTimeout(timer);
-                const killDirectChild = (signal) => {
-                    if (child.exitCode === null && child.signalCode === null)
-                        child.kill(signal);
+                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);
                 };
-                const termination = child.pid === undefined
-                    ? Promise.resolve(killDirectChild('SIGKILL'))
-                    : terminateProcessTree(child.pid, killDirectChild, {}, { observation: processTreeObservation });
-                void Promise.resolve(termination).then(settleAfterTermination, settleAfterTermination);
-            }
-            child.stdout?.setEncoding('utf8');
-            child.stderr?.setEncoding('utf8');
-            child.stdout?.on('data', (chunk) => {
-                stdout += chunk;
-            });
-            child.stderr?.on('data', (chunk) => {
-                stderr += chunk;
-            });
-            child.on('error', (error) => {
-                if (settled || terminating)
-                    return;
-                settled = true;
-                cleanup();
-                reject(error);
-            });
-            child.on('close', (exitCode, signal) => {
-                if (settled || terminating)
-                    return;
-                settled = true;
-                cleanup();
-                resolve({ exitCode, signal, stdout, stderr, timedOut });
+                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();
             });
-            options.signal?.addEventListener('abort', abort, { once: true });
-            if (options.signal?.aborted)
-                abort();
-        });
-    },
-};
-async function emitLifecycleEvent(context, event) {
-    const commandEvent = {
-        type: event.type,
-        message: event.message,
-        data: event.data,
-        level: event.level,
-        source: {
-            plugin: event.plugin,
-            platform: event.platform,
-            scope: event.scope,
-            action: 'lifecycle',
         },
     };
-    await context.reporter.event(commandEvent);
-    await context.debugLogger.log(commandEvent);
 }
-export async function runLifecycleScript(options) {
-    const target = await resolveLifecycleScriptTarget({
-        event: options.event,
-        pluginName: options.pluginName,
-        platform: options.platform,
-        currentPlugin: options.currentPlugin,
-        cwd: options.cwd,
-        env: options.context.env,
-        runtimeOs: options.runtimeOs,
-    });
-    for (const warning of target.warnings) {
-        await options.context.reporter.notice({
-            level: 'warning',
-            message: warning,
-            source: {
-                platform: options.platform,
-                plugin: options.pluginName,
-                scope: options.scope,
-                action: 'lifecycle',
-            },
-            target: 'stderr',
-        });
-    }
-    if (target.noOp) {
-        await emitLifecycleEvent(options.context, {
-            type: 'lifecycle.noop',
-            message: `${options.event} lifecycle script is not declared.`,
-            plugin: options.pluginName,
-            platform: options.platform,
-            scope: options.scope,
-            level: 'debug',
-        });
-        return { executed: false, target };
-    }
-    const writtenContext = await writeLifecycleScriptContext({
-        sourceId: options.currentPlugin?.sourceId,
-        sourceIdentity: options.currentPlugin?.sourceIdentity,
-        target,
-        event: options.event,
-        platform: options.platform,
-        scope: options.scope,
-        cwd: options.cwd,
-        commandEnv: options.context.env,
-        artifacts: options.artifacts,
-    });
+export const defaultPluginProcessRunner = createDefaultPluginProcessRunner();
+export async function runPreApplyScript(options) {
+    const declaration = options.plugin.manifest.scripts?.preApply;
+    if (!declaration)
+        return;
+    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 {
-        await fs.ensureDir(path.join(writtenContext.tempDir, 'home'));
-        await fs.ensureDir(path.join(writtenContext.tempDir, 'tmp'));
-        const timeoutMs = resolveLifecycleScriptTimeoutMs({
-            cliTimeoutMs: options.scriptTimeoutMs,
-            manifest: target.sourceManifest,
-        });
-        const spawnEnv = buildLifecycleSpawnEnv({
-            commandEnv: options.context.env,
-            contextPath: writtenContext.contextPath,
-            tempDir: writtenContext.tempDir,
-            plugin: writtenContext.context.plugin,
-            event: options.event,
-            platform: options.platform,
-            scope: options.scope,
-            bundleRoot: writtenContext.context.plugin.rootDir,
-            runtimeOs: options.runtimeOs,
-        });
-        const invocation = buildLifecycleScriptInvocation({
-            entry: target.entry,
-            entryPath: target.entryPath,
-            cwd: options.cwd,
-            env: spawnEnv,
-        });
-        await emitLifecycleEvent(options.context, {
-            type: 'lifecycle.start',
-            plugin: options.pluginName,
-            platform: options.platform,
-            scope: options.scope,
-            level: 'info',
-            data: {
-                event: options.event,
-                source: target.source,
-                command: invocation.command,
-                args: invocation.args,
-                timeoutMs,
-            },
-        });
-        const result = await (options.runner ?? defaultPluginProcessRunner).run(invocation, { timeoutMs });
-        const stdoutSummary = summarizePluginScriptOutput(result.stdout, writtenContext.sensitiveValues);
-        const stderrSummary = summarizePluginScriptOutput(result.stderr, writtenContext.sensitiveValues);
-        await emitLifecycleEvent(options.context, {
-            type: 'lifecycle.finish',
-            plugin: options.pluginName,
-            platform: options.platform,
-            scope: options.scope,
-            level: result.exitCode === 0 && !result.timedOut ? 'info' : 'warning',
-            data: {
-                event: options.event,
-                exitCode: result.exitCode,
-                signal: result.signal,
-                timedOut: result.timedOut,
-                stdout: stdoutSummary,
-                stderr: stderrSummary,
-            },
-        });
-        if (result.timedOut) {
-            throw new Error(`Lifecycle script "${options.event}" timed out after ${timeoutMs} ms. stderr: ${stderrSummary}`);
+        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: 'preApply', platform: options.platform, scope: options.scope, bundleRoot: options.plugin.rootDir });
+        delete env.AW_PLUGIN_CONTEXT;
+        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 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 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 new Error(`Lifecycle script "${options.event}" failed with exit code ${result.exitCode}. stderr: ${stderrSummary}`);
+            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 }),
+            });
         }
-        return {
-            executed: true,
-            target,
-            exitCode: result.exitCode,
-            signal: result.signal,
-            stdout: stdoutSummary,
-            stderr: stderrSummary,
-            timedOut: result.timedOut,
-        };
+    }
+    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 writtenContext.cleanup();
+        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