kiriya 0.1.0

package/dist/src/core/domain/ports/config-store.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config-store.js.map

package/dist/src/core/domain/ports/confirmation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=confirmation.js.map

package/dist/src/core/domain/ports/environment.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=environment.js.map

package/dist/src/core/domain/ports/file-content.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=file-content.js.map

package/dist/src/core/domain/ports/file-system.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=file-system.js.map

package/dist/src/core/domain/ports/hasher.js

@@ -0,0 +1,2 @@
+export const HASH_ALGORITHMS = ["sha256", "sha1", "md5", "sha512"];
+//# sourceMappingURL=hasher.js.map

package/dist/src/core/domain/ports/network.js

@@ -0,0 +1,2 @@
+export const DNS_RECORD_TYPES = ["a", "aaaa", "cname", "mx", "txt", "ns"];
+//# sourceMappingURL=network.js.map

package/dist/src/core/domain/ports/opener.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=opener.js.map

package/dist/src/core/domain/ports/passthrough.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=passthrough.js.map

package/dist/src/core/domain/ports/plugin-inventory.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plugin-inventory.js.map

package/dist/src/core/domain/ports/plugin-source.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plugin-source.js.map

package/dist/src/core/domain/ports/port-table.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=port-table.js.map

package/dist/src/core/domain/ports/process-runner.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=process-runner.js.map

package/dist/src/core/domain/ports/process-table.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=process-table.js.map

package/dist/src/core/domain/ports/protected-paths.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=protected-paths.js.map

package/dist/src/core/domain/ports/random-source.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=random-source.js.map

package/dist/src/core/domain/ports/standard-input.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=standard-input.js.map

package/dist/src/core/domain/ports/system-info.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=system-info.js.map

package/dist/src/core/domain/ports/trash.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trash.js.map

package/dist/src/core/domain/secrets.js

@@ -0,0 +1,59 @@
+import { splitWords } from "./text-case.js";
+const SECRET_ASSIGNMENT = /(pass(word)?|pwd|secret|token|api[-_]?key)\s*[=:]/i;
+const PRIVATE_KEY = /-----BEGIN [A-Z ]*PRIVATE KEY-----/;
+/** `scheme://user:password@host`. */
+const URL_CREDENTIALS = /[a-z][a-z0-9+.-]*:\/\/[^\s/:@]+:[^\s/@]+@/i;
+/** A JSON Web Token: two base64url JSON parts, then the signature. */
+const JWT = /eyJ[A-Za-z0-9_-]{8,}\.eyJ[A-Za-z0-9_-]{8,}\./;
+/** Tokens whose issuers give them a recognisable prefix, such as GitHub, GitLab, Slack and npm tokens and AWS access keys. */
+const PREFIXED_TOKEN = /^(?:(?:ghp|gho|ghu|ghs|ghr)_|github_pat_|glpat-|xox[abprs]-|npm_|sk-)[A-Za-z0-9_-]{16,}$|^AKIA[0-9A-Z]{16}$/;
+/** Text that looks like it carries a secret: `Password=...`, a private key, a URL with a password, or a token. */
+export function looksSecret(value) {
+    return (SECRET_ASSIGNMENT.test(value) ||
+        PRIVATE_KEY.test(value) ||
+        URL_CREDENTIALS.test(value) ||
+        JWT.test(value) ||
+        PREFIXED_TOKEN.test(value.trim()));
+}
+const SECRET_WORDS = new Set([
+    "password",
+    "passwd",
+    "passphrase",
+    "pass",
+    "pwd",
+    "secret",
+    "secrets",
+    "token",
+    "tokens",
+    "credential",
+    "credentials",
+    "cookie",
+    "dsn",
+]);
+const SECRET_ENDINGS = /(?:password|passwd|passphrase|secret|token)s?$/;
+const SECRET_PHRASES = [
+    "apikey",
+    "accesskey",
+    "privatekey",
+    "secretkey",
+    "signingkey",
+    "encryptionkey",
+    "masterkey",
+    "licensekey",
+    "subscriptionkey",
+    "accountkey",
+    "connectionstring",
+];
+/**
+ * A variable or setting name whose value is usually a secret, such as `GITHUB_TOKEN`,
+ * `DB_PASSWORD`, `apiKey` or `ConnectionStrings__Default`. `PWD`, the working folder, is not.
+ */
+export function isSecretName(name) {
+    if (name.toUpperCase() === "PWD")
+        return false;
+    const words = splitWords(name).map((word) => word.toLowerCase());
+    const joined = words.join("");
+    return (words.some((word) => SECRET_WORDS.has(word) || SECRET_ENDINGS.test(word)) ||
+        SECRET_PHRASES.some((phrase) => joined.includes(phrase)));
+}
+//# sourceMappingURL=secrets.js.map

package/dist/src/core/domain/targets.js

@@ -0,0 +1,41 @@
+/** The ports URL schemes use when a URL names none. */
+const DEFAULT_PORTS = {
+    "http:": 80,
+    "https:": 443,
+    "ws:": 80,
+    "wss:": 443,
+    "ftp:": 21,
+    "ssh:": 22,
+};
+function validPort(text) {
+    if (!/^\d{1,5}$/.test(text))
+        return null;
+    const port = Number(text);
+    return port >= 1 && port <= 65_535 ? port : null;
+}
+/** `host:port`, `[IPv6]:port`, or a URL such as https://example.com whose scheme gives the port; null for anything else. */
+export function parseTarget(text) {
+    const value = text.trim();
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(value)) {
+        let url;
+        try {
+            url = new URL(value);
+        }
+        catch {
+            return null;
+        }
+        const port = url.port === "" ? (DEFAULT_PORTS[url.protocol] ?? null) : validPort(url.port);
+        const host = url.hostname.replace(/^\[(.*)\]$/, "$1");
+        return port === null || host === "" ? null : { host, port };
+    }
+    const match = /^\[([^\]]+)\]:(\d+)$/.exec(value) ?? /^([^:\s[\]]+):(\d+)$/.exec(value);
+    if (match === null)
+        return null;
+    const port = validPort(match[2] ?? "");
+    return port === null ? null : { host: match[1] ?? "", port };
+}
+/** host:port, with an IPv6 address in brackets. */
+export function formatTarget(target) {
+    return target.host.includes(":") ? `[${target.host}]:${target.port}` : `${target.host}:${target.port}`;
+}
+//# sourceMappingURL=targets.js.map

package/dist/src/core/domain/text-case.js

@@ -0,0 +1,39 @@
+export const TEXT_CASES = ["kebab", "snake", "camel", "pascal", "constant", "title", "lower", "upper"];
+/** "userProfile_v2 Final" -> ["user", "Profile", "v2", "Final"]; letters of any script count. */
+export function splitWords(text) {
+    return text
+        .replace(/(\p{Ll}|\p{N})(\p{Lu})/gu, "$1 $2")
+        .replace(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, "$1 $2")
+        .split(/[^\p{L}\p{N}\p{M}]+/u)
+        .filter((word) => word.length > 0);
+}
+/**
+ * Text in another case. Words are found at separators, case changes and digits;
+ * `lower` and `upper` keep the text as it is apart from its case.
+ */
+export function toCase(text, style) {
+    if (style === "lower")
+        return text.toLowerCase();
+    if (style === "upper")
+        return text.toUpperCase();
+    const words = splitWords(text);
+    if (words.length === 0)
+        return text;
+    const lower = words.map((word) => word.toLowerCase());
+    const capital = (word) => word.charAt(0).toUpperCase() + word.slice(1);
+    switch (style) {
+        case "kebab":
+            return lower.join("-");
+        case "snake":
+            return lower.join("_");
+        case "constant":
+            return lower.join("_").toUpperCase();
+        case "camel":
+            return lower.map((word, index) => (index === 0 ? word : capital(word))).join("");
+        case "pascal":
+            return lower.map(capital).join("");
+        case "title":
+            return lower.map(capital).join(" ");
+    }
+}
+//# sourceMappingURL=text-case.js.map

package/dist/src/core/domain/values/bytes.js

@@ -0,0 +1,13 @@
+const UNITS = ["B", "KB", "MB", "GB", "TB"];
+/** 1536 -> "1.5 KB". Units of 1024, the same on every OS. */
+export function formatBytes(bytes) {
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < UNITS.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    const shown = unit === 0 ? String(value) : value.toFixed(value >= 10 ? 0 : 1);
+    return `${shown} ${UNITS[unit] ?? "B"}`;
+}
+//# sourceMappingURL=bytes.js.map

package/dist/src/core/domain/view.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=view.js.map

package/dist/src/core/infrastructure/node/can-listen.js

@@ -0,0 +1,10 @@
+import { createServer } from "node:net";
+/** Opens a TCP server on every interface and closes it again; false when the port is taken or not allowed. */
+export function canListen(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", () => resolve(false));
+        server.listen({ port, exclusive: true }, () => server.close(() => resolve(true)));
+    });
+}
+//# sourceMappingURL=can-listen.js.map

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

@@ -0,0 +1,12 @@
+import { UsageError } from "../../domain/errors.js";
+/**
+ * Standard input that carries something else, such as MCP messages, so no command may
+ * read it. It reports a terminal, which makes a command ask for its value as an argument.
+ */
+export class ClosedStandardInput {
+    isTerminal = true;
+    read() {
+        return Promise.reject(new UsageError("core.input.missing"));
+    }
+}
+//# sourceMappingURL=closed-standard-input.adapter.js.map

package/dist/src/core/infrastructure/node/config-location.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+/**
+ * Where this user's configuration file lives (docs/usage.md): KIRIYA_CONFIG
+ * when set; otherwise %APPDATA% on Windows, $XDG_CONFIG_HOME or ~/.config on Linux,
+ * and Application Support on macOS. A relative XDG value is ignored, as the specification says.
+ */
+export function configFilePath(environment, cwd) {
+    const paths = environment.os === "windows" ? path.win32 : path.posix;
+    const override = environment.variable("KIRIYA_CONFIG");
+    if (override !== undefined && override !== "")
+        return paths.resolve(cwd, override);
+    const home = environment.homeDirectory;
+    const absolute = (value) => value !== undefined && paths.isAbsolute(value);
+    switch (environment.os) {
+        case "windows": {
+            const appData = environment.variable("APPDATA");
+            return paths.join(absolute(appData) ? appData : paths.join(home, "AppData", "Roaming"), "kiriya", "config.json");
+        }
+        case "macos":
+            return paths.join(home, "Library", "Application Support", "kiriya", "config.json");
+        case "linux": {
+            const configHome = environment.variable("XDG_CONFIG_HOME");
+            return paths.join(absolute(configHome) ? configHome : paths.join(home, ".config"), "kiriya", "config.json");
+        }
+    }
+}
+//# sourceMappingURL=config-location.js.map

package/dist/src/core/infrastructure/node/fs-errors.js

@@ -0,0 +1,22 @@
+import { ConflictError, NotFoundError, OperationFailedError, RefusedError } from "../../domain/errors.js";
+export function errorCode(error) {
+    return error.code ?? "UNKNOWN";
+}
+const MISSING = new Set(["ENOENT", "ENOTDIR"]);
+export function isMissing(error) {
+    return MISSING.has(errorCode(error));
+}
+/** Node.js errors become typed errors here, so no errno code reaches a use case. */
+export function translateFsError(error, path) {
+    const code = errorCode(error);
+    if (MISSING.has(code))
+        throw new NotFoundError("core.fs.not-found", { path }, { cause: error });
+    if (code === "EACCES" || code === "EPERM")
+        throw new RefusedError("core.fs.permission", { path }, { cause: error });
+    if (code === "EEXIST" || code === "ERR_FS_CP_EEXIST")
+        throw new ConflictError("core.fs.exists", { path }, { cause: error });
+    if (code === "EISDIR")
+        throw new ConflictError("core.fs.is-folder", { path }, { cause: error });
+    throw new OperationFailedError("core.fs.failed", { path, detail: code }, { cause: error });
+}
+//# sourceMappingURL=fs-errors.js.map

package/dist/src/core/infrastructure/node/json-config-store.adapter.js

@@ -0,0 +1,69 @@
+import { lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { OperationFailedError } from "../../domain/errors.js";
+import { isMissing, translateFsError } from "./fs-errors.js";
+export class JsonConfigStore {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    async exists() {
+        try {
+            await lstat(this.path);
+            return true;
+        }
+        catch (error) {
+            if (isMissing(error))
+                return false;
+            return translateFsError(error, this.path);
+        }
+    }
+    async read() {
+        let text;
+        try {
+            text = await readFile(this.path, "utf8");
+        }
+        catch (error) {
+            if (isMissing(error))
+                return {};
+            return translateFsError(error, this.path);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch (error) {
+            throw new OperationFailedError("core.config.invalid-json", { path: this.path }, { cause: error });
+        }
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            throw new OperationFailedError("core.config.not-an-object", { path: this.path });
+        }
+        const values = {};
+        for (const [key, value] of Object.entries(parsed)) {
+            if (typeof value === "string") {
+                values[key] = value;
+            }
+            else if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+                values[key] = value;
+            }
+            else {
+                throw new OperationFailedError("core.config.invalid-field", { path: this.path, field: key });
+            }
+        }
+        return values;
+    }
+    async write(values) {
+        const sorted = Object.fromEntries(Object.entries(values).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+        const temporary = `${this.path}.${process.pid}.tmp`;
+        try {
+            await mkdir(dirname(this.path), { recursive: true });
+            await writeFile(temporary, `${JSON.stringify(sorted, null, 2)}\n`, "utf8");
+            await rename(temporary, this.path);
+        }
+        catch (error) {
+            await rm(temporary, { force: true });
+            translateFsError(error, this.path);
+        }
+    }
+}
+//# sourceMappingURL=json-config-store.adapter.js.map

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

@@ -0,0 +1,82 @@
+import { createGunzip, createGzip, deflateRaw, inflateRaw } from "node:zlib";
+import { OperationFailedError } from "../../domain/errors.js";
+function failed(error) {
+    return new OperationFailedError("core.compression.failed", { detail: error.message }, { cause: error });
+}
+/** A zlib transform whose output is collected as it arrives and handed back on each push. */
+class ZlibStream {
+    transform;
+    ready = [];
+    failure = null;
+    finished;
+    constructor(transform) {
+        this.transform = transform;
+        transform.on("data", (chunk) => this.ready.push(chunk));
+        this.finished = new Promise((resolve) => {
+            transform.once("end", () => resolve());
+            transform.once("error", (error) => {
+                this.failure = error;
+                resolve();
+            });
+        });
+    }
+    push(data) {
+        if (this.failure !== null)
+            return Promise.reject(failed(this.failure));
+        return new Promise((resolve, reject) => {
+            // zlib destroys itself on damaged data without calling back the write in progress, so its error settles this too.
+            const onError = (error) => reject(failed(error));
+            this.transform.once("error", onError);
+            this.transform.write(data, (error) => {
+                this.transform.off("error", onError);
+                const problem = error ?? this.failure;
+                if (problem === null || problem === undefined)
+                    resolve(this.take());
+                else
+                    reject(failed(problem));
+            });
+        });
+    }
+    async end() {
+        if (this.failure === null)
+            this.transform.end();
+        await this.finished;
+        if (this.failure !== null)
+            throw failed(this.failure);
+        return this.take();
+    }
+    take() {
+        const output = Buffer.concat(this.ready);
+        this.ready = [];
+        return output;
+    }
+}
+export class NodeCompressionAdapter {
+    deflateRaw(data) {
+        return new Promise((resolve, reject) => {
+            deflateRaw(data, { level: 6 }, (error, result) => {
+                if (error === null)
+                    resolve(result);
+                else
+                    reject(failed(error));
+            });
+        });
+    }
+    inflateRaw(data) {
+        return new Promise((resolve, reject) => {
+            inflateRaw(data, (error, result) => {
+                if (error === null)
+                    resolve(result);
+                else
+                    reject(failed(error));
+            });
+        });
+    }
+    gzip() {
+        return new ZlibStream(createGzip({ level: 6 }));
+    }
+    gunzip() {
+        return new ZlibStream(createGunzip());
+    }
+}
+//# sourceMappingURL=node-compression.adapter.js.map

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

@@ -0,0 +1,21 @@
+import { homedir } from "node:os";
+function osFamily(platform) {
+    if (platform === "win32")
+        return "windows";
+    if (platform === "darwin")
+        return "macos";
+    // Other Unix-like systems follow the Linux adapters until they get their own.
+    return "linux";
+}
+export class NodeEnvironmentAdapter {
+    os = osFamily(process.platform);
+    homeDirectory = homedir();
+    variable(name) {
+        return process.env[name];
+    }
+    variables() {
+        const entries = Object.entries(process.env).filter((entry) => entry[1] !== undefined);
+        return Object.fromEntries(entries);
+    }
+}
+//# sourceMappingURL=node-environment.adapter.js.map

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

@@ -0,0 +1,99 @@
+import { open, readFile, rm, writeFile } from "node:fs/promises";
+import { OperationFailedError } from "../../domain/errors.js";
+import { translateFsError } from "./fs-errors.js";
+class NodeFileReader {
+    handle;
+    path;
+    size;
+    constructor(handle, path, size) {
+        this.handle = handle;
+        this.path = path;
+        this.size = size;
+    }
+    async readAt(position, length) {
+        const buffer = new Uint8Array(length);
+        let done = 0;
+        try {
+            while (done < length) {
+                const { bytesRead } = await this.handle.read(buffer, done, length - done, position + done);
+                if (bytesRead === 0)
+                    throw new OperationFailedError("core.fs.truncated", { path: this.path });
+                done += bytesRead;
+            }
+        }
+        catch (error) {
+            if (error instanceof OperationFailedError)
+                throw error;
+            translateFsError(error, this.path);
+        }
+        return buffer;
+    }
+    close() {
+        return this.handle.close();
+    }
+}
+class NodeFileWriter {
+    handle;
+    path;
+    constructor(handle, path) {
+        this.handle = handle;
+        this.path = path;
+    }
+    async write(data) {
+        try {
+            let done = 0;
+            while (done < data.length) {
+                const { bytesWritten } = await this.handle.write(data, done, data.length - done);
+                done += bytesWritten;
+            }
+        }
+        catch (error) {
+            translateFsError(error, this.path);
+        }
+    }
+    close() {
+        return this.handle.close();
+    }
+    async discard() {
+        // The handle may already be closed by a failed write; removing the file is what matters.
+        await this.handle.close().catch(() => undefined);
+        await rm(this.path, { force: true });
+    }
+}
+export class NodeFileContentAdapter {
+    async read(path) {
+        try {
+            return await readFile(path);
+        }
+        catch (error) {
+            return translateFsError(error, path);
+        }
+    }
+    async write(path, data) {
+        try {
+            await writeFile(path, data);
+        }
+        catch (error) {
+            translateFsError(error, path);
+        }
+    }
+    async openForReading(path) {
+        try {
+            const handle = await open(path, "r");
+            const { size } = await handle.stat();
+            return new NodeFileReader(handle, path, size);
+        }
+        catch (error) {
+            return translateFsError(error, path);
+        }
+    }
+    async createExclusive(path) {
+        try {
+            return new NodeFileWriter(await open(path, "wx"), path);
+        }
+        catch (error) {
+            return translateFsError(error, path);
+        }
+    }
+}
+//# sourceMappingURL=node-file-content.adapter.js.map