@replicated/portal-components 0.0.2 → 0.0.3

package/dist/esm/install-actions.js

@@ -0,0 +1,746 @@
+import { cache } from 'react';
+
+/**
+ * Enterprise Portal Components
+ * This file is generated by tsup. Do not edit manually.
+ */
+
+// src/utils/api-client.ts
+async function authenticatedFetch(url, options = {}) {
+  const { token, ...fetchOptions } = options;
+  const headers = new Headers(fetchOptions.headers);
+  if (token) {
+    headers.set("authorization", `Bearer ${token}`);
+  }
+  const response = await fetch(url, {
+    ...fetchOptions,
+    headers
+  });
+  if (response.status === 401) {
+    await handle401();
+  }
+  if (response.status === 502 || response.status === 503 || response.status === 504) {
+    await handleServerError(response.status);
+  }
+  return response;
+}
+async function handle401() {
+  const { redirect } = await import('next/navigation');
+  return redirect("/?expired=1");
+}
+async function handleServerError(statusCode) {
+  const { redirect } = await import('next/navigation');
+  let sourceUrl;
+  try {
+    const { headers } = await import('next/headers');
+    const headersList = await headers();
+    const referer = headersList.get("referer");
+    const host = headersList.get("host");
+    const pathname = headersList.get("x-invoke-path") || headersList.get("x-forwarded-path");
+    if (referer) {
+      sourceUrl = referer;
+    } else if (host && pathname) {
+      const protocol = headersList.get("x-forwarded-proto") || "https";
+      sourceUrl = `${protocol}://${host}${pathname}`;
+    }
+  } catch (error) {
+    console.debug("[portal-components] Could not determine source URL", error);
+  }
+  const params = new URLSearchParams({ code: String(statusCode) });
+  if (sourceUrl) {
+    params.set("source", sourceUrl);
+  }
+  return redirect(`/error?${params.toString()}`);
+}
+var getApiOrigin = () => {
+  return (process.env.REPLICATED_APP_ORIGIN || "https://replicated.app").replace(/\/+$/, "");
+};
+var fetchCustomBrandingImpl = async () => {
+  const appSlug = process.env.PORTAL_APP_SLUG;
+  if (!appSlug) {
+    throw new Error("PORTAL_APP_SLUG is not configured");
+  }
+  const url = `${getApiOrigin()}/v3/custom-branding?app_slug=${encodeURIComponent(
+    appSlug
+  )}`;
+  if (process.env.NODE_ENV !== "production") {
+    console.debug(
+      "[portal-components] fetching custom branding via %s",
+      url
+    );
+  }
+  const response = await fetch(url, {
+    headers: {
+      accept: "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Custom branding request failed (${response.status} ${response.statusText})`
+    );
+  }
+  const payload = await response.json();
+  const brandingData = payload?.branding_data;
+  if (typeof brandingData !== "string") {
+    throw new Error("Custom branding response missing branding_data string");
+  }
+  return {
+    brandingData,
+    documentation: payload?.documentation ?? null
+  };
+};
+cache(fetchCustomBrandingImpl);
+var decodeJwtPayload = (token) => {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("Invalid JWT received");
+  }
+  const payloadSegment = parts[1];
+  if (!payloadSegment) {
+    throw new Error("JWT payload segment missing");
+  }
+  const padded = payloadSegment.padEnd(
+    payloadSegment.length + (4 - payloadSegment.length % 4) % 4,
+    "="
+  );
+  const decoded = Buffer.from(padded, "base64").toString("utf-8");
+  return JSON.parse(decoded);
+};
+var getCustomerIdFromToken = (token) => {
+  const payload = decodeJwtPayload(token);
+  const customerId = payload?.customer_id || payload?.customerId;
+  if (typeof customerId !== "string" || !customerId.trim()) {
+    throw new Error("Unable to determine customer_id from session token");
+  }
+  return customerId.trim();
+};
+
+// src/actions/install.ts
+async function fetchChannelReleases(input, context) {
+  const { token, channelId } = input;
+  if (!token || typeof token !== "string") {
+    throw new Error("fetchChannelReleases requires a session token");
+  }
+  const customerId = getCustomerIdFromToken(token);
+  const origin = getApiOrigin();
+  const url = new URL(`${origin}/v3/channel-releases`);
+  url.searchParams.set("customer_id", customerId);
+  if (channelId) {
+    url.searchParams.set("channel_id", channelId);
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.debug("[portal-components] fetching channel releases via %s", url.toString());
+  }
+  const response = await authenticatedFetch(url.toString(), {
+    method: "GET",
+    token,
+    headers: {
+      accept: "application/json"
+    },
+    signal: context?.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Channel releases request failed (${response.status} ${response.statusText}): ${errorText}`
+    );
+  }
+  const payload = await response.json();
+  return {
+    channelReleases: payload.channelReleases || []
+  };
+}
+async function createInstallOptions(input, context) {
+  const {
+    token,
+    installType,
+    instanceName,
+    serviceAccountId,
+    networkAvailability,
+    isMultiNode = false,
+    channelId,
+    channelReleaseSequence,
+    registryAvailability,
+    kubernetesDistribution
+  } = input;
+  if (!token || typeof token !== "string") {
+    throw new Error("createInstallOptions requires a session token");
+  }
+  if (!instanceName?.trim()) {
+    throw new Error("Instance name is required");
+  }
+  if (!serviceAccountId?.trim()) {
+    throw new Error("Service account ID is required");
+  }
+  const customerId = getCustomerIdFromToken(token);
+  const origin = getApiOrigin();
+  const endpoint = `${origin}/v3/customers/${customerId}/install-options?includeInstructions=true`;
+  const body = {
+    install_type: installType,
+    instance_name: instanceName.trim(),
+    service_account_id: serviceAccountId.trim(),
+    network_availability: networkAvailability,
+    is_multi_node: isMultiNode
+  };
+  if (channelId) {
+    body.channel_id = channelId;
+  }
+  if (channelReleaseSequence !== void 0) {
+    body.channel_release_sequence = channelReleaseSequence;
+  }
+  if (registryAvailability) {
+    body.registry_availability = registryAvailability;
+  }
+  if (kubernetesDistribution) {
+    body.kubernetes_distribution = kubernetesDistribution;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.debug("[portal-components] creating install options via %s", endpoint);
+  }
+  const response = await authenticatedFetch(endpoint, {
+    method: "POST",
+    token,
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json"
+    },
+    body: JSON.stringify(body),
+    signal: context?.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Create install options failed (${response.status} ${response.statusText}): ${errorText}`
+    );
+  }
+  return await response.json();
+}
+async function getInstallOptions(input, context) {
+  const {
+    token,
+    installOptionsId,
+    includeInstructions = true,
+    privateRegistryHostname,
+    proxyUrl
+  } = input;
+  if (!token || typeof token !== "string") {
+    throw new Error("getInstallOptions requires a session token");
+  }
+  if (!installOptionsId?.trim()) {
+    throw new Error("Install options ID is required");
+  }
+  const customerId = getCustomerIdFromToken(token);
+  const origin = getApiOrigin();
+  const url = new URL(`${origin}/v3/customers/${customerId}/install-options/${installOptionsId.trim()}`);
+  if (includeInstructions) {
+    url.searchParams.set("includeInstructions", "true");
+  }
+  if (privateRegistryHostname) {
+    url.searchParams.set("privateRegistryHostname", privateRegistryHostname);
+  }
+  if (proxyUrl) {
+    url.searchParams.set("proxyUrl", proxyUrl);
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.debug("[portal-components] fetching install options via %s", url.toString());
+  }
+  const response = await authenticatedFetch(url.toString(), {
+    method: "GET",
+    token,
+    headers: {
+      accept: "application/json"
+    },
+    signal: context?.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Get install options failed (${response.status} ${response.statusText}): ${errorText}`
+    );
+  }
+  return await response.json();
+}
+async function updateInstallOptions(input, context) {
+  const {
+    token,
+    installOptionsId,
+    installType,
+    channelId,
+    channelReleaseSequence,
+    networkAvailability,
+    registryAvailability,
+    kubernetesDistribution,
+    isMultiNode,
+    serviceAccountId,
+    adminConsoleUrl,
+    status,
+    includeInstructions = true,
+    privateRegistryHostname,
+    proxyUrl
+  } = input;
+  if (!token || typeof token !== "string") {
+    throw new Error("updateInstallOptions requires a session token");
+  }
+  if (!installOptionsId?.trim()) {
+    throw new Error("Install options ID is required");
+  }
+  const customerId = getCustomerIdFromToken(token);
+  const origin = getApiOrigin();
+  const url = new URL(`${origin}/v3/customers/${customerId}/install-options/${installOptionsId.trim()}`);
+  if (includeInstructions) {
+    url.searchParams.set("includeInstructions", "true");
+  }
+  if (privateRegistryHostname) {
+    url.searchParams.set("privateRegistryHostname", privateRegistryHostname);
+  }
+  if (proxyUrl) {
+    url.searchParams.set("proxyUrl", proxyUrl);
+  }
+  const body = {};
+  if (installType !== void 0) {
+    body.install_type = installType;
+  }
+  if (channelId !== void 0) {
+    body.channel_id = channelId;
+  }
+  if (channelReleaseSequence !== void 0) {
+    body.channel_release_sequence = channelReleaseSequence;
+  }
+  if (networkAvailability !== void 0) {
+    body.network_availability = networkAvailability;
+  }
+  if (registryAvailability !== void 0) {
+    body.registry_availability = registryAvailability;
+  }
+  if (kubernetesDistribution !== void 0) {
+    body.kubernetes_distribution = kubernetesDistribution;
+  }
+  if (isMultiNode !== void 0) {
+    body.is_multi_node = isMultiNode;
+  }
+  if (serviceAccountId !== void 0) {
+    body.service_account_id = serviceAccountId;
+  }
+  if (adminConsoleUrl !== void 0) {
+    body.admin_console_url = adminConsoleUrl;
+  }
+  if (status !== void 0) {
+    body.status = status;
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.debug("[portal-components] updating install options via %s", url.toString());
+  }
+  const response = await authenticatedFetch(url.toString(), {
+    method: "PATCH",
+    token,
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json"
+    },
+    body: JSON.stringify(body),
+    signal: context?.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Update install options failed (${response.status} ${response.statusText}): ${errorText}`
+    );
+  }
+  return await response.json();
+}
+function filterEmbeddedClusterReleases(releases) {
+  return releases.filter(
+    (release) => release.installationTypes?.embeddedCluster?.version
+  );
+}
+function filterHelmReleases(releases) {
+  return releases.filter(
+    (release) => release.installationTypes?.helm?.version
+  );
+}
+async function getUpdateInstructions(input, context) {
+  const {
+    token,
+    installOptionsId,
+    instanceId,
+    targetChannelId,
+    targetChannelSequence,
+    privateRegistryHostname
+  } = input;
+  if (!token || typeof token !== "string") {
+    throw new Error("getUpdateInstructions requires a session token");
+  }
+  if (!targetChannelId?.trim()) {
+    throw new Error("Target channel ID is required");
+  }
+  if (targetChannelSequence === void 0 || targetChannelSequence === null) {
+    throw new Error("Target channel sequence is required");
+  }
+  const identifier = installOptionsId || instanceId;
+  if (!identifier) {
+    throw new Error("Either installOptionsId or instanceId is required");
+  }
+  const customerId = getCustomerIdFromToken(token);
+  const origin = getApiOrigin();
+  const queryParams = new URLSearchParams();
+  queryParams.set("targetChannelId", targetChannelId.trim());
+  queryParams.set("targetChannelSequence", targetChannelSequence.toString());
+  if (privateRegistryHostname?.trim()) {
+    queryParams.set("privateRegistryHostname", privateRegistryHostname.trim());
+  }
+  if (!installOptionsId && instanceId) {
+    queryParams.set("instance_id", instanceId);
+  }
+  const pathId = installOptionsId || "placeholder";
+  const url = `${origin}/v3/customers/${customerId}/install-options/${pathId}/update-instructions?${queryParams.toString()}`;
+  if (process.env.NODE_ENV !== "production") {
+    console.debug("[portal-components] fetching update instructions via %s", url);
+  }
+  const response = await authenticatedFetch(url, {
+    method: "GET",
+    token,
+    headers: {
+      accept: "application/json"
+    },
+    signal: context?.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = "Failed to fetch update instructions";
+    try {
+      const errorData = JSON.parse(errorText);
+      errorMessage = errorData.error || errorData.message || errorMessage;
+    } catch {
+    }
+    throw new Error(errorMessage);
+  }
+  const data = await response.json();
+  return {
+    instructions: {
+      format: data.format || "steps",
+      install_type: data.install_type,
+      title: data.title,
+      steps: data.steps || []
+    }
+  };
+}
+async function fetchPendingInstallations(input, context) {
+  const { token } = input;
+  if (typeof token !== "string" || token.trim().length === 0) {
+    throw new Error("fetchPendingInstallations requires a non-empty token");
+  }
+  let customerId;
+  try {
+    customerId = getCustomerIdFromToken(token);
+  } catch {
+    return { installations: [] };
+  }
+  const origin = getApiOrigin();
+  const queryParams = new URLSearchParams();
+  queryParams.set("status", "in_progress");
+  queryParams.set("page_size", "5");
+  queryParams.set("order_by", "created_at");
+  queryParams.set("order_direction", "desc");
+  const endpoint = `${origin}/v3/customers/${customerId}/install-options?${queryParams.toString()}`;
+  const response = await authenticatedFetch(endpoint, {
+    method: "GET",
+    token,
+    headers: {
+      accept: "application/json"
+    },
+    signal: context?.signal
+  });
+  if (!response.ok) {
+    throw new Error(
+      `Pending installations request failed (${response.status} ${response.statusText})`
+    );
+  }
+  const payload = await response.json();
+  console.log("[portal-components] fetchPendingInstallations raw response:", JSON.stringify(payload, null, 2));
+  const installArray = payload?.install_options || [];
+  const installations = installArray.map((item) => ({
+    id: String(item.id || ""),
+    name: String(item.instance_name || "Unknown"),
+    method: item.install_type === "helm" ? "helm" : "linux",
+    startedBy: String(item.service_account_email_address || "Unknown"),
+    startedAt: String(item.started_at || (/* @__PURE__ */ new Date()).toISOString())
+  }));
+  console.log("[portal-components] fetchPendingInstallations parsed installations:", installations.length);
+  return {
+    installations
+  };
+}
+
+// src/actions/instances.ts
+var ACTIVE_INSTANCE_THRESHOLD_MS = 24 * 60 * 60 * 1e3;
+function isInstanceActive(instance) {
+  if (!instance.lastCheckin) {
+    return false;
+  }
+  const lastCheckinTime = new Date(instance.lastCheckin).getTime();
+  const threshold = Date.now() - ACTIVE_INSTANCE_THRESHOLD_MS;
+  return lastCheckinTime > threshold;
+}
+function filterActiveInactiveInstances(instances) {
+  const activeInstances = instances.filter(isInstanceActive);
+  const inactiveInstances = instances.filter((instance) => !isInstanceActive(instance));
+  return { activeInstances, inactiveInstances };
+}
+function getInstallType(instance, installOptions) {
+  const instanceHasNoInstallTypes = !instance.kotsInstallId && !instance.kurlInstallId && !instance.embeddedClusterId;
+  const isManuallyCreatedAirgapInstance = instance.isAirgap && instanceHasNoInstallTypes;
+  if (instance.embeddedClusterId) {
+    return "embedded cluster";
+  }
+  if (instanceHasNoInstallTypes && instance.k8sDistribution) {
+    return "helm";
+  }
+  if (isManuallyCreatedAirgapInstance && !instance.k8sDistribution) {
+    if (installOptions) {
+      const matchingInstallOption = installOptions.find(
+        (option) => option.instance_id === instance.id
+      );
+      if (matchingInstallOption) {
+        if (matchingInstallOption.install_type === "helm") {
+          return "helm";
+        }
+        if (matchingInstallOption.install_type === "linux") {
+          return "embedded cluster";
+        }
+      }
+    }
+    return "embedded cluster";
+  }
+  return null;
+}
+function calculateUpdatesForInstance(instance, channelReleases) {
+  if (!channelReleases || !Array.isArray(channelReleases)) {
+    return 0;
+  }
+  const instanceChannelSequence = instance.channelSequence ?? 0;
+  const matchingReleases = channelReleases.filter(
+    (release) => release.channelId === instance.channelId
+  );
+  return matchingReleases.filter(
+    (release) => release.channelSequence > instanceChannelSequence
+  ).length;
+}
+function getInstanceName(instance) {
+  const nameTag = instance.tags?.find((tag) => tag.key === "name");
+  return nameTag?.value || instance.id.slice(0, 7);
+}
+async function fetchInstances2(input, context) {
+  const { token } = input;
+  if (!token || typeof token !== "string") {
+    throw new Error("fetchInstances requires a session token");
+  }
+  const customerId = getCustomerIdFromToken(token);
+  const origin = getApiOrigin();
+  const url = new URL(`${origin}/v3/instances`);
+  url.searchParams.set("customer_id", customerId);
+  if (process.env.NODE_ENV !== "production") {
+    console.debug("[portal-components] fetching instances via %s", url.toString());
+  }
+  const response = await authenticatedFetch(url.toString(), {
+    method: "GET",
+    token,
+    headers: {
+      accept: "application/json"
+    },
+    signal: context?.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Instances request failed (${response.status} ${response.statusText}): ${errorText}`
+    );
+  }
+  const payload = await response.json();
+  const allInstances = payload.instances || [];
+  const online = allInstances.filter((instance) => !instance.isAirgap);
+  const airgap = allInstances.filter((instance) => instance.isAirgap);
+  return {
+    instances: allInstances,
+    online,
+    airgap
+  };
+}
+async function createAirgapInstance(input, context) {
+  const {
+    token,
+    serviceAccountId,
+    instanceName,
+    channelId,
+    channelSequence,
+    k8sVersion,
+    k8sDistribution,
+    appStatus = "missing"
+  } = input;
+  if (!token || typeof token !== "string") {
+    throw new Error("createAirgapInstance requires a session token");
+  }
+  if (!serviceAccountId?.trim()) {
+    throw new Error("Service account ID is required");
+  }
+  if (!channelId?.trim()) {
+    throw new Error("Channel ID is required");
+  }
+  const customerId = getCustomerIdFromToken(token);
+  const origin = getApiOrigin();
+  const url = new URL(`${origin}/v3/instance/airgap`);
+  url.searchParams.set("customer_id", customerId);
+  const body = {
+    service_account_id: serviceAccountId.trim(),
+    channel_id: channelId.trim(),
+    channel_sequence: channelSequence,
+    app_status: appStatus
+  };
+  if (instanceName?.trim()) {
+    body.instance_name = instanceName.trim();
+  }
+  if (k8sVersion?.trim()) {
+    body.k8s_version = k8sVersion.trim();
+  }
+  if (k8sDistribution?.trim()) {
+    body.k8s_distribution = k8sDistribution.trim();
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.debug("[portal-components] creating airgap instance via %s", url.toString());
+  }
+  const response = await authenticatedFetch(url.toString(), {
+    method: "POST",
+    token,
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json"
+    },
+    body: JSON.stringify(body),
+    signal: context?.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = "Failed to create airgap instance";
+    try {
+      const errorData = JSON.parse(errorText);
+      errorMessage = errorData.error || errorData.message || errorMessage;
+    } catch {
+    }
+    throw new Error(errorMessage);
+  }
+  const data = await response.json();
+  return {
+    instanceId: data.instance_id,
+    licenseId: data.license_id,
+    createdAt: data.created_at,
+    lastActive: data.last_active,
+    appFirstReadyAt: data.app_first_ready_at,
+    appStatus: data.app_status,
+    isAirgap: data.is_airgap,
+    channelId: data.channel_id,
+    channelSequence: data.channel_sequence,
+    k8sVersion: data.k8s_version,
+    k8sDistribution: data.k8s_distribution
+  };
+}
+async function updateAirgapInstance(input, context) {
+  const {
+    token,
+    instanceId,
+    serviceAccountId,
+    channelId,
+    channelSequence
+  } = input;
+  if (!token || typeof token !== "string") {
+    throw new Error("updateAirgapInstance requires a session token");
+  }
+  if (!instanceId?.trim()) {
+    throw new Error("Instance ID is required");
+  }
+  if (!channelId?.trim()) {
+    throw new Error("Channel ID is required");
+  }
+  const customerId = getCustomerIdFromToken(token);
+  const origin = getApiOrigin();
+  const url = new URL(`${origin}/v3/instance/airgap/${instanceId.trim()}`);
+  url.searchParams.set("customer_id", customerId);
+  const body = {
+    channel_id: channelId.trim(),
+    channel_sequence: channelSequence
+  };
+  if (serviceAccountId?.trim()) {
+    body.service_account_id = serviceAccountId.trim();
+  }
+  if (process.env.NODE_ENV !== "production") {
+    console.debug("[portal-components] updating airgap instance via %s", url.toString());
+  }
+  const response = await authenticatedFetch(url.toString(), {
+    method: "PATCH",
+    token,
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json"
+    },
+    body: JSON.stringify(body),
+    signal: context?.signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    let errorMessage = "Failed to update airgap instance";
+    try {
+      const errorData = JSON.parse(errorText);
+      errorMessage = errorData.error || errorData.message || errorMessage;
+    } catch {
+    }
+    throw new Error(errorMessage);
+  }
+  return { success: true };
+}
+async function fetchInstallOptionsByInstanceIds(input, context) {
+  const { token, instanceIds } = input;
+  if (!token || typeof token !== "string") {
+    throw new Error("fetchInstallOptionsByInstanceIds requires a session token");
+  }
+  if (!instanceIds || instanceIds.length === 0) {
+    return { installOptions: [] };
+  }
+  const customerId = getCustomerIdFromToken(token);
+  const origin = getApiOrigin();
+  const chunks = [];
+  for (let i = 0; i < instanceIds.length; i += 50) {
+    chunks.push(instanceIds.slice(i, i + 50));
+  }
+  const allInstallOptions = [];
+  for (const chunk of chunks) {
+    if (chunk.length === 0) continue;
+    const queryParams = chunk.map((id) => `instance_id=${encodeURIComponent(id)}`).join("&");
+    const url = `${origin}/v3/customers/${customerId}/install-options?${queryParams}`;
+    if (process.env.NODE_ENV !== "production") {
+      console.debug("[portal-components] fetching install options via %s", url);
+    }
+    const response = await authenticatedFetch(url, {
+      method: "GET",
+      token,
+      headers: {
+        accept: "application/json"
+      },
+      signal: context?.signal
+    });
+    if (response.status === 404) {
+      continue;
+    }
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `Install options request failed (${response.status} ${response.statusText}): ${errorText}`
+      );
+    }
+    const payload = await response.json();
+    const options = payload?.install_options || [];
+    allInstallOptions.push(...options);
+  }
+  return { installOptions: allInstallOptions };
+}
+
+export { ACTIVE_INSTANCE_THRESHOLD_MS, calculateUpdatesForInstance, createAirgapInstance, createInstallOptions, fetchChannelReleases, fetchInstallOptionsByInstanceIds, fetchInstances2 as fetchInstances, fetchPendingInstallations, filterActiveInactiveInstances, filterEmbeddedClusterReleases, filterHelmReleases, getInstallOptions, getInstallType, getInstanceName, getUpdateInstructions, isInstanceActive, updateAirgapInstance, updateInstallOptions };
+//# sourceMappingURL=install-actions.js.map
+//# sourceMappingURL=install-actions.js.map