devchain-cli 0.24.0 → 0.24.2

package/dist/server/modules/remotes/docker/docker-handoff.js

@@ -13,15 +13,18 @@ exports.DockerHandoff = void 0;
 exports.dockerSelection = dockerSelection;
 exports.buildRecord = buildRecord;
 exports.captureSettings = captureSettings;
+const docker_project_compose_1 = require("./docker-project-compose");
 const docker_data_groups_1 = require("./docker-data-groups");
 const common_1 = require("@nestjs/common");
 const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
 const node_stream_1 = require("node:stream");
-const promises_1 = require("node:stream/promises");
+const promises_2 = require("node:stream/promises");
 const error_types_1 = require("../../../common/errors/error-types");
 const logger_1 = require("../../../common/logging/logger");
 const docker_archive_journal_1 = require("../../core/controllers/docker-archive-journal");
 const docker_archive_1 = require("../../core/controllers/docker-archive");
+const docker_image_metadata_1 = require("../../core/controllers/docker-image-metadata");
 const docker_engine_client_1 = require("../../core/controllers/docker-engine.client");
 const docker_settings_1 = require("../../core/controllers/docker-settings");
 const file_sync_dto_1 = require("../../file-sync/file-sync.dto");
@@ -30,16 +33,17 @@ const docker_import_inventory_store_1 = require("../operations/docker-import-inv
 const remote_host_client_1 = require("../operations/remote-host.client");
 const remote_operation_errors_1 = require("../operations/remote-operation.errors");
 const remote_operation_types_1 = require("../operations/remote-operation.types");
+const host_docker_dto_1 = require("../host/host-docker.dto");
 const docker_plan_fit_1 = require("./docker-plan-fit");
 const docker_plan_files_1 = require("./docker-plan-files");
 const docker_plan_dto_1 = require("./docker-plan.dto");
 const docker_plan_policy_1 = require("./docker-plan-policy");
 const docker_plan_service_1 = require("./docker-plan.service");
+const connect_choices_store_1 = require("../connect-choices.store");
 const docker_plan_source_service_1 = require("./docker-plan-source.service");
 const docker_handoff_store_1 = require("./docker-handoff.store");
 const logger = (0, logger_1.createLogger)('DockerHandoff');
 const RATE_WARMUP_MS = 5_000;
-const DEFAULT_NETWORKS = new Set(['bridge', 'host', 'none', 'default']);
 function dockerSelection(details) {
     const selection = details.dockerSelection;
     return selection?.items?.length ? selection : null;
@@ -69,9 +73,10 @@ let DockerHandoff = class DockerHandoff {
     journal;
     exclusions;
     inventory;
+    choices;
     active = new Map();
     rollbackLimits = { vmCleanupMs: 10 * 60_000, homeConnectMs: 30_000, homeStartMs: 60_000 };
-    constructor(plans, source, host, store, journal, exclusions, inventory) {
+    constructor(plans, source, host, store, journal, exclusions, inventory, choices) {
         this.plans = plans;
         this.source = source;
         this.host = host;
@@ -79,6 +84,7 @@ let DockerHandoff = class DockerHandoff {
         this.journal = journal;
         this.exclusions = exclusions;
         this.inventory = inventory;
+        this.choices = choices;
     }
     interrupt(operationId) {
         this.active.get(operationId)?.abort();
@@ -92,6 +98,7 @@ let DockerHandoff = class DockerHandoff {
             const plan = await this.plans.plan(projectId, { remoteId: run.operation.remoteId, items: selection.items }, signal, { estimate: false });
             if (!plan.availability.available || !plan.apiVersion)
                 throw new remote_operation_errors_1.RemoteOperationStepRefusedError('DOCKER_PLAN_REFUSED', plan.availability.reason?.message ?? 'Docker is unavailable.', { reason: plan.availability.reason?.code ?? null });
+            this.choices.recordPlan(projectId, run.operation.remoteId, plan.items);
             const selected = plan.items.filter((item) => item.selectedMode);
             if (!plan.canConnect) {
                 const reasons = [
@@ -104,20 +111,18 @@ let DockerHandoff = class DockerHandoff {
                 ];
                 throw new remote_operation_errors_1.RemoteOperationStepRefusedError('DOCKER_PLAN_REFUSED', reasons.join(' ') || 'The Docker import cannot proceed.', { fit: plan.fit });
             }
-            const record = buildRecord(plan.items, selected, plan.apiVersion, await this.plans.projectRoot(projectId));
+            const record = buildRecord(plan.items, selected, plan.apiVersion, await this.plans.projectRoot(projectId), plan.networks);
             const previousRecord = await this.store.read(run.operation.id);
             record.inventoryBefore =
                 previousRecord?.inventoryBefore !== undefined
                     ? previousRecord.inventoryBefore
                     : this.inventory.get(projectId, run.operation.remoteId);
-            const managed = [
-                ...new Set([
-                    ...plan.managedExclusions,
-                    ...(this.inventory
-                        .get(projectId, run.operation.remoteId)
-                        ?.items.flatMap((item) => item.bindPaths) ?? []),
-                ]),
-            ];
+            for (const kept of record.keptInventory ?? []) {
+                const prior = record.inventoryBefore?.items.find((item) => item.name === kept.name);
+                if (prior?.vmImageId && prior.imageId === kept.imageId)
+                    kept.vmImageId = prior.vmImageId;
+            }
+            const managed = (0, docker_import_inventory_store_1.connectExclusions)(plan, this.inventory.get(projectId, run.operation.remoteId));
             if (managed.length > file_sync_dto_1.IGNORE_PATTERNS_MAX)
                 throw new remote_operation_errors_1.RemoteOperationStepRefusedError('DOCKER_TOO_MANY_DATA_FOLDERS', `The Docker data folders need ${managed.length} file-sync exclusions; at most ${file_sync_dto_1.IGNORE_PATTERNS_MAX} are supported.`, { count: managed.length });
             await this.store.write(run.operation.id, record);
@@ -187,20 +192,69 @@ let DockerHandoff = class DockerHandoff {
             const progress = new TransferProgress(run, record);
             await this.journal.reconcile(client, signal);
             const pendingImages = record.images.filter((i) => !record.verified.images.includes(i.id));
+            const candidates = new Map(pendingImages.map((image) => [
+                image.id,
+                (0, docker_import_inventory_store_1.vmImageCandidates)(record.inventoryBefore, image.id),
+            ]));
             const present = pendingImages.length
-                ? (await this.host.dockerImagesPresent(remoteId, pendingImages.map((i) => i.id), options)).ids
+                ? (await this.host.dockerImagesPresent(remoteId, [...new Set([...candidates.values()].flat())], options)).ids
                 : [];
+            const verify = async (image, vmId) => {
+                image.vmId = vmId;
+                record.verified.images.push(image.id);
+                await this.store.write(run.operation.id, record);
+            };
+            let matchUnsupported = false;
+            const missing = [];
             for (const image of pendingImages) {
+                let vmId = candidates.get(image.id).find((id) => present.includes(id));
+                if (!vmId) {
+                    const inspect = await client.json('GET', `/images/${encodeURIComponent(image.id)}/json`, undefined, { signal });
+                    const tags = inspect.RepoTags;
+                    if (tags?.length && !matchUnsupported) {
+                        try {
+                            const { images } = await this.host.dockerMatchImages(remoteId, tags, options);
+                            vmId = (0, docker_image_metadata_1.vmImageIdForTags)(inspect, tags, images);
+                        }
+                        catch (error) {
+                            if (!(error instanceof remote_host_client_1.RemoteHostRequestError && error.status === 404))
+                                throw error;
+                            matchUnsupported = true;
+                        }
+                    }
+                    if (!vmId) {
+                        missing.push({ image, tags: tags ?? [], layers: inspect.RootFS?.Layers ?? null });
+                        continue;
+                    }
+                }
                 progress.item(image.id, 'image', image.sizeBytes);
-                if (!present.includes(image.id)) {
+                await verify(image, vmId);
+                progress.complete();
+            }
+            let supportsReferences = true;
+            for (const group of groupImages(missing)) {
+                progress.item(group.length === 1 ? group[0].image.id : `${group.length} images`, 'image', group.reduce((total, entry) => total + entry.image.sizeBytes, 0));
+                if (group.length > 1 && supportsReferences) {
+                    const archive = await saveImages(client, group.flatMap((entry) => entry.tags), signal);
+                    const loaded = await this.host.dockerLoadImage(remoteId, progress.count(archive), options);
+                    supportsReferences = hasReferences(loaded);
+                    if (supportsReferences) {
+                        const vmIds = group.map((entry) => loadedVmId(entry.image.id, entry.layers, loaded.images, entry.tags));
+                        for (const [index, entry] of group.entries()) {
+                            entry.image.vmId = vmIds[index];
+                            record.verified.images.push(entry.image.id);
+                        }
+                        await this.store.write(run.operation.id, record);
+                        progress.complete();
+                        continue;
+                    }
+                }
+                for (const { image } of group) {
                     const saved = await saveImage(client, image.id, signal);
-                    await this.host.dockerLoadImage(remoteId, progress.count(saved), options);
-                    const loaded = await this.host.dockerImagesPresent(remoteId, [image.id], options);
-                    if (!loaded.ids.includes(image.id))
-                        throw new DockerHandoffError('The VM did not load an image with the expected ID.');
+                    const loaded = await this.host.dockerLoadImage(remoteId, progress.count(saved.archive), options);
+                    supportsReferences &&= hasReferences(loaded);
+                    await verify(image, loadedVmId(image.id, saved.layers, loaded.images));
                 }
-                record.verified.images.push(image.id);
-                await this.store.write(run.operation.id, record);
                 progress.complete();
             }
             const presentKeptVolumes = record.ensureVolumes?.length
@@ -239,7 +293,7 @@ let DockerHandoff = class DockerHandoff {
                 await this.store.write(run.operation.id, record);
                 await this.host.dockerCreateVolume(remoteId, { projectId, name: volume.name, labels }, options);
                 if (restore) {
-                    await this.copy(client, progress, remoteId, { projectId, image: volume.helperImage, mountType: 'volume', source: volume.name }, options);
+                    await this.copy(client, progress, remoteId, { projectId, image: volume.helperImage, mountType: 'volume', source: volume.name }, vmImageId(record, volume.helperImage), options);
                     (record.copiedData ??= { volumes: [], binds: [] }).volumes.push(volume.name);
                 }
                 record.verified.volumes.push(volume.name);
@@ -265,17 +319,42 @@ let DockerHandoff = class DockerHandoff {
                         .map((path) => ({ path, replace: false })),
                 }, options);
             const binds = record.binds.filter((b) => !record.verified.binds.includes(b.path));
+            const files = new Set();
+            for (const bind of binds)
+                if (await isFile(bind.path))
+                    files.add(bind.path);
+            const fileFlag = (path) => (files.has(path) ? { file: true } : {});
             const created = binds.filter((b) => !b.replace);
             for (let offset = 0; offset < created.length; offset += 64)
                 await this.host.dockerPrepareBinds(remoteId, {
                     projectId,
                     paths: created
                         .slice(offset, offset + 64)
-                        .map((b) => ({ path: b.path, replace: false })),
+                        .map((b) => ({ path: b.path, replace: false, ...fileFlag(b.path) })),
                 }, options);
             for (const bind of binds.filter((b) => b.replace)) {
                 try {
-                    await this.host.dockerPrepareBinds(remoteId, { projectId, paths: [{ path: bind.path, replace: true, image: bind.helperImage }] }, options);
+                    const vm = await this.host.dockerScan(remoteId, [bind.path], options, []);
+                    for (const holder of vm.containers)
+                        if ((0, docker_data_groups_1.overlapsData)((0, docker_data_groups_1.mountedData)(holder.mounts), { volumes: [], bindPaths: [bind.path] }) &&
+                            (holder.labels[host_docker_dto_1.DOCKER_PROJECT_LABEL] === projectId ||
+                                (0, docker_project_compose_1.projectCompose)(holder.labels, record.projectRoot, projectId)) &&
+                            holder.metadata?.running !== false)
+                            await this.host.dockerStopContainer(remoteId, holder.id, projectId, {
+                                ...options,
+                                projectRoot: record.projectRoot,
+                            });
+                    await this.host.dockerPrepareBinds(remoteId, {
+                        projectId,
+                        paths: [
+                            {
+                                path: bind.path,
+                                replace: true,
+                                image: vmImageId(record, bind.helperImage),
+                                ...fileFlag(bind.path),
+                            },
+                        ],
+                    }, options);
                 }
                 catch (error) {
                     if (!(error instanceof remote_host_client_1.RemoteHostRequestError) || error.status !== 422)
@@ -285,28 +364,51 @@ let DockerHandoff = class DockerHandoff {
             }
             for (const bind of binds) {
                 progress.item(bind.path, 'bind', bind.sizeBytes);
-                await this.copy(client, progress, remoteId, { projectId, image: bind.helperImage, mountType: 'bind', source: bind.path }, options);
+                await this.copy(client, progress, remoteId, {
+                    projectId,
+                    image: bind.helperImage,
+                    mountType: files.has(bind.path) ? 'file' : 'bind',
+                    source: bind.path,
+                }, vmImageId(record, bind.helperImage), options);
                 (record.copiedData ??= { volumes: [], binds: [] }).binds.push(bind.path);
                 record.verified.binds.push(bind.path);
                 await this.store.write(run.operation.id, record);
                 progress.complete();
             }
-            for (const network of record.networks) {
+            const settings = await this.store.readSettings(run.operation.id);
+            const automaticNetworks = new Set(record.automaticRangeNetworks);
+            const networks = record.networks
+                .map((network) => ({
+                ...network,
+                ipam: automaticNetworks.has(network.name) ? undefined : network.ipam,
+            }))
+                .sort((a, b) => Number(!!b.ipam) - Number(!!a.ipam));
+            for (const network of networks) {
                 progress.item(network.name, 'network');
-                const { created } = await this.host.dockerCreateNetwork(remoteId, {
-                    projectId,
-                    name: network.name,
-                    labels: network.labels,
-                    internal: network.internal,
-                    attachable: network.attachable,
-                    options: network.options,
-                }, options);
-                if (created && !record.created.networks.includes(network.name)) {
+                const shared = !network.labels[host_docker_dto_1.COMPOSE_PROJECT_LABEL];
+                let created;
+                try {
+                    ({ created } = await this.host.dockerCreateNetwork(remoteId, {
+                        projectId,
+                        name: network.name,
+                        labels: network.labels,
+                        internal: network.internal,
+                        attachable: network.attachable,
+                        options: network.options,
+                        ...(network.ipam ? { ipam: network.ipam } : {}),
+                        ...(shared ? { shared: true } : {}),
+                    }, options));
+                }
+                catch (error) {
+                    if (!(error instanceof error_types_1.AppError))
+                        throw error;
+                    throw new DockerHandoffError(`Network ${network.name}: ${error.message}`, error.code);
+                }
+                if (created && !shared && !record.created.networks.includes(network.name)) {
                     record.created.networks.push(network.name);
                     await this.store.write(run.operation.id, record);
                 }
             }
-            const settings = await this.store.readSettings(run.operation.id);
             for (const item of record.items.filter((i) => i.createsContainer)) {
                 if (record.verified.containers.includes(item.name))
                     continue;
@@ -315,20 +417,35 @@ let DockerHandoff = class DockerHandoff {
                     throw new DockerHandoffError(`The captured settings of ${item.name} are missing.`);
                 progress.item(item.name, 'container');
                 if (item.targetAction === 'replace' || record.created.containers.includes(item.name))
-                    await this.deleteIfPresent(remoteId, 'containers', item.name, projectId, options);
+                    await this.deleteIfPresent(remoteId, 'containers', item.name, projectId, {
+                        ...options,
+                        projectRoot: record.projectRoot,
+                    });
                 record.created.containers.push(item.name);
                 await this.store.write(run.operation.id, record);
-                await this.host.dockerCreateContainer(remoteId, { projectId, name: item.name, config: captured.config }, options);
+                await this.host.dockerCreateContainer(remoteId, {
+                    projectId,
+                    name: item.name,
+                    config: {
+                        ...captured.config,
+                        Image: vmImageId(record, String(captured.config.Image)),
+                    },
+                }, options);
                 record.verified.containers.push(item.name);
                 await this.store.write(run.operation.id, record);
             }
             await progress.finish();
+            const vmPair = (imageId, carried) => {
+                const vmId = record.images.find((i) => i.id === imageId)?.vmId ?? carried;
+                return vmId && vmId !== imageId ? { vmImageId: vmId } : {};
+            };
             const imported = record.items
                 .filter((item) => item.targetAction !== 'leave-as-is' &&
                 !record.keptInventory?.some((kept) => kept.name === item.name))
                 .map((item) => ({
                 name: item.name,
                 imageId: item.imageIds[0] ?? item.id,
+                ...vmPair(item.imageIds[0] ?? item.id),
                 volumes: item.volumes.map((name) => ({
                     name,
                     sizeBytes: record.volumes.find((v) => v.name === name)?.sizeBytes ?? null,
@@ -338,7 +455,10 @@ let DockerHandoff = class DockerHandoff {
                     .map((path) => (0, docker_plan_files_1.projectAnchoredPath)(record.projectRoot, path)),
                 sizeBytes: item.sizeBytes,
             }));
-            imported.push(...(record.keptInventory ?? []));
+            imported.push(...(record.keptInventory ?? []).map(({ vmImageId: carried, ...item }) => ({
+                ...item,
+                ...vmPair(item.imageId, carried),
+            })));
             const kept = (this.inventory.get(projectId, remoteId)?.items ?? []).filter((prior) => !imported.some((item) => item.name === prior.name));
             record.inventoryStampedAt ??= new Date().toISOString();
             if (record.inventoryBefore === undefined)
@@ -487,7 +607,10 @@ let DockerHandoff = class DockerHandoff {
         const { holders } = await this.host.dockerVolumeHolders(remoteId, volume.name, options);
         for (const holder of holders) {
             try {
-                await this.host.dockerDelete(remoteId, 'containers', holder.id, projectId, options);
+                await this.host.dockerDelete(remoteId, 'containers', holder.id, projectId, {
+                    ...options,
+                    projectRoot: record.projectRoot,
+                });
             }
             catch (error) {
                 if (notFound(error))
@@ -516,13 +639,14 @@ let DockerHandoff = class DockerHandoff {
             return false;
         }
     }
-    async copy(client, progress, remoteId, request, options) {
-        const helper = await this.journal.create(client, request.image, [{ Type: request.mountType, Source: request.source, Target: '/data', ReadOnly: true }], options.signal);
+    async copy(client, progress, remoteId, request, vmImage, options) {
+        const layout = (0, docker_archive_1.dockerArchiveLayout)(request.mountType, request.source);
+        const helper = await this.journal.create(client, request.image, [{ ...layout.mount, ReadOnly: true }], options.signal);
         try {
-            const archive = await (0, docker_archive_1.readDockerArchive)(client, helper.id, options.signal);
+            const archive = await (0, docker_archive_1.readDockerArchive)(client, helper.id, options.signal, layout.readPath);
             const hash = (0, node_crypto_1.createHash)('sha256');
             const body = progress.count(archive, (chunk) => hash.update(chunk));
-            const { sha256 } = await this.host.dockerWriteArchive(remoteId, request, body, options);
+            const { sha256 } = await this.host.dockerWriteArchive(remoteId, { ...request, image: vmImage }, body, options);
             if (sha256 !== hash.digest('hex'))
                 throw new DockerHandoffError('The copied data did not match on the VM; retry the copy.');
         }
@@ -540,12 +664,16 @@ exports.DockerHandoff = DockerHandoff = __decorate([
         docker_handoff_store_1.DockerHandoffStore,
         docker_archive_journal_1.DockerArchiveJournal,
         file_sync_managed_exclusions_store_1.FileSyncManagedExclusionsStore,
-        docker_import_inventory_store_1.DockerImportInventoryStore])
+        docker_import_inventory_store_1.DockerImportInventoryStore,
+        connect_choices_store_1.ConnectChoicesStore])
 ], DockerHandoff);
-function buildRecord(all, selected, apiVersion, projectRoot) {
+function buildRecord(all, selected, apiVersion, projectRoot, networks = []) {
     const moving = selected.filter(docker_plan_fit_1.movesToVm);
+    const copiedImages = selected
+        .filter((item) => (0, docker_plan_fit_1.copiesImages)(item, projectRoot))
+        .flatMap((item) => item.images);
     const helperImage = (item) => {
-        const image = item.images[0]?.id ?? moving.flatMap((i) => i.images)[0]?.id;
+        const image = item.images[0]?.id ?? copiedImages[0]?.id;
         if (!image)
             throw new remote_operation_errors_1.RemoteOperationStepRefusedError('DOCKER_PLAN_REFUSED', `${item.name}: no local image is available to copy its data.`);
         return image;
@@ -572,7 +700,10 @@ function buildRecord(all, selected, apiVersion, projectRoot) {
         for (const name of emptyVolumes(item))
             if (!volumes.some((v) => v.name === name))
                 volumes.push({ name, helperImage: helperImage(item), sizeBytes: 0 });
-    const images = [...new Map(moving.flatMap((i) => i.images).map((i) => [i.id, i])).values()].map((image) => ({ id: image.id, sizeBytes: image.size.bytes }));
+    const images = [...new Map(copiedImages.map((i) => [i.id, i])).values()].map((image) => ({
+        id: image.id,
+        sizeBytes: image.size.bytes,
+    }));
     const containerIds = new Set(all.filter((i) => i.kind === 'container').map((i) => i.id));
     const stopIds = new Set();
     for (const item of moving) {
@@ -644,6 +775,9 @@ function buildRecord(all, selected, apiVersion, projectRoot) {
         stopIds: [...stopIds],
         stopped: [],
         networks: [],
+        automaticRangeNetworks: networks
+            .filter((network) => network.kind === 'automatic-range')
+            .map((network) => network.name),
         verified: { images: [], volumes: [], binds: [], containers: [] },
         created: { volumes: [], networks: [], containers: [] },
         replaced: [],
@@ -702,32 +836,66 @@ function captureSettings(inspect, name, socketPath) {
         host.Mounts = mounts;
     return { name, config };
 }
+function endpoints(config) {
+    return (config?.NetworkingConfig
+        ?.EndpointsConfig ?? {});
+}
 function networkNames(config) {
-    const endpoints = config.NetworkingConfig
-        ?.EndpointsConfig;
-    return Object.keys(endpoints ?? {}).filter((name) => !DEFAULT_NETWORKS.has(name));
+    return Object.keys(endpoints(config)).filter((name) => !docker_settings_1.DEFAULT_NETWORKS.has(name));
 }
 async function homeNetwork(client, name, signal) {
     const network = await client.json('GET', `/networks/${encodeURIComponent(name)}`, undefined, { signal });
     if (network.Driver !== 'bridge')
         throw new remote_operation_errors_1.RemoteOperationStepRefusedError('DOCKER_PLAN_REFUSED', `Network ${name} uses the ${network.Driver} driver; only bridge networks move.`);
+    const ranges = (0, docker_settings_1.ipv4Ranges)(network.IPAM?.Config);
     return {
         name,
         labels: network.Labels ?? {},
         internal: network.Internal === true,
         attachable: network.Attachable === true,
         options: network.Options ?? {},
+        ...(ranges.length ? { ipam: { Config: ranges } } : {}),
     };
 }
 async function homeVolumeLabels(client, name, signal) {
     const volume = await client.json('GET', `/volumes/${encodeURIComponent(name)}`, undefined, { signal });
     return volume.Labels ?? {};
 }
+function groupImages(images) {
+    const groups = new Map();
+    for (const image of images) {
+        const key = image.tags.length && image.layers ? JSON.stringify(image.layers) : image.image.id;
+        groups.set(key, [...(groups.get(key) ?? []), image]);
+    }
+    return [...groups.values()];
+}
+const hasReferences = (loaded) => loaded.images.every((image) => image.references !== undefined);
+function saveImages(client, names, signal) {
+    const query = [...new Set(names)].map((name) => `names=${encodeURIComponent(name)}`).join('&');
+    return client.stream('GET', `/images/get?${query}`, { signal });
+}
 async function saveImage(client, id, signal) {
     const image = await client.json('GET', `/images/${encodeURIComponent(id)}/json`, undefined, { signal });
     const names = image.RepoTags?.length ? image.RepoTags : [id];
-    const query = names.map((n) => `names=${encodeURIComponent(n)}`).join('&');
-    return client.stream('GET', `/images/get?${query}`, { signal });
+    return {
+        archive: await saveImages(client, names, signal),
+        layers: image.RootFS?.Layers ?? [],
+    };
+}
+function loadedVmId(homeId, homeLayers, reported, tags) {
+    const matches = reported.filter((image) => (tags === undefined || image.references?.some((reference) => tags.includes(reference))) &&
+        image.layers.length === homeLayers.length &&
+        image.layers.every((layer, index) => layer === homeLayers[index]));
+    const match = matches.find((image) => image.id === homeId) ?? matches[0];
+    if (!match)
+        throw new DockerHandoffError(`The VM loaded image ${homeId}, but none of the images it reported (${reported.map((i) => i.id).join(', ') || 'none'}) has the same layers. The VM engine can store images under its own IDs. Retry the copy.`);
+    return match.id;
+}
+function isFile(path) {
+    return (0, promises_1.stat)(path).then((stats) => stats.isFile(), () => false);
+}
+function vmImageId(record, homeId) {
+    return record.images.find((image) => image.id === homeId)?.vmId ?? homeId;
 }
 class TransferProgress {
     run;
@@ -770,7 +938,7 @@ class TransferProgress {
                 callback(null, chunk);
             },
         });
-        (0, promises_1.pipeline)(source, counter).catch(() => undefined);
+        (0, promises_2.pipeline)(source, counter).catch(() => undefined);
         return counter;
     }
     async finish() {