@ai-agent-forge/agent-forge 0.85.0

package/dist/plugins/ecosystem/node-package-install-host.js

@@ -0,0 +1,857 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, mkdtemp, rename, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { inflateRawSync } from "node:zlib";
+import { parseCapabilityPluginManifest } from "../../core/extensions/capability-plugin.js";
+import { createNodePackageInstallPersistenceV1, } from "./node-package-install-persistence.js";
+import { parseNodeTarGzPackageV1 } from "./node-tar-package.js";
+import { pluginManifestDigestV1 } from "./updates.js";
+const NODE_PACKAGE_INSTALL_HOST_VERSION_V1 = 1;
+export const NODE_PACKAGE_FORMAT_VERSION_V1 = 1;
+const DEFAULT_MAX_ARCHIVE_BYTES_V1 = 128 * 1024 * 1024;
+const MAX_ARCHIVE_BYTES_V1 = 512 * 1024 * 1024;
+const DEFAULT_MAX_EXTRACTED_BYTES_V1 = 256 * 1024 * 1024;
+const MAX_EXTRACTED_BYTES_V1 = 1024 * 1024 * 1024;
+const DEFAULT_MAX_ENTRY_BYTES_V1 = 64 * 1024 * 1024;
+const MAX_ENTRY_BYTES_V1 = 256 * 1024 * 1024;
+const DEFAULT_MAX_ENTRIES_V1 = 2048;
+const MAX_ENTRIES_V1 = 8192;
+const MAX_PACKAGE_MANIFEST_BYTES_V1 = 64 * 1024;
+const ECOSYSTEM_MANIFEST_FILE_V1 = "agent-forge.json";
+const CAPABILITY_MANIFEST_FILE_V1 = "plugin.json";
+const LOCAL_FILE_HEADER_V1 = 0x04034b50;
+const CENTRAL_FILE_HEADER_V1 = 0x02014b50;
+const END_OF_CENTRAL_DIRECTORY_V1 = 0x06054b50;
+const ZIP64_END_OF_CENTRAL_DIRECTORY_V1 = 0x06064b50;
+const ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_V1 = 0x07064b50;
+export class NodePackageInstallErrorV1 extends Error {
+    code;
+    constructor(code) {
+        super(`Node package installation failed: ${code}`);
+        this.name = "NodePackageInstallErrorV1";
+        this.code = code;
+    }
+}
+/**
+ * Adapt an AgentSession-like loader to the host-only runtime seam. The
+ * manifest path is never returned as a DTO or sent through model context.
+ */
+export function createNodePackageInstallSessionLoaderV1(session) {
+    return async ({ manifestPath }) => {
+        const handle = await session.loadCapabilityPluginManifest(manifestPath);
+        return { dispose: handle.dispose };
+    };
+}
+/**
+ * Create a package host with an explicit AgentSession-compatible runtime
+ * loader. This is an opt-in composition helper; it does not alter Core's
+ * default session construction or install untrusted package code.
+ */
+export async function createNodePackageInstallHostForSessionV1(options, session) {
+    if (options.loadPlugin !== undefined)
+        throw new Error("loadPlugin must be omitted when binding a session");
+    return await createNodePackageInstallHostV1({
+        ...options,
+        loadPlugin: createNodePackageInstallSessionLoaderV1(session),
+    });
+}
+function positiveLimit(value, fallback, maximum, label) {
+    const result = value ?? fallback;
+    if (!Number.isSafeInteger(result) || result < 1 || result > maximum)
+        throw new Error(`${label} must be a positive integer at most ${maximum}`);
+    return result;
+}
+/** Resolve the archive budget limits shared by the ZIP and tgz package parsers. */
+export function resolveNodePackageLimitsV1(limitsInput) {
+    return {
+        maxArchiveBytes: positiveLimit(limitsInput.maxArchiveBytes, DEFAULT_MAX_ARCHIVE_BYTES_V1, MAX_ARCHIVE_BYTES_V1, "maxArchiveBytes"),
+        maxExtractedBytes: positiveLimit(limitsInput.maxExtractedBytes, DEFAULT_MAX_EXTRACTED_BYTES_V1, MAX_EXTRACTED_BYTES_V1, "maxExtractedBytes"),
+        maxEntryBytes: positiveLimit(limitsInput.maxEntryBytes, DEFAULT_MAX_ENTRY_BYTES_V1, MAX_ENTRY_BYTES_V1, "maxEntryBytes"),
+        maxEntries: positiveLimit(limitsInput.maxEntries, DEFAULT_MAX_ENTRIES_V1, MAX_ENTRIES_V1, "maxEntries"),
+    };
+}
+function readU16(bytes, offset) {
+    if (offset < 0 || offset + 2 > bytes.byteLength)
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    return bytes[offset] | (bytes[offset + 1] << 8);
+}
+function readU32(bytes, offset) {
+    if (offset < 0 || offset + 4 > bytes.byteLength)
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    return (bytes[offset] | (bytes[offset + 1] << 8) | (bytes[offset + 2] << 16) | (bytes[offset + 3] << 24)) >>> 0;
+}
+function decodeName(bytes, utf8) {
+    try {
+        const value = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        if (!utf8 && /[^\x00-\x7f]/u.test(value))
+            throw new Error("non-ascii zip name");
+        return value;
+    }
+    catch {
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    }
+}
+/** Normalized archive entry name shared by the ZIP and tgz package parsers. */
+export function normalizedEntryName(value) {
+    if (value.length === 0 || value.includes("\\") || /[\u0000-\u001f\u007f]/u.test(value))
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    const directory = value.endsWith("/");
+    if (value.startsWith("/") || /^[a-z]:/iu.test(value))
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    const parts = value.split("/");
+    if (directory)
+        parts.pop();
+    if (parts.length === 0 ||
+        parts.some((part) => part === "" ||
+            part === "." ||
+            part === ".." ||
+            part.includes(":") ||
+            /[ .]$/u.test(part) ||
+            /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\..*)?$/iu.test(part)))
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    return { name: parts.join("/"), directory };
+}
+function crcTable() {
+    const table = new Uint32Array(256);
+    for (let index = 0; index < table.length; index += 1) {
+        let value = index;
+        for (let bit = 0; bit < 8; bit += 1)
+            value = (value & 1) === 0 ? value >>> 1 : (value >>> 1) ^ 0xedb88320;
+        table[index] = value >>> 0;
+    }
+    return table;
+}
+const CRC_TABLE_V1 = crcTable();
+function crc32(bytes) {
+    let value = 0xffffffff;
+    for (const byte of bytes)
+        value = (value >>> 8) ^ CRC_TABLE_V1[(value ^ byte) & 0xff];
+    return (value ^ 0xffffffff) >>> 0;
+}
+function findEndOfCentralDirectory(bytes) {
+    const minimum = Math.max(0, bytes.byteLength - 0xffff - 22);
+    for (let offset = bytes.byteLength - 22; offset >= minimum; offset -= 1) {
+        if (readU32(bytes, offset) !== END_OF_CENTRAL_DIRECTORY_V1)
+            continue;
+        const disk = readU16(bytes, offset + 4);
+        const centralDisk = readU16(bytes, offset + 6);
+        const entries = readU16(bytes, offset + 10);
+        const centralEntries = readU16(bytes, offset + 8);
+        const size = readU32(bytes, offset + 12);
+        const start = readU32(bytes, offset + 16);
+        const commentLength = readU16(bytes, offset + 20);
+        if (disk !== 0 ||
+            centralDisk !== 0 ||
+            entries !== centralEntries ||
+            offset + 22 + commentLength !== bytes.byteLength)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        if (entries === 0xffff || size === 0xffffffff || start === 0xffffffff)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        if (start + size > offset)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        return { offset, entries, size, start };
+    }
+    for (let offset = Math.max(0, bytes.byteLength - 64); offset < bytes.byteLength - 3; offset += 1) {
+        const signature = readU32(bytes, offset);
+        if (signature === ZIP64_END_OF_CENTRAL_DIRECTORY_V1 || signature === ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_V1)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+    }
+    throw new NodePackageInstallErrorV1("archive_invalid");
+}
+function parseCentralDirectory(bytes, limits) {
+    const end = findEndOfCentralDirectory(bytes);
+    if (end.entries > limits.maxEntries || end.size > bytes.byteLength || end.start + end.size > end.offset)
+        throw new NodePackageInstallErrorV1("archive_budget_exceeded");
+    const entries = [];
+    const names = new Set();
+    let offset = end.start;
+    for (let index = 0; index < end.entries; index += 1) {
+        if (readU32(bytes, offset) !== CENTRAL_FILE_HEADER_V1)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        const madeBy = readU16(bytes, offset + 4) >>> 8;
+        const flags = readU16(bytes, offset + 8);
+        const method = readU16(bytes, offset + 10);
+        const crc = readU32(bytes, offset + 16);
+        const compressedSize = readU32(bytes, offset + 20);
+        const uncompressedSize = readU32(bytes, offset + 24);
+        const nameLength = readU16(bytes, offset + 28);
+        const extraLength = readU16(bytes, offset + 30);
+        const commentLength = readU16(bytes, offset + 32);
+        const disk = readU16(bytes, offset + 34);
+        const externalAttributes = readU32(bytes, offset + 38);
+        const localOffset = readU32(bytes, offset + 42);
+        const nameStart = offset + 46;
+        const recordEnd = nameStart + nameLength + extraLength + commentLength;
+        if (recordEnd > end.start + end.size ||
+            disk !== 0 ||
+            (flags & ~(0x8 | 0x800)) !== 0 ||
+            (flags & 1) !== 0 ||
+            (flags & 0x40) !== 0)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        if (method !== 0 && method !== 8)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        if (uncompressedSize > limits.maxEntryBytes || compressedSize > limits.maxArchiveBytes)
+            throw new NodePackageInstallErrorV1("archive_budget_exceeded");
+        const name = normalizedEntryName(decodeName(bytes.subarray(nameStart, nameStart + nameLength), (flags & 0x800) !== 0));
+        if (names.has(name.name))
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        names.add(name.name);
+        const unixMode = madeBy === 3 ? (externalAttributes >>> 16) & 0xffff : 0;
+        if ((unixMode & 0xf000) === 0xa000)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        entries.push({
+            name: name.name,
+            directory: name.directory,
+            flags,
+            method,
+            compressedSize,
+            uncompressedSize,
+            crc32: crc,
+            localOffset,
+        });
+        offset = recordEnd;
+    }
+    if (offset !== end.start + end.size)
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    // Validate the local-file regions before extraction. A forged central
+    // directory must not be able to point into another entry or into the
+    // central directory/EOCD; otherwise extraction could reinterpret metadata
+    // bytes as package contents.
+    const spans = [];
+    for (const entry of entries) {
+        if (entry.localOffset < 0 || entry.localOffset + 30 > end.start)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        if (readU32(bytes, entry.localOffset) !== LOCAL_FILE_HEADER_V1)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        const localNameLength = readU16(bytes, entry.localOffset + 26);
+        const localExtraLength = readU16(bytes, entry.localOffset + 28);
+        const dataStart = entry.localOffset + 30 + localNameLength + localExtraLength;
+        const dataEnd = dataStart + entry.compressedSize;
+        if (dataStart < entry.localOffset + 30 || dataEnd < dataStart || dataEnd > end.start)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        spans.push({ start: entry.localOffset, end: dataEnd });
+    }
+    spans.sort((left, right) => left.start - right.start || left.end - right.end);
+    for (let index = 1; index < spans.length; index += 1) {
+        if (spans[index - 1].end > spans[index].start)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+    }
+    return entries;
+}
+function extractEntry(bytes, entry, maxEntryBytes) {
+    if (entry.directory) {
+        if (entry.compressedSize !== 0 || entry.uncompressedSize !== 0)
+            throw new NodePackageInstallErrorV1("archive_invalid");
+        return new Uint8Array();
+    }
+    if (entry.localOffset + 30 > bytes.byteLength)
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    if (readU32(bytes, entry.localOffset) !== LOCAL_FILE_HEADER_V1)
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    const localFlags = readU16(bytes, entry.localOffset + 6);
+    const localMethod = readU16(bytes, entry.localOffset + 8);
+    const nameLength = readU16(bytes, entry.localOffset + 26);
+    const extraLength = readU16(bytes, entry.localOffset + 28);
+    const localName = decodeName(bytes.subarray(entry.localOffset + 30, entry.localOffset + 30 + nameLength), (entry.flags & 0x800) !== 0);
+    if (normalizedEntryName(localName).name !== entry.name || localFlags !== entry.flags || localMethod !== entry.method)
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    const localCompressedSize = readU32(bytes, entry.localOffset + 18);
+    const localUncompressedSize = readU32(bytes, entry.localOffset + 22);
+    if ((entry.flags & 8) === 0 &&
+        (localCompressedSize !== entry.compressedSize || localUncompressedSize !== entry.uncompressedSize))
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    const dataStart = entry.localOffset + 30 + nameLength + extraLength;
+    const dataEnd = dataStart + entry.compressedSize;
+    if (dataStart > bytes.byteLength || dataEnd > bytes.byteLength)
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    const compressed = bytes.subarray(dataStart, dataEnd);
+    let output;
+    try {
+        output =
+            entry.method === 0
+                ? new Uint8Array(compressed)
+                : inflateRawSync(compressed, { maxOutputLength: maxEntryBytes });
+    }
+    catch {
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    }
+    if (output.byteLength !== entry.uncompressedSize ||
+        output.byteLength > maxEntryBytes ||
+        crc32(output) !== entry.crc32)
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    return output;
+}
+export function parseNodeZipPackageV1(input, limitsInput = {}) {
+    if (!(input instanceof Uint8Array))
+        throw new NodePackageInstallErrorV1("archive_invalid");
+    const limits = resolveNodePackageLimitsV1(limitsInput);
+    if (input.byteLength > limits.maxArchiveBytes)
+        throw new NodePackageInstallErrorV1("archive_budget_exceeded");
+    const descriptors = parseCentralDirectory(input, limits);
+    let extractedBytes = 0;
+    return Object.freeze(descriptors.map((descriptor) => {
+        const bytes = extractEntry(input, descriptor, limits.maxEntryBytes);
+        extractedBytes += bytes.byteLength;
+        if (extractedBytes > limits.maxExtractedBytes)
+            throw new NodePackageInstallErrorV1("archive_budget_exceeded");
+        return Object.freeze({ name: descriptor.name, directory: descriptor.directory, bytes });
+    }));
+}
+function manifestKeys(value) {
+    const allowed = new Set([
+        "packageFormatVersion",
+        "id",
+        "pluginVersion",
+        "apiVersion",
+        "minHostVersion",
+        "maxHostVersion",
+        "capabilityRefs",
+        "requires",
+        "platform",
+        "testOnly",
+    ]);
+    return Object.keys(value).every((key) => allowed.has(key));
+}
+function packageManifest(value, record) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new NodePackageInstallErrorV1("package_manifest_invalid");
+    const manifest = value;
+    if (!manifestKeys(manifest) ||
+        manifest.packageFormatVersion !== NODE_PACKAGE_FORMAT_VERSION_V1 ||
+        manifest.id !== record.pluginId ||
+        manifest.pluginVersion !== record.pluginVersion)
+        throw new NodePackageInstallErrorV1("package_manifest_mismatch");
+    if (typeof manifest.apiVersion !== "string" || manifest.apiVersion !== record.manifest.apiVersion)
+        throw new NodePackageInstallErrorV1("package_manifest_mismatch");
+    try {
+        if (pluginManifestDigestV1(manifest) !== record.manifestDigest)
+            throw new NodePackageInstallErrorV1("package_manifest_mismatch");
+    }
+    catch (error) {
+        if (error instanceof NodePackageInstallErrorV1)
+            throw error;
+        throw new NodePackageInstallErrorV1("package_manifest_invalid");
+    }
+}
+function capabilityManifest(value, record, entries) {
+    let manifest;
+    try {
+        manifest = parseCapabilityPluginManifest(value, "<installed plugin.json>");
+    }
+    catch {
+        throw new NodePackageInstallErrorV1("package_manifest_invalid");
+    }
+    if (manifest.id !== record.pluginId || manifest.version !== record.pluginVersion)
+        throw new NodePackageInstallErrorV1("package_manifest_mismatch");
+    const entryValue = manifest.entry.startsWith("./") ? manifest.entry.slice(2) : manifest.entry;
+    const entry = normalizedEntryName(entryValue);
+    if (entry.directory || !entries.some((candidate) => candidate.name === entry.name && !candidate.directory))
+        throw new NodePackageInstallErrorV1("package_manifest_mismatch");
+}
+function opaqueScope(value) {
+    if (typeof value !== "string" ||
+        value.trim() === "" ||
+        value.length > 2048 ||
+        /\s|[\u0000-\u001f\u007f]/u.test(value))
+        throw new NodePackageInstallErrorV1("installation_identity_mismatch");
+    return value;
+}
+function installationKey(scope, scopeRef, pluginId) {
+    return `${scope}\u0000${scopeRef}\u0000${pluginId}`;
+}
+function identityMatches(record, input) {
+    return (record.pluginId === input.pluginId &&
+        record.pluginVersion === input.pluginVersion &&
+        record.manifestDigest === input.manifestDigest &&
+        record.scope === input.scope &&
+        record.scopeRef === input.scopeRef);
+}
+function artifactIdentityMatchesRecord(artifact, record) {
+    return (artifact.version === 1 &&
+        artifact.pluginId === record.pluginId &&
+        artifact.pluginVersion === record.pluginVersion &&
+        artifact.manifestDigest === record.manifestDigest);
+}
+function expectedArtifactDigest(value) {
+    const prefixed = /^(sha256|sha512):([0-9a-f]+)$/iu.exec(value);
+    if (prefixed !== null) {
+        const algorithm = prefixed[1].toLowerCase();
+        const hex = prefixed[2].toLowerCase();
+        if ((algorithm === "sha256" && hex.length === 64) || (algorithm === "sha512" && hex.length === 128))
+            return { algorithm, hex };
+    }
+    if (/^[0-9a-f]{64}$/iu.test(value))
+        return { algorithm: "sha256", hex: value.toLowerCase() };
+    if (/^[0-9a-f]{128}$/iu.test(value))
+        return { algorithm: "sha512", hex: value.toLowerCase() };
+    throw new NodePackageInstallErrorV1("invalid_artifact");
+}
+async function collectArtifact(openArtifact, artifact, maxBytes, signal) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of openArtifact({ artifact, signal })) {
+        if (signal.aborted)
+            throw new NodePackageInstallErrorV1("cancelled");
+        if (!(chunk instanceof Uint8Array))
+            throw new NodePackageInstallErrorV1("invalid_artifact");
+        if (chunk.byteLength > maxBytes - total)
+            throw new NodePackageInstallErrorV1("archive_budget_exceeded");
+        chunks.push(new Uint8Array(chunk));
+        total += chunk.byteLength;
+    }
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return result;
+}
+function packagePath(root, key) {
+    return join(root, createHash("sha256").update(key).digest("hex"));
+}
+async function writeEntries(root, entries, signal) {
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    for (const entry of entries) {
+        if (signal.aborted)
+            throw new NodePackageInstallErrorV1("cancelled");
+        const target = join(root, ...entry.name.split("/"));
+        if (entry.directory) {
+            await mkdir(target, { recursive: true, mode: 0o700 });
+            continue;
+        }
+        const parent = join(root, ...entry.name.split("/").slice(0, -1));
+        await mkdir(parent, { recursive: true, mode: 0o700 });
+        await writeFile(target, entry.bytes, { flag: "wx", mode: 0o600 });
+    }
+}
+/**
+ * Host-owned ZIP/tgz package installer. It extracts only a bounded,
+ * non-encrypted ZIP ("application/zip") or gzip-compressed tar
+ * ("application/gzip") package and never executes package contents. The
+ * returned installation handle is opaque; paths stay inside the host-owned
+ * instance directory.
+ */
+export async function createNodePackageInstallHostV1(options) {
+    if (typeof options.openArtifact !== "function")
+        throw new Error("openArtifact is required");
+    const limits = resolveNodePackageLimitsV1(options);
+    const parent = options.installationDirectory ?? tmpdir();
+    if (!isAbsolute(parent))
+        throw new Error("installationDirectory must be absolute");
+    if (options.persistence !== undefined && options.persistence !== "ephemeral" && options.persistence !== "persistent")
+        throw new Error("persistence mode is invalid");
+    const supportedScopes = options.supportedScopes ?? ["global", "project"];
+    if (!Array.isArray(supportedScopes) ||
+        supportedScopes.length === 0 ||
+        new Set(supportedScopes).size !== supportedScopes.length ||
+        supportedScopes.some((scope) => scope !== "global" && scope !== "project"))
+        throw new Error("supportedScopes is invalid");
+    await mkdir(parent, { recursive: true, mode: 0o700 });
+    const persistent = options.persistence === "persistent";
+    const instanceRoot = persistent
+        ? join(parent, "agent-forge-plugin-install-store-v1")
+        : await mkdtemp(join(parent, "agent-forge-plugin-install-"));
+    const persistence = persistent
+        ? await createNodePackageInstallPersistenceV1({
+            rootDirectory: instanceRoot,
+            lockTimeoutMs: options.persistenceLockTimeoutMs,
+        })
+        : undefined;
+    const records = new Map();
+    const activeByKey = new Map();
+    if (persistence !== undefined) {
+        for (const record of await persistence.load())
+            records.set(record.installationRef, { ...record });
+    }
+    for (const record of records.values()) {
+        if (record.state === "active")
+            activeByKey.set(installationKey(record.scope, record.scopeRef, record.pluginId), record.installationRef);
+    }
+    let closed = false;
+    const activeOperations = new Set();
+    const runtimeHandles = new Map();
+    const applyPersistentSnapshot = (snapshot) => {
+        records.clear();
+        activeByKey.clear();
+        for (const value of snapshot)
+            records.set(value.installationRef, { ...value });
+        for (const value of records.values()) {
+            if (value.state === "active")
+                activeByKey.set(installationKey(value.scope, value.scopeRef, value.pluginId), value.installationRef);
+        }
+    };
+    const commitRecords = async (update) => {
+        if (persistence === undefined) {
+            await update(records);
+            return;
+        }
+        applyPersistentSnapshot(await persistence.mutate({ update }));
+    };
+    let drained;
+    let closePromise;
+    const begin = (parentSignal) => {
+        if (closed)
+            throw new NodePackageInstallErrorV1("host_closed");
+        const controller = new AbortController();
+        if (parentSignal?.aborted)
+            controller.abort(parentSignal.reason);
+        else
+            parentSignal?.addEventListener("abort", () => controller.abort(parentSignal.reason), { once: true });
+        activeOperations.add(controller);
+        return { controller, signal: controller.signal };
+    };
+    const end = (controller) => {
+        activeOperations.delete(controller);
+        if (activeOperations.size === 0) {
+            drained?.();
+            drained = undefined;
+        }
+    };
+    const waitDrained = async () => {
+        if (activeOperations.size === 0)
+            return;
+        await new Promise((resolve) => {
+            drained = resolve;
+        });
+    };
+    const getRecord = (installation, record, scope, scopeRef) => {
+        const value = records.get(installation.installationRef);
+        if (value === undefined ||
+            installation.pluginId !== record.pluginId ||
+            installation.pluginVersion !== record.pluginVersion ||
+            installation.manifestDigest !== record.manifestDigest ||
+            installation.scope !== scope ||
+            installation.scopeRef !== scopeRef ||
+            !identityMatches(value, {
+                pluginId: record.pluginId,
+                pluginVersion: record.pluginVersion,
+                manifestDigest: record.manifestDigest,
+                scope,
+                scopeRef,
+            }))
+            throw new NodePackageInstallErrorV1("installation_identity_mismatch");
+        return value;
+    };
+    const disposeRuntime = async (installationRef) => {
+        const handle = runtimeHandles.get(installationRef);
+        if (handle === undefined)
+            return;
+        if (handle.dispose !== undefined)
+            await Promise.resolve(handle.dispose());
+        runtimeHandles.delete(installationRef);
+    };
+    const loadRuntime = async (installation, record, directory, signal) => {
+        if (options.loadPlugin === undefined)
+            return undefined;
+        try {
+            const loaded = await options.loadPlugin({
+                installation,
+                record,
+                directory,
+                manifestPath: join(directory, CAPABILITY_MANIFEST_FILE_V1),
+                signal,
+            });
+            return loaded ?? undefined;
+        }
+        catch (error) {
+            if (error instanceof NodePackageInstallErrorV1)
+                throw error;
+            throw new NodePackageInstallErrorV1("installation_io_failed");
+        }
+    };
+    const host = {
+        version: NODE_PACKAGE_INSTALL_HOST_VERSION_V1,
+        supportedScopes: Object.freeze([...supportedScopes]),
+        getInstallationDirectory(input) {
+            const record = records.get(input.installation.installationRef);
+            if (record === undefined ||
+                record.pluginId !== input.installation.pluginId ||
+                record.pluginVersion !== input.installation.pluginVersion ||
+                record.manifestDigest !== input.installation.manifestDigest ||
+                record.scope !== input.installation.scope ||
+                record.scopeRef !== input.installation.scopeRef)
+                throw new NodePackageInstallErrorV1("installation_unknown");
+            return record.directory;
+        },
+        async install(input) {
+            const operation = begin(input.signal);
+            let staging;
+            try {
+                if (input.artifact === undefined)
+                    throw new NodePackageInstallErrorV1("invalid_artifact");
+                if (!artifactIdentityMatchesRecord(input.artifact, input.record))
+                    throw new NodePackageInstallErrorV1("invalid_artifact");
+                const mediaType = input.artifact.mediaType.toLowerCase();
+                if (mediaType !== "application/zip" && mediaType !== "application/gzip")
+                    throw new NodePackageInstallErrorV1("unsupported_media_type");
+                const scopeRef = opaqueScope(input.scopeRef);
+                const bytes = await collectArtifact(options.openArtifact, input.artifact, limits.maxArchiveBytes, operation.signal);
+                if (input.artifact.sizeBytes !== bytes.byteLength)
+                    throw new NodePackageInstallErrorV1("invalid_artifact");
+                const digest = expectedArtifactDigest(input.artifact.artifactDigest);
+                if (createHash(digest.algorithm).update(bytes).digest("hex") !== digest.hex)
+                    throw new NodePackageInstallErrorV1("invalid_artifact");
+                const entries = mediaType === "application/gzip"
+                    ? await parseNodeTarGzPackageV1(bytes, limits)
+                    : parseNodeZipPackageV1(bytes, limits);
+                const manifestEntry = entries.find((entry) => entry.name === ECOSYSTEM_MANIFEST_FILE_V1 && !entry.directory);
+                if (manifestEntry === undefined)
+                    throw new NodePackageInstallErrorV1("package_manifest_missing");
+                if (manifestEntry.bytes.byteLength > MAX_PACKAGE_MANIFEST_BYTES_V1)
+                    throw new NodePackageInstallErrorV1("package_manifest_invalid");
+                let manifest;
+                try {
+                    manifest = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(manifestEntry.bytes));
+                }
+                catch {
+                    throw new NodePackageInstallErrorV1("package_manifest_invalid");
+                }
+                packageManifest(manifest, input.record);
+                const capabilityEntry = entries.find((entry) => entry.name === CAPABILITY_MANIFEST_FILE_V1 && !entry.directory);
+                if (capabilityEntry === undefined)
+                    throw new NodePackageInstallErrorV1("package_manifest_missing");
+                if (capabilityEntry.bytes.byteLength > MAX_PACKAGE_MANIFEST_BYTES_V1)
+                    throw new NodePackageInstallErrorV1("package_manifest_invalid");
+                let capability;
+                try {
+                    capability = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(capabilityEntry.bytes));
+                }
+                catch {
+                    throw new NodePackageInstallErrorV1("package_manifest_invalid");
+                }
+                capabilityManifest(capability, input.record, entries);
+                const key = installationKey(input.scope, scopeRef, input.record.pluginId);
+                staging = join(instanceRoot, `.staging-${randomUUID()}`);
+                await writeEntries(staging, entries, operation.signal);
+                const installRef = `plugin-install://node-zip/${randomUUID()}`;
+                const destination = packagePath(instanceRoot, `${key}\u0000${installRef}`);
+                await rename(staging, destination);
+                staging = undefined;
+                const installedRecord = {
+                    installationRef: installRef,
+                    directory: destination,
+                    pluginId: input.record.pluginId,
+                    pluginVersion: input.record.pluginVersion,
+                    manifestDigest: input.record.manifestDigest,
+                    scope: input.scope,
+                    scopeRef,
+                    state: "installed",
+                };
+                try {
+                    await commitRecords((values) => {
+                        values.set(installRef, installedRecord);
+                    });
+                }
+                catch (error) {
+                    await rm(destination, { recursive: true, force: true }).catch(() => undefined);
+                    throw error;
+                }
+                return { installationRef: installRef, scope: input.scope, scopeRef };
+            }
+            catch (error) {
+                if (operation.signal.aborted || input.signal?.aborted)
+                    throw new NodePackageInstallErrorV1("cancelled");
+                if (error instanceof NodePackageInstallErrorV1)
+                    throw error;
+                throw new NodePackageInstallErrorV1("installation_io_failed");
+            }
+            finally {
+                if (staging !== undefined)
+                    await rm(staging, { recursive: true, force: true }).catch(() => undefined);
+                end(operation.controller);
+            }
+        },
+        async activate(input) {
+            const operation = begin(input.signal);
+            let candidate;
+            try {
+                const scopeRef = opaqueScope(input.scopeRef);
+                const record = getRecord(input.installation, input.record, input.scope, scopeRef);
+                if (record.state !== "installed")
+                    throw new NodePackageInstallErrorV1("installation_identity_mismatch");
+                candidate = await loadRuntime(input.installation, input.record, record.directory, operation.signal);
+                const key = installationKey(input.scope, scopeRef, input.record.pluginId);
+                const previousRef = activeByKey.get(key);
+                if (previousRef !== undefined) {
+                    const previous = records.get(previousRef);
+                    if (previous !== undefined) {
+                        await disposeRuntime(previousRef);
+                    }
+                }
+                await commitRecords((values) => {
+                    const candidateRecord = values.get(input.installation.installationRef);
+                    if (candidateRecord === undefined)
+                        throw new NodePackageInstallErrorV1("installation_identity_mismatch");
+                    if (previousRef !== undefined) {
+                        const previousRecord = values.get(previousRef);
+                        if (previousRecord !== undefined)
+                            values.set(previousRef, { ...previousRecord, state: "retained" });
+                    }
+                    values.set(input.installation.installationRef, { ...candidateRecord, state: "active" });
+                });
+                activeByKey.set(key, input.installation.installationRef);
+                if (candidate !== undefined)
+                    runtimeHandles.set(input.installation.installationRef, candidate);
+                candidate = undefined;
+            }
+            catch (error) {
+                if (candidate?.dispose !== undefined)
+                    await Promise.resolve(candidate.dispose()).catch(() => undefined);
+                if (error instanceof NodePackageInstallErrorV1)
+                    throw error;
+                throw new NodePackageInstallErrorV1("installation_io_failed");
+            }
+            finally {
+                end(operation.controller);
+            }
+        },
+        async rollback(input) {
+            const operation = begin(input.signal);
+            let candidate;
+            try {
+                const scopeRef = opaqueScope(input.scopeRef);
+                const failed = records.get(input.failed.installationRef);
+                if (failed === undefined ||
+                    !identityMatches(failed, {
+                        pluginId: input.failed.pluginId,
+                        pluginVersion: input.failed.pluginVersion,
+                        manifestDigest: input.failed.manifestDigest,
+                        scope: input.scope,
+                        scopeRef,
+                    }))
+                    throw new NodePackageInstallErrorV1("installation_identity_mismatch");
+                const previous = records.get(input.previous.installationRef);
+                if (previous === undefined ||
+                    !identityMatches(previous, {
+                        pluginId: input.previous.pluginId,
+                        pluginVersion: input.previous.pluginVersion,
+                        manifestDigest: input.previous.manifestDigest,
+                        scope: input.scope,
+                        scopeRef,
+                    }) ||
+                    (previous.state !== "active" && previous.state !== "retained") ||
+                    failed.pluginId !== previous.pluginId)
+                    throw new NodePackageInstallErrorV1("installation_identity_mismatch");
+                const previousInstallation = {
+                    version: 1,
+                    pluginId: previous.pluginId,
+                    pluginVersion: previous.pluginVersion,
+                    manifestDigest: previous.manifestDigest,
+                    scope: previous.scope,
+                    scopeRef: previous.scopeRef,
+                    installationRef: input.previous.installationRef,
+                    state: "active",
+                };
+                candidate = await loadRuntime(previousInstallation, undefined, previous.directory, operation.signal);
+                await disposeRuntime(input.failed.installationRef);
+                await rm(failed.directory, { recursive: true, force: true });
+                await commitRecords((values) => {
+                    values.delete(input.failed.installationRef);
+                    const previousRecord = values.get(input.previous.installationRef);
+                    if (previousRecord !== undefined)
+                        values.set(input.previous.installationRef, { ...previousRecord, state: "active" });
+                });
+                activeByKey.set(installationKey(input.scope, scopeRef, failed.pluginId), input.previous.installationRef);
+                if (candidate !== undefined)
+                    runtimeHandles.set(input.previous.installationRef, candidate);
+                candidate = undefined;
+            }
+            catch (error) {
+                if (candidate?.dispose !== undefined)
+                    await Promise.resolve(candidate.dispose()).catch(() => undefined);
+                if (error instanceof NodePackageInstallErrorV1)
+                    throw error;
+                throw new NodePackageInstallErrorV1("installation_io_failed");
+            }
+            finally {
+                end(operation.controller);
+            }
+        },
+        async uninstall(input) {
+            const operation = begin(input.signal);
+            try {
+                const scopeRef = opaqueScope(input.scopeRef);
+                const record = records.get(input.installation.installationRef);
+                if (record === undefined ||
+                    !identityMatches(record, {
+                        pluginId: input.installation.pluginId,
+                        pluginVersion: input.installation.pluginVersion,
+                        manifestDigest: input.installation.manifestDigest,
+                        scope: input.scope,
+                        scopeRef,
+                    }))
+                    throw new NodePackageInstallErrorV1("installation_unknown");
+                await disposeRuntime(input.installation.installationRef);
+                await rm(record.directory, { recursive: true, force: false });
+                await commitRecords((values) => {
+                    values.delete(input.installation.installationRef);
+                });
+                const key = installationKey(input.scope, scopeRef, record.pluginId);
+                if (activeByKey.get(key) === input.installation.installationRef)
+                    activeByKey.delete(key);
+            }
+            finally {
+                end(operation.controller);
+            }
+        },
+        async close() {
+            if (closePromise !== undefined)
+                return await closePromise;
+            closed = true;
+            for (const operation of activeOperations)
+                operation.abort();
+            closePromise = (async () => {
+                await waitDrained();
+                let disposeError = false;
+                for (const installationRef of runtimeHandles.keys()) {
+                    try {
+                        await disposeRuntime(installationRef);
+                    }
+                    catch {
+                        disposeError = true;
+                    }
+                }
+                if (persistence === undefined)
+                    await rm(instanceRoot, { recursive: true, force: true });
+                else
+                    await persistence.close();
+                records.clear();
+                activeByKey.clear();
+                if (disposeError)
+                    throw new NodePackageInstallErrorV1("installation_io_failed");
+            })();
+            return await closePromise;
+        },
+    };
+    if (options.loadPlugin !== undefined) {
+        try {
+            for (const record of records.values()) {
+                if (record.state !== "active")
+                    continue;
+                const installation = {
+                    version: 1,
+                    pluginId: record.pluginId,
+                    pluginVersion: record.pluginVersion,
+                    manifestDigest: record.manifestDigest,
+                    scope: record.scope,
+                    scopeRef: record.scopeRef,
+                    installationRef: record.installationRef,
+                    state: "active",
+                };
+                const runtime = await loadRuntime(installation, undefined, record.directory, new AbortController().signal);
+                if (runtime !== undefined)
+                    runtimeHandles.set(record.installationRef, runtime);
+            }
+        }
+        catch (error) {
+            await host.close().catch(() => undefined);
+            if (error instanceof NodePackageInstallErrorV1)
+                throw error;
+            throw new NodePackageInstallErrorV1("installation_io_failed");
+        }
+    }
+    return host;
+}
+//# sourceMappingURL=node-package-install-host.js.map