@mittwald/cli 1.0.0-alpha.9 → 1.0.0-beta.2

package/dist/lib/apiutil/api_retry.js

@@ -0,0 +1,43 @@
+import debug from "debug";
+import axiosRetry from "axios-retry";
+const d = debug("mw:api-retry");
+export function configureAxiosRetry(axios) {
+    let shouldRetryAccessDenied = false;
+    axios.interceptors.request.use((config) => {
+        return {
+            ...config,
+            validateStatus: (status) => status < 300,
+        };
+    });
+    axios.interceptors.request.use((config) => {
+        if (config.method?.toLowerCase() === "post") {
+            shouldRetryAccessDenied = true;
+        }
+        return config;
+    });
+    axiosRetry(axios, {
+        retries: 10,
+        retryDelay: axiosRetry.exponentialDelay,
+        onRetry(count, error, config) {
+            if (error.response?.status === 412 && config.headers !== undefined) {
+                delete config.headers["if-event-reached"];
+            }
+            d("retrying request after %d attempts; error: %o", count, error.message);
+        },
+        retryCondition(error) {
+            if (error.code === "ERR_FR_TOO_MANY_REDIRECTS") {
+                return false;
+            }
+            if (axiosRetry.isNetworkOrIdempotentRequestError(error)) {
+                return true;
+            }
+            const isSafeRequest = error.config?.method?.toLowerCase() === "get";
+            const isPreconditionFailed = error.response?.status === 412;
+            const isAccessDenied = error.response?.status === 403;
+            if (isPreconditionFailed) {
+                return true;
+            }
+            return isSafeRequest && isAccessDenied && shouldRetryAccessDenied;
+        },
+    });
+}

package/dist/lib/apiutil/assert_success.d.ts

@@ -0,0 +1,3 @@
+import { Response } from "@mittwald/api-client-commons";
+export declare function assertSuccess<T extends Response>(response: T): void;
+export default assertSuccess;

package/dist/lib/apiutil/assert_success.js

@@ -0,0 +1,7 @@
+import { ApiClientError } from "@mittwald/api-client-commons";
+export function assertSuccess(response) {
+    if (response.status >= 300) {
+        throw ApiClientError.fromResponse(`Unexpected response status (expected <300, got: ${response.status})`, response);
+    }
+}
+export default assertSuccess;

package/dist/lib/auth/token.d.ts

@@ -0,0 +1,13 @@
+import { Config } from "@oclif/core";
+/**
+ * Gets the filename in which the CLI should store the API token.
+ *
+ * @param config The CLI configuration object.
+ */
+export declare function getTokenFilename(config: Config): string;
+/**
+ * Reads the API token from the environment or the configuration file.
+ *
+ * @param config The CLI configuration object.
+ */
+export declare function readApiToken(config: Config): Promise<string | undefined>;

package/dist/lib/auth/token.js

@@ -0,0 +1,44 @@
+import path from "path";
+import fs from "fs/promises";
+import { isNotFound } from "../util/fs/isNotFound.js";
+/**
+ * Gets the filename in which the CLI should store the API token.
+ *
+ * @param config The CLI configuration object.
+ */
+export function getTokenFilename(config) {
+    return path.join(config.configDir, "token");
+}
+/**
+ * Reads the API token from the environment or the configuration file.
+ *
+ * @param config The CLI configuration object.
+ */
+export async function readApiToken(config) {
+    return (readApiTokenFromEnvironment() ?? (await readApiTokenFromConfig(config)));
+}
+/** Reads the API token from the MITTWALD_API_TOKEN environment variable. */
+function readApiTokenFromEnvironment() {
+    const token = process.env.MITTWALD_API_TOKEN;
+    if (token === undefined) {
+        return undefined;
+    }
+    return token.trim();
+}
+/**
+ * Reads the API token from the configuration file.
+ *
+ * @param config The CLI configuration object.
+ */
+async function readApiTokenFromConfig(config) {
+    try {
+        const tokenFileContents = await fs.readFile(getTokenFilename(config), "utf-8");
+        return tokenFileContents.trim();
+    }
+    catch (err) {
+        if (isNotFound(err)) {
+            return undefined;
+        }
+        throw err;
+    }
+}

package/dist/lib/basecommands/BaseCommand.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "@oclif/core";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+export declare abstract class BaseCommand extends Command {
+    protected authenticationRequired: boolean;
+    protected apiClient: MittwaldAPIV2Client;
+    init(): Promise<void>;
+}

package/dist/lib/basecommands/BaseCommand.js

@@ -0,0 +1,25 @@
+import { Command } from "@oclif/core";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import { configureAxiosRetry } from "../apiutil/api_retry.js";
+import { configureConsistencyHandling } from "../apiutil/api_consistency.js";
+import { getTokenFilename, readApiToken } from "../auth/token.js";
+import { configureAxiosLogging } from "../apiutil/api_logging.js";
+export class BaseCommand extends Command {
+    authenticationRequired = true;
+    apiClient = MittwaldAPIV2Client.newUnauthenticated();
+    async init() {
+        await super.init();
+        if (this.authenticationRequired) {
+            const token = await readApiToken(this.config);
+            if (token === undefined) {
+                throw new Error(`Could not get token from either config file (${getTokenFilename(this.config)}) or environment`);
+            }
+            this.apiClient = MittwaldAPIV2Client.newWithToken(token);
+            this.apiClient.axios.defaults.headers["User-Agent"] =
+                `mittwald-cli/${this.config.version}`;
+            configureAxiosLogging(this.apiClient.axios);
+            configureAxiosRetry(this.apiClient.axios);
+            configureConsistencyHandling(this.apiClient.axios);
+        }
+    }
+}

package/dist/lib/basecommands/CommandFlags.d.ts

@@ -0,0 +1,6 @@
+import { BaseCommand } from "./BaseCommand.js";
+import { Interfaces } from "@oclif/core";
+/** CommandFlags is a helper type that extracts the flags from a command class. */
+export type CommandFlags<T extends typeof BaseCommand> = Interfaces.InferredFlags<T["flags"]>;
+/** CommandArgs is a helper type that extracts the args from a command class. */
+export type CommandArgs<T extends typeof BaseCommand> = Interfaces.InferredArgs<T["args"]>;

package/dist/lib/basecommands/CommandFlags.js

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

package/dist/lib/basecommands/DeleteBaseCommand.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from "./BaseCommand.js";
+import { ExecRenderBaseCommand } from "./ExecRenderBaseCommand.js";
+export declare abstract class DeleteBaseCommand<T extends typeof BaseCommand> extends ExecRenderBaseCommand<T, void> {
+    static resourceName: string;
+    static baseFlags: {
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        quiet: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    protected exec(): Promise<void>;
+    protected render(): null;
+    protected abstract deleteResource(): Promise<void>;
+}

package/dist/lib/basecommands/DeleteBaseCommand.js

@@ -0,0 +1,43 @@
+import { jsxs as _jsxs, Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Flags, ux } from "@oclif/core";
+import { ExecRenderBaseCommand } from "./ExecRenderBaseCommand.js";
+import { makeProcessRenderer, processFlags, } from "../../rendering/process/process_flags.js";
+import { Success } from "../../rendering/react/components/Success.js";
+import { Text } from "ink";
+export class DeleteBaseCommand extends ExecRenderBaseCommand {
+    static resourceName = "object";
+    static baseFlags = {
+        ...processFlags,
+        force: Flags.boolean({
+            char: "f",
+            description: "Do not ask for confirmation",
+        }),
+    };
+    async exec() {
+        const resourceName = this.ctor.resourceName;
+        const process = makeProcessRenderer(this.flags, `Deleting ${resourceName}`);
+        if (!this.flags.force) {
+            const confirmed = await process.addConfirmation(_jsxs(Text, { children: ["confirm deletion of ", resourceName] }));
+            if (!confirmed) {
+                process.addInfo(_jsxs(Text, { children: ["deletion of ", resourceName, " was cancelled"] }));
+                process.complete(_jsx(_Fragment, {}));
+                ux.exit(1);
+                return;
+            }
+        }
+        const deletingStep = process.addStep(_jsxs(Text, { children: ["deleting ", resourceName] }));
+        try {
+            await this.deleteResource();
+            deletingStep.complete();
+            process.complete(_jsxs(Success, { children: ["The ", resourceName, " was successfully deleted. How sad. \uD83E\uDD7A"] }));
+        }
+        catch (err) {
+            deletingStep.error(err);
+            process.complete(_jsxs(Text, { children: ["Failed to delete ", resourceName] }));
+            ux.exit(1);
+        }
+    }
+    render() {
+        return null;
+    }
+}

package/dist/lib/basecommands/ExecRenderBaseCommand.d.ts

@@ -0,0 +1,8 @@
+import { BaseCommand } from "./BaseCommand.js";
+import { ReactNode } from "react";
+import { ExtendedBaseCommand } from "./ExtendedBaseCommand.js";
+export declare abstract class ExecRenderBaseCommand<T extends typeof BaseCommand, TRes> extends ExtendedBaseCommand<T> {
+    protected abstract exec(): Promise<TRes>;
+    run(): Promise<void>;
+    protected abstract render(executionResult: TRes): ReactNode;
+}

package/dist/lib/basecommands/ExecRenderBaseCommand.js

@@ -0,0 +1,25 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { render, Text } from "ink";
+import { RenderContextProvider } from "../../rendering/react/context.js";
+import { ExtendedBaseCommand } from "./ExtendedBaseCommand.js";
+const RenderComponent = (p) => (_jsx(_Fragment, { children: p.render() }));
+function wrapRender(fn) {
+    return (result) => {
+        const innerResult = fn(result);
+        if (typeof innerResult === "string") {
+            return _jsx(Text, { children: innerResult });
+        }
+        return innerResult;
+    };
+}
+export class ExecRenderBaseCommand extends ExtendedBaseCommand {
+    async run() {
+        const result = await this.exec();
+        const wrappedRender = wrapRender(this.render.bind(this));
+        render(_jsx(RenderContextProvider, { value: {
+                apiClient: this.apiClient,
+                renderAsJson: false,
+            }, children: _jsx(Suspense, { fallback: _jsx(Text, { children: "Loading..." }), children: _jsx(RenderComponent, { render: () => wrappedRender(result) }) }) }));
+    }
+}

package/dist/lib/basecommands/ExtendedBaseCommand.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from "./BaseCommand.js";
+import { CommandArgs, CommandFlags } from "./CommandFlags.js";
+import { CommandType } from "../context/FlagSetBuilder.js";
+export declare abstract class ExtendedBaseCommand<T extends typeof BaseCommand> extends BaseCommand {
+    protected flags: CommandFlags<T>;
+    protected args: CommandArgs<T>;
+    init(): Promise<void>;
+    withAppInstallationId(command: CommandType<"installation"> | "flag" | "arg"): Promise<string>;
+    withProjectId(command: CommandType<"project"> | "flag" | "arg"): Promise<string>;
+    withServerId(command: CommandType<"server"> | "flag" | "arg"): Promise<string>;
+}

package/dist/lib/basecommands/ExtendedBaseCommand.js

@@ -0,0 +1,28 @@
+import { BaseCommand } from "./BaseCommand.js";
+import { withAppInstallationId } from "../resources/app/flags.js";
+import { withProjectId } from "../resources/project/flags.js";
+import { withServerId } from "../resources/server/flags.js";
+export class ExtendedBaseCommand extends BaseCommand {
+    flags;
+    args;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.args = args;
+        this.flags = flags;
+    }
+    async withAppInstallationId(command) {
+        return withAppInstallationId(this.apiClient, command, this.flags, this.args, this.config);
+    }
+    async withProjectId(command) {
+        return withProjectId(this.apiClient, command, this.flags, this.args, this.config);
+    }
+    async withServerId(command) {
+        return withServerId(this.apiClient, command, this.flags, this.args, this.config);
+    }
+}

package/dist/lib/basecommands/GetBaseCommand.d.ts

@@ -0,0 +1,16 @@
+import { Command, Interfaces } from "@oclif/core";
+import { BaseCommand } from "./BaseCommand.js";
+import { Response } from "@mittwald/api-client-commons";
+import { ExtendedBaseCommand } from "./ExtendedBaseCommand.js";
+import { GetFormatter } from "../../rendering/formatter/GetFormatter.js";
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof GetBaseCommand)["baseFlags"] & T["flags"]>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T["args"]>;
+export declare abstract class GetBaseCommand<T extends typeof BaseCommand, TAPIResponse extends Response> extends ExtendedBaseCommand<T> {
+    static baseFlags: {
+        [x: string]: Interfaces.Flag<any>;
+    };
+    protected formatter: GetFormatter;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    protected abstract getData(): Promise<TAPIResponse>;
+}

package/dist/lib/basecommands/GetBaseCommand.js

@@ -0,0 +1,25 @@
+import { assertStatus } from "@mittwald/api-client-commons";
+import { ExtendedBaseCommand } from "./ExtendedBaseCommand.js";
+import { GetFormatter } from "../../rendering/formatter/GetFormatter.js";
+export class GetBaseCommand extends ExtendedBaseCommand {
+    static baseFlags = {
+        ...GetFormatter.flags,
+    };
+    formatter = new GetFormatter();
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.args = args;
+        this.flags = flags;
+    }
+    async run() {
+        const response = await this.getData();
+        assertStatus(response, 200);
+        this.formatter.log(response.data, { outputFormat: this.flags.output });
+    }
+}

package/dist/lib/basecommands/ListBaseCommand.d.ts

@@ -0,0 +1,30 @@
+import { Command, Interfaces } from "@oclif/core";
+import { BaseCommand } from "./BaseCommand.js";
+import { ListColumns, ListFormatter } from "../../rendering/formatter/ListFormatter.js";
+import { Response } from "@mittwald/api-client-commons";
+import { ExtendedBaseCommand } from "./ExtendedBaseCommand.js";
+import { SuccessfulResponse } from "../apiutil/SuccessfulResponse.js";
+export type Flags<T extends typeof Command> = Interfaces.InferredFlags<(typeof ListBaseCommand)["baseFlags"] & T["flags"]>;
+export type Args<T extends typeof Command> = Interfaces.InferredArgs<T["args"]>;
+export type ColumnOpts<TItem> = {
+    shortIdKey?: keyof TItem;
+    outputFormat?: string;
+};
+export type SorterFunction<TItem> = (a: TItem, b: TItem) => number;
+export declare abstract class ListBaseCommand<T extends typeof BaseCommand, TItem extends Record<string, unknown>, TAPIResponse extends Response> extends ExtendedBaseCommand<T> {
+    static baseFlags: {
+        output: Interfaces.OptionFlag<"json" | "txt" | "yaml" | "csv" | "tsv">;
+        extended: Interfaces.BooleanFlag<boolean>;
+        "no-header": Interfaces.BooleanFlag<boolean>;
+        "no-truncate": Interfaces.BooleanFlag<boolean>;
+        "no-relative-dates": Interfaces.BooleanFlag<boolean>;
+        "csv-separator": Interfaces.OptionFlag<"," | ";">;
+    };
+    protected formatter: ListFormatter;
+    protected sorter?: SorterFunction<TItem>;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    protected abstract getData(): Promise<TAPIResponse>;
+    protected mapData(data: SuccessfulResponse<TAPIResponse, 200>["data"]): TItem[] | Promise<TItem[]>;
+    protected getColumns(data: TItem[], opts?: ColumnOpts<TItem>): ListColumns<TItem>;
+}

package/dist/lib/basecommands/ListBaseCommand.js

@@ -0,0 +1,73 @@
+import { ListFormatter, } from "../../rendering/formatter/ListFormatter.js";
+import { assertStatus } from "@mittwald/api-client-commons";
+import { ExtendedBaseCommand } from "./ExtendedBaseCommand.js";
+import ListDateColumnFormatter, { isResourceWithCreatedAt, } from "../../rendering/formatter/ListDateColumnFormatter.js";
+export class ListBaseCommand extends ExtendedBaseCommand {
+    static baseFlags = {
+        ...ListFormatter.flags,
+    };
+    formatter = new ListFormatter();
+    sorter;
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: this.ctor.flags,
+            baseFlags: super.ctor.baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.args = args;
+        this.flags = flags;
+    }
+    async run() {
+        const response = await this.getData();
+        assertStatus(response, 200);
+        const data = await this.mapData(response.data);
+        this.formatter.log(data, this.getColumns(data), this.flags);
+    }
+    mapData(data) {
+        if (this.sorter !== undefined) {
+            data.sort(this.sorter);
+        }
+        return data;
+    }
+    getColumns(data, opts = {}) {
+        const { shortIdKey = "shortId" } = opts;
+        if (data.length === 0) {
+            return {
+                id: {
+                    header: "ID",
+                    exactWidth: 36,
+                },
+            };
+        }
+        // define some default columns, can be overwritten by child class
+        let columns = {
+            id: {
+                header: "ID",
+                exactWidth: 36,
+            },
+        };
+        if (shortIdKey in data[0]) {
+            // If there's a short ID in the data, the actual UUID becomes less useful,
+            // so we hide it by default.
+            columns.id.header = "UUID";
+            columns.id.extended = true;
+            columns = {
+                ...columns,
+                [shortIdKey]: {
+                    header: "ID",
+                    exactWidth: 8,
+                },
+            };
+        }
+        if (isResourceWithCreatedAt(data[0])) {
+            const createdAt = new ListDateColumnFormatter(this.flags).buildColumn();
+            columns = {
+                ...columns,
+                createdAt,
+            };
+        }
+        return columns;
+    }
+}

package/dist/lib/basecommands/RenderBaseCommand.d.ts

@@ -0,0 +1,22 @@
+import { BaseCommand } from "./BaseCommand.js";
+import { ReactNode } from "react";
+import { ExtendedBaseCommand } from "./ExtendedBaseCommand.js";
+import { Interfaces } from "@oclif/core";
+import { FlagInput } from "@oclif/core/interfaces";
+import { CommandType } from "../context/FlagSetBuilder.js";
+declare const renderFlags: {
+    output: Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+};
+export declare abstract class RenderBaseCommand<T extends typeof BaseCommand> extends ExtendedBaseCommand<T> {
+    protected static renderFlags: {
+        output: Interfaces.OptionFlag<string, Interfaces.CustomOptions>;
+    };
+    protected renderFlags: Interfaces.InferredFlags<typeof renderFlags>;
+    static buildFlags(): FlagInput;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    protected abstract render(): ReactNode;
+    protected useAppInstallationId(command: CommandType<"installation"> | "flag" | "arg"): string;
+    protected useProjectId(command: CommandType<"project"> | "flag" | "arg"): string;
+}
+export {};

package/dist/lib/basecommands/RenderBaseCommand.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+import { render } from "ink";
+import { RenderContextProvider } from "../../rendering/react/context.js";
+import { ExtendedBaseCommand } from "./ExtendedBaseCommand.js";
+import { JsonCollectionProvider } from "../../rendering/react/json/JsonCollectionProvider.js";
+import { Flags } from "@oclif/core";
+import { Render } from "../../rendering/react/components/Render.js";
+import { useIncreaseInkStdoutColumns } from "../../rendering/react/hooks/useIncreaseInkStdoutColumns.js";
+import { usePromise } from "@mittwald/react-use-promise";
+import ErrorBoundary from "../../rendering/react/components/ErrorBoundary.js";
+const renderFlags = {
+    output: Flags.string({
+        description: "The output format to use; use 'txt' for a human readable text representation, and 'json' for a machine-readable JSON representation.",
+        char: "o",
+        default: "txt",
+        options: ["txt", "json"],
+    }),
+};
+export class RenderBaseCommand extends ExtendedBaseCommand {
+    static renderFlags = renderFlags;
+    renderFlags;
+    static buildFlags() {
+        return RenderBaseCommand.renderFlags;
+    }
+    async init() {
+        await super.init();
+        const { args, flags } = await this.parse({
+            flags: {
+                ...renderFlags,
+                ...this.ctor.flags,
+            },
+            baseFlags: super.ctor.baseFlags,
+            args: this.ctor.args,
+            strict: this.ctor.strict,
+        });
+        this.flags = flags;
+        this.renderFlags = flags;
+        this.args = args;
+    }
+    async run() {
+        const onError = () => {
+            setImmediate(() => {
+                handle.unmount();
+                process.exit(1);
+            });
+        };
+        const handle = render(_jsx(RenderContextProvider, { value: {
+                apiClient: this.apiClient,
+                renderAsJson: this.renderFlags.output === "json",
+            }, children: _jsx(JsonCollectionProvider, { children: _jsx(Suspense, { children: _jsx(ErrorBoundary, { onError: onError, children: _jsx(Render, { render: () => {
+                                useIncreaseInkStdoutColumns();
+                                return this.render();
+                            } }) }) }) }) }));
+    }
+    useAppInstallationId(command) {
+        return usePromise(() => this.withAppInstallationId(command), []);
+    }
+    useProjectId(command) {
+        return usePromise(() => this.withProjectId(command), []);
+    }
+}

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

@@ -0,0 +1,37 @@
+import { Config } from "@oclif/core";
+import { MittwaldAPIV2Client } from "@mittwald/api-client";
+import ContextProvider from "./ContextProvider.js";
+export type ContextNames = "project" | "server" | "org" | "installation" | "domain" | "dnszone" | "mailaddress" | "maildeliverybox" | "conversation" | "backup";
+export type ContextKey<N extends ContextNames = ContextNames> = `${N}-id`;
+export type ContextMap = Partial<Record<ContextKey, ContextValue>>;
+export type ContextMapUpdate = Partial<Record<ContextKey, string>>;
+export type ContextValueSource = {
+    type: string;
+    identifier: string;
+};
+export type ContextValue = {
+    value: string;
+    source: ContextValueSource;
+};
+export declare const contextIDNormalizers: {
+    [k in ContextKey]?: (apiClient: MittwaldAPIV2Client, id: string) => Promise<string>;
+};
+export default class Context {
+    private readonly contextData;
+    private readonly apiClient;
+    readonly providers: ContextProvider[];
+    constructor(apiClient: MittwaldAPIV2Client, config: Config);
+    private initializeContextData;
+    reset(): Promise<void>;
+    private persist;
+    private setContextValue;
+    getContextValue(key: ContextKey): Promise<ContextValue | undefined>;
+    setProjectId: (id: string) => Promise<string>;
+    setServerId: (id: string) => Promise<string>;
+    setOrgId: (id: string) => Promise<string>;
+    setAppInstallationId: (id: string) => Promise<string>;
+    projectId: () => Promise<ContextValue | undefined>;
+    serverId: () => Promise<ContextValue | undefined>;
+    orgId: () => Promise<ContextValue | undefined>;
+    appInstallationId: () => Promise<ContextValue | undefined>;
+}

package/dist/lib/context/Context.js

@@ -0,0 +1,65 @@
+import UserContextProvider from "./UserContextProvider.js";
+import TerraformContextProvider from "./TerraformContextProvider.js";
+import DDEVContextProvider from "./DDEVContextProvider.js";
+function isWritable(p) {
+    return "update" in p;
+}
+export const contextIDNormalizers = {};
+export default class Context {
+    contextData;
+    apiClient;
+    providers;
+    constructor(apiClient, config) {
+        this.apiClient = apiClient;
+        this.providers = [
+            new UserContextProvider(config),
+            new TerraformContextProvider(),
+            new DDEVContextProvider(apiClient),
+        ];
+        this.contextData = this.initializeContextData();
+    }
+    async initializeContextData() {
+        const contextData = {};
+        for (const provider of this.providers) {
+            const overrides = await provider.getOverrides();
+            Object.assign(contextData, overrides);
+        }
+        return contextData;
+    }
+    async reset() {
+        for (const provider of this.providers) {
+            if (isWritable(provider)) {
+                await provider.reset();
+            }
+        }
+    }
+    async persist(data) {
+        for (const provider of this.providers) {
+            if (isWritable(provider)) {
+                await provider.update(data);
+            }
+        }
+    }
+    async setContextValue(key, value) {
+        if (key in contextIDNormalizers) {
+            value = await contextIDNormalizers[key](this.apiClient, value);
+        }
+        await this.persist({ [key]: value });
+        return 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);
+    setAppInstallationId = (id) => this.setContextValue("installation-id", id);
+    projectId = () => this.getContextValue("project-id");
+    serverId = () => this.getContextValue("server-id");
+    orgId = () => this.getContextValue("org-id");
+    appInstallationId = () => this.getContextValue("installation-id");
+}

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

@@ -0,0 +1,6 @@
+import { ContextMap } from "./Context.js";
+interface ContextProvider {
+    name: string;
+    getOverrides(): Promise<ContextMap>;
+}
+export default ContextProvider;

package/dist/lib/context/ContextProvider.js

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