@mittwald/cli 1.2.2 → 1.2.6

package/dist/commands/context/set.js

@@ -21,7 +21,9 @@ export class Set extends BaseCommand {
     };
     async run() {
         const { flags } = await this.parse(Set);
-        const ctx = new Context(this.apiClient, this.config);
+        const ctx = new Context(this.apiClient, this.config, {
+            onInitError() { },
+        });
         if (flags["project-id"]) {
             const projectId = await ctx.setProjectId(flags["project-id"]);
             this.log(`Set project ID to ${projectId}`);

package/dist/commands/login/status.js

@@ -1,22 +1,23 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { formatDistanceToNow } from "date-fns";
 import { RenderBaseCommand } from "../../lib/basecommands/RenderBaseCommand.js";
 import { SingleResult, SingleResultTable, } from "../../rendering/react/components/SingleResult.js";
 import useOwnAccount from "../../lib/resources/login/useOwnAccount.js";
+import { Text } from "ink";
 export default class Status extends RenderBaseCommand {
     static description = "Checks your current authentication status";
     render() {
         const account = useOwnAccount(this.apiClient);
         const rows = {};
         rows["User identification"] = (_jsx(SingleResultTable, { rows: {
-                Id: account.userId,
-                Email: account.email,
+                Id: _jsx(Text, { children: account.userId }),
+                Email: _jsx(Text, { children: account.email }),
             } }));
         if (account.person) {
-            rows["Name"] = `${account.person.firstName} ${account.person.lastName}`;
+            rows["Name"] = (_jsxs(Text, { children: [account.person.firstName, " ", account.person.lastName] }));
         }
         if (account.passwordUpdatedAt) {
-            rows["Last password change"] = `${formatDistanceToNow(new Date(account.passwordUpdatedAt))} ago`;
+            rows["Last password change"] = (_jsxs(Text, { children: [formatDistanceToNow(new Date(account.passwordUpdatedAt)), " ago"] }));
         }
         return _jsx(SingleResult, { title: "Login status", rows: rows });
     }

package/dist/commands/org/invite/list-own.d.ts

@@ -40,7 +40,7 @@ export declare class List extends ListBaseCommand<typeof List, ResponseItem, Res
             owner?: import("node_modules/@mittwald/api-client/dist/types/generated/v2/types.js").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
             projectCount: number;
             vatId?: string | undefined;
-            vatIdValidationState?: ("valid" | "invalid" | "pending" | "unspecified") | undefined;
+            vatIdValidationState?: "valid" | "invalid" | "pending" | "unspecified" | undefined;
         };
         avatarRefId?: string;
         customerId: string;

package/dist/commands/org/membership/list-own.d.ts

@@ -40,7 +40,7 @@ export declare class ListOwn extends ListBaseCommand<typeof ListOwn, ResponseIte
             owner?: import("node_modules/@mittwald/api-client/dist/types/generated/v2/types.js").MittwaldAPIV2.Components.Schemas.CustomerContact | undefined;
             projectCount: number;
             vatId?: string | undefined;
-            vatIdValidationState?: ("valid" | "invalid" | "pending" | "unspecified") | undefined;
+            vatIdValidationState?: "valid" | "invalid" | "pending" | "unspecified" | undefined;
         };
         customerId: string;
         email: string;

package/dist/commands/org/membership/list.d.ts

@@ -27,10 +27,14 @@ export declare class List extends ListBaseCommand<typeof List, ResponseItem, Res
     protected mapData(data: SuccessfulResponse<Response, 200>["data"]): Promise<(MittwaldAPIV2.Components.Schemas.MembershipCustomerMembership | {
         user: {
             avatarRef?: string | undefined;
+            customerMemberships?: {
+                [k: string]: import("node_modules/@mittwald/api-client/dist/types/generated/v2/types.js").MittwaldAPIV2.Components.Schemas.UserCustomerMembership;
+            } | undefined;
             email?: string | undefined;
             employeeInformation?: {
                 department: string;
             } | undefined;
+            isEmployee?: boolean | undefined;
             mfa?: {
                 active: boolean;
                 setup: boolean;
@@ -38,6 +42,9 @@ export declare class List extends ListBaseCommand<typeof List, ResponseItem, Res
             passwordUpdatedAt?: string | undefined;
             person: import("node_modules/@mittwald/api-client/dist/types/generated/v2/types.js").MittwaldAPIV2.Components.Schemas.CommonsPerson;
             phoneNumber?: string | undefined;
+            projectMemberships?: {
+                [k: string]: import("node_modules/@mittwald/api-client/dist/types/generated/v2/types.js").MittwaldAPIV2.Components.Schemas.UserProjectMembership;
+            } | undefined;
             registeredAt?: string | undefined;
             userId: string;
         };

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

@@ -16,11 +16,15 @@ export type ContextValue = {
 export declare const contextIDNormalizers: {
     [k in ContextKey]?: (apiClient: MittwaldAPIV2Client, id: string) => Promise<string>;
 };
+export interface ContextOptions {
+    onInitError: (err: unknown) => void;
+}
 export default class Context {
     private readonly contextData;
     private readonly apiClient;
+    private readonly opts;
     readonly providers: ContextProvider[];
-    constructor(apiClient: MittwaldAPIV2Client, config: Config);
+    constructor(apiClient: MittwaldAPIV2Client, config: Config, opts?: Partial<ContextOptions>);
     private initializeContextData;
     reset(): Promise<void>;
     private persist;

package/dist/lib/context/Context.js

@@ -1,6 +1,7 @@
 import UserContextProvider from "./UserContextProvider.js";
 import TerraformContextProvider from "./TerraformContextProvider.js";
 import DDEVContextProvider from "./DDEVContextProvider.js";
+import InvalidContextError from "../error/InvalidContextError.js";
 function isWritable(p) {
     return "update" in p;
 }
@@ -8,21 +9,35 @@ export const contextIDNormalizers = {};
 export default class Context {
     contextData;
     apiClient;
+    opts;
     providers;
-    constructor(apiClient, config) {
+    constructor(apiClient, config, opts = {}) {
         this.apiClient = apiClient;
         this.providers = [
             new UserContextProvider(config),
             new TerraformContextProvider(),
             new DDEVContextProvider(apiClient),
         ];
+        this.opts = {
+            onInitError(err) {
+                throw err;
+            },
+            ...opts,
+        };
         this.contextData = this.initializeContextData();
     }
     async initializeContextData() {
         const contextData = {};
         for (const provider of this.providers) {
-            const overrides = await provider.getOverrides();
-            Object.assign(contextData, overrides);
+            try {
+                const overrides = await provider.getOverrides();
+                Object.assign(contextData, overrides);
+            }
+            catch (err) {
+                if (err instanceof InvalidContextError) {
+                    this.opts.onInitError(err);
+                }
+            }
         }
         return contextData;
     }

package/dist/lib/context/DDEVContextProvider.js

@@ -4,6 +4,7 @@ import fs from "fs/promises";
 import yaml from "js-yaml";
 import { assertStatus } from "@mittwald/api-client";
 import { pathExists } from "../util/fs/pathExists.js";
+import InvalidContextError from "../error/InvalidContextError.js";
 /**
  * DDEVContextProvider is a ContextProvider that reads context overrides from
  * local DDEV configuration files; it looks for a .ddev directory in the current
@@ -44,20 +45,25 @@ export default class DDEVContextProvider {
         return overrides;
     }
     async fillOverridesFromAppInstallationId(source, appInstallationId) {
-        const response = await this.apiClient.app.getAppinstallation({
-            appInstallationId,
-        });
-        assertStatus(response, 200);
-        const out = {
-            "installation-id": { value: response.data.id, source },
-        };
-        if (response.data.projectId) {
-            out["project-id"] = {
-                value: response.data.projectId,
-                source,
+        try {
+            const response = await this.apiClient.app.getAppinstallation({
+                appInstallationId,
+            });
+            assertStatus(response, 200);
+            const out = {
+                "installation-id": { value: response.data.id, source },
             };
+            if (response.data.projectId) {
+                out["project-id"] = {
+                    value: response.data.projectId,
+                    source,
+                };
+            }
+            return out;
+        }
+        catch (err) {
+            throw new InvalidContextError(`error while getting app installation ${appInstallationId}: ${err}`, { cause: err });
         }
-        return out;
     }
     /**
      * Find the .ddev directory in the current working directory or any of its

package/dist/lib/error/InvalidContextError.d.ts

@@ -0,0 +1,2 @@
+export default class InvalidContextError extends Error {
+}

package/dist/lib/error/InvalidContextError.js

@@ -0,0 +1,2 @@
+export default class InvalidContextError extends Error {
+}

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

@@ -159,7 +159,7 @@ export function provideSupportedFlags(requestedFlagNames, appName) {
     return flagsToReturn;
 }
 export async function autofillFlags(apiClient, process, necessaryFlags, flags, projectId, appName, defaults) {
-    const ownUser = await apiClient.user.getOwnAccount();
+    const ownUser = await apiClient.user.getUser({ userId: "self" });
     assertStatus(ownUser, 200);
     // Version
     if (necessaryFlags.includes("version") && !flags.version) {

package/dist/lib/resources/database/common.js

@@ -1,7 +1,7 @@
 import { assertStatus } from "@mittwald/api-client-commons";
 export async function getUser(apiClient, p) {
     return await p.runStep("fetching user", async () => {
-        const r = await apiClient.user.getOwnAccount();
+        const r = await apiClient.user.getUser({ userId: "self" });
         assertStatus(r, 200);
         return r.data;
     });

package/dist/lib/resources/database/mysql/temp_user.d.ts

@@ -2,6 +2,16 @@ import type { MittwaldAPIV2 } from "@mittwald/api-client";
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 import { ProcessRenderer } from "../../../../rendering/process/process.js";
 type DatabaseMySqlUser = MittwaldAPIV2.Components.Schemas.DatabaseMySqlUser;
+/**
+ * Generates a random password that fulfills the requirements for [mysql
+ * passwords][mysql].
+ *
+ * [mysql]: https://developer.mittwald.de/docs/v2/api/security/passwords#mysql
+ *
+ * @param length Desired length in characters
+ * @returns A randomly generated password
+ */
+export declare function generateRandomPassword(length?: number): string;
 /**
  * Runs a callback function with a temporary user for a database operation.
  *

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

@@ -1,6 +1,6 @@
 import { assertStatus } from "@mittwald/api-client";
-import { randomBytes } from "crypto";
 import assertSuccess from "../../../apiutil/assert_success.js";
+import { randomInt } from "crypto";
 async function createTemporaryUser(apiClient, databaseId, password) {
     const createResponse = await apiClient.database.createMysqlUser({
         mysqlDatabaseId: databaseId,
@@ -22,8 +22,39 @@ async function retrieveTemporaryUser(apiClient, mysqlUserId) {
     assertStatus(userResponse, 200);
     return userResponse.data;
 }
-function generateRandomPassword() {
-    return randomBytes(32).toString("base64");
+/**
+ * Generates a random password that fulfills the requirements for [mysql
+ * passwords][mysql].
+ *
+ * [mysql]: https://developer.mittwald.de/docs/v2/api/security/passwords#mysql
+ *
+ * @param length Desired length in characters
+ * @returns A randomly generated password
+ */
+export function generateRandomPassword(length = 32) {
+    // Character pools
+    const lowercase = "abcdefghijklmnopqrstuvwxyz";
+    const uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    const digits = "0123456789";
+    const specialChars = "#!~%^*_+-=?{}()<>|.,;";
+    const allChars = lowercase + uppercase + digits + specialChars;
+    // Ensure the password includes at least one of each required character type
+    const passwordArray = [
+        lowercase[randomInt(0, lowercase.length)],
+        uppercase[randomInt(0, uppercase.length)],
+        digits[randomInt(0, digits.length)],
+        specialChars[randomInt(0, specialChars.length)],
+    ];
+    // Fill the remaining characters randomly
+    for (let i = passwordArray.length; i < length; i++) {
+        passwordArray.push(allChars[randomInt(0, allChars.length)]);
+    }
+    // Shuffle the array to avoid predictable patterns
+    for (let i = passwordArray.length - 1; i > 0; i--) {
+        const j = randomInt(0, i + 1);
+        [passwordArray[i], passwordArray[j]] = [passwordArray[j], passwordArray[i]];
+    }
+    return passwordArray.join("");
 }
 /**
  * Runs a callback function with a temporary user for a database operation.

package/dist/lib/resources/database/mysql/temp_user.test.d.ts

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

package/dist/lib/resources/database/mysql/temp_user.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "@jest/globals";
+import { generateRandomPassword } from "./temp_user.js";
+describe("generateRandomPassword", () => {
+    it("should generate a password of the specified length", () => {
+        const length = 12;
+        const password = generateRandomPassword(length);
+        expect(password.length).toBe(length);
+    });
+    it("should include at least one lowercase character", () => {
+        const password = generateRandomPassword(12);
+        expect(/[a-z]/.test(password)).toBe(true);
+    });
+    it("should include at least one uppercase character", () => {
+        const password = generateRandomPassword(12);
+        expect(/[A-Z]/.test(password)).toBe(true);
+    });
+    it("should include at least one digit", () => {
+        const password = generateRandomPassword(12);
+        expect(/[0-9]/.test(password)).toBe(true);
+    });
+    it("should include at least one special character", () => {
+        const specialChars = "#!~%^*_+-=?{}()<>|.,;";
+        const password = generateRandomPassword(12);
+        expect(new RegExp(`[${specialChars.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&")}]`).test(password)).toBe(true);
+    });
+    it("should generate passwords that are unique", () => {
+        const password1 = generateRandomPassword(12);
+        const password2 = generateRandomPassword(12);
+        expect(password1).not.toBe(password2);
+    });
+    it("should work for passwords with length greater than 8", () => {
+        const password = generateRandomPassword(20);
+        expect(password.length).toBe(20);
+        expect(/[a-z]/.test(password)).toBe(true);
+        expect(/[A-Z]/.test(password)).toBe(true);
+        expect(/[0-9]/.test(password)).toBe(true);
+        const specialChars = "#!~%^*_+-=?{}()<>|.,;";
+        expect(new RegExp(`[${specialChars.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&")}]`).test(password)).toBe(true);
+    });
+});

package/dist/lib/resources/login/useOwnAccount.d.ts

@@ -1,11 +1,24 @@
 import { MittwaldAPIV2Client } from "@mittwald/api-client";
 export default function useOwnAccount(client: MittwaldAPIV2Client): {
+    avatarRef?: string | undefined;
+    customerMemberships?: {
+        [k: string]: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.UserCustomerMembership;
+    } | undefined;
     email?: string | undefined;
-    mfaDetails?: {
-        mfaConfirmed?: boolean;
-        mfaInitialized?: boolean;
+    employeeInformation?: {
+        department: string;
+    } | undefined;
+    isEmployee?: boolean | undefined;
+    mfa?: {
+        active: boolean;
+        setup: boolean;
     } | undefined;
     passwordUpdatedAt?: string | undefined;
-    person?: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CommonsPerson | undefined;
-    userId?: string | undefined;
+    person: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.CommonsPerson;
+    phoneNumber?: string | undefined;
+    projectMemberships?: {
+        [k: string]: import("@mittwald/api-client").MittwaldAPIV2.Components.Schemas.UserProjectMembership;
+    } | undefined;
+    registeredAt?: string | undefined;
+    userId: string;
 };

package/dist/lib/resources/login/useOwnAccount.js

@@ -1,7 +1,7 @@
 import { assertStatus } from "@mittwald/api-client";
 import { usePromise } from "@mittwald/react-use-promise";
 export default function useOwnAccount(client) {
-    const result = usePromise(() => client.user.getOwnAccount(), []);
+    const result = usePromise(() => client.user.getUser({ userId: "self" }), []);
     assertStatus(result, 200);
     return result.data;
 }

package/dist/lib/resources/ssh/appinstall.js

@@ -13,7 +13,7 @@ export async function getSSHConnectionForAppInstallation(client, appInstallation
     });
     assertStatus(projectResponse, 200);
     if (sshUser === undefined) {
-        const userResponse = await client.user.getOwnAccount();
+        const userResponse = await client.user.getUser({ userId: "self" });
         assertStatus(userResponse, 200);
         sshUser = userResponse.data.email;
     }

package/dist/lib/resources/ssh/project.js

@@ -3,7 +3,7 @@ export async function getSSHConnectionForProject(client, projectId, sshUser) {
     const projectResponse = await client.project.getProject({ projectId });
     assertStatus(projectResponse, 200);
     if (sshUser === undefined) {
-        const userResponse = await client.user.getOwnAccount();
+        const userResponse = await client.user.getUser({ userId: "self" });
         assertStatus(userResponse, 200);
         sshUser = userResponse.data.email;
     }

package/dist/lib/units/Duration.js

@@ -28,7 +28,7 @@ export default class Duration {
     }
     static fromString(input) {
         const parsed = parseDuration(input);
-        if (parsed === undefined) {
+        if (parsed === null) {
             throw new Error("could not parse duration: " + input);
         }
         return new Duration(parsed);

package/dist/lib/units/Duration.test.d.ts

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

package/dist/lib/units/Duration.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "@jest/globals";
+import Duration from "./Duration.js";
+describe("Duration class", () => {
+    describe("Static factory methods", () => {
+        test("fromZero should return a Duration of 0 milliseconds", () => {
+            const duration = Duration.fromZero();
+            expect(duration.milliseconds).toBe(0);
+        });
+        test("fromMilliseconds should return a Duration with the given milliseconds", () => {
+            const duration = Duration.fromMilliseconds(500);
+            expect(duration.milliseconds).toBe(500);
+        });
+        test("fromSeconds should return a Duration with the given seconds converted to milliseconds", () => {
+            const duration = Duration.fromSeconds(2);
+            expect(duration.milliseconds).toBe(2000);
+        });
+        test("fromString should parse valid duration strings", () => {
+            const duration = Duration.fromString("2s");
+            expect(duration.milliseconds).toBe(2000);
+        });
+        test("fromString should throw an error for invalid input", () => {
+            expect(() => Duration.fromString("invalid")).toThrow("could not parse duration: invalid");
+        });
+    });
+    describe("Instance methods", () => {
+        test("seconds should return duration in seconds", () => {
+            const duration = Duration.fromMilliseconds(3000);
+            expect(duration.seconds).toBe(3);
+        });
+        test("from should return a Date object offset by the duration", () => {
+            const baseDate = new Date("2023-01-01T00:00:00Z");
+            const duration = Duration.fromSeconds(10);
+            expect(duration.from(baseDate)).toEqual(new Date("2023-01-01T00:00:10Z"));
+        });
+        test("fromNow should return a future Date object", () => {
+            const duration = Duration.fromSeconds(5);
+            const now = new Date();
+            const future = duration.fromNow();
+            expect(future.getTime()).toBeGreaterThan(now.getTime());
+        });
+        test("add should correctly add two durations", () => {
+            const duration1 = Duration.fromSeconds(10);
+            const duration2 = Duration.fromSeconds(5);
+            const result = duration1.add(duration2);
+            expect(result.milliseconds).toBe(15000);
+        });
+        test("compare should return correct comparison results", () => {
+            const duration1 = Duration.fromSeconds(10);
+            const duration2 = Duration.fromSeconds(5);
+            expect(duration1.compare(duration2)).toBeGreaterThan(0);
+            expect(duration2.compare(duration1)).toBeLessThan(0);
+            expect(duration1.compare(duration1)).toBe(0);
+        });
+        test("toString should return formatted duration string", () => {
+            expect(Duration.fromMilliseconds(500).toString()).toBe("500ms");
+            expect(Duration.fromSeconds(3).toString()).toBe("3s");
+        });
+    });
+});

package/dist/rendering/react/components/OptionalValue.d.ts

@@ -1,5 +1,5 @@
 import { ReactNode } from "react";
-interface OptionalValueProps<T> {
+interface OptionalValueProps<T extends ReactNode> {
     value: T | undefined | null;
     render?: (value: T) => ReactNode;
 }
@@ -9,5 +9,5 @@ interface OptionalValueProps<T> {
  * @class
  * @param props
  */
-declare function OptionalValue<T>(props: OptionalValueProps<T>): import("react/jsx-runtime").JSX.Element;
+declare function OptionalValue<T extends ReactNode>(props: OptionalValueProps<T>): import("react/jsx-runtime").JSX.Element;
 export default OptionalValue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/cli",
-  "version": "1.2.2",
+  "version": "1.2.6",
   "description": "Hand-crafted CLI for the mittwald API",
   "license": "MIT",
   "author": {
@@ -28,7 +28,7 @@
     "package": "yarn package:tarballs && yarn package:windows && yarn package:macos",
     "package:macos": "oclif pack macos",
     "package:tarballs": "oclif pack tarballs --targets=linux-x64,linux-arm64,darwin-x64,darwin-arm64",
-    "package:windows": "oclif pack win",
+    "package:windows": "oclif pack win --targets=win32-x64,win32-x86",
     "post:generate": "yarn run -T compile && yarn run -T compile:cjs",
     "test": "yarn test:format && yarn test:licenses && yarn test:unit",
     "test:format": "yarn lint && yarn format --check",
@@ -59,7 +59,7 @@
     "marked": "^12.0.0",
     "marked-terminal": "^6.0.0",
     "open": "^10.0.3",
-    "parse-duration": "^1.1.0",
+    "parse-duration": "^2.0.1",
     "pretty-bytes": "^6.1.0",
     "react": "^18.2.0",
     "semver": "^7.5.4",
@@ -68,7 +68,7 @@
     "slice-ansi": "^7.1.0",
     "string-width": "^7.2.0",
     "tempfile": "^5.0.0",
-    "uuid": "^10.0.0"
+    "uuid": "^11.0.3"
   },
   "devDependencies": {
     "@jest/globals": "^29.7.0",
@@ -76,24 +76,23 @@
     "@types/chalk": "^2.2.0",
     "@types/js-yaml": "^4.0.9",
     "@types/marked-terminal": "^3.1.3",
-    "@types/node": "^20.3.3",
+    "@types/node": "^22.7.5",
     "@types/parse-duration": "^0.3.0",
     "@types/pretty-bytes": "^5.2.0",
     "@types/react": "^18",
     "@types/semver": "^7.5.0",
     "@types/shell-escape": "^0.2.3",
-    "@types/uuid": "^10.0.0",
     "@typescript-eslint/eslint-plugin": "^8.3.0",
     "@typescript-eslint/parser": "^8.3.0",
     "@yarnpkg/pnpify": "^4.0.0-rc.48",
     "eslint": "^9.9.1",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint-config-prettier": "^10.0.1",
     "eslint-plugin-json": "^4.0.0",
     "eslint-plugin-prettier": "^5.1.3",
     "globals": "^15.9.0",
     "jest": "^29.7.0",
     "license-checker-rseidelsohn": "^4.2.6",
-    "nock": "^13.5.4",
+    "nock": "^14.0.0",
     "oclif": "^4.14.31",
     "prettier": "^3.2.5",
     "prettier-plugin-jsdoc": "^1.3.0",