@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/commands/mutate-child-execution.js

@@ -0,0 +1,374 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MUTATE_CHILD_EXECUTION_TESTING = void 0;
+exports.awaitFileMutationWorkerPublication = awaitFileMutationWorkerPublication;
+exports.awaitNestedFileMutationResponse = awaitNestedFileMutationResponse;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const file_move_to_dir_execution_cache_1 = require("./file-move-to-dir-execution-cache");
+const file_rename_execution_cache_1 = require("./file-rename-execution-cache");
+const mutate_output_values_1 = require("./mutate-output-values");
+async function awaitFileMutationWorkerPublication(input, options = {}) {
+    const runtime = options.runtime ?? DEFAULT_RUNTIME;
+    const graceMs = options.publicationGraceMs ?? 2_000;
+    const pollMs = options.pollMs ?? 25;
+    const deadline = runtime.now() + graceMs;
+    let lastCompatible = null;
+    while (runtime.now() <= deadline) {
+        const status = runtime.read(input.kind, input.cwd, input.executionId);
+        if (status) {
+            if (status.executionId !== input.executionId || status.operation !== input.operation) {
+                if (runtime.isAlive(input.workerPid)) {
+                    runtime.terminate(input.workerPid);
+                }
+                return childFailure(input.executionId, input.operation, "MUTATE_CHILD_EXECUTION_IDENTITY_MISMATCH", "Spawned child cache did not match the exact operation identity.");
+            }
+            if (status.workerPid !== undefined && status.workerPid !== input.workerPid) {
+                if (runtime.isAlive(input.workerPid)) {
+                    runtime.terminate(input.workerPid);
+                }
+                return childFailure(input.executionId, input.operation, "MUTATE_CHILD_EXECUTION_IDENTITY_MISMATCH", "Spawned child cache published a different worker process identity.");
+            }
+            lastCompatible = status;
+            if (status.workerPid === input.workerPid) {
+                if (status.status !== "running" || status.phase === "completed") {
+                    return terminalChildResponse(status);
+                }
+                return null;
+            }
+        }
+        if (!runtime.isAlive(input.workerPid)) {
+            break;
+        }
+        await runtime.delay(Math.min(pollMs, Math.max(1, deadline - runtime.now())));
+    }
+    if (runtime.isAlive(input.workerPid)) {
+        runtime.terminate(input.workerPid);
+    }
+    const failure = childFailure(input.executionId, input.operation, "MUTATE_CHILD_EXECUTION_START_UNCONFIRMED", `Child file mutation did not publish its exact worker identity within ${graceMs}ms.`);
+    if (lastCompatible && lastCompatible.workerPid === undefined) {
+        runtime.fail(input.cwd, lastCompatible, "MUTATE_CHILD_EXECUTION_START_UNCONFIRMED", String(failure.error));
+    }
+    return failure;
+}
+async function awaitNestedFileMutationResponse(cwd, response, options = {}) {
+    if (response.operation !== "execution.status" || response.status !== "running") {
+        return response;
+    }
+    const runtime = options.runtime ?? DEFAULT_RUNTIME;
+    const reference = readRunningChildReference(response);
+    if (!reference) {
+        return childFailure(typeof response.executionId === "string" ? response.executionId : "unknown", "mutate.child", "MUTATE_CHILD_EXECUTION_IDENTITY_MISSING", "Running child response did not provide an exact supported cache namespace, operation, kind, and worker pid.");
+    }
+    const pollMs = options.pollMs ?? 100;
+    const publicationGraceMs = options.publicationGraceMs ?? 2_000;
+    const publicationDeadline = runtime.now() + publicationGraceMs;
+    let initial = null;
+    let lastSeen = null;
+    while (runtime.now() <= publicationDeadline) {
+        const candidate = runtime.read(reference.kind, cwd, reference.executionId);
+        if (candidate) {
+            lastSeen = candidate;
+            if (!isCompatibleStatusBeforePublication(candidate, reference)) {
+                if (runtime.isAlive(reference.workerPid)) {
+                    runtime.terminate(reference.workerPid);
+                }
+                return childFailure(reference.executionId, reference.operation, "MUTATE_CHILD_EXECUTION_IDENTITY_MISMATCH", "Running child cache did not match the exact operation, namespace, and worker process from the response.");
+            }
+            if (candidate.workerPid === reference.workerPid) {
+                initial = candidate;
+                break;
+            }
+        }
+        if (!runtime.isAlive(reference.workerPid)) {
+            break;
+        }
+        await runtime.delay(Math.min(pollMs, Math.max(1, publicationDeadline - runtime.now())));
+    }
+    if (!initial) {
+        if (runtime.isAlive(reference.workerPid)) {
+            runtime.terminate(reference.workerPid);
+        }
+        const failure = childFailure(reference.executionId, reference.operation, "MUTATE_CHILD_EXECUTION_START_UNCONFIRMED", `Child file mutation did not publish its exact worker identity within ${publicationGraceMs}ms.`);
+        if (lastSeen) {
+            runtime.fail(cwd, lastSeen, "MUTATE_CHILD_EXECUTION_START_UNCONFIRMED", String(failure.error));
+        }
+        return failure;
+    }
+    options.onDelegated?.(reference.executionId);
+    const deadlineMs = options.deadlineMs ?? readChildWaitDeadlineMs();
+    const deadline = runtime.now() + deadlineMs;
+    let deadObservedAt = null;
+    while (runtime.now() < deadline) {
+        const status = runtime.read(reference.kind, cwd, reference.executionId);
+        if (!status) {
+            if (runtime.isAlive(reference.workerPid)) {
+                runtime.terminate(reference.workerPid);
+            }
+            const failure = childFailure(reference.executionId, initial.operation, "MUTATE_CHILD_EXECUTION_STATUS_LOST", "Child file mutation status disappeared while the aggregate was waiting.");
+            runtime.fail(cwd, initial, "MUTATE_CHILD_EXECUTION_STATUS_LOST", String(failure.error));
+            return failure;
+        }
+        if (!isCompatibleStatus(status, reference)) {
+            if (runtime.isAlive(reference.workerPid)) {
+                runtime.terminate(reference.workerPid);
+            }
+            return childFailure(reference.executionId, reference.operation, "MUTATE_CHILD_EXECUTION_IDENTITY_MISMATCH", "Child execution cache identity changed while the aggregate was waiting.");
+        }
+        if (status.status !== "running" || status.phase === "completed") {
+            return terminalChildResponse(status);
+        }
+        if (status.workerPid && !runtime.isAlive(status.workerPid)) {
+            deadObservedAt ??= runtime.now();
+            if (runtime.now() - deadObservedAt >= Math.max(100, pollMs * 2)) {
+                const failure = childFailure(reference.executionId, status.operation, "MUTATE_CHILD_EXECUTION_CRASHED", `Child file mutation process exited before publishing a terminal result: ${status.workerPid}`);
+                runtime.fail(cwd, status, "MUTATE_CHILD_EXECUTION_CRASHED", String(failure.error));
+                return failure;
+            }
+        }
+        else {
+            deadObservedAt = null;
+        }
+        await runtime.delay(pollMs);
+    }
+    const final = runtime.read(reference.kind, cwd, reference.executionId);
+    if (final && !isCompatibleStatus(final, reference)) {
+        if (runtime.isAlive(reference.workerPid)) {
+            runtime.terminate(reference.workerPid);
+        }
+        return childFailure(reference.executionId, reference.operation, "MUTATE_CHILD_EXECUTION_IDENTITY_MISMATCH", "Child execution cache identity changed at the aggregate deadline.");
+    }
+    if (final && (final.status !== "running" || final.phase === "completed")) {
+        return terminalChildResponse(final);
+    }
+    if (final?.workerPid && runtime.isAlive(final.workerPid)) {
+        const terminated = runtime.terminate(final.workerPid);
+        if (!terminated && runtime.isAlive(final.workerPid)) {
+            const failure = childFailure(reference.executionId, final.operation, "MUTATE_CHILD_EXECUTION_TERMINATION_FAILED", `Child file mutation deadline expired and process-tree reclamation could not be confirmed for PID ${final.workerPid}.`);
+            runtime.fail(cwd, final, "MUTATE_CHILD_EXECUTION_TERMINATION_FAILED", String(failure.error));
+            return failure;
+        }
+    }
+    const failure = childFailure(reference.executionId, final?.operation ?? initial.operation, "MUTATE_CHILD_EXECUTION_DEADLINE", `Child file mutation did not publish a terminal result within ${deadlineMs}ms.`);
+    runtime.fail(cwd, final ?? initial, "MUTATE_CHILD_EXECUTION_DEADLINE", String(failure.error));
+    return failure;
+}
+function readRunningChildReference(response) {
+    const executionId = typeof response.executionId === "string" ? response.executionId : "";
+    const kind = response.childExecutionKind;
+    const operation = typeof response.childOperation === "string" ? response.childOperation : "";
+    const cacheNamespace = typeof response.childCacheNamespace === "string" ? response.childCacheNamespace : "";
+    const workerPid = typeof response.childWorkerPid === "number" && Number.isInteger(response.childWorkerPid) && response.childWorkerPid > 0
+        ? response.childWorkerPid
+        : 0;
+    const expectedNamespace = kind === "file.rename"
+        ? file_rename_execution_cache_1.FILE_RENAME_EXECUTION_NAMESPACE
+        : kind === "move.toDir"
+            ? file_move_to_dir_execution_cache_1.FILE_MOVE_TO_DIR_EXECUTION_NAMESPACE
+            : null;
+    const operationCompatible = kind === "file.rename"
+        ? operation.startsWith("file.rename.")
+        : kind === "move.toDir"
+            ? operation.startsWith("move.toDir.")
+            : false;
+    if (!executionId || (kind !== "file.rename" && kind !== "move.toDir") || expectedNamespace !== cacheNamespace || !operationCompatible || workerPid <= 0) {
+        return null;
+    }
+    return { executionId, kind, operation, cacheNamespace, workerPid };
+}
+function isCompatibleStatus(status, reference) {
+    return status.executionId === reference.executionId &&
+        status.operation === reference.operation &&
+        status.workerPid === reference.workerPid;
+}
+function isCompatibleStatusBeforePublication(status, reference) {
+    return status.executionId === reference.executionId &&
+        status.operation === reference.operation &&
+        (status.workerPid === undefined || status.workerPid === reference.workerPid);
+}
+function terminalChildResponse(status) {
+    if ((0, mutate_output_values_1.isObject)(status.result)) {
+        return status.result;
+    }
+    if (status.status === "failed") {
+        return childFailure(status.executionId, status.operation, status.error ?? "MUTATE_CHILD_EXECUTION_FAILED", status.error ?? "Child file mutation failed without a result payload.");
+    }
+    return childFailure(status.executionId, status.operation, "MUTATE_CHILD_EXECUTION_RESULT_MISSING", "Child file mutation completed without a result payload.");
+}
+function childFailure(executionId, operation, code, error) {
+    return {
+        ok: false,
+        operation,
+        executionId,
+        code,
+        error,
+        filesWritten: [],
+        filesTouched: []
+    };
+}
+function readChildWaitDeadlineMs() {
+    const parsed = Number.parseInt(process.env.AIB_MUTATE_CHILD_EXECUTION_WAIT_MS ?? "900000", 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : 900_000;
+}
+function isProcessAlive(pid) {
+    if (process.platform === "linux") {
+        const state = readLinuxProcessStat(pid);
+        return state !== null && state.state !== "Z";
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function terminateProcessTree(pid) {
+    if (process.platform === "win32") {
+        (0, node_child_process_1.spawnSync)("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true
+        });
+        return waitForProcessExit(pid, 2_000);
+    }
+    try {
+        process.kill(-pid, "SIGTERM");
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            // The child may have exited between the liveness check and termination.
+        }
+    }
+    if (waitForProcessExit(pid, 500)) {
+        return true;
+    }
+    try {
+        process.kill(-pid, "SIGKILL");
+    }
+    catch {
+        try {
+            process.kill(pid, "SIGKILL");
+        }
+        catch {
+            // The process may have exited during escalation.
+        }
+    }
+    return waitForProcessExit(pid, 2_000);
+}
+function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    const waitArray = new Int32Array(new SharedArrayBuffer(4));
+    while (Date.now() <= deadline) {
+        if (!isOwnedProcessTreeAlive(pid)) {
+            return true;
+        }
+        Atomics.wait(waitArray, 0, 0, Math.min(25, Math.max(1, deadline - Date.now())));
+    }
+    return !isOwnedProcessTreeAlive(pid);
+}
+function isOwnedProcessTreeAlive(pid) {
+    if (process.platform === "win32") {
+        return isProcessAlive(pid);
+    }
+    if (process.platform === "linux") {
+        try {
+            for (const entry of fs.readdirSync("/proc", { withFileTypes: true })) {
+                if (!entry.isDirectory() || !/^\d+$/.test(entry.name))
+                    continue;
+                const stat = readLinuxProcessStat(Number.parseInt(entry.name, 10));
+                if (stat?.processGroup === pid && stat.state !== "Z")
+                    return true;
+            }
+            return false;
+        }
+        catch {
+            // Fall through to the portable process-group probe.
+        }
+    }
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readLinuxProcessStat(pid) {
+    try {
+        const raw = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+        const close = raw.lastIndexOf(")");
+        if (close < 0)
+            return null;
+        const fields = raw.slice(close + 2).trim().split(/\s+/);
+        const state = fields[0];
+        const processGroup = Number.parseInt(fields[2] ?? "", 10);
+        return state && Number.isInteger(processGroup) ? { state, processGroup } : null;
+    }
+    catch {
+        return null;
+    }
+}
+exports.MUTATE_CHILD_EXECUTION_TESTING = {
+    terminateProcessTree,
+    isOwnedProcessTreeAlive
+};
+function failChildExecution(cwd, status, code, error) {
+    const result = childFailure(status.executionId, status.operation, code, error);
+    status.status = "failed";
+    status.phase = "completed";
+    status.failedRows = Math.max(1, status.failedRows);
+    status.notRunRows = Math.max(0, status.rowCount - status.completedRows - status.failedRows);
+    status.error = code;
+    status.result = result;
+    if (status.operation.startsWith("file.rename.")) {
+        (0, file_rename_execution_cache_1.writeFileRenameExecutionStatus)(cwd, status);
+        return;
+    }
+    (0, file_move_to_dir_execution_cache_1.writeFileMoveToDirExecutionStatus)(cwd, status);
+}
+const DEFAULT_RUNTIME = {
+    now: () => Date.now(),
+    delay: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    read: (kind, cwd, executionId) => kind === "file.rename"
+        ? (0, file_rename_execution_cache_1.tryReadFileRenameExecutionStatus)(cwd, executionId)
+        : (0, file_move_to_dir_execution_cache_1.tryReadFileMoveToDirExecutionStatus)(cwd, executionId),
+    fail: failChildExecution,
+    isAlive: isProcessAlive,
+    terminate: terminateProcessTree
+};