kiriya 0.1.0

package/dist/src/core/infrastructure/platform/macos/macos-process-table.adapter.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+import { CapabilityUnavailableError } from "../../../domain/errors.js";
+import { endProcesses } from "../../node/process-signals.js";
+/** `ps -axww -o pid=,ppid=,rss=,comm=`: comm comes last so its spaces survive; rss is in kilobytes. */
+export function parsePsStats(output) {
+    const stats = new Map();
+    for (const line of output.split("\n")) {
+        const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(.+?)\s*$/.exec(line);
+        if (match === null)
+            continue;
+        stats.set(Number(match[1]), { ppid: Number(match[2]), memoryBytes: Number(match[3]) * 1024, path: match[4] ?? "" });
+    }
+    return stats;
+}
+/** `ps -axww -o pid=,args=`: each process's command line. */
+export function parsePsArgs(output) {
+    const commands = new Map();
+    for (const line of output.split("\n")) {
+        const match = /^\s*(\d+)\s+(.*?)\s*$/.exec(line);
+        if (match !== null && match[2] !== undefined && match[2] !== "")
+            commands.set(Number(match[1]), match[2]);
+    }
+    return commands;
+}
+/** Two runs of ps, because a name and a command line can both hold spaces and ps separates columns with spaces. */
+export class MacosProcessTableAdapter {
+    processRunner;
+    selfPid = process.pid;
+    constructor(processRunner) {
+        this.processRunner = processRunner;
+    }
+    async list(_detailed, signal) {
+        const [stats, args] = await Promise.all([
+            this.ps(["-axww", "-o", "pid=,ppid=,rss=,comm="], signal),
+            this.ps(["-axww", "-o", "pid=,args="], signal),
+        ]);
+        const commands = parsePsArgs(args);
+        const processes = [...parsePsStats(stats)].map(([pid, stat]) => ({
+            pid,
+            ppid: stat.ppid,
+            name: path.posix.basename(stat.path),
+            command: commands.get(pid) ?? null,
+            memoryBytes: stat.memoryBytes,
+        }));
+        return { processes, detailed: true };
+    }
+    end(pids, force) {
+        return endProcesses(pids, force);
+    }
+    protectedPids() {
+        return new Set([0, 1, process.pid, process.ppid]);
+    }
+    async ps(args, signal) {
+        const result = await this.processRunner.run("/bin/ps", args, { signal, timeoutMs: 30_000 });
+        if (result.code !== 0) {
+            const detail = result.stderr.trim().split("\n")[0] ?? "";
+            throw new CapabilityUnavailableError("core.processes.failed", { program: "ps", code: result.code, detail });
+        }
+        return result.stdout;
+    }
+}
+//# sourceMappingURL=macos-process-table.adapter.js.map

package/dist/src/core/infrastructure/platform/macos/macos-trash.adapter.js

@@ -0,0 +1,64 @@
+import { constants } from "node:fs";
+import { access, rename } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { message } from "../../../domain/message.js";
+import { runProgram } from "../../node/run-program.js";
+const SYSTEM_TRASH = "/usr/bin/trash";
+async function exists(path) {
+    try {
+        await access(path, constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * macOS 15 and later ship /usr/bin/trash; older systems get a plain move into
+ * ~/.Trash, which Finder cannot Put Back. Verified on macOS 26 in the phase 0 spike.
+ */
+export class MacosTrashAdapter {
+    environment;
+    location = "core.trash.location.macos";
+    constructor(environment) {
+        this.environment = environment;
+    }
+    async send(paths) {
+        const useSystem = await exists(SYSTEM_TRASH);
+        const outcomes = [];
+        for (const path of paths)
+            outcomes.push(useSystem ? await this.withSystemTrash(path) : await this.byMove(path));
+        return outcomes;
+    }
+    async withSystemTrash(path) {
+        const result = await runProgram(SYSTEM_TRASH, [path], { timeoutMs: 10 * 60_000 });
+        if (result.code === 0 && !(await exists(path)))
+            return { path, ok: true };
+        return {
+            path,
+            ok: false,
+            reason: message("core.trash.failed", { detail: result.stderr.trim() || `exit ${result.code}` }),
+        };
+    }
+    async byMove(path) {
+        const trash = join(this.environment.homeDirectory, ".Trash");
+        const name = basename(path);
+        const extension = extname(name);
+        const stem = name.slice(0, name.length - extension.length);
+        try {
+            for (let attempt = 1;; attempt += 1) {
+                const candidate = join(trash, attempt === 1 ? name : `${stem} ${attempt}${extension}`);
+                if (await exists(candidate))
+                    continue;
+                await rename(path, candidate);
+                return { path, ok: true };
+            }
+        }
+        catch (error) {
+            const code = error.code;
+            const key = code === "EXDEV" ? "core.trash.other-device" : "core.trash.failed";
+            return { path, ok: false, reason: message(key, { detail: code ?? error.message }) };
+        }
+    }
+}
+//# sourceMappingURL=macos-trash.adapter.js.map

package/dist/src/core/infrastructure/platform/windows/system32.js

@@ -0,0 +1,6 @@
+import path from "node:path";
+/** A program in Windows' System32 folder, by full path, so nothing earlier in PATH can stand in for it. */
+export function system32(program) {
+    return path.win32.join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", program);
+}
+//# sourceMappingURL=system32.js.map

package/dist/src/core/infrastructure/platform/windows/windows-clipboard.adapter.js

@@ -0,0 +1,50 @@
+import { CapabilityUnavailableError, OperationFailedError } from "../../../domain/errors.js";
+import { firstLine, runPowerShellTyped } from "../../node/typed-programs.js";
+const PREAMBLE = String.raw `
+$ErrorActionPreference = 'Stop'
+$mode = $ExecutionContext.SessionState.LanguageMode
+if ($mode -ne 'FullLanguage') { "mode|$mode"; exit 0 }
+`;
+const WRITE_SCRIPT = `${PREAMBLE}
+$bytes = [Convert]::FromBase64String([Console]::In.ReadToEnd().Trim())
+Set-Clipboard -Value ([Text.Encoding]::UTF8.GetString($bytes))
+"done|"
+`;
+const READ_SCRIPT = `${PREAMBLE}
+$text = Get-Clipboard -Raw
+if ($null -eq $text) { $text = '' }
+"text|" + [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($text))
+`;
+/**
+ * Set-Clipboard and Get-Clipboard through Windows PowerShell, because clip.exe garbles
+ * UTF-8. Text travels as base64 on stdin and stdout, so no code page touches it. Like
+ * the trash, the cmdlets need full language mode. Verified in the phase 0 spike.
+ */
+export class WindowsClipboardAdapter {
+    backend() {
+        return Promise.resolve("PowerShell Set-Clipboard");
+    }
+    async write(text, signal) {
+        await this.run(WRITE_SCRIPT, "done|", signal, Buffer.from(text, "utf8").toString("base64"));
+    }
+    async read(signal) {
+        const encoded = await this.run(READ_SCRIPT, "text|", signal);
+        return Buffer.from(encoded, "base64").toString("utf8");
+    }
+    /** What the script printed after `prefix`. */
+    async run(script, prefix, signal, input = "") {
+        const result = await runPowerShellTyped(script, { input, signal, timeoutMs: 60_000 });
+        const lines = result.stdout.split(/\r?\n/).map((line) => line.trim());
+        const mode = lines.find((line) => line.startsWith("mode|"));
+        if (mode !== undefined) {
+            throw new CapabilityUnavailableError("core.clipboard.windows.language-mode", { mode: mode.slice(5) });
+        }
+        const answer = lines.find((line) => line.startsWith(prefix));
+        if (result.code !== 0 || answer === undefined) {
+            const detail = firstLine(result.stderr);
+            throw new OperationFailedError("core.clipboard.failed", { program: "PowerShell", code: result.code, detail });
+        }
+        return answer.slice(prefix.length);
+    }
+}
+//# sourceMappingURL=windows-clipboard.adapter.js.map

package/dist/src/core/infrastructure/platform/windows/windows-opener.adapter.js

@@ -0,0 +1,11 @@
+import path from "node:path";
+import { launchDetached } from "../../node/typed-programs.js";
+/** explorer.exe opens a file in its application, a folder in a window, and a web address in the browser. */
+export class WindowsOpenerAdapter {
+    open(target) {
+        // explorer.exe exits with 1 even when it opened the target, so only whether it started counts.
+        const explorer = path.win32.join(process.env["SystemRoot"] ?? "C:\\Windows", "explorer.exe");
+        return launchDetached(explorer, [target]);
+    }
+}
+//# sourceMappingURL=windows-opener.adapter.js.map

package/dist/src/core/infrastructure/platform/windows/windows-port-table.adapter.js

@@ -0,0 +1,38 @@
+import { CapabilityUnavailableError } from "../../../domain/errors.js";
+import { canListen } from "../../node/can-listen.js";
+import { system32 } from "./system32.js";
+const LINE = /^\s*TCP\s+(\S+):(\d+)\s+(\S+):(\d+)\s+\S+\s+(\d+)\s*$/;
+/**
+ * `netstat -ano`. The state column is translated on Windows in other languages, so a
+ * listener is recognised by its foreign port of 0 rather than by the word LISTENING.
+ */
+export function parseWindowsNetstat(output) {
+    const listeners = [];
+    for (const line of output.split(/\r?\n/)) {
+        const match = LINE.exec(line);
+        if (match === null || match[4] !== "0")
+            continue;
+        const address = (match[1] ?? "").replace(/^\[(.*)\]$/, "$1");
+        listeners.push({ address, port: Number(match[2]), pid: Number(match[5]) });
+    }
+    return listeners;
+}
+/** netstat shows owners without elevation and took about 30 ms in measurements. */
+export class WindowsPortTableAdapter {
+    processRunner;
+    constructor(processRunner) {
+        this.processRunner = processRunner;
+    }
+    async listeners(signal) {
+        const result = await this.processRunner.run(system32("netstat.exe"), ["-ano"], { signal, timeoutMs: 60_000 });
+        if (result.code !== 0) {
+            const detail = result.stderr.trim().split(/\r?\n/)[0] ?? "";
+            throw new CapabilityUnavailableError("core.ports.failed", { program: "netstat", code: result.code, detail });
+        }
+        return parseWindowsNetstat(result.stdout);
+    }
+    canListen(port) {
+        return canListen(port);
+    }
+}
+//# sourceMappingURL=windows-port-table.adapter.js.map

package/dist/src/core/infrastructure/platform/windows/windows-process-table.adapter.js

@@ -0,0 +1,134 @@
+import { CapabilityUnavailableError, InterruptedError } from "../../../domain/errors.js";
+import { endProcesses } from "../../node/process-signals.js";
+import { runPowerShell } from "../../node/run-program.js";
+import { system32 } from "./system32.js";
+const BYTE_ORDER_MARK = String.fromCharCode(0xfeff);
+/** The fields of one CSV line, where a quoted field may hold commas. */
+export function csvFields(line) {
+    const fields = [];
+    let current = "";
+    let quoted = false;
+    for (const char of line) {
+        if (char === '"') {
+            quoted = !quoted;
+        }
+        else if (char === "," && !quoted) {
+            fields.push(current);
+            current = "";
+        }
+        else {
+            current += char;
+        }
+    }
+    fields.push(current);
+    return fields;
+}
+/**
+ * `tasklist /fo csv /nh`: image name, PID, session name, session number, and memory
+ * such as "45,120 K" in the machine's own number format, so only its digits are read.
+ */
+export function parseTasklist(output) {
+    return output
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith('"'))
+        .flatMap((line) => {
+        const fields = csvFields(line);
+        const pid = fields[1] ?? "";
+        if (!/^\d+$/.test(pid))
+            return [];
+        const digits = (fields[4] ?? "").replace(/\D/g, "");
+        const memoryBytes = digits === "" ? null : Number(digits) * 1024;
+        return [{ pid: Number(pid), ppid: null, name: fields[0] ?? "", command: null, memoryBytes }];
+    });
+}
+/** The JSON the CIM script prints; null when it is not that JSON. */
+export function parseCimProcesses(output) {
+    const text = output.trim();
+    let rows;
+    try {
+        rows = JSON.parse(text.startsWith(BYTE_ORDER_MARK) ? text.slice(1) : text);
+    }
+    catch {
+        return null;
+    }
+    if (!Array.isArray(rows))
+        return null;
+    return rows.flatMap((row) => {
+        if (typeof row !== "object" || row === null)
+            return [];
+        const value = row;
+        if (typeof value.pid !== "number")
+            return [];
+        return [
+            {
+                pid: value.pid,
+                ppid: typeof value.ppid === "number" ? value.ppid : null,
+                name: typeof value.name === "string" ? value.name : "",
+                command: typeof value.command === "string" && value.command !== "" ? value.command : null,
+                memoryBytes: typeof value.memory === "number" ? value.memory : null,
+            },
+        ];
+    });
+}
+/** UTF-8 output fails harmlessly under Constrained Language Mode; the listing still works there. */
+const CIM_SCRIPT = String.raw `
+try { [Console]::OutputEncoding = [System.Text.Encoding]::UTF8 } catch { }
+$rows = @(Get-CimInstance -ClassName Win32_Process | ForEach-Object {
+  [pscustomobject]@{ pid = $_.ProcessId; ppid = $_.ParentProcessId; name = $_.Name; command = $_.CommandLine; memory = $_.WorkingSetSize }
+})
+ConvertTo-Json -InputObject $rows -Compress
+`;
+function listingFailed(program, result) {
+    const detail = result.stderr.trim().split(/\r?\n/)[0] ?? "";
+    return new CapabilityUnavailableError("core.processes.failed", { program, code: result.code, detail });
+}
+/**
+ * Names and memory come from tasklist, measured at about 0.7 s. Parent ids and command
+ * lines need Get-CimInstance through PowerShell, which takes a second or more; WMIC is gone
+ * from current Windows. Verified on Windows Server 2025 in the phase 0 spike.
+ */
+export class WindowsProcessTableAdapter {
+    processRunner;
+    selfPid = process.pid;
+    constructor(processRunner) {
+        this.processRunner = processRunner;
+    }
+    async list(detailed, signal) {
+        if (!detailed)
+            return { processes: await this.fromTasklist(signal), detailed: false };
+        return { processes: await this.fromCim(signal), detailed: true };
+    }
+    end(pids, force) {
+        return endProcesses(pids, force);
+    }
+    protectedPids() {
+        // 0 is the System Idle Process and 4 the System process.
+        return new Set([0, 4, process.pid, process.ppid]);
+    }
+    async fromTasklist(signal) {
+        const result = await this.processRunner.run(system32("tasklist.exe"), ["/fo", "csv", "/nh"], {
+            signal,
+            timeoutMs: 60_000,
+        });
+        if (result.code !== 0)
+            throw listingFailed("tasklist", result);
+        return parseTasklist(result.stdout);
+    }
+    async fromCim(signal) {
+        let result;
+        try {
+            result = await runPowerShell(CIM_SCRIPT, { signal, timeoutMs: 120_000 });
+        }
+        catch (error) {
+            if (signal.aborted)
+                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: "powershell.exe", detail });
+        }
+        const processes = result.code === 0 ? parseCimProcesses(result.stdout) : null;
+        if (processes === null)
+            throw listingFailed("Get-CimInstance", result);
+        return processes;
+    }
+}
+//# sourceMappingURL=windows-process-table.adapter.js.map

package/dist/src/core/infrastructure/platform/windows/windows-trash.adapter.js

@@ -0,0 +1,86 @@
+import { CapabilityUnavailableError } from "../../../domain/errors.js";
+import { message } from "../../../domain/message.js";
+import { runPowerShell } from "../../node/run-program.js";
+const NEWLINE = String.fromCharCode(10);
+/**
+ * SHFileOperation with FOF_ALLOWUNDO sends to the Recycle Bin without dialogs. It
+ * deletes permanently on drives without a Recycle Bin, so only fixed local drives
+ * are accepted. Under Constrained Language Mode Add-Type cannot load the C#, which
+ * is reported rather than worked around. Verified in the phase 0 spike.
+ */
+const SCRIPT = String.raw `
+$ErrorActionPreference = 'Stop'
+$mode = $ExecutionContext.SessionState.LanguageMode
+"mode|$mode"
+if ($mode -ne 'FullLanguage') { exit 0 }
+Add-Type -TypeDefinition @'
+using System;
+using System.Runtime.InteropServices;
+public static class KiriyaRecycleBin {
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  private struct Operation {
+    public IntPtr Window; public uint Function; public string From; public string To;
+    public ushort Flags; public bool Aborted; public IntPtr NameMappings; public string Title;
+  }
+  [DllImport("shell32.dll", CharSet = CharSet.Unicode)]
+  private static extern int SHFileOperation(ref Operation operation);
+  public static int Send(string path) {
+    var operation = new Operation { Function = 3, From = path + new string((char)0, 2), Flags = 0x0040 | 0x0010 | 0x0400 | 0x0004 };
+    int code = SHFileOperation(ref operation);
+    return code != 0 ? code : (operation.Aborted ? -1 : 0);
+  }
+}
+'@
+$paths = $env:KIRIYA_TRASH_PATHS -split [char]10
+for ($i = 0; $i -lt $paths.Length; $i++) {
+  $p = $paths[$i]
+  if ($p -eq '') { continue }
+  try {
+    $root = [System.IO.Path]::GetPathRoot($p)
+    if ($root.StartsWith('\\')) { "network|$i"; continue }
+    $drive = New-Object System.IO.DriveInfo($root)
+    if ($drive.DriveType -ne 'Fixed') { "drive|$i|$($drive.DriveType)"; continue }
+    $code = [KiriyaRecycleBin]::Send($p)
+    if ($code -eq 0 -and -not (Test-Path -LiteralPath $p)) { "ok|$i" } else { "error|$i|SHFileOperation returned $code" }
+  } catch { "error|$i|$($_.Exception.Message)" }
+}
+`;
+export class WindowsTrashAdapter {
+    location = "core.trash.location.recycle-bin";
+    async send(paths) {
+        const result = await runPowerShell(SCRIPT, {
+            env: { KIRIYA_TRASH_PATHS: paths.join(NEWLINE) },
+            timeoutMs: 10 * 60_000,
+        });
+        const lines = result.stdout
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line !== "");
+        const mode = lines.find((line) => line.startsWith("mode|"))?.slice(5) ?? "unknown";
+        if (mode !== "FullLanguage")
+            throw new CapabilityUnavailableError("core.trash.windows.language-mode", { mode });
+        const byIndex = new Map();
+        for (const line of lines) {
+            const [status, indexText, ...rest] = line.split("|");
+            if (indexText === undefined || !/^[0-9]+$/.test(indexText))
+                continue;
+            const index = Number(indexText);
+            const path = paths[index] ?? "";
+            if (status === "ok")
+                byIndex.set(index, { path, ok: true });
+            else if (status === "network")
+                byIndex.set(index, { path, ok: false, reason: message("core.trash.windows.network") });
+            else if (status === "drive") {
+                byIndex.set(index, { path, ok: false, reason: message("core.trash.windows.drive", { drive: rest.join("|") }) });
+            }
+            else
+                byIndex.set(index, { path, ok: false, reason: message("core.trash.failed", { detail: rest.join("|") }) });
+        }
+        return paths.map((path, index) => byIndex.get(index) ?? {
+            path,
+            ok: false,
+            reason: message("core.trash.failed", { detail: result.stderr.trim().split(/\r?\n/)[0] ?? "no result" }),
+        });
+    }
+}
+//# sourceMappingURL=windows-trash.adapter.js.map

package/dist/src/core/presentation/cli/argv.js

@@ -0,0 +1,83 @@
+import { parseArgs } from "node:util";
+import { UsageError } from "../../domain/errors.js";
+import { message } from "../../domain/message.js";
+import { closest } from "./suggest.js";
+const GLOBAL_TOKENS = {
+    "--json": "json",
+    "--no-color": "noColor",
+    "--no-input": "noInput",
+    "--debug": "debug",
+    "--help": "help",
+    "-h": "help",
+    "--version": "version",
+    "-V": "version",
+};
+/** Global flags may appear anywhere before `--`; they are taken out before the command parses the rest. */
+export function splitGlobalFlags(argv) {
+    const flags = {
+        json: false,
+        noColor: false,
+        noInput: false,
+        debug: false,
+        help: false,
+        version: false,
+    };
+    const rest = [];
+    let passthrough = false;
+    for (const token of argv) {
+        const flag = passthrough ? undefined : GLOBAL_TOKENS[token];
+        if (token === "--")
+            passthrough = true;
+        if (flag === undefined)
+            rest.push(token);
+        else
+            flags[flag] = true;
+    }
+    return { flags, rest };
+}
+/** Node's parseArgs errors carry English text; turn the common ones into message keys. */
+function usageError(error, schema) {
+    const code = error.code;
+    const text = error instanceof Error ? error.message : String(error);
+    const option = /'(?:-\w, )?(-{1,2}[^'\s=,]+)/.exec(text)?.[1];
+    if (code === "ERR_PARSE_ARGS_UNKNOWN_OPTION" && option !== undefined) {
+        const known = [...Object.keys(schema.options), ...Object.keys(GLOBAL_TOKENS).map((token) => token.slice(2))].map((name) => `--${name}`);
+        const suggestion = option.startsWith("--") ? closest(option, known) : undefined;
+        return new UsageError("core.usage.unknown-option", suggestion === undefined ? { option } : { option, hint: message("core.usage.did-you-mean", { suggestion }) });
+    }
+    if (code === "ERR_PARSE_ARGS_INVALID_OPTION_VALUE" && option !== undefined) {
+        const name = option.replace(/^-+/, "");
+        const key = text.includes("does not take an argument") ? "core.usage.takes-no-value" : "core.usage.expects-value";
+        return new UsageError(key, { option: name });
+    }
+    return new UsageError("core.usage.bad-arguments", { detail: text });
+}
+/** argv for one command, checked against its schema: unknown flags and argument counts are usage errors. */
+export function parseCommandArguments(schema, args) {
+    const options = {};
+    for (const [name, spec] of Object.entries(schema.options)) {
+        options[name] = {
+            type: spec.type,
+            ...(spec.short === undefined ? {} : { short: spec.short }),
+            ...(spec.multiple === true ? { multiple: true } : {}),
+        };
+    }
+    let parsed;
+    try {
+        parsed = parseArgs({ args: [...args], options, allowPositionals: true, strict: true });
+    }
+    catch (error) {
+        throw usageError(error, schema);
+    }
+    const variadic = schema.positionals.some((positional) => positional.variadic);
+    if (!variadic && parsed.positionals.length > schema.positionals.length) {
+        throw new UsageError("core.usage.too-many-arguments", {
+            extra: parsed.positionals.slice(schema.positionals.length).join(" "),
+        });
+    }
+    const missing = schema.positionals.find((positional, index) => positional.required && parsed.positionals[index] === undefined);
+    if (missing !== undefined)
+        throw new UsageError("core.usage.missing-argument", { name: missing.name });
+    return { positionals: parsed.positionals, options: parsed.values };
+}
+//# sourceMappingURL=argv.js.map