@wix/cli/build/DevCommand-G54O4VW4.js

CLI tool for building Wix sites and applications

import { createRequire as _createRequire } from 'node:module';
const require = _createRequire(import.meta.url);
import {
  useTunnel
} from "./chunk-MG5MUFY3.js";
import {
  useWixCliAppBi
} from "./chunk-CKNVM7JY.js";
import {
  LifecycleState,
  LinkClickTip,
  OverrideType,
  RedirectLink,
  looseComponentSchema,
  parseLooseAppManifest,
  useDevCenterOverridesClient,
  useUpdateDeploymentTopologyForApp,
  useUpdateDeploymentTopologyForSite
} from "./chunk-EA4ZV7ZO.js";
import {
  PlatformLink
} from "./chunk-BUPV3T3K.js";
import {
  OnboardingState,
  useVeloClient
} from "./chunk-ZJ4HTMFG.js";
import "./chunk-DGC6KEUB.js";
import "./chunk-QRGKMYDD.js";
import "./chunk-CKNI3TGO.js";
import "./chunk-YLCFL3QA.js";
import {
  ComponentType,
  useDevCenterClient
} from "./chunk-BHWSM372.js";
import {
  createPackageManager,
  getRepoType
} from "./chunk-7QJUAJW3.js";
import {
  execa
} from "./chunk-NMCF7XG5.js";
import "./chunk-MHV22UIU.js";
import {
  createAstroLogger
} from "./chunk-7BABMGCW.js";
import {
  useProjectModel,
  useSiteConfig
} from "./chunk-OQJA5FSX.js";
import {
  ASTRO_APP_CONFIG_PATH,
  astroAppConfigSchema,
  devMetadataSchema,
  getAstroAppConfigPath,
  getDebugLogPath
} from "./chunk-KCDAY54L.js";
import {
  useHttpClient
} from "./chunk-FYLO6WOU.js";
import {
  usePanoramaMethodLogger
} from "./chunk-3B6VL2WO.js";
import "./chunk-7QTVQZAE.js";
import {
  BiProvider,
  ErrorViewer,
  TimeoutError,
  getHttpErrorInfo,
  isHttpValidationError,
  openBrowser,
  pRetry,
  pWaitFor,
  resolveUrl,
  serializer,
  toURLSearchParams,
  useBiLogger,
  useDebugLog,
  useErrorReporter
} from "./chunk-CCWE4DS6.js";
import {
  createEnv,
  extractHttpError,
  wixCliAction,
  wixCliAppFlowStepsAnswers
} from "./chunk-U5H3SP3I.js";
import {
  I18nProvider,
  Trans,
  useTranslation
} from "./chunk-TIVTYCB2.js";
import "./chunk-RPTAJN5Y.js";
import {
  Alert,
  Badge,
  Box_default,
  ConfirmInput,
  Key,
  PointerIcon,
  SelectInput,
  SelectOptionAvailability,
  Spinner,
  Text,
  useAsync,
  useAsyncCallback,
  useExit,
  use_input_default
} from "./chunk-UC5LTXTA.js";
import "./chunk-5VIJC5EU.js";
import "./chunk-MZDJNQLB.js";
import {
  require_react
} from "./chunk-QNHANFRW.js";
import {
  stripAnsi
} from "./chunk-AFPDHQYI.js";
import "./chunk-HYKBBZLS.js";
import "./chunk-C5RTKQVL.js";
import {
  readUserConfig,
  updateUserConfig
} from "./chunk-4EJ5VQTT.js";
import "./chunk-4UTFAKA5.js";
import "./chunk-LU3R3EBR.js";
import {
  getTestOverrides
} from "./chunk-XZUGLEBK.js";
import {
  outputDir,
  pathExists,
  readJson,
  writeJson
} from "./chunk-TLLAD5LU.js";
import {
  external_exports
} from "./chunk-SDLCFZRL.js";
import {
  CliError,
  CliErrorCode,
  normalizeError,
  require_lib
} from "./chunk-CO5A7CZG.js";
import {
  __toESM,
  init_esm_shims
} from "./chunk-EXLZF52D.js";

// ../cli-astro-commands/src/components/DevCommand/index.ts
init_esm_shims();

// ../cli-astro-commands/src/components/DevCommand/DevCommand.tsx
init_esm_shims();
var import_react32 = __toESM(require_react(), 1);
var import_variant14 = __toESM(require_lib(), 1);

// ../cli-astro-commands/src/components/DevCommand/utils/runAstroDev.ts
init_esm_shims();
var EVENT_LINE = "line";
var EVENT_SERVER_ADDRESS = "server_address";
function runAstroDev({
  packageManager,
  projectFolder,
  port,
  allowedHosts
}) {
  const binaryArgs = ["astro", "dev"];
  if (port) {
    binaryArgs.push("--port", `${port}`);
  }
  if (allowedHosts) {
    binaryArgs.push("--allowed-hosts", allowedHosts);
  }
  const { file, args } = packageManager.getRunBinaryCmd(binaryArgs);
  const result = execa(file, args, {
    cwd: projectFolder,
    stdio: "pipe",
    env: { FORCE_COLOR: "1" },
    cleanup: true,
    windowsHide: false
  });
  let stdoutBuffer = "";
  result.stdout?.on("data", (chunk) => {
    stdoutBuffer += chunk.toString();
    const lines = stdoutBuffer.split("\n");
    stdoutBuffer = lines.pop() ?? "";
    for (const line of lines) {
      result.stdout?.emit(EVENT_LINE, line);
      if (line.includes("http://")) {
        const match11 = /(http:\/\/[^\s]+)/.exec(line);
        if (match11?.[1]) {
          const address = stripAnsi(match11[1]).trim();
          result.stdout?.emit(EVENT_SERVER_ADDRESS, address);
        }
      }
    }
  });
  let stdErrBuffer = "";
  result.stderr?.on("data", (chunk) => {
    stdErrBuffer += chunk.toString();
    const lines = stdErrBuffer.split("\n");
    stdErrBuffer = lines.pop() ?? "";
    for (const line of lines) {
      result.stderr?.emit(EVENT_LINE, line);
    }
  });
  return result;
}

// ../cli-astro-commands/src/components/DevCommand/utils/useAstroLogger.tsx
init_esm_shims();
var import_react = __toESM(require_react(), 1);

// ../cli-astro-commands/src/components/DevCommand/utils/devLogStream.tsx
init_esm_shims();
import { EOL } from "node:os";
import { createWriteStream } from "node:fs";
import { PassThrough } from "node:stream";
import { pipeline } from "node:stream/promises";
import { dirname } from "node:path";
var streamCache = /* @__PURE__ */ new Map();
var createNoopStream = () => ({
  write: () => {
  },
  close: () => {
  },
  isClosed: () => true
});
var getDevLogStream = async (options) => {
  const { filePath } = options;
  const entry = streamCache.get(filePath);
  if (entry && !entry.stream.isClosed()) {
    entry.refCount++;
    return {
      write: (msg) => entry.stream.write(msg),
      release: () => {
        entry.refCount--;
        if (entry.refCount === 0) {
          entry.stream.close();
          streamCache.delete(filePath);
        }
      }
    };
  }
  let stream;
  try {
    stream = await createDevLogStream(options);
  } catch {
    stream = createNoopStream();
  }
  const newEntry = { stream, refCount: 1 };
  streamCache.set(filePath, newEntry);
  return {
    write: (msg) => newEntry.stream.write(msg),
    release: () => {
      newEntry.refCount--;
      if (newEntry.refCount === 0) {
        newEntry.stream.close();
        streamCache.delete(filePath);
      }
    }
  };
};
var createDevLogStream = async ({ filePath }) => {
  await outputDir(dirname(filePath));
  const source = new PassThrough();
  const fileStream = createWriteStream(filePath, { flags: "w" });
  let closed = false;
  const isClosed = () => closed;
  pipeline(source, fileStream).catch(() => {
    if (!closed) {
      closed = true;
    }
  });
  const write = (msg) => {
    if (closed) {
      return;
    }
    source.write(stripAnsi(msg).concat(EOL));
  };
  const close = () => {
    if (closed) {
      return;
    }
    closed = true;
    source.end();
  };
  return {
    write,
    close,
    isClosed
  };
};

// ../cli-astro-commands/src/components/DevCommand/utils/useAstroLogger.tsx
var FORMAT_REGEXP = /^\d{1,2}:\d{1,2}:\d{1,2}\s*/;
var formatMessage = (msg, type = "info") => `[${(/* @__PURE__ */ new Date()).toISOString()}] [cli] [${type}] ${stripAnsi(msg).replace(FORMAT_REGEXP, "")}`;
var useAstroLogger = ({
  isPrefixed = true
} = {}) => {
  const {
    model: { projectFolder }
  } = useProjectModel();
  const streamRef = (0, import_react.useRef)();
  const logger = (0, import_react.useMemo)(
    () => createAstroLogger({
      isPrefixed,
      onLog: (msg) => {
        streamRef.current?.write(formatMessage(msg));
      },
      onError: (msg) => {
        streamRef.current?.write(formatMessage(msg, "error"));
      }
    }),
    [isPrefixed]
  );
  (0, import_react.useEffect)(() => {
    let shouldCleanStream = false;
    void getDevLogStream({
      filePath: getDebugLogPath(projectFolder)
    }).then((devLogStream) => {
      if (shouldCleanStream) {
        devLogStream.release();
        return;
      }
      streamRef.current = devLogStream;
    });
    return () => {
      shouldCleanStream = true;
      streamRef.current?.release();
    };
  }, [projectFolder]);
  return logger;
};

// ../cli-astro-commands/src/components/DevCommand/hooks/useFetchDevMetadata.ts
init_esm_shims();
function useFetchDevMetadata() {
  const http = useHttpClient({ type: "standalone" });
  return useAsyncCallback(async (_, serverLocalUrl) => {
    const url = new URL("/_wix/dev-metadata.json", serverLocalUrl);
    try {
      const { data } = await http.get(url.toString());
      return {
        devMetadata: devMetadataSchema.parse(data),
        serverLocalUrl
      };
    } catch {
      return {
        devMetadata: null,
        serverLocalUrl
      };
    }
  });
}

// ../cli-astro-commands/src/components/DevCommand/DevScreenBorder.tsx
init_esm_shims();
var import_react2 = __toESM(require_react(), 1);
var DevScreenBorder = ({ children }) => {
  return /* @__PURE__ */ import_react2.default.createElement(
    Box_default,
    {
      flexDirection: "column",
      borderTop: true,
      borderLeft: false,
      borderBottom: false,
      borderRight: false,
      borderStyle: "round",
      borderColor: "blueBright",
      width: "95%"
    },
    children
  );
};

// ../cli-astro-commands/src/components/DevCommand/SiteDevFlow.tsx
init_esm_shims();
var import_react9 = __toESM(require_react(), 1);

// ../cli-astro-commands/src/components/DevCommand/DevEnvironment.tsx
init_esm_shims();
var import_react6 = __toESM(require_react(), 1);

// ../cli-astro-commands/src/components/DevCommand/hooks/useDevCenterUpdater.tsx
init_esm_shims();
var import_react4 = __toESM(require_react(), 1);
var import_variant2 = __toESM(require_lib(), 1);

// ../cli-astro-commands/src/files/app.config.ts
init_esm_shims();
async function readAppConfig(projectFolder, writeDebugLog) {
  const configPath = getAstroAppConfigPath(projectFolder);
  const isConfigExist = await pathExists(configPath);
  if (!isConfigExist) {
    return null;
  }
  try {
    const json = await readJson(configPath);
    const appConfig = await astroAppConfigSchema.safeParseAsync(json);
    if (!appConfig.success) {
      return null;
    }
    return appConfig.data;
  } catch (e) {
    writeDebugLog?.(e);
    return null;
  }
}
async function saveAppConfig(projectFolder, config) {
  const currentConfig = await readAppConfig(projectFolder) ?? {};
  const newConfig = {
    ...currentConfig,
    ...config
  };
  await writeJson(getAstroAppConfigPath(projectFolder), newConfig);
}

// ../cli-astro-commands/src/components/DevCommand/hooks/useFetchAppManifest.ts
init_esm_shims();
var import_react3 = __toESM(require_react(), 1);

// ../cli-astro-commands/src/components/DevCommand/utils/isTunnelRequired.ts
init_esm_shims();
function isTunnelRequired(appManifest) {
  for (const extension of appManifest.components) {
    const knownAppManifest = parseKnownExtensionManifest(extension);
    if (knownAppManifest != null && knownAppManifest.compType === ComponentType.WEBHOOK) {
      return !URL.canParse(knownAppManifest.compData.webhook.callbackUrl);
    }
  }
  return false;
}
function parseKnownExtensionManifest(extensionManifest) {
  const appManifestResult = looseComponentSchema.safeParse(extensionManifest);
  if (appManifestResult.error) {
    return null;
  }
  return appManifestResult.data;
}

// ../cli-astro-commands/src/components/DevCommand/hooks/useFetchAppManifest.ts
function useFetchAppManifest() {
  const http = useHttpClient({ type: "standalone" });
  return (0, import_react3.useCallback)(
    async (serverLocalUrl, devMetadata, baseUrl, tunnelUrl) => {
      const url = new URL("/_wix/app-manifest.json", serverLocalUrl);
      const { data: text } = await http.get(url.toString(), {
        responseType: "text",
        transitional: {
          silentJSONParsing: true,
          forcedJSONParsing: false,
          clarifyTimeoutError: false
        },
        disableWixHeaders: true
      });
      if (devMetadata != null) {
        const { staticsUrlPlaceholder, serverUrlPlaceholder } = devMetadata;
        const placeholders = /* @__PURE__ */ new Map();
        placeholders.set(staticsUrlPlaceholder, baseUrl);
        placeholders.set(serverUrlPlaceholder, tunnelUrl);
        return {
          manifest: parseLooseAppManifest(text, placeholders),
          isTunnelRequired: text.includes(serverUrlPlaceholder)
        };
      }
      const manifestV1 = parseLooseAppManifest(text);
      return {
        manifest: manifestV1,
        isTunnelRequired: isTunnelRequired(manifestV1)
      };
    },
    [http]
  );
}

// ../cli-astro-commands/src/components/DevCommand/utils/DevCenterWatcher.ts
init_esm_shims();
import EventEmitter from "node:events";
var DevCenterWatcher = class extends EventEmitter {
  onManifestUpdated(listener) {
    this.on("manifestUpdated", listener);
    return () => {
      this.off("manifestUpdated", listener);
    };
  }
};

// ../cli-astro-commands/src/components/DevCommand/hooks/checkManifestForChanges.ts
init_esm_shims();
var import_variant = __toESM(require_lib(), 1);
import { isDeepStrictEqual } from "node:util";
var ManifestUpdateResult = (0, import_variant.variant)({
  Changed: (0, import_variant.fields)(),
  Unchanged: {}
});
function checkManifestForChanges(previous, latest) {
  if (previous == null) {
    return ManifestUpdateResult.Changed({ updatedComponents: [] });
  }
  if (isDeepStrictEqual(previous, latest)) {
    return ManifestUpdateResult.Unchanged();
  }
  const oldComponentsMap = new Map(
    previous.components.map((comp) => [comp.compId, comp])
  );
  const changedComponents = latest.components.filter((newComp) => {
    const oldComp = oldComponentsMap.get(newComp.compId);
    return !isDeepStrictEqual(newComp, oldComp);
  });
  return ManifestUpdateResult.Changed({ updatedComponents: changedComponents });
}

// ../cli-astro-commands/src/components/DevCommand/hooks/useDevCenterUpdater.tsx
var { pollInterval } = getTestOverrides();
var { devCenterDraftOverrides } = createEnv();
var overrideLifecycleState = devCenterDraftOverrides ? LifecycleState.DRAFT : void 0;
var useDevCenterUpdater = ({
  siteId,
  serverLocalUrl,
  serverExposedUrl,
  devMetadata
}) => {
  const devCenterWatcher = (0, import_react4.useMemo)(() => new DevCenterWatcher(), []);
  const [versionOverrideId, setVersionOverrideId] = (0, import_react4.useState)();
  const [manifest, setManifest] = (0, import_react4.useState)(null);
  const { reportError } = useErrorReporter();
  const writeToDebugLog = useDebugLog();
  const exit = useExit();
  const {
    model: { projectFolder, releaseAppId }
  } = useProjectModel();
  const logger = useAstroLogger({ isPrefixed: true });
  const devCenterOverrides = useDevCenterOverridesClient({ siteId });
  const openTunnel = useTunnel();
  const tunnelUrl = (0, import_react4.useRef)();
  const [tunnelRequired, setTunnelRequired] = (0, import_react4.useState)(false);
  const fetchAppManifest = useFetchAppManifest();
  const baseUrl = serverExposedUrl ?? serverLocalUrl;
  const updateDevCenter = (0, import_react4.useCallback)(
    async (latestManifest, isTunnelRequired2) => {
      const manifestUpdateResult = checkManifestForChanges(
        manifest,
        latestManifest
      );
      if ((0, import_variant2.isType)(manifestUpdateResult, "Unchanged")) {
        return manifestUpdateResult;
      }
      if (!serverExposedUrl && !tunnelUrl.current && isTunnelRequired2) {
        const config = await readUserConfig();
        if (!config.tunneling) {
          setTunnelRequired(true);
          return ManifestUpdateResult.Unchanged();
        }
        const serverLocalPort = parseInt(new URL(serverLocalUrl).port, 10);
        const tunnel = await openTunnel(serverLocalPort);
        tunnelUrl.current = tunnel.url;
        return ManifestUpdateResult.Unchanged();
      }
      const appConfig = await readAppConfig(projectFolder, writeToDebugLog);
      let updatedVersionOverrideId = appConfig?.devArmTag;
      if (!updatedVersionOverrideId) {
        updatedVersionOverrideId = await devCenterOverrides.createComponentsOverride({
          type: OverrideType.DEV,
          appManifest: latestManifest,
          projectId: releaseAppId,
          lifecycleState: overrideLifecycleState
        });
      } else {
        const updateState = await devCenterOverrides.updateComponentsOverrides({
          id: updatedVersionOverrideId,
          type: OverrideType.DEV,
          appManifest: latestManifest,
          projectId: releaseAppId
        });
        if (!(0, import_variant2.isType)(updateState, "Updated")) {
          updatedVersionOverrideId = await devCenterOverrides.createComponentsOverride({
            type: OverrideType.DEV,
            appManifest: latestManifest,
            projectId: releaseAppId,
            lifecycleState: overrideLifecycleState
          });
        }
      }
      if (updatedVersionOverrideId !== appConfig?.devArmTag) {
        await saveAppConfig(projectFolder, {
          devArmTag: updatedVersionOverrideId
        });
      }
      setManifest(latestManifest);
      setVersionOverrideId(updatedVersionOverrideId);
      devCenterWatcher.emit("manifestUpdated", {
        versionOverrideId: updatedVersionOverrideId,
        updatedComponents: manifestUpdateResult.updatedComponents
      });
      return manifestUpdateResult;
    },
    [
      releaseAppId,
      manifest,
      serverLocalUrl,
      serverExposedUrl,
      devCenterOverrides,
      projectFolder,
      openTunnel,
      devCenterWatcher,
      writeToDebugLog
    ]
  );
  const [timer, setTimer] = (0, import_react4.useState)(Date.now());
  (0, import_react4.useEffect)(() => {
    let disposed = false;
    async function fetchAndUpdate() {
      const { manifest: manifest2, isTunnelRequired: isTunnelRequired2 } = await fetchAppManifest(
        serverLocalUrl,
        devMetadata,
        baseUrl,
        tunnelUrl.current ?? baseUrl
      );
      try {
        const result = await updateDevCenter(manifest2, isTunnelRequired2);
        if ((0, import_variant2.isType)(result, "Changed")) {
          logger.log(
            "App manifest updated. Refresh existing browser tabs to view the latest changes."
          );
          if (process.env.REMOTE_MACHINE_TASK_EVENTS_URL) {
            const eventData = {
              type: "manifest_update",
              appId: manifest2.appId,
              overrideId: versionOverrideId,
              result: "SUCCESS"
            };
            void fetch(process.env.REMOTE_MACHINE_TASK_EVENTS_URL, {
              method: "POST",
              headers: { "Content-Type": "application/json" },
              body: JSON.stringify({
                eventName: "manifest-update",
                taskId: process.env.REMOTE_MACHINE_TASK_ID,
                executionId: process.env.REMOTE_MACHINE_EXECUTION_ID,
                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                eventData
              })
            });
          }
        }
      } catch (error) {
        setManifest(manifest2);
        logger.error(/* @__PURE__ */ import_react4.default.createElement(ErrorViewer, { error }));
        writeToDebugLog(error);
        reportError(error);
        if (process.env.REMOTE_MACHINE_TASK_EVENTS_URL) {
          const normalizedError = normalizeError(error);
          const httpError = extractHttpError(normalizedError);
          if (httpError) {
            const errorInfo = getHttpErrorInfo(httpError);
            let validationViolations;
            try {
              if (isHttpValidationError(httpError)) {
                validationViolations = httpError.response?.data.details.validationError.fieldViolations.map(
                  (violation) => `${violation.field}: ${violation.description}`
                ).join("\n");
              }
            } catch {
            }
            const eventData = {
              type: "manifest_update",
              appId: manifest2.appId,
              overrideId: versionOverrideId ?? "",
              result: "FAILURE",
              code: errorInfo.response.status,
              message: errorInfo.response.data.message,
              validationViolations
            };
            void fetch(process.env.REMOTE_MACHINE_TASK_EVENTS_URL, {
              method: "POST",
              headers: { "Content-Type": "application/json" },
              body: JSON.stringify({
                eventName: "manifest-update",
                taskId: process.env.REMOTE_MACHINE_TASK_ID,
                executionId: process.env.REMOTE_MACHINE_EXECUTION_ID,
                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
                eventData
              })
            });
          }
        }
        throw error;
      }
    }
    void fetchAndUpdate().catch((error) => {
      if (error instanceof Error && error.name === "TrustedAppIsNotMarkedAsInternal") {
        exit(error);
      }
    }).finally(() => {
      if (!disposed) {
        setTimeout(() => setTimer(Date.now()), pollInterval ?? 1e3);
      }
    });
    return () => {
      disposed = true;
    };
  }, [timer]);
  return { baseUrl, tunnelRequired, versionOverrideId, devCenterWatcher };
};

// ../cli-astro-commands/src/components/DevCommand/TunnelingConsent.tsx
init_esm_shims();
var import_react5 = __toESM(require_react(), 1);
var import_variant3 = __toESM(require_lib(), 1);
var TunnelingConsent = ({ required, children }) => {
  const exit = useExit();
  const [approved, setApproved] = (0, import_react5.useState)();
  const { status } = useAsync(async () => {
    const config = await readUserConfig();
    if (config.tunneling) {
      setApproved(true);
    }
    return config;
  }, []);
  if (!required || approved) {
    return children;
  }
  return /* @__PURE__ */ import_react5.default.createElement(import_react5.default.Fragment, null, (0, import_variant3.match)(status, {
    Success: () => /* @__PURE__ */ import_react5.default.createElement(
      ConfirmInput,
      {
        label: "To continue, a secure tunnel will be set up from your machine for development purposes.",
        initialValue: true,
        onSubmit: async (approved2) => {
          setApproved(approved2);
          await updateUserConfig({ tunneling: approved2 });
          if (!approved2) {
            exit();
          }
        }
      }
    ),
    Error: () => null,
    Loading: () => null
  }), approved === false && /* @__PURE__ */ import_react5.default.createElement(Text, { skin: "error" }, "Operation aborted. Tunneling is necessary to run your application."));
};

// ../cli-astro-commands/src/components/DevCommand/DevEnvironment.tsx
var DevEnvironmentContext = (0, import_react6.createContext)(null);
var DevEnvironmentProvider = ({
  siteId,
  serverLocalUrl,
  serverExposedUrl,
  devMetadata,
  children
}) => {
  const { baseUrl, tunnelRequired, versionOverrideId, devCenterWatcher } = useDevCenterUpdater({
    siteId,
    serverLocalUrl,
    serverExposedUrl,
    devMetadata
  });
  return /* @__PURE__ */ import_react6.default.createElement(TunnelingConsent, { required: tunnelRequired }, versionOverrideId == null ? /* @__PURE__ */ import_react6.default.createElement(Spinner, { text: "Preparing your dashboard..." }) : /* @__PURE__ */ import_react6.default.createElement(
    DevEnvironmentContext.Provider,
    {
      value: { baseUrl, versionOverrideId, devCenterWatcher }
    },
    children
  ));
};
var useDevEnvironment = () => {
  const ctx = (0, import_react6.useContext)(DevEnvironmentContext);
  if (!ctx) {
    throw new Error(
      "useDevEnvironment must be used inside DevEnvironmentProvider"
    );
  }
  return ctx;
};

// ../cli-astro-commands/src/components/DevCommand/site-flow/SiteDev.tsx
init_esm_shims();
var import_react8 = __toESM(require_react(), 1);
var import_variant4 = __toESM(require_lib(), 1);

// ../cli-astro-commands/src/components/DevCommand/site-flow/useSiteDeploymentTopologyUpdater.tsx
init_esm_shims();
var import_react7 = __toESM(require_react(), 1);
function useSiteDeploymentTopologyUpdater() {
  const { baseUrl, versionOverrideId } = useDevEnvironment();
  const { siteId } = useSiteConfig();
  const updateTopology = useUpdateDeploymentTopologyForSite(siteId);
  const exit = useExit();
  (0, import_react7.useEffect)(() => {
    updateTopology({
      versionOverrideId,
      siteUrl: baseUrl,
      environment: "development"
    }).catch(exit);
  }, [versionOverrideId, baseUrl, updateTopology, exit]);
}

// ../cli-astro-commands/src/components/DevCommand/site-flow/SiteDev.tsx
var SiteDev = () => {
  const { appId, siteId } = useSiteConfig();
  const { baseUrl, versionOverrideId } = useDevEnvironment();
  const veloClient = useVeloClient();
  const { status: gitHubOnboardingStatus } = useAsync(
    () => veloClient.getGitHubOnboardingStatus(appId),
    [appId]
  );
  useSiteDeploymentTopologyUpdater();
  return /* @__PURE__ */ import_react8.default.createElement(import_react8.default.Fragment, null, /* @__PURE__ */ import_react8.default.createElement(Text, null, "Development environment ready"), /* @__PURE__ */ import_react8.default.createElement(Box_default, { marginY: 1, flexDirection: "column", gap: 1 }, /* @__PURE__ */ import_react8.default.createElement(Text, null, "Open the preview on:"), /* @__PURE__ */ import_react8.default.createElement(Box_default, { paddingLeft: 2, flexDirection: "column" }, /* @__PURE__ */ import_react8.default.createElement(PlatformLink, { url: baseUrl, platform: "site" }), /* @__PURE__ */ import_react8.default.createElement(
    PlatformLink,
    {
      url: `https://manage.wix.com/dashboard/${siteId}?apps-override=${versionOverrideId}`,
      platform: "dashboard"
    }
  ), (0, import_variant4.match)(gitHubOnboardingStatus, {
    Success: ({ result }) => result?.status === OnboardingState.GITHUB_ENABLED && /* @__PURE__ */ import_react8.default.createElement(
      PlatformLink,
      {
        url: `https://vibe.wix.com/projects/${siteId}`,
        platform: "editor"
      }
    ),
    Error: () => null,
    Loading: () => null
  })), /* @__PURE__ */ import_react8.default.createElement(LinkClickTip, null)));
};

// ../cli-astro-commands/src/components/DevCommand/SiteDevFlow.tsx
var SiteDevFlow = (props) => {
  const { siteId } = useSiteConfig();
  return /* @__PURE__ */ import_react9.default.createElement(DevEnvironmentProvider, { ...props, siteId }, /* @__PURE__ */ import_react9.default.createElement(SiteDev, null));
};

// ../cli-astro-commands/src/components/DevCommand/AppDevFlow.tsx
init_esm_shims();
var import_react31 = __toESM(require_react(), 1);

// ../cli-astro-commands/src/components/DevCommand/app-flow/site/index.ts
init_esm_shims();

// ../cli-astro-commands/src/components/DevCommand/app-flow/site/SiteProvider.tsx
init_esm_shims();
var import_react21 = __toESM(require_react(), 1);
var import_variant11 = __toESM(require_lib(), 1);

// ../cli-astro-commands/src/components/DevCommand/app-flow/site/ResolveSite.tsx
init_esm_shims();
var import_react19 = __toESM(require_react(), 1);

// ../cli-site-selector/src/index.ts
init_esm_shims();

// ../cli-site-selector/src/SiteSelector.tsx
init_esm_shims();
var import_react18 = __toESM(require_react(), 1);
var import_variant9 = __toESM(require_lib(), 1);

// ../site-list-client/src/index.ts
init_esm_shims();

// ../site-list-client/src/site-list-client.ts
init_esm_shims();

// ../../node_modules/@wix/ambassador-site-list-v2-site/build/es/http.impl.js
init_esm_shims();
var _querySitesRequest = {};
var _querySitesResponse = { sites: "_site" };
var _site = {
  createdDate: "google.protobuf.Timestamp",
  updatedDate: "google.protobuf.Timestamp",
  trashedDate: "google.protobuf.Timestamp"
};
function resolveComWixpressSitelistApiSiteListServiceV2Url(opts) {
  var domainToMappings = {
    "www._base_domain_": [
      {
        srcPath: "/_api/sites-list",
        destPath: "/api"
      },
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "feedback._base_domain_": [
      {
        srcPath: "/_api/sites-list",
        destPath: "/api"
      }
    ],
    "manage._base_domain_": [
      {
        srcPath: "/_api/sites-list",
        destPath: "/api"
      },
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      },
      {
        srcPath: "/_api/sites-list-data",
        destPath: "/api/sites-list-data"
      }
    ],
    "www.wixapis.com": [
      {
        srcPath: "/site-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "api._api_base_domain_": [
      {
        srcPath: "/sites-list",
        destPath: ""
      }
    ],
    "bo._base_domain_": [
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "wixbo.ai": [
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "wix-bo.com": [
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "dev._base_domain_": [
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "editor._base_domain_": [
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "blocks._base_domain_": [
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "create.editorx": [
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "online.codux.com": [
      {
        srcPath: "/_api/sites-list",
        destPath: ""
      },
      {
        srcPath: "/_api/sites-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "*.dev.wix-code.com": [
      {
        srcPath: "/site-list/v2/sites",
        destPath: "/v2/sites"
      }
    ],
    "vibe._base_domain_": [
      {
        srcPath: "/_api/sites-list",
        destPath: ""
      }
    ]
  };
  return resolveUrl(Object.assign(opts, { domainToMappings }));
}
function querySites(payload) {
  var _a = serializer(_querySitesRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
  var fromRes = serializer(_querySitesResponse, { _site }).fromJSON;
  function __querySites(_a2) {
    var host = _a2.host;
    var serializedData = toReq(payload);
    var metadata = {
      entityFqdn: "wix.site_list.v2.site",
      method: "POST",
      methodFqn: "com.wixpress.sitelist.api.SiteListServiceV2.QuerySites",
      migrationOptions: {
        optInTransformResponse: true
      },
      url: resolveComWixpressSitelistApiSiteListServiceV2Url({
        protoPath: "/v2/sites/query",
        data: serializedData,
        host
      }),
      data: serializedData,
      transformResponse: fromRes
    };
    return metadata;
  }
  __querySites.fromReq = fromReq;
  __querySites.__isAmbassador = true;
  return __querySites;
}

// ../site-list-client/src/schemas.ts
init_esm_shims();
var siteSchema = external_exports.object({
  id: external_exports.string(),
  displayName: external_exports.string(),
  viewUrl: external_exports.union([external_exports.string().url(), external_exports.literal("")]).optional()
});
var querySitesSchema = external_exports.object({
  sites: external_exports.array(siteSchema)
});

// ../site-list-client/src/site-list-client.ts
var SiteListClient = class {
  constructor(httpClient) {
    this.httpClient = httpClient;
    const { minRetryTimeout } = getTestOverrides();
    this.retryOptions = {
      retries: 3,
      minTimeout: minRetryTimeout,
      maxTimeout: 3 * 1e3
    };
  }
  retryOptions;
  querySites = async (opts = {}) => {
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(querySites(opts)),
        this.retryOptions
      );
      return querySitesSchema.parse(data).sites;
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToQuerySites(),
        cause: e,
        info: { ...opts }
      });
    }
  };
  getSite = async (id, inclHeadless) => {
    const queryPayload = {
      query: {
        filter: {
          id: { $in: [id] },
          ...inclHeadless ? {
            namespace: { $in: ["WIX", "HEADLESS"] }
          } : {}
        }
      }
    };
    try {
      const { data } = await pRetry(
        () => this.httpClient.request(querySites(queryPayload)),
        this.retryOptions
      );
      const { sites } = querySitesSchema.parse(data);
      return sites.at(0) ?? null;
    } catch (e) {
      throw new CliError({
        code: CliErrorCode.FailedToGetSite(),
        cause: e,
        info: { id }
      });
    }
  };
};

// ../site-list-client/src/useSiteListClient.ts
init_esm_shims();
var import_react10 = __toESM(require_react(), 1);
function useSiteListClient() {
  const httpClient = useHttpClient({ type: "backoffice" });
  const client = (0, import_react10.useMemo)(() => new SiteListClient(httpClient), [httpClient]);
  return usePanoramaMethodLogger(client);
}

// ../cli-site-selector/src/SiteTypeSelect.tsx
init_esm_shims();
var import_react12 = __toESM(require_react(), 1);
var import_variant5 = __toESM(require_lib(), 1);

// ../cli-site-selector/src/bi.ts
init_esm_shims();
var import_react11 = __toESM(require_react(), 1);
function siteSelectorBiEvents(biLogger) {
  return {
    cliAction: ({
      question,
      action,
      key,
      additionalInfo
    }) => {
      void biLogger.report(
        wixCliAction({
          question,
          action,
          key,
          additionalInfo: JSON.stringify(additionalInfo)
        })
      );
    },
    cliFlowStepAnswered: ({
      question,
      answer,
      additionalInfo
    }) => {
      void biLogger.report(
        wixCliAppFlowStepsAnswers({
          question,
          answer,
          additionalInfo: JSON.stringify(additionalInfo)
        })
      );
    }
  };
}
function useSiteSelectorBi() {
  const biLogger = useBiLogger();
  return (0, import_react11.useMemo)(() => siteSelectorBiEvents(biLogger), [biLogger]);
}

// ../cli-site-selector/src/SiteTypeSelect.tsx
var SiteTypeSelect = ({ onSubmit, onError, sites }) => {
  const bi = useSiteSelectorBi();
  const { t } = useTranslation();
  const { getDevSitesCount, getDevSitesLimit } = useDevCenterClient();
  const { status } = useAsync(
    () => Promise.all([getDevSitesCount(), getDevSitesLimit()]),
    [],
    { onError }
  );
  const handleSubmit = (option) => {
    void bi.cliFlowStepAnswered({
      question: t("site_type_select.label"),
      answer: option.title
    });
    onSubmit(option.value);
  };
  return (0, import_variant5.match)(status, {
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react12.default.createElement(Spinner, { text: t("general.loading") }),
    Success: ({ result: [devSitesCount, devSitesLimit] }) => {
      const isDevSitesLimitReached = devSitesCount >= devSitesLimit;
      const userHasNoSites = sites.length === 0;
      return /* @__PURE__ */ import_react12.default.createElement(
        SelectInput,
        {
          label: t("site_type_select.label"),
          options: [
            {
              availability: userHasNoSites ? SelectOptionAvailability.Disabled({
                reason: t("site_type_select.no_sites")
              }) : SelectOptionAvailability.Enabled(),
              title: t("site_type_select.pick_existing_site"),
              value: "select-existing-site"
            },
            {
              title: t("site_type_select.create_new_dev_site"),
              value: "create-dev-site",
              availability: isDevSitesLimitReached ? SelectOptionAvailability.Disabled({
                reason: t("site_type_select.create_new_dev_site.disabled", {
                  limit: devSitesLimit
                })
              }) : SelectOptionAvailability.Enabled()
            },
            {
              title: t("site_type_select.create_new_harmony_site"),
              value: "create-harmony-site",
              availability: isDevSitesLimitReached ? SelectOptionAvailability.Disabled({
                reason: t("site_type_select.create_new_dev_site.disabled", {
                  limit: devSitesLimit
                })
              }) : SelectOptionAvailability.Enabled()
            }
          ],
          onSubmit: handleSubmit
        }
      );
    }
  });
};

// ../cli-site-selector/src/CreateDevSite.tsx
init_esm_shims();
var import_react15 = __toESM(require_react(), 1);
var import_variant7 = __toESM(require_lib(), 1);

// ../cli-site-selector/src/WaitForAppToBeInstalled.tsx
init_esm_shims();
var import_react14 = __toESM(require_react(), 1);
var import_variant6 = __toESM(require_lib(), 1);

// ../cli-site-selector/src/OpenBrowser.tsx
init_esm_shims();
var import_react13 = __toESM(require_react(), 1);
var OpenBrowser = ({ siteId, appId }) => {
  const { t } = useTranslation();
  const bi = useSiteSelectorBi();
  use_input_default(async (input, key) => {
    if (key.return) {
      bi.cliAction({
        question: t("install_app_on_site.warning.instructions"),
        key: "enter",
        action: "install_app_on_site"
      });
      await openBrowser(
        `https://manage.wix.com/installer/install?metaSiteId=${siteId}&appId=${appId}&platform=cli&version=latest`
      );
    }
  });
  return /* @__PURE__ */ import_react13.default.createElement(import_react13.default.Fragment, null, /* @__PURE__ */ import_react13.default.createElement(Trans, { i18nKey: "install_app_on_site.warning" }), /* @__PURE__ */ import_react13.default.createElement(
    Trans,
    {
      i18nKey: "install_app_on_site.warning.instructions",
      components: [/* @__PURE__ */ import_react13.default.createElement(Key, { value: "Enter" })]
    }
  ));
};

// ../cli-site-selector/src/WaitForAppToBeInstalled.tsx
var AppInstallData = (0, import_variant6.variant)({
  Success: {},
  Canceled: {}
});
function isAbortError(error) {
  return error && typeof error === "object" && "name" in error && error.name === "AbortError";
}
var WaitForAppToBeInstalled = ({
  appId,
  site,
  onSubmit,
  onError
}) => {
  const { isAppInstalled } = useDevCenterClient({ siteId: site.id });
  const { status } = useAsync(
    async ({ signal }) => {
      const { pollInterval: pollInterval2 } = getTestOverrides();
      try {
        await pWaitFor(() => isAppInstalled(appId), {
          // Polling interval is set to 6.5 seconds to avoid rate limiting (429)
          interval: pollInterval2 ?? 6500,
          timeout: {
            milliseconds: 60 * 1e3 * 2,
            signal
          }
        });
        return AppInstallData.Success();
      } catch (error) {
        if (error instanceof TimeoutError) {
          throw new CliError({
            code: CliErrorCode.SiteSelectorTimedout(),
            cause: error
          });
        }
        if (isAbortError(error)) {
          return AppInstallData.Canceled();
        }
        throw error;
      }
    },
    [],
    {
      onError,
      onSuccess: (result) => {
        if ((0, import_variant6.isType)(result, AppInstallData.Success)) {
          onSubmit();
        }
      }
    }
  );
  return (0, import_variant6.match)(status, {
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react14.default.createElement(OpenBrowser, { siteId: site.id, appId }),
    Success: () => /* @__PURE__ */ import_react14.default.createElement(Alert, { type: "success" }, /* @__PURE__ */ import_react14.default.createElement(Badge, { skin: "success" }, /* @__PURE__ */ import_react14.default.createElement(Trans, { i18nKey: "general.success" })), " ", /* @__PURE__ */ import_react14.default.createElement(Trans, { i18nKey: "install_app_on_site.finished_successfully" }))
  });
};

// ../cli-site-selector/src/CreateDevSite.tsx
var CreateDevSite = ({
  status,
  appId,
  onSubmit,
  onError
}) => {
  const { t } = useTranslation();
  return (0, import_variant7.match)(status, {
    NotRequested: () => null,
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react15.default.createElement(Spinner, { text: t("create_dev_site.loading") }),
    Success: ({ result }) => /* @__PURE__ */ import_react15.default.createElement(import_react15.default.Fragment, null, /* @__PURE__ */ import_react15.default.createElement(
      Trans,
      {
        i18nKey: "create_dev_site.success",
        components: [/* @__PURE__ */ import_react15.default.createElement(Text, { skin: "success", bold: true })],
        values: { name: result.displayName }
      }
    ), /* @__PURE__ */ import_react15.default.createElement(
      WaitForAppToBeInstalled,
      {
        appId,
        site: result,
        onSubmit: () => onSubmit(result),
        onError
      }
    ))
  });
};

// ../cli-site-selector/src/SelectExistingSite.tsx
init_esm_shims();
var import_react17 = __toESM(require_react(), 1);
var import_variant8 = __toESM(require_lib(), 1);

// ../cli-site-selector/src/SiteListSelect.tsx
init_esm_shims();
var import_react16 = __toESM(require_react(), 1);
var SiteListSelect = ({ onSubmit, sites }) => {
  const { t } = useTranslation();
  const bi = useSiteSelectorBi();
  const handleSubmit = (0, import_react16.useCallback)(
    (option) => {
      bi.cliFlowStepAnswered({
        question: t("site_list_select.label"),
        answer: option.title
      });
      onSubmit(option.value);
    },
    [bi, onSubmit, t]
  );
  return /* @__PURE__ */ import_react16.default.createElement(
    SelectInput,
    {
      label: t("site_list_select.label"),
      options: sites.map((site) => ({
        key: site.id,
        title: site.displayName,
        description: site.viewUrl,
        value: site
      })),
      onSubmit: handleSubmit
    }
  );
};

// ../cli-site-selector/src/SelectExistingSite.tsx
var CheckAppInstalledOnSite = ({ appId, site, onSubmit, onError }) => {
  const { t } = useTranslation();
  const { isAppInstalled } = useDevCenterClient({ siteId: site.id });
  const { status } = useAsync(async () => isAppInstalled(appId), [], {
    onError,
    onSuccess: (isInstalled) => {
      if (isInstalled) {
        onSubmit(site);
      }
    }
  });
  return (0, import_variant8.match)(status, {
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react17.default.createElement(Spinner, { text: t("general.loading") }),
    Success: ({ result: isInstalled }) => {
      if (isInstalled) {
        return null;
      }
      return /* @__PURE__ */ import_react17.default.createElement(
        WaitForAppToBeInstalled,
        {
          appId,
          site,
          onSubmit: () => onSubmit(site),
          onError
        }
      );
    }
  });
};
var SelectExistingSite = ({
  sites,
  appId,
  onSubmit,
  onError
}) => {
  const [siteToInstallAppOn, setSiteToInstallAppOn] = (0, import_react17.useState)(
    null
  );
  return /* @__PURE__ */ import_react17.default.createElement(import_react17.default.Fragment, null, /* @__PURE__ */ import_react17.default.createElement(
    SiteListSelect,
    {
      onSubmit: (site) => setSiteToInstallAppOn(site),
      sites
    }
  ), siteToInstallAppOn && /* @__PURE__ */ import_react17.default.createElement(
    CheckAppInstalledOnSite,
    {
      appId,
      site: siteToInstallAppOn,
      onSubmit: () => onSubmit(siteToInstallAppOn),
      onError
    }
  ));
};

// ../cli-site-selector/src/messages.json
var messages_default = {
  "general.loading": "Loading...",
  "general.success": "Done",
  "site_type_select.label": "Select development site:",
  "site_type_select.pick_existing_site": "Select an existing site:",
  "site_type_select.create_new_dev_site": "Create a new development site",
  "site_type_select.create_new_dev_site.disabled": "You have reached the maximum number of {limit} development sites.",
  "site_type_select.create_new_harmony_site": "Create a new Harmony Development Site",
  "site_type_select.no_sites": "No sites found.",
  "create_dev_site.loading": "Creating your new development site...",
  "create_dev_site.success": "Development site <0>{name}</0> created.",
  "site_list_select.label": "Select Site:",
  "install_app_on_site.warning": "Your new app needs to be installed on the selected development site.",
  "install_app_on_site.warning.instructions": "Press <0/> to install the app in your browser.",
  "install_app_on_site.finished_successfully": "App installed."
};

// ../cli-site-selector/src/SiteSelector.tsx
var HARMONY_SITE_TEMPLATE = "91532250-8835-46ac-9666-e4db8770b275";
var SiteSelector = ({
  appId,
  biLogger,
  onSubmit,
  onError
}) => {
  const [siteType, setSiteType] = (0, import_react18.useState)(null);
  const { createDevSite } = useDevCenterClient();
  const siteListClient = useSiteListClient();
  const { status } = useAsync(
    () => siteListClient.querySites({
      query: {
        cursorPaging: {
          limit: 100
        }
      }
    }),
    [],
    {
      onError
    }
  );
  const createSite = useAsyncCallback(
    (_, siteType2) => siteType2 === "create-harmony-site" ? createDevSite({ templateId: HARMONY_SITE_TEMPLATE }) : createDevSite(),
    {
      onError
    }
  );
  function handleSelectSiteType(siteType2) {
    setSiteType(siteType2);
    if (siteType2 !== "select-existing-site") {
      void createSite.execute(siteType2);
    }
  }
  return /* @__PURE__ */ import_react18.default.createElement(BiProvider, { value: biLogger }, /* @__PURE__ */ import_react18.default.createElement(I18nProvider, { messages: messages_default }, (0, import_variant9.match)(status, {
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react18.default.createElement(Spinner, { text: /* @__PURE__ */ import_react18.default.createElement(Trans, { i18nKey: "general.loading" }) }),
    Success: ({ result: sites }) => /* @__PURE__ */ import_react18.default.createElement(import_react18.default.Fragment, null, /* @__PURE__ */ import_react18.default.createElement(
      SiteTypeSelect,
      {
        onSubmit: handleSelectSiteType,
        onError,
        sites
      }
    ), siteType === "select-existing-site" ? /* @__PURE__ */ import_react18.default.createElement(
      SelectExistingSite,
      {
        sites,
        appId,
        onSubmit,
        onError
      }
    ) : /* @__PURE__ */ import_react18.default.createElement(
      CreateDevSite,
      {
        status: createSite.status,
        appId,
        onSubmit,
        onError
      }
    ))
  })));
};

// ../cli-astro-commands/src/components/DevCommand/app-flow/site/ResolveSite.tsx
var ResolveSite = ({ onSubmit }) => {
  const exit = useExit();
  const { model } = useProjectModel();
  const biLogger = useBiLogger();
  return /* @__PURE__ */ import_react19.default.createElement(import_react19.default.Fragment, null, /* @__PURE__ */ import_react19.default.createElement(Alert, { type: "insight" }, "You don't have a development site currently configured."), /* @__PURE__ */ import_react19.default.createElement(
    SiteSelector,
    {
      appId: model.config.appId,
      biLogger,
      onSubmit: (site) => onSubmit(site.id),
      onError: exit
    }
  ));
};

// ../cli-astro-commands/src/components/DevCommand/app-flow/site/context.ts
init_esm_shims();
var import_react20 = __toESM(require_react(), 1);
var SiteContext = (0, import_react20.createContext)(null);

// ../cli-astro-commands/src/components/DevCommand/app-flow/site/site-value.ts
init_esm_shims();
var import_variant10 = __toESM(require_lib(), 1);
var SiteValue = (0, import_variant10.variant)({
  NotConfigured: {},
  Resolved: (0, import_variant10.fields)()
});

// ../cli-astro-commands/src/components/DevCommand/app-flow/site/SiteProvider.tsx
var SiteProvider = ({
  children
}) => {
  const exit = useExit();
  const { model } = useProjectModel();
  const { projectFolder, env } = model;
  const userDefinedSiteId = env.WIX_SITE_ID;
  const writeDebugLog = useDebugLog();
  const { status, merge } = useAsync(async () => {
    if (userDefinedSiteId) {
      return SiteValue.Resolved({ siteId: userDefinedSiteId });
    }
    const siteId = (await readAppConfig(projectFolder, writeDebugLog))?.siteId;
    return siteId ? SiteValue.Resolved({ siteId }) : SiteValue.NotConfigured();
  }, []);
  const setSiteId = (0, import_react21.useCallback)(
    async (siteId) => {
      if (userDefinedSiteId) {
        throw new Error("Cannot change site: siteId is user-defined");
      }
      try {
        await saveAppConfig(projectFolder, { siteId });
        merge({ result: SiteValue.Resolved({ siteId }) });
      } catch (e) {
        throw new CliError({
          code: CliErrorCode.FailedToSaveDevelopmentSite({
            path: ASTRO_APP_CONFIG_PATH
          }),
          cause: e
        });
      }
    },
    [merge, projectFolder, userDefinedSiteId]
  );
  const handleResolveSite = (0, import_react21.useCallback)(
    (siteId) => setSiteId(siteId).catch(exit),
    [exit, setSiteId]
  );
  return (0, import_variant11.match)(status, {
    Error: () => null,
    Loading: () => /* @__PURE__ */ import_react21.default.createElement(Spinner, { text: "Resolving development site..." }),
    Success: ({ result: state }) => {
      return (0, import_variant11.match)(state, {
        NotConfigured: () => /* @__PURE__ */ import_react21.default.createElement(ResolveSite, { onSubmit: handleResolveSite }),
        Resolved: ({ siteId }) => /* @__PURE__ */ import_react21.default.createElement(
          SiteContext.Provider,
          {
            value: {
              siteId,
              setSiteId,
              canChangeSite: !userDefinedSiteId
            }
          },
          children(siteId)
        )
      });
    }
  });
};

// ../cli-astro-commands/src/components/DevCommand/app-flow/site/useSite.ts
init_esm_shims();
var import_react22 = __toESM(require_react(), 1);
function useSite() {
  const context = (0, import_react22.useContext)(SiteContext);
  if (context == null) {
    throw new Error("useSite() cannot be used without an <SiteProvider>");
  }
  return context;
}

// ../cli-astro-commands/src/components/DevCommand/app-flow/AppDev.tsx
init_esm_shims();
var import_react30 = __toESM(require_react(), 1);
var import_variant13 = __toESM(require_lib(), 1);

// ../cli-astro-commands/src/components/DevC