@mittwald/cli 1.4.3 → 1.5.0

package/README.md

@@ -107,6 +107,7 @@ USAGE
 * [`mw app`](docs/app.md) - Manage apps, and app installations in your projects
 * [`mw autocomplete`](docs/autocomplete.md) - Display autocomplete installation instructions.
 * [`mw backup`](docs/backup.md) - Manage backups of your projects
+* [`mw container`](docs/container.md) - Delete a container
 * [`mw context`](docs/context.md) - Save certain environment parameters for later use
 * [`mw conversation`](docs/conversation.md) - Manage your support cases
 * [`mw cronjob`](docs/cronjob.md) - Manage cronjobs of your projects
@@ -119,9 +120,11 @@ USAGE
 * [`mw mail`](docs/mail.md) - Manage mailboxes and mail addresses in your projects
 * [`mw org`](docs/org.md) - Manage your organizations, and also any kinds of user memberships concerning these organizations.
 * [`mw project`](docs/project.md) - Manage your projects, and also any kinds of user memberships concerning these projects.
+* [`mw registry`](docs/registry.md) - Manage container registries
 * [`mw server`](docs/server.md) - Manage your servers
 * [`mw sftp-user`](docs/sftp-user.md) - Manage SFTP users of your projects
 * [`mw ssh-user`](docs/ssh-user.md) - Manage SSH users of your projects
+* [`mw stack`](docs/stack.md) - Manage container stacks
 * [`mw update`](docs/update.md) - update the mw CLI
 * [`mw user`](docs/user.md) - Manage your own user account
 

package/dist/commands/app/dependency/versions.d.ts

@@ -2,7 +2,7 @@ import { Simplify } from "@mittwald/api-client-commons";
 import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { ListBaseCommand, SorterFunction } from "../../../lib/basecommands/ListBaseCommand.js";
 import { ListColumns } from "../../../rendering/formatter/ListFormatter.js";
-type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2SystemSoftwareSystemSoftwareIdVersions.Get.Responses.$200.Content.ApplicationJson[number]>;
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2SystemSoftwaresSystemSoftwareIdVersions.Get.Responses.$200.Content.ApplicationJson[number]>;
 type Response = Awaited<ReturnType<MittwaldAPIV2Client["app"]["listSystemsoftwareversions"]>>;
 export declare class Versions extends ListBaseCommand<typeof Versions, ResponseItem, Response> {
     static description: string;

package/dist/commands/container/delete.d.ts

@@ -0,0 +1,15 @@
+import { DeleteBaseCommand } from "../../lib/basecommands/DeleteBaseCommand.js";
+export default class Delete extends DeleteBaseCommand<typeof Delete> {
+    static description: string;
+    static resourceName: string;
+    static aliases: string[];
+    static flags: {
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        "container-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected deleteResource(): Promise<void>;
+}

package/dist/commands/container/delete.js

@@ -0,0 +1,39 @@
+import { Args } from "@oclif/core";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { withContainerAndStackId } from "../../lib/resources/container/flags.js";
+import assertSuccess from "../../lib/apiutil/assert_success.js";
+import { DeleteBaseCommand } from "../../lib/basecommands/DeleteBaseCommand.js";
+import { assertStatus } from "@mittwald/api-client";
+export default class Delete extends DeleteBaseCommand {
+    static description = "Delete a container";
+    static resourceName = "container";
+    static aliases = ["container:rm"];
+    static flags = {
+        ...DeleteBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    static args = {
+        "container-id": Args.string({
+            description: "ID or short ID of the container to start",
+            required: true,
+        }),
+    };
+    async deleteResource() {
+        const [serviceId, stackId] = await withContainerAndStackId(this.apiClient, Delete, this.flags, this.args, this.config);
+        const stackResponse = await this.apiClient.container.getStack({ stackId });
+        assertStatus(stackResponse, 200);
+        const service = stackResponse.data.services?.find((s) => s.id === serviceId);
+        if (!service) {
+            return;
+        }
+        const response = await this.apiClient.container.updateStack({
+            stackId,
+            data: {
+                services: {
+                    [service.serviceName]: {},
+                },
+            },
+        });
+        assertSuccess(response);
+    }
+}

package/dist/commands/container/list.d.ts

@@ -0,0 +1,23 @@
+import { Simplify } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { ListColumns } from "../../rendering/formatter/Table.js";
+type ResponseItem = Simplify<MittwaldAPIV2.Paths.V2ProjectsProjectIdServices.Get.Responses.$200.Content.ApplicationJson[number]>;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["container"]["listServices"]>>;
+export declare class List extends ListBaseCommand<typeof List, ResponseItem, Response> {
+    static description: string;
+    static aliases: string[];
+    static args: {};
+    static flags: {
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        output: import("@oclif/core/interfaces").OptionFlag<"json" | "txt" | "yaml" | "csv" | "tsv">;
+        extended: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-header": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-truncate": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "no-relative-dates": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "csv-separator": import("@oclif/core/interfaces").OptionFlag<"," | ";">;
+    };
+    getData(): Promise<Response>;
+    protected getColumns(data: ResponseItem[]): ListColumns<ResponseItem>;
+}
+export {};

package/dist/commands/container/list.js

@@ -0,0 +1,53 @@
+import { ListBaseCommand } from "../../lib/basecommands/ListBaseCommand.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { makeDateRendererForFormat } from "../../rendering/textformat/formatDate.js";
+export class List extends ListBaseCommand {
+    static description = "List containers belonging to a project.";
+    static aliases = ["container:ls"];
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        ...projectFlags,
+    };
+    async getData() {
+        const projectId = await this.withProjectId(List);
+        return this.apiClient.container.listServices({ projectId });
+    }
+    getColumns(data) {
+        const { id, shortId } = super.getColumns(data);
+        const dateFormatter = makeDateRendererForFormat(this.flags.output, !this.flags["no-relative-dates"]);
+        return {
+            id,
+            stackId: {
+                header: "Stack ID",
+                extended: true,
+                exactWidth: 40,
+            },
+            shortId,
+            name: {
+                get: (svc) => svc.serviceName,
+            },
+            image: {
+                get: (svc) => svc.deployedState.image,
+            },
+            command: {
+                get: (svc) => svc.deployedState.command?.join(" "),
+            },
+            description: {},
+            ports: {
+                get: (svc) => {
+                    if (svc.deployedState.ports === undefined ||
+                        svc.deployedState.ports.length === 0) {
+                        return "no ports";
+                    }
+                    return svc.deployedState.ports.join(", ");
+                },
+            },
+            status: {
+                get(svc) {
+                    return svc.status + " (" + dateFormatter(svc.statusSetAt) + ")";
+                },
+            },
+        };
+    }
+}

package/dist/commands/container/logs.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+export declare class Logs extends BaseCommand {
+    static summary: string;
+    static description: string;
+    static aliases: string[];
+    static flags: {
+        "no-pager": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+    };
+    static args: {
+        "container-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/container/logs.js

@@ -0,0 +1,47 @@
+import { BaseCommand } from "../../lib/basecommands/BaseCommand.js";
+import { GetBaseCommand } from "../../lib/basecommands/GetBaseCommand.js";
+import { Args, Flags } from "@oclif/core";
+import { withContainerAndStackId } from "../../lib/resources/container/flags.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { assertStatus } from "@mittwald/api-client";
+import { printToPager } from "../../lib/util/pager.js";
+export class Logs extends BaseCommand {
+    static summary = "Display logs of a specific container.";
+    static description = "This command prints the log output of a specific container. " +
+        "" +
+        'When this command is run in a terminal, the output is piped through a pager. The pager is determined by your PAGER environment variable, with defaulting to "less". You can disable this behavior with the --no-pager flag.';
+    static aliases = ["container:ls"];
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+        ...projectFlags,
+        "no-pager": Flags.boolean({
+            description: "Disable pager for output.",
+        }),
+    };
+    static args = {
+        "container-id": Args.string({
+            description: "ID of the container for which to get logs",
+            required: true,
+        }),
+    };
+    async run() {
+        const { flags, args } = await this.parse(Logs);
+        const [serviceId, stackId] = await withContainerAndStackId(this.apiClient, Logs, flags, args, this.config);
+        const usePager = process.stdin.isTTY && !flags["no-pager"];
+        const logsResp = await this.apiClient.container.getServiceLogs({
+            stackId,
+            serviceId,
+        });
+        assertStatus(logsResp, 200);
+        // This is to work around a bug which causes the response to
+        // "getServiceLogs" to contain extra NULL bytes.
+        // eslint-disable-next-line no-control-regex
+        const logs = logsResp.data.replace(/^\x00*/, "");
+        if (usePager) {
+            printToPager(logs);
+        }
+        else {
+            this.log(logs);
+        }
+    }
+}

package/dist/commands/container/recreate.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from "react";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+type Result = {
+    serviceId: string;
+};
+export declare class Recreate extends ExecRenderBaseCommand<typeof Recreate, Result> {
+    static summary: string;
+    static flags: {
+        pull: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        "container-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Result>;
+    protected render({ serviceId }: Result): ReactNode;
+}
+export {};

package/dist/commands/container/recreate.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Args, Flags } from "@oclif/core";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { withContainerAndStackId } from "../../lib/resources/container/flags.js";
+import assertSuccess from "../../lib/apiutil/assert_success.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import { assertStatus } from "@mittwald/api-client";
+export class Recreate extends ExecRenderBaseCommand {
+    static summary = "Recreates a container.";
+    static flags = {
+        ...processFlags,
+        ...projectFlags,
+        pull: Flags.boolean({
+            description: "pull the container image before recreating the container",
+        }),
+        force: Flags.boolean({
+            description: "also recreate the container when it is already up to date",
+        }),
+    };
+    static args = {
+        "container-id": Args.string({
+            description: "ID or short ID of the container to restart",
+            required: true,
+        }),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Recreating a container");
+        const { pull, force } = this.flags;
+        const [serviceId, stackId] = await withContainerAndStackId(this.apiClient, Recreate, this.flags, this.args, this.config);
+        if (pull) {
+            await p.runStep("pulling image and recreating", async () => {
+                const r = await this.apiClient.container.pullImageForService({
+                    serviceId,
+                    stackId,
+                });
+                assertSuccess(r);
+            });
+        }
+        else {
+            const service = await p.runStep("getting container status", async () => {
+                const r = await this.apiClient.container.getService({
+                    serviceId,
+                    stackId,
+                });
+                assertStatus(r, 200);
+                return r.data;
+            });
+            if (!service.requiresRecreate && !force) {
+                p.addInfo("service is already up to date");
+            }
+            else {
+                await p.runStep("recreating container", async () => {
+                    const r = await this.apiClient.container.restartService({
+                        serviceId,
+                        stackId,
+                    });
+                    assertSuccess(r);
+                });
+            }
+        }
+        await p.complete(_jsxs(Success, { children: ["Container ", _jsx(Value, { children: serviceId }), " was successfully recreated."] }));
+        return { serviceId };
+    }
+    render({ serviceId }) {
+        if (this.flags.quiet) {
+            return serviceId;
+        }
+    }
+}

package/dist/commands/container/restart.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from "react";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+type Result = {
+    serviceId: string;
+};
+export declare class Restart extends ExecRenderBaseCommand<typeof Restart, Result> {
+    static summary: string;
+    static flags: {
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        "container-id": import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Result>;
+    protected render({ serviceId }: Result): ReactNode;
+}
+export {};

package/dist/commands/container/restart.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Args } from "@oclif/core";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { withContainerAndStackId } from "../../lib/resources/container/flags.js";
+import assertSuccess from "../../lib/apiutil/assert_success.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Value } from "../../rendering/react/components/Value.js";
+export class Restart extends ExecRenderBaseCommand {
+    static summary = "Restarts a container.";
+    static flags = {
+        ...processFlags,
+        ...projectFlags,
+    };
+    static args = {
+        "container-id": Args.string({
+            description: "ID or short ID of the container to restart",
+            required: true,
+        }),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Restarting a container");
+        const [serviceId, stackId] = await withContainerAndStackId(this.apiClient, Restart, this.flags, this.args, this.config);
+        await p.runStep("restarting container", async () => {
+            const r = await this.apiClient.container.restartService({
+                serviceId,
+                stackId,
+            });
+            assertSuccess(r);
+        });
+        await p.complete(_jsxs(Success, { children: ["Container ", _jsx(Value, { children: serviceId }), " was successfully restarted."] }));
+        return { serviceId };
+    }
+    render({ serviceId }) {
+        if (this.flags.quiet) {
+            return serviceId;
+        }
+    }
+}

package/dist/commands/container/run.d.ts

@@ -0,0 +1,57 @@
+import { ReactNode } from "react";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+type Result = {
+    serviceId: string;
+};
+export declare class Run extends ExecRenderBaseCommand<typeof Run, Result> {
+    static summary: string;
+    static flags: {
+        env: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "env-file": import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        entrypoint: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        publish: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "publish-all": import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        volume: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        "project-id": import("@oclif/core/interfaces").OptionFlag<string>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    static args: {
+        image: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        command: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+        args: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    protected exec(): Promise<Result>;
+    private addServiceToStack;
+    /**
+     * Builds a container service request from command line arguments and image
+     * metadata
+     *
+     * @param image The container image to use
+     * @param imageMeta Metadata about the container image
+     * @param serviceName Name of the service to create
+     * @returns A properly formatted container service request
+     */
+    private buildServiceRequest;
+    /**
+     * Parses environment variables from command line flags and env files
+     *
+     * @returns An object containing environment variable key-value pairs
+     */
+    private parseEnvironmentVariables;
+    private parseEnvironmentVariablesFromFile;
+    private parseEnvironmentVariablesFromEnvFlags;
+    /**
+     * Determines which ports to expose based on flags and image metadata
+     *
+     * @param imageMeta Metadata about the container image
+     * @returns An array of port mappings
+     */
+    private getPortMappings;
+    private getImageAndMeta;
+    private getImageMeta;
+    private getServiceName;
+    protected render({ serviceId }: Result): ReactNode;
+}
+export {};

package/dist/commands/container/run.js

@@ -0,0 +1,224 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Args, Flags } from "@oclif/core";
+import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { projectFlags } from "../../lib/resources/project/flags.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Value } from "../../rendering/react/components/Value.js";
+import * as dockerNames from "docker-names";
+import { assertStatus } from "@mittwald/api-client";
+import * as fs from "fs/promises";
+import { parse } from "envfile";
+import { pathExists } from "../../lib/util/fs/pathExists.js";
+export class Run extends ExecRenderBaseCommand {
+    static summary = "Creates and starts a new container.";
+    static flags = {
+        ...processFlags,
+        ...projectFlags,
+        env: Flags.string({
+            summary: "set environment variables in the container",
+            description: "Format: KEY=VALUE. Multiple environment variables can be specified with multiple --env flags.",
+            required: false,
+            multiple: true,
+            char: "e",
+        }),
+        "env-file": Flags.string({
+            summary: "read environment variables from a file",
+            description: "The file should contain lines in the format KEY=VALUE. Multiple files can be specified with multiple --env-file flags.",
+            multiple: true,
+            required: false,
+        }),
+        description: Flags.string({
+            summary: "add a descriptive label to the container",
+            description: "This helps identify the container's purpose or contents.",
+            required: false,
+        }),
+        entrypoint: Flags.string({
+            summary: "override the default entrypoint of the container image",
+            description: "The entrypoint is the command that will be executed when the container starts. If omitted, the entrypoint defined in the image will be used.",
+            required: false,
+        }),
+        name: Flags.string({
+            summary: "assign a custom name to the container",
+            description: "This makes it easier to reference the container in subsequent commands. If omitted, a random name will be generated automatically.",
+            required: false,
+        }),
+        publish: Flags.string({
+            summary: "publish a container's port(s) to the host",
+            description: "Map a container's port to a port on the host system. " +
+                "Format: <host-port>:<container-port> or just <container-port> (in which case the host port will be automatically assigned). " +
+                "For example, -p 8080:80 maps port 80 in the container to port 8080 on the host. " +
+                "Use multiple -p flags to publish multiple ports.",
+            required: false,
+            multiple: true,
+            char: "p",
+        }),
+        "publish-all": Flags.boolean({
+            summary: "publish all ports that are defined in the image",
+            description: "Automatically publish all ports that are exposed by the container image to random ports on the host.",
+            required: false,
+            char: "P",
+        }),
+        volume: Flags.string({
+            summary: "bind mount a volume to the container",
+            description: "This flag can be used to add volume mounts to the container. It can be used multiple times to mount multiple volumes." +
+                "" +
+                "Needs to be in the format <host-path>:<container-path>. " +
+                "" +
+                "If you specify a file path as volume, this will mount a path from your hosting environment's file system (NOT your local file system) into the container. " +
+                "You can also specify a named volume, which needs to be created beforehand.",
+            required: false,
+            char: "v",
+            multiple: true,
+        }),
+    };
+    static args = {
+        image: Args.string({
+            summary: "container image to run",
+            description: "Can be specified as a repository/tag or repository@digest (e.g., 'ubuntu:20.04' or 'alpine@sha256:abc123...'). If no tag is provided, 'latest' is assumed.",
+            required: true,
+        }),
+        command: Args.string({
+            summary: "command to run in the container",
+            description: "This overrides the default command specified in the container image. If omitted, the default command from the image will be used. For example, 'bash' or 'python app.py'.",
+            required: false,
+        }),
+        args: Args.string({
+            summary: "arguments to pass to the command",
+            description: "These are the runtime arguments passed to the command specified by the command parameter or the container's default command, not to the container itself. For example, if the command is 'echo', the args might be 'hello world'.",
+            required: false,
+            variadic: true,
+        }),
+    };
+    async exec() {
+        const p = makeProcessRenderer(this.flags, "Creating a container");
+        const projectId = await this.withProjectId(Run);
+        const stackId = projectId;
+        const serviceName = this.getServiceName();
+        const { image, meta: imageMeta } = await p.runStep("getting image metadata", this.getImageAndMeta(projectId));
+        const serviceRequest = await p.runStep("preparing service request", this.buildServiceRequest(image, imageMeta, serviceName));
+        const stack = await p.runStep("creating container", this.addServiceToStack(stackId, serviceName, serviceRequest));
+        const service = stack.services?.find(matchServiceByName(serviceName));
+        const serviceId = service?.id;
+        if (!serviceId) {
+            throw new Error("Service ID not found in the created stack.");
+        }
+        await p.complete(_jsxs(Success, { children: ["Container ", _jsx(Value, { children: serviceId }), " was successfully created and started."] }));
+        return { serviceId };
+    }
+    async addServiceToStack(stackId, serviceName, serviceRequest) {
+        const resp = await this.apiClient.container.updateStack({
+            stackId,
+            data: {
+                services: {
+                    [serviceName]: serviceRequest,
+                },
+            },
+        });
+        assertStatus(resp, 200);
+        return resp.data;
+    }
+    /**
+     * Builds a container service request from command line arguments and image
+     * metadata
+     *
+     * @param image The container image to use
+     * @param imageMeta Metadata about the container image
+     * @param serviceName Name of the service to create
+     * @returns A properly formatted container service request
+     */
+    async buildServiceRequest(image, imageMeta, serviceName) {
+        const command = this.args.command ? [this.args.command] : imageMeta.command;
+        const entrypoint = this.flags.entrypoint
+            ? [this.flags.entrypoint]
+            : imageMeta.entrypoint;
+        const description = this.flags.description ?? serviceName;
+        const envs = await this.parseEnvironmentVariables();
+        const ports = this.getPortMappings(imageMeta);
+        const volumes = this.flags.volume;
+        return {
+            image,
+            command,
+            entrypoint,
+            description,
+            envs,
+            ports,
+            volumes,
+        };
+    }
+    /**
+     * Parses environment variables from command line flags and env files
+     *
+     * @returns An object containing environment variable key-value pairs
+     */
+    async parseEnvironmentVariables() {
+        return {
+            ...this.parseEnvironmentVariablesFromEnvFlags(),
+            ...(await this.parseEnvironmentVariablesFromFile()),
+        };
+    }
+    async parseEnvironmentVariablesFromFile() {
+        const result = {};
+        for (const envFile of this.flags["env-file"] ?? []) {
+            if (!(await pathExists(envFile))) {
+                throw new Error(`Env file not found: ${envFile}`);
+            }
+            const fileContent = await fs.readFile(envFile, { encoding: "utf-8" });
+            const parsed = parse(fileContent);
+            Object.assign(result, parsed);
+        }
+        return result;
+    }
+    parseEnvironmentVariablesFromEnvFlags() {
+        const splitIntoKeyAndValue = (e) => e.split("=", 2);
+        const envFlags = this.flags.env ?? [];
+        return Object.fromEntries(envFlags.map(splitIntoKeyAndValue));
+    }
+    /**
+     * Determines which ports to expose based on flags and image metadata
+     *
+     * @param imageMeta Metadata about the container image
+     * @returns An array of port mappings
+     */
+    getPortMappings(imageMeta) {
+        if (this.flags["publish-all"]) {
+            const definedPorts = imageMeta.exposedPorts ?? [];
+            const concatPort = (p) => {
+                const [port, protocol = "tcp"] = p.port.split("/", 2);
+                return `${port}:${port}/${protocol}`;
+            };
+            return definedPorts.map(concatPort);
+        }
+        return this.flags.publish ?? [];
+    }
+    async getImageAndMeta(projectId) {
+        const { image } = this.args;
+        const meta = await this.getImageMeta(image, projectId);
+        return { image, meta };
+    }
+    async getImageMeta(image, projectId) {
+        const resp = await this.apiClient.container.getContainerImageConfig({
+            queryParameters: {
+                imageReference: image,
+                useCredentialsForProjectId: projectId,
+            },
+        });
+        assertStatus(resp, 200);
+        return resp.data;
+    }
+    getServiceName() {
+        const { name } = this.flags;
+        if (name !== undefined) {
+            return name;
+        }
+        return dockerNames.getRandomName();
+    }
+    render({ serviceId }) {
+        if (this.flags.quiet) {
+            return serviceId;
+        }
+    }
+}
+function matchServiceByName(name) {
+    return (service) => service.serviceName === name;
+}