@aria-cli/cli 1.0.57 → 1.0.59

package/dist/peer-identity.js

@@ -1,23 +0,0 @@
-export function discoveredPeerIdentityKey(peer) {
-    const nodeId = typeof peer.nodeId === "string" ? peer.nodeId.trim() : "";
-    const transport = typeof peer.transport === "string" ? peer.transport : "unknown";
-    if (nodeId) {
-        return `node:${nodeId}`;
-    }
-    const principalFingerprint = typeof peer.principalFingerprint === "string" ? peer.principalFingerprint.trim() : "";
-    if (principalFingerprint) {
-        return `principal:${principalFingerprint}`;
-    }
-    return `endpoint:${transport}:${peer.host}:${peer.port}:${peer.displayNameSnapshot}`;
-}
-export function mergeDiscoveredPeersByIdentity(preferredPeers, additionalPeers) {
-    const merged = new Map();
-    for (const peer of [...preferredPeers, ...additionalPeers]) {
-        const key = discoveredPeerIdentityKey(peer);
-        if (!merged.has(key)) {
-            merged.set(key, peer);
-        }
-    }
-    return [...merged.values()];
-}
-//# sourceMappingURL=peer-identity.js.map

package/dist/polling-subscription.js

@@ -1,34 +0,0 @@
-async function sleep(ms) {
-    await new Promise((resolve) => setTimeout(resolve, Math.max(ms, 0)));
-}
-export async function* createPollingSubscription(loadOnce, options = { pollIntervalMs: 1_000 }) {
-    const seenVersions = new Map();
-    let afterCreatedAt = options.initialAfterCreatedAt ?? 0;
-    while (true) {
-        const snapshot = await loadOnce();
-        let emitted = false;
-        for (const item of snapshot) {
-            const createdAt = options.getCursor?.(item);
-            if (typeof createdAt === "number" && createdAt < afterCreatedAt) {
-                continue;
-            }
-            const identity = options.getIdentityKey?.(item);
-            if (typeof identity === "string") {
-                const versionKey = options.getVersionKey?.(item) ?? JSON.stringify(item);
-                if (seenVersions.get(identity) === versionKey) {
-                    continue;
-                }
-                seenVersions.set(identity, versionKey);
-            }
-            if (typeof createdAt === "number") {
-                afterCreatedAt = Math.max(afterCreatedAt, createdAt);
-            }
-            emitted = true;
-            yield item;
-        }
-        if (!emitted) {
-            await sleep(options.pollIntervalMs);
-        }
-    }
-}
-//# sourceMappingURL=polling-subscription.js.map

package/dist/relaunch.js

@@ -1,617 +0,0 @@
-/**
- * @aria/cli - Relaunch / self-restart infrastructure
- *
- * Implements the parent-child supervisor pattern (inspired by gemini-cli):
- *
- *   Parent process (supervisor)
- *     └─ spawns child with ARIA_NO_RELAUNCH=true, stdio: inherit
- *     └─ loops: if child exits with RELAUNCH_EXIT_CODE → respawn
- *     └─ otherwise: propagate exit code and exit
- *
- *   Child process (actual ARIA)
- *     └─ runs the Ink REPL normally
- *     └─ on restart: requestRelaunch() → process.exit(RELAUNCH_EXIT_CODE)
- *     └─ supervisor catches it and respawns
- *
- * This replaces the fragile "detached spawn + kill self" approach
- * with a reliable supervisor loop that inherits the terminal properly.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync, } from "node:fs";
-import { dirname, join, resolve } from "node:path";
-import { NO_RELAUNCH_ENV, RELAUNCH_EXIT_CODE, RESUME_ARION_ENV, RESUME_SESSION_ENV, RESTART_KIND_ENV, clearRelaunchMarker as clearSharedRelaunchMarker, readRelaunchMarker as readSharedRelaunchMarker, writeRelaunchMarker as writeSharedRelaunchMarker, } from "@aria-cli/types";
-import { getAriaDir } from "./config.js";
-import { resolveAriaLaunchSpec } from "./runtime/launch-spec.js";
-import { spawnAria } from "./runtime/spawn-aria.js";
-export { NO_RELAUNCH_ENV, RELAUNCH_EXIT_CODE, RESUME_ARION_ENV, RESUME_SESSION_ENV, RESTART_KIND_ENV, } from "@aria-cli/types";
-export function writeRelaunchMarker(marker) {
-    writeSharedRelaunchMarker(marker);
-}
-export function readRelaunchMarker(pid) {
-    return readSharedRelaunchMarker(pid);
-}
-export function clearRelaunchMarker(pid) {
-    clearSharedRelaunchMarker(pid);
-}
-function isIgnorableTerminalWriteError(error) {
-    if (!error || typeof error !== "object")
-        return false;
-    const maybe = error;
-    return maybe.code === "EPIPE" || maybe.code === "EIO" || maybe.code === "ERR_STREAM_DESTROYED";
-}
-function writeSupervisorStderr(message) {
-    try {
-        process.stderr.write(message);
-    }
-    catch (error) {
-        if (isIgnorableTerminalWriteError(error)) {
-            return;
-        }
-        throw error;
-    }
-}
-function isProcessExitSentinel(error) {
-    if (!error || typeof error !== "object") {
-        return error instanceof Error && /^exit:\d+$/.test(error.message);
-    }
-    if (error.__ariaProcessExit === true) {
-        return true;
-    }
-    return error instanceof Error && /^exit:\d+$/.test(error.message);
-}
-/** Maximum age (ms) for a relaunch marker to be considered valid. */
-const RELAUNCH_MARKER_TTL_MS = 30_000;
-let pendingResumeSessionId = process.env[RESUME_SESSION_ENV] ?? null;
-let pendingArionName = process.env[RESUME_ARION_ENV] || "ARIA";
-export function setPendingResumeSessionId(sessionId) {
-    const normalized = sessionId?.trim() || null;
-    pendingResumeSessionId = normalized;
-    if (normalized) {
-        process.env[RESUME_SESSION_ENV] = normalized;
-    }
-    else {
-        delete process.env[RESUME_SESSION_ENV];
-    }
-}
-export function getPendingResumeSessionId() {
-    return pendingResumeSessionId;
-}
-export function setPendingArionName(name) {
-    pendingArionName = name || "ARIA";
-    process.env[RESUME_ARION_ENV] = pendingArionName;
-}
-export function getPendingArionName() {
-    return pendingArionName;
-}
-function findBunWorkspaceRoot(startDir) {
-    let dir = resolve(startDir);
-    while (true) {
-        if (existsSync(join(dir, "bunfig.toml")) || existsSync(join(dir, "bun.lock")))
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-function getBunCommand() {
-    return process.platform === "win32" ? "bun.exe" : "bun";
-}
-/**
- * Rebuild workspace before relaunch (dev workflow).
- *
- * This is best-effort and only runs when a bun workspace root is detected.
- */
-export async function rebuildWorkspaceIfPresent(startDir = process.cwd()) {
-    const root = findBunWorkspaceRoot(startDir);
-    if (!root)
-        return { attempted: false };
-    const started = Date.now();
-    const command = getBunCommand();
-    const proc = Bun.spawn([command, "run", "build"], {
-        cwd: root,
-        env: process.env,
-        stdin: "inherit",
-        stdout: "inherit",
-        stderr: "inherit",
-    });
-    const code = await proc.exited;
-    if (code !== 0) {
-        throw new Error(`bun run build failed with exit code ${code}`);
-    }
-    return {
-        attempted: true,
-        root,
-        durationMs: Date.now() - started,
-    };
-}
-/**
- * Returns true if we are already running inside a supervised child process.
- */
-export function isChildProcess() {
-    return process.env[NO_RELAUNCH_ENV] === "true";
-}
-/**
- * Trigger a relaunch from the child process.
- *
- * Two modes:
- *   1. Supervised child (normal): IPC handoff to supervisor + exit(RELAUNCH_EXIT_CODE)
- *   2. Compiled direct (no supervisor): spawn a new process with resume env vars,
- *      wait for it, and propagate its exit code. This avoids loading the 82MB
- *      binary twice on the initial startup while still supporting relaunch.
- */
-export async function requestRelaunch(reason, resumeSessionId) {
-    const logReason = reason || "Restart requested";
-    if (resumeSessionId !== undefined) {
-        setPendingResumeSessionId(resumeSessionId);
-    }
-    const sessionId = getPendingResumeSessionId();
-    const arionName = getPendingArionName();
-    writeSupervisorStderr(`[aria] Relaunch requested: ${logReason} (session=${sessionId?.slice(0, 8) ?? "none"}, arion=${arionName})\n`);
-    // Write disk-backed marker as durable fallback in case IPC is lost.
-    const markerPid = process.ppid || process.pid;
-    writeRelaunchMarker({
-        sessionId,
-        arionName,
-        pid: markerPid,
-        timestamp: new Date().toISOString(),
-    });
-    // ── Compiled direct mode: no supervisor listening ──────────────────
-    // Spawn a new ARIA process (supervisor mode) with resume env vars.
-    // The current process waits for the child and propagates its exit code
-    // so the terminal stays owned by an ARIA process throughout.
-    const hasSupervisor = typeof process.send === "function";
-    if (!hasSupervisor) {
-        const spec = resolveAriaLaunchSpec({
-            mode: "repl",
-            args: [],
-            env: {
-                ...process.env,
-                [NO_RELAUNCH_ENV]: "", // clear — enter supervisor mode
-                ARIA_USE_SUPERVISOR: "1", // skip compiled-direct, use supervisor loop
-                [RESUME_SESSION_ENV]: sessionId || "",
-                [RESUME_ARION_ENV]: arionName,
-                [RESTART_KIND_ENV]: "explicit",
-            },
-        });
-        writeSupervisorStderr(`[aria] Spawning new supervisor for relaunch...\n`);
-        const child = spawnAria(spec);
-        const code = await new Promise((resolve) => {
-            child.on("close", (c) => resolve(typeof c === "number" ? c : 1));
-            child.on("error", () => resolve(1));
-        });
-        process.exit(code);
-        throw new Error("Unreachable");
-    }
-    // ── Supervised child mode: IPC handoff ─────────────────────────────
-    // Inform the parent supervisor which session to auto-resume after respawn.
-    try {
-        const send = process.send;
-        if (typeof send === "function") {
-            const nonce = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            const acked = await new Promise((resolve) => {
-                let settled = false;
-                const timeout = setTimeout(() => {
-                    if (settled)
-                        return;
-                    settled = true;
-                    process.off("message", onMessage);
-                    resolve(false);
-                }, 120);
-                const onMessage = (msg) => {
-                    if (!msg || typeof msg !== "object")
-                        return;
-                    const payload = msg;
-                    if (payload.type !== "aria-relaunch-ack")
-                        return;
-                    if (payload.nonce !== nonce)
-                        return;
-                    if (settled)
-                        return;
-                    settled = true;
-                    clearTimeout(timeout);
-                    process.off("message", onMessage);
-                    resolve(true);
-                };
-                process.on("message", onMessage);
-                send({ type: "aria-relaunch", nonce, resumeSessionId: sessionId, arionName }, (err) => {
-                    if (err && !settled) {
-                        settled = true;
-                        clearTimeout(timeout);
-                        process.off("message", onMessage);
-                        resolve(false);
-                    }
-                });
-            });
-            if (acked) {
-                writeSupervisorStderr(`[aria] IPC handoff acknowledged by supervisor\n`);
-            }
-            else {
-                writeSupervisorStderr(`[aria] IPC ack timeout — disk marker will be used as fallback\n`);
-            }
-        }
-    }
-    catch {
-        // Non-fatal: disk marker is the fallback.
-    }
-    process.exit(RELAUNCH_EXIT_CODE);
-    // Unreachable — satisfies TypeScript
-    throw new Error("Unreachable");
-}
-/**
- * Supervisor loop: spawns ARIA as a child process and respawns on RELAUNCH_EXIT_CODE.
- *
- * The child inherits the terminal (stdio: inherit) so the user experience
- * is seamless. The parent just watches and re-executes when needed.
- *
- * @param scriptPath - Legacy compatibility label retained for tests/callers
- * @param scriptArgs - Arguments to forward to the internal REPL mode
- * @param nodeArgs   - Legacy compatibility placeholder (ignored)
- */
-/** Maximum consecutive crash restarts before giving up. */
-const MAX_CRASH_RESTARTS = 3;
-function getCrashStatePath(...parts) {
-    return join(getAriaDir(), ...parts);
-}
-function getCrashMarkerDir() {
-    return getCrashStatePath("crash-markers");
-}
-function getCrashMarkerPath(sessionId) {
-    return join(getCrashMarkerDir(), `${sessionId}.json`);
-}
-function readCrashMarker(sessionId) {
-    const markerPath = getCrashMarkerPath(sessionId);
-    if (!existsSync(markerPath))
-        return null;
-    try {
-        return JSON.parse(readFileSync(markerPath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-function writeCrashMarker(marker) {
-    try {
-        const dir = getCrashMarkerDir();
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(getCrashMarkerPath(marker.sessionId), JSON.stringify(marker), "utf-8");
-    }
-    catch {
-        // Best-effort — don't crash the supervisor over crash tracking
-    }
-}
-function clearCrashMarker(sessionId) {
-    try {
-        const markerPath = getCrashMarkerPath(sessionId);
-        if (existsSync(markerPath))
-            unlinkSync(markerPath);
-    }
-    catch {
-        // Best-effort
-    }
-}
-function getCrashReportPath() {
-    return getCrashStatePath("crash-reports", "latest.json");
-}
-function abandonPoisonedResumeSession(sessionId, crashCount) {
-    writeSupervisorStderr(`[aria] Session ${sessionId} exceeded crash limit (${crashCount}/${MAX_CRASH_RESTARTS}). ` +
-        `Starting fresh instead of resuming.\n`);
-    clearCrashMarker(sessionId);
-    pendingResumeSessionId = null;
-    setPendingResumeSessionId(null);
-}
-function readAndClearCrashReport() {
-    const reportPath = getCrashReportPath();
-    if (!existsSync(reportPath))
-        return null;
-    try {
-        const raw = JSON.parse(readFileSync(reportPath, "utf-8"));
-        try {
-            unlinkSync(reportPath);
-        }
-        catch {
-            /* best effort */
-        }
-        return {
-            message: raw?.error?.message ?? "unknown",
-            stack: raw?.error?.stack ?? undefined,
-            heapMb: raw?.process?.heapUsedMb,
-            rssMb: raw?.process?.rssMb,
-        };
-    }
-    catch {
-        try {
-            unlinkSync(reportPath);
-        }
-        catch {
-            /* best effort */
-        }
-        return null;
-    }
-}
-/**
- * Unified fallback resolver for recovering session context when IPC handoff
- * is lost (child exited before parent received the message).
- *
- * Priority order:
- *   1. Disk-backed relaunch marker (written by child before exit)
- *   2. SessionHistory lookup (most recent incomplete session for the active arion)
- *
- * Used for both crash recovery AND explicit restart recovery.
- */
-async function recoverResumeContext(currentArionName) {
-    // 1. Try disk-backed relaunch marker (namespaced by current child PID)
-    const marker = readRelaunchMarker(process.pid);
-    if (marker) {
-        const age = Date.now() - new Date(marker.timestamp).getTime();
-        if (age < RELAUNCH_MARKER_TTL_MS) {
-            clearRelaunchMarker(process.pid);
-            return {
-                sessionId: marker.sessionId,
-                arionName: marker.arionName || currentArionName,
-                source: "marker",
-            };
-        }
-        // Stale marker — clean up
-        clearRelaunchMarker(process.pid);
-    }
-    // 2. Query SessionHistory for most recent incomplete session
-    // First preferred arion, then scan other arions and choose most recently updated.
-    try {
-        const { SessionHistory } = await import("./history/index.js");
-        const { getAriaDir } = await import("./config.js");
-        const ariaDir = getAriaDir();
-        const candidateArions = new Set([currentArionName]);
-        const arionsDir = join(ariaDir, "arions");
-        if (existsSync(arionsDir)) {
-            for (const entry of readdirSync(arionsDir, { withFileTypes: true })) {
-                if (entry.isDirectory() && entry.name.trim()) {
-                    candidateArions.add(entry.name.trim());
-                }
-            }
-        }
-        let best = null;
-        for (const arionName of candidateArions) {
-            const dbPath = SessionHistory.resolvePerArionPath(ariaDir, arionName);
-            if (!existsSync(dbPath))
-                continue;
-            const tmpHistory = new SessionHistory(dbPath);
-            try {
-                const incomplete = tmpHistory.getIncompleteSessions(1);
-                if (incomplete.length === 0)
-                    continue;
-                const top = incomplete[0];
-                const updatedAtMs = top.updatedAt.getTime();
-                // Prefer current arion first when timestamps tie.
-                if (!best ||
-                    updatedAtMs > best.updatedAtMs ||
-                    (updatedAtMs === best.updatedAtMs && arionName === currentArionName)) {
-                    best = {
-                        sessionId: top.id,
-                        arionName,
-                        updatedAtMs,
-                    };
-                }
-            }
-            finally {
-                tmpHistory.close();
-            }
-        }
-        if (best) {
-            return {
-                sessionId: best.sessionId,
-                arionName: best.arionName,
-                source: best.arionName === currentArionName ? "history" : "history-scan",
-            };
-        }
-    }
-    catch (err) {
-        writeSupervisorStderr(`[aria] SessionHistory fallback failed: ${err instanceof Error ? err.message : String(err)}\n`);
-    }
-    return { sessionId: null, arionName: currentArionName, source: "none" };
-}
-export async function supervise(scriptPath, scriptArgs, nodeArgs = [], options = {}) {
-    // Restore crash count from persistent marker if resuming a session
-    let consecutiveCrashes = 0;
-    if (pendingResumeSessionId) {
-        const marker = readCrashMarker(pendingResumeSessionId);
-        if (marker) {
-            consecutiveCrashes = marker.count;
-            if (consecutiveCrashes >= MAX_CRASH_RESTARTS) {
-                abandonPoisonedResumeSession(pendingResumeSessionId, consecutiveCrashes);
-                consecutiveCrashes = 0;
-            }
-        }
-    }
-    // Tracks the kind of restart so the child can distinguish explicit /restart
-    // from crash recovery (affects whether auto-continue message is injected).
-    let nextRestartKind;
-    while (true) {
-        try {
-            await options.beforeSpawn?.();
-            const result = await spawnChild(scriptPath, scriptArgs, nodeArgs, pendingResumeSessionId, pendingArionName, nextRestartKind);
-            nextRestartKind = undefined; // Reset for next iteration
-            const exitCode = result.code;
-            pendingResumeSessionId = result.resumeSessionId;
-            setPendingResumeSessionId(pendingResumeSessionId);
-            pendingArionName = result.arionName;
-            setPendingArionName(pendingArionName);
-            if (exitCode === 0) {
-                // Clean exit — clear any crash markers and relaunch marker
-                if (pendingResumeSessionId)
-                    clearCrashMarker(pendingResumeSessionId);
-                clearRelaunchMarker(process.pid);
-                process.exit(0);
-            }
-            if (exitCode === RELAUNCH_EXIT_CODE) {
-                // Explicit restart request — reset crash counter and clear crash marker
-                consecutiveCrashes = 0;
-                if (pendingResumeSessionId)
-                    clearCrashMarker(pendingResumeSessionId);
-                // If IPC didn't deliver the session ID, use the unified fallback resolver.
-                // This is the key fix: explicit restarts now have the same recovery
-                // guarantees as crash restarts.
-                if (!pendingResumeSessionId) {
-                    const recovered = await recoverResumeContext(pendingArionName);
-                    if (recovered.sessionId) {
-                        pendingResumeSessionId = recovered.sessionId;
-                        setPendingResumeSessionId(pendingResumeSessionId);
-                        pendingArionName = recovered.arionName;
-                        setPendingArionName(pendingArionName);
-                        writeSupervisorStderr(`[aria] IPC session ID lost — recovered via ${recovered.source}: ${pendingResumeSessionId.slice(0, 8)}...\n`);
-                    }
-                }
-                else {
-                    // IPC succeeded — consume disk marker if present
-                    clearRelaunchMarker(process.pid);
-                }
-                nextRestartKind = "explicit";
-                writeSupervisorStderr(`[aria] Respawning after relaunch request...\n`);
-                continue;
-            }
-            // Unexpected exit (crash, segfault, OOM, unhandled exception)
-            nextRestartKind = "crash";
-            consecutiveCrashes++;
-            const crashAttempt = consecutiveCrashes;
-            const crashedSessionId = pendingResumeSessionId;
-            let abandonedResumeSession = false;
-            // Read crash report written by the child's uncaughtException/unhandledRejection handler
-            const crashReport = readAndClearCrashReport();
-            // Persist crash marker so the count survives supervisor restarts
-            if (crashedSessionId) {
-                writeCrashMarker({
-                    sessionId: crashedSessionId,
-                    count: crashAttempt,
-                    lastExitCode: exitCode,
-                    lastCrash: new Date().toISOString(),
-                    lastError: crashReport?.message,
-                    lastStack: crashReport?.stack?.slice(0, 2000),
-                });
-            }
-            // Log crash details to stderr for diagnostics
-            if (crashReport) {
-                writeSupervisorStderr(`[aria] Crash error: ${crashReport.message}\n`);
-                if (crashReport.stack) {
-                    writeSupervisorStderr(`[aria] Stack: ${crashReport.stack.slice(0, 2000)}\n`);
-                }
-                if (crashReport.heapMb != null || crashReport.rssMb != null) {
-                    writeSupervisorStderr(`[aria] Memory at crash: heap=${crashReport.heapMb ?? "?"}MB, rss=${crashReport.rssMb ?? "?"}MB\n`);
-                }
-            }
-            if (crashedSessionId && crashAttempt >= MAX_CRASH_RESTARTS) {
-                abandonPoisonedResumeSession(crashedSessionId, crashAttempt);
-                consecutiveCrashes = 0;
-                abandonedResumeSession = true;
-            }
-            else if (crashAttempt > MAX_CRASH_RESTARTS) {
-                writeSupervisorStderr(`[aria] Too many consecutive crashes (${crashAttempt}), giving up (exit ${exitCode})\n`);
-                process.exit(exitCode);
-            }
-            const backoffMs = Math.min(1000 * Math.pow(2, Math.max(crashAttempt - 1, 0)), 30000);
-            writeSupervisorStderr(`[aria] Crash detected (exit ${exitCode}, attempt ${crashAttempt}/${MAX_CRASH_RESTARTS}). ` +
-                `Restarting in ${backoffMs}ms...\n`);
-            // Fallback: if IPC didn't deliver the session ID, use the unified resolver.
-            if (!pendingResumeSessionId && !abandonedResumeSession) {
-                const recovered = await recoverResumeContext(pendingArionName);
-                if (recovered.sessionId) {
-                    pendingResumeSessionId = recovered.sessionId;
-                    setPendingResumeSessionId(pendingResumeSessionId);
-                    pendingArionName = recovered.arionName;
-                    setPendingArionName(pendingArionName);
-                    writeSupervisorStderr(`[aria] IPC session ID lost — recovered via ${recovered.source}: ${pendingResumeSessionId.slice(0, 8)}...\n`);
-                }
-            }
-            await new Promise((r) => setTimeout(r, backoffMs));
-            // Respawn with the same resume session ID so the child auto-continues
-        }
-        catch (error) {
-            if (isProcessExitSentinel(error)) {
-                throw error;
-            }
-            process.stdin.resume();
-            const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
-            writeSupervisorStderr(`[aria] Fatal: failed to spawn child process.\n${message}\n`);
-            process.exit(1);
-        }
-    }
-}
-export async function superviseInteractiveSession(invocation, options = {}) {
-    const forwardedArgs = [...invocation.rawArgs];
-    return supervise("__internal-repl", forwardedArgs, [], options);
-}
-/**
- * Spawn a single child process and wait for it to exit.
- */
-function spawnChild(scriptPath, scriptArgs, nodeArgs, resumeSessionId, arionName, restartKind) {
-    // Pause parent stdin while child owns the terminal
-    process.stdin.pause();
-    void scriptPath;
-    void nodeArgs;
-    const childEnv = {
-        ...process.env,
-        [NO_RELAUNCH_ENV]: "true",
-    };
-    if (resumeSessionId) {
-        childEnv[RESUME_SESSION_ENV] = resumeSessionId;
-    }
-    else {
-        delete childEnv[RESUME_SESSION_ENV];
-    }
-    childEnv[RESUME_ARION_ENV] = arionName;
-    if (restartKind) {
-        childEnv[RESTART_KIND_ENV] = restartKind;
-    }
-    else {
-        delete childEnv[RESTART_KIND_ENV];
-    }
-    const childArgs = scriptArgs;
-    const spec = resolveAriaLaunchSpec({
-        mode: "repl",
-        args: childArgs,
-        env: childEnv,
-        cwd: process.cwd(),
-    });
-    const child = spawnAria(spec, { ipc: true });
-    return new Promise((resolve, reject) => {
-        let resumeFromChild = resumeSessionId;
-        let arionFromChild = arionName;
-        child.on("message", (message) => {
-            if (!message || typeof message !== "object")
-                return;
-            const payload = message;
-            if (payload.type !== "aria-relaunch")
-                return;
-            if (typeof payload.resumeSessionId === "string" && payload.resumeSessionId.trim()) {
-                resumeFromChild = payload.resumeSessionId.trim();
-            }
-            else if (payload.resumeSessionId === null) {
-                resumeFromChild = null;
-            }
-            if (typeof payload.arionName === "string" && payload.arionName.trim()) {
-                arionFromChild = payload.arionName.trim();
-            }
-            // Acknowledge receipt so child can exit with confidence.
-            try {
-                child.send({
-                    type: "aria-relaunch-ack",
-                    nonce: typeof payload.nonce === "string" ? payload.nonce : undefined,
-                });
-            }
-            catch {
-                // Child may have already exited — non-fatal.
-            }
-        });
-        child.on("error", (err) => {
-            process.stdin.resume();
-            reject(err);
-        });
-        child.on("close", (code) => {
-            process.stdin.resume();
-            resolve({
-                code: (typeof code === "number" ? code : null) ?? 1,
-                resumeSessionId: resumeFromChild,
-                arionName: arionFromChild,
-            });
-        });
-    });
-}
-//# sourceMappingURL=relaunch.js.map