@nggaigc/cli 0.1.9 → 0.1.12

package/README.md

@@ -1,11 +1,13 @@
 # @nggaigc/cli
 
-NGGAIGC Codex Skill 的 Windows 一命令安装器。
+NGGAIGC Codex Skill 的一命令安装器。
 
 ```powershell
 npx --yes @nggaigc/cli@latest install
 ```
 
-安装器会先验证内置 Plugin 的 Ed25519 签名、归档哈希和逐文件哈希，再原子安装 Skill。首次运行会打开 NGGAIGC 浏览器授权页；浏览器仅接收短期连接挑战，安装器通过内存中的独立轮询凭据获取连接结果，设备凭据只通过标准输入进入 Windows Credential Manager。安装器不接受 API Key、授权码或设备凭据参数，也不从环境变量读取这些值。
+安装器会先验证内置 Plugin 的 Ed25519 签名、归档哈希和逐文件哈希，再原子安装 Skill。首次运行会打开 NGGAIGC 浏览器授权页；浏览器仅接收短期连接挑战，安装器通过内存中的独立轮询凭据获取连接结果，设备凭据只通过标准输入进入操作系统受保护的凭据存储（Windows Credential Manager 或 macOS Keychain）。安装器不接受 API Key、授权码或设备凭据参数，也不从环境变量读取这些值。
 
-当前候选支持 Windows x64/arm64，自动使用当前 Node.js 22.x（22.13 起）或 24.x。两个版本使用同一个安装包和同一套代码，不下载或内嵌 Node.js；其他主版本暂不支持。
+已发布的 0.1.10 安装器仍仅支持 Windows x64/arm64。此源码中的 0.1.12 / Plugin 1.1.14 是尚未签名、尚未发布的测试候选；候选计划保持 Windows x64/arm64，并增加 Apple 芯片 Mac arm64，使用本机 Node.js 22.x（22.13 起）或 24.x，不下载或内嵌 Node.js。
+
+macOS 适配仍需在真实 M3 Mac 编译并核验 Keychain helper，再制作新签名 Plugin 与单一 CLI 包；旧 Windows-only 签名归档不会被重标为 Mac 兼容。Intel Mac 不在本候选声明范围内，也没有实机验收。不要将本候选版本替换为公开安装命令或 npm `latest`。

package/dist/archive.js

@@ -0,0 +1,213 @@
+import { chmod, lstat, mkdir, open, realpath } from "node:fs/promises";
+import path from "node:path";
+import { inflateRawSync } from "node:zlib";
+// The release builder emits ordinary single-disk ZIPs. Deliberately reject
+// ZIP64, encryption, links and unsupported flags rather than delegating to an
+// OS extractor with different traversal/overwrite semantics on each platform.
+const MAX_ARCHIVE = 64 * 1024 * 1024;
+const MAX_EXPANDED = 64 * 1024 * 1024;
+const MAX_FILES = 1024;
+const decoder = new TextDecoder("utf-8", { fatal: true });
+export function safeArchivePath(value) {
+    return (value.length > 0 &&
+        value.length <= 240 &&
+        value === value.normalize("NFC") &&
+        !/[\\:<>"|?*]/.test(value) &&
+        !Array.from(value).some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127) &&
+        value
+            .split("/")
+            .every((part) => part !== "" &&
+            part !== "." &&
+            part !== ".." &&
+            !/[. ]$/.test(part) &&
+            !/^(con|prn|aux|nul|com[0-9]|lpt[0-9])(?:\.|$)/i.test(part)));
+}
+export function crc32(bytes) {
+    let crc = 0xffffffff;
+    for (const byte of bytes) {
+        crc ^= byte;
+        for (let bit = 0; bit < 8; bit++)
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function extraFields(bytes) {
+    for (let offset = 0; offset < bytes.length;) {
+        if (offset + 4 > bytes.length)
+            throw new Error("ZIP_EXTRA_INVALID");
+        const id = bytes.readUInt16LE(offset);
+        const length = bytes.readUInt16LE(offset + 2);
+        // ZIP64, alternate Unicode path, Unix link metadata and NTFS attributes
+        // are unnecessary for our package and can introduce conflicting names.
+        if ([0x0001, 0x000a, 0x000d, 0x5855, 0x756e, 0x7075].includes(id))
+            throw new Error("ZIP_EXTRA_UNSUPPORTED");
+        offset += 4 + length;
+        if (offset > bytes.length)
+            throw new Error("ZIP_EXTRA_INVALID");
+    }
+}
+export function decodeArchive(archive) {
+    if (archive.length < 22 || archive.length > MAX_ARCHIVE)
+        throw new Error("ZIP_SIZE_INVALID");
+    let end = archive.length - 22;
+    const first = Math.max(0, end - 65535);
+    for (; end >= first; end--) {
+        if (archive.readUInt32LE(end) === 0x06054b50 &&
+            end + 22 + archive.readUInt16LE(end + 20) === archive.length)
+            break;
+    }
+    if (end < first ||
+        archive.readUInt16LE(end + 4) !== 0 ||
+        archive.readUInt16LE(end + 6) !== 0)
+        throw new Error("ZIP_END_INVALID");
+    const count = archive.readUInt16LE(end + 10);
+    const centralSize = archive.readUInt32LE(end + 12);
+    const centralOffset = archive.readUInt32LE(end + 16);
+    if (count < 1 ||
+        count > MAX_FILES ||
+        archive.readUInt16LE(end + 8) !== count ||
+        centralOffset + centralSize !== end)
+        throw new Error("ZIP_DIRECTORY_INVALID");
+    const names = new Map();
+    const entries = [];
+    const ranges = [];
+    let expanded = 0;
+    let cursor = centralOffset;
+    for (let index = 0; index < count; index++) {
+        if (cursor + 46 > end || archive.readUInt32LE(cursor) !== 0x02014b50)
+            throw new Error("ZIP_ENTRY_INVALID");
+        const flags = archive.readUInt16LE(cursor + 8);
+        const method = archive.readUInt16LE(cursor + 10);
+        const crc = archive.readUInt32LE(cursor + 16);
+        const compressedSize = archive.readUInt32LE(cursor + 20);
+        const size = archive.readUInt32LE(cursor + 24);
+        const nameLength = archive.readUInt16LE(cursor + 28);
+        const extraLength = archive.readUInt16LE(cursor + 30);
+        const commentLength = archive.readUInt16LE(cursor + 32);
+        const attributes = archive.readUInt32LE(cursor + 38);
+        const unixType = (attributes >>> 16) & 0xf000;
+        const unixMode = (attributes >>> 16) & 0x0fff;
+        const local = archive.readUInt32LE(cursor + 42);
+        const next = cursor + 46 + nameLength + extraLength + commentLength;
+        expanded += size;
+        if (next > end ||
+            nameLength < 1 ||
+            (flags & ~0x808) !== 0 ||
+            (method !== 0 && method !== 8) ||
+            size > MAX_EXPANDED ||
+            expanded > MAX_EXPANDED ||
+            archive.readUInt16LE(cursor + 34) !== 0 ||
+            ![0, 0x4000, 0x8000].includes(unixType) ||
+            (attributes & 0x400) !== 0)
+            throw new Error("ZIP_ENTRY_UNSUPPORTED");
+        const rawName = archive.subarray(cursor + 46, cursor + 46 + nameLength);
+        const fullName = decoder.decode(rawName);
+        const directory = fullName.endsWith("/");
+        const name = directory ? fullName.slice(0, -1) : fullName;
+        const executable = !directory && (unixMode & 0o111) !== 0;
+        const key = name.toLowerCase();
+        if (!safeArchivePath(name) ||
+            names.has(key) ||
+            (unixMode & 0o7000) !== 0 ||
+            (executable && name !== "skills/nggaigc/scripts/macos-keychain") ||
+            (directory && (size !== 0 || unixType === 0x8000)) ||
+            (!directory && (unixType === 0x4000 || (attributes & 0x10) !== 0)))
+            throw new Error("ZIP_PATH_INVALID");
+        names.set(key, directory);
+        extraFields(archive.subarray(cursor + 46 + nameLength, cursor + 46 + nameLength + extraLength));
+        if (local + 30 > centralOffset ||
+            archive.readUInt32LE(local) !== 0x04034b50 ||
+            archive.readUInt16LE(local + 6) !== flags ||
+            archive.readUInt16LE(local + 8) !== method ||
+            archive.readUInt16LE(local + 26) !== nameLength)
+            throw new Error("ZIP_LOCAL_INVALID");
+        const localExtra = archive.readUInt16LE(local + 28);
+        const start = local + 30 + nameLength + localExtra;
+        const dataEnd = start + compressedSize;
+        if (dataEnd > centralOffset ||
+            !archive.subarray(local + 30, local + 30 + nameLength).equals(rawName))
+            throw new Error("ZIP_LOCAL_INVALID");
+        extraFields(archive.subarray(local + 30 + nameLength, start));
+        let entryEnd = dataEnd;
+        if (flags & 8) {
+            const descriptor = dataEnd + (archive.readUInt32LE(dataEnd) === 0x08074b50 ? 4 : 0);
+            entryEnd = descriptor + 12;
+            if (entryEnd > centralOffset ||
+                archive.readUInt32LE(descriptor) !== crc ||
+                archive.readUInt32LE(descriptor + 4) !== compressedSize ||
+                archive.readUInt32LE(descriptor + 8) !== size)
+                throw new Error("ZIP_DESCRIPTOR_INVALID");
+        }
+        else if (archive.readUInt32LE(local + 14) !== crc ||
+            archive.readUInt32LE(local + 18) !== compressedSize ||
+            archive.readUInt32LE(local + 22) !== size)
+            throw new Error("ZIP_LOCAL_INVALID");
+        const compressed = archive.subarray(start, dataEnd);
+        const bytes = method === 0
+            ? Buffer.from(compressed)
+            : inflateRawSync(compressed, { maxOutputLength: Math.max(1, size) });
+        if (bytes.length !== size || crc32(bytes) !== crc)
+            throw new Error("ZIP_CONTENT_INVALID");
+        entries.push({ name, bytes, directory, executable });
+        ranges.push([local, entryEnd]);
+        cursor = next;
+    }
+    if (cursor !== end)
+        throw new Error("ZIP_DIRECTORY_INVALID");
+    // Reject gaps, overlapping local records and unlisted hidden entries.
+    ranges.sort(([a], [b]) => a - b);
+    let offset = 0;
+    for (const [start, finish] of ranges) {
+        if (start !== offset)
+            throw new Error("ZIP_LOCAL_INVALID");
+        offset = finish;
+    }
+    if (offset !== centralOffset)
+        throw new Error("ZIP_LOCAL_INVALID");
+    for (const name of names.keys()) {
+        const segments = name.split("/");
+        segments.pop();
+        while (segments.length) {
+            if (names.get(segments.join("/")) === false)
+                throw new Error("ZIP_PATH_CONFLICT");
+            segments.pop();
+        }
+    }
+    return entries;
+}
+export async function writeArchive(entries, destination) {
+    const requested = path.resolve(destination);
+    // Require a new directory below an existing non-link directory. Never merge
+    // into caller-owned contents or follow an existing junction/symlink.
+    const parent = path.dirname(requested);
+    const facts = await lstat(parent);
+    if (!facts.isDirectory() || facts.isSymbolicLink())
+        throw new Error("ZIP_DESTINATION_UNSAFE");
+    // macOS /var is a system symlink to /private/var. Resolve parent aliases
+    // once while still rejecting a caller-supplied linked destination parent.
+    const root = path.join(await realpath(parent), path.basename(requested));
+    await mkdir(root, { mode: 0o700 });
+    for (const entry of entries) {
+        const file = path.resolve(root, ...entry.name.split("/"));
+        const relative = path.relative(root, file);
+        if (!relative ||
+            relative.startsWith(`..${path.sep}`) ||
+            path.isAbsolute(relative))
+            throw new Error("ZIP_DESTINATION_UNSAFE");
+        await mkdir(entry.directory ? file : path.dirname(file), {
+            recursive: true,
+            mode: 0o700,
+        });
+        if (entry.directory)
+            continue;
+        const handle = await open(file, "wx", entry.executable ? 0o700 : 0o600);
+        try {
+            await handle.writeFile(entry.bytes);
+        }
+        finally {
+            await handle.close();
+        }
+        if (entry.executable)
+            await chmod(file, 0o755);
+    }
+}

package/dist/bin.js

@@ -1,39 +1,60 @@
 #!/usr/bin/env node
-import { CliError } from "./errors.js";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CliError, fixedErrorCode } from "./errors.js";
 import { runInstall } from "./install.js";
+import { runSkillStartCommand, } from "./skill-command.js";
 const messages = {
     authorizing: "浏览器已成功启动，请在 NGGAIGC 页面确认连接…",
     connected: "NGGAIGC Skill 已安装，设备连接验证成功。",
     installing: "正在安全安装已签名的 NGGAIGC Skill…",
-    launching: "正在请求 Windows 打开默认浏览器…",
+    launching: "正在请求系统打开默认浏览器…",
     verifying: "正在验证 NGGAIGC 签名安装包…",
 };
 const errorMessages = {
     ARCHIVE_EXTRACTION_FAILED: "安装包无法安全解压，请稍后重试。",
     BROWSER_AUTHORIZATION_FAILED: "浏览器授权未完成，请重新运行安装命令。",
-    BROWSER_OPEN_FAILED: "Windows 未能打开默认浏览器。请确认已设置可用的默认浏览器，然后重新运行安装命令；本次连接未完成。",
+    BROWSER_OPEN_FAILED: "系统未能打开默认浏览器。请确认已设置可用的默认浏览器，然后重新运行安装命令；本次连接未完成。",
     CONNECTION_VERIFICATION_FAILED: "设备连接验证失败，请重新运行安装命令。",
-    INSTALLATION_FAILED: "本地安装未完成，请重试；现有文件未被修改。",
-    INVALID_INPUT: "命令格式无效。请仅运行：npx --yes @nggaigc/cli@latest install",
+    INSTALLATION_FAILED: "本地安装未完成，请检查现有文件状态后重试。",
+    SKILL_PAIR_UPGRADE_REQUIRED: "检测到无法安全配套迁移的本地 Seedream Skill，已停止升级。请保留旧 Skill 和任务文件并联系支持。",
+    SKILL_PAIR_RECOVERY_REQUIRED: "检测到本地组合安装中断或目录变化，已停止自动操作。请保留相关目录和任务文件并联系支持。",
+    INVALID_INPUT: "命令格式无效。请使用 install，或 start-skill skill.<id> [version]。",
     PACKAGE_VERIFICATION_FAILED: "安装包签名或完整性验证失败，已停止安装。",
     RUNTIME_UNSUPPORTED: "请使用 Node.js 22.x（22.13 起）或 24.x 版本。",
-    UNSUPPORTED_PLATFORM: "当前候选仅支持 Windows x64 或 Windows arm64。",
+    UNSUPPORTED_PLATFORM: "当前系统或架构尚未获得此签名安装包支持，请使用已支持的平台。",
 };
-export async function main(args) {
+export async function main(args, runtime = {}) {
+    const output = runtime.output ?? ((line) => process.stdout.write(line));
+    const errorOutput = runtime.error ?? ((line) => process.stderr.write(line));
+    if (args[0] === "start-skill" && (args.length === 2 || args.length === 3)) {
+        try {
+            const result = await (runtime.startSkill ?? runSkillStartCommand)(args[1], args[2], runtime.skillOptions);
+            output(`${JSON.stringify({ status: "ready", ...result })}\n`);
+            return 0;
+        }
+        catch (error) {
+            const code = fixedErrorCode(error) ?? "SKILL_START_UNAVAILABLE";
+            errorOutput(`${JSON.stringify({ error: { code } })}\n`);
+            return 1;
+        }
+    }
     if (args.length !== 1 || args[0] !== "install") {
-        process.stderr.write(`${errorMessages.INVALID_INPUT}\n`);
+        errorOutput(`${errorMessages.INVALID_INPUT}\n`);
         return 1;
     }
     try {
         await runInstall({
-            reporter: (event) => process.stdout.write(`${messages[event]}\n`),
+            reporter: (event) => output(`${messages[event]}\n`),
         });
         return 0;
     }
     catch (error) {
         const code = error instanceof CliError ? error.code : "INSTALLATION_FAILED";
-        process.stderr.write(`${errorMessages[code] ?? errorMessages.INSTALLATION_FAILED}\n`);
+        errorOutput(`${errorMessages[code] ?? errorMessages.INSTALLATION_FAILED}\n`);
         return 1;
     }
 }
-process.exitCode = await main(process.argv.slice(2));
+if (process.argv[1] &&
+    path.resolve(process.argv[1]) === fileURLToPath(import.meta.url))
+    process.exitCode = await main(process.argv.slice(2));

package/dist/bundle.js

@@ -1,8 +1,7 @@
-import { spawn } from "node:child_process";
 import { createHash, createPublicKey, verify as verifySignature, } from "node:crypto";
 import { lstat, readFile, readdir } from "node:fs/promises";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { decodeArchive, safeArchivePath, writeArchive } from "./archive.js";
 import { CliError } from "./errors.js";
 const manifestKeys = [
     "artifactId",
@@ -18,9 +17,10 @@ const manifestKeys = [
     "version",
 ];
 const signatureKeys = ["algorithm", "keyId", "scope", "value"];
-const archiveName = "nggaigc-plugin-1.1.10.zip";
-const trustedKeyId = "ngg-signing-skill-release-1";
-const trustedKeySpkiSha256 = "3d7450a1a26785d900be03e52b4b7d0b2e84fe4e4fcb6f2e903c1371b0b96cee";
+const windowsPlatforms = ["win32-x64", "win32-arm64"];
+const desktopPlatforms = [...windowsPlatforms, "darwin-arm64"];
+export const trustedKeyId = "ngg-signing-skill-release-1";
+export const trustedKeySpkiSha256 = "3d7450a1a26785d900be03e52b4b7d0b2e84fe4e4fcb6f2e903c1371b0b96cee";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -28,16 +28,6 @@ function exactKeys(value, expected) {
     return (JSON.stringify(Object.keys(value).sort()) ===
         JSON.stringify([...expected].sort()));
 }
-function safeArchivePath(value) {
-    return (value.length >= 1 &&
-        value.length <= 240 &&
-        !value.startsWith("/") &&
-        !value.includes("\\") &&
-        !value.includes("\0") &&
-        value
-            .split("/")
-            .every((part) => part !== "" && part !== "." && part !== ".."));
-}
 async function json(file) {
     try {
         return JSON.parse(await readFile(file, "utf8"));
@@ -57,8 +47,9 @@ export async function verifyBundle(input) {
             !exactKeys(manifestValue, manifestKeys) ||
             manifestValue.schemaVersion !== "nggaigc-plugin-package/v1" ||
             manifestValue.artifactId !== "plugin.nggaigc" ||
-            manifestValue.version !== "1.1.10" ||
-            manifestValue.artifactPath !== `packages/plugins/${archiveName}` ||
+            manifestValue.version !== "1.1.14" ||
+            manifestValue.artifactPath !==
+                `packages/plugins/nggaigc-plugin-${manifestValue.version}.zip` ||
             typeof manifestValue.sourceCommit !== "string" ||
             !/^[a-f0-9]{40}$/.test(manifestValue.sourceCommit) ||
             typeof manifestValue.sha256 !== "string" ||
@@ -71,7 +62,7 @@ export async function verifyBundle(input) {
             !Number.isSafeInteger(manifestValue.fileCount) ||
             !Array.isArray(manifestValue.platforms) ||
             JSON.stringify(manifestValue.platforms) !==
-                JSON.stringify(["win32-x64", "win32-arm64"]) ||
+                JSON.stringify(desktopPlatforms) ||
             !record(manifestValue.files) ||
             Object.keys(manifestValue.files).length !== manifestValue.fileCount ||
             Object.entries(manifestValue.files).some(([name, digest]) => !safeArchivePath(name) ||
@@ -104,16 +95,50 @@ export async function verifyBundle(input) {
         const archiveFacts = await lstat(input.archive);
         if (!archiveFacts.isFile() || archiveFacts.isSymbolicLink())
             throw new Error();
+        if (archiveFacts.size !== manifestValue.sizeBytes)
+            throw new Error();
         const archive = await readFile(input.archive);
         if (archive.length !== manifestValue.sizeBytes ||
             createHash("sha256").update(archive).digest("hex") !==
                 manifestValue.sha256 ||
             !verifySignature(null, archive, publicKey, Buffer.from(signature.value, "base64")))
             throw new Error();
+        // Metadata is not covered by the artifact-bytes signature. Bind version,
+        // file hashes and new platform support to the actual signed ZIP payload.
+        const contents = decodeArchive(archive).filter((entry) => !entry.directory);
+        const actualFiles = Object.fromEntries(contents.map((entry) => [
+            entry.name,
+            createHash("sha256").update(entry.bytes).digest("hex"),
+        ]));
+        if (Object.keys(actualFiles).length !== manifestValue.fileCount ||
+            Object.entries(actualFiles).some(([name, hash]) => manifestValue.files[name] !== hash))
+            throw new Error();
+        const plugin = contents.find((entry) => entry.name === ".codex-plugin/plugin.json");
+        const pluginMetadata = plugin
+            ? JSON.parse(plugin.bytes.toString("utf8"))
+            : undefined;
+        if (!record(pluginMetadata) ||
+            pluginMetadata.version !== manifestValue.version)
+            throw new Error();
+        const supported = contents.find((entry) => entry.name === "skills/nggaigc/scripts/supported-platforms.json");
+        if (!supported)
+            throw new Error();
+        const capabilities = JSON.parse(supported.bytes.toString("utf8"));
+        if (!record(capabilities) ||
+            !exactKeys(capabilities, ["schemaVersion", "platforms"]) ||
+            capabilities.schemaVersion !== "nggaigc-supported-platforms/v1" ||
+            JSON.stringify(capabilities.platforms) !==
+                JSON.stringify(desktopPlatforms))
+            throw new Error();
+        const helper = contents.find((entry) => entry.name === "skills/nggaigc/scripts/macos-keychain");
+        if (!helper?.executable || helper.bytes.length < 8)
+            throw new Error();
         return {
             archive: path.resolve(input.archive),
             files: manifestValue.files,
             version: manifestValue.version,
+            platforms: manifestValue.platforms,
+            sha256: manifestValue.sha256,
         };
     }
     catch (error) {
@@ -122,60 +147,23 @@ export async function verifyBundle(input) {
         throw new CliError("PACKAGE_VERIFICATION_FAILED");
     }
 }
-function powershellPath() {
-    return path.join(process.env.SystemRoot ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
-}
-export async function extractBundle(archive, destination) {
-    const script = fileURLToPath(new URL("../scripts/expand-archive.ps1", import.meta.url));
-    await new Promise((resolve, reject) => {
-        const child = spawn(powershellPath(), [
-            "-NoLogo",
-            "-NoProfile",
-            "-NonInteractive",
-            "-File",
-            script,
-            "-Archive",
-            archive,
-            "-Destination",
-            destination,
-        ], {
-            windowsHide: true,
-            stdio: ["ignore", "pipe", "pipe"],
-            env: {
-                SystemRoot: process.env.SystemRoot,
-                LOCALAPPDATA: process.env.LOCALAPPDATA,
-                USERPROFILE: process.env.USERPROFILE,
-                PATH: process.env.PATH,
-            },
-        });
-        let bytes = 0;
-        let failed = false;
-        const limit = (chunk) => {
-            bytes += chunk.length;
-            if (bytes > 64 * 1024) {
-                failed = true;
-                child.kill();
-            }
-        };
-        child.stdout.on("data", limit);
-        child.stderr.on("data", limit);
-        const timer = setTimeout(() => {
-            failed = true;
-            child.kill();
-        }, 30_000);
-        timer.unref();
-        child.once("error", () => {
-            clearTimeout(timer);
-            reject(new CliError("ARCHIVE_EXTRACTION_FAILED"));
-        });
-        child.once("exit", (code) => {
-            clearTimeout(timer);
-            if (failed || code !== 0)
-                reject(new CliError("ARCHIVE_EXTRACTION_FAILED"));
-            else
-                resolve();
-        });
-    });
+export async function extractBundle(archive, destination, expectedSha256) {
+    try {
+        const facts = await lstat(archive);
+        if (!facts.isFile() ||
+            facts.isSymbolicLink() ||
+            facts.size > 64 * 1024 * 1024)
+            throw new Error();
+        const bytes = await readFile(archive);
+        if (expectedSha256 &&
+            createHash("sha256").update(bytes).digest("hex") !== expectedSha256)
+            throw new Error();
+        const contents = decodeArchive(bytes);
+        await writeArchive(contents, destination);
+    }
+    catch {
+        throw new CliError("ARCHIVE_EXTRACTION_FAILED");
+    }
 }
 async function entries(directory, prefix = "") {
     let children;