@mittwald/cli 1.11.2 → 1.13.1-beta.6

package/dist/commands/project/create.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Flags } from "@oclif/core";
 import { assertStatus } from "@mittwald/api-client-commons";
 import { serverFlags } from "../../lib/resources/server/flags.js";
@@ -7,6 +7,7 @@ import { Success } from "../../rendering/react/components/Success.js";
 import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
 import { waitFlags, waitUntil } from "../../lib/wait.js";
 import Context from "../../lib/context/Context.js";
+import { Value } from "../../rendering/react/components/Value.js";
 export default class Create extends ExecRenderBaseCommand {
     static description = "Create a new project";
     static flags = {
@@ -19,7 +20,8 @@ export default class Create extends ExecRenderBaseCommand {
             description: "A description for the project.",
         }),
         "update-context": Flags.boolean({
-            description: "Update the CLI context to use the newly created project",
+            description: "update the CLI context to use the newly created project",
+            char: "c",
         }),
     };
     async exec() {
@@ -48,12 +50,16 @@ export default class Create extends ExecRenderBaseCommand {
             }, this.flags["wait-timeout"]);
             stepWaiting.complete();
         }
+        const projectResult = await this.apiClient.project.getProject({
+            projectId: result.data.id,
+        });
+        assertStatus(projectResult, 200);
         if (flags["update-context"]) {
             await process.runStep("updating CLI context", async () => {
                 await new Context(this.apiClient, this.config).setProjectId(result.data.id);
             });
         }
-        process.complete(_jsx(Success, { children: "Your new project was successfully created! \uD83D\uDE80" }));
+        await process.complete(_jsx(ProjectCreationSuccess, { shortId: projectResult.data.shortId }));
         return { projectId: result.data.id };
     }
     render({ projectId }) {
@@ -62,3 +68,6 @@ export default class Create extends ExecRenderBaseCommand {
         }
     }
 }
+function ProjectCreationSuccess({ shortId }) {
+    return (_jsxs(Success, { children: ["Your new project ", _jsx(Value, { children: shortId }), " was successfully created! \uD83D\uDE80"] }));
+}

package/dist/commands/stack/deploy.d.ts

@@ -8,10 +8,12 @@ export declare class Deploy extends ExecRenderBaseCommand<typeof Deploy, DeployR
     static aliases: string[];
     static flags: {
         "compose-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        "from-template": import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         "env-file": import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         "stack-id": import("@oclif/core/interfaces").OptionFlag<string>;
     };
+    private loadStackDefinition;
     protected exec(): Promise<DeployResult>;
     protected render({ restartedServices }: DeployResult): ReactNode;
 }

package/dist/commands/stack/deploy.js

@@ -3,14 +3,16 @@ import { ExecRenderBaseCommand } from "../../lib/basecommands/ExecRenderBaseComm
 import { stackFlags, withStackId } from "../../lib/resources/stack/flags.js";
 import { Flags } from "@oclif/core";
 import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
-import { loadStackFromFile } from "../../lib/resources/stack/loader.js";
+import { loadStackFromFile, loadStackFromStr, } from "../../lib/resources/stack/loader.js";
 import { assertStatus } from "@mittwald/api-client";
 import assertSuccess from "../../lib/apiutil/assert_success.js";
-import { collectEnvironment } from "../../lib/resources/stack/env.js";
+import { collectEnvironment, fillMissingEnvironmentVariables, } from "../../lib/resources/stack/env.js";
 import { sanitizeStackDefinition } from "../../lib/resources/stack/sanitize.js";
 import { enrichStackDefinition } from "../../lib/resources/stack/enrich.js";
 import { Success } from "../../rendering/react/components/Success.js";
 import { Value } from "../../rendering/react/components/Value.js";
+import { loadStackFromTemplate } from "../../lib/resources/stack/template-loader.js";
+import { parse } from "envfile";
 export class Deploy extends ExecRenderBaseCommand {
     static description = "Deploys a docker-compose compatible file to a mittwald container stack";
     static aliases = ["stack:up"];
@@ -21,22 +23,63 @@ export class Deploy extends ExecRenderBaseCommand {
             summary: 'path to a compose file, or "-" to read from stdin',
             default: "./docker-compose.yml",
             char: "c",
+            exclusive: ["from-template"],
+        }),
+        "from-template": Flags.string({
+            summary: "deploy from a GitHub template (e.g., mittwald/n8n)",
+            description: `\
+Fetch and deploy a stack from a GitHub template repository. Template names are automatically converted to repository names by prefixing "stack-template-" to the name part.
+
+For example, "mittwald/n8n" resolves to the repository "mittwald/stack-template-n8n". The command fetches both docker-compose.yml and .env files from the main branch.
+
+Environment variable precedence (from lowest to highest):
+1. Template .env file (if present in the repository)
+2. System environment variables (process.env)
+3. Local --env-file (if specified)
+
+This flag is mutually exclusive with --compose-file.`,
+            exclusive: ["compose-file"],
         }),
         "env-file": Flags.file({
             summary: "alternative path to file with environment variables",
             default: "./.env",
         }),
     };
+    async loadStackDefinition(source, envFile, existing, renderer) {
+        // Build environment: start with process.env, then template .env, then local --env-file
+        let env = { ...process.env };
+        if ("template" in source) {
+            const hasServices = existing.services?.length ?? 0 > 0;
+            if (hasServices) {
+                throw new Error("Re-applying templates to existing stacks is currently not supported.");
+            }
+            // Load from GitHub template
+            const { composeYaml, envContent } = await renderer.runStep("fetching template from GitHub", () => loadStackFromTemplate(source.template));
+            if (envContent) {
+                const templateEnv = parse(envContent);
+                env = { ...env, ...templateEnv };
+            }
+            env = await collectEnvironment(env, envFile);
+            env = await fillMissingEnvironmentVariables(env, renderer);
+            return loadStackFromStr(composeYaml, env);
+        }
+        // Load from local file
+        env = await collectEnvironment(env, envFile);
+        return loadStackFromFile(source.composeFile, env);
+    }
     async exec() {
         const stackId = await withStackId(this.apiClient, Deploy, this.flags, this.args, this.config);
-        const { "compose-file": composeFile, "env-file": envFile } = this.flags;
+        const { "compose-file": composeFile, "from-template": fromTemplate, "env-file": envFile, } = this.flags;
         const r = makeProcessRenderer(this.flags, "Deploying container stack");
+        const existingStack = await r.runStep("retrieving current stack state", async () => {
+            const resp = await this.apiClient.container.getStack({ stackId });
+            assertStatus(resp, 200);
+            return resp.data;
+        });
         const result = { restartedServices: [] };
-        const env = await collectEnvironment(process.env, envFile);
-        let stackDefinition = await loadStackFromFile(composeFile, env);
+        let stackDefinition = await this.loadStackDefinition(fromTemplate ? { template: fromTemplate } : { composeFile }, envFile, existingStack, r);
         stackDefinition = sanitizeStackDefinition(stackDefinition);
         stackDefinition = await r.runStep("getting image configurations", () => enrichStackDefinition(stackDefinition));
-        this.debug("complete stack definition: %O", stackDefinition);
         const declaredStack = await r.runStep("deploying stack", async () => {
             const resp = await this.apiClient.container.declareStack({
                 stackId,

package/dist/lib/context/FlagSetBuilder.d.ts

@@ -27,6 +27,7 @@ export type FlagSetOptions = {
     normalize: NormalizeFn;
     displayName: string;
     retrieveFromContext: boolean;
+    retrieveFunction: (client: MittwaldAPIV2Client, ctx: Context) => Promise<string | null>;
     expectedShortIDFormat: {
         pattern: RegExp;
         display: string;

package/dist/lib/context/FlagSetBuilder.js

@@ -119,7 +119,7 @@ export default class FlagSetBuilder {
     buildIDGetter() {
         const idInputSanityCheck = this.buildSanityCheck();
         const idFromArgsOrFlag = this.buildIDFromArgsOrFlag();
-        const { normalize = (_, id) => id, retrieveFromContext = true } = this.opts;
+        const { normalize = (_, id) => id, retrieveFromContext = true, retrieveFunction, } = this.opts;
         return async (apiClient, commandType, flags, args, cfg) => {
             const context = new Context(apiClient, cfg);
             const idInput = idFromArgsOrFlag(flags, args);
@@ -133,6 +133,12 @@ export default class FlagSetBuilder {
                     return idFromContext.value;
                 }
             }
+            if (retrieveFunction) {
+                const idFromFunction = await retrieveFunction(apiClient, context);
+                if (idFromFunction) {
+                    return idFromFunction;
+                }
+            }
             throw makeMissingContextInputError(commandType, this.name, this.flagName);
         };
     }

package/dist/lib/intellij/config.test.js

@@ -7,7 +7,10 @@ import { generateIntellijConfigs } from "./config.js";
 describe("IntelliJ Config Generator", () => {
     let tempDir;
     let testData;
-    const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "@_" });
+    const parser = new XMLParser({
+        ignoreAttributes: false,
+        attributeNamePrefix: "@_",
+    });
     beforeEach(() => {
         tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "intellij-test-"));
         testData = {
@@ -74,7 +77,11 @@ describe("IntelliJ Config Generator", () => {
         });
         test("should add multiple SSH configs for different hosts", () => {
             generateIntellijConfigs(testData, tempDir);
-            const differentHostData = { ...testData, host: "ssh.other.example.com", appShortId: "app456" };
+            const differentHostData = {
+                ...testData,
+                host: "ssh.other.example.com",
+                appShortId: "app456",
+            };
             generateIntellijConfigs(differentHostData, tempDir);
             const configPath = path.join(tempDir, ".idea", "sshConfigs.xml");
             const content = fs.readFileSync(configPath, "utf8");

package/dist/lib/resources/app/Installer.d.ts

@@ -5,7 +5,7 @@ import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { Config } from "@oclif/core";
 type AppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
 type AppInstallation = MittwaldAPIV2.Components.Schemas.AppAppInstallation;
-type ImplicitDefaultFlag = "wait" | "wait-timeout" | "site-title";
+type ImplicitDefaultFlag = "wait" | "wait-timeout" | "site-title" | "install-path" | "update-context";
 export interface AppInstallationResult {
     appInstallation: AppInstallation;
     appVersion: AppVersion;

package/dist/lib/resources/app/Installer.js

@@ -7,6 +7,7 @@ import { triggerAppInstallation } from "./install.js";
 import { waitUntilAppStateHasNormalized } from "./wait.js";
 import { Success } from "../../../rendering/react/components/Success.js";
 import AppUsageHints from "../../../rendering/react/components/AppInstallation/AppUsageHints.js";
+import Context from "../../context/Context.js";
 export class AppInstaller {
     appId;
     appName;
@@ -25,7 +26,14 @@ export class AppInstaller {
         this.description = AppInstaller.makeDescription(appName);
     }
     get flags() {
-        const flags = provideSupportedFlags([...this.appSupportedFlags, "wait", "wait-timeout", "site-title"], this.appName);
+        const flags = provideSupportedFlags([
+            ...this.appSupportedFlags,
+            "wait",
+            "wait-timeout",
+            "site-title",
+            "install-path",
+            "update-context",
+        ], this.appName);
         if (this.mutateFlags) {
             this.mutateFlags(flags);
         }
@@ -45,6 +53,11 @@ export class AppInstaller {
         else {
             successText = `Your ${this.appName} installation has started. Have fun when it's ready! 🎉`;
         }
+        if (flags["update-context"]) {
+            const context = new Context(apiClient, config);
+            await context.setProjectId(appInstallation.projectId);
+            await context.setAppInstallationId(appInstallation.id);
+        }
         await process.complete(_jsx(Success, { children: successText }));
         return {
             appInstallation,

package/dist/lib/resources/app/flags.d.ts

@@ -1,7 +1,7 @@
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 import { ProcessRenderer } from "../../../rendering/process/process.js";
 import { ProcessFlags } from "../../../rendering/process/process_flags.js";
-import { FlagInput, OptionFlag, OutputFlags } from "@oclif/core/interfaces";
+import { BooleanFlag, FlagInput, OptionFlag, OutputFlags } from "@oclif/core/interfaces";
 import { waitFlags } from "../../wait.js";
 export declare const appInstallationFlags: import("../../context/FlagSetBuilder.js").ContextFlags<"installation">, appInstallationArgs: import("../../context/FlagSetBuilder.js").ContextArgs<"installation">, withAppInstallationId: (apiClient: MittwaldAPIV2Client, command: "flag" | "arg" | import("../../context/FlagSetBuilder.js").CommandType<"installation">, flags: {
     [k: string]: unknown;
@@ -22,10 +22,12 @@ type AvailableFlags = typeof waitFlags & {
     "shop-lang": OptionFlag<string | undefined>;
     "shop-currency": OptionFlag<string | undefined>;
     "install-mode": OptionFlag<string>;
+    "install-path": OptionFlag<string>;
     "document-root": OptionFlag<string>;
     "opensearch-host": OptionFlag<string>;
     "opensearch-port": OptionFlag<string>;
     entrypoint: OptionFlag<string | undefined>;
+    "update-context": BooleanFlag<boolean>;
 };
 export type RelevantFlags<TFlags extends readonly AvailableFlagName[]> = ProcessFlags & Pick<AvailableFlags, TFlags[number]>;
 export type RelevantFlagInput<TFlags extends readonly AvailableFlagName[]> = FlagInput<RelevantFlags<TFlags>>;

package/dist/lib/resources/app/flags.js

@@ -113,6 +113,12 @@ function buildFlagsWithDescription(appName) {
             options: ["composer", "symlink"],
             default: "composer",
         }),
+        "install-path": Flags.string({
+            required: false,
+            summary: `the installation path of your ${appName} application`,
+            description: "This is the path where your application will be installed. If omitted, this will default to an automatically-generated path.",
+            default: undefined,
+        }),
         "document-root": Flags.string({
             required: true,
             summary: `the document root from which your ${appName} will be served (relative to the installation path)`,
@@ -137,6 +143,12 @@ function buildFlagsWithDescription(appName) {
             required: false,
             default: undefined,
         }),
+        "update-context": Flags.boolean({
+            description: "update the CLI context to use the newly created app installation",
+            char: "c",
+            required: false,
+            default: false,
+        }),
         ...waitFlags,
     };
 }

package/dist/lib/resources/app/install.d.ts

@@ -5,6 +5,7 @@ type AppAppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
 export declare function triggerAppInstallation(apiClient: MittwaldAPIV2Client, process: ProcessRenderer, projectId: string, flags: {
     "site-title": string;
     "document-root"?: string;
+    "install-path"?: string;
 } & {
     [k: string]: unknown;
 }, appVersion: AppAppVersion): Promise<AppAppInstallation>;

package/dist/lib/resources/app/install.js

@@ -7,6 +7,7 @@ export async function triggerAppInstallation(apiClient, process, projectId, flag
                 appVersionId: appVersion.id,
                 description: flags["site-title"],
                 updatePolicy: "none",
+                installationPath: flags["install-path"],
                 userInputs: Object.keys(flags).map((k) => ({
                     name: k.replace("-", "_"),
                     value: flags[k],

package/dist/lib/resources/app/versions.d.ts

@@ -1,11 +1,17 @@
 import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
 import { ProcessRenderer } from "../../../rendering/process/process.js";
 type AppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+type ObjectWithVersions = {
+    internalVersion: string;
+    externalVersion: string;
+};
 export declare function normalizeToAppVersionUuid(apiClient: MittwaldAPIV2Client, version: string, process: ProcessRenderer, appUuid: string): Promise<MittwaldAPIV2.Components.Schemas.AppAppVersion>;
 export declare function getLatestAvailableAppVersionForApp(apiClient: MittwaldAPIV2Client, appId: string): Promise<AppVersion | undefined>;
 export declare function getAllUpgradeCandidatesFromAppInstallationId(apiClient: MittwaldAPIV2Client, appInstallationId: string): Promise<AppVersion[]>;
 export declare function getLatestAvailableTargetAppVersionForAppVersionUpgradeCandidates(apiClient: MittwaldAPIV2Client, appId: string, baseAppVersionId: string): Promise<AppVersion | undefined>;
 export declare function getAvailableTargetAppVersionFromExternalVersion(apiClient: MittwaldAPIV2Client, appId: string, baseAppVersionId: string, targetExternalVersion: string): Promise<AppVersion | undefined>;
 export declare function getAppVersionUuidFromAppVersion(apiClient: MittwaldAPIV2Client, appId: string, appVersion: string | undefined): Promise<AppVersion | undefined>;
-export declare function sortArrayByExternalVersion(versions: AppVersion[]): AppVersion[];
+export declare function sortArrayByExternalVersion<T extends ObjectWithVersions>(versions: T[]): T[];
+export declare function sortArrayByInternalVersion<T extends ObjectWithVersions>(versions: T[]): T[];
+export declare function compareVersionsBy<T extends ObjectWithVersions>(field: "internal" | "external"): (a: T, b: T) => -1 | 0 | 1;
 export {};

package/dist/lib/resources/app/versions.js

@@ -1,5 +1,5 @@
 import { assertStatus } from "@mittwald/api-client-commons";
-import { gt } from "semver";
+import { coerce, gt } from "semver";
 import { getAppInstallationFromUuid, getAppNameFromUuid } from "./uuid.js";
 import { compare } from "semver";
 export async function normalizeToAppVersionUuid(apiClient, version, process, appUuid) {
@@ -78,5 +78,38 @@ export async function getAppVersionUuidFromAppVersion(apiClient, appId, appVersi
         item.externalVersion === appVersion);
 }
 export function sortArrayByExternalVersion(versions) {
-    return versions.sort((a, b) => compare(b.externalVersion, a.externalVersion));
+    return versions.sort(compareVersionsBy("external"));
+}
+export function sortArrayByInternalVersion(versions) {
+    return versions.sort(compareVersionsBy("internal"));
+}
+export function compareVersionsBy(field) {
+    const fullField = `${field}Version`;
+    return (a, b) => {
+        const aCoerced = coerce(a[fullField]);
+        const bCoerced = coerce(b[fullField]);
+        if (!aCoerced || !bCoerced) {
+            return naiveVersionCompare(a.internalVersion, b.internalVersion);
+        }
+        return compare(aCoerced, bCoerced);
+    };
+}
+/**
+ * A naive version comparison function that compares version strings in the
+ * format "x.y.z". This function does not handle pre-release or build metadata.
+ */
+function naiveVersionCompare(a, b) {
+    const aParts = a.split(".").map((part) => parseInt(part, 10));
+    const bParts = b.split(".").map((part) => parseInt(part, 10));
+    for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+        const aPart = aParts[i] || 0;
+        const bPart = bParts[i] || 0;
+        if (aPart > bPart) {
+            return 1;
+        }
+        if (aPart < bPart) {
+            return -1;
+        }
+    }
+    return 0;
 }

package/dist/lib/resources/container/containerconfig.js

@@ -40,7 +40,13 @@ export async function parseEnvironmentVariablesFromFile(envFiles = []) {
  * @returns An object containing environment variable key-value pairs
  */
 export function parseEnvironmentVariablesFromEnvFlags(envFlags = []) {
-    const splitIntoKeyAndValue = (e) => e.split("=", 2);
+    const splitIntoKeyAndValue = (e) => {
+        const index = e.indexOf("=");
+        if (index < 0) {
+            throw new Error(`Invalid environment variable format: ${e}`);
+        }
+        return [e.slice(0, index), e.slice(index + 1)];
+    };
     return Object.fromEntries(envFlags.map(splitIntoKeyAndValue));
 }
 /**

package/dist/lib/resources/container/containerconfig.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/resources/container/containerconfig.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "@jest/globals";
+import { parseEnvironmentVariablesFromEnvFlags } from "./containerconfig.js";
+describe("Containerconfig handling", () => {
+    describe("Config parsing", () => {
+        test("call parser with simple flags", () => {
+            const args = ["foo=bar", "ham=eggs"];
+            const res = parseEnvironmentVariablesFromEnvFlags(args);
+            expect(res).toStrictEqual({
+                foo: "bar",
+                ham: "eggs",
+            });
+        });
+        test("call parser with flag containing another '='", () => {
+            const args = ["extra_args=first=1 second=2 third=littlebitoflove"];
+            const res = parseEnvironmentVariablesFromEnvFlags(args);
+            expect(res).toStrictEqual({
+                extra_args: "first=1 second=2 third=littlebitoflove",
+            });
+        });
+        test("throw error for invalid flag format", () => {
+            const args = ["invalidFlagWithoutEqualsSign"];
+            expect(() => parseEnvironmentVariablesFromEnvFlags(args)).toThrow("Invalid environment variable format: invalidFlagWithoutEqualsSign");
+        });
+    });
+});

package/dist/lib/resources/database/mysql/flags.js

@@ -3,7 +3,7 @@ import { assertStatus } from "@mittwald/api-client-commons";
 export const mysqlConnectionFlags = {
     "mysql-password": Flags.string({
         char: "p",
-        summary: "the password to use for the MySQL user (env: MYSQL_PWD)",
+        summary: "the password to use for the MySQL user",
         description: `\
 The password to use for the MySQL user. If not provided, the environment variable MYSQL_PWD will be used. If that is not set either, the command will interactively ask for the password.
 

package/dist/lib/resources/stack/env.d.ts

@@ -1 +1,11 @@
+import { ProcessRenderer } from "../../../rendering/process/process.js";
 export declare function collectEnvironment(base: NodeJS.ProcessEnv, envFile: string): Promise<Record<string, string | undefined>>;
+/**
+ * Fills in missing environment variables in the base environment.
+ *
+ * This is done by checking for special placeholder values:
+ *
+ * - `__PROMPT__`: prompts the user to input a value.
+ * - `__GENERATE__`: generates a random base64-encoded string.
+ */
+export declare function fillMissingEnvironmentVariables(base: NodeJS.ProcessEnv, renderer: ProcessRenderer): Promise<Record<string, string | undefined>>;

package/dist/lib/resources/stack/env.js

@@ -1,6 +1,7 @@
 import * as fs from "fs/promises";
 import { parse } from "envfile";
 import { pathExists } from "../../util/fs/pathExists.js";
+import { getRandomValues } from "node:crypto";
 export async function collectEnvironment(base, envFile) {
     if (!(await pathExists(envFile))) {
         return base;
@@ -9,3 +10,24 @@ export async function collectEnvironment(base, envFile) {
     const parsed = parse(defs);
     return { ...base, ...parsed };
 }
+/**
+ * Fills in missing environment variables in the base environment.
+ *
+ * This is done by checking for special placeholder values:
+ *
+ * - `__PROMPT__`: prompts the user to input a value.
+ * - `__GENERATE__`: generates a random base64-encoded string.
+ */
+export async function fillMissingEnvironmentVariables(base, renderer) {
+    const output = { ...base };
+    for (const [key, value] of Object.entries(base)) {
+        if (value === "__PROMPT__") {
+            output[key] = await renderer.addInput(`enter value for environment variable ${key}`, false);
+        }
+        if (value === "__GENERATE__") {
+            renderer.addInfo(`generating random value for environment variable ${key}`);
+            output[key] = Buffer.from(getRandomValues(new Uint8Array(32))).toString("base64");
+        }
+    }
+    return output;
+}

package/dist/lib/resources/stack/flags.js

@@ -1,2 +1,17 @@
 import FlagSetBuilder from "../../context/FlagSetBuilder.js";
-export const { flags: stackFlags, args: stackArgs, withId: withStackId, } = new FlagSetBuilder("stack", "s").build();
+import { assertStatus } from "@mittwald/api-client";
+export const { flags: stackFlags, args: stackArgs, withId: withStackId, } = new FlagSetBuilder("stack", "s", {
+    retrieveFunction: async (client, context) => {
+        const projectContext = await context.projectId();
+        if (!projectContext) {
+            return null;
+        }
+        const projectId = projectContext.value;
+        const stacks = await client.container.listStacks({ projectId });
+        assertStatus(stacks, 200);
+        if (stacks.data.length === 1) {
+            return stacks.data[0].id;
+        }
+        return null;
+    },
+}).build();

package/dist/lib/resources/stack/template-loader.d.ts

@@ -0,0 +1,18 @@
+export interface TemplateContent {
+    composeYaml: string;
+    envContent: string | null;
+}
+export declare class TemplateFileNotFoundError extends Error {
+    constructor(url: string);
+}
+export declare class GitHubRateLimitError extends Error {
+    constructor();
+}
+export declare class TemplateNetworkError extends Error {
+    constructor(message: string);
+}
+export declare function validateTemplateName(name: string): void;
+export declare function templateNameToRepoName(templateName: string): string;
+export declare function buildGitHubRawUrl(templateName: string, filename: string): string;
+export declare function fetchTemplateFile(url: string): Promise<string>;
+export declare function loadStackFromTemplate(templateName: string): Promise<TemplateContent>;

package/dist/lib/resources/stack/template-loader.js

@@ -0,0 +1,94 @@
+import axios from "axios";
+export class TemplateFileNotFoundError extends Error {
+    constructor(url) {
+        super(`File not found at ${url}`);
+        this.name = "TemplateFileNotFoundError";
+    }
+}
+export class GitHubRateLimitError extends Error {
+    constructor() {
+        super("GitHub API rate limit exceeded. Please try again later.");
+        this.name = "GitHubRateLimitError";
+    }
+}
+export class TemplateNetworkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TemplateNetworkError";
+    }
+}
+export function validateTemplateName(name) {
+    const validFormat = /^[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+$/;
+    if (!validFormat.test(name)) {
+        throw new Error(`Invalid template name format: '${name}'. Expected format: 'owner/name' (e.g., 'mittwald/n8n')`);
+    }
+}
+export function templateNameToRepoName(templateName) {
+    const [owner, name] = templateName.split("/");
+    return `${owner}/stack-template-${name}`;
+}
+export function buildGitHubRawUrl(templateName, filename) {
+    const repoName = templateNameToRepoName(templateName);
+    return `https://raw.githubusercontent.com/${repoName}/main/${filename}`;
+}
+function convertAxiosError(error, url) {
+    if (!axios.isAxiosError(error)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    const axiosError = error;
+    if (axiosError.response?.status === 404) {
+        return new TemplateFileNotFoundError(url);
+    }
+    if (axiosError.response?.status === 403) {
+        return new GitHubRateLimitError();
+    }
+    if (axiosError.code === "ETIMEDOUT") {
+        return new TemplateNetworkError("Request timed out while fetching template from GitHub");
+    }
+    if (axiosError.code === "ECONNREFUSED" || axiosError.code === "ENOTFOUND") {
+        return new TemplateNetworkError("Network error: Unable to connect to GitHub. Please check your internet connection.");
+    }
+    return error;
+}
+export async function fetchTemplateFile(url) {
+    try {
+        const response = await axios.get(url, {
+            responseType: "text",
+            timeout: 10000,
+        });
+        return response.data;
+    }
+    catch (error) {
+        throw convertAxiosError(error, url);
+    }
+}
+export async function loadStackFromTemplate(templateName) {
+    validateTemplateName(templateName);
+    const composeUrl = buildGitHubRawUrl(templateName, "docker-compose.yml");
+    const envUrl = buildGitHubRawUrl(templateName, ".env");
+    let composeYaml;
+    try {
+        composeYaml = await fetchTemplateFile(composeUrl);
+    }
+    catch (error) {
+        if (error instanceof TemplateFileNotFoundError) {
+            const repoName = templateNameToRepoName(templateName);
+            throw new Error(`Template '${templateName}' not found. Repository '${repoName}' does not exist or does not contain a docker-compose.yml file.`);
+        }
+        throw error;
+    }
+    let envContent = null;
+    try {
+        envContent = await fetchTemplateFile(envUrl);
+    }
+    catch (error) {
+        if (error instanceof TemplateFileNotFoundError) {
+            // .env file is optional, so we ignore 404 errors
+            envContent = null;
+        }
+        else {
+            throw error;
+        }
+    }
+    return { composeYaml, envContent };
+}

package/dist/lib/resources/stack/template-loader.test.d.ts

@@ -0,0 +1 @@
+export {};