@timurproko/a1 0.1.1-dev.7 → 0.1.1-dev.9

package/dist/src/foundation/transparent-terminal/native-launcher.js

@@ -1,146 +0,0 @@
-import { spawn } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { resolveTransparentCommand } from "./command-resolution.js";
-export function createPlatformTransparentLauncher(platform = process.platform, adapter = defaultSpawnAdapter) {
-    if (platform === "win32")
-        return new WindowsTransparentLauncher(adapter);
-    if (platform === "linux" || platform === "darwin")
-        return new UnixTransparentLauncher(adapter);
-    throw new Error(`transparent terminal attachment is unsupported on ${platform}`);
-}
-export class WindowsTransparentLauncher {
-    adapter;
-    constructor(adapter = defaultSpawnAdapter) {
-        this.adapter = adapter;
-    }
-    async launch(profile) {
-        return await launchInherited(profile, this.adapter, {
-            windowsHide: true,
-            windowsVerbatimArguments: false,
-            detached: false,
-        });
-    }
-}
-export class UnixTransparentLauncher {
-    adapter;
-    constructor(adapter = defaultSpawnAdapter) {
-        this.adapter = adapter;
-    }
-    async launch(profile) {
-        // Staying in the foreground process group preserves the inherited controlling
-        // terminal without an intermediary or synthetic terminal restoration.
-        return await launchInherited(profile, this.adapter, {
-            detached: false,
-        });
-    }
-}
-async function launchInherited(profile, adapter, platformOptions) {
-    const command = await adapter.resolveCommand(profile);
-    const child = adapter.spawn(command.executable, command.arguments, {
-        ...platformOptions,
-        cwd: profile.cwd,
-        env: { ...profile.environment, TERM: profile.terminalType },
-        shell: false,
-        stdio: "inherit",
-    });
-    await spawned(child);
-    if (!child.pid)
-        throw Object.assign(new Error("transparent child has no process identity"), { code: "NO_PROCESS_ID" });
-    const outcome = childOutcome(child);
-    const startIdentity = await adapter.observeStartIdentity(child);
-    const processIdentity = { pid: child.pid, startIdentity };
-    let stopOutcome = null;
-    return {
-        processIdentity,
-        outcome,
-        stop(reason) {
-            stopOutcome ??= stopOwnedChild(child, adapter, processIdentity.startIdentity, reason);
-            return stopOutcome;
-        },
-    };
-}
-function spawned(child) {
-    return new Promise((resolve, reject) => {
-        if (child.pid) {
-            resolve();
-            return;
-        }
-        child.once("spawn", resolve);
-        child.once("error", reject);
-    });
-}
-function childOutcome(child) {
-    return new Promise(resolve => {
-        child.once("error", error => resolve({ kind: "broker-error", message: error.message, code: errorCode(error) }));
-        child.once("close", (exitCode, signal) => {
-            if (signal)
-                resolve({ kind: "signaled", signal });
-            else
-                resolve({ kind: "exited", exitCode: exitCode ?? 1 });
-        });
-    });
-}
-async function stopOwnedChild(child, adapter, expectedStartIdentity, reason) {
-    if (!await adapter.identityMatches(child, expectedStartIdentity)) {
-        return { kind: "broker-error", message: "refusing cleanup because transparent child ownership changed", code: "PROCESS_IDENTITY_MISMATCH" };
-    }
-    await adapter.stop(child, false);
-    if (!await adapter.waitForExit(child, 1_500)) {
-        if (!await adapter.identityMatches(child, expectedStartIdentity)) {
-            return { kind: "broker-error", message: "refusing forced cleanup because transparent child ownership changed", code: "PROCESS_IDENTITY_MISMATCH" };
-        }
-        await adapter.stop(child, true);
-        if (!await adapter.waitForExit(child, 1_500)) {
-            return { kind: "broker-error", message: "transparent child did not exit within the bounded cleanup deadline", code: "CLEANUP_TIMEOUT" };
-        }
-    }
-    return { kind: "stopped", reason };
-}
-function errorCode(error) {
-    return "code" in error && typeof error.code === "string" ? error.code : null;
-}
-const observedStartIdentities = new WeakMap();
-const defaultSpawnAdapter = {
-    async resolveCommand(profile) {
-        return await resolveTransparentCommand(profile.executable, profile.arguments, {
-            cwd: profile.cwd,
-            environment: profile.environment,
-        });
-    },
-    spawn(executable, arguments_, options) {
-        return spawn(executable, [...arguments_], options);
-    },
-    async observeStartIdentity(child) {
-        if (!child.pid)
-            throw new Error("transparent child has no PID");
-        const identity = `${child.pid}:${randomUUID()}`;
-        observedStartIdentities.set(child, identity);
-        return identity;
-    },
-    async identityMatches(child, expectedStartIdentity) {
-        return child.pid !== undefined
-            && child.exitCode === null
-            && child.signalCode === null
-            && observedStartIdentities.get(child) === expectedStartIdentity;
-    },
-    async stop(child, force) {
-        if (child.exitCode !== null || child.signalCode !== null)
-            return;
-        child.kill(force ? "SIGKILL" : "SIGTERM");
-    },
-    async waitForExit(child, timeoutMs) {
-        if (child.exitCode !== null || child.signalCode !== null)
-            return true;
-        return await new Promise(resolve => {
-            const timer = setTimeout(() => finish(false), timeoutMs);
-            timer.unref();
-            const finish = (exited) => {
-                clearTimeout(timer);
-                child.off("close", onClose);
-                resolve(exited);
-            };
-            const onClose = () => finish(true);
-            child.once("close", onClose);
-        });
-    },
-};