@wix/cli-app 1.1.53 → 1.1.56

package/build/chunk-3KMSVIRS.js

@@ -0,0 +1,1323 @@
+import { createRequire as _createRequire } from 'node:module';
+const require = _createRequire(import.meta.url);
+import {
+  useBackendComponents
+} from "./chunk-U4QPSXJP.js";
+import {
+  useTunnel
+} from "./chunk-KCMEJP7H.js";
+import {
+  useDebugLog
+} from "./chunk-TTW4MEC3.js";
+import {
+  createAppManifest,
+  getComponentSourceBuilder,
+  getViteConfig,
+  getViteConfig2,
+  getViteServerUrl,
+  updateAppManifestWithBaseUrl
+} from "./chunk-SP37PQ3I.js";
+import {
+  DevCenterComponent,
+  ErrorViewer,
+  PlatformType,
+  deepEqual,
+  isHttpError,
+  openBrowser,
+  pRetry,
+  readAppConfig,
+  resolveUrl,
+  saveAppConfig,
+  serializer,
+  useDevCenterClient,
+  useErrorReporter,
+  useHttpClient,
+  useProjectModel
+} from "./chunk-TSFNDZPX.js";
+import {
+  Alert,
+  CliError,
+  CliErrorCode,
+  Link,
+  Newline,
+  Spinner,
+  Text,
+  Trans,
+  getTestOverrides,
+  require_lib,
+  require_react,
+  useAsync,
+  useExit,
+  useTranslation,
+  z
+} from "./chunk-XU5JBKO6.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-PYIAC2GK.js";
+
+// src/components/DevCommand/DevEnvironment.tsx
+init_esm_shims();
+var import_react10 = __toESM(require_react(), 1);
+var import_variant4 = __toESM(require_lib(), 1);
+
+// src/components/DevCommand/useArmUpdater.ts
+init_esm_shims();
+var import_react2 = __toESM(require_react(), 1);
+var import_variant2 = __toESM(require_lib(), 1);
+
+// ../arm-client/src/index.ts
+init_esm_shims();
+
+// ../arm-client/src/client.ts
+init_esm_shims();
+
+// ../../node_modules/@wix/ambassador-ctp-gradual-rollout-v1-app-config/build/es/http.impl.js
+init_esm_shims();
+var _createAppReleaseRequest = {};
+var _createAppReleaseResponse = {};
+var _createComponentsRequest = {};
+var _createComponentsResponse = {};
+var _promoteAppReleaseToDevCenterRequest = {};
+var _promoteAppReleaseToDevCenterResponse = {};
+var _updateAppReleaseRequest = {};
+var _updateAppReleaseResponse = {};
+function resolveComWixCtpAppsReleaseManagerServiceUrl(opts) {
+  var domainToMappings = {
+    "api._api_base_domain_": [
+      {
+        srcPath: "/apps-release-manager-service-web",
+        destPath: ""
+      }
+    ],
+    "bo._base_domain_": [
+      {
+        srcPath: "/apps-release-manager-service-web",
+        destPath: ""
+      }
+    ],
+    "wixbo.ai": [
+      {
+        srcPath: "/apps-release-manager-service-web",
+        destPath: ""
+      }
+    ],
+    "wix-bo.com": [
+      {
+        srcPath: "/apps-release-manager-service-web",
+        destPath: ""
+      }
+    ],
+    "www._base_domain_": [
+      {
+        srcPath: "/apps-release-manager-service-web/artifacts-release-manager/app-releases",
+        destPath: "/artifacts-release-manager/app-releases"
+      },
+      {
+        srcPath: "/_api/apps-release-manager-service-web/artifacts-release-manager/app-releases",
+        destPath: "/artifacts-release-manager/app-releases"
+      },
+      {
+        srcPath: "/apps-release-manager-service-web/apps/create",
+        destPath: "/apps/create"
+      },
+      {
+        srcPath: "/apps-release-manager-service-web/apps/promote",
+        destPath: "/apps/promote"
+      },
+      {
+        srcPath: "/apps-release-manager-service-web/apps/tags",
+        destPath: "/apps/tags"
+      },
+      {
+        srcPath: "/apps-release-manager-service-web/apps/create-components",
+        destPath: "/apps/create-components"
+      }
+    ],
+    "manage._base_domain_": [
+      {
+        srcPath: "/apps-release-manager-service-web/apps/promote",
+        destPath: "/apps/promote"
+      },
+      {
+        srcPath: "/apps-release-manager-service-web/apps/create",
+        destPath: "/apps/create"
+      },
+      {
+        srcPath: "/apps-release-manager-service-web/apps/tags",
+        destPath: "/apps/tags"
+      },
+      {
+        srcPath: "/apps-release-manager-service-web/apps/create-components",
+        destPath: "/apps/create-components"
+      }
+    ]
+  };
+  return resolveUrl(Object.assign(opts, { domainToMappings }));
+}
+function createAppRelease(payload) {
+  var _a = serializer(_createAppReleaseRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
+  var fromRes = serializer(_createAppReleaseResponse, {}).fromJSON;
+  function __createAppRelease(_a2) {
+    var host = _a2.host;
+    var serializedData = toReq(payload);
+    var metadata = {
+      entityFqdn: "wix.ctp.gradual_rollout.v1.app_config",
+      method: "POST",
+      methodFqn: "com.wix.ctp.AppsReleaseManagerService.CreateAppRelease",
+      url: resolveComWixCtpAppsReleaseManagerServiceUrl({
+        protoPath: "/apps/create/{appId}",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: fromRes
+    };
+    return metadata;
+  }
+  __createAppRelease.fromReq = fromReq;
+  __createAppRelease.__isAmbassador = true;
+  return __createAppRelease;
+}
+function updateAppRelease(payload) {
+  var _a = serializer(_updateAppReleaseRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
+  var fromRes = serializer(_updateAppReleaseResponse, {}).fromJSON;
+  function __updateAppRelease(_a2) {
+    var host = _a2.host;
+    var serializedData = toReq(payload);
+    var metadata = {
+      entityFqdn: "wix.ctp.gradual_rollout.v1.app_config",
+      method: "PUT",
+      methodFqn: "com.wix.ctp.AppsReleaseManagerService.UpdateAppRelease",
+      url: resolveComWixCtpAppsReleaseManagerServiceUrl({
+        protoPath: "/apps/tags/{tag}",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: fromRes
+    };
+    return metadata;
+  }
+  __updateAppRelease.fromReq = fromReq;
+  __updateAppRelease.__isAmbassador = true;
+  return __updateAppRelease;
+}
+function createComponents(payload) {
+  var _a = serializer(_createComponentsRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
+  var fromRes = serializer(_createComponentsResponse, {}).fromJSON;
+  function __createComponents(_a2) {
+    var host = _a2.host;
+    var serializedData = toReq(payload);
+    var metadata = {
+      entityFqdn: "wix.ctp.gradual_rollout.v1.app_config",
+      method: "POST",
+      methodFqn: "com.wix.ctp.AppsReleaseManagerService.CreateComponents",
+      url: resolveComWixCtpAppsReleaseManagerServiceUrl({
+        protoPath: "/apps/create-components/{appId}",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: fromRes
+    };
+    return metadata;
+  }
+  __createComponents.fromReq = fromReq;
+  __createComponents.__isAmbassador = true;
+  return __createComponents;
+}
+function promoteAppReleaseToDevCenter(payload) {
+  var _a = serializer(_promoteAppReleaseToDevCenterRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
+  var fromRes = serializer(_promoteAppReleaseToDevCenterResponse, {}).fromJSON;
+  function __promoteAppReleaseToDevCenter(_a2) {
+    var host = _a2.host;
+    var serializedData = toReq(payload);
+    var metadata = {
+      entityFqdn: "wix.ctp.gradual_rollout.v1.app_config",
+      method: "POST",
+      methodFqn: "com.wix.ctp.AppsReleaseManagerService.PromoteAppReleaseToDevCenter",
+      url: resolveComWixCtpAppsReleaseManagerServiceUrl({
+        protoPath: "/apps/promote/{appId}/{tag}",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: fromRes
+    };
+    return metadata;
+  }
+  __promoteAppReleaseToDevCenter.fromReq = fromReq;
+  __promoteAppReleaseToDevCenter.__isAmbassador = true;
+  return __promoteAppReleaseToDevCenter;
+}
+
+// ../arm-client/src/client.ts
+var import_variant = __toESM(require_lib(), 1);
+
+// ../arm-client/src/schemas.ts
+init_esm_shims();
+var promoteAppReleaseSchema = z.object({
+  newVersion: z.string()
+});
+var createAppReleaseSchema = z.object({
+  tag: z.string()
+});
+
+// ../arm-client/src/client.ts
+var { AppPermissionDenied } = CliErrorCode;
+var UpdateAppReleaseData = (0, import_variant.variant)({
+  TagNotFound: (0, import_variant.fields)(),
+  TagUpdated: {}
+});
+var ARMClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+    const { minRetryTimeout } = getTestOverrides();
+    this.retryOptions = {
+      maxTimeout: 3 * 1e3,
+      minTimeout: minRetryTimeout,
+      retries: 3
+    };
+  }
+  retryOptions;
+  createComponents = async (appId, componentConfigs, projectId) => {
+    try {
+      await pRetry(
+        () => this.httpClient.request(
+          createComponents({
+            appId,
+            componentConfigs,
+            projectId
+          })
+        ),
+        this.retryOptions
+      );
+    } catch (e) {
+      if (isHttpError(e) && e.response?.status === 403) {
+        throw new CliError({
+          cause: e,
+          code: AppPermissionDenied({ appId })
+        });
+      }
+      throw new CliError({
+        cause: e,
+        code: CliErrorCode.FailedToCreateComponents()
+      });
+    }
+  };
+  createAppRelease = async (manifest, projectId) => {
+    try {
+      const { data } = await pRetry(
+        () => this.httpClient.request(
+          createAppRelease({
+            appId: manifest.appId,
+            componentConfigs: manifest.components,
+            projectId
+          })
+        ),
+        this.retryOptions
+      );
+      return createAppReleaseSchema.parse(data).tag;
+    } catch (e) {
+      if (isHttpError(e) && e.response?.status === 403) {
+        throw new CliError({
+          cause: e,
+          code: AppPermissionDenied({ appId: manifest.appId })
+        });
+      }
+      throw new CliError({
+        cause: e,
+        code: CliErrorCode.FailedToCreateAppRelease()
+      });
+    }
+  };
+  updateAppRelease = async (manifest, tag) => {
+    try {
+      await pRetry(
+        () => this.httpClient.request(
+          updateAppRelease({
+            appId: manifest.appId,
+            componentConfigs: manifest.components,
+            tag
+          })
+        ),
+        this.retryOptions
+      );
+      return UpdateAppReleaseData.TagUpdated();
+    } catch (e) {
+      if (isHttpError(e)) {
+        if (e.response?.status === 404) {
+          return UpdateAppReleaseData.TagNotFound({ cause: e });
+        }
+        if (e.response?.status === 403) {
+          throw new CliError({
+            cause: e,
+            code: AppPermissionDenied({ appId: manifest.appId })
+          });
+        }
+      }
+      throw new CliError({
+        cause: e,
+        code: CliErrorCode.FailedToUpdateAppRelease()
+      });
+    }
+  };
+  promoteToDevCenter = async (appId, tag, versionType) => {
+    const { data } = await pRetry(
+      () => this.httpClient.request(
+        promoteAppReleaseToDevCenter({ appId, tag, versionType })
+      ),
+      this.retryOptions
+    );
+    return promoteAppReleaseSchema.parse(data);
+  };
+};
+
+// ../arm-client/src/useARMClient.ts
+init_esm_shims();
+var import_react = __toESM(require_react(), 1);
+function useARMClient() {
+  const httpClient = useHttpClient({ type: "backoffice" });
+  return (0, import_react.useMemo)(() => new ARMClient(httpClient), [httpClient]);
+}
+
+// src/components/DevCommand/useArmUpdater.ts
+var createAppManifestWithBaseUrl = async (model, clientDevServerUrl, backendServerUrl) => {
+  const manifest = await createAppManifest({
+    appId: model.config.appId,
+    components: model.components,
+    componentSourceBuilder: getComponentSourceBuilder(
+      model,
+      { clientDevServerUrl },
+      { backendDevServerUrl: backendServerUrl?.localUrl }
+    )
+  });
+  return updateAppManifestWithBaseUrl(
+    manifest,
+    clientDevServerUrl,
+    backendServerUrl?.tunnelUrl
+  );
+};
+function useArmUpdater() {
+  const { model } = useProjectModel();
+  const writeDebugLog = useDebugLog();
+  const { createAppRelease: createAppRelease2, updateAppRelease: updateAppRelease2 } = useARMClient();
+  return (0, import_react2.useCallback)(
+    async ({
+      backendServerUrl,
+      devServerUrl,
+      projectModelWatcher,
+      onChange,
+      onError
+    }) => {
+      const { projectId } = model.config;
+      const appManifest = await createAppManifestWithBaseUrl(
+        model,
+        devServerUrl,
+        backendServerUrl
+      );
+      const appConfig = await readAppConfig(model.projectFolder, writeDebugLog);
+      const createOrUpdateAppRelease = async (tag) => {
+        if (tag) {
+          const updateState = await updateAppRelease2(appManifest, tag);
+          return (0, import_variant2.match)(updateState, {
+            TagUpdated: () => tag,
+            TagNotFound: ({ cause }) => {
+              writeDebugLog(cause);
+              return createAppRelease2(appManifest, projectId);
+            }
+          });
+        }
+        return createAppRelease2(appManifest, projectId);
+      };
+      const armTag = await createOrUpdateAppRelease(appConfig?.devArmTag);
+      if (armTag !== appConfig?.devArmTag) {
+        await saveAppConfig(model.projectFolder, { devArmTag: armTag }).catch(
+          (error) => writeDebugLog(error)
+        );
+      }
+      projectModelWatcher.onChange(async (newModel, changeType) => {
+        try {
+          if (changeType === "model-updated") {
+            if (newModel.components.length === 0) {
+              return;
+            }
+            const updatedAppManifest = await createAppManifestWithBaseUrl(
+              newModel,
+              devServerUrl,
+              backendServerUrl
+            );
+            if (!deepEqual(appManifest, updatedAppManifest)) {
+              await updateAppRelease2(updatedAppManifest, armTag);
+            }
+          }
+          onChange(changeType);
+        } catch (e) {
+          onError(e);
+        }
+      }).onError(onError);
+      return armTag;
+    },
+    [createAppRelease2, model, updateAppRelease2, writeDebugLog]
+  );
+}
+
+// src/components/DevCommand/useDevServer.ts
+init_esm_shims();
+var import_react3 = __toESM(require_react(), 1);
+import { createServer } from "vite";
+function useViteDevServer({
+  createConfig
+}) {
+  const { reportError } = useErrorReporter();
+  const devServerRef = (0, import_react3.useRef)();
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      devServerRef.current?.close().catch(reportError);
+    };
+  }, [reportError]);
+  return (0, import_react3.useCallback)(
+    async (options) => {
+      const config = await createConfig(options);
+      const devServer = await createServer(config);
+      devServerRef.current = devServer;
+      await devServer.listen();
+      return { devServerUrl: getViteServerUrl(devServer), devServer };
+    },
+    [createConfig]
+  );
+}
+function useClientDevServer({ https }) {
+  const { model } = useProjectModel();
+  const createDevServer = useViteDevServer({
+    createConfig: ({ projectModelWatcher, baseBackendUrl, customLogger }) => {
+      return getViteConfig(
+        model,
+        {
+          type: "dev" /* dev */,
+          https,
+          projectModelWatcher,
+          customLogger
+        },
+        { baseBackendUrl }
+      );
+    }
+  });
+  return createDevServer;
+}
+function useBackendDevServer({ https }) {
+  const { model } = useProjectModel();
+  const { getAppSecret } = useDevCenterClient();
+  const createDevServer = useViteDevServer({
+    createConfig: async ({ projectModelWatcher, customLogger }) => {
+      const appSecret = await getAppSecret({
+        appId: model.config.appId
+      });
+      return getViteConfig2(
+        model,
+        {
+          type: "dev" /* dev */,
+          https,
+          customLogger,
+          projectModelWatcher
+        },
+        appSecret
+      );
+    }
+  });
+  return createDevServer;
+}
+
+// src/context/armTag.tsx
+init_esm_shims();
+var import_react4 = __toESM(require_react(), 1);
+var ArmTagContext = (0, import_react4.createContext)(null);
+var ArmTagProvider = ({
+  children,
+  armTag
+}) => {
+  return /* @__PURE__ */ import_react4.default.createElement(ArmTagContext.Provider, { value: { armTag } }, children);
+};
+var useArmTag = () => {
+  const context = (0, import_react4.useContext)(ArmTagContext);
+  if (context == null) {
+    throw new Error("useArmTag() cannot be used without an <ArmTagProvider>");
+  }
+  return context;
+};
+
+// src/components/DevCommand/useSiteOverrideUpdater.ts
+init_esm_shims();
+var import_react8 = __toESM(require_react(), 1);
+
+// ../site-override-client/src/index.ts
+init_esm_shims();
+
+// ../site-override-client/src/client.ts
+init_esm_shims();
+
+// ../../node_modules/@wix/ambassador-cli-site-override-service-v1-site-override/build/es/http.impl.js
+init_esm_shims();
+var _createOverrideRequest = {};
+var _createOverrideResponse = {};
+function resolveWixCliV1SiteOverrideServiceUrl(opts) {
+  var domainToMappings = {
+    "bo._base_domain_": [
+      {
+        srcPath: "/_serverless/site-override",
+        destPath: ""
+      }
+    ],
+    "wixbo.ai": [
+      {
+        srcPath: "/_serverless/site-override",
+        destPath: ""
+      }
+    ],
+    "wix-bo.com": [
+      {
+        srcPath: "/_serverless/site-override",
+        destPath: ""
+      }
+    ],
+    "manage._base_domain_": [
+      {
+        srcPath: "/_serverless/site-override",
+        destPath: ""
+      }
+    ]
+  };
+  return resolveUrl(Object.assign(opts, { domainToMappings }));
+}
+function createOverride(payload) {
+  var _a = serializer(_createOverrideRequest, {}), toReq = _a.toJSON, fromReq = _a.fromJSON;
+  var fromRes = serializer(_createOverrideResponse, {}).fromJSON;
+  function __createOverride(_a2) {
+    var host = _a2.host;
+    var serializedData = toReq(payload);
+    var metadata = {
+      entityFqdn: "wix.cli.site_override_service.v1.site_override",
+      method: "POST",
+      methodFqn: "wix.cli.v1.SiteOverrideService.CreateOverride",
+      url: resolveWixCliV1SiteOverrideServiceUrl({
+        protoPath: "/v1/site-overrides",
+        data: serializedData,
+        host
+      }),
+      data: serializedData,
+      transformResponse: fromRes
+    };
+    return metadata;
+  }
+  __createOverride.fromReq = fromReq;
+  __createOverride.__isAmbassador = true;
+  return __createOverride;
+}
+
+// ../site-override-client/src/schemas.ts
+init_esm_shims();
+var createOverrideSchema = z.object({
+  siteOverride: z.object({
+    id: z.string()
+  })
+});
+
+// ../site-override-client/src/client.ts
+var SiteOverrideClient = class {
+  constructor(httpClient) {
+    this.httpClient = httpClient;
+    const { minRetryTimeout } = getTestOverrides();
+    this.retryOptions = {
+      retries: 3,
+      minTimeout: minRetryTimeout,
+      maxTimeout: 3 * 1e3
+    };
+  }
+  retryOptions;
+  createOverride = async ({
+    appId,
+    siteId,
+    overrides,
+    siteOverrideId
+  }) => {
+    try {
+      const { data } = await pRetry(
+        () => this.httpClient.request(
+          createOverride({
+            siteOverride: {
+              id: siteOverrideId,
+              appId,
+              siteId,
+              overrides
+            }
+          })
+        ),
+        this.retryOptions
+      );
+      return createOverrideSchema.parse(data).siteOverride;
+    } catch (error) {
+      if (isHttpError(error) && error.response?.status === 403) {
+        if (error.response.data?.details?.applicationError?.code === "PERMISSION_DENIED_FOR_SITE") {
+          throw new CliError({
+            code: CliErrorCode.SitePermissionDenied({ siteId }),
+            cause: error
+          });
+        }
+        throw new CliError({
+          code: CliErrorCode.AppPermissionDenied({ appId }),
+          cause: error
+        });
+      }
+      throw new CliError({
+        code: CliErrorCode.FailedToCreateSiteOverride(),
+        cause: error
+      });
+    }
+  };
+};
+
+// ../site-override-client/src/useSiteOverrideClient.ts
+init_esm_shims();
+var import_react5 = __toESM(require_react(), 1);
+function useSiteOverrideClient() {
+  const httpClient = useHttpClient({ type: "backoffice" });
+  return (0, import_react5.useMemo)(() => new SiteOverrideClient(httpClient), [httpClient]);
+}
+
+// src/site-override/createSiteOverrides.ts
+init_esm_shims();
+var import_variant3 = __toESM(require_lib(), 1);
+
+// ../../node_modules/@wix/ambassador-cli-site-override-service-v1-site-override/build/es/types.impl.js
+init_esm_shims();
+var Type;
+(function(Type2) {
+  Type2["UNKNOWN_TYPE"] = "UNKNOWN_TYPE";
+  Type2["EMBEDDED_SCRIPT"] = "EMBEDDED_SCRIPT";
+})(Type || (Type = {}));
+var WebhookIdentityType;
+(function(WebhookIdentityType2) {
+  WebhookIdentityType2["UNKNOWN"] = "UNKNOWN";
+  WebhookIdentityType2["ANONYMOUS_VISITOR"] = "ANONYMOUS_VISITOR";
+  WebhookIdentityType2["MEMBER"] = "MEMBER";
+  WebhookIdentityType2["WIX_USER"] = "WIX_USER";
+  WebhookIdentityType2["APP"] = "APP";
+})(WebhookIdentityType || (WebhookIdentityType = {}));
+
+// src/site-override/createSiteOverrides.ts
+function createSiteOverrides(model) {
+  const componentsToOverride = model.components.filter(
+    (0, import_variant3.isType)(DevCenterComponent.EmbeddedScript)
+  );
+  if (componentsToOverride.length === 0) {
+    return null;
+  }
+  return componentsToOverride.reduce(
+    (acc, component) => {
+      const paramsOverride = component.paramsOverride ?? {};
+      return {
+        ...acc,
+        [component.id]: {
+          type: Type.EMBEDDED_SCRIPT,
+          componentId: component.id,
+          embeddedScriptOptions: { parameters: paramsOverride }
+        }
+      };
+    },
+    {}
+  );
+}
+
+// src/site/useSite.ts
+init_esm_shims();
+var import_react7 = __toESM(require_react(), 1);
+
+// src/site/context.ts
+init_esm_shims();
+var import_react6 = __toESM(require_react(), 1);
+var SiteContext = (0, import_react6.createContext)(null);
+
+// src/site/useSite.ts
+function useSite() {
+  const context = (0, import_react7.useContext)(SiteContext);
+  if (context == null) {
+    throw new Error("useSite() cannot be used without an <SiteProvider>");
+  }
+  return context;
+}
+
+// src/components/DevCommand/useSiteOverrideUpdater.ts
+function useSiteOverrideUpdater() {
+  const { model } = useProjectModel();
+  const { site } = useSite();
+  const exit = useExit();
+  const writeDebugLog = useDebugLog();
+  const { createOverride: createOverride2 } = useSiteOverrideClient();
+  const { appId } = model.config;
+  const siteRef = (0, import_react8.useRef)(site);
+  const isUpdaterInitialized = (0, import_react8.useRef)(false);
+  (0, import_react8.useEffect)(() => {
+    siteRef.current = site;
+    const updateSiteOverrides = async () => {
+      const overrides = createSiteOverrides(model) ?? {};
+      const appConfig = await readAppConfig(model.projectFolder, writeDebugLog);
+      const siteOverrideId = appConfig?.devSiteOverrideId;
+      if (!siteOverrideId) {
+        throw new CliError({
+          code: CliErrorCode.InvalidSiteOverrideID(),
+          cause: null
+        });
+      }
+      await createOverride2({
+        appId,
+        siteId: site.id,
+        overrides,
+        siteOverrideId
+      });
+    };
+    if (isUpdaterInitialized.current) {
+      updateSiteOverrides().catch(exit);
+    }
+  }, [site]);
+  return (0, import_react8.useCallback)(
+    async ({
+      projectModelWatcher
+    }) => {
+      const appConfig = await readAppConfig(model.projectFolder, writeDebugLog);
+      let overrides = createSiteOverrides(model) ?? {};
+      const { id: siteOverrideId } = await createOverride2({
+        appId,
+        siteId: site.id,
+        overrides,
+        siteOverrideId: appConfig?.devSiteOverrideId
+      });
+      projectModelWatcher.onChange(async (newModel, changeType) => {
+        if (changeType === "model-updated") {
+          const updatedOverrides = createSiteOverrides(newModel) ?? {};
+          if (!deepEqual(overrides, updatedOverrides)) {
+            await createOverride2({
+              appId,
+              siteId: siteRef.current.id,
+              overrides: updatedOverrides,
+              siteOverrideId
+            });
+            overrides = updatedOverrides;
+          }
+        }
+      });
+      if (siteOverrideId !== appConfig?.devSiteOverrideId) {
+        await saveAppConfig(model.projectFolder, {
+          devSiteOverrideId: siteOverrideId
+        }).catch((error) => writeDebugLog(error));
+      }
+      isUpdaterInitialized.current = true;
+      return siteOverrideId;
+    },
+    [model, writeDebugLog, createOverride2, appId, site]
+  );
+}
+
+// src/context/siteOverride.tsx
+init_esm_shims();
+var import_react9 = __toESM(require_react(), 1);
+var SiteOverrideContext = (0, import_react9.createContext)(null);
+var SiteOverrideProvider = ({ children, siteOverrideId }) => {
+  return /* @__PURE__ */ import_react9.default.createElement(SiteOverrideContext.Provider, { value: { siteOverrideId } }, children);
+};
+var useSiteOverrideId = () => {
+  const context = (0, import_react9.useContext)(SiteOverrideContext);
+  if (context == null) {
+    throw new Error(
+      "useSiteOverrideId() cannot be used without an <SiteOverrideProvider>"
+    );
+  }
+  return context;
+};
+
+// src/components/DevCommand/DevEnvironment.tsx
+var DevEnvironmentContext = (0, import_react10.createContext)(null);
+var DevEnvironmentProvider = ({ https, logger, children }) => {
+  const { t } = useTranslation();
+  const { reportError } = useErrorReporter();
+  const { backendComponents, backendComponentsByType } = useBackendComponents();
+  const createClientDevServer = useClientDevServer({ https });
+  const createBackendDevServer = useBackendDevServer({ https });
+  const startTunnel = useTunnel();
+  const createArmUpdater = useArmUpdater();
+  const createSiteOverrideUpdater = useSiteOverrideUpdater();
+  const { watcher: projectModelWatcher } = useProjectModel();
+  const { status } = useAsync(async () => {
+    let backendDevServerUrl;
+    if (backendComponents.length > 0) {
+      backendDevServerUrl = await createBackendDevServer({
+        projectModelWatcher,
+        customLogger: logger
+      }).then(async ({ devServerUrl }) => {
+        let tunnelUrl;
+        if (backendComponentsByType.Event.length > 0 || backendComponentsByType.ServicePlugin.length > 0) {
+          const { url } = await startTunnel(Number(new URL(devServerUrl).port));
+          tunnelUrl = url;
+        }
+        return { localUrl: devServerUrl, tunnelUrl };
+      });
+    }
+    const { devServerUrl: clientDevServerUrl, devServer: clientDevServer } = await createClientDevServer({
+      baseBackendUrl: backendDevServerUrl?.localUrl,
+      projectModelWatcher,
+      customLogger: logger
+    });
+    const armTag = await createArmUpdater({
+      backendServerUrl: backendDevServerUrl,
+      devServerUrl: clientDevServerUrl,
+      projectModelWatcher,
+      onChange(changeType) {
+        (0, import_variant4.match)(changeType, {
+          "change-received": () => {
+            logger.info(t("dev_command.config_change"));
+          },
+          "model-did-not-change": () => {
+            logger.info(t("dev_command.config_didnt_update"));
+          },
+          "model-updated": () => {
+            clientDevServer.ws.send({ type: "full-reload" });
+            logger.info(t("dev_command.config_update"));
+          }
+        });
+      },
+      onError(error) {
+        reportError(error);
+        logger.error(/* @__PURE__ */ import_react10.default.createElement(ErrorViewer, { error }));
+        logger.info(t("dev_command.config_didnt_update"));
+      }
+    });
+    const siteOverrideId = await createSiteOverrideUpdater({
+      projectModelWatcher
+    });
+    logger.info(
+      /* @__PURE__ */ import_react10.default.createElement(Alert, { type: "success" }, t("dev_command.dev_environment.started"))
+    );
+    return {
+      clientDevServerUrl,
+      armTag,
+      siteOverrideId,
+      https
+    };
+  }, []);
+  return (0, import_variant4.match)(status, {
+    Error: () => null,
+    Loading: () => /* @__PURE__ */ import_react10.default.createElement(Spinner, { text: t("dev_command.dev_environment.loading") }),
+    Success: ({
+      result: { clientDevServerUrl, https: https2, armTag, siteOverrideId }
+    }) => /* @__PURE__ */ import_react10.default.createElement(
+      DevEnvironmentContext.Provider,
+      {
+        value: { clientDevServerUrl, https: https2, logger }
+      },
+      /* @__PURE__ */ import_react10.default.createElement(SiteOverrideProvider, { siteOverrideId }, /* @__PURE__ */ import_react10.default.createElement(ArmTagProvider, { armTag }, children))
+    )
+  });
+};
+function useDevEnvironment() {
+  const context = (0, import_react10.useContext)(DevEnvironmentContext);
+  if (context == null) {
+    throw new Error(
+      "useDevEnvironment() cannot be used without an <DevEnvironmentProvider>"
+    );
+  }
+  return context;
+}
+
+// ../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"
+      }
+    ],
+    "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"
+      }
+    ]
+  };
+  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",
+      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 = z.object({
+  id: z.string(),
+  displayName: z.string(),
+  viewUrl: z.union([z.string().url(), z.literal("")]).optional()
+});
+var querySitesSchema = z.object({
+  sites: z.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) => {
+    try {
+      const { data } = await pRetry(
+        () => this.httpClient.request(
+          querySites({ query: { filter: { id: { $in: [id] } } } })
+        ),
+        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_react11 = __toESM(require_react(), 1);
+function useSiteListClient() {
+  const httpClient = useHttpClient({ type: "backoffice" });
+  return (0, import_react11.useMemo)(() => new SiteListClient(httpClient), [httpClient]);
+}
+
+// ../site-list-client/src/index.ts
+init_esm_shims();
+
+// src/site/site-state.ts
+init_esm_shims();
+var import_variant5 = __toESM(require_lib(), 1);
+var SiteState = (0, import_variant5.variant)({
+  NotConfigured: {},
+  NotFound: (0, import_variant5.fields)(),
+  Resolved: (0, import_variant5.fields)()
+});
+
+// src/site/resolve-configured-site.ts
+init_esm_shims();
+async function resolveConfiguredSite({
+  projectFolder,
+  siteListClient: { getSite },
+  siteId,
+  writeDebugLog
+}) {
+  const resolvedSiteId = !siteId ? (await readAppConfig(projectFolder, writeDebugLog))?.siteId : siteId;
+  if (!resolvedSiteId) {
+    return SiteState.NotConfigured();
+  }
+  const site = await getSite(resolvedSiteId);
+  if (!site) {
+    return SiteState.NotFound({ id: resolvedSiteId });
+  }
+  return SiteState.Resolved({ site });
+}
+
+// src/components/extensions/utils.tsx
+init_esm_shims();
+var import_react12 = __toESM(require_react(), 1);
+var import_variant6 = __toESM(require_lib(), 1);
+import { URL as URL2 } from "node:url";
+var redirectWithCSMv2FTs = (url, platformType) => {
+  const elgarBaseURL = (0, import_variant6.isType)(platformType, PlatformType.Site) ? `${url.origin}/_api` : "https://apps.wix.com";
+  const elgarRedirectUrl = new URL2(`${elgarBaseURL}/elgar-server/redirect`);
+  const petriOvr = [
+    "specs.UseAppsRuntimeCache",
+    "specs.ApplyQueryParamsOverrides",
+    "specs.thunderbolt.passWidgetBundleUrls",
+    "specs.blocks-client.useBundledWidgetCode"
+  ];
+  for (const spec of petriOvr) {
+    elgarRedirectUrl.searchParams.append("experiments", `${spec}#true`);
+  }
+  elgarRedirectUrl.searchParams.append("redirectToUrl", url.toString());
+  elgarRedirectUrl.searchParams.append("staticsVersions", "{}");
+  return elgarRedirectUrl;
+};
+function wrapWithRedirectUrl({
+  url,
+  clientDevServerUrl
+}) {
+  const redirectUrl = new URL2("/redirect", clientDevServerUrl);
+  redirectUrl.searchParams.append("url", url);
+  return redirectUrl.href;
+}
+function useResolvePlatformUrl() {
+  const { model } = useProjectModel();
+  const { site } = useSite();
+  const { armTag } = useArmTag();
+  const { siteOverrideId } = useSiteOverrideId();
+  return (0, import_react12.useCallback)(
+    (platformType) => {
+      return resolvePlatformUrl(platformType, {
+        site,
+        appId: model.config.appId,
+        tag: armTag,
+        siteOverrideId
+      });
+    },
+    [site, model.config.appId, armTag, siteOverrideId]
+  );
+}
+function useResolvePlatformDevUrl() {
+  const resolvePlatformUrl2 = useResolvePlatformUrl();
+  const { https, clientDevServerUrl } = useDevEnvironment();
+  return (0, import_react12.useCallback)(
+    (platformType) => {
+      let url = resolvePlatformUrl2(platformType);
+      if (https) {
+        url = wrapWithRedirectUrl({ url, clientDevServerUrl });
+      }
+      return url;
+    },
+    [resolvePlatformUrl2, https, clientDevServerUrl]
+  );
+}
+function resolvePlatformUrl(platformType, options) {
+  const { site, tag, siteOverrideId } = options;
+  const url = (0, import_variant6.match)(platformType, {
+    Dashboard: () => new URL2(`dashboard/${site.id}`, "https://manage.wix.com/"),
+    Editor: () => new URL2(`https://wix.com/editor/${site.id}`),
+    Site: () => {
+      const siteUrl = new URL2(site.viewUrl);
+      if (siteOverrideId) {
+        siteUrl.searchParams.append("site-override", siteOverrideId);
+      }
+      return siteUrl;
+    }
+  });
+  url.searchParams.append("apps-override", tag);
+  return (0, import_variant6.isOfVariant)(
+    platformType,
+    (0, import_variant6.variantList)([PlatformType.Editor, PlatformType.Site])
+  ) ? redirectWithCSMv2FTs(url, platformType).toString() : url.toString();
+}
+function useResolveDashboardExtensionUrl() {
+  const { model } = useProjectModel();
+  const { site } = useSite();
+  const { armTag } = useArmTag();
+  const { siteOverrideId } = useSiteOverrideId();
+  return (0, import_react12.useCallback)(
+    (extension) => {
+      return resolveDashboardExtensionUrl(extension, {
+        site,
+        appId: model.config.appId,
+        tag: armTag,
+        siteOverrideId
+      });
+    },
+    [site, model.config.appId, armTag, siteOverrideId]
+  );
+}
+function useResolveDashboardExtensionDevUrl() {
+  const resolveDashboardExtensionUrl2 = useResolveDashboardExtensionUrl();
+  const { https, clientDevServerUrl } = useDevEnvironment();
+  return (0, import_react12.useCallback)(
+    (extension) => {
+      let url = resolveDashboardExtensionUrl2(extension);
+      if (https) {
+        url = wrapWithRedirectUrl({ url, clientDevServerUrl });
+      }
+      return url;
+    },
+    [resolveDashboardExtensionUrl2, https, clientDevServerUrl]
+  );
+}
+function resolveDashboardExtensionUrl(extension, options) {
+  const { appId, site, tag } = options;
+  const url = (0, import_variant6.matcher)(extension).with({
+    DashboardPage: () => new URL2(
+      `dashboard/${site.id}/app/${appId}${extension.route}`,
+      "https://manage.wix.com/"
+    )
+  }).when(
+    ["DashboardMenuPlugin", "DashboardPlugin", "DashboardModal"],
+    () => new URL2(
+      `dashboard/${site.id}${extension.route}`,
+      "https://manage.wix.com/"
+    )
+  ).complete();
+  url.searchParams.append("apps-override", tag);
+  return url.toString();
+}
+var useOpenPage = () => {
+  const { logger } = useDevEnvironment();
+  return (0, import_react12.useCallback)(
+    async ({ url, title }) => {
+      try {
+        await openBrowser(url);
+      } catch {
+        logger.error(
+          /* @__PURE__ */ import_react12.default.createElement(Alert, { type: "error" }, /* @__PURE__ */ import_react12.default.createElement(
+            Trans,
+            {
+              i18nKey: "general.open_page_error",
+              components: [/* @__PURE__ */ import_react12.default.createElement(Text, { bold: true })],
+              values: { title }
+            }
+          ), /* @__PURE__ */ import_react12.default.createElement(Newline, null), /* @__PURE__ */ import_react12.default.createElement(Link, { url }))
+        );
+      }
+    },
+    [logger]
+  );
+};
+
+export {
+  SiteListClient,
+  useSiteListClient,
+  SiteContext,
+  SiteState,
+  resolveConfiguredSite,
+  ARMClient,
+  useARMClient,
+  ArmTagProvider,
+  useArmTag,
+  useSiteOverrideClient,
+  createSiteOverrides,
+  useSite,
+  SiteOverrideProvider,
+  DevEnvironmentProvider,
+  useDevEnvironment,
+  redirectWithCSMv2FTs,
+  useResolvePlatformUrl,
+  useResolvePlatformDevUrl,
+  resolvePlatformUrl,
+  useResolveDashboardExtensionUrl,
+  useResolveDashboardExtensionDevUrl,
+  resolveDashboardExtensionUrl,
+  useOpenPage
+};
+//# sourceMappingURL=chunk-3KMSVIRS.js.map