@modelprofile.com/flexharness 6.1.0 → 7.0.1

package/dist_ts_tools_node/tool.context.js

@@ -0,0 +1,837 @@
+import * as plugins from './plugins.js';
+const DEFAULT_LOCAL_SHELL_MAX_OUTPUT_BYTES = 1024 * 1024;
+const LOCAL_SHELL_KILL_GRACE_MS = 1000;
+export const createLocalToolExecutionContext = (options = {}) => {
+    const cwd = options.cwd ?? process.cwd();
+    const rootDir = options.rootDir;
+    const additionalReadOnlyRoots = [...new Set((options.additionalReadOnlyRoots ?? []).map((rootDirArg, index) => {
+            if (typeof rootDirArg !== 'string' || !rootDirArg.trim()) {
+                throw new Error(`additionalReadOnlyRoots[${index}] must be a non-empty path.`);
+            }
+            return plugins.path.resolve(rootDirArg);
+        }))];
+    const maxShellOutputBytes = options.maxShellOutputBytes ?? DEFAULT_LOCAL_SHELL_MAX_OUTPUT_BYTES;
+    if (!Number.isSafeInteger(maxShellOutputBytes) || maxShellOutputBytes <= 0) {
+        throw new Error('maxShellOutputBytes must be a positive integer.');
+    }
+    const maxRetainedJobs = options.maxRetainedJobs ?? 100;
+    if (!Number.isSafeInteger(maxRetainedJobs) || maxRetainedJobs < 0) {
+        throw new Error('maxRetainedJobs must be a non-negative integer.');
+    }
+    const outputListenerTimeoutMs = options.outputListenerTimeoutMs ?? 30_000;
+    if (!Number.isSafeInteger(outputListenerTimeoutMs) || outputListenerTimeoutMs <= 0) {
+        throw new Error('outputListenerTimeoutMs must be a positive integer.');
+    }
+    const jobStoreOperationTimeoutMs = options.jobStoreOperationTimeoutMs
+        ?? outputListenerTimeoutMs;
+    if (!Number.isSafeInteger(jobStoreOperationTimeoutMs) || jobStoreOperationTimeoutMs <= 0) {
+        throw new Error('jobStoreOperationTimeoutMs must be a positive integer.');
+    }
+    const jobs = createLocalToolJobContext({
+        cwd,
+        rootDir,
+        maxOutputBytes: maxShellOutputBytes,
+        maxRetainedJobs,
+        jobStore: options.jobStore,
+        outputListenerTimeoutMs,
+        jobStoreOperationTimeoutMs,
+        settleOrphanedJob: options.settleOrphanedJob,
+        beforeOperation: options.beforeOperation,
+        abortSignal: options.abortSignal,
+    });
+    return {
+        cwd,
+        rootDir,
+        additionalReadOnlyRoots,
+        abortSignal: options.abortSignal,
+        requestPermission: options.requestPermission,
+        shell: {
+            run: (command, runOptions) => runLocalShellCommand(command, {
+                cwd: resolveLocalPath(runOptions?.cwd ?? cwd, rootDir),
+                timeoutMs: runOptions?.timeoutMs,
+                abortSignal: runOptions?.abortSignal ?? options.abortSignal,
+                onOutput: runOptions?.onOutput,
+                outputListenerTimeoutMs,
+                maxOutputBytes: maxShellOutputBytes,
+                beforeOperation: options.beforeOperation,
+            }),
+            runStructured: (command, runOptions) => runLocalStructuredCommand(command, {
+                cwd: resolveLocalPath(runOptions?.cwd ?? cwd, rootDir),
+                timeoutMs: runOptions?.timeoutMs,
+                abortSignal: runOptions?.abortSignal ?? options.abortSignal,
+                onOutput: runOptions?.onOutput,
+                outputListenerTimeoutMs,
+                maxOutputBytes: maxShellOutputBytes,
+                beforeOperation: options.beforeOperation,
+            }),
+        },
+        jobs,
+        fs: {
+            readFile: async (filePath, readOptions, invocationOptions) => {
+                const abortSignal = invocationOptions?.abortSignal ?? options.abortSignal;
+                throwIfAborted(abortSignal);
+                const resolved = resolveLocalReadPath(filePath, rootDir, cwd);
+                const readRoots = plugins.path.isAbsolute(filePath)
+                    ? [...(rootDir ? [rootDir] : []), ...additionalReadOnlyRoots]
+                    : rootDir
+                        ? [rootDir]
+                        : [];
+                const operationPath = readRoots.length > 0
+                    ? await resolveCanonicalExistingLocalReadPath(resolved, filePath, readRoots)
+                    : resolved;
+                await runBeforeLocalOperation(options.beforeOperation, abortSignal);
+                const content = await plugins.fs.promises.readFile(operationPath, 'utf8');
+                throwIfAborted(abortSignal);
+                if (readOptions?.startLine !== undefined || readOptions?.endLine !== undefined) {
+                    const lines = content.split('\n');
+                    const start = Math.max((readOptions.startLine ?? 1) - 1, 0);
+                    const end = Math.max(readOptions.endLine ?? lines.length, start);
+                    return lines.slice(start, end).join('\n');
+                }
+                return content;
+            },
+            writeFile: async (filePath, content, invocationOptions) => {
+                const abortSignal = invocationOptions?.abortSignal ?? options.abortSignal;
+                throwIfAborted(abortSignal);
+                const resolved = resolveLocalPath(filePath, rootDir, cwd);
+                const parentPath = plugins.path.dirname(resolved);
+                const canonicalBoundary = rootDir
+                    ? {
+                        rootDir,
+                        canonicalRoot: await resolveCanonicalProspectivePath(plugins.path.resolve(rootDir)),
+                    }
+                    : undefined;
+                if (canonicalBoundary) {
+                    const canonicalProspectiveParent = await resolveCanonicalProspectivePath(parentPath);
+                    assertCanonicalPathAllowed(canonicalProspectiveParent, canonicalBoundary.canonicalRoot, filePath, canonicalBoundary.rootDir);
+                    await assertExistingWriteTargetAllowed(resolved, canonicalBoundary.canonicalRoot, filePath, canonicalBoundary.rootDir);
+                }
+                await runBeforeLocalOperation(options.beforeOperation, abortSignal);
+                await plugins.fs.promises.mkdir(parentPath, { recursive: true });
+                throwIfAborted(abortSignal);
+                if (canonicalBoundary) {
+                    const canonicalParent = await plugins.fs.promises.realpath(parentPath);
+                    assertCanonicalPathAllowed(canonicalParent, canonicalBoundary.canonicalRoot, filePath, canonicalBoundary.rootDir);
+                    await assertExistingWriteTargetAllowed(resolved, canonicalBoundary.canonicalRoot, filePath, canonicalBoundary.rootDir);
+                }
+                await plugins.fs.promises.writeFile(resolved, content, 'utf8');
+                throwIfAborted(abortSignal);
+                return `Written ${Buffer.byteLength(content, 'utf8')} bytes to ${filePath}`;
+            },
+            listDirectory: async (directoryPath, listOptions, invocationOptions) => {
+                const abortSignal = invocationOptions?.abortSignal ?? options.abortSignal;
+                throwIfAborted(abortSignal);
+                const resolved = resolveLocalReadPath(directoryPath, rootDir, cwd);
+                const readRoots = plugins.path.isAbsolute(directoryPath)
+                    ? [...(rootDir ? [rootDir] : []), ...additionalReadOnlyRoots]
+                    : rootDir
+                        ? [rootDir]
+                        : [];
+                const operationPath = readRoots.length > 0
+                    ? await resolveCanonicalExistingLocalReadPath(resolved, directoryPath, readRoots)
+                    : resolved;
+                await runBeforeLocalOperation(options.beforeOperation, abortSignal);
+                const result = await listLocalDirectory(operationPath, !!listOptions?.recursive, abortSignal);
+                throwIfAborted(abortSignal);
+                return result;
+            },
+            deletePath: async (targetPath, invocationOptions) => {
+                const abortSignal = invocationOptions?.abortSignal ?? options.abortSignal;
+                throwIfAborted(abortSignal);
+                const resolved = resolveLocalPath(targetPath, rootDir, cwd);
+                if (rootDir) {
+                    await resolveCanonicalExistingLocalPath(resolved, targetPath, rootDir);
+                }
+                await runBeforeLocalOperation(options.beforeOperation, abortSignal);
+                await plugins.fs.promises.rm(resolved, { recursive: false, force: false });
+                throwIfAborted(abortSignal);
+                return `Deleted ${targetPath}`;
+            },
+        },
+    };
+};
+const resolveLocalPath = (targetPath, rootDir, baseDir) => {
+    const base = rootDir ?? baseDir ?? process.cwd();
+    const resolved = plugins.path.isAbsolute(targetPath)
+        ? plugins.path.resolve(targetPath)
+        : plugins.path.resolve(base, targetPath);
+    if (rootDir) {
+        const resolvedRoot = plugins.path.resolve(rootDir);
+        if (resolved !== resolvedRoot && !resolved.startsWith(resolvedRoot + plugins.path.sep)) {
+            throw new Error(`Access denied: "${targetPath}" is outside allowed root "${rootDir}"`);
+        }
+    }
+    return resolved;
+};
+const resolveLocalReadPath = (targetPath, rootDir, baseDir) => plugins.path.isAbsolute(targetPath)
+    ? plugins.path.resolve(targetPath)
+    : plugins.path.resolve(rootDir ?? baseDir ?? process.cwd(), targetPath);
+const resolveCanonicalExistingLocalReadPath = async (resolvedPath, targetPath, readRoots) => {
+    const canonicalPath = await plugins.fs.promises.realpath(resolvedPath);
+    for (const readRoot of readRoots) {
+        const canonicalRoot = await resolveCanonicalProspectivePath(plugins.path.resolve(readRoot));
+        if (canonicalPathIsAllowed(canonicalPath, canonicalRoot))
+            return canonicalPath;
+    }
+    throw new Error(`Access denied: "${targetPath}" resolves outside allowed read roots.`);
+};
+const resolveCanonicalExistingLocalPath = async (resolvedPath, targetPath, rootDir) => {
+    const canonicalRoot = await resolveCanonicalProspectivePath(plugins.path.resolve(rootDir));
+    const canonicalPath = await plugins.fs.promises.realpath(resolvedPath);
+    assertCanonicalPathAllowed(canonicalPath, canonicalRoot, targetPath, rootDir);
+    return canonicalPath;
+};
+const resolveCanonicalProspectivePath = async (targetPath) => {
+    let existingAncestor = targetPath;
+    while (true) {
+        try {
+            const canonicalAncestor = await plugins.fs.promises.realpath(existingAncestor);
+            return plugins.path.resolve(canonicalAncestor, plugins.path.relative(existingAncestor, targetPath));
+        }
+        catch (error) {
+            const errorCode = error.code;
+            if (errorCode !== 'ENOENT' && errorCode !== 'ENOTDIR') {
+                throw error;
+            }
+            const parentPath = plugins.path.dirname(existingAncestor);
+            if (parentPath === existingAncestor) {
+                throw error;
+            }
+            existingAncestor = parentPath;
+        }
+    }
+};
+const assertExistingWriteTargetAllowed = async (resolvedPath, canonicalRoot, targetPath, rootDir) => {
+    try {
+        await plugins.fs.promises.lstat(resolvedPath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return;
+        }
+        throw error;
+    }
+    let canonicalTarget;
+    try {
+        canonicalTarget = await plugins.fs.promises.realpath(resolvedPath);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw createAccessDeniedError(targetPath, rootDir);
+        }
+        throw error;
+    }
+    assertCanonicalPathAllowed(canonicalTarget, canonicalRoot, targetPath, rootDir);
+};
+const assertCanonicalPathAllowed = (canonicalPath, canonicalRoot, targetPath, rootDir) => {
+    if (!canonicalPathIsAllowed(canonicalPath, canonicalRoot)) {
+        throw createAccessDeniedError(targetPath, rootDir);
+    }
+};
+const canonicalPathIsAllowed = (canonicalPath, canonicalRoot) => {
+    const relativePath = plugins.path.relative(canonicalRoot, canonicalPath);
+    return relativePath !== '..'
+        && !relativePath.startsWith(`..${plugins.path.sep}`)
+        && !plugins.path.isAbsolute(relativePath);
+};
+const createAccessDeniedError = (targetPath, rootDir) => new Error(`Access denied: "${targetPath}" resolves outside canonical root "${rootDir}"`);
+const throwIfAborted = (abortSignal) => {
+    abortSignal?.throwIfAborted();
+};
+const runBeforeLocalOperation = async (beforeOperation, abortSignal) => {
+    throwIfAborted(abortSignal);
+    if (!beforeOperation)
+        return;
+    const guardPromise = Promise.resolve().then(() => beforeOperation());
+    void guardPromise.catch(() => undefined);
+    if (!abortSignal) {
+        await guardPromise;
+        return;
+    }
+    let onAbort;
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(abortSignal.reason ?? new DOMException('Local operation aborted', 'AbortError'));
+        abortSignal.addEventListener('abort', onAbort, { once: true });
+        if (abortSignal.aborted)
+            onAbort();
+    });
+    try {
+        await Promise.race([guardPromise, aborted]);
+    }
+    finally {
+        abortSignal.removeEventListener('abort', onAbort);
+    }
+    throwIfAborted(abortSignal);
+};
+const listLocalDirectory = async (directoryPath, recursive, abortSignal) => {
+    throwIfAborted(abortSignal);
+    const entries = await plugins.fs.promises.readdir(directoryPath, { withFileTypes: true });
+    throwIfAborted(abortSignal);
+    const result = [];
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        throwIfAborted(abortSignal);
+        const relativePath = entry.name + (entry.isDirectory() ? '/' : '');
+        result.push(relativePath);
+        if (recursive && entry.isDirectory()) {
+            const childEntries = await listLocalDirectory(plugins.path.join(directoryPath, entry.name), true, abortSignal);
+            result.push(...childEntries.map((childEntry) => `${entry.name}/${childEntry}`));
+        }
+    }
+    throwIfAborted(abortSignal);
+    return result;
+};
+/** @internal */
+export const handleLocalShellChildError = (error, childPid, handlers) => {
+    if (childPid === undefined) {
+        handlers.settleSpawnFailure(error);
+        return;
+    }
+    handlers.retainError(error);
+    handlers.requestTermination();
+};
+const runLocalShellCommand = async (command, options) => runLocalProcessCommand(command, options);
+const runLocalStructuredCommand = async (command, options) => {
+    validateLocalStructuredCommand(command);
+    return runLocalProcessCommand(command, options);
+};
+const validateLocalStructuredCommand = (command) => {
+    if (!command.executable.trim())
+        throw new Error('Structured shell executable must not be empty.');
+    if (!command.args.every((argument) => typeof argument === 'string')) {
+        throw new Error('Structured shell arguments must all be strings.');
+    }
+};
+const runLocalProcessCommand = async (command, options) => {
+    if (options.beforeOperation) {
+        await runBeforeLocalOperation(options.beforeOperation, options.abortSignal);
+    }
+    else {
+        throwIfAborted(options.abortSignal);
+    }
+    return new Promise((resolve) => {
+        const ownsProcessGroup = process.platform !== 'win32';
+        const executable = typeof command === 'string' ? 'bash' : command.executable;
+        const args = typeof command === 'string' ? ['-lc', command] : command.args;
+        const child = plugins.childProcess.spawn(executable, args, {
+            cwd: options.cwd,
+            detached: ownsProcessGroup,
+            shell: false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        let capturedBytes = 0;
+        let settled = false;
+        let terminationReason;
+        let childError;
+        let signalError;
+        let outputListenerError;
+        let outputQueue = Promise.resolve();
+        const outputAbortController = new AbortController();
+        const outputDecoders = {
+            stdout: new plugins.StringDecoder('utf8'),
+            stderr: new plugins.StringDecoder('utf8'),
+        };
+        let killTimer;
+        const timeoutTimer = options.timeoutMs && options.timeoutMs > 0
+            ? setTimeout(() => requestTermination('timeout'), options.timeoutMs)
+            : undefined;
+        const signalProcess = (signal) => {
+            if (child.pid === undefined)
+                return;
+            if (ownsProcessGroup) {
+                try {
+                    process.kill(-child.pid, signal);
+                    return;
+                }
+                catch (error) {
+                    if (error.code === 'ESRCH')
+                        return;
+                    signalError = error;
+                }
+            }
+            try {
+                child.kill(signal);
+            }
+            catch (error) {
+                if (error.code !== 'ESRCH') {
+                    signalError = error;
+                }
+            }
+        };
+        function requestTermination(reason) {
+            if (terminationReason)
+                return;
+            terminationReason = reason;
+            outputAbortController.abort(new Error(`Command output delivery stopped because the command is terminating (${reason}).`));
+            signalProcess('SIGTERM');
+            killTimer = setTimeout(() => signalProcess('SIGKILL'), LOCAL_SHELL_KILL_GRACE_MS);
+        }
+        const onAbort = () => requestTermination('abort');
+        const deliverOutput = async (stream, text) => {
+            const listenerPromise = Promise.resolve(options.onOutput(stream, text));
+            void listenerPromise.catch(() => undefined);
+            let timeoutTimer;
+            let onOutputAbort;
+            const aborted = new Promise((_resolve, reject) => {
+                onOutputAbort = () => reject(outputAbortController.signal.reason);
+                outputAbortController.signal.addEventListener('abort', onOutputAbort, { once: true });
+                if (outputAbortController.signal.aborted)
+                    onOutputAbort();
+            });
+            const timeout = options.outputListenerTimeoutMs === undefined
+                ? undefined
+                : new Promise((_resolve, reject) => {
+                    timeoutTimer = setTimeout(() => reject(new Error(`Command output listener timed out after ${options.outputListenerTimeoutMs}ms.`)), options.outputListenerTimeoutMs);
+                });
+            try {
+                await Promise.race([listenerPromise, aborted, ...(timeout ? [timeout] : [])]);
+            }
+            finally {
+                if (timeoutTimer)
+                    clearTimeout(timeoutTimer);
+                outputAbortController.signal.removeEventListener('abort', onOutputAbort);
+            }
+        };
+        const enqueueOutput = (stream, source, text) => {
+            if (!text || !options.onOutput)
+                return;
+            source?.pause();
+            outputQueue = outputQueue
+                .then(() => outputListenerError ? undefined : deliverOutput(stream, text))
+                .catch((error) => {
+                outputListenerError = error instanceof Error ? error : new Error(String(error));
+                requestTermination('output-listener');
+            })
+                .finally(() => source?.resume());
+        };
+        const captureChunk = (stream, chunks, source, chunk) => {
+            const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            const remainingBytes = Math.max(options.maxOutputBytes - capturedBytes, 0);
+            if (remainingBytes > 0) {
+                const capturedChunk = chunkBuffer.subarray(0, remainingBytes);
+                chunks.push(capturedChunk);
+                capturedBytes += capturedChunk.byteLength;
+                enqueueOutput(stream, source, outputDecoders[stream].write(capturedChunk));
+            }
+            if (chunkBuffer.byteLength > remainingBytes) {
+                requestTermination('output-limit');
+            }
+        };
+        const onStdout = (chunk) => captureChunk('stdout', stdoutChunks, child.stdout, chunk);
+        const onStderr = (chunk) => captureChunk('stderr', stderrChunks, child.stderr, chunk);
+        const cleanup = () => {
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            options.abortSignal?.removeEventListener('abort', onAbort);
+            child.stdout?.removeListener('data', onStdout);
+            child.stderr?.removeListener('data', onStderr);
+            child.removeListener('error', onChildError);
+            child.removeListener('exit', onChildExit);
+            child.removeListener('close', onChildClose);
+        };
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(result);
+        };
+        const buildOutput = () => ({
+            stdout: Buffer.concat(stdoutChunks).toString('utf8'),
+            stderr: Buffer.concat(stderrChunks).toString('utf8'),
+        });
+        function onChildError(error) {
+            handleLocalShellChildError(error, child.pid, {
+                settleSpawnFailure: (spawnError) => {
+                    const output = buildOutput();
+                    settle({
+                        exitCode: 1,
+                        stdout: output.stdout,
+                        stderr: `${output.stderr}${spawnError.message}`,
+                    });
+                },
+                retainError: (processError) => {
+                    childError = processError;
+                },
+                requestTermination: () => requestTermination('error'),
+            });
+        }
+        function onChildExit() {
+            if (ownsProcessGroup)
+                signalProcess('SIGKILL');
+        }
+        async function finishChildClose(code, signal) {
+            enqueueOutput('stdout', child.stdout, outputDecoders.stdout.end());
+            enqueueOutput('stderr', child.stderr, outputDecoders.stderr.end());
+            // Process outcome is fixed at close. Later aborts/timeouts must not reclassify it while
+            // already-received output finishes its bounded listener delivery.
+            if (timeoutTimer)
+                clearTimeout(timeoutTimer);
+            if (killTimer)
+                clearTimeout(killTimer);
+            options.abortSignal?.removeEventListener('abort', onAbort);
+            await outputQueue;
+            if (terminationReason) {
+                signalProcess('SIGKILL');
+            }
+            const output = buildOutput();
+            const statusMessage = terminationReason === 'timeout'
+                ? `Command timed out after ${options.timeoutMs}ms.`
+                : terminationReason === 'output-limit'
+                    ? `Command output exceeded the local limit of ${options.maxOutputBytes} bytes and was terminated.`
+                    : terminationReason === 'output-listener'
+                        ? `Command output listener failed and the command was terminated: ${outputListenerError?.message ?? 'unknown listener error'}`
+                        : terminationReason === 'abort'
+                            ? 'Command was aborted.'
+                            : '';
+            const signalErrorMessage = signalError ? `Failed to signal command process: ${signalError.message}` : '';
+            const childErrorMessage = childError ? `Command process error: ${childError.message}` : '';
+            settle({
+                exitCode: terminationReason === 'timeout'
+                    ? 124
+                    : terminationReason === 'abort'
+                        ? 130
+                        : terminationReason === 'output-limit'
+                            ? 1
+                            : terminationReason === 'output-listener'
+                                ? 1
+                                : terminationReason === 'error'
+                                    ? 1
+                                    : code ?? 1,
+                stdout: output.stdout,
+                stderr: [output.stderr, statusMessage, childErrorMessage, signalErrorMessage].filter(Boolean).join('\n').trim(),
+                signal: signal ?? undefined,
+            });
+        }
+        function onChildClose(code, signal) {
+            void finishChildClose(code, signal);
+        }
+        options.abortSignal?.addEventListener('abort', onAbort, { once: true });
+        if (options.abortSignal?.aborted)
+            onAbort();
+        child.stdout?.on('data', onStdout);
+        child.stderr?.on('data', onStderr);
+        child.once('error', onChildError);
+        child.once('exit', onChildExit);
+        child.once('close', onChildClose);
+    });
+};
+const assertOrphanSettlement = (persistedJob, settledJob) => {
+    if (!settledJob
+        || settledJob.executionId !== persistedJob.executionId
+        || settledJob.type !== persistedJob.type
+        || !['finished', 'failed', 'aborted'].includes(settledJob.state)) {
+        throw new Error(`Orphan settlement for background execution "${persistedJob.executionId}" must return a terminal state with the same executionId and type.`);
+    }
+};
+const createLocalToolJobContext = (options) => {
+    const states = new Map();
+    const controllers = new Map();
+    const completions = new Map();
+    const terminalExecutionIds = [];
+    const listeners = new Set();
+    let persistenceRevision = 0;
+    let persistenceError;
+    let persistenceQueue = Promise.resolve();
+    const reportListenerError = (error) => {
+        process.emitWarning(error instanceof Error ? error : String(error), {
+            code: 'SMARTAGENT_JOB_LISTENER_ERROR',
+        });
+    };
+    const runJobStoreOperation = async (operation) => {
+        const controller = new AbortController();
+        const timeoutError = new Error(`Job store operation timed out after ${options.jobStoreOperationTimeoutMs}ms.`);
+        let timer;
+        const operationPromise = Promise.resolve().then(() => operation(controller.signal));
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            timer = setTimeout(() => {
+                controller.abort(timeoutError);
+                reject(timeoutError);
+            }, options.jobStoreOperationTimeoutMs);
+        });
+        try {
+            return await Promise.race([operationPromise, timeoutPromise]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    };
+    const persist = () => {
+        if (!options.jobStore)
+            return Promise.resolve();
+        const snapshot = structuredClone([...states.values()]);
+        const operation = persistenceQueue.then(async () => {
+            if (persistenceError !== undefined)
+                throw persistenceError;
+            persistenceRevision = await runJobStoreOperation((abortSignal) => options.jobStore.save(snapshot, persistenceRevision, abortSignal));
+        });
+        persistenceQueue = operation.catch((error) => {
+            persistenceError ??= error;
+        });
+        return operation;
+    };
+    const flushPersistence = async () => {
+        if (persistenceError !== undefined)
+            throw persistenceError;
+        await persistenceQueue;
+        if (persistenceError !== undefined)
+            throw persistenceError;
+    };
+    const emitLifecycle = (event) => {
+        for (const listener of [...listeners]) {
+            try {
+                const result = listener(event);
+                if (result && typeof result.then === 'function') {
+                    void result.catch(reportListenerError);
+                }
+            }
+            catch (error) {
+                reportListenerError(error);
+            }
+        }
+    };
+    const emitOutput = async (event) => {
+        for (const listener of [...listeners]) {
+            let timer;
+            try {
+                await Promise.race([
+                    Promise.resolve().then(() => listener(event)),
+                    new Promise((_resolve, reject) => {
+                        timer = setTimeout(() => reject(new Error(`Job output listener timed out after ${options.outputListenerTimeoutMs}ms.`)), options.outputListenerTimeoutMs);
+                    }),
+                ]);
+            }
+            finally {
+                if (timer)
+                    clearTimeout(timer);
+            }
+        }
+    };
+    const ready = (async () => {
+        const snapshot = options.jobStore
+            ? await runJobStoreOperation((abortSignal) => options.jobStore.load(abortSignal))
+            : undefined;
+        if (!snapshot)
+            return;
+        persistenceRevision = snapshot.revision;
+        let changed = false;
+        for (const restoredState of snapshot.jobs) {
+            let state = structuredClone(restoredState);
+            if (state.state === 'running') {
+                if (options.settleOrphanedJob) {
+                    const settledState = await runJobStoreOperation(async (abortSignal) => options.settleOrphanedJob(structuredClone(state), abortSignal));
+                    assertOrphanSettlement(state, settledState);
+                    state = structuredClone(settledState);
+                }
+                else {
+                    const now = Date.now();
+                    state.state = 'failed';
+                    state.exitCode = null;
+                    state.stderr = [state.stderr, 'Background execution was interrupted by a host restart.']
+                        .filter(Boolean)
+                        .join('\n');
+                    state.updatedAt = now;
+                    state.finishedAt = now;
+                }
+                changed = true;
+            }
+            states.set(state.executionId, state);
+            terminalExecutionIds.push(state.executionId);
+        }
+        while (terminalExecutionIds.length > options.maxRetainedJobs) {
+            const expiredExecutionId = terminalExecutionIds.shift();
+            if (expiredExecutionId) {
+                states.delete(expiredExecutionId);
+                changed = true;
+            }
+        }
+        if (changed)
+            await persist();
+    })();
+    return {
+        start: async (request, invocationOptions) => {
+            await ready;
+            await flushPersistence();
+            const operationAbortSignal = invocationOptions?.abortSignal ?? options.abortSignal;
+            const clonedRequest = structuredClone(request);
+            if (clonedRequest.type !== 'shell' || !clonedRequest.command) {
+                throw new Error('The local job context only supports structured shell jobs.');
+            }
+            validateLocalStructuredCommand(clonedRequest.command);
+            const commandCwd = resolveLocalPath(clonedRequest.cwd ?? options.cwd, options.rootDir);
+            await runBeforeLocalOperation(options.beforeOperation, operationAbortSignal);
+            const executionId = `shell_${plugins.crypto.randomUUID()}`;
+            const startedAt = Date.now();
+            const runningState = {
+                executionId,
+                type: 'shell',
+                state: 'running',
+                request: clonedRequest,
+                stdout: '',
+                stderr: '',
+                startedAt,
+                updatedAt: startedAt,
+            };
+            const startedEvent = structuredClone({
+                type: 'started',
+                job: runningState,
+            });
+            const controller = new AbortController();
+            states.set(executionId, runningState);
+            controllers.set(executionId, controller);
+            try {
+                await persist();
+            }
+            catch (error) {
+                states.delete(executionId);
+                controllers.delete(executionId);
+                throw error;
+            }
+            try {
+                throwIfAborted(operationAbortSignal);
+            }
+            catch (error) {
+                states.delete(executionId);
+                controllers.delete(executionId);
+                try {
+                    await persist();
+                }
+                catch (rollbackError) {
+                    process.emitWarning(rollbackError instanceof Error ? rollbackError : String(rollbackError), { code: 'SMARTAGENT_JOB_ADMISSION_ROLLBACK_ERROR' });
+                }
+                throw error;
+            }
+            let outputSequence = 0;
+            let outputPersistenceFailed = false;
+            let resolveProcessResult;
+            let rejectProcessResult;
+            const processResult = new Promise((resolve, reject) => {
+                resolveProcessResult = resolve;
+                rejectProcessResult = reject;
+            });
+            const completion = (async () => {
+                let terminalState;
+                try {
+                    const result = await processResult;
+                    const finishedAt = Date.now();
+                    terminalState = {
+                        executionId,
+                        type: 'shell',
+                        state: controller.signal.aborted
+                            ? 'aborted'
+                            : result.exitCode === 0
+                                ? 'finished'
+                                : 'failed',
+                        request: clonedRequest,
+                        exitCode: result.exitCode,
+                        stdout: result.stdout,
+                        stderr: result.stderr ?? '',
+                        signal: result.signal,
+                        startedAt,
+                        updatedAt: finishedAt,
+                        finishedAt,
+                    };
+                }
+                catch (error) {
+                    const finishedAt = Date.now();
+                    terminalState = {
+                        executionId,
+                        type: 'shell',
+                        state: controller.signal.aborted ? 'aborted' : 'failed',
+                        request: clonedRequest,
+                        exitCode: null,
+                        stdout: states.get(executionId)?.stdout ?? '',
+                        stderr: [
+                            states.get(executionId)?.stderr,
+                            error instanceof Error ? error.message : String(error),
+                        ].filter(Boolean).join('\n'),
+                        startedAt,
+                        updatedAt: finishedAt,
+                        finishedAt,
+                    };
+                }
+                states.set(executionId, terminalState);
+                controllers.delete(executionId);
+                completions.delete(executionId);
+                terminalExecutionIds.push(executionId);
+                while (terminalExecutionIds.length > options.maxRetainedJobs) {
+                    const expiredExecutionId = terminalExecutionIds.shift();
+                    if (expiredExecutionId)
+                        states.delete(expiredExecutionId);
+                }
+                if (!outputPersistenceFailed)
+                    await persist();
+                emitLifecycle({ type: 'finished', job: structuredClone(terminalState) });
+                return terminalState;
+            })();
+            completions.set(executionId, completion);
+            const handle = { executionId, state: 'running', completion };
+            const processCompletion = runLocalProcessCommand(clonedRequest.command, {
+                cwd: commandCwd,
+                timeoutMs: clonedRequest.timeoutMs,
+                abortSignal: controller.signal,
+                maxOutputBytes: options.maxOutputBytes,
+                onOutput: async (stream, chunk) => {
+                    const state = states.get(executionId);
+                    if (!state || state.state !== 'running')
+                        return;
+                    if (stream === 'stdout')
+                        state.stdout = `${state.stdout ?? ''}${chunk}`;
+                    else
+                        state.stderr = `${state.stderr ?? ''}${chunk}`;
+                    state.updatedAt = Date.now();
+                    try {
+                        await persist();
+                    }
+                    catch (error) {
+                        outputPersistenceFailed = true;
+                        persistenceError ??= error;
+                        throw error;
+                    }
+                    await emitOutput({
+                        type: 'output',
+                        job: structuredClone(state),
+                        stream,
+                        chunk,
+                        sequence: ++outputSequence,
+                    });
+                },
+            });
+            void processCompletion.then(resolveProcessResult, rejectProcessResult);
+            emitLifecycle(startedEvent);
+            return handle;
+        },
+        get: async (executionId) => {
+            await ready;
+            await flushPersistence();
+            const state = states.get(executionId);
+            if (!state)
+                throw new Error(`Unknown background execution "${executionId}".`);
+            return structuredClone(state);
+        },
+        list: async () => {
+            await ready;
+            await flushPersistence();
+            return structuredClone([...states.values()]);
+        },
+        abort: async (executionId) => {
+            await ready;
+            const state = states.get(executionId);
+            if (!state)
+                throw new Error(`Unknown background execution "${executionId}".`);
+            if (state.state !== 'running')
+                return;
+            controllers.get(executionId)?.abort(new DOMException('Background execution aborted', 'AbortError'));
+            await completions.get(executionId);
+        },
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+    };
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tool.context.js","sourceRoot":"","sources":["../ts_tools_node/tool.context.ts"],"names":[],"mappings":"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"}