@git.zone/tsrust 1.9.0 → 1.10.0

package/dist_ts/mod_matrix/classes.matrixcommandrunner.js

@@ -0,0 +1,266 @@
+import * as childProcess from 'node:child_process';
+import * as fs from 'node:fs';
+const defaultCommandTimeoutMs = 60 * 60 * 1000;
+const forceKillDelayMs = 10 * 1000;
+const maximumCapturedOutputBytes = 16 * 1024 * 1024;
+export class MatrixCommandRunner {
+    environment;
+    constructor(environment = process.env) {
+        this.environment = environment;
+    }
+    async execute(commandArg, argsArg, optionsArg = {}) {
+        if ([optionsArg.heartbeatStdin === true, optionsArg.input !== undefined, !!optionsArg.inputFile]
+            .filter(Boolean)
+            .length > 1) {
+            throw new Error('A matrix command can use only one stdin source');
+        }
+        if (optionsArg.capture && optionsArg.outputFile) {
+            throw new Error('A matrix command cannot capture stdout and write it to a file');
+        }
+        if (optionsArg.outputFile &&
+            (!Number.isSafeInteger(optionsArg.maximumOutputBytes) ||
+                (optionsArg.maximumOutputBytes || 0) <= 0)) {
+            throw new Error('A matrix output file requires a positive byte limit');
+        }
+        const capture = optionsArg.capture === true;
+        let inputFileDescriptor;
+        let outputFileDescriptor;
+        let child;
+        try {
+            if (optionsArg.inputFile) {
+                inputFileDescriptor = fs.openSync(optionsArg.inputFile, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+            }
+            if (optionsArg.outputFile) {
+                outputFileDescriptor = fs.openSync(optionsArg.outputFile, fs.constants.O_WRONLY |
+                    fs.constants.O_CREAT |
+                    fs.constants.O_EXCL |
+                    fs.constants.O_NOFOLLOW, 0o600);
+            }
+            const stdinMode = inputFileDescriptor ??
+                (optionsArg.heartbeatStdin || optionsArg.input !== undefined ? 'pipe' : 'ignore');
+            const stdoutMode = optionsArg.outputFile ? 'pipe' : capture ? 'pipe' : 'inherit';
+            child = childProcess.spawn(commandArg, argsArg, {
+                cwd: optionsArg.cwd || process.cwd(),
+                env: optionsArg.environment || this.environment,
+                stdio: [stdinMode, stdoutMode, capture ? 'pipe' : 'inherit'],
+                detached: true,
+            });
+        }
+        catch (error) {
+            if (inputFileDescriptor !== undefined)
+                fs.closeSync(inputFileDescriptor);
+            if (outputFileDescriptor !== undefined)
+                fs.closeSync(outputFileDescriptor);
+            throw error;
+        }
+        if (inputFileDescriptor !== undefined)
+            fs.closeSync(inputFileDescriptor);
+        let stdout = '';
+        let stderr = '';
+        let capturedOutputBytes = 0;
+        let timedOut = false;
+        let outputLimitExceeded = false;
+        let outputFileBytes = 0;
+        let outputFileError;
+        let forwardedSignal;
+        let forwardedSignalCount = 0;
+        let spawnError;
+        let stdinError;
+        let forceKillTimer;
+        let heartbeatTimer;
+        const killProcessGroup = (signalArg) => {
+            if (!child.pid)
+                return;
+            try {
+                process.kill(-child.pid, signalArg);
+            }
+            catch {
+                try {
+                    child.kill(signalArg);
+                }
+                catch {
+                    // The process may already have exited.
+                }
+            }
+        };
+        const terminateProcessGroup = (signalArg) => {
+            killProcessGroup(signalArg);
+            if (!forceKillTimer) {
+                forceKillTimer = setTimeout(() => killProcessGroup('SIGKILL'), forceKillDelayMs);
+            }
+        };
+        const processGroupExists = () => {
+            if (!child.pid)
+                return false;
+            try {
+                process.kill(-child.pid, 0);
+                return true;
+            }
+            catch (error) {
+                if (error.code === 'ESRCH')
+                    return false;
+                throw error;
+            }
+        };
+        const waitForProcessGroupExit = async (timeoutMsArg) => {
+            const deadline = Date.now() + timeoutMsArg;
+            while (processGroupExists() && Date.now() < deadline) {
+                await new Promise((resolve) => setTimeout(resolve, 100));
+            }
+            return !processGroupExists();
+        };
+        const ensureProcessGroupStopped = async () => {
+            if (!processGroupExists())
+                return;
+            terminateProcessGroup('SIGTERM');
+            if (!(await waitForProcessGroupExit(forceKillDelayMs + 1000))) {
+                killProcessGroup('SIGKILL');
+                if (!(await waitForProcessGroupExit(2000))) {
+                    throw new Error(`${commandArg} left a live descendant process group`);
+                }
+            }
+        };
+        const signalHandlers = new Map();
+        for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) {
+            const handler = () => {
+                forwardedSignal = signal;
+                forwardedSignalCount += 1;
+                if (forwardedSignalCount === 1)
+                    terminateProcessGroup(signal);
+                else
+                    killProcessGroup('SIGKILL');
+            };
+            signalHandlers.set(signal, handler);
+            process.on(signal, handler);
+        }
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            terminateProcessGroup('SIGTERM');
+        }, optionsArg.timeoutMs || defaultCommandTimeoutMs);
+        if (optionsArg.heartbeatStdin) {
+            child.stdin?.on('error', () => {
+                // Process close handles a lost heartbeat channel.
+            });
+            const sendHeartbeat = () => {
+                if (!child.stdin?.destroyed)
+                    child.stdin?.write('heartbeat\n');
+            };
+            sendHeartbeat();
+            heartbeatTimer = setInterval(sendHeartbeat, 1000);
+        }
+        else if (optionsArg.input !== undefined) {
+            child.stdin?.on('error', (errorArg) => {
+                stdinError = errorArg;
+                terminateProcessGroup('SIGTERM');
+            });
+            child.stdin?.end(optionsArg.input);
+        }
+        const captureChunk = (targetArg, chunkArg) => {
+            capturedOutputBytes += chunkArg.length;
+            if (capturedOutputBytes > maximumCapturedOutputBytes) {
+                outputLimitExceeded = true;
+                terminateProcessGroup('SIGTERM');
+                return;
+            }
+            if (targetArg === 'stdout')
+                stdout += chunkArg.toString('utf8');
+            else
+                stderr += chunkArg.toString('utf8');
+        };
+        if (optionsArg.outputFile) {
+            child.stdout?.on('data', (chunkArg) => {
+                if (outputLimitExceeded || outputFileError || outputFileDescriptor === undefined)
+                    return;
+                if (outputFileBytes + chunkArg.length > (optionsArg.maximumOutputBytes || 0)) {
+                    outputLimitExceeded = true;
+                    terminateProcessGroup('SIGTERM');
+                    return;
+                }
+                try {
+                    let offset = 0;
+                    while (offset < chunkArg.length) {
+                        offset += fs.writeSync(outputFileDescriptor, chunkArg, offset, chunkArg.length - offset);
+                    }
+                    outputFileBytes += chunkArg.length;
+                }
+                catch (error) {
+                    outputFileError = error;
+                    terminateProcessGroup('SIGTERM');
+                }
+            });
+        }
+        else {
+            child.stdout?.on('data', (chunkArg) => captureChunk('stdout', chunkArg));
+        }
+        child.stderr?.on('data', (chunkArg) => captureChunk('stderr', chunkArg));
+        child.once('error', (errorArg) => {
+            spawnError = errorArg;
+        });
+        return new Promise((resolve, reject) => {
+            child.once('close', (codeArg, signalArg) => {
+                void (async () => {
+                    try {
+                        if (outputFileDescriptor !== undefined) {
+                            try {
+                                fs.fsyncSync(outputFileDescriptor);
+                                fs.closeSync(outputFileDescriptor);
+                                outputFileDescriptor = undefined;
+                            }
+                            catch (error) {
+                                outputFileError = error;
+                            }
+                        }
+                        await ensureProcessGroupStopped();
+                        const exitCode = codeArg ?? -1;
+                        if (timedOut) {
+                            throw new Error(`${commandArg} exceeded its command timeout`);
+                        }
+                        if (outputLimitExceeded) {
+                            throw new Error(`${commandArg} exceeded the captured output limit`);
+                        }
+                        if (forwardedSignal) {
+                            throw new Error(`${commandArg} was interrupted by ${forwardedSignal}`);
+                        }
+                        if (spawnError)
+                            throw spawnError;
+                        if (stdinError)
+                            throw stdinError;
+                        if (outputFileError)
+                            throw outputFileError;
+                        if (!(optionsArg.allowedExitCodes || [0]).includes(exitCode)) {
+                            if (capture && stdout)
+                                process.stdout.write(stdout);
+                            if (capture && stderr)
+                                process.stderr.write(stderr);
+                            throw new Error(`${commandArg} exited with ${signalArg ? `signal ${signalArg}` : `status ${exitCode}`}`);
+                        }
+                        resolve({ stdout, stderr, exitCode });
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                    finally {
+                        clearTimeout(timeout);
+                        if (forceKillTimer)
+                            clearTimeout(forceKillTimer);
+                        if (heartbeatTimer)
+                            clearInterval(heartbeatTimer);
+                        child.stdin?.end();
+                        if (outputFileDescriptor !== undefined) {
+                            try {
+                                fs.closeSync(outputFileDescriptor);
+                            }
+                            catch {
+                                // Preserve the command's primary error.
+                            }
+                        }
+                        for (const [signal, handler] of signalHandlers) {
+                            process.off(signal, handler);
+                        }
+                    }
+                })();
+            });
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.matrixcommandrunner.js","sourceRoot":"","sources":["../../ts/mod_matrix/classes.matrixcommandrunner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,SAAS,CAAC;AA6B9B,MAAM,uBAAuB,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAC/C,MAAM,gBAAgB,GAAG,EAAE,GAAG,IAAI,CAAC;AACnC,MAAM,0BAA0B,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAGpD,MAAM,OAAO,mBAAmB;IACV;IAApB,YAAoB,cAAiC,OAAO,CAAC,GAAG;QAA5C,gBAAW,GAAX,WAAW,CAAiC;IAAG,CAAC;IAE7D,KAAK,CAAC,OAAO,CAClB,UAAkB,EAClB,OAAiB,EACjB,aAAoC,EAAE;QAEtC,IACE,CAAC,UAAU,CAAC,cAAc,KAAK,IAAI,EAAE,UAAU,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC,CAAC,UAAU,CAAC,SAAS,CAAC;aACzF,MAAM,CAAC,OAAO,CAAC;aACf,MAAM,GAAG,CAAC,EACb,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACpE,CAAC;QACD,IAAI,UAAU,CAAC,OAAO,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;YAChD,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;QACnF,CAAC;QACD,IACE,UAAU,CAAC,UAAU;YACrB,CAAC,CAAC,MAAM,CAAC,aAAa,CAAC,UAAU,CAAC,kBAAkB,CAAC;gBACnD,CAAC,UAAU,CAAC,kBAAkB,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,EAC5C,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;QACzE,CAAC;QACD,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,KAAK,IAAI,CAAC;QAC5C,IAAI,mBAAuC,CAAC;QAC5C,IAAI,oBAAwC,CAAC;QAC7C,IAAI,KAAgC,CAAC;QACrC,IAAI,CAAC;YACH,IAAI,UAAU,CAAC,SAAS,EAAE,CAAC;gBACzB,mBAAmB,GAAG,EAAE,CAAC,QAAQ,CAC/B,UAAU,CAAC,SAAS,EACpB,EAAE,CAAC,SAAS,CAAC,QAAQ,GAAG,EAAE,CAAC,SAAS,CAAC,UAAU,CAChD,CAAC;YACJ,CAAC;YACD,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;gBAC1B,oBAAoB,GAAG,EAAE,CAAC,QAAQ,CAChC,UAAU,CAAC,UAAU,EACrB,EAAE,CAAC,SAAS,CAAC,QAAQ;oBACnB,EAAE,CAAC,SAAS,CAAC,OAAO;oBACpB,EAAE,CAAC,SAAS,CAAC,MAAM;oBACnB,EAAE,CAAC,SAAS,CAAC,UAAU,EACzB,KAAK,CACN,CAAC;YACJ,CAAC;YACD,MAAM,SAAS,GACb,mBAAmB;gBACnB,CAAC,UAAU,CAAC,cAAc,IAAI,UAAU,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YACpF,MAAM,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;YACjF,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,UAAU,EAAE,OAAO,EAAE;gBAC9C,GAAG,EAAE,UAAU,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE;gBACpC,GAAG,EAAE,UAAU,CAAC,WAAW,IAAI,IAAI,CAAC,WAAW;gBAC/C,KAAK,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;gBAC5D,QAAQ,EAAE,IAAI;aACf,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,mBAAmB,KAAK,SAAS;gBAAE,EAAE,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;YACzE,IAAI,oBAAoB,KAAK,SAAS;gBAAE,EAAE,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;YAC3E,MAAM,KAAK,CAAC;QACd,CAAC;QACD,IAAI,mBAAmB,KAAK,SAAS;YAAE,EAAE,CAAC,SAAS,CAAC,mBAAmB,CAAC,CAAC;QAEzE,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,IAAI,MAAM,GAAG,EAAE,CAAC;QAChB,IAAI,mBAAmB,GAAG,CAAC,CAAC;QAC5B,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,IAAI,mBAAmB,GAAG,KAAK,CAAC;QAChC,IAAI,eAAe,GAAG,CAAC,CAAC;QACxB,IAAI,eAAkC,CAAC;QACvC,IAAI,eAA6C,CAAC;QAClD,IAAI,oBAAoB,GAAG,CAAC,CAAC;QAC7B,IAAI,UAA6B,CAAC;QAClC,IAAI,UAA6B,CAAC;QAClC,IAAI,cAA0C,CAAC;QAC/C,IAAI,cAA0C,CAAC;QAE/C,MAAM,gBAAgB,GAAG,CAAC,SAAyB,EAAQ,EAAE;YAC3D,IAAI,CAAC,KAAK,CAAC,GAAG;gBAAE,OAAO;YACvB,IAAI,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;YACtC,CAAC;YAAC,MAAM,CAAC;gBACP,IAAI,CAAC;oBACH,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBACxB,CAAC;gBAAC,MAAM,CAAC;oBACP,uCAAuC;gBACzC,CAAC;YACH,CAAC;QACH,CAAC,CAAC;QACF,MAAM,qBAAqB,GAAG,CAAC,SAAyB,EAAQ,EAAE;YAChE,gBAAgB,CAAC,SAAS,CAAC,CAAC;YAC5B,IAAI,CAAC,cAAc,EAAE,CAAC;gBACpB,cAAc,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,gBAAgB,CAAC,SAAS,CAAC,EAAE,gBAAgB,CAAC,CAAC;YACnF,CAAC;QACH,CAAC,CAAC;QACF,MAAM,kBAAkB,GAAG,GAAY,EAAE;YACvC,IAAI,CAAC,KAAK,CAAC,GAAG;gBAAE,OAAO,KAAK,CAAC;YAC7B,IAAI,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;gBAC5B,OAAO,IAAI,CAAC;YACd,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAK,KAA+B,CAAC,IAAI,KAAK,OAAO;oBAAE,OAAO,KAAK,CAAC;gBACpE,MAAM,KAAK,CAAC;YACd,CAAC;QACH,CAAC,CAAC;QACF,MAAM,uBAAuB,GAAG,KAAK,EAAE,YAAoB,EAAoB,EAAE;YAC/E,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,CAAC;YAC3C,OAAO,kBAAkB,EAAE,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;gBACrD,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;YAC3D,CAAC;YACD,OAAO,CAAC,kBAAkB,EAAE,CAAC;QAC/B,CAAC,CAAC;QACF,MAAM,yBAAyB,GAAG,KAAK,IAAmB,EAAE;YAC1D,IAAI,CAAC,kBAAkB,EAAE;gBAAE,OAAO;YAClC,qBAAqB,CAAC,SAAS,CAAC,CAAC;YACjC,IAAI,CAAC,CAAC,MAAM,uBAAuB,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC;gBAC9D,gBAAgB,CAAC,SAAS,CAAC,CAAC;gBAC5B,IAAI,CAAC,CAAC,MAAM,uBAAuB,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;oBAC3C,MAAM,IAAI,KAAK,CAAC,GAAG,UAAU,uCAAuC,CAAC,CAAC;gBACxE,CAAC;YACH,CAAC;QACH,CAAC,CAAC;QAEF,MAAM,cAAc,GAAG,IAAI,GAAG,EAAgC,CAAC;QAC/D,KAAK,MAAM,MAAM,IAAI,CAAC,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAuB,EAAE,CAAC;YAC3E,MAAM,OAAO,GAAG,GAAS,EAAE;gBACzB,eAAe,GAAG,MAAM,CAAC;gBACzB,oBAAoB,IAAI,CAAC,CAAC;gBAC1B,IAAI,oBAAoB,KAAK,CAAC;oBAAE,qBAAqB,CAAC,MAAM,CAAC,CAAC;;oBACzD,gBAAgB,CAAC,SAAS,CAAC,CAAC;YACnC,CAAC,CAAC;YACF,cAAc,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YACpC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC9B,CAAC;QAED,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE;YAC9B,QAAQ,GAAG,IAAI,CAAC;YAChB,qBAAqB,CAAC,SAAS,CAAC,CAAC;QACnC,CAAC,EAAE,UAAU,CAAC,SAAS,IAAI,uBAAuB,CAAC,CAAC;QAEpD,IAAI,UAAU,CAAC,cAAc,EAAE,CAAC;YAC9B,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE;gBAC5B,kDAAkD;YACpD,CAAC,CAAC,CAAC;YACH,MAAM,aAAa,GAAG,GAAS,EAAE;gBAC/B,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,SAAS;oBAAE,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;YACjE,CAAC,CAAC;YACF,aAAa,EAAE,CAAC;YAChB,cAAc,GAAG,WAAW,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC;QACpD,CAAC;aAAM,IAAI,UAAU,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;YAC1C,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,EAAE;gBACpC,UAAU,GAAG,QAAQ,CAAC;gBACtB,qBAAqB,CAAC,SAAS,CAAC,CAAC;YACnC,CAAC,CAAC,CAAC;YACH,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACrC,CAAC;QAED,MAAM,YAAY,GAAG,CAAC,SAA8B,EAAE,QAAgB,EAAQ,EAAE;YAC9E,mBAAmB,IAAI,QAAQ,CAAC,MAAM,CAAC;YACvC,IAAI,mBAAmB,GAAG,0BAA0B,EAAE,CAAC;gBACrD,mBAAmB,GAAG,IAAI,CAAC;gBAC3B,qBAAqB,CAAC,SAAS,CAAC,CAAC;gBACjC,OAAO;YACT,CAAC;YACD,IAAI,SAAS,KAAK,QAAQ;gBAAE,MAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;;gBAC3D,MAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAC3C,CAAC,CAAC;QACF,IAAI,UAAU,CAAC,UAAU,EAAE,CAAC;YAC1B,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,QAAgB,EAAE,EAAE;gBAC5C,IAAI,mBAAmB,IAAI,eAAe,IAAI,oBAAoB,KAAK,SAAS;oBAAE,OAAO;gBACzF,IAAI,eAAe,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,UAAU,CAAC,kBAAkB,IAAI,CAAC,CAAC,EAAE,CAAC;oBAC7E,mBAAmB,GAAG,IAAI,CAAC;oBAC3B,qBAAqB,CAAC,SAAS,CAAC,CAAC;oBACjC,OAAO;gBACT,CAAC;gBACD,IAAI,CAAC;oBACH,IAAI,MAAM,GAAG,CAAC,CAAC;oBACf,OAAO,MAAM,GAAG,QAAQ,CAAC,MAAM,EAAE,CAAC;wBAChC,MAAM,IAAI,EAAE,CAAC,SAAS,CACpB,oBAAoB,EACpB,QAAQ,EACR,MAAM,EACN,QAAQ,CAAC,MAAM,GAAG,MAAM,CACzB,CAAC;oBACJ,CAAC;oBACD,eAAe,IAAI,QAAQ,CAAC,MAAM,CAAC;gBACrC,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,eAAe,GAAG,KAAc,CAAC;oBACjC,qBAAqB,CAAC,SAAS,CAAC,CAAC;gBACnC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,QAAgB,EAAE,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;QACnF,CAAC;QACD,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,EAAE,CAAC,QAAgB,EAAE,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC;QACjF,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,EAAE;YAC/B,UAAU,GAAG,QAAQ,CAAC;QACxB,CAAC,CAAC,CAAC;QAEH,OAAO,IAAI,OAAO,CAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3D,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,EAAE;gBACzC,KAAK,CAAC,KAAK,IAAI,EAAE;oBACf,IAAI,CAAC;wBACH,IAAI,oBAAoB,KAAK,SAAS,EAAE,CAAC;4BACvC,IAAI,CAAC;gCACH,EAAE,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;gCACnC,EAAE,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;gCACnC,oBAAoB,GAAG,SAAS,CAAC;4BACnC,CAAC;4BAAC,OAAO,KAAK,EAAE,CAAC;gCACf,eAAe,GAAG,KAAc,CAAC;4BACnC,CAAC;wBACH,CAAC;wBACD,MAAM,yBAAyB,EAAE,CAAC;wBAClC,MAAM,QAAQ,GAAG,OAAO,IAAI,CAAC,CAAC,CAAC;wBAC/B,IAAI,QAAQ,EAAE,CAAC;4BACb,MAAM,IAAI,KAAK,CAAC,GAAG,UAAU,+BAA+B,CAAC,CAAC;wBAChE,CAAC;wBACD,IAAI,mBAAmB,EAAE,CAAC;4BACxB,MAAM,IAAI,KAAK,CAAC,GAAG,UAAU,qCAAqC,CAAC,CAAC;wBACtE,CAAC;wBACD,IAAI,eAAe,EAAE,CAAC;4BACpB,MAAM,IAAI,KAAK,CAAC,GAAG,UAAU,uBAAuB,eAAe,EAAE,CAAC,CAAC;wBACzE,CAAC;wBACD,IAAI,UAAU;4BAAE,MAAM,UAAU,CAAC;wBACjC,IAAI,UAAU;4BAAE,MAAM,UAAU,CAAC;wBACjC,IAAI,eAAe;4BAAE,MAAM,eAAe,CAAC;wBAC3C,IAAI,CAAC,CAAC,UAAU,CAAC,gBAAgB,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;4BAC7D,IAAI,OAAO,IAAI,MAAM;gCAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;4BACpD,IAAI,OAAO,IAAI,MAAM;gCAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;4BACpD,MAAM,IAAI,KAAK,CACb,GAAG,UAAU,gBACX,SAAS,CAAC,CAAC,CAAC,UAAU,SAAS,EAAE,CAAC,CAAC,CAAC,UAAU,QAAQ,EACxD,EAAE,CACH,CAAC;wBACJ,CAAC;wBACD,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CAAC;oBACxC,CAAC;oBAAC,OAAO,KAAK,EAAE,CAAC;wBACf,MAAM,CAAC,KAAK,CAAC,CAAC;oBAChB,CAAC;4BAAS,CAAC;wBACT,YAAY,CAAC,OAAO,CAAC,CAAC;wBACtB,IAAI,cAAc;4BAAE,YAAY,CAAC,cAAc,CAAC,CAAC;wBACjD,IAAI,cAAc;4BAAE,aAAa,CAAC,cAAc,CAAC,CAAC;wBAClD,KAAK,CAAC,KAAK,EAAE,GAAG,EAAE,CAAC;wBACnB,IAAI,oBAAoB,KAAK,SAAS,EAAE,CAAC;4BACvC,IAAI,CAAC;gCACH,EAAE,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;4BACrC,CAAC;4BAAC,MAAM,CAAC;gCACP,wCAAwC;4BAC1C,CAAC;wBACH,CAAC;wBACD,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,cAAc,EAAE,CAAC;4BAC/C,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;wBAC/B,CAAC;oBACH,CAAC;gBACH,CAAC,CAAC,EAAE,CAAC;YACP,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist_ts/mod_matrix/classes.nativematrixbuilder.d.ts

@@ -0,0 +1,64 @@
+import { type IArtifactAssemblyResult } from '../mod_artifact/index.js';
+import { type ITsrustConfig } from '../mod_cli/helpers.targets.js';
+import { type IMatrixCommandRunner } from './classes.matrixcommandrunner.js';
+import { type TMatrixHost } from './helpers.matrixconfig.js';
+export interface INativeMatrixBuilderOptions {
+    workspace: string;
+    config: ITsrustConfig;
+    environment?: NodeJS.ProcessEnv;
+    commandRunner?: IMatrixCommandRunner;
+}
+export interface INativeMatrixCheckResult {
+    workers: TMatrixHost[];
+    targets: string[];
+}
+export interface INativeMatrixBuildResult extends INativeMatrixCheckResult {
+    gitCommit: string;
+    assembly: IArtifactAssemblyResult;
+}
+export declare class NativeMatrixBuilder {
+    private readonly workspace;
+    private readonly environment;
+    private readonly commandRunner;
+    private readonly plan;
+    constructor(optionsArg: INativeMatrixBuilderOptions);
+    check(): Promise<INativeMatrixCheckResult>;
+    build(): Promise<INativeMatrixBuildResult>;
+    private checkResult;
+    private assertForwardEnvironmentGrant;
+    private workerEnvironment;
+    private transportEnvironment;
+    private remainingBuildTimeout;
+    private assertInstalledTsrustVersion;
+    private assertPlanMatchesCommit;
+    private remoteWorkerEnvironmentFunction;
+    private assertBundleCompatibleSource;
+    private checkLocalWorker;
+    private checkLocalToolchain;
+    private checkLocalExecution;
+    private checkLocalLinuxCrossExecution;
+    private resolveSshWorker;
+    private checkSshWorker;
+    private remoteToolchainCapabilityCommand;
+    private remoteRootValidationCommands;
+    private remoteOwnershipValidationCommands;
+    private remoteExecutionProbeCommands;
+    private readBinaryTargets;
+    private detectRustDirectory;
+    private readProjectIdentity;
+    private assertProjectIdentityUnchanged;
+    private ensureLocalRunParent;
+    private buildLocalWorker;
+    private workerTsrustArgs;
+    private assertWorkerSource;
+    private assertArtifactDirectory;
+    private smokeLocalArtifacts;
+    private describeRemoteWorkspace;
+    private createRemoteWorkspace;
+    private buildSshWorker;
+    private remoteSmokeCommands;
+    private cleanupRemoteWorkspace;
+    private runRemoteTransferScript;
+    private runRemoteLoginScript;
+    private runRemoteOwnedScript;
+}