kiriya 0.1.0

package/dist/src/modules/net/application/check-connection.use-case.js

@@ -0,0 +1,71 @@
+import { done } from "../../../core/domain/command.js";
+import { UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { formatTarget, parseTarget } from "../../../core/domain/targets.js";
+const MAX_TIMEOUT_SECONDS = 120;
+export const checkSpec = {
+    id: "net.check",
+    summary: "net.check.summary",
+    examples: ["kiriya net check localhost:5432", "kiriya net check https://example.com", "kiriya net check [::1]:8080"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: true,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "target", description: "net.check.arg.target", required: true, variadic: false }],
+        options: { timeout: { type: "string", description: "net.check.option.timeout", valueName: "<seconds>" } },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const text = reader.positional(0) ?? "";
+            const target = parseTarget(text);
+            if (target === null)
+                throw new UsageError("net.check.target-invalid", { target: text });
+            const timeoutSeconds = reader.positiveInteger("timeout", 5);
+            if (timeoutSeconds > MAX_TIMEOUT_SECONDS) {
+                throw new UsageError("net.check.timeout-range", { max: MAX_TIMEOUT_SECONDS });
+            }
+            return { target, timeoutSeconds };
+        },
+    },
+};
+const FAILURE_KEYS = {
+    refused: "net.check.refused",
+    timeout: "net.check.timeout",
+    "not-found": "net.check.not-found",
+    unreachable: "net.check.unreachable",
+    failed: "net.check.failed",
+};
+function failureMessage(input, outcome) {
+    return message(FAILURE_KEYS[outcome.failure], {
+        target: formatTarget(input.target),
+        host: input.target.host,
+        seconds: input.timeoutSeconds,
+        code: outcome.code ?? outcome.failure,
+    });
+}
+export class CheckConnection {
+    network;
+    spec = checkSpec;
+    constructor(network) {
+        this.network = network;
+    }
+    async execute(input, context) {
+        const { host, port } = input.target;
+        const outcome = await this.network.connect(host, port, input.timeoutSeconds * 1000, context.signal);
+        if (outcome.ok) {
+            return done({ host, port, reachable: true, address: outcome.address, ms: outcome.ms, failure: null, code: null });
+        }
+        const data = {
+            host,
+            port,
+            reachable: false,
+            address: null,
+            ms: outcome.ms,
+            failure: outcome.failure,
+            code: outcome.code,
+        };
+        return done(data, { failures: [failureMessage(input, outcome)] });
+    }
+}
+//# sourceMappingURL=check-connection.use-case.js.map

package/dist/src/modules/net/application/list-addresses.use-case.js

@@ -0,0 +1,29 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+export const addressesSpec = {
+    id: "net.ip",
+    summary: "net.ip.summary",
+    examples: ["kiriya net ip", "kiriya net ip --all --json"],
+    safety: "read",
+    // Addresses change when the machine joins another network.
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [],
+        options: { all: { type: "boolean", description: "net.ip.option.all" } },
+        parse: (raw) => ({ all: new RawReader(raw).flag("all") }),
+    },
+};
+export class ListAddresses {
+    network;
+    spec = addressesSpec;
+    constructor(network) {
+        this.network = network;
+    }
+    execute(input) {
+        const addresses = this.network.addresses().filter((address) => input.all || !address.internal);
+        return Promise.resolve(done({ addresses }));
+    }
+}
+//# sourceMappingURL=list-addresses.use-case.js.map

package/dist/src/modules/net/application/lookup-name.use-case.js

@@ -0,0 +1,55 @@
+import { done } from "../../../core/domain/command.js";
+import { UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { DNS_RECORD_TYPES, } from "../../../core/domain/ports/network.js";
+const LOOKUP_TYPES = ["system", ...DNS_RECORD_TYPES];
+const DNS_TIMEOUT_MS = 5_000;
+export const dnsSpec = {
+    id: "net.dns",
+    summary: "net.dns.summary",
+    examples: ["kiriya net dns example.com", "kiriya net dns example.com --type mx", "kiriya net dns localhost --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: true,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "name", description: "net.dns.arg.name", required: true, variadic: false }],
+        options: {
+            type: { type: "string", description: "net.dns.option.type", valueName: `<${LOOKUP_TYPES.join("|")}>` },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const name = reader.positional(0)?.trim() ?? "";
+            if (name === "")
+                throw new UsageError("net.dns.name-missing");
+            return { name, type: reader.choice("type", LOOKUP_TYPES, "system") };
+        },
+    },
+};
+const FAILURE_KEYS = {
+    "not-found": "net.dns.not-found",
+    timeout: "net.dns.timeout",
+    failed: "net.dns.failed",
+};
+export class LookupName {
+    network;
+    spec = dnsSpec;
+    constructor(network) {
+        this.network = network;
+    }
+    async execute(input) {
+        const outcome = input.type === "system"
+            ? await this.network.lookup(input.name)
+            : await this.network.resolve(input.name, input.type, DNS_TIMEOUT_MS);
+        if (outcome.ok)
+            return done({ name: input.name, type: input.type, records: outcome.records, failure: null });
+        const params = {
+            name: input.name,
+            type: input.type === "system" ? "address" : input.type.toUpperCase(),
+            code: outcome.code ?? outcome.failure,
+        };
+        return done({ name: input.name, type: input.type, records: [], failure: outcome.failure }, { failures: [message(FAILURE_KEYS[outcome.failure], params)] });
+    }
+}
+//# sourceMappingURL=lookup-name.use-case.js.map

package/dist/src/modules/net/net.module.js

@@ -0,0 +1,17 @@
+import { CheckConnection } from "./application/check-connection.use-case.js";
+import { ListAddresses } from "./application/list-addresses.use-case.js";
+import { LookupName } from "./application/lookup-name.use-case.js";
+import { addressesView, checkView, dnsView } from "./presentation/net.views.js";
+export const netModule = {
+    id: "net",
+    summary: "net.summary",
+    about: "net.about",
+    examples: ["kiriya net ip", "kiriya net check localhost:5432", "kiriya net dns example.com --type mx"],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/net.md",
+    register(registrar, ports) {
+        registrar.add(new ListAddresses(ports.network), addressesView);
+        registrar.add(new CheckConnection(ports.network), checkView);
+        registrar.add(new LookupName(ports.network), dnsView);
+    },
+};
+//# sourceMappingURL=net.module.js.map

package/dist/src/modules/net/presentation/net.views.js

@@ -0,0 +1,39 @@
+import { message } from "../../../core/domain/message.js";
+import { formatTarget } from "../../../core/domain/targets.js";
+const NO_MAC = "00:00:00:00:00:00";
+/** Addresses under the interface they belong to. */
+export const addressesView = (output, format) => {
+    if (output.addresses.length === 0)
+        return [format.dim(format.text(message("net.ip.none")))];
+    const macLabel = format.text(message("net.ip.mac"));
+    const width = Math.max(4, macLabel.length);
+    const lines = [];
+    for (const name of new Set(output.addresses.map((address) => address.interfaceName))) {
+        const entries = output.addresses.filter((address) => address.interfaceName === name);
+        lines.push(format.bold(name));
+        for (const entry of entries)
+            lines.push(`  ${entry.family.padEnd(width)}  ${entry.cidr ?? entry.address}`);
+        const mac = entries[0]?.mac;
+        if (mac !== undefined && mac !== NO_MAC)
+            lines.push(format.dim(`  ${macLabel.padEnd(width)}  ${mac}`));
+    }
+    return lines;
+};
+/** An unreachable target arrives as a failure. */
+export const checkView = (output, format) => output.reachable
+    ? [
+        format.green(format.text(message("net.check.reachable", {
+            target: formatTarget(output),
+            ms: output.ms,
+            address: output.address ?? output.host,
+        }))),
+    ]
+    : [];
+export const dnsView = (output) => {
+    const width = Math.max(0, ...output.records.map((record) => record.type.length));
+    return output.records.map((record) => {
+        const priority = record.priority === null ? "" : `${record.priority} `;
+        return `  ${record.type.padEnd(width)}  ${priority}${record.value}`;
+    });
+};
+//# sourceMappingURL=net.views.js.map

package/dist/src/modules/open/application/open-target.use-case.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError, RefusedError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { classifyTarget, runsWhenOpened } from "../domain/targets.js";
+export const openSpec = {
+    id: "open",
+    summary: "open.summary",
+    examples: ["kiriya open .", "kiriya open report.pdf", "kiriya open https://example.com/docs"],
+    safety: "read",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    // A web address can carry whatever an agent puts in it to any site.
+    sensitive: true,
+    input: {
+        positionals: [{ name: "target", description: "open.arg.target", required: true, variadic: false, path: true }],
+        options: {},
+        parse: (raw) => ({ target: new RawReader(raw).positional(0) ?? "" }),
+    },
+};
+/** Opening never runs a program: other schemes and files that would run as programs are refused. */
+export class OpenTarget {
+    opener;
+    fileSystem;
+    environment;
+    spec = openSpec;
+    constructor(opener, fileSystem, environment) {
+        this.opener = opener;
+        this.fileSystem = fileSystem;
+        this.environment = environment;
+    }
+    async execute(input, context) {
+        const target = classifyTarget(input.target);
+        if (target.kind === "refused")
+            throw new RefusedError("open.scheme-refused", { scheme: target.scheme });
+        if (target.kind === "url") {
+            await this.opener.open(target.url, context.signal);
+            return done({ target: target.url, kind: "url" });
+        }
+        // An absolute path never starts with a dash, so no opener mistakes it for an option.
+        const absolute = path.resolve(context.cwd, target.path);
+        const stat = await this.fileSystem.stat(absolute);
+        if (stat === null)
+            throw new NotFoundError("core.fs.not-found", { path: absolute });
+        if (runsWhenOpened(path.basename(absolute), this.environment.os)) {
+            throw new RefusedError("open.runs-program", { path: absolute });
+        }
+        await this.opener.open(absolute, context.signal);
+        return done({ target: absolute, kind: stat.kind === "directory" ? "folder" : "file" });
+    }
+}
+//# sourceMappingURL=open-target.use-case.js.map

package/dist/src/modules/open/domain/targets.js

@@ -0,0 +1,45 @@
+/** Web and mail addresses; every other scheme can start programs or reach places a file name should not. */
+export const OPENABLE_SCHEMES = ["http", "https", "mailto"];
+/** A scheme at the start makes an address; a Windows drive such as C:\ does not. */
+export function classifyTarget(text) {
+    const scheme = /^([a-z][a-z0-9+.-]*):/i.exec(text)?.[1];
+    if (scheme === undefined || /^[a-z]:([\\/]|$)/i.test(text))
+        return { kind: "path", path: text };
+    const lower = scheme.toLowerCase();
+    return OPENABLE_SCHEMES.includes(lower) ? { kind: "url", url: text } : { kind: "refused", scheme: lower };
+}
+/** Names that each OS runs as a program, or as a script or installer, when they are opened. */
+const RUNS_WHEN_OPENED = {
+    windows: [
+        ".exe",
+        ".com",
+        ".bat",
+        ".cmd",
+        ".ps1",
+        ".psm1",
+        ".vbs",
+        ".vbe",
+        ".js",
+        ".jse",
+        ".wsf",
+        ".wsh",
+        ".msi",
+        ".msc",
+        ".scr",
+        ".lnk",
+        ".url",
+        ".hta",
+        ".cpl",
+        ".reg",
+        ".jar",
+        ".pif",
+        ".appref-ms",
+    ],
+    macos: [".app", ".command", ".tool", ".terminal", ".pkg", ".workflow", ".jar"],
+    linux: [".desktop", ".appimage", ".jar"],
+};
+export function runsWhenOpened(name, os) {
+    const lower = name.toLowerCase();
+    return RUNS_WHEN_OPENED[os].some((extension) => lower.endsWith(extension));
+}
+//# sourceMappingURL=targets.js.map

package/dist/src/modules/open/open.module.js

@@ -0,0 +1,12 @@
+import { OpenTarget } from "./application/open-target.use-case.js";
+import { openView } from "./presentation/open.view.js";
+export const openModule = {
+    id: "open",
+    summary: "open.summary",
+    about: "open.about",
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/open.md",
+    register(registrar, ports) {
+        registrar.add(new OpenTarget(ports.opener, ports.fileSystem, ports.environment), openView);
+    },
+};
+//# sourceMappingURL=open.module.js.map

package/dist/src/modules/open/presentation/open.view.js

@@ -0,0 +1,6 @@
+import { message } from "../../../core/domain/message.js";
+export const openView = (output, format) => {
+    const target = output.kind === "url" ? output.target : format.path(output.target);
+    return [format.dim(format.text(message("open.done", { target })))];
+};
+//# sourceMappingURL=open.view.js.map

package/dist/src/modules/port/application/end-port-owners.use-case.js

@@ -0,0 +1,68 @@
+import { processLabels, reportEnded } from "../../../core/application/process-ending.js";
+import { requireTypedConfirmation } from "../../../core/application/safety.js";
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError, RefusedError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { ownedListeners, readPort } from "./port-owners.js";
+export const killSpec = {
+    id: "port.kill",
+    summary: "port.kill.summary",
+    examples: ["kiriya port kill 3000", "kiriya port kill 3000 --force --confirm=3000"],
+    safety: "destroy",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "port", description: "port.kill.arg.port", required: true, variadic: false }],
+        options: {
+            force: { type: "boolean", description: "port.kill.option.force" },
+            confirm: { type: "string", description: "port.kill.option.confirm", valueName: "<port>", terminalOnly: true },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                port: readPort(reader.positional(0) ?? ""),
+                force: reader.flag("force"),
+                confirm: reader.string("confirm"),
+            };
+        },
+    },
+};
+export class EndPortOwners {
+    ports;
+    processes;
+    spec = killSpec;
+    constructor(ports, processes) {
+        this.ports = ports;
+        this.processes = processes;
+    }
+    async execute(input, context) {
+        const { port } = input;
+        const listeners = await ownedListeners(this.ports, this.processes, port, context.signal);
+        if (listeners.length === 0)
+            throw new NotFoundError("port.kill.nothing", { port });
+        const pids = [...new Set(listeners.flatMap((listener) => (listener.pid === null ? [] : [listener.pid])))];
+        // kiriya never elevates, so another user's listener stays out of reach.
+        if (pids.length === 0)
+            throw new RefusedError("port.kill.hidden", { port });
+        const names = new Map();
+        for (const listener of listeners) {
+            if (listener.pid !== null && listener.name !== null)
+                names.set(listener.pid, listener.name);
+        }
+        const guarded = this.processes.protectedPids();
+        const refused = pids.find((pid) => guarded.has(pid));
+        if (refused !== undefined) {
+            throw new RefusedError("port.kill.protected", { name: names.get(refused) ?? "?", pid: refused });
+        }
+        const warning = message("port.kill.warn", { port, processes: processLabels(pids, names) });
+        await requireTypedConfirmation(context, warning, String(port), input.confirm);
+        const report = reportEnded(await this.processes.end(pids, input.force), names);
+        const hidden = listeners.some((listener) => listener.pid === null)
+            ? [message("port.kill.some-hidden", { port })]
+            : [];
+        return done({ port, processes: report.processes }, { failures: report.failures, warnings: [...hidden, ...report.warnings] });
+    }
+}
+//# sourceMappingURL=end-port-owners.use-case.js.map

package/dist/src/modules/port/application/find-free-port.use-case.js

@@ -0,0 +1,40 @@
+import { done } from "../../../core/domain/command.js";
+import { OperationFailedError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { readPort } from "./port-owners.js";
+const DEFAULT_FROM = 3000;
+const LAST_PORT = 65_535;
+export const freeSpec = {
+    id: "port.free",
+    summary: "port.free.summary",
+    examples: ["kiriya port free", "kiriya port free --from 8080", "PORT=$(kiriya port free)"],
+    safety: "read",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [],
+        options: { from: { type: "string", description: "port.free.option.from", valueName: "<port>" } },
+        parse(raw) {
+            const from = new RawReader(raw).string("from");
+            return { from: from === undefined ? DEFAULT_FROM : readPort(from) };
+        },
+    },
+};
+export class FindFreePort {
+    ports;
+    spec = freeSpec;
+    constructor(ports) {
+        this.ports = ports;
+    }
+    async execute(input, context) {
+        const taken = new Set((await this.ports.listeners(context.signal)).map((listener) => listener.port));
+        for (let port = input.from; port <= LAST_PORT; port += 1) {
+            // The listener table catches a port held on one address that a test bind could still share on some systems.
+            if (!taken.has(port) && (await this.ports.canListen(port)))
+                return done({ port });
+        }
+        throw new OperationFailedError("port.free.none", { from: input.from });
+    }
+}
+//# sourceMappingURL=find-free-port.use-case.js.map

package/dist/src/modules/port/application/find-listeners.use-case.js

@@ -0,0 +1,34 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { ownedListeners, readPort } from "./port-owners.js";
+export const whoSpec = {
+    id: "port.who",
+    summary: "port.who.summary",
+    examples: ["kiriya port who 3000", "kiriya port who", "kiriya port who 5432 --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "port", description: "port.who.arg.port", required: false, variadic: false }],
+        options: {},
+        parse(raw) {
+            const text = new RawReader(raw).positional(0);
+            return { port: text === undefined ? null : readPort(text) };
+        },
+    },
+};
+export class FindListeners {
+    ports;
+    processes;
+    spec = whoSpec;
+    constructor(ports, processes) {
+        this.ports = ports;
+        this.processes = processes;
+    }
+    async execute(input, context) {
+        const listeners = await ownedListeners(this.ports, this.processes, input.port, context.signal);
+        return done({ port: input.port, listeners });
+    }
+}
+//# sourceMappingURL=find-listeners.use-case.js.map

package/dist/src/modules/port/application/port-owners.js

@@ -0,0 +1,25 @@
+import { UsageError } from "../../../core/domain/errors.js";
+import { byCodePoint } from "../../../core/domain/names.js";
+import { parsePort } from "../domain/port-number.js";
+export function readPort(text) {
+    const port = parsePort(text);
+    if (port === null)
+        throw new UsageError("port.invalid", { port: text });
+    return port;
+}
+/** Listeners on one port, or on all when `port` is null, with their owners' names, sorted by port, address and id. */
+export async function ownedListeners(ports, processes, port, signal) {
+    const listeners = (await ports.listeners(signal)).filter((listener) => port === null || listener.port === port);
+    const names = new Map();
+    if (listeners.some((listener) => listener.pid !== null)) {
+        for (const entry of (await processes.list(false, signal)).processes)
+            names.set(entry.pid, entry.name);
+    }
+    const unique = new Map();
+    for (const listener of listeners) {
+        const name = listener.pid === null ? null : (names.get(listener.pid) ?? null);
+        unique.set(`${listener.port}|${listener.address}|${listener.pid ?? ""}`, { ...listener, name });
+    }
+    return [...unique.values()].sort((first, second) => first.port - second.port || byCodePoint(first.address, second.address) || (first.pid ?? -1) - (second.pid ?? -1));
+}
+//# sourceMappingURL=port-owners.js.map

package/dist/src/modules/port/domain/port-number.js

@@ -0,0 +1,8 @@
+/** A TCP port from 1 to 65535 written in digits, or null. */
+export function parsePort(text) {
+    if (!/^\d{1,5}$/.test(text.trim()))
+        return null;
+    const port = Number(text.trim());
+    return port >= 1 && port <= 65_535 ? port : null;
+}
+//# sourceMappingURL=port-number.js.map

package/dist/src/modules/port/port.module.js

@@ -0,0 +1,17 @@
+import { EndPortOwners } from "./application/end-port-owners.use-case.js";
+import { FindFreePort } from "./application/find-free-port.use-case.js";
+import { FindListeners } from "./application/find-listeners.use-case.js";
+import { freeView, killView, whoView } from "./presentation/port.views.js";
+export const portModule = {
+    id: "port",
+    summary: "port.summary",
+    about: "port.about",
+    examples: ["kiriya port who 3000", "kiriya port kill 3000", "kiriya port free --from 8000"],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/port.md",
+    register(registrar, ports) {
+        registrar.add(new FindListeners(ports.portTable, ports.processTable), whoView);
+        registrar.add(new EndPortOwners(ports.portTable, ports.processTable), killView);
+        registrar.add(new FindFreePort(ports.portTable), freeView);
+    },
+};
+//# sourceMappingURL=port.module.js.map

package/dist/src/modules/port/presentation/port.views.js

@@ -0,0 +1,27 @@
+import { message } from "../../../core/domain/message.js";
+import { columns, endedLines } from "../../../core/presentation/ended-processes.js";
+export const whoView = (output, format) => {
+    if (output.listeners.length === 0) {
+        const empty = output.port === null ? message("port.who.none-at-all") : message("port.who.none", { port: output.port });
+        return [format.dim(format.text(empty))];
+    }
+    const hidden = format.text(message("port.who.hidden"));
+    const header = [
+        format.text(message("port.column.port")),
+        format.text(message("port.column.address")),
+        format.text(message("port.column.pid")),
+        format.text(message("port.column.process")),
+    ];
+    const rows = output.listeners.map((listener) => [
+        String(listener.port),
+        listener.address,
+        listener.pid === null ? "" : String(listener.pid),
+        listener.name ?? (listener.pid === null ? hidden : ""),
+    ]);
+    const [first = "", ...rest] = columns([header, ...rows]);
+    return [format.bold(first), ...rest];
+};
+export const killView = (output, format) => endedLines(output.processes, format);
+/** The number alone, so `$(kiriya port free)` works in a script. */
+export const freeView = (output) => [String(output.port)];
+//# sourceMappingURL=port.views.js.map

package/dist/src/modules/proc/application/end-processes.use-case.js

@@ -0,0 +1,77 @@
+import { processLabels, reportEnded } from "../../../core/application/process-ending.js";
+import { requireTypedConfirmation } from "../../../core/application/safety.js";
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError, RefusedError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { programKey } from "../domain/process-tree.js";
+export const killSpec = {
+    id: "proc.kill",
+    summary: "proc.kill.summary",
+    examples: ["kiriya proc kill 4100", "kiriya proc kill node", "kiriya proc kill node --force --confirm=node"],
+    safety: "destroy",
+    idempotent: false,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "target", description: "proc.kill.arg.target", required: true, variadic: false }],
+        options: {
+            force: { type: "boolean", description: "proc.kill.option.force" },
+            confirm: {
+                type: "string",
+                description: "proc.kill.option.confirm",
+                valueName: "<id-or-name>",
+                terminalOnly: true,
+            },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const target = reader.positional(0)?.trim() ?? "";
+            if (target === "")
+                throw new UsageError("proc.kill.target-missing");
+            return { target, force: reader.flag("force"), confirm: reader.string("confirm") };
+        },
+    },
+};
+export class EndProcesses {
+    table;
+    spec = killSpec;
+    constructor(table) {
+        this.table = table;
+    }
+    async execute(input, context) {
+        const { processes } = await this.table.list(false, context.signal);
+        const guarded = this.table.protectedPids();
+        const warnings = [];
+        let targets;
+        if (/^\d+$/.test(input.target)) {
+            const pid = Number(input.target);
+            const found = processes.find((entry) => entry.pid === pid);
+            if (found === undefined)
+                throw new NotFoundError("proc.kill.no-pid", { pid });
+            if (guarded.has(pid))
+                throw new RefusedError("proc.kill.protected", { name: found.name, pid });
+            targets = [found];
+        }
+        else {
+            const key = programKey(input.target);
+            const matches = processes.filter((entry) => programKey(entry.name) === key);
+            if (matches.length === 0)
+                throw new NotFoundError("proc.kill.no-name", { name: input.target });
+            // Ending every node would end kiriya itself, and perhaps the program that started it.
+            targets = matches.filter((entry) => !guarded.has(entry.pid));
+            if (targets.length === 0)
+                throw new RefusedError("proc.kill.only-protected", { name: input.target });
+            const skipped = matches.length - targets.length;
+            if (skipped > 0)
+                warnings.push(message("proc.kill.skipped", { count: skipped }));
+        }
+        const names = new Map(targets.map((entry) => [entry.pid, entry.name]));
+        const pids = targets.map((entry) => entry.pid).sort((first, second) => first - second);
+        const warning = message("proc.kill.warn", { processes: processLabels(pids, names) });
+        await requireTypedConfirmation(context, warning, input.target, input.confirm);
+        const report = reportEnded(await this.table.end(pids, input.force), names);
+        return done({ target: input.target, processes: report.processes }, { failures: report.failures, warnings: [...warnings, ...report.warnings] });
+    }
+}
+//# sourceMappingURL=end-processes.use-case.js.map