kiriya 0.1.0

package/dist/src/core/infrastructure/node/node-file-system.adapter.js

@@ -0,0 +1,169 @@
+import { chmod, cp, lstat, mkdir, readdir, readlink, realpath, rename, rm, rmdir, stat, utimes, writeFile, } from "node:fs/promises";
+import { ConflictError } from "../../domain/errors.js";
+import { errorCode, isMissing, translateFsError } from "./fs-errors.js";
+function kindOf(entry) {
+    if (entry.isSymbolicLink())
+        return "symlink";
+    if (entry.isDirectory())
+        return "directory";
+    if (entry.isFile())
+        return "file";
+    return "other";
+}
+function toStat(stats) {
+    return {
+        kind: kindOf(stats),
+        size: stats.size,
+        modifiedMs: Math.floor(stats.mtimeMs),
+        createdMs: Math.floor(stats.birthtimeMs),
+        accessedMs: Math.floor(stats.atimeMs),
+        mode: stats.mode,
+        device: stats.dev,
+    };
+}
+export class NodeFileSystemAdapter {
+    async lstat(path) {
+        try {
+            return toStat(await lstat(path));
+        }
+        catch (error) {
+            if (isMissing(error))
+                return null;
+            return translateFsError(error, path);
+        }
+    }
+    async stat(path) {
+        try {
+            return toStat(await stat(path));
+        }
+        catch (error) {
+            if (isMissing(error))
+                return null;
+            return translateFsError(error, path);
+        }
+    }
+    async readDirectory(path) {
+        try {
+            const entries = await readdir(path, { withFileTypes: true });
+            return entries.map((entry) => ({ name: entry.name, kind: kindOf(entry) }));
+        }
+        catch (error) {
+            return translateFsError(error, path);
+        }
+    }
+    async readLink(path) {
+        try {
+            return await readlink(path);
+        }
+        catch (error) {
+            return translateFsError(error, path);
+        }
+    }
+    async realPath(path) {
+        try {
+            return await realpath(path);
+        }
+        catch (error) {
+            if (isMissing(error))
+                return null;
+            return translateFsError(error, path);
+        }
+    }
+    async createDirectory(path) {
+        try {
+            await mkdir(path, { recursive: true });
+        }
+        catch (error) {
+            translateFsError(error, path);
+        }
+    }
+    async createFile(path, content) {
+        try {
+            await writeFile(path, content, { encoding: "utf8", flag: "wx" });
+        }
+        catch (error) {
+            translateFsError(error, path);
+        }
+    }
+    async remove(path) {
+        try {
+            await rm(path, { recursive: true, force: false, maxRetries: 3 });
+        }
+        catch (error) {
+            translateFsError(error, path);
+        }
+    }
+    async copy(source, destination, overwrite) {
+        try {
+            await cp(source, destination, {
+                recursive: true,
+                preserveTimestamps: true,
+                force: overwrite,
+                errorOnExist: !overwrite,
+                verbatimSymlinks: true,
+            });
+        }
+        catch (error) {
+            translateFsError(error, destination);
+        }
+    }
+    async move(source, destination) {
+        // rename replaces an existing file on Linux and macOS, so the check comes first.
+        if ((await this.lstat(destination)) !== null)
+            throw new ConflictError("core.fs.exists", { path: destination });
+        try {
+            await rename(source, destination);
+            return;
+        }
+        catch (error) {
+            if (errorCode(error) !== "EXDEV")
+                translateFsError(error, source);
+        }
+        try {
+            await this.copy(source, destination, false);
+            await rm(source, { recursive: true, force: true, maxRetries: 3 });
+        }
+        catch (error) {
+            translateFsError(error, source);
+        }
+    }
+    async setTimes(path, accessedMs, modifiedMs) {
+        try {
+            await utimes(path, new Date(accessedMs), new Date(modifiedMs));
+        }
+        catch (error) {
+            translateFsError(error, path);
+        }
+    }
+    async setMode(path, mode) {
+        try {
+            await chmod(path, mode);
+        }
+        catch (error) {
+            translateFsError(error, path);
+        }
+    }
+    async sameEntry(first, second) {
+        try {
+            const [a, b] = await Promise.all([lstat(first, { bigint: true }), lstat(second, { bigint: true })]);
+            // Some file systems, such as FAT, report no file ids at all.
+            return a.ino !== 0n && a.ino === b.ino && a.dev === b.dev;
+        }
+        catch {
+            return false;
+        }
+    }
+    async removeEmptyDirectory(path) {
+        try {
+            await rmdir(path);
+            return true;
+        }
+        catch (error) {
+            const code = errorCode(error);
+            if (code === "ENOTEMPTY" || code === "EEXIST")
+                return false;
+            return translateFsError(error, path);
+        }
+    }
+}
+//# sourceMappingURL=node-file-system.adapter.js.map

package/dist/src/core/infrastructure/node/node-hasher.adapter.js

@@ -0,0 +1,32 @@
+import { createHash } from "node:crypto";
+import { open } from "node:fs/promises";
+import { translateFsError } from "./fs-errors.js";
+const CHUNK_BYTES = 1024 * 1024;
+export class NodeHasherAdapter {
+    async hashFile(path, algorithm, limitBytes = Number.POSITIVE_INFINITY) {
+        const hash = createHash(algorithm);
+        const handle = await open(path, "r").catch((error) => translateFsError(error, path));
+        try {
+            const buffer = new Uint8Array(CHUNK_BYTES);
+            let total = 0;
+            for (;;) {
+                const wanted = Math.min(buffer.length, limitBytes - total);
+                if (wanted <= 0)
+                    break;
+                const { bytesRead } = await handle.read(buffer, 0, wanted, null);
+                if (bytesRead === 0)
+                    break;
+                hash.update(buffer.subarray(0, bytesRead));
+                total += bytesRead;
+            }
+            return hash.digest("hex");
+        }
+        catch (error) {
+            return translateFsError(error, path);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+}
+//# sourceMappingURL=node-hasher.adapter.js.map

package/dist/src/core/infrastructure/node/node-network.adapter.js

@@ -0,0 +1,168 @@
+import { Resolver, lookup as systemLookup } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { createConnection } from "node:net";
+import { networkInterfaces } from "node:os";
+import { InterruptedError } from "../../domain/errors.js";
+const CONNECT_FAILURES = {
+    ECONNREFUSED: "refused",
+    ETIMEDOUT: "timeout",
+    ENOTFOUND: "not-found",
+    EAI_AGAIN: "not-found",
+    EAI_NONAME: "not-found",
+    EHOSTUNREACH: "unreachable",
+    ENETUNREACH: "unreachable",
+    EADDRNOTAVAIL: "unreachable",
+};
+const LOOKUP_FAILURES = {
+    ENOTFOUND: "not-found",
+    ENODATA: "not-found",
+    EAI_NONAME: "not-found",
+    ETIMEOUT: "timeout",
+    EAI_AGAIN: "timeout",
+};
+/** The code Node.js gives an error, looking inside the AggregateError that trying several addresses produces. */
+function errorCode(error) {
+    if (typeof error !== "object" || error === null)
+        return null;
+    if ("code" in error && typeof error.code === "string")
+        return error.code;
+    if (error instanceof AggregateError)
+        return errorCode(error.errors[0]);
+    return null;
+}
+/** A certificate or TLS problem is told apart, since trying again does not fix it by itself. */
+function httpFailure(code) {
+    if (code === null)
+        return "failed";
+    if (code.startsWith("ERR_TLS_") || code.startsWith("ERR_SSL_") || /CERT|SELF_SIGNED/.test(code))
+        return "tls";
+    return CONNECT_FAILURES[code] ?? "failed";
+}
+function lookupFailure(error) {
+    const code = errorCode(error);
+    return { ok: false, failure: (code === null ? undefined : LOOKUP_FAILURES[code]) ?? "failed", code };
+}
+async function records(resolver, name, type) {
+    const plain = (recordType) => (value) => ({ type: recordType, value, priority: null });
+    switch (type) {
+        case "a":
+            return (await resolver.resolve4(name)).map(plain("A"));
+        case "aaaa":
+            return (await resolver.resolve6(name)).map(plain("AAAA"));
+        case "cname":
+            return (await resolver.resolveCname(name)).map(plain("CNAME"));
+        case "ns":
+            return (await resolver.resolveNs(name)).map(plain("NS"));
+        case "txt":
+            // A TXT record arrives in chunks of at most 255 characters.
+            return (await resolver.resolveTxt(name)).map((chunks) => plain("TXT")(chunks.join("")));
+        case "mx":
+            return (await resolver.resolveMx(name))
+                .sort((first, second) => first.priority - second.priority)
+                .map((entry) => ({ type: "MX", value: entry.exchange, priority: entry.priority }));
+    }
+}
+export class NodeNetworkAdapter {
+    addresses() {
+        return Object.entries(networkInterfaces()).flatMap(([interfaceName, entries]) => (entries ?? []).map((entry) => ({
+            interfaceName,
+            family: entry.family,
+            address: entry.address,
+            cidr: entry.cidr,
+            mac: entry.mac,
+            internal: entry.internal,
+        })));
+    }
+    connect(host, port, timeoutMs, signal) {
+        if (signal.aborted)
+            return Promise.reject(new InterruptedError("core.error.interrupted"));
+        return new Promise((resolve, reject) => {
+            const started = performance.now();
+            const elapsed = () => Math.round(performance.now() - started);
+            const socket = createConnection({ host, port });
+            // null means the run was interrupted.
+            const settle = (outcome) => {
+                clearTimeout(timer);
+                signal.removeEventListener("abort", onAbort);
+                socket.destroy();
+                if (outcome === null)
+                    reject(new InterruptedError("core.error.interrupted"));
+                else
+                    resolve(outcome);
+            };
+            const onAbort = () => settle(null);
+            const timer = setTimeout(() => settle({ ok: false, failure: "timeout", code: null, ms: elapsed() }), timeoutMs);
+            signal.addEventListener("abort", onAbort, { once: true });
+            socket.once("connect", () => settle({ ok: true, address: socket.remoteAddress ?? host, ms: elapsed() }));
+            socket.once("error", (error) => {
+                const code = errorCode(error);
+                const failure = (code === null ? undefined : CONNECT_FAILURES[code]) ?? "failed";
+                settle({ ok: false, failure, code, ms: elapsed() });
+            });
+        });
+    }
+    request(url, timeoutMs, signal) {
+        if (signal.aborted)
+            return Promise.reject(new InterruptedError("core.error.interrupted"));
+        return new Promise((resolve, reject) => {
+            const started = performance.now();
+            const elapsed = () => Math.round(performance.now() - started);
+            const target = new URL(url);
+            const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+            const outgoing = send(target, { method: "GET", headers: { "user-agent": "kiriya" } });
+            let settled = false;
+            // null means the run was interrupted.
+            const settle = (outcome) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                signal.removeEventListener("abort", onAbort);
+                outgoing.destroy();
+                if (outcome === null)
+                    reject(new InterruptedError("core.error.interrupted"));
+                else
+                    resolve(outcome);
+            };
+            const onAbort = () => settle(null);
+            const timer = setTimeout(() => settle({ ok: false, failure: "timeout", code: null, ms: elapsed() }), timeoutMs);
+            signal.addEventListener("abort", onAbort, { once: true });
+            outgoing.once("response", (response) => {
+                // The status is all a wait needs, so the body is never read.
+                response.destroy();
+                settle({ ok: true, status: response.statusCode ?? 0, ms: elapsed() });
+            });
+            // Kept after settling, because destroying the request can still emit an error.
+            outgoing.on("error", (error) => {
+                const code = errorCode(error);
+                settle({ ok: false, failure: httpFailure(code), code, ms: elapsed() });
+            });
+            outgoing.end();
+        });
+    }
+    async lookup(name) {
+        try {
+            const found = await systemLookup(name, { all: true });
+            const addresses = found.map((entry) => ({
+                type: entry.family === 6 ? "AAAA" : "A",
+                value: entry.address,
+                priority: null,
+            }));
+            return { ok: true, records: addresses };
+        }
+        catch (error) {
+            return lookupFailure(error);
+        }
+    }
+    async resolve(name, type, timeoutMs) {
+        const resolver = new Resolver({ timeout: timeoutMs, tries: 2 });
+        try {
+            return { ok: true, records: await records(resolver, name, type) };
+        }
+        catch (error) {
+            return lookupFailure(error);
+        }
+    }
+}
+//# sourceMappingURL=node-network.adapter.js.map

package/dist/src/core/infrastructure/node/node-plugin-source.adapter.js

@@ -0,0 +1,89 @@
+import { readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { NotFoundError, OperationFailedError } from "../../domain/errors.js";
+const PACKAGE_NAME = /^(@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*$/i;
+async function kindOf(target) {
+    try {
+        const found = await stat(target);
+        return found.isDirectory() ? "directory" : found.isFile() ? "file" : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function manifestOf(folder) {
+    try {
+        return JSON.parse(await readFile(path.join(folder, "package.json"), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+const field = (value, name) => typeof value === "object" && value !== null ? value[name] : undefined;
+/** A package folder's ES module entry: its "." export, then "main", then index.js. */
+function entryFile(folder, manifest) {
+    const root = typeof manifest?.exports === "string" ? manifest.exports : field(manifest?.exports, ".");
+    const conditional = typeof root === "string" ? root : (field(root, "import") ?? field(root, "default"));
+    if (typeof conditional === "string")
+        return path.resolve(folder, conditional);
+    if (typeof manifest?.main === "string")
+        return path.resolve(folder, manifest.main);
+    return path.join(folder, "index.js");
+}
+/**
+ * Where a package name may be installed: node_modules above kiriya itself, which is
+ * where global installs sit side by side, then node_modules above the configuration file.
+ */
+function packageFolders(name, baseDirectory) {
+    const folders = [];
+    for (const start of [path.dirname(fileURLToPath(import.meta.url)), baseDirectory]) {
+        for (let current = start;; current = path.dirname(current)) {
+            folders.push(path.join(current, "node_modules", name));
+            if (path.dirname(current) === current)
+                break;
+        }
+    }
+    return folders;
+}
+export class NodePluginSource {
+    async load(entry, baseDirectory) {
+        let folder = null;
+        let file = null;
+        if (entry.startsWith(".") || path.isAbsolute(entry)) {
+            const target = path.resolve(baseDirectory, entry);
+            const kind = await kindOf(target);
+            if (kind === "file")
+                file = target;
+            if (kind === "directory")
+                folder = target;
+        }
+        else if (PACKAGE_NAME.test(entry)) {
+            for (const candidate of packageFolders(entry, baseDirectory)) {
+                if ((await kindOf(candidate)) === "directory") {
+                    folder = candidate;
+                    break;
+                }
+            }
+        }
+        if (folder === null && file === null)
+            throw new NotFoundError("core.plugin.not-found", { entry });
+        const manifest = folder === null ? null : await manifestOf(folder);
+        const location = file ?? entryFile(folder ?? "", manifest);
+        let exports;
+        try {
+            exports = await import(pathToFileURL(location).href);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new OperationFailedError("core.plugin.import-failed", { entry, detail }, { cause: error });
+        }
+        return {
+            location,
+            name: typeof manifest?.name === "string" ? manifest.name : null,
+            version: typeof manifest?.version === "string" ? manifest.version : null,
+            exports,
+        };
+    }
+}
+//# sourceMappingURL=node-plugin-source.adapter.js.map

package/dist/src/core/infrastructure/node/node-process-runner.adapter.js

@@ -0,0 +1,48 @@
+import { constants } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import path from "node:path";
+import { CapabilityUnavailableError, InterruptedError } from "../../domain/errors.js";
+import { runProgram } from "./run-program.js";
+/**
+ * Without a shell, Windows starts only real executables, so PATH is searched for
+ * .exe and .com files there; batch files would need cmd.exe and are not found.
+ */
+const WINDOWS_EXTENSIONS = [".exe", ".com"];
+export class NodeProcessRunnerAdapter {
+    async find(program) {
+        const windows = process.platform === "win32";
+        const extensions = !windows || path.extname(program) !== "" ? [""] : WINDOWS_EXTENSIONS;
+        const directories = (process.env["PATH"] ?? "").split(path.delimiter).filter((directory) => directory !== "");
+        for (const directory of directories) {
+            for (const extension of extensions) {
+                const candidate = path.join(directory, `${program}${extension}`);
+                try {
+                    if (!(await stat(candidate)).isFile())
+                        continue;
+                    if (!windows)
+                        await access(candidate, constants.X_OK);
+                    return candidate;
+                }
+                catch {
+                    // Not in this folder, or not executable: keep looking.
+                }
+            }
+        }
+        return null;
+    }
+    async run(program, args, options = {}) {
+        try {
+            const result = await runProgram(program, args, options);
+            return { code: result.code, stdout: result.stdout, stderr: result.stderr };
+        }
+        catch (error) {
+            // Aborting the signal kills the program, which Node.js reports as an error.
+            if (options.signal?.aborted === true) {
+                throw new InterruptedError("core.error.interrupted", {}, { cause: error });
+            }
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new CapabilityUnavailableError("core.process.cannot-start", { program, detail }, { cause: error });
+        }
+    }
+}
+//# sourceMappingURL=node-process-runner.adapter.js.map

package/dist/src/core/infrastructure/node/node-random-source.adapter.js

@@ -0,0 +1,7 @@
+import { randomFillSync } from "node:crypto";
+export class NodeRandomSource {
+    bytes(count) {
+        return randomFillSync(new Uint8Array(count));
+    }
+}
+//# sourceMappingURL=node-random-source.adapter.js.map

package/dist/src/core/infrastructure/node/node-standard-input.adapter.js

@@ -0,0 +1,24 @@
+import { OperationFailedError } from "../../domain/errors.js";
+import { formatBytes } from "../../domain/values/bytes.js";
+export class NodeStandardInput {
+    stream;
+    constructor(stream = process.stdin) {
+        this.stream = stream;
+    }
+    get isTerminal() {
+        return this.stream.isTTY === true;
+    }
+    async read(maxBytes) {
+        const chunks = [];
+        let total = 0;
+        for await (const chunk of this.stream) {
+            const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+            total += buffer.length;
+            if (total > maxBytes)
+                throw new OperationFailedError("core.stdin.too-large", { limit: formatBytes(maxBytes) });
+            chunks.push(buffer);
+        }
+        return Buffer.concat(chunks);
+    }
+}
+//# sourceMappingURL=node-standard-input.adapter.js.map

package/dist/src/core/infrastructure/node/node-system-info.adapter.js

@@ -0,0 +1,63 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+/** PRETTY_NAME from the text of an os-release file, or null. */
+export function prettyNameFromOsRelease(text) {
+    for (const line of text.split(/\r?\n/)) {
+        const match = /^PRETTY_NAME=(.*)$/.exec(line.trim());
+        if (match === null)
+            continue;
+        const value = (match[1] ?? "").trim().replace(/^(["'])(.*)\1$/, "$2");
+        return value === "" ? null : value;
+    }
+    return null;
+}
+/** Windows 11 still names itself Windows 10 where Node.js reads the name; its builds start at 22000. */
+export function windowsName(version, release) {
+    const build = Number(release.split(".")[2] ?? "0");
+    return build >= 22000 ? version.replace(/^Windows 10\b/, "Windows 11") : version;
+}
+export class NodeSystemInfoAdapter {
+    environment;
+    processRunner;
+    constructor(environment, processRunner) {
+        this.environment = environment;
+        this.processRunner = processRunner;
+    }
+    async read() {
+        const { locale, timeZone } = Intl.DateTimeFormat().resolvedOptions();
+        return {
+            os: this.environment.os,
+            osName: await this.osName(),
+            kernel: os.release(),
+            arch: os.arch(),
+            cpuModel: os.cpus()[0]?.model.trim() ?? "",
+            cpuCount: os.availableParallelism(),
+            memoryTotalBytes: os.totalmem(),
+            memoryFreeBytes: os.freemem(),
+            uptimeSeconds: Math.floor(os.uptime()),
+            hostname: os.hostname(),
+            locale,
+            timeZone,
+        };
+    }
+    async osName() {
+        switch (this.environment.os) {
+            case "windows":
+                return windowsName(os.version(), os.release());
+            case "linux":
+                for (const file of ["/etc/os-release", "/usr/lib/os-release"]) {
+                    const name = await readFile(file, "utf8").then(prettyNameFromOsRelease, () => null);
+                    if (name !== null)
+                        return name;
+                }
+                return "Linux";
+            case "macos": {
+                const version = await this.processRunner
+                    .run("/usr/bin/sw_vers", ["-productVersion"], { timeoutMs: 10_000 })
+                    .then((result) => (result.code === 0 ? result.stdout.trim() : ""), () => "");
+                return version === "" ? "macOS" : `macOS ${version}`;
+            }
+        }
+    }
+}
+//# sourceMappingURL=node-system-info.adapter.js.map

package/dist/src/core/infrastructure/node/process-signals.js

@@ -0,0 +1,51 @@
+import { setTimeout as sleep } from "node:timers/promises";
+const WAIT_MS = 3_000;
+const POLL_MS = 100;
+function errorCode(error) {
+    return typeof error === "object" && error !== null && "code" in error && typeof error.code === "string"
+        ? error.code
+        : null;
+}
+/** Signal 0 checks that a process exists without touching it; EPERM means it exists but is not ours. */
+function isRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return errorCode(error) === "EPERM";
+    }
+}
+function refusal(code) {
+    if (code === "ESRCH")
+        return "not-found";
+    return code === "EPERM" ? "denied" : "failed";
+}
+/**
+ * SIGTERM, or SIGKILL with `force`, then polling until each process is gone or a few
+ * seconds pass. Node.js ends a Windows process at once for either signal.
+ */
+export async function endProcesses(pids, force) {
+    const results = new Map();
+    for (const pid of pids) {
+        try {
+            process.kill(pid, force ? "SIGKILL" : "SIGTERM");
+        }
+        catch (error) {
+            const code = errorCode(error);
+            results.set(pid, { pid, outcome: refusal(code), code });
+        }
+    }
+    const signalled = pids.filter((pid) => !results.has(pid));
+    const deadline = Date.now() + WAIT_MS;
+    let running = signalled.filter(isRunning);
+    while (running.length > 0 && Date.now() < deadline) {
+        await sleep(POLL_MS);
+        running = running.filter(isRunning);
+    }
+    for (const pid of signalled) {
+        results.set(pid, { pid, outcome: running.includes(pid) ? "still-running" : "ended", code: null });
+    }
+    return pids.map((pid) => results.get(pid) ?? { pid, outcome: "failed", code: null });
+}
+//# sourceMappingURL=process-signals.js.map