@evref-bl/plexus-core 0.1.0-alpha.0

package/dist/imageRescue.js

@@ -0,0 +1,686 @@
+import fs from "node:fs";
+import path from "node:path";
+import { loadProjectConfig } from "./projectConfig.js";
+import { createStdioPharoLauncherMcpClient, } from "./pharoLauncherMcpClient.js";
+import { HttpPharoMcpHealthClient, } from "./pharoMcpHealth.js";
+import { defaultProjectPortRange, defaultWorkspaceId, loadProjectState, projectStatePathForConfig, sanitizeRuntimeId, saveProjectState, } from "./projectState.js";
+import { writeImageStartupScript } from "./projectStartupScript.js";
+const defaultPoll = {
+    intervalMs: 500,
+    processTimeoutMs: 30_000,
+    healthTimeoutMs: 5 * 60_000,
+};
+export class ImageRescueError extends Error {
+    result;
+    constructor(message, result) {
+        super(message);
+        this.result = result;
+        this.name = "ImageRescueError";
+    }
+}
+function defaultSleep(durationMs) {
+    return new Promise((resolve) => setTimeout(resolve, durationMs));
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function launcherResultData(result) {
+    if (isObject(result) && "data" in result) {
+        const commandResult = result;
+        return commandResult.ok === false ? undefined : commandResult.data;
+    }
+    return result;
+}
+function assertLauncherOk(result, toolName) {
+    if (isObject(result) && result.ok === false) {
+        throw new Error(`${toolName} returned ok: false`);
+    }
+}
+function parseToolContent(value) {
+    if (!isObject(value)) {
+        return value;
+    }
+    const content = value.content;
+    if (!Array.isArray(content)) {
+        return value;
+    }
+    const textContent = content.find((item) => isObject(item) && item.type === "text" && typeof item.text === "string");
+    if (!textContent) {
+        return value;
+    }
+    try {
+        return JSON.parse(textContent.text);
+    }
+    catch {
+        return textContent.text;
+    }
+}
+function resultData(value) {
+    const parsed = parseToolContent(value);
+    if (isObject(parsed) && "data" in parsed) {
+        return parsed.data;
+    }
+    return parsed;
+}
+function nowStamp(now) {
+    return now().toISOString().replaceAll(/[:.]/g, "-");
+}
+function defaultTargetImageId(sourceImageId) {
+    return sanitizeRuntimeId(`${sourceImageId}-rescue`);
+}
+function defaultTargetImageName(sourceImageName, now) {
+    return `${sourceImageName}-rescue-${nowStamp(now).slice(0, 19)}`;
+}
+function processMatchesImage(process, imageName) {
+    return (process.imageName === imageName ||
+        path.basename(process.imagePath ?? "", ".image") === imageName ||
+        process.commandLine.includes(`${imageName}.image`) ||
+        process.commandLine.includes(imageName));
+}
+async function pollUntil(timeoutMs, intervalMs, sleep, producer) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt <= timeoutMs) {
+        const result = await producer();
+        if (result !== undefined) {
+            return result;
+        }
+        await sleep(intervalMs);
+    }
+    return undefined;
+}
+async function pollProcessForImage(client, imageName, timeoutMs, intervalMs, sleep) {
+    return pollUntil(timeoutMs, intervalMs, sleep, async () => {
+        const result = await client.callTool("pharo_launcher_process_list");
+        const processes = launcherResultData(result) ?? [];
+        return processes.find((process) => processMatchesImage(process, imageName));
+    });
+}
+async function launchImage(client, healthClient, imageState, startupScriptPath, poll, sleep) {
+    const launchResult = await client.callTool("pharo_launcher_image_launch", {
+        imageName: imageState.imageName,
+        detached: true,
+        script: startupScriptPath,
+    });
+    assertLauncherOk(launchResult, "pharo_launcher_image_launch");
+    const process = await pollProcessForImage(client, imageState.imageName, poll.processTimeoutMs, poll.intervalMs, sleep);
+    if (!process) {
+        throw new Error(`Timed out waiting for PharoLauncher process for image ${imageState.imageName}`);
+    }
+    const healthy = await pollUntil(poll.healthTimeoutMs, poll.intervalMs, sleep, async () => ((await healthClient.check(imageState.assignedPort)) ? true : undefined));
+    if (!healthy) {
+        throw new Error(`Timed out waiting for Pharo MCP health on port ${imageState.assignedPort}`);
+    }
+    return process.pid;
+}
+function resolveWorkspaceId(projectRoot, workspaceId) {
+    return workspaceId ? sanitizeRuntimeId(workspaceId) : defaultWorkspaceId(projectRoot);
+}
+function findImageState(state, imageId) {
+    const image = state.images.find((candidate) => candidate.id === imageId);
+    if (!image) {
+        throw new ImageRescueError(`Project state does not contain image id: ${imageId}`);
+    }
+    return image;
+}
+function findImageConfig(configImages, imageId) {
+    const image = configImages.find((candidate) => candidate.id === imageId);
+    if (!image) {
+        throw new ImageRescueError(`Project config does not contain image id: ${imageId}`);
+    }
+    return image;
+}
+function allocatePort(state, requestedPort, range) {
+    const usedPorts = new Set(state.images.map((image) => image.assignedPort));
+    if (requestedPort !== undefined) {
+        if (usedPorts.has(requestedPort)) {
+            throw new ImageRescueError(`Requested target MCP port is already used: ${requestedPort}`);
+        }
+        return requestedPort;
+    }
+    for (let port = range.start; port <= range.end; port += 1) {
+        if (!usedPorts.has(port)) {
+            return port;
+        }
+    }
+    throw new ImageRescueError(`No available port in range ${range.start}-${range.end}`);
+}
+function launcherImagesDirectory(configReport) {
+    return (configReport.profile?.imagesDir?.path ??
+        (configReport.launcherDir?.path
+            ? path.join(configReport.launcherDir.path, "images")
+            : undefined));
+}
+function resolveImagePaths(imageName, launcherImage, configReport) {
+    const rawImagePath = launcherImage?.imagePath;
+    const imagesDirectory = launcherImagesDirectory(configReport);
+    const imagePath = rawImagePath
+        ? path.isAbsolute(rawImagePath)
+            ? rawImagePath
+            : imagesDirectory
+                ? path.resolve(imagesDirectory, rawImagePath)
+                : path.resolve(rawImagePath)
+        : imagesDirectory
+            ? path.join(imagesDirectory, imageName, `${imageName}.image`)
+            : undefined;
+    const imageDirectoryPath = imagePath ? path.dirname(imagePath) : undefined;
+    const changesPath = imagePath
+        ? imagePath.replace(/\.image$/i, ".changes")
+        : undefined;
+    const localDirectoryPath = imageDirectoryPath
+        ? path.join(imageDirectoryPath, "pharo-local")
+        : undefined;
+    const ombuDirectoryPath = localDirectoryPath
+        ? path.join(localDirectoryPath, "ombu-sessions")
+        : undefined;
+    return {
+        ...(imagePath ? { imagePath } : {}),
+        ...(imageDirectoryPath ? { imageDirectoryPath } : {}),
+        ...(changesPath ? { changesPath } : {}),
+        ...(localDirectoryPath ? { localDirectoryPath } : {}),
+        ...(ombuDirectoryPath ? { ombuDirectoryPath } : {}),
+    };
+}
+async function launcherImageInfo(client, imageName) {
+    const result = await client.callTool("pharo_launcher_image_info", {
+        imageName,
+        format: "ston",
+    });
+    return launcherResultData(result);
+}
+async function launcherConfigReport(client) {
+    const result = await client.callTool("pharo_launcher_config");
+    return launcherResultData(result) ?? {};
+}
+async function snapshotRepositories(image, imageMcpClient, capturedAt) {
+    if (!imageMcpClient || image.status !== "running") {
+        return undefined;
+    }
+    try {
+        const result = await imageMcpClient.callTool(image, "find_repositories", {
+            limit: 1000,
+        });
+        const repositories = extractObjects(resultData(result));
+        return {
+            capturedAt,
+            status: "captured",
+            repositories,
+        };
+    }
+    catch (error) {
+        return {
+            capturedAt,
+            status: "unavailable",
+            repositories: [],
+            error: errorMessage(error),
+        };
+    }
+}
+function extractObjects(value) {
+    if (Array.isArray(value)) {
+        return value.filter(isObject);
+    }
+    if (isObject(value)) {
+        for (const key of ["repositories", "items", "entries", "data"]) {
+            const nested = value[key];
+            if (Array.isArray(nested)) {
+                return nested.filter(isObject);
+            }
+        }
+    }
+    return [];
+}
+function listOmbuFiles(directoryPath) {
+    if (!directoryPath || !fs.existsSync(directoryPath)) {
+        return [];
+    }
+    return fs
+        .readdirSync(directoryPath, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".ombu"))
+        .map((entry) => {
+        const filePath = path.join(directoryPath, entry.name);
+        const stat = fs.statSync(filePath);
+        return {
+            path: filePath,
+            mtimeMs: stat.mtimeMs,
+            size: stat.size,
+        };
+    })
+        .sort((a, b) => (b.mtimeMs ?? 0) - (a.mtimeMs ?? 0));
+}
+function selectionArguments(selection) {
+    if (!selection) {
+        return {};
+    }
+    return {
+        ...(selection.indexes ? { indexes: selection.indexes } : {}),
+        ...(selection.entryReferences
+            ? { entryReferences: selection.entryReferences }
+            : {}),
+        ...(selection.startIndex !== undefined ? { startIndex: selection.startIndex } : {}),
+        ...(selection.endIndex !== undefined ? { endIndex: selection.endIndex } : {}),
+        ...(selection.latestCount !== undefined ? { latestCount: selection.latestCount } : {}),
+    };
+}
+function extractIndexesFromEntries(value) {
+    const entries = extractObjects(value);
+    const indexes = entries
+        .map((entry) => entry.index)
+        .filter((index) => Number.isInteger(index));
+    return indexes;
+}
+function excludedIndexes(exclude) {
+    if (exclude?.latestCount !== undefined) {
+        throw new ImageRescueError("exclude.latestCount cannot be inverted safely yet; use indexes or ranges");
+    }
+    const indexes = new Set(exclude?.indexes ?? []);
+    if (exclude?.startIndex !== undefined && exclude.endIndex !== undefined) {
+        for (let index = exclude.startIndex; index <= exclude.endIndex; index += 1) {
+            indexes.add(index);
+        }
+    }
+    return indexes;
+}
+function selectedIndexes(selection, availableIndexes) {
+    if (!selection) {
+        return new Set(availableIndexes);
+    }
+    if (selection.entryReferences && selection.entryReferences.length > 0) {
+        throw new ImageRescueError("selection.entryReferences cannot be combined with exclude yet; use indexes or ranges");
+    }
+    if (selection.latestCount !== undefined) {
+        throw new ImageRescueError("selection.latestCount cannot be combined with exclude yet; use indexes or ranges");
+    }
+    const indexes = new Set(selection.indexes ?? availableIndexes);
+    if (selection.startIndex !== undefined || selection.endIndex !== undefined) {
+        const startIndex = selection.startIndex ?? Math.min(...availableIndexes);
+        const endIndex = selection.endIndex ?? Math.max(...availableIndexes);
+        for (const index of [...indexes]) {
+            if (index < startIndex || index > endIndex) {
+                indexes.delete(index);
+            }
+        }
+    }
+    return indexes;
+}
+async function resolveSelectionWithExclusions(imageMcpClient, targetImage, historyFilePath, selection, exclude, codeChangesOnly) {
+    if (!exclude) {
+        return selection;
+    }
+    if (exclude.entryReferences && exclude.entryReferences.length > 0) {
+        throw new ImageRescueError("exclude.entryReferences cannot be inverted safely yet; use indexes or ranges");
+    }
+    const listResult = await imageMcpClient.callTool(targetImage, "manage-change-history", {
+        operation: "listEntries",
+        historyFilePath,
+        codeChangesOnly,
+    });
+    const availableIndexes = extractIndexesFromEntries(resultData(listResult));
+    if (availableIndexes.length === 0) {
+        throw new ImageRescueError("Could not read entry indexes while applying exclusions");
+    }
+    const includeIndexes = selectedIndexes(selection, availableIndexes);
+    const excludes = excludedIndexes(exclude);
+    return {
+        indexes: [...includeIndexes].filter((index) => !excludes.has(index)),
+    };
+}
+function repositoryName(repository) {
+    const value = repository.name ?? repository.repositoryName;
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function repositoryLocation(repository) {
+    const value = repository.location ?? repository.directory;
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function repositorySubdirectory(repository) {
+    const value = repository.subdirectory;
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function repositoryPackageNames(repository) {
+    const value = repository.packageNames ?? repository.packages;
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string")
+        : undefined;
+}
+function defaultRepositoryActions(snapshot) {
+    if (!snapshot || snapshot.status !== "captured") {
+        return [];
+    }
+    return snapshot.repositories.flatMap((repository) => {
+        const name = repositoryName(repository);
+        const location = repositoryLocation(repository);
+        if (!name || !location) {
+            return [];
+        }
+        return [
+            {
+                label: `Register repository ${name}`,
+                toolName: "edit_repository",
+                arguments: {
+                    operation: "create",
+                    name,
+                    location,
+                    ...(repositorySubdirectory(repository)
+                        ? { subdirectory: repositorySubdirectory(repository) }
+                        : {}),
+                    ...(repositoryPackageNames(repository)
+                        ? { packageNames: repositoryPackageNames(repository) }
+                        : {}),
+                },
+            },
+        ];
+    });
+}
+async function runRepositoryActions(imageMcpClient, targetImage, actions, confirm) {
+    const results = [];
+    for (const action of actions) {
+        const toolName = action.toolName ?? "load_repository";
+        const label = action.label ?? toolName;
+        if (!confirm) {
+            results.push({
+                label,
+                toolName,
+                arguments: action.arguments,
+                status: "planned",
+            });
+            continue;
+        }
+        if (!imageMcpClient || !targetImage) {
+            results.push({
+                label,
+                toolName,
+                arguments: action.arguments,
+                status: "skipped",
+                error: "No target image MCP client is available",
+            });
+            continue;
+        }
+        try {
+            const result = await imageMcpClient.callTool(targetImage, toolName, action.arguments);
+            results.push({
+                label,
+                toolName,
+                arguments: action.arguments,
+                status: "applied",
+                result: resultData(result),
+            });
+        }
+        catch (error) {
+            results.push({
+                label,
+                toolName,
+                arguments: action.arguments,
+                status: "failed",
+                error: errorMessage(error),
+            });
+        }
+    }
+    return results;
+}
+function selectedHistoryFile(historyFilePath, historyFiles) {
+    return historyFilePath ?? historyFiles[0]?.path;
+}
+async function listHistoryFilesThroughImage(imageMcpClient, image, directoryPath, includeEntryCounts) {
+    if (!imageMcpClient || !image || image.status !== "running" || !directoryPath) {
+        return undefined;
+    }
+    const result = await imageMcpClient.callTool(image, "manage-change-history", {
+        operation: "listFiles",
+        directoryPath,
+        includeEntryCounts,
+    });
+    return resultData(result);
+}
+async function applyHistoryEntries(imageMcpClient, targetImage, historyFilePath, selection, exclude, codeChangesOnly, confirm) {
+    if (!historyFilePath) {
+        return undefined;
+    }
+    let resolvedSelection = selection;
+    if (imageMcpClient && targetImage) {
+        resolvedSelection = await resolveSelectionWithExclusions(imageMcpClient, targetImage, historyFilePath, selection, exclude, codeChangesOnly);
+    }
+    const argumentsValue = {
+        operation: "applyEntries",
+        historyFilePath,
+        codeChangesOnly,
+        confirm,
+        ...selectionArguments(resolvedSelection),
+    };
+    if (!confirm) {
+        return {
+            historyFilePath,
+            arguments: argumentsValue,
+            status: "planned",
+        };
+    }
+    if (!imageMcpClient || !targetImage) {
+        throw new ImageRescueError("A running target image is required to apply history entries");
+    }
+    try {
+        const result = await imageMcpClient.callTool(targetImage, "manage-change-history", argumentsValue);
+        return {
+            historyFilePath,
+            arguments: argumentsValue,
+            status: "applied",
+            result: resultData(result),
+        };
+    }
+    catch (error) {
+        return {
+            historyFilePath,
+            arguments: argumentsValue,
+            status: "failed",
+            error: errorMessage(error),
+            failureClass: "apply-time-breaker",
+        };
+    }
+}
+function updateImageMetadata(image, snapshot) {
+    image.imagePath = snapshot.paths.imagePath;
+    image.imageDirectoryPath = snapshot.paths.imageDirectoryPath;
+    image.changesPath = snapshot.paths.changesPath;
+    image.localDirectoryPath = snapshot.paths.localDirectoryPath;
+    image.ombuDirectoryPath = snapshot.paths.ombuDirectoryPath;
+    image.vmId = snapshot.launcherImage?.vmId;
+    image.pharoVersion = snapshot.launcherImage?.pharoVersion;
+    image.originTemplate = snapshot.launcherImage?.originTemplate;
+    image.rescueSnapshot = snapshot;
+}
+function targetConfigFromSource(sourceConfig, targetImageId, targetImageName, targetPort) {
+    return {
+        ...sourceConfig,
+        id: targetImageId,
+        imageName: targetImageName,
+        active: true,
+        mcp: {
+            ...sourceConfig.mcp,
+            port: targetPort,
+        },
+    };
+}
+async function createTargetImage(client, targetImageName, templateName, templateCategory) {
+    const result = await client.callTool("pharo_launcher_image_create", {
+        newImageName: targetImageName,
+        templateName,
+        ...(templateCategory ? { templateCategory } : {}),
+        noLaunch: true,
+    });
+    assertLauncherOk(result, "pharo_launcher_image_create");
+}
+export async function rescueImage(options) {
+    const projectRoot = path.resolve(options.projectRoot);
+    const config = loadProjectConfig(projectRoot);
+    const workspaceId = resolveWorkspaceId(projectRoot, options.workspaceId);
+    const statePath = projectStatePathForConfig({
+        projectRoot,
+        config,
+        workspaceId,
+        stateRoot: options.stateRoot,
+    });
+    const state = loadProjectState(statePath);
+    if (!state) {
+        throw new ImageRescueError(`No PLexus runtime state found at ${statePath}`);
+    }
+    const now = options.now ?? (() => new Date());
+    const capturedAt = now().toISOString();
+    const sourceImage = findImageState(state, options.sourceImageId);
+    const sourceConfig = findImageConfig(config.images, options.sourceImageId);
+    const launcherClient = options.pharoLauncherMcpClient ??
+        (await createStdioPharoLauncherMcpClient());
+    const ownsLauncherClient = !options.pharoLauncherMcpClient;
+    const warnings = [];
+    try {
+        const [configReport, launcherImage] = await Promise.all([
+            launcherConfigReport(launcherClient),
+            launcherImageInfo(launcherClient, sourceImage.imageName),
+        ]);
+        const paths = resolveImagePaths(sourceImage.imageName, launcherImage, configReport);
+        const repositorySnapshot = (await snapshotRepositories(sourceImage, options.imageMcpClient, capturedAt)) ?? sourceImage.rescueSnapshot?.repositories;
+        const sourceSnapshot = {
+            capturedAt,
+            ...(launcherImage ? { launcherImage } : {}),
+            paths,
+            ...(repositorySnapshot ? { repositories: repositorySnapshot } : {}),
+        };
+        const historyDirectoryPath = options.sourceHistoryDirectoryPath ?? paths.ombuDirectoryPath;
+        const historyFiles = listOmbuFiles(historyDirectoryPath);
+        const selectedHistoryFilePath = selectedHistoryFile(options.historyFilePath, historyFiles);
+        const targetImageId = options.targetImageId ?? defaultTargetImageId(options.sourceImageId);
+        let targetImage = state.images.find((image) => image.id === targetImageId);
+        let historyListing;
+        if (options.operation === "plan" && options.includeEntryCounts) {
+            const historyReader = targetImage?.status === "running" ? targetImage : sourceImage;
+            try {
+                historyListing = await listHistoryFilesThroughImage(options.imageMcpClient, historyReader, historyDirectoryPath, options.includeEntryCounts);
+            }
+            catch (error) {
+                warnings.push(`Could not list history files through Pharo: ${errorMessage(error)}`);
+            }
+        }
+        if ((options.operation === "snapshotSource" || options.operation === "prepareTarget") &&
+            repositorySnapshot?.status === "unavailable") {
+            warnings.push(`Repository snapshot is unavailable: ${repositorySnapshot.error ?? "unknown error"}`);
+        }
+        if (options.operation === "snapshotSource") {
+            updateImageMetadata(sourceImage, sourceSnapshot);
+            state.updatedAt = capturedAt;
+            saveProjectState(statePath, state);
+            return {
+                ok: true,
+                operation: options.operation,
+                projectRoot,
+                statePath,
+                state,
+                sourceImage,
+                sourceSnapshot,
+                historyDirectoryPath,
+                historyFiles,
+                historyListing,
+                selectedHistoryFilePath,
+                warnings,
+            };
+        }
+        if (options.operation === "prepareTarget") {
+            if (targetImage) {
+                throw new ImageRescueError(`Target image id already exists: ${targetImageId}`);
+            }
+            const targetImageName = options.targetImageName ??
+                defaultTargetImageName(sourceImage.imageName, now);
+            const templateName = options.targetTemplateName ?? launcherImage?.originTemplate?.name;
+            if (!templateName) {
+                throw new ImageRescueError("targetTemplateName is required because the source image origin template is unknown");
+            }
+            await createTargetImage(launcherClient, targetImageName, templateName, options.targetTemplateCategory);
+            const assignedPort = allocatePort(state, options.targetMcpPort, options.portRange ?? defaultProjectPortRange);
+            targetImage = {
+                id: targetImageId,
+                imageName: targetImageName,
+                assignedPort,
+                status: "starting",
+            };
+            state.images.push(targetImage);
+            updateImageMetadata(sourceImage, sourceSnapshot);
+            state.updatedAt = capturedAt;
+            saveProjectState(statePath, state);
+            const targetConfig = targetConfigFromSource(sourceConfig, targetImageId, targetImageName, assignedPort);
+            const startupScript = writeImageStartupScript({
+                projectRoot,
+                projectId: config.kanban.projectId,
+                workspaceId,
+                stateRoot: options.stateRoot,
+                imageConfig: targetConfig,
+                imageState: targetImage,
+            });
+            const poll = {
+                ...defaultPoll,
+                ...options.poll,
+            };
+            try {
+                const pid = await launchImage(launcherClient, options.healthClient ?? new HttpPharoMcpHealthClient(), targetImage, startupScript.filePath, poll, options.sleep ?? defaultSleep);
+                targetImage.pid = pid;
+                targetImage.status = "running";
+                state.updatedAt = now().toISOString();
+                saveProjectState(statePath, state);
+            }
+            catch (error) {
+                targetImage.status = "failed";
+                state.updatedAt = now().toISOString();
+                saveProjectState(statePath, state);
+                throw error;
+            }
+        }
+        if (options.operation === "applyPlan") {
+            if (!targetImage) {
+                throw new ImageRescueError(`Target image id is not in runtime state: ${targetImageId}`);
+            }
+            const actionSource = options.repositoryActions ??
+                ((options.loadRepositories ?? true)
+                    ? defaultRepositoryActions(repositorySnapshot)
+                    : []);
+            const repositoryResults = await runRepositoryActions(options.imageMcpClient, targetImage, actionSource, options.confirm === true);
+            const changeResult = await applyHistoryEntries(options.imageMcpClient, targetImage, selectedHistoryFilePath, options.selection, options.exclude, options.codeChangesOnly ?? true, options.confirm === true);
+            return {
+                ok: repositoryResults.every((repository) => repository.status !== "failed") &&
+                    changeResult?.status !== "failed",
+                operation: options.operation,
+                projectRoot,
+                statePath,
+                state,
+                sourceImage,
+                targetImage,
+                sourceSnapshot,
+                historyDirectoryPath,
+                historyFiles,
+                historyListing,
+                selectedHistoryFilePath,
+                repositoryResults,
+                changeResult,
+                warnings,
+            };
+        }
+        return {
+            ok: true,
+            operation: options.operation,
+            projectRoot,
+            statePath,
+            state,
+            sourceImage,
+            targetImage,
+            sourceSnapshot,
+            historyDirectoryPath,
+            historyFiles,
+            historyListing,
+            selectedHistoryFilePath,
+            warnings,
+        };
+    }
+    finally {
+        if (ownsLauncherClient) {
+            await launcherClient.close?.();
+        }
+    }
+}
+//# sourceMappingURL=imageRescue.js.map