@mittwald/cli 1.0.0-alpha.10

package/dist/esm/generated/user/getSession.js

@@ -0,0 +1,25 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { Args } from "@oclif/core";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export class GeneratedUserGetSession extends GetBaseCommand {
+    static description = "Get a specific Session";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        tokenId: Args.string({
+            description: "tokenId to identify the concrete Session",
+            required: true,
+        }),
+    };
+    async getData() {
+        return await this.apiClient.user.getSession({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/user/getSshKey.d.ts

@@ -0,0 +1,16 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2UsersSelfSshKeys.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["user"]["getSshKey"]>>;
+export declare abstract class GeneratedUserGetSshKey extends GetBaseCommand<typeof GeneratedUserGetSshKey, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {
+        sshKeyId: import("@oclif/core/lib/interfaces/parser.js").Arg<string, Record<string, unknown>>;
+    };
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}
+export {};

package/dist/esm/generated/user/getSshKey.js

@@ -0,0 +1,25 @@
+/* eslint-disable */
+/* prettier-ignore */
+/* This file is auto-generated with acg (@mittwald/api-code-generator) */
+import { Args } from "@oclif/core";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export class GeneratedUserGetSshKey extends GetBaseCommand {
+    static description = "Get a specific stored SshKey";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {
+        sshKeyId: Args.string({
+            description: "undefined",
+            required: true,
+        }),
+    };
+    async getData() {
+        return await this.apiClient.user.getSshKey({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/user/getUser.d.ts

@@ -0,0 +1,14 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2UsersUserId.Get.Parameters.Path;
+type APIResponse = Awaited<ReturnType<MittwaldAPIV2Client["user"]["getUser"]>>;
+export declare abstract class GeneratedUserGetUser extends GetBaseCommand<typeof GeneratedUserGetUser, APIResponse> {
+    static description: string;
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    static args: {};
+    protected getData(): Promise<APIResponse>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}
+export {};

package/dist/esm/generated/user/getUser.js

@@ -0,0 +1,16 @@
+import { GetBaseCommand } from "../../GetBaseCommand.js";
+export class GeneratedUserGetUser extends GetBaseCommand {
+    static description = "Get profile information for a user.";
+    static flags = {
+        ...GetBaseCommand.baseFlags,
+    };
+    static args = {};
+    async getData() {
+        return await this.apiClient.user.getUser({
+            pathParameters: await this.mapParams(this.args),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/user/listApiTokens.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2UsersSelfApiTokens.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["user"]["listApiTokens"]>>;
+export declare abstract class GeneratedUserListApiTokens<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedUserListApiTokens, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/user/listApiTokens.js

@@ -0,0 +1,17 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedUserListApiTokens extends ListBaseCommand {
+    static description = "List all ApiTokens of the user";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.user.listApiTokens({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/user/listFeedback.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2UsersUserIdFeedback.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["user"]["listFeedback"]>>;
+export declare abstract class GeneratedUserListFeedback<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedUserListFeedback, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        "user-id": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/user/listFeedback.js

@@ -0,0 +1,24 @@
+import { Flags } from "@oclif/core";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedUserListFeedback extends ListBaseCommand {
+    static description = "Submitted feedback of the given user.";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+        "user-id": Flags.string({
+            description: "`self` or the id of a user.",
+            required: true,
+        }),
+    };
+    async getData() {
+        const pathParams = {
+            userId: this.flags["user-id"],
+        };
+        return await this.apiClient.user.listFeedback({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/user/listSessions.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2UsersSelfSessions.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["user"]["listSessions"]>>;
+export declare abstract class GeneratedUserListSessions<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedUserListSessions, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/user/listSessions.js

@@ -0,0 +1,17 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedUserListSessions extends ListBaseCommand {
+    static description = "List all active sessions";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.user.listSessions({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/generated/user/listSshKeys.d.ts

@@ -0,0 +1,13 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export type PathParams = MittwaldAPIV2.Paths.V2UsersSelfSshKeys.Get.Parameters.Path;
+export type Response = Awaited<ReturnType<MittwaldAPIV2Client["user"]["listSshKeys"]>>;
+export declare abstract class GeneratedUserListSshKeys<TItem extends Record<string, unknown>> extends ListBaseCommand<typeof GeneratedUserListSshKeys, TItem, Response> {
+    static description: string;
+    static args: {};
+    static flags: {
+        [x: string]: import("@oclif/core/lib/interfaces/parser.js").CompletableFlag<any>;
+    };
+    getData(): Promise<Response>;
+    protected mapParams(input: PathParams): Promise<PathParams> | PathParams;
+}

package/dist/esm/generated/user/listSshKeys.js

@@ -0,0 +1,17 @@
+import { ListBaseCommand } from "../../ListBaseCommand.js";
+export class GeneratedUserListSshKeys extends ListBaseCommand {
+    static description = "Get your stored ssh keys";
+    static args = {};
+    static flags = {
+        ...ListBaseCommand.baseFlags,
+    };
+    async getData() {
+        const pathParams = {};
+        return await this.apiClient.user.listSshKeys({
+            pathParameters: await this.mapParams(pathParams),
+        });
+    }
+    mapParams(input) {
+        return input;
+    }
+}

package/dist/esm/lib/app/appHelpers.d.ts

@@ -0,0 +1,4 @@
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare function getAppUuidFromAppName(apiClient: MittwaldAPIV2Client, softwareName: string): Promise<string>;
+export declare function getAppNameFromUuid(apiClient: MittwaldAPIV2Client, uuid: string): Promise<string>;
+export declare function getAppVersionFromUuid(apiClient: MittwaldAPIV2Client, appId: string, appVersionId: string): Promise<string>;

package/dist/esm/lib/app/appHelpers.js

@@ -0,0 +1,43 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { isUuid } from "../../Helpers.js";
+// Get App UUID from App Name
+export async function getAppUuidFromAppName(apiClient, softwareName) {
+    const apps = await apiClient.app.listApps();
+    assertStatus(apps, 200);
+    const foundApp = apps.data.find((item) => {
+        return (item.name.toLowerCase().replace(/[!. ]/g, "") ===
+            softwareName.toLowerCase().replace(/[!. ]/g, ""));
+    });
+    if (foundApp) {
+        return foundApp.id;
+    }
+    throw new Error("Access Denied.");
+}
+// Get App Human readable Name from App UUID
+export async function getAppNameFromUuid(apiClient, uuid) {
+    if (!isUuid(uuid)) {
+        throw new Error("Given UUID not valid.");
+    }
+    const apps = await apiClient.app.listApps();
+    assertStatus(apps, 200);
+    const foundApp = apps.data.find((item) => {
+        return item.id === uuid;
+    });
+    if (foundApp) {
+        return foundApp.name;
+    }
+    throw new Error("App not found.");
+}
+// Get App Human Readable Version from App Version
+export async function getAppVersionFromUuid(apiClient, appId, appVersionId) {
+    if (!isUuid(appId) && !isUuid(appVersionId)) {
+        throw new Error("Given UUID not valid.");
+    }
+    const appVersion = await apiClient.app.getAppversion({
+        pathParameters: { appId: appId, appVersionId: appVersionId },
+    });
+    if (appVersion.data.externalVersion) {
+        return appVersion.data.externalVersion;
+    }
+    throw new Error("AppVersion not found.");
+}

package/dist/esm/lib/app/appVersionHelpers.d.ts

@@ -0,0 +1,5 @@
+import { MittwaldAPIV2, MittwaldAPIV2Client } from "@mittwald/api-client";
+type AppVersion = MittwaldAPIV2.Components.Schemas.AppAppVersion;
+export declare function getLatestAvailableAppVersionForApp(apiClient: MittwaldAPIV2Client, appId: string): Promise<AppVersion | undefined>;
+export declare function getAppVersionUuidFromAppVersion(apiClient: MittwaldAPIV2Client, appId: string, appVersion: string | undefined): Promise<AppVersion | undefined>;
+export {};

package/dist/esm/lib/app/appVersionHelpers.js

@@ -0,0 +1,35 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { gt } from "semver";
+// Get latest available Internal App Version for App UUID
+export async function getLatestAvailableAppVersionForApp(apiClient, appId) {
+    const versions = await apiClient.app.listAppversions({
+        pathParameters: {
+            appId,
+        },
+    });
+    assertStatus(versions, 200);
+    if (versions.data.length === 0) {
+        return undefined;
+    }
+    let latestVersion = "0.0.0";
+    for (const version of versions.data) {
+        if (gt(version.internalVersion, latestVersion)) {
+            latestVersion = version.internalVersion;
+        }
+    }
+    return versions.data.find((item) => item.internalVersion === latestVersion);
+}
+// App Version UUID from App Version irellevant if internal or external
+export async function getAppVersionUuidFromAppVersion(apiClient, appId, appVersion) {
+    const versions = await apiClient.app.listAppversions({
+        pathParameters: {
+            appId,
+        },
+    });
+    if (!appVersion) {
+        return getLatestAvailableAppVersionForApp(apiClient, appId);
+    }
+    assertStatus(versions, 200);
+    return versions.data.find((item) => item.internalVersion === appVersion ||
+        item.externalVersion === appVersion);
+}

package/dist/esm/lib/bytes.d.ts

@@ -0,0 +1 @@
+export declare function parseBytes(input: string): number;

package/dist/esm/lib/bytes.js

@@ -0,0 +1,16 @@
+export function parseBytes(input) {
+    const numeric = parseInt(input.replace(/[^0-9]/g, ""), 10);
+    if (`${numeric}` == input) {
+        return numeric;
+    }
+    if (input.toLowerCase().endsWith("gi")) {
+        return numeric * (1 << 30);
+    }
+    if (input.toLowerCase().endsWith("mi")) {
+        return numeric * (1 << 20);
+    }
+    if (input.toLowerCase().endsWith("ki")) {
+        return numeric * (1 << 10);
+    }
+    throw new Error("unsupported byte unit; supported are 'gi', 'mi', 'ki'");
+}

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

@@ -0,0 +1,16 @@
+import { Config } from "@oclif/core";
+export declare class Context {
+    private readonly config;
+    private readonly contextData;
+    constructor(config: Config);
+    private initializeContextData;
+    private persist;
+    private setContextValue;
+    getContextValue(key: string): Promise<string | undefined>;
+    setProjectId: (id: string) => Promise<void>;
+    setServerId: (id: string) => Promise<void>;
+    setOrgId: (id: string) => Promise<void>;
+    projectId: () => Promise<string | undefined>;
+    serverId: () => Promise<string | undefined>;
+    orgId: () => Promise<string | undefined>;
+}

package/dist/esm/lib/context.js

@@ -0,0 +1,42 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+export class Context {
+    config;
+    contextData;
+    constructor(config) {
+        this.config = config;
+        this.contextData = this.initializeContextData();
+    }
+    async initializeContextData() {
+        try {
+            const contents = await fs.readFile(path.join(this.config.configDir, "context.json"), "utf-8");
+            return JSON.parse(contents);
+        }
+        catch (e) {
+            if (e instanceof Error && "code" in e && e.code === "ENOENT") {
+                return {};
+            }
+            throw e;
+        }
+    }
+    async persist(data) {
+        await fs.writeFile(path.join(this.config.configDir, "context.json"), JSON.stringify(data), "utf-8");
+    }
+    async setContextValue(key, value) {
+        const data = await this.contextData;
+        return await this.persist({ ...data, [key]: value });
+    }
+    async getContextValue(key) {
+        const data = await this.contextData;
+        if (key in data) {
+            return data[key];
+        }
+        return undefined;
+    }
+    setProjectId = (id) => this.setContextValue("project-id", id);
+    setServerId = (id) => this.setContextValue("server-id", id);
+    setOrgId = (id) => this.setContextValue("org-id", id);
+    projectId = () => this.getContextValue("project-id");
+    serverId = () => this.getContextValue("server-id");
+    orgId = () => this.getContextValue("org-id");
+}

package/dist/esm/lib/context_flags.d.ts

@@ -0,0 +1,18 @@
+import { Config } from "@oclif/core";
+import { Arg, ArgOutput, FlagOutput, OptionFlag } from "@oclif/core/lib/interfaces/parser.js";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { AlphabetLowercase } from "@oclif/core/lib/interfaces/index.js";
+type ContextFlags = {
+    [k: string]: OptionFlag<unknown>;
+};
+type ContextArgs = {
+    [k: string]: Arg<unknown>;
+};
+export type FlagSet = {
+    flags: ContextFlags;
+    args: ContextArgs;
+    withId: (apiClient: MittwaldAPIV2Client, flags: FlagOutput, args: ArgOutput, cfg: Config) => Promise<string>;
+};
+export type NormalizeFn = (apiClient: MittwaldAPIV2Client, id: string) => string | Promise<string>;
+export declare function makeFlagSet(name: string, char: AlphabetLowercase, normalize?: NormalizeFn): FlagSet;
+export {};

package/dist/esm/lib/context_flags.js

@@ -0,0 +1,42 @@
+import { Args, Flags } from "@oclif/core";
+import { Context } from "./context.js";
+export function makeFlagSet(name, char, normalize = (_, id) => id) {
+    const flagName = `${name}-id`;
+    const flags = {
+        [flagName]: Flags.string({
+            char,
+            required: false,
+            description: `ID or short ID of a ${name}; this flag is optional if a default ${name} is set in the context`,
+        }),
+    };
+    const args = {
+        [flagName]: Args.string({
+            description: `ID or short ID of a ${name}; this argument is optional if a default ${name} is set in the context`,
+        }),
+    };
+    const idFromArgsOrFlag = (flags, args) => {
+        if (args[flagName]) {
+            return args[flagName];
+        }
+        if (flags[flagName]) {
+            return flags[flagName];
+        }
+        return undefined;
+    };
+    const withId = async (apiClient, flags, args, cfg) => {
+        const idInput = idFromArgsOrFlag(flags, args);
+        if (idInput) {
+            return normalize(apiClient, idInput);
+        }
+        const idFromContext = await new Context(cfg).getContextValue(flagName);
+        if (idFromContext) {
+            return idFromContext;
+        }
+        throw new Error(`No ${name} ID given. Please specify one with --${flagName} or set a default server with 'mittwald context set --${flagName} <${flagName}>'`);
+    };
+    return {
+        flags,
+        args,
+        withId,
+    };
+}

package/dist/esm/lib/conversation/message_input.d.ts

@@ -0,0 +1,10 @@
+export declare const messageFlags: {
+    message: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    "message-from": import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+    editor: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+};
+export declare function retrieveMessage(flags: {
+    message?: string;
+    "message-from"?: string;
+    editor: string;
+}): Promise<string | undefined>;

package/dist/esm/lib/conversation/message_input.js

@@ -0,0 +1,49 @@
+import { Flags } from "@oclif/core";
+import * as fs from "fs";
+import * as cp from "child_process";
+import tempfile from "tempfile";
+export const messageFlags = {
+    message: Flags.string({
+        description: "The body of the message to send; if neither this nor --message-from is given, an editor will be opened to enter the message.",
+        exclusive: ["message-from"],
+    }),
+    "message-from": Flags.string({
+        description: "A file from which to read the message to send; may be '-' to read from stdin. If neither this nor --message is given, an editor will be opened to enter the message.",
+        exclusive: ["message"],
+    }),
+    editor: Flags.string({
+        description: "The editor to use when opening the message for editing; will respect your EDITOR environment variable, and fall back on 'vim' if that is not set.",
+        default: process.env.EDITOR || "vim",
+    }),
+};
+export async function retrieveMessage(flags) {
+    if (flags.message) {
+        return flags.message;
+    }
+    if (flags["message-from"]) {
+        if (flags["message-from"] === "-") {
+            // Needs to be "readFileSync" because (according to the typings, at least)
+            // only that supports reading directly from an open file descriptor.
+            // Ding, ding.
+            return fs.readFileSync(process.stdin.fd, "utf-8");
+        }
+        return fs.readFileSync(flags["message-from"], "utf-8");
+    }
+    return retrieveMessageFromEditor(flags.editor);
+}
+async function retrieveMessageFromEditor(editor) {
+    const tmp = tempfile({ extension: ".md" });
+    try {
+        let args = [tmp];
+        if (editor === "vim") {
+            args = ["-c", "syntax on", "-c", "set filetype=markdown", ...args];
+        }
+        cp.spawnSync(editor, args, {
+            stdio: "inherit",
+        });
+        return fs.readFileSync(tmp, "utf-8");
+    }
+    finally {
+        fs.unlinkSync(tmp);
+    }
+}

package/dist/esm/lib/handleError.d.ts

@@ -0,0 +1,11 @@
+import { OclifError, PrettyPrintableError } from "@oclif/core/lib/interfaces/index.js";
+import { ApiClientError, AxiosResponse } from "@mittwald/api-client-commons";
+import { MittwaldAPIV2 } from "@mittwald/api-client";
+import CommonsValidationErrors = MittwaldAPIV2.Components.Schemas.CommonsValidationErrors;
+export declare const handleError: (error: Error & Partial<PrettyPrintableError> & Partial<OclifError> & {
+    skipOclifErrorHandling?: boolean;
+}) => void;
+export declare function isUnexpectedError(err: unknown): boolean;
+export declare function isValidationError(err: unknown): err is ApiClientError<CommonsValidationErrors> & {
+    response: AxiosResponse<CommonsValidationErrors>;
+};

package/dist/esm/lib/handleError.js

@@ -0,0 +1,28 @@
+import oclif from "@oclif/core";
+import { ApiClientError } from "@mittwald/api-client-commons";
+export const handleError = (error) => {
+    if (!isUnexpectedError(error)) {
+        process.exit(1);
+        return;
+    }
+    if (error instanceof ApiClientError) {
+        const responseJson = JSON.stringify(error.response?.data, undefined, 2);
+        const errorMessage = `\
+${error.message}
+
+Response:
+─────────
+${responseJson}`;
+        error = new Error(errorMessage, {
+            cause: error,
+        });
+    }
+    oclif.Errors.handle(error);
+};
+export function isUnexpectedError(err) {
+    return !isValidationError(err);
+}
+export function isValidationError(err) {
+    return (err instanceof ApiClientError &&
+        err.response?.data?.type === "ValidationError");
+}

package/dist/esm/lib/mergeObjects.d.ts

@@ -0,0 +1 @@
+export declare const mergeObjects: <T1, T2>(obj1: T1, obj2: T2) => T1 & T2;

package/dist/esm/lib/mergeObjects.js

@@ -0,0 +1,6 @@
+export const mergeObjects = (obj1, obj2) => {
+    return {
+        ...Object.fromEntries(Object.entries(obj1 ?? {}).filter(([, value]) => !!value)),
+        ...Object.fromEntries(Object.entries(obj2 ?? {}).filter(([, value]) => !!value)),
+    };
+};

package/dist/esm/lib/notify.d.ts

@@ -0,0 +1,2 @@
+import { Notification, NotificationCallback } from "node-notifier";
+export declare function notify(notification?: Notification, callback?: NotificationCallback): void;

package/dist/esm/lib/notify.js

@@ -0,0 +1,5 @@
+import { NotificationCenter, } from "node-notifier";
+export function notify(notification, callback) {
+    const notifier = new NotificationCenter();
+    notifier.notify(notification, callback);
+}

package/dist/esm/lib/org/flags.d.ts

@@ -0,0 +1,5 @@
+export declare const orgFlags: {
+    [k: string]: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
+}, orgArgs: {
+    [k: string]: import("@oclif/core/lib/interfaces/parser.js").Arg<unknown>;
+}, withOrgId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;

package/dist/esm/lib/org/flags.js

@@ -0,0 +1,2 @@
+import { makeFlagSet } from "../context_flags.js";
+export const { flags: orgFlags, args: orgArgs, withId: withOrgId, } = makeFlagSet("org", "o");

package/dist/esm/lib/project/flags.d.ts

@@ -0,0 +1,5 @@
+export declare const projectFlags: {
+    [k: string]: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
+}, projectArgs: {
+    [k: string]: import("@oclif/core/lib/interfaces/parser.js").Arg<unknown>;
+}, withProjectId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;

package/dist/esm/lib/project/flags.js

@@ -0,0 +1,3 @@
+import { normalizeProjectIdToUuid } from "../../Helpers.js";
+import { makeFlagSet } from "../context_flags.js";
+export const { flags: projectFlags, args: projectArgs, withId: withProjectId, } = makeFlagSet("project", "p", normalizeProjectIdToUuid);

package/dist/esm/lib/server/flags.d.ts

@@ -0,0 +1,5 @@
+export declare const serverFlags: {
+    [k: string]: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<unknown>;
+}, serverArgs: {
+    [k: string]: import("@oclif/core/lib/interfaces/parser.js").Arg<unknown>;
+}, withServerId: (apiClient: import("@mittwald/api-client").MittwaldAPIV2Client, flags: import("@oclif/core/lib/interfaces/parser.js").FlagOutput, args: import("@oclif/core/lib/interfaces/parser.js").ArgOutput, cfg: import("@oclif/core").Config) => Promise<string>;

package/dist/esm/lib/server/flags.js

@@ -0,0 +1,3 @@
+import { normalizeServerIdToUuid } from "../../Helpers.js";
+import { makeFlagSet } from "../context_flags.js";
+export const { flags: serverFlags, args: serverArgs, withId: withServerId, } = makeFlagSet("server", "s", normalizeServerIdToUuid);