kiriya 0.1.0

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

@@ -0,0 +1,50 @@
+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 { byNameThenPid } from "../domain/process-tree.js";
+export const findSpec = {
+    id: "proc.find",
+    summary: "proc.find.summary",
+    examples: ["kiriya proc find vite", "kiriya proc find server.js --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "text", description: "proc.find.arg.text", required: true, variadic: false }],
+        options: {},
+        parse(raw) {
+            const text = new RawReader(raw).positional(0)?.trim() ?? "";
+            if (text === "")
+                throw new UsageError("proc.find.text-missing");
+            return { text };
+        },
+    },
+};
+export class FindProcesses {
+    table;
+    spec = findSpec;
+    constructor(table) {
+        this.table = table;
+    }
+    async execute(input, context) {
+        const listing = await this.table.list(true, context.signal);
+        const needle = input.text.toLowerCase();
+        // kiriya's own command line holds the text, and so may the shell or wrapper that started it.
+        const selfPid = this.table.selfPid;
+        const launcher = listing.processes.find((entry) => entry.pid === selfPid)?.ppid ?? null;
+        const processes = listing.processes
+            .filter((entry) => {
+            if (entry.pid === selfPid)
+                return false;
+            if (entry.name.toLowerCase().includes(needle))
+                return true;
+            return entry.pid !== launcher && (entry.command?.toLowerCase().includes(needle) ?? false);
+        })
+            .sort(byNameThenPid);
+        const failures = processes.length === 0 ? [message("proc.find.none", { text: input.text })] : [];
+        return done({ processes, detailed: listing.detailed }, { failures });
+    }
+}
+//# sourceMappingURL=find-processes.use-case.js.map

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

@@ -0,0 +1,41 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { byNameThenPid } from "../domain/process-tree.js";
+export const listSpec = {
+    id: "proc.list",
+    summary: "proc.list.summary",
+    examples: ["kiriya proc list", "kiriya proc list --name node", "kiriya proc list --full --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [],
+        options: {
+            name: { type: "string", description: "proc.list.option.name", valueName: "<text>" },
+            full: { type: "boolean", description: "proc.list.option.full", sensitive: true },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { name: reader.string("name"), full: reader.flag("full") };
+        },
+    },
+};
+export class ListProcesses {
+    table;
+    spec = listSpec;
+    constructor(table) {
+        this.table = table;
+    }
+    async execute(input, context) {
+        const listing = await this.table.list(input.full, context.signal);
+        const needle = input.name?.toLowerCase();
+        const processes = listing.processes
+            .filter((entry) => needle === undefined || entry.name.toLowerCase().includes(needle))
+            .sort(byNameThenPid);
+        const failures = input.name !== undefined && processes.length === 0 ? [message("proc.list.none", { name: input.name })] : [];
+        return done({ processes, detailed: listing.detailed }, { failures });
+    }
+}
+//# sourceMappingURL=list-processes.use-case.js.map

package/dist/src/modules/proc/application/show-tree.use-case.js

@@ -0,0 +1,40 @@
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { processTree } from "../domain/process-tree.js";
+export const treeSpec = {
+    id: "proc.tree",
+    summary: "proc.tree.summary",
+    examples: ["kiriya proc tree", "kiriya proc tree 4100", "kiriya proc tree 4100 --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "pid", description: "proc.tree.arg.pid", required: false, variadic: false }],
+        options: {},
+        parse(raw) {
+            const text = new RawReader(raw).positional(0);
+            if (text === undefined)
+                return { pid: null };
+            if (!/^\d+$/.test(text))
+                throw new UsageError("proc.tree.pid-invalid", { pid: text });
+            return { pid: Number(text) };
+        },
+    },
+};
+export class ShowTree {
+    table;
+    spec = treeSpec;
+    constructor(table) {
+        this.table = table;
+    }
+    async execute(input, context) {
+        const { processes } = await this.table.list(true, context.signal);
+        if (input.pid !== null && !processes.some((entry) => entry.pid === input.pid)) {
+            throw new NotFoundError("proc.tree.no-pid", { pid: input.pid });
+        }
+        return done({ rows: processTree(processes, input.pid) });
+    }
+}
+//# sourceMappingURL=show-tree.use-case.js.map

package/dist/src/modules/proc/domain/process-tree.js

@@ -0,0 +1,55 @@
+import { byCodePoint } from "../../../core/domain/names.js";
+/** A program name compared the same way everywhere: in lower case and without Windows' .exe. */
+export function programKey(name) {
+    return name.toLowerCase().replace(/\.exe$/, "");
+}
+export function byNameThenPid(first, second) {
+    return byCodePoint(first.name.toLowerCase(), second.name.toLowerCase()) || first.pid - second.pid;
+}
+/**
+ * Processes with each parent before its children, children by id. A process whose parent
+ * is not listed is a root; parent ids that loop, as reused ids can make them, are walked once.
+ */
+export function processTree(processes, rootPid) {
+    const byPid = new Map(processes.map((entry) => [entry.pid, entry]));
+    const children = new Map();
+    const roots = [];
+    for (const entry of processes) {
+        const parent = entry.ppid === null || entry.ppid === entry.pid ? undefined : byPid.get(entry.ppid);
+        if (parent === undefined) {
+            roots.push(entry);
+        }
+        else {
+            children.set(parent.pid, [...(children.get(parent.pid) ?? []), entry]);
+        }
+    }
+    const rows = [];
+    const visited = new Set();
+    const walk = (start) => {
+        const stack = [[start, 0]];
+        for (let next = stack.pop(); next !== undefined; next = stack.pop()) {
+            const [entry, depth] = next;
+            if (visited.has(entry.pid))
+                continue;
+            visited.add(entry.pid);
+            rows.push({ pid: entry.pid, ppid: entry.ppid, name: entry.name, depth });
+            const kids = [...(children.get(entry.pid) ?? [])].sort((first, second) => second.pid - first.pid);
+            for (const kid of kids)
+                stack.push([kid, depth + 1]);
+        }
+    };
+    if (rootPid !== null) {
+        const root = byPid.get(rootPid);
+        if (root !== undefined)
+            walk(root);
+        return rows;
+    }
+    const byId = (first, second) => first.pid - second.pid;
+    for (const root of [...roots].sort(byId))
+        walk(root);
+    for (const entry of [...processes].sort(byId))
+        if (!visited.has(entry.pid))
+            walk(entry);
+    return rows;
+}
+//# sourceMappingURL=process-tree.js.map

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

@@ -0,0 +1,28 @@
+import { message } from "../../../core/domain/message.js";
+import { columns, endedLines } from "../../../core/presentation/ended-processes.js";
+/** Id, memory and name; with details also the parent id and, last, the command line. */
+export const processesView = (output, format) => {
+    if (output.processes.length === 0)
+        return [];
+    const label = (key) => format.text(message(key));
+    const detailed = output.detailed;
+    const header = [
+        label("proc.column.pid"),
+        ...(detailed ? [label("proc.column.parent")] : []),
+        label("proc.column.memory"),
+        label("proc.column.name"),
+        ...(detailed ? [label("proc.column.command")] : []),
+    ];
+    const rows = output.processes.map((entry) => [
+        String(entry.pid),
+        ...(detailed ? [entry.ppid === null ? "" : String(entry.ppid)] : []),
+        entry.memoryBytes === null ? "" : format.bytes(entry.memoryBytes),
+        entry.name,
+        ...(detailed ? [entry.command ?? ""] : []),
+    ]);
+    const [first = "", ...rest] = columns([header, ...rows]);
+    return [format.bold(first), ...rest];
+};
+export const killView = (output, format) => endedLines(output.processes, format);
+export const treeView = (output, format) => output.rows.map((row) => `${"  ".repeat(row.depth)}${row.name} ${format.dim(String(row.pid))}`);
+//# sourceMappingURL=proc.views.js.map

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

@@ -0,0 +1,19 @@
+import { EndProcesses } from "./application/end-processes.use-case.js";
+import { FindProcesses } from "./application/find-processes.use-case.js";
+import { ListProcesses } from "./application/list-processes.use-case.js";
+import { ShowTree } from "./application/show-tree.use-case.js";
+import { killView, processesView, treeView } from "./presentation/proc.views.js";
+export const procModule = {
+    id: "proc",
+    summary: "proc.summary",
+    about: "proc.about",
+    examples: ["kiriya proc find vite", "kiriya proc tree", "kiriya proc kill node"],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/proc.md",
+    register(registrar, ports) {
+        registrar.add(new ListProcesses(ports.processTable), processesView);
+        registrar.add(new FindProcesses(ports.processTable), processesView);
+        registrar.add(new EndProcesses(ports.processTable), killView);
+        registrar.add(new ShowTree(ports.processTable), treeView);
+    },
+};
+//# sourceMappingURL=proc.module.js.map

package/dist/src/modules/sys/application/create-report.use-case.js

@@ -0,0 +1,30 @@
+import { done } from "../../../core/domain/command.js";
+import { findTools, machineFacts, noInput, SYS_COMMAND, } from "./machine-facts.js";
+export const reportSpec = {
+    id: "sys.report",
+    summary: "sys.report.summary",
+    examples: ["kiriya sys report", "kiriya sys report --json"],
+    ...SYS_COMMAND,
+    idempotent: false,
+    input: noInput,
+};
+/** Machine facts and tool versions to paste into a bug report; the host name and tool paths stay out. */
+export class CreateReport {
+    system;
+    processRunner;
+    runtime;
+    spec = reportSpec;
+    constructor(system, processRunner, runtime) {
+        this.system = system;
+        this.processRunner = processRunner;
+        this.runtime = runtime;
+    }
+    async execute(_input, context) {
+        const [snapshot, tools] = await Promise.all([this.system.read(), findTools(this.processRunner, context.signal)]);
+        return done({
+            machine: machineFacts(snapshot, this.runtime),
+            tools: tools.map((tool) => ({ name: tool.name, version: tool.version, path: null })),
+        });
+    }
+}
+//# sourceMappingURL=create-report.use-case.js.map

package/dist/src/modules/sys/application/find-tools.use-case.js

@@ -0,0 +1,20 @@
+import { done } from "../../../core/domain/command.js";
+import { findTools, noInput, SYS_COMMAND } from "./machine-facts.js";
+export const toolsSpec = {
+    id: "sys.tools",
+    summary: "sys.tools.summary",
+    examples: ["kiriya sys tools", "kiriya sys tools --json"],
+    ...SYS_COMMAND,
+    input: noInput,
+};
+export class FindTools {
+    processRunner;
+    spec = toolsSpec;
+    constructor(processRunner) {
+        this.processRunner = processRunner;
+    }
+    async execute(_input, context) {
+        return done({ tools: await findTools(this.processRunner, context.signal) });
+    }
+}
+//# sourceMappingURL=find-tools.use-case.js.map

package/dist/src/modules/sys/application/machine-facts.js

@@ -0,0 +1,44 @@
+import { KiriyaError } from "../../../core/domain/errors.js";
+import { TOOLS, toolVersion } from "../domain/tools.js";
+export const noInput = { positionals: [], options: {}, parse: () => ({}) };
+export const SYS_COMMAND = { safety: "read", idempotent: true, usesNetwork: false, runsUserCommands: false };
+export function machineFacts(snapshot, runtime) {
+    return {
+        os: snapshot.os,
+        osName: snapshot.osName,
+        kernel: snapshot.kernel,
+        arch: snapshot.arch,
+        cpuModel: snapshot.cpuModel,
+        cpuCount: snapshot.cpuCount,
+        memoryTotalBytes: snapshot.memoryTotalBytes,
+        memoryFreeBytes: snapshot.memoryFreeBytes,
+        locale: snapshot.locale,
+        timeZone: snapshot.timeZone,
+        node: runtime.nodeVersion,
+        kiriya: runtime.kiriyaVersion,
+    };
+}
+const PROBE_TIMEOUT_MS = 15_000;
+async function probe(runner, tool, signal) {
+    for (const program of tool.programs) {
+        const found = await runner.find(program);
+        if (found === null)
+            continue;
+        try {
+            const result = await runner.run(found, tool.args, { timeoutMs: PROBE_TIMEOUT_MS, signal });
+            const version = toolVersion(tool, `${result.stdout}\n${result.stderr}`);
+            if (version !== null)
+                return { name: tool.name, version, path: found };
+        }
+        catch (error) {
+            if (!(error instanceof KiriyaError) || error.kind === "interrupted")
+                throw error;
+        }
+    }
+    return { name: tool.name, version: null, path: null };
+}
+/** Every known tool, looked for at the same time. */
+export function findTools(runner, signal) {
+    return Promise.all(TOOLS.map((tool) => probe(runner, tool, signal)));
+}
+//# sourceMappingURL=machine-facts.js.map

package/dist/src/modules/sys/application/show-info.use-case.js

@@ -0,0 +1,29 @@
+import { done } from "../../../core/domain/command.js";
+import { machineFacts, noInput, SYS_COMMAND } from "./machine-facts.js";
+export const infoSpec = {
+    id: "sys.info",
+    summary: "sys.info.summary",
+    examples: ["kiriya sys info", "kiriya sys info --json"],
+    ...SYS_COMMAND,
+    // Free memory and uptime change from one run to the next.
+    idempotent: false,
+    input: noInput,
+};
+export class ShowInfo {
+    system;
+    runtime;
+    spec = infoSpec;
+    constructor(system, runtime) {
+        this.system = system;
+        this.runtime = runtime;
+    }
+    async execute() {
+        const snapshot = await this.system.read();
+        return done({
+            ...machineFacts(snapshot, this.runtime),
+            uptimeSeconds: snapshot.uptimeSeconds,
+            hostname: snapshot.hostname,
+        });
+    }
+}
+//# sourceMappingURL=show-info.use-case.js.map

package/dist/src/modules/sys/domain/tools.js

@@ -0,0 +1,17 @@
+export const TOOLS = [
+    { name: "node", programs: ["node"], args: ["--version"], version: /\bv(\d+\.\d+\.\d+)/ },
+    { name: "python", programs: ["python3", "python"], args: ["--version"], version: /\bPython (\d+\.\d+(?:\.\d+)?)/ },
+    { name: "dotnet", programs: ["dotnet"], args: ["--version"], version: /^(\d+\.\d+\.\d+\S*)\s*$/m },
+    { name: "java", programs: ["java"], args: ["-version"], version: /\bversion "([^"]+)"/ },
+    { name: "go", programs: ["go"], args: ["version"], version: /\bgo(\d+\.\d+(?:\.\d+)?)/ },
+    { name: "git", programs: ["git"], args: ["--version"], version: /\bgit version (\S+)/ },
+    { name: "docker", programs: ["docker"], args: ["--version"], version: /\bDocker version ([^,\s]+)/ },
+];
+/**
+ * The version in a tool's output, or null. A stand-in that prints no version, such as
+ * the Microsoft Store's python or macOS's java without a JDK, does not count as installed.
+ */
+export function toolVersion(tool, output) {
+    return tool.version.exec(output)?.[1] ?? null;
+}
+//# sourceMappingURL=tools.js.map

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

@@ -0,0 +1,67 @@
+import { message } from "../../../core/domain/message.js";
+function osRow(machine, format) {
+    const params = { name: machine.osName, kernel: machine.kernel, arch: machine.arch };
+    return ["sys.label.os", format.text(message("sys.info.os", params))];
+}
+function cpuRow(machine, format) {
+    return ["sys.label.cpu", format.text(message("sys.info.cpu", { model: machine.cpuModel, count: machine.cpuCount }))];
+}
+function memoryRow(machine, format) {
+    const params = { total: format.bytes(machine.memoryTotalBytes), free: format.bytes(machine.memoryFreeBytes) };
+    return ["sys.label.memory", format.text(message("sys.info.memory", params))];
+}
+function localeRow(machine, format) {
+    const params = { locale: machine.locale, timeZone: machine.timeZone };
+    return ["sys.label.locale", format.text(message("sys.info.locale", params))];
+}
+function uptime(seconds, format) {
+    const days = Math.floor(seconds / 86_400);
+    const hours = Math.floor((seconds % 86_400) / 3_600);
+    const minutes = Math.floor((seconds % 3_600) / 60);
+    return format.text(message("sys.info.uptime", { days, hours, minutes }));
+}
+export const infoView = (output, format) => {
+    const rows = [
+        osRow(output, format),
+        cpuRow(output, format),
+        memoryRow(output, format),
+        ["sys.label.uptime", uptime(output.uptimeSeconds, format)],
+        ["sys.label.host", output.hostname],
+        localeRow(output, format),
+        ["sys.label.node", output.node],
+        ["sys.label.kiriya", output.kiriya],
+    ];
+    const labels = rows.map(([key]) => format.text(message(key)));
+    const width = Math.max(...labels.map((label) => label.length));
+    return rows.map(([, value], index) => `  ${format.bold((labels[index] ?? "").padEnd(width))}  ${value}`);
+};
+export const toolsView = (output, format) => {
+    const nameWidth = Math.max(...output.tools.map((tool) => tool.name.length));
+    const versionWidth = Math.max(0, ...output.tools.map((tool) => tool.version?.length ?? 0));
+    return output.tools.map((tool) => tool.version === null
+        ? `  ${tool.name.padEnd(nameWidth)}  ${format.dim(format.text(message("sys.tools.not-found")))}`
+        : `  ${tool.name.padEnd(nameWidth)}  ${tool.version.padEnd(versionWidth)}  ${format.dim(tool.path ?? "")}`);
+};
+/** Markdown without colour, to paste into an issue as it is. */
+export const reportView = (output, format) => {
+    const { machine, tools } = output;
+    const found = tools.flatMap((tool) => (tool.version === null ? [] : [`${tool.name} ${tool.version}`]));
+    const missing = tools.filter((tool) => tool.version === null).map((tool) => tool.name);
+    const toolText = [
+        found.join(", "),
+        missing.length > 0 ? format.text(message("sys.report.not-found", { names: missing.join(", ") })) : "",
+    ]
+        .filter((part) => part !== "")
+        .join("; ");
+    const rows = [
+        ["sys.label.kiriya", machine.kiriya],
+        ["sys.label.node", machine.node],
+        osRow(machine, format),
+        cpuRow(machine, format),
+        memoryRow(machine, format),
+        localeRow(machine, format),
+        ["sys.label.tools", toolText],
+    ];
+    return rows.map(([key, value]) => `- **${format.text(message(key))}:** ${value}`);
+};
+//# sourceMappingURL=sys.views.js.map

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

@@ -0,0 +1,17 @@
+import { CreateReport } from "./application/create-report.use-case.js";
+import { FindTools } from "./application/find-tools.use-case.js";
+import { ShowInfo } from "./application/show-info.use-case.js";
+import { infoView, reportView, toolsView } from "./presentation/sys.views.js";
+export const sysModule = {
+    id: "sys",
+    summary: "sys.summary",
+    about: "sys.about",
+    examples: ["kiriya sys info", "kiriya sys tools", "kiriya sys report"],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/sys.md",
+    register(registrar, ports) {
+        registrar.add(new ShowInfo(ports.system, ports.runtime), infoView);
+        registrar.add(new FindTools(ports.processRunner), toolsView);
+        registrar.add(new CreateReport(ports.system, ports.processRunner, ports.runtime), reportView);
+    },
+};
+//# sourceMappingURL=sys.module.js.map

package/dist/src/modules/wait/application/poll.js

@@ -0,0 +1,26 @@
+import { InterruptedError } from "../../../core/domain/errors.js";
+/** The time between attempts. */
+export const INTERVAL_MS = 500;
+/** The least time an attempt is given, so the last one, made at the deadline, can still succeed. */
+export const LEAST_ATTEMPT_MS = 250;
+/**
+ * Tries at once, then every INTERVAL_MS, until an attempt is ready or timeoutMs has passed.
+ * Each attempt is told how long it may take. Aborting the signal throws InterruptedError.
+ */
+export async function poll(clock, timeoutMs, signal, attempt) {
+    const started = clock.now();
+    const deadline = started + timeoutMs;
+    let attempts = 0;
+    for (;;) {
+        if (signal.aborted)
+            throw new InterruptedError("core.error.interrupted");
+        attempts += 1;
+        const outcome = await attempt(Math.max(deadline - clock.now(), LEAST_ATTEMPT_MS));
+        const left = deadline - clock.now();
+        if (outcome.ready || left <= 0) {
+            return { ready: outcome.ready, last: outcome.value, attempts, waitedMs: clock.now() - started };
+        }
+        await clock.sleep(Math.min(INTERVAL_MS, left), signal);
+    }
+}
+//# sourceMappingURL=poll.js.map

package/dist/src/modules/wait/application/wait-file.use-case.js

@@ -0,0 +1,55 @@
+import path from "node:path";
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { readTimeout, TIMEOUT_OPTION } from "../domain/wait-input.js";
+import { poll } from "./poll.js";
+export const waitFileSpec = {
+    id: "wait.file",
+    summary: "wait.file.summary",
+    examples: ["kiriya wait file dist/app.js", "kiriya wait file .build.lock --gone --timeout 300"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "path", description: "wait.file.arg.path", required: true, variadic: false, path: true }],
+        options: {
+            gone: { type: "boolean", description: "wait.file.option.gone" },
+            timeout: TIMEOUT_OPTION,
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { path: reader.positional(0) ?? "", gone: reader.flag("gone"), timeoutSeconds: readTimeout(reader) };
+        },
+    },
+};
+export class WaitForFile {
+    fileSystem;
+    clock;
+    spec = waitFileSpec;
+    constructor(fileSystem, clock) {
+        this.fileSystem = fileSystem;
+        this.clock = clock;
+    }
+    async execute(input, context) {
+        const target = path.resolve(context.cwd, input.path);
+        const polled = await poll(this.clock, input.timeoutSeconds * 1000, context.signal, async () => {
+            const exists = (await this.fileSystem.stat(target)) !== null;
+            return { ready: exists !== input.gone, value: exists };
+        });
+        const data = {
+            path: target,
+            gone: input.gone,
+            ready: polled.ready,
+            attempts: polled.attempts,
+            waitedMs: polled.waitedMs,
+        };
+        if (polled.ready)
+            return done(data);
+        const params = { path: target, seconds: input.timeoutSeconds };
+        const failure = input.gone ? message("wait.file.still-there", params) : message("wait.file.timed-out", params);
+        return done(data, { failures: [failure] });
+    }
+}
+//# sourceMappingURL=wait-file.use-case.js.map

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

@@ -0,0 +1,76 @@
+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 } from "../../../core/domain/targets.js";
+import { failureReason } from "../domain/reasons.js";
+import { parsePortTarget, readTimeout, TIMEOUT_OPTION } from "../domain/wait-input.js";
+import { poll } from "./poll.js";
+/** The longest one connection attempt may take, so a host that never answers is tried again. */
+export const PORT_ATTEMPT_MS = 2_000;
+export const waitPortSpec = {
+    id: "wait.port",
+    summary: "wait.port.summary",
+    examples: [
+        "kiriya wait port 5432",
+        "kiriya wait port db.internal:5432 --timeout 120",
+        "kiriya wait port 3000 --gone",
+    ],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: true,
+    runsUserCommands: false,
+    input: {
+        positionals: [{ name: "target", description: "wait.port.arg.target", required: true, variadic: false }],
+        options: {
+            gone: { type: "boolean", description: "wait.port.option.gone" },
+            timeout: TIMEOUT_OPTION,
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const text = reader.positional(0) ?? "";
+            const target = parsePortTarget(text);
+            if (target === null)
+                throw new UsageError("wait.port.target-invalid", { target: text });
+            return { target, gone: reader.flag("gone"), timeoutSeconds: readTimeout(reader) };
+        },
+    },
+};
+export class WaitForPort {
+    network;
+    clock;
+    spec = waitPortSpec;
+    constructor(network, clock) {
+        this.network = network;
+        this.clock = clock;
+    }
+    async execute(input, context) {
+        const { host, port } = input.target;
+        const polled = await poll(this.clock, input.timeoutSeconds * 1000, context.signal, async (allowedMs) => {
+            const outcome = await this.network.connect(host, port, Math.min(PORT_ATTEMPT_MS, allowedMs), context.signal);
+            return { ready: outcome.ok !== input.gone, value: outcome };
+        });
+        const { last } = polled;
+        const data = {
+            host,
+            port,
+            gone: input.gone,
+            ready: polled.ready,
+            attempts: polled.attempts,
+            waitedMs: polled.waitedMs,
+            address: last.ok ? last.address : null,
+            failure: last.ok ? null : last.failure,
+            code: last.ok ? null : last.code,
+        };
+        if (polled.ready)
+            return done(data);
+        const target = formatTarget(input.target);
+        const seconds = input.timeoutSeconds;
+        // Not ready with a connection that worked can only mean --gone.
+        const failure = last.ok
+            ? message("wait.port.still-listening", { target, seconds })
+            : message("wait.port.timed-out", { target, seconds, reason: failureReason(last.failure, host, last.code) });
+        return done(data, { failures: [failure] });
+    }
+}
+//# sourceMappingURL=wait-port.use-case.js.map