kiriya 0.1.0

package/dist/src/modules/convert/domain/json-syntax.js

@@ -0,0 +1,135 @@
+class Stop {
+    offset;
+    constructor(offset) {
+        this.offset = offset;
+    }
+}
+const NUMBER = /-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+/**
+ * Where JSON text first breaks the grammar, or null when it is valid. JSON.parse's
+ * messages differ between Node.js versions and often give no position, so kiriya
+ * finds the place itself and every version reports the same line and column.
+ */
+export function findJsonProblem(text) {
+    try {
+        scan(text);
+        return null;
+    }
+    catch (error) {
+        if (!(error instanceof Stop))
+            throw error;
+        const offset = Math.min(error.offset, text.length);
+        const before = text.slice(0, offset);
+        const lineStart = before.lastIndexOf("\n") + 1;
+        return { offset, line: before.split("\n").length, column: offset - lineStart + 1 };
+    }
+}
+/** Throws Stop at the first character that breaks the grammar. Keeps its own stack, so deep nesting cannot overflow. */
+function scan(text) {
+    let at = 0;
+    const fail = () => {
+        throw new Stop(at);
+    };
+    const skipSpace = () => {
+        while (at < text.length && " \t\n\r".includes(text.charAt(at)))
+            at += 1;
+    };
+    const expect = (char) => {
+        if (text.charAt(at) !== char)
+            fail();
+        at += 1;
+    };
+    const string = () => {
+        at += 1;
+        while (at < text.length) {
+            const code = text.charCodeAt(at);
+            if (code === 0x22) {
+                at += 1;
+                return;
+            }
+            if (code < 0x20)
+                fail();
+            if (code !== 0x5c) {
+                at += 1;
+                continue;
+            }
+            const escaped = text.charAt(at + 1);
+            if (escaped !== "" && '"\\/bfnrt'.includes(escaped)) {
+                at += 2;
+            }
+            else if (escaped === "u" && /^[0-9a-fA-F]{4}$/.test(text.slice(at + 2, at + 6))) {
+                at += 6;
+            }
+            else {
+                at += 1;
+                fail();
+            }
+        }
+        fail();
+    };
+    const key = () => {
+        skipSpace();
+        if (text.charAt(at) !== '"')
+            fail();
+        string();
+        skipSpace();
+        expect(":");
+    };
+    const scalar = () => {
+        if (text.charAt(at) === '"') {
+            string();
+            return;
+        }
+        for (const word of ["true", "false", "null"]) {
+            if (text.startsWith(word, at)) {
+                at += word.length;
+                return;
+            }
+        }
+        NUMBER.lastIndex = at;
+        if (!NUMBER.test(text))
+            fail();
+        at = NUMBER.lastIndex;
+    };
+    /** The closing characters of the arrays and objects the scan is inside. */
+    const open = [];
+    for (;;) {
+        // A value starts here.
+        skipSpace();
+        const char = text.charAt(at);
+        if (char === "{" || char === "[") {
+            const close = char === "{" ? "}" : "]";
+            at += 1;
+            skipSpace();
+            if (text.charAt(at) !== close) {
+                open.push(close);
+                if (close === "}")
+                    key();
+                continue;
+            }
+            at += 1;
+        }
+        else {
+            scalar();
+        }
+        // A value ended: a comma leads to the next one, or the arrays and objects around it close.
+        for (;;) {
+            skipSpace();
+            const close = open.at(-1);
+            if (close === undefined) {
+                if (at !== text.length)
+                    fail();
+                return;
+            }
+            if (text.charAt(at) === ",") {
+                at += 1;
+                if (close === "}")
+                    key();
+                break;
+            }
+            expect(close);
+            open.pop();
+        }
+    }
+}
+//# sourceMappingURL=json-syntax.js.map

package/dist/src/modules/convert/domain/jwt.js

@@ -0,0 +1,29 @@
+import { fromBase64, utf8Text } from "../../../core/domain/encodings.js";
+function jsonObject(segment) {
+    const bytes = fromBase64(segment);
+    const text = bytes === null ? null : utf8Text(bytes);
+    if (text === null)
+        return null;
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** A JWT's header and payload, without looking at its signature; null when it is not a JWT. */
+export function decodeJwt(token) {
+    const parts = token.trim().split(".");
+    if (parts.length !== 3)
+        return null;
+    const header = jsonObject(parts[0] ?? "");
+    const payload = jsonObject(parts[1] ?? "");
+    return header === null || payload === null ? null : { header, payload };
+}
+/** A NumericDate claim such as `exp`, in seconds, as epoch milliseconds; null when absent or not a number. */
+export function claimTime(payload, claim) {
+    const value = payload[claim];
+    return typeof value === "number" && Number.isFinite(value) ? Math.round(value * 1000) : null;
+}
+//# sourceMappingURL=jwt.js.map

package/dist/src/modules/convert/domain/moments.js

@@ -0,0 +1,20 @@
+export const EPOCH_UNITS = ["auto", "seconds", "ms"];
+/** JavaScript dates reach 8.64e15 milliseconds either side of 1970. */
+const LIMIT_MS = 8.64e15;
+/**
+ * A moment as epoch milliseconds, from a number or a date; null when it is neither.
+ * With `auto`, numbers below 10^11 are seconds: 10^11 seconds is the year 5138,
+ * while 10^11 milliseconds is only 1973.
+ */
+export function parseMoment(value, unit) {
+    const trimmed = value.trim();
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) {
+        const number = Number(trimmed);
+        const seconds = unit === "seconds" || (unit === "auto" && Math.abs(number) < 1e11);
+        const ms = Math.round(seconds ? number * 1000 : number);
+        return Math.abs(ms) <= LIMIT_MS ? ms : null;
+    }
+    const parsed = Date.parse(trimmed);
+    return Number.isNaN(parsed) ? null : parsed;
+}
+//# sourceMappingURL=moments.js.map

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

@@ -0,0 +1,44 @@
+import { message } from "../../../core/domain/message.js";
+/** Only the result, so it can be piped or captured. */
+export const outputView = (output) => output.output.split("\n");
+/** Invalid JSON prints nothing here: the failure names the line and column. */
+export const jsonView = (output, format) => {
+    if (!output.valid)
+        return [];
+    if (output.output === null)
+        return [format.green(format.text(message("convert.json.valid")))];
+    return output.output.split("\n");
+};
+export const jwtView = (output, format) => {
+    const lines = [
+        format.bold(format.text(message("convert.jwt.header"))),
+        ...JSON.stringify(output.header, null, 2).split("\n"),
+        "",
+        format.bold(format.text(message("convert.jwt.payload"))),
+        ...JSON.stringify(output.payload, null, 2).split("\n"),
+    ];
+    const times = [
+        ["convert.jwt.issued", output.issuedAt],
+        ["convert.jwt.not-before", output.notBefore],
+        [output.expired === true ? "convert.jwt.expired" : "convert.jwt.expires", output.expiresAt],
+    ];
+    const present = times.filter((entry) => entry[1] !== null);
+    if (present.length > 0)
+        lines.push("");
+    for (const [key, time] of present) {
+        const text = format.text(message(key, { time: format.time(Date.parse(time)) }));
+        lines.push(key === "convert.jwt.expired" ? format.red(text) : text);
+    }
+    return lines;
+};
+export const timeView = (output, format) => {
+    const rows = [
+        [format.text(message("convert.time.label.iso")), output.iso],
+        [format.text(message("convert.time.label.local")), format.time(output.epochMs)],
+        [format.text(message("convert.time.label.seconds")), String(output.epochSeconds)],
+        [format.text(message("convert.time.label.ms")), String(output.epochMs)],
+    ];
+    const width = Math.max(...rows.map(([label]) => label.length));
+    return rows.map(([label, value]) => `  ${label.padEnd(width)}  ${value}`);
+};
+//# sourceMappingURL=convert.views.js.map

package/dist/src/modules/docker/application/clean-engine.use-case.js

@@ -0,0 +1,77 @@
+import { requireTypedConfirmation } from "../../../core/application/safety.js";
+import { done, preview } from "../../../core/domain/command.js";
+import { OperationFailedError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { parseDiskUsage, reclaimedSpace } from "../domain/engine-output.js";
+import { DockerEngine } from "./docker-engine.js";
+/** The word a script passes as --confirm, since there is no single count to type. */
+export const CLEAN_CONFIRMATION = "prune";
+const PRUNE_TIMEOUT_MS = 10 * 60_000;
+export const cleanSpec = {
+    id: "docker.clean",
+    summary: "docker.clean.summary",
+    examples: [
+        "kiriya docker clean",
+        "kiriya docker clean --apply",
+        "kiriya docker clean --volumes --apply --confirm=prune",
+    ],
+    safety: "destroy",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [],
+        options: {
+            volumes: { type: "boolean", description: "docker.clean.option.volumes" },
+            apply: { type: "boolean", description: "docker.clean.option.apply" },
+            confirm: {
+                type: "string",
+                description: "docker.clean.option.confirm",
+                valueName: CLEAN_CONFIRMATION,
+                terminalOnly: true,
+            },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { volumes: reader.flag("volumes"), apply: reader.flag("apply"), confirm: reader.string("confirm") };
+        },
+    },
+};
+/**
+ * Stopped containers, dangling images, unused networks and the build cache; unused
+ * anonymous volumes only with --volumes. Named volumes and images in use are never pruned.
+ */
+export class CleanEngine {
+    processRunner;
+    spec = cleanSpec;
+    constructor(processRunner) {
+        this.processRunner = processRunner;
+    }
+    async execute(input, context) {
+        const engine = await DockerEngine.connect(this.processRunner, context.signal);
+        const df = await engine.capture(["system", "df", "--format", "{{json .}}"]);
+        if (df.code !== 0) {
+            throw new OperationFailedError("docker.command-failed", { command: "system df", detail: df.stderr.trim() });
+        }
+        const data = { usage: parseDiskUsage(df.stdout), volumes: input.volumes, results: [] };
+        if (!input.apply)
+            return preview(data, "--apply");
+        const warning = message(input.volumes ? "docker.clean.warn-volumes" : "docker.clean.warn");
+        await requireTypedConfirmation(context, warning, CLEAN_CONFIRMATION, input.confirm);
+        const targets = ["container", "image", "network", "builder", ...(input.volumes ? ["volume"] : [])];
+        const results = [];
+        const failures = [];
+        for (const target of targets) {
+            if (context.signal.aborted)
+                break;
+            const pruned = await engine.capture([target, "prune", "--force"], PRUNE_TIMEOUT_MS);
+            const succeeded = pruned.code === 0;
+            if (!succeeded)
+                failures.push(message("docker.clean.failed", { target, detail: pruned.stderr.trim() }));
+            results.push({ target, succeeded, reclaimed: reclaimedSpace(pruned.stdout) });
+        }
+        return done({ ...data, results }, { failures });
+    }
+}
+//# sourceMappingURL=clean-engine.use-case.js.map

package/dist/src/modules/docker/application/compose-project.js

@@ -0,0 +1,45 @@
+import path from "node:path";
+import { NotFoundError } from "../../../core/domain/errors.js";
+import { COMPOSE_FILE_NAMES, parseCompose, projectNameFromFolder, } from "../domain/compose-file.js";
+export const fileOption = {
+    type: "string",
+    description: "docker.option.file",
+    valueName: "<compose.yaml>",
+    path: true,
+};
+export const servicesPositional = {
+    name: "services",
+    description: "docker.arg.services",
+    required: false,
+    variadic: true,
+};
+/** The compose file --file names, or the one docker compose would pick in the working folder. */
+export async function findComposeProject(fileSystem, content, cwd, fileArg) {
+    let file = null;
+    if (fileArg !== undefined) {
+        const target = path.resolve(cwd, fileArg);
+        if ((await fileSystem.stat(target))?.kind !== "file")
+            throw new NotFoundError("core.fs.not-found", { path: target });
+        file = target;
+    }
+    else {
+        for (const name of COMPOSE_FILE_NAMES) {
+            const candidate = path.join(cwd, name);
+            if ((await fileSystem.stat(candidate))?.kind === "file") {
+                file = candidate;
+                break;
+            }
+        }
+    }
+    if (file === null)
+        throw new NotFoundError("docker.no-compose-file", { folder: cwd });
+    const folder = path.dirname(file);
+    const text = new TextDecoder().decode(await content.read(file));
+    const summary = parseCompose(text, projectNameFromFolder(path.basename(folder)));
+    return { name: summary.project, file, folder, services: summary.services };
+}
+/** Arguments for `docker compose` that pin the file and folder, so it never picks up another project. */
+export function composeArgs(project, args) {
+    return ["compose", "--file", project.file, "--project-directory", project.folder, ...args];
+}
+//# sourceMappingURL=compose-project.js.map

package/dist/src/modules/docker/application/docker-engine.js

@@ -0,0 +1,40 @@
+import { CapabilityUnavailableError } from "../../../core/domain/errors.js";
+const PROBE_TIMEOUT_MS = 30_000;
+/** The docker CLI with a running engine behind it. */
+export class DockerEngine {
+    runner;
+    docker;
+    signal;
+    constructor(runner, docker, signal) {
+        this.runner = runner;
+        this.docker = docker;
+        this.signal = signal;
+    }
+    /** CapabilityUnavailableError when docker is not on PATH, or its engine does not answer. */
+    static async connect(runner, signal) {
+        const docker = await runner.find("docker");
+        if (docker === null)
+            throw new CapabilityUnavailableError("docker.not-installed");
+        const probe = await runner.run(docker, ["version", "--format", "{{.Server.Version}}"], {
+            timeoutMs: PROBE_TIMEOUT_MS,
+            signal,
+        });
+        if (probe.code !== 0 || probe.stdout.trim() === "")
+            throw new CapabilityUnavailableError("docker.not-running");
+        return new DockerEngine(runner, docker, signal);
+    }
+    /** For output kiriya reads. */
+    capture(args, timeoutMs = 60_000) {
+        return this.runner.run(this.docker, args, { timeoutMs, signal: this.signal });
+    }
+    /** For output a person reads as it arrives, such as a build or logs; no time limit, and the exit code back. */
+    async stream(args, passthrough) {
+        const result = await this.runner.run(this.docker, args, {
+            timeoutMs: 0,
+            signal: this.signal,
+            onOutput: (text, stream) => passthrough.write(text, stream),
+        });
+        return result.code;
+    }
+}
+//# sourceMappingURL=docker-engine.js.map

package/dist/src/modules/docker/application/list-containers.use-case.js

@@ -0,0 +1,69 @@
+import { done } from "../../../core/domain/command.js";
+import { NotFoundError, OperationFailedError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { parseContainers, parseProjects } from "../domain/engine-output.js";
+import { composeArgs, fileOption, findComposeProject } from "./compose-project.js";
+import { DockerEngine } from "./docker-engine.js";
+export const psSpec = {
+    id: "docker.ps",
+    summary: "docker.ps.summary",
+    examples: ["kiriya docker ps", "kiriya docker ps --projects", "kiriya docker ps --file deploy/compose.yaml --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [],
+        options: { file: fileOption, projects: { type: "boolean", description: "docker.ps.option.projects" } },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { file: reader.string("file"), projects: reader.flag("projects") };
+        },
+    },
+};
+/** The containers of the project here; every compose project with --projects, or when there is no project here. */
+export class ListContainers {
+    fileSystem;
+    content;
+    processRunner;
+    spec = psSpec;
+    constructor(fileSystem, content, processRunner) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+        this.processRunner = processRunner;
+    }
+    async execute(input, context) {
+        const project = input.projects ? null : await this.projectHere(input, context.cwd);
+        const engine = await DockerEngine.connect(this.processRunner, context.signal);
+        if (project === null) {
+            const listed = await engine.capture(["compose", "ls", "--all", "--format", "json"]);
+            if (listed.code !== 0)
+                throw new OperationFailedError("docker.command-failed", {
+                    command: "compose ls",
+                    detail: listed.stderr.trim(),
+                });
+            return done({ mode: "projects", projects: parseProjects(listed.stdout) });
+        }
+        const listed = await engine.capture(composeArgs(project, ["ps", "--all", "--format", "json"]));
+        if (listed.code !== 0)
+            throw new OperationFailedError("docker.command-failed", { command: "compose ps", detail: listed.stderr.trim() });
+        return done({
+            mode: "project",
+            project: project.name,
+            file: project.file,
+            containers: parseContainers(listed.stdout),
+        });
+    }
+    async projectHere(input, cwd) {
+        try {
+            return await findComposeProject(this.fileSystem, this.content, cwd, input.file);
+        }
+        catch (error) {
+            if (input.file === undefined && error instanceof NotFoundError && error.detail.key === "docker.no-compose-file") {
+                return null;
+            }
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=list-containers.use-case.js.map

package/dist/src/modules/docker/application/run-compose.use-case.js

@@ -0,0 +1,83 @@
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { portMappings } from "../domain/compose-file.js";
+import { composeArgs, fileOption, findComposeProject, servicesPositional } from "./compose-project.js";
+import { DockerEngine } from "./docker-engine.js";
+/** `up` and `rebuild` differ only in the compose arguments and their messages. */
+class StartProject {
+    spec;
+    variant;
+    fileSystem;
+    content;
+    processRunner;
+    constructor(spec, variant, fileSystem, content, processRunner) {
+        this.spec = spec;
+        this.variant = variant;
+        this.fileSystem = fileSystem;
+        this.content = content;
+        this.processRunner = processRunner;
+    }
+    async execute(input, context) {
+        const project = await findComposeProject(this.fileSystem, this.content, context.cwd, input.file);
+        const engine = await DockerEngine.connect(this.processRunner, context.signal);
+        const code = await engine.stream(composeArgs(project, this.variant.args(input)), context.passthrough);
+        const started = project.services.filter((service) => input.services.length === 0 || input.services.includes(service.name));
+        const output = {
+            project: project.name,
+            file: project.file,
+            services: input.services,
+            succeeded: code === 0,
+            ports: code === 0 ? portMappings(started) : [],
+        };
+        const failures = code === 0 ? [] : [message(this.variant.failed, { project: project.name, code })];
+        return done(output, { failures });
+    }
+}
+/** Starting a compose project runs whatever programs its compose file names, so it is never an MCP tool. */
+const COMPOSE_START = { idempotent: true, usesNetwork: false, runsUserCommands: true };
+export const upSpec = {
+    id: "docker.up",
+    summary: "docker.up.summary",
+    examples: ["kiriya docker up", "kiriya docker up api db --build", "kiriya docker up --file deploy/compose.yaml"],
+    safety: "write",
+    ...COMPOSE_START,
+    input: {
+        positionals: [servicesPositional],
+        options: { file: fileOption, build: { type: "boolean", description: "docker.up.option.build" } },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { services: reader.positionalsFrom(0), file: reader.string("file"), build: reader.flag("build") };
+        },
+    },
+};
+export const rebuildSpec = {
+    id: "docker.rebuild",
+    summary: "docker.rebuild.summary",
+    examples: ["kiriya docker rebuild", "kiriya docker rebuild api"],
+    safety: "write",
+    ...COMPOSE_START,
+    input: {
+        positionals: [servicesPositional],
+        options: { file: fileOption },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { services: reader.positionalsFrom(0), file: reader.string("file"), build: true };
+        },
+    },
+};
+export function createUp(fileSystem, content, runner) {
+    const variant = {
+        args: (input) => ["up", "--detach", ...(input.build ? ["--build"] : []), ...input.services],
+        failed: "docker.up.failed",
+    };
+    return new StartProject(upSpec, variant, fileSystem, content, runner);
+}
+export function createRebuild(fileSystem, content, runner) {
+    const variant = {
+        args: (input) => ["up", "--detach", "--build", "--force-recreate", ...input.services],
+        failed: "docker.rebuild.failed",
+    };
+    return new StartProject(rebuildSpec, variant, fileSystem, content, runner);
+}
+//# sourceMappingURL=run-compose.use-case.js.map

package/dist/src/modules/docker/application/show-logs.use-case.js

@@ -0,0 +1,51 @@
+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 { composeArgs, fileOption, findComposeProject, servicesPositional } from "./compose-project.js";
+import { DockerEngine } from "./docker-engine.js";
+export const logsSpec = {
+    id: "docker.logs",
+    summary: "docker.logs.summary",
+    examples: ["kiriya docker logs", "kiriya docker logs api -f", "kiriya docker logs db --tail all"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [servicesPositional],
+        options: {
+            file: fileOption,
+            follow: { type: "boolean", description: "docker.logs.option.follow", short: "f", terminalOnly: true },
+            tail: { type: "string", description: "docker.logs.option.tail", valueName: "<n|all>" },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            const tail = reader.string("tail") ?? "200";
+            if (tail !== "all" && !/^[0-9]+$/.test(tail))
+                throw new UsageError("docker.logs.tail-invalid", { value: tail });
+            return { services: reader.positionalsFrom(0), file: reader.string("file"), follow: reader.flag("follow"), tail };
+        },
+    },
+};
+/** The logs arrive through the passthrough as docker prints them; --follow runs until Ctrl+C. */
+export class ShowLogs {
+    fileSystem;
+    content;
+    processRunner;
+    spec = logsSpec;
+    constructor(fileSystem, content, processRunner) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+        this.processRunner = processRunner;
+    }
+    async execute(input, context) {
+        const project = await findComposeProject(this.fileSystem, this.content, context.cwd, input.file);
+        const engine = await DockerEngine.connect(this.processRunner, context.signal);
+        const args = ["logs", "--tail", input.tail, ...(input.follow ? ["--follow"] : []), ...input.services];
+        const code = await engine.stream(composeArgs(project, args), context.passthrough);
+        const failures = code === 0 ? [] : [message("docker.logs.failed", { project: project.name, code })];
+        return done({ project: project.name, succeeded: code === 0 }, { failures });
+    }
+}
+//# sourceMappingURL=show-logs.use-case.js.map

package/dist/src/modules/docker/application/stop-project.use-case.js

@@ -0,0 +1,56 @@
+import { requireTypedConfirmation } from "../../../core/application/safety.js";
+import { done } from "../../../core/domain/command.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { composeArgs, fileOption, findComposeProject } from "./compose-project.js";
+import { DockerEngine } from "./docker-engine.js";
+export const downSpec = {
+    id: "docker.down",
+    summary: "docker.down.summary",
+    examples: ["kiriya docker down", "kiriya docker down --volumes", "kiriya docker down --volumes --confirm=my-project"],
+    safety: "destroy",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [],
+        options: {
+            file: fileOption,
+            volumes: { type: "boolean", description: "docker.down.option.volumes" },
+            confirm: {
+                type: "string",
+                description: "docker.down.option.confirm",
+                valueName: "<project>",
+                terminalOnly: true,
+            },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return { file: reader.string("file"), volumes: reader.flag("volumes"), confirm: reader.string("confirm") };
+        },
+    },
+};
+export class StopProject {
+    fileSystem;
+    content;
+    processRunner;
+    spec = downSpec;
+    constructor(fileSystem, content, processRunner) {
+        this.fileSystem = fileSystem;
+        this.content = content;
+        this.processRunner = processRunner;
+    }
+    async execute(input, context) {
+        const project = await findComposeProject(this.fileSystem, this.content, context.cwd, input.file);
+        const engine = await DockerEngine.connect(this.processRunner, context.signal);
+        if (input.volumes) {
+            const warning = message("docker.down.warn-volumes", { project: project.name });
+            await requireTypedConfirmation(context, warning, project.name, input.confirm);
+        }
+        const args = composeArgs(project, ["down", ...(input.volumes ? ["--volumes"] : [])]);
+        const code = await engine.stream(args, context.passthrough);
+        const failures = code === 0 ? [] : [message("docker.down.failed", { project: project.name, code })];
+        return done({ project: project.name, volumes: input.volumes, succeeded: code === 0 }, { failures });
+    }
+}
+//# sourceMappingURL=stop-project.use-case.js.map