kiriya 0.1.0

package/dist/src/main.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * The composition root: the only file that constructs adapters and wires them in.
+ * Choosing an adapter by operating system happens here and nowhere else.
+ */
+import { readFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { BUILT_IN_MODULES } from "./config/modules.js";
+import { CommandRegistry } from "./core/application/command-registry.js";
+import { pluginEntries } from "./core/application/config-values.js";
+import { PathGuard } from "./core/application/path-guard.js";
+import { PluginLoader } from "./core/application/plugin-loader.js";
+import { ClosedStandardInput } from "./core/infrastructure/node/closed-standard-input.adapter.js";
+import { configFilePath } from "./core/infrastructure/node/config-location.js";
+import { JsonConfigStore } from "./core/infrastructure/node/json-config-store.adapter.js";
+import { NodeCompressionAdapter } from "./core/infrastructure/node/node-compression.adapter.js";
+import { NodeEnvironmentAdapter } from "./core/infrastructure/node/node-environment.adapter.js";
+import { NodeFileContentAdapter } from "./core/infrastructure/node/node-file-content.adapter.js";
+import { NodeFileSystemAdapter } from "./core/infrastructure/node/node-file-system.adapter.js";
+import { NodeHasherAdapter } from "./core/infrastructure/node/node-hasher.adapter.js";
+import { NodeNetworkAdapter } from "./core/infrastructure/node/node-network.adapter.js";
+import { NodePluginSource } from "./core/infrastructure/node/node-plugin-source.adapter.js";
+import { NodeProcessRunnerAdapter } from "./core/infrastructure/node/node-process-runner.adapter.js";
+import { NodeRandomSource } from "./core/infrastructure/node/node-random-source.adapter.js";
+import { NodeStandardInput } from "./core/infrastructure/node/node-standard-input.adapter.js";
+import { NodeSystemInfoAdapter } from "./core/infrastructure/node/node-system-info.adapter.js";
+import { SystemClockAdapter } from "./core/infrastructure/node/system-clock.adapter.js";
+import { FreedesktopTrashAdapter } from "./core/infrastructure/platform/linux/freedesktop-trash.adapter.js";
+import { LinuxClipboardAdapter } from "./core/infrastructure/platform/linux/linux-clipboard.adapter.js";
+import { LinuxOpenerAdapter } from "./core/infrastructure/platform/linux/linux-opener.adapter.js";
+import { LinuxPortTableAdapter } from "./core/infrastructure/platform/linux/linux-port-table.adapter.js";
+import { LinuxProcessTableAdapter } from "./core/infrastructure/platform/linux/linux-process-table.adapter.js";
+import { MacosClipboardAdapter } from "./core/infrastructure/platform/macos/macos-clipboard.adapter.js";
+import { MacosOpenerAdapter } from "./core/infrastructure/platform/macos/macos-opener.adapter.js";
+import { MacosPortTableAdapter } from "./core/infrastructure/platform/macos/macos-port-table.adapter.js";
+import { MacosProcessTableAdapter } from "./core/infrastructure/platform/macos/macos-process-table.adapter.js";
+import { MacosTrashAdapter } from "./core/infrastructure/platform/macos/macos-trash.adapter.js";
+import { WindowsClipboardAdapter } from "./core/infrastructure/platform/windows/windows-clipboard.adapter.js";
+import { WindowsOpenerAdapter } from "./core/infrastructure/platform/windows/windows-opener.adapter.js";
+import { WindowsPortTableAdapter } from "./core/infrastructure/platform/windows/windows-port-table.adapter.js";
+import { WindowsProcessTableAdapter } from "./core/infrastructure/platform/windows/windows-process-table.adapter.js";
+import { WindowsTrashAdapter } from "./core/infrastructure/platform/windows/windows-trash.adapter.js";
+import { splitGlobalFlags } from "./core/presentation/cli/argv.js";
+import { CliApplication } from "./core/presentation/cli/cli-application.js";
+import { serveMcp } from "./core/presentation/mcp/mcp-application.js";
+import { en } from "./i18n/locales/en.js";
+function trashFor(environment) {
+    switch (environment.os) {
+        case "windows":
+            return new WindowsTrashAdapter();
+        case "macos":
+            return new MacosTrashAdapter(environment);
+        case "linux":
+            return new FreedesktopTrashAdapter(environment);
+    }
+}
+function processTableFor(environment, processRunner) {
+    switch (environment.os) {
+        case "windows":
+            return new WindowsProcessTableAdapter(processRunner);
+        case "macos":
+            return new MacosProcessTableAdapter(processRunner);
+        case "linux":
+            return new LinuxProcessTableAdapter();
+    }
+}
+function portTableFor(environment, processRunner) {
+    switch (environment.os) {
+        case "windows":
+            return new WindowsPortTableAdapter(processRunner);
+        case "macos":
+            return new MacosPortTableAdapter(processRunner);
+        case "linux":
+            return new LinuxPortTableAdapter();
+    }
+}
+function clipboardFor(environment, processRunner) {
+    switch (environment.os) {
+        case "windows":
+            return new WindowsClipboardAdapter();
+        case "macos":
+            return new MacosClipboardAdapter();
+        case "linux":
+            return new LinuxClipboardAdapter(environment, processRunner);
+    }
+}
+function openerFor(environment, processRunner) {
+    switch (environment.os) {
+        case "windows":
+            return new WindowsOpenerAdapter();
+        case "macos":
+            return new MacosOpenerAdapter();
+        case "linux":
+            return new LinuxOpenerAdapter(environment, processRunner);
+    }
+}
+const { version } = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf8"));
+const argv = process.argv.slice(2);
+// Over MCP, stdin carries the protocol, so no command may read it.
+const servingMcp = splitGlobalFlags(argv).rest[0] === "mcp";
+const environment = new NodeEnvironmentAdapter();
+const config = new JsonConfigStore(configFilePath(environment, process.cwd()));
+const plugins = new PluginLoader();
+const processRunner = new NodeProcessRunnerAdapter();
+const registry = new CommandRegistry();
+const ports = {
+    fileSystem: new NodeFileSystemAdapter(),
+    fileContent: new NodeFileContentAdapter(),
+    hasher: new NodeHasherAdapter(),
+    compression: new NodeCompressionAdapter(),
+    processRunner,
+    trash: trashFor(environment),
+    environment,
+    clock: new SystemClockAdapter(),
+    random: new NodeRandomSource(),
+    stdin: servingMcp ? new ClosedStandardInput() : new NodeStandardInput(),
+    system: new NodeSystemInfoAdapter(environment, processRunner),
+    network: new NodeNetworkAdapter(),
+    processTable: processTableFor(environment, processRunner),
+    portTable: portTableFor(environment, processRunner),
+    clipboard: clipboardFor(environment, processRunner),
+    opener: openerFor(environment, processRunner),
+    commands: registry,
+    protectedPaths: new PathGuard(environment),
+    config,
+    plugins,
+    runtime: { kiriyaVersion: version, nodeVersion: process.version },
+};
+for (const module of BUILT_IN_MODULES)
+    registry.register(module, ports);
+// A configuration file kiriya cannot read loads no plugins; `kiriya doctor` and `kiriya config` report why.
+const entries = await config.read().then(pluginEntries, () => []);
+await plugins.load(entries, dirname(config.path), new NodePluginSource(), registry, ports);
+const catalog = { ...en, ...plugins.messages };
+const streams = { stdin: process.stdin, stdout: process.stdout, stderr: process.stderr };
+const cli = new CliApplication({
+    registry,
+    catalog,
+    version,
+    environment,
+    ...streams,
+    serveMcp: (input, cwd) => serveMcp({
+        registry,
+        catalog,
+        version,
+        fileSystem: ports.fileSystem,
+        config,
+        random: ports.random,
+        clock: ports.clock,
+        ...streams,
+    }, input, cwd),
+});
+process.exitCode = await cli.run(argv, process.cwd());
+//# sourceMappingURL=main.js.map

package/dist/src/modules/archive/application/archive-sources.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+import { DEPENDENCY_DIRECTORIES } from "../../../config/dependency-directories.js";
+import { expandPaths, outermost } from "../../../core/application/paths.js";
+import { walk } from "../../../core/application/walk.js";
+import { UsageError } from "../../../core/domain/errors.js";
+/** Every entry to store, gathered before writing starts, so a new archive never ends up inside itself. */
+export async function collectSources(fileSystem, paths, cwd, options) {
+    const sources = outermost(await expandPaths(fileSystem, paths, cwd, options.all));
+    const entries = [];
+    const topNames = new Set();
+    let skippedLinks = 0;
+    for (const source of sources) {
+        const name = path.basename(source);
+        if (topNames.has(name.toLowerCase()))
+            throw new UsageError("archive.same-name", { name });
+        topNames.add(name.toLowerCase());
+        const stat = await fileSystem.lstat(source);
+        if (stat === null)
+            continue;
+        if (stat.kind === "symlink") {
+            skippedLinks += 1;
+            continue;
+        }
+        if (stat.kind !== "directory") {
+            entries.push({ name, path: source, size: stat.size, modifiedMs: stat.modifiedMs, mode: stat.mode });
+            continue;
+        }
+        // A folder keeps its own name and everything inside it, hidden files included.
+        entries.push({ name: `${name}/`, path: null, size: 0, modifiedMs: stat.modifiedMs, mode: stat.mode });
+        const walkOptions = options.lean
+            ? { all: true, skipDirectories: DEPENDENCY_DIRECTORIES }
+            : { all: true };
+        for await (const entry of walk(fileSystem, source, walkOptions)) {
+            if (entry.kind === "symlink") {
+                skippedLinks += 1;
+                continue;
+            }
+            if (entry.kind !== "directory" && entry.kind !== "file")
+                continue;
+            const entryStat = await fileSystem.lstat(entry.path);
+            if (entryStat === null)
+                continue;
+            const isFolder = entry.kind === "directory";
+            entries.push({
+                name: `${name}/${entry.rel}${isFolder ? "/" : ""}`,
+                path: isFolder ? null : entry.path,
+                size: isFolder ? 0 : entryStat.size,
+                modifiedMs: entryStat.modifiedMs,
+                mode: entryStat.mode,
+            });
+        }
+    }
+    return { entries, skippedLinks };
+}
+//# sourceMappingURL=archive-sources.js.map

package/dist/src/modules/archive/application/create-tar.use-case.js

@@ -0,0 +1,123 @@
+import path from "node:path";
+import { done } from "../../../core/domain/command.js";
+import { ConflictError, InterruptedError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { TAR_END, tarCompression, tarHeader, tarPadding } from "../domain/tar-format.js";
+import { collectSources } from "./archive-sources.js";
+/** Files are read in pieces this size, so no file has to fit in memory. */
+const CHUNK_BYTES = 1024 * 1024;
+export const tarSpec = {
+    id: "archive.tar",
+    summary: "archive.tar.summary",
+    examples: [
+        "kiriya archive tar my-project --to my-project.tar.gz --lean",
+        'kiriya archive tar "logs/*.log" --to logs.tgz',
+        "kiriya archive tar dist --to dist.tar",
+    ],
+    safety: "write",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "paths", description: "archive.tar.arg.paths", required: true, variadic: true, path: true }],
+        options: {
+            to: { type: "string", description: "archive.tar.option.to", valueName: "<file.tar.gz>", path: true },
+            lean: { type: "boolean", description: "archive.tar.option.lean" },
+            all: { type: "boolean", description: "archive.tar.option.all" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const to = reader.string("to");
+            if (to === undefined)
+                throw new UsageError("archive.tar.to-required");
+            return { paths: reader.positionalsFrom(0), to, lean: reader.flag("lean"), all: reader.flag("all") };
+        },
+    },
+};
+/** The archive file, written through gzip when there is one. */
+class ArchiveSink {
+    writer;
+    gzip;
+    bytesOut = 0;
+    constructor(writer, gzip) {
+        this.writer = writer;
+        this.gzip = gzip;
+    }
+    async write(bytes) {
+        if (bytes.length === 0)
+            return;
+        await this.emit(this.gzip === null ? bytes : await this.gzip.push(bytes));
+    }
+    async finish() {
+        if (this.gzip !== null)
+            await this.emit(await this.gzip.end());
+        await this.writer.close();
+    }
+    async emit(bytes) {
+        if (bytes.length === 0)
+            return;
+        await this.writer.write(bytes);
+        this.bytesOut += bytes.length;
+    }
+}
+export class CreateTar {
+    fileSystem;
+    content;
+    compression;
+    spec = tarSpec;
+    constructor(fileSystem, content, compression) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+        this.compression = compression;
+    }
+    async execute(input, context) {
+        const archive = path.resolve(context.cwd, input.to);
+        const compressed = tarCompression(archive);
+        if (compressed === null)
+            throw new UsageError("archive.tar.extension", { path: input.to });
+        if ((await this.fileSystem.lstat(archive)) !== null)
+            throw new ConflictError("core.fs.exists", { path: archive });
+        const { entries, skippedLinks } = await collectSources(this.fileSystem, input.paths, context.cwd, input);
+        const writer = await this.content.createExclusive(archive);
+        const sink = new ArchiveSink(writer, compressed ? this.compression.gzip() : null);
+        let bytesIn = 0;
+        try {
+            for (const entry of entries) {
+                if (context.signal.aborted)
+                    throw new InterruptedError("core.error.interrupted");
+                bytesIn += await this.add(sink, entry);
+            }
+            await sink.write(TAR_END);
+            await sink.finish();
+        }
+        catch (error) {
+            // A failed archive leaves nothing behind.
+            await writer.discard();
+            throw error;
+        }
+        return done({ archive, entries: entries.length, bytesIn, bytesOut: sink.bytesOut, skippedLinks, compressed });
+    }
+    /** One entry's header and content. The size is taken when the file opens, in case it changed since it was listed. */
+    async add(sink, entry) {
+        if (entry.path === null) {
+            await sink.write(tarHeader({ name: entry.name, isDirectory: true, size: 0, mode: 0o755, modifiedMs: entry.modifiedMs }));
+            return 0;
+        }
+        const reader = await this.content.openForReading(entry.path);
+        try {
+            // Executable files stay executable; everything else is readable by all and writable by its owner.
+            const mode = (entry.mode & 0o111) !== 0 ? 0o755 : 0o644;
+            const size = reader.size;
+            await sink.write(tarHeader({ name: entry.name, isDirectory: false, size, mode, modifiedMs: entry.modifiedMs }));
+            for (let position = 0; position < size; position += CHUNK_BYTES) {
+                await sink.write(await reader.readAt(position, Math.min(CHUNK_BYTES, size - position)));
+            }
+            await sink.write(new Uint8Array(tarPadding(size)));
+            return size;
+        }
+        finally {
+            await reader.close();
+        }
+    }
+}
+//# sourceMappingURL=create-tar.use-case.js.map

package/dist/src/modules/archive/application/create-zip.use-case.js

@@ -0,0 +1,106 @@
+import path from "node:path";
+import { done } from "../../../core/domain/command.js";
+import { ConflictError, InterruptedError, OperationFailedError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { crc32 } from "../domain/crc32.js";
+import { centralHeader, DEFLATED, endRecord, localHeader, MAX_ENTRIES, STORED, ZIP32_LIMIT, } from "../domain/zip-format.js";
+import { collectSources } from "./archive-sources.js";
+export const zipSpec = {
+    id: "archive.zip",
+    summary: "archive.zip.summary",
+    examples: [
+        "kiriya archive zip my-project --to my-project.zip --lean",
+        'kiriya archive zip "reports/*.pdf" --to reports.zip',
+        "kiriya archive zip src docs README.md --to handover.zip",
+    ],
+    safety: "write",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "paths", description: "archive.zip.arg.paths", required: true, variadic: true, path: true }],
+        options: {
+            to: { type: "string", description: "archive.zip.option.to", valueName: "<file.zip>", path: true },
+            lean: { type: "boolean", description: "archive.zip.option.lean" },
+            all: { type: "boolean", description: "archive.zip.option.all" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const to = reader.string("to");
+            if (to === undefined)
+                throw new UsageError("archive.zip.to-required");
+            return { paths: reader.positionalsFrom(0), to, lean: reader.flag("lean"), all: reader.flag("all") };
+        },
+    },
+};
+export class CreateZip {
+    fileSystem;
+    content;
+    compression;
+    spec = zipSpec;
+    constructor(fileSystem, content, compression) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+        this.compression = compression;
+    }
+    async execute(input, context) {
+        const archive = path.resolve(context.cwd, input.to);
+        if ((await this.fileSystem.lstat(archive)) !== null)
+            throw new ConflictError("core.fs.exists", { path: archive });
+        const { entries, skippedLinks } = await collectSources(this.fileSystem, input.paths, context.cwd, input);
+        if (entries.length >= MAX_ENTRIES) {
+            throw new OperationFailedError("archive.zip.too-many-entries", { count: entries.length });
+        }
+        const writer = await this.content.createExclusive(archive);
+        let offset = 0;
+        let bytesIn = 0;
+        const write = async (bytes) => {
+            await writer.write(bytes);
+            offset += bytes.length;
+        };
+        try {
+            const central = [];
+            for (const entry of entries) {
+                if (context.signal.aborted)
+                    throw new InterruptedError("core.error.interrupted");
+                if (entry.size >= ZIP32_LIMIT)
+                    throw new OperationFailedError("archive.zip.entry-too-large", { name: entry.name });
+                if (offset >= ZIP32_LIMIT)
+                    throw new OperationFailedError("archive.zip.archive-too-large", { path: archive });
+                const data = entry.path === null ? new Uint8Array(0) : await this.content.read(entry.path);
+                if (data.length >= ZIP32_LIMIT)
+                    throw new OperationFailedError("archive.zip.entry-too-large", { name: entry.name });
+                const deflated = entry.path === null ? data : await this.compression.deflateRaw(data);
+                const method = entry.path !== null && deflated.length < data.length ? DEFLATED : STORED;
+                const stored = method === DEFLATED ? deflated : data;
+                const header = {
+                    name: entry.name,
+                    isDirectory: entry.path === null,
+                    method,
+                    crc: crc32(data),
+                    compressedSize: stored.length,
+                    size: data.length,
+                    modifiedMs: entry.modifiedMs,
+                };
+                central.push(centralHeader(header, offset));
+                await write(localHeader(header));
+                await write(stored);
+                bytesIn += data.length;
+            }
+            const directoryOffset = offset;
+            for (const bytes of central)
+                await write(bytes);
+            if (offset >= ZIP32_LIMIT)
+                throw new OperationFailedError("archive.zip.archive-too-large", { path: archive });
+            await write(endRecord({ count: entries.length, size: offset - directoryOffset, offset: directoryOffset }));
+            await writer.close();
+        }
+        catch (error) {
+            // A failed archive leaves nothing behind.
+            await writer.discard();
+            throw error;
+        }
+        return done({ archive, entries: entries.length, bytesIn, bytesOut: offset, skippedLinks });
+    }
+}
+//# sourceMappingURL=create-zip.use-case.js.map

package/dist/src/modules/archive/application/extract-tar.use-case.js

@@ -0,0 +1,240 @@
+import path from "node:path";
+import { isInside } from "../../../core/application/paths.js";
+import { requireTypedConfirmation } from "../../../core/application/safety.js";
+import { done } from "../../../core/domain/command.js";
+import { ConflictError, KiriyaError, NotFoundError, OperationFailedError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { invalidNameReason } from "../../../core/domain/names.js";
+import { safeEntrySegments } from "../domain/zip-format.js";
+import { readTar } from "./tar-reader.js";
+/** Names listed per kind of problem before the rest are counted. */
+const REPORT_LIMIT = 20;
+export const untarSpec = {
+    id: "archive.untar",
+    summary: "archive.untar.summary",
+    examples: [
+        "kiriya archive untar release.tar.gz",
+        "kiriya archive untar release.tgz --list",
+        "kiriya archive untar node.tar.gz --to vendor/node --overwrite",
+    ],
+    safety: "destroy",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "archive", description: "archive.untar.arg.archive", required: true, variadic: false, path: true },
+        ],
+        options: {
+            to: { type: "string", description: "archive.untar.option.to", valueName: "<folder>", path: true },
+            list: { type: "boolean", description: "archive.untar.option.list" },
+            overwrite: { type: "boolean", description: "archive.untar.option.overwrite" },
+            confirm: {
+                type: "string",
+                description: "archive.untar.option.confirm",
+                valueName: "<count>",
+                terminalOnly: true,
+            },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                archive: reader.positional(0) ?? "",
+                to: reader.string("to"),
+                list: reader.flag("list"),
+                overwrite: reader.flag("overwrite"),
+                confirm: reader.string("confirm"),
+            };
+        },
+    },
+};
+/** The default folder: the archive's name without .tar.gz, .tgz or .tar, next to it. */
+export function defaultTarget(archive) {
+    const name = path.basename(archive);
+    let base = name.replace(/(\.tar\.gz|\.tgz|\.tar)$/i, "");
+    if (base === name)
+        base = path.basename(name, path.extname(name));
+    if (base === name || base === "")
+        base = `${name}-extracted`;
+    return path.join(path.dirname(archive), base);
+}
+export class ExtractTar {
+    fileSystem;
+    content;
+    compression;
+    spec = untarSpec;
+    constructor(fileSystem, content, compression) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+        this.compression = compression;
+    }
+    async execute(input, context) {
+        const archive = path.resolve(context.cwd, input.archive);
+        if ((await this.fileSystem.lstat(archive)) === null) {
+            throw new NotFoundError("core.fs.not-found", { path: archive });
+        }
+        // A first pass reads only the headers, so nothing is written before every name has been checked.
+        const entries = [];
+        await readTar(this.content, this.compression, archive, context.signal, (event) => {
+            if (event.kind === "entry")
+                entries.push(event.entry);
+            return Promise.resolve();
+        });
+        if (input.list) {
+            const listed = entries.map(({ name, type, size, modifiedMs }) => ({ name, type, size, modifiedMs }));
+            const bytes = entries.reduce((sum, entry) => sum + (entry.type === "file" ? entry.size : 0), 0);
+            return done({ mode: "list", archive, entries: listed, bytes });
+        }
+        return this.extract(entries, archive, input, context);
+    }
+    async extract(entries, archive, input, context) {
+        const target = path.resolve(context.cwd, input.to ?? defaultTarget(archive));
+        const plan = new Map();
+        const unsafe = [];
+        const skipped = [];
+        const failures = [];
+        let skippedLinks = 0;
+        entries.forEach((entry, index) => {
+            // A link can point anywhere, so extracting one could let later entries escape the target.
+            if (entry.type === "link" || entry.type === "other") {
+                skippedLinks += 1;
+                return;
+            }
+            const segments = safeEntrySegments(entry.name);
+            if (segments === null) {
+                unsafe.push(entry.name);
+                return;
+            }
+            if (segments.length === 0)
+                return;
+            const invalid = segments
+                .map((segment) => ({ segment, reason: invalidNameReason(segment) }))
+                .find((item) => item.reason !== null);
+            if (invalid !== undefined && invalid.reason !== null) {
+                skipped.push(entry.name);
+                const reason = message(invalid.reason, { name: invalid.segment });
+                failures.push(message("archive.unzip.invalid-name", { name: entry.name, reason }));
+                return;
+            }
+            const destination = path.join(target, ...segments);
+            if (isInside(destination, target))
+                plan.set(index, destination);
+            else
+                unsafe.push(entry.name);
+        });
+        const result = {
+            mode: "extract",
+            archive,
+            target,
+            extracted: false,
+            files: 0,
+            bytes: 0,
+            unsafe,
+            skipped,
+            conflicts: [],
+            skippedLinks,
+        };
+        if (unsafe.length > 0) {
+            const names = unsafe.slice(0, REPORT_LIMIT).map((name) => message("archive.unzip.unsafe-name", { name }));
+            return done(result, { failures: [...names, message("archive.unzip.unsafe-archive")] });
+        }
+        const conflicts = [];
+        for (const [index, destination] of plan) {
+            if (entries[index]?.type === "file" && (await this.fileSystem.lstat(destination)) !== null) {
+                conflicts.push(destination);
+            }
+        }
+        if (conflicts.length > 0) {
+            if (!input.overwrite) {
+                const existing = conflicts
+                    .slice(0, REPORT_LIMIT)
+                    .map((conflict) => message("core.fs.exists", { path: conflict }));
+                const more = conflicts.length > REPORT_LIMIT
+                    ? [message("core.list.more", { count: conflicts.length - REPORT_LIMIT })]
+                    : [];
+                return done({ ...result, conflicts }, { failures: [...failures, ...existing], warnings: [...more, message("archive.unzip.nothing-extracted")] });
+            }
+            const warning = message("archive.unzip.warn-overwrite", { count: conflicts.length, target });
+            await requireTypedConfirmation(context, warning, String(conflicts.length), input.confirm);
+        }
+        const written = await this.write(entries, plan, archive, failures, context.signal);
+        return done({ ...result, conflicts, extracted: true, ...written }, { failures });
+    }
+    /** The second pass: the same entries again, now with their data written out. */
+    async write(entries, plan, archive, failures, signal) {
+        const progress = {
+            index: -1,
+            open: null,
+            files: 0,
+            bytes: 0,
+        };
+        const fail = async (current, error) => {
+            if (!(error instanceof KiriyaError))
+                throw error;
+            failures.push(message("archive.unzip.entry-failed", { name: current.entry.name, reason: error.detail }));
+            await current.writer?.discard();
+            current.writer = null;
+        };
+        try {
+            await readTar(this.content, this.compression, archive, signal, async (event) => {
+                if (event.kind === "entry") {
+                    progress.index += 1;
+                    const expected = entries[progress.index];
+                    if (expected?.name !== event.entry.name || expected.size !== event.entry.size) {
+                        throw new OperationFailedError("archive.untar.changed", { path: archive });
+                    }
+                    const destination = plan.get(progress.index);
+                    const next = destination === undefined ? null : { entry: event.entry, destination, writer: null };
+                    progress.open = next;
+                    if (next !== null)
+                        await this.begin(next).catch((error) => fail(next, error));
+                    return;
+                }
+                const current = progress.open;
+                // A folder, an entry that is not extracted, or a file whose writing already failed.
+                if (current?.writer === null || current?.writer === undefined)
+                    return;
+                const writer = current.writer;
+                if (event.kind === "data") {
+                    await writer.write(event.bytes).catch((error) => fail(current, error));
+                    return;
+                }
+                progress.open = null;
+                try {
+                    await writer.close();
+                    current.writer = null;
+                    await this.fileSystem.setTimes(current.destination, current.entry.modifiedMs, current.entry.modifiedMs);
+                    // The owner keeps read and write access, whatever the archive says.
+                    await this.fileSystem.setMode(current.destination, (current.entry.mode & 0o777) | 0o600);
+                    progress.files += 1;
+                    progress.bytes += current.entry.size;
+                }
+                catch (error) {
+                    await fail(current, error);
+                }
+            });
+        }
+        catch (error) {
+            await progress.open?.writer?.discard();
+            throw error;
+        }
+        return { files: progress.files, bytes: progress.bytes };
+    }
+    /** Makes the folder, or opens the file for writing, replacing a file already there. */
+    async begin(open) {
+        if (open.entry.type === "directory") {
+            await this.fileSystem.createDirectory(open.destination);
+            return;
+        }
+        const existing = await this.fileSystem.lstat(open.destination);
+        if (existing?.kind === "directory") {
+            throw new ConflictError("archive.unzip.folder-in-the-way", { name: open.entry.name });
+        }
+        await this.fileSystem.createDirectory(path.dirname(open.destination));
+        if (existing !== null)
+            await this.fileSystem.remove(open.destination);
+        open.writer = await this.content.createExclusive(open.destination);
+    }
+}
+//# sourceMappingURL=extract-tar.use-case.js.map