webstudio 0.105.0

package/lib/cli.js

@@ -0,0 +1,875 @@
+// src/cli.ts
+import { exit, argv } from "node:process";
+import { hideBin } from "yargs/helpers";
+
+// src/config.ts
+import { join } from "node:path";
+import envPaths from "env-paths";
+import { z } from "zod";
+var GLOBAL_CONFIG_FOLDER = envPaths("webstudio").config;
+var GLOBAL_CONFIG_FILE_NAME = "webstudio-config.json";
+var GLOBAL_CONFIG_FILE = join(
+  GLOBAL_CONFIG_FOLDER,
+  GLOBAL_CONFIG_FILE_NAME
+);
+var LOCAL_CONFIG_FILE = ".webstudio/config.json";
+var LOCAL_DATA_FILE = ".webstudio/data.json";
+var zLocalConfig = z.object({
+  projectId: z.string()
+});
+var jsonToLocalConfig = (json) => {
+  return zLocalConfig.parse(json);
+};
+var zGlobalConfig = z.record(
+  z.union([
+    z.object({
+      // origin mistakenly called host in the past
+      host: z.string(),
+      token: z.string()
+    }),
+    z.object({
+      origin: z.string(),
+      token: z.string()
+    })
+  ]).transform((value) => {
+    if ("host" in value) {
+      return {
+        origin: value.host,
+        token: value.token
+      };
+    }
+    return value;
+  })
+);
+var jsonToGlobalConfig = (json) => {
+  return zGlobalConfig.parse(json);
+};
+var PROJECT_TEMPALTES = [
+  "vercel",
+  "netlify-functions",
+  "netlify-edge-functions"
+];
+
+// src/fs-utils.ts
+import { dirname } from "node:path";
+import {
+  access,
+  mkdir,
+  writeFile,
+  constants,
+  readFile
+} from "node:fs/promises";
+var isFileExists = async (filePath) => {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var ensureFileInPath = async (filePath, content) => {
+  const dir = dirname(filePath);
+  await ensureFolderExists(dir);
+  try {
+    await access(filePath, constants.F_OK);
+  } catch {
+    await writeFile(filePath, content || "", "utf8");
+  }
+};
+var ensureFolderExists = async (folderPath) => {
+  try {
+    await access(folderPath, constants.F_OK);
+  } catch {
+    await mkdir(folderPath, { recursive: true });
+  }
+};
+var loadJSONFile = async (filePath) => {
+  try {
+    const content = await readFile(filePath, "utf8");
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+};
+
+// src/commands/link.ts
+import { stdin, stdout, cwd } from "node:process";
+import { join as join2 } from "node:path";
+import * as readline from "node:readline/promises";
+import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+var linkOptions = (yargs) => yargs.option("link", {
+  alias: "l",
+  type: "string",
+  describe: "Link to a webstudio project"
+});
+var link = async (options) => {
+  let shareLink;
+  if (options.link) {
+    shareLink = options.link;
+  } else {
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    shareLink = await rl.question(
+      `Please paste a link from the Share Dialog in the builder: `
+    );
+    rl.close();
+  }
+  const shareLinkUrl = new URL(shareLink);
+  const origin = shareLinkUrl.origin;
+  const token = shareLinkUrl.searchParams.get("authToken");
+  const paths = shareLinkUrl.pathname.split("/").slice(1);
+  if (paths[0] !== "builder" || paths.length !== 2) {
+    throw new Error("Invalid share link.");
+  }
+  const projectId = paths[1];
+  if (token == null) {
+    throw new Error("Invalid share link.");
+  }
+  try {
+    const currentConfig = await readFile2(GLOBAL_CONFIG_FILE, "utf-8");
+    const currentConfigJson = jsonToGlobalConfig(JSON.parse(currentConfig));
+    const newConfig = {
+      ...currentConfigJson,
+      [projectId]: {
+        origin,
+        token
+      }
+    };
+    await writeFile2(GLOBAL_CONFIG_FILE, JSON.stringify(newConfig, null, 2));
+    console.info(`Saved credentials for project ${projectId}.
+  You can find your config at ${GLOBAL_CONFIG_FILE}
+        `);
+    const localConfig = {
+      projectId
+    };
+    await ensureFileInPath(
+      join2(cwd(), LOCAL_CONFIG_FILE),
+      JSON.stringify(localConfig, null, 2)
+    );
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENONET") {
+      throw new Error(`Global config file is not found`);
+    }
+    throw error;
+  }
+};
+
+// src/commands/sync.ts
+import { readFile as readFile3, writeFile as writeFile3 } from "node:fs/promises";
+import { cwd as cwd2 } from "node:process";
+import { join as join3 } from "node:path";
+import ora from "ora";
+import {
+  loadProjectDataByBuildId,
+  loadProjectDataById
+} from "@webstudio-is/http-client";
+import pc from "picocolors";
+var syncOptions = (yargs) => yargs.option("buildId", {
+  type: "string",
+  describe: "[Experimental] Project build id to sync"
+}).option("origin", {
+  type: "string",
+  describe: "[Experimental] Remote origin to sync with"
+}).option("authToken", {
+  type: "string",
+  describe: "[Experimental] Service token"
+});
+var sync = async (options) => {
+  const spinner = ora("Syncing project data").start();
+  spinner.text = "Loading project data from config file";
+  const definedOptionValues = [
+    options.buildId,
+    options.origin,
+    options.authToken
+  ].filter(Boolean);
+  if (definedOptionValues.length > 0 && definedOptionValues.length < 3) {
+    spinner.fail(`Please provide buildId, origin and authToken`);
+    return;
+  }
+  let project;
+  if (options.buildId !== void 0 && options.origin !== void 0 && options.authToken !== void 0) {
+    project = await loadProjectDataByBuildId({
+      buildId: options.buildId,
+      authToken: options.authToken,
+      origin: options.origin
+    });
+  } else {
+    if (await isFileExists(GLOBAL_CONFIG_FILE) === false) {
+      spinner.fail(
+        `Global config file at path ${GLOBAL_CONFIG_FILE} is not found. Please link your project using webstudio link command`
+      );
+      return;
+    }
+    const globalConfigText = await readFile3(GLOBAL_CONFIG_FILE, "utf-8");
+    const globalConfig = jsonToGlobalConfig(JSON.parse(globalConfigText));
+    if (await isFileExists(LOCAL_CONFIG_FILE) === false) {
+      spinner.fail(
+        `Local config file is not found. Please make sure current directory is a webstudio project`
+      );
+      return;
+    }
+    const localConfigText = await readFile3(
+      join3(cwd2(), LOCAL_CONFIG_FILE),
+      "utf-8"
+    );
+    const localConfig = jsonToLocalConfig(JSON.parse(localConfigText));
+    const projectConfig = globalConfig[localConfig.projectId];
+    if (projectConfig === void 0) {
+      spinner.fail(
+        `Project config is not found, please run ${pc.dim("webstudio link")}`
+      );
+      return;
+    }
+    const { origin, token } = projectConfig;
+    spinner.text = "Loading project data from webstudio\n";
+    project = await loadProjectDataById({
+      projectId: localConfig.projectId,
+      authToken: token,
+      origin
+    });
+  }
+  project;
+  spinner.text = "Saving project data to config file";
+  const localBuildFilePath = join3(cwd2(), LOCAL_DATA_FILE);
+  await ensureFileInPath(localBuildFilePath);
+  await writeFile3(localBuildFilePath, JSON.stringify(project, null, 2), "utf8");
+  spinner.succeed("Project data synced successfully");
+};
+
+// src/commands/build.ts
+import { access as access3 } from "node:fs/promises";
+
+// src/prebuild.ts
+import { basename, dirname as dirname2, join as join4, normalize } from "node:path";
+import { createWriteStream } from "node:fs";
+import {
+  rm,
+  access as access2,
+  mkdtemp,
+  rename,
+  cp,
+  readFile as readFile4,
+  writeFile as writeFile4,
+  readdir
+} from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import { tmpdir } from "node:os";
+import { cwd as cwd3 } from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import pLimit from "p-limit";
+import ora2 from "ora";
+import merge from "deepmerge";
+import {
+  generateCssText,
+  generateUtilsExport,
+  generatePageComponent,
+  getIndexesWithinAncestors,
+  namespaceMeta,
+  normalizeProps
+} from "@webstudio-is/react-sdk";
+import {
+  createScope,
+  findTreeInstanceIds,
+  parseComponentName
+} from "@webstudio-is/sdk";
+import { createImageLoader } from "@webstudio-is/image";
+import * as baseComponentMetas from "@webstudio-is/sdk-components-react/metas";
+import * as remixComponentMetas from "@webstudio-is/sdk-components-react-remix/metas";
+import * as radixComponentMetas from "@webstudio-is/sdk-components-react-radix/metas";
+var limit = pLimit(10);
+var downloadAsset = async (url, name, assetBaseUrl, temporaryDir) => {
+  const assetPath = join4("public", assetBaseUrl, name);
+  const tempAssetPath = join4(temporaryDir, name);
+  try {
+    await access2(assetPath);
+  } catch {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+      }
+      const writableStream = createWriteStream(tempAssetPath);
+      await pipeline(
+        response.body,
+        writableStream
+      );
+      await ensureFolderExists(dirname2(assetPath));
+      await rename(tempAssetPath, assetPath);
+    } catch (error) {
+      console.error(`Error in downloading file ${name} 
+ ${error}`);
+    }
+  }
+};
+var mergeJsonFiles = async (sourcePath, destinationPath) => {
+  const sourceJson = await readFile4(sourcePath, "utf8");
+  const destinationJson = await readFile4(destinationPath, "utf8").catch(
+    (error) => {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return "{}";
+      }
+      throw new Error(error);
+    }
+  );
+  const content = JSON.stringify(
+    merge(JSON.parse(sourceJson), JSON.parse(destinationJson)),
+    null,
+    "  "
+  );
+  await writeFile4(destinationPath, content, "utf8");
+};
+var isCliTemplate = async (template) => {
+  const currentPath = fileURLToPath(new URL(import.meta.url));
+  const templatesPath = normalize(
+    join4(dirname2(currentPath), "..", "templates")
+  );
+  const dirents = await readdir(templatesPath, { withFileTypes: true });
+  for (const dirent of dirents) {
+    if (dirent.isDirectory() && dirent.name === template) {
+      return true;
+    }
+  }
+  return false;
+};
+var copyTemplates = async (template = "defaults") => {
+  const currentPath = fileURLToPath(new URL(import.meta.url));
+  const templatesPath = await isCliTemplate(template) ? normalize(join4(dirname2(currentPath), "..", "templates", template)) : template;
+  await cp(templatesPath, cwd3(), {
+    recursive: true,
+    filter: (source) => {
+      return basename(source) !== "package.json";
+    }
+  });
+  if (await isFileExists(join4(templatesPath, "package.json")) === true) {
+    await mergeJsonFiles(
+      join4(templatesPath, "package.json"),
+      join4(cwd3(), "package.json")
+    );
+  }
+};
+var prebuild = async (options) => {
+  if (options.template !== void 0 && await isCliTemplate(options.template) === false && options.template.startsWith(".") === false) {
+    throw Error(
+      `
+ Template ${options.template} is not available 
+ Please check webstudio --help for more details`
+    );
+  }
+  const spinner = ora2("Scaffolding the project files");
+  spinner.start();
+  spinner.text = "Generating files";
+  await copyTemplates();
+  if (options.template !== void 0) {
+    await copyTemplates(options.template);
+  }
+  const constants2 = await import(pathToFileURL(join4(cwd3(), "app/constants.mjs")).href);
+  const { assetBaseUrl } = constants2;
+  const siteData = await loadJSONFile(LOCAL_DATA_FILE);
+  if (siteData === null) {
+    throw new Error(
+      `Project data is missing, please make sure you the project is synced.`
+    );
+  }
+  const domain = siteData.build.deployment?.projectDomain;
+  if (domain === void 0) {
+    throw new Error(`Project domain is missing from the site data`);
+  }
+  const remixRoutes = {
+    routes: []
+  };
+  const radixComponentNamespacedMetas = Object.entries(
+    radixComponentMetas
+  ).reduce(
+    (r, [name, meta]) => {
+      const namespace = "@webstudio-is/sdk-components-react-radix";
+      r[`${namespace}:${name}`] = namespaceMeta(
+        meta,
+        namespace,
+        new Set(Object.keys(radixComponentMetas))
+      );
+      return r;
+    },
+    {}
+  );
+  const metas = new Map(
+    Object.entries({
+      ...baseComponentMetas,
+      ...radixComponentNamespacedMetas,
+      ...remixComponentMetas
+    })
+  );
+  const projectMetas = /* @__PURE__ */ new Map();
+  const componentsByPage = {};
+  const siteDataByPage = {};
+  for (const page of Object.values(siteData.pages)) {
+    const originPath = page.path;
+    const path = originPath === "" ? "index" : originPath.replace("/", "");
+    if (path !== "index") {
+      remixRoutes.routes.push({
+        path: originPath === "" ? "/" : originPath,
+        file: `routes/${path}.tsx`
+      });
+    }
+    const instanceMap = new Map(siteData.build.instances);
+    const pageInstanceSet = findTreeInstanceIds(
+      instanceMap,
+      page.rootInstanceId
+    );
+    const instances = siteData.build.instances.filter(([id]) => pageInstanceSet.has(id));
+    const dataSources = [];
+    const normalizedProps = normalizeProps({
+      props: siteData.build.props.map(([_id, prop]) => prop),
+      assetBaseUrl,
+      assets: new Map(siteData.assets.map((asset) => [asset.id, asset])),
+      pages: new Map(siteData.pages.map((page2) => [page2.id, page2]))
+    });
+    const props = [];
+    for (const prop of normalizedProps) {
+      if (pageInstanceSet.has(prop.instanceId)) {
+        props.push([prop.id, prop]);
+      }
+    }
+    for (const [dataSourceId, dataSource] of siteData.build.dataSources) {
+      if (dataSource.scopeInstanceId === void 0 || pageInstanceSet.has(dataSource.scopeInstanceId)) {
+        dataSources.push([dataSourceId, dataSource]);
+      }
+    }
+    siteDataByPage[path] = {
+      build: {
+        props,
+        instances,
+        dataSources
+      },
+      pages: siteData.pages,
+      page,
+      assets: siteData.assets
+    };
+    componentsByPage[path] = /* @__PURE__ */ new Set();
+    for (const [_instanceId, instance] of instances) {
+      if (instance.component) {
+        componentsByPage[path].add(instance.component);
+        const meta = metas.get(instance.component);
+        if (meta) {
+          projectMetas.set(instance.component, meta);
+        }
+      }
+    }
+  }
+  const assetsToDownload = [];
+  const fontAssets = [];
+  const appDomain = options.preview ? "wstd.work" : "wstd.io";
+  const assetBuildUrl = `https://${domain}.${appDomain}/cgi/asset/`;
+  const temporaryDir = await mkdtemp(join4(tmpdir(), "webstudio-"));
+  const imageLoader = createImageLoader({
+    imageBaseUrl: assetBuildUrl
+  });
+  if (options.assets === true) {
+    for (const asset of siteData.assets) {
+      if (asset.type === "image") {
+        const imageSrc = imageLoader({
+          width: 16,
+          quality: 100,
+          src: asset.name,
+          format: "raw"
+        });
+        assetsToDownload.push(
+          limit(
+            () => downloadAsset(imageSrc, asset.name, assetBaseUrl, temporaryDir)
+          )
+        );
+      }
+      if (asset.type === "font") {
+        assetsToDownload.push(
+          limit(
+            () => downloadAsset(
+              `${assetBuildUrl}${asset.name}`,
+              asset.name,
+              assetBaseUrl,
+              temporaryDir
+            )
+          )
+        );
+        fontAssets.push(asset);
+      }
+    }
+  }
+  spinner.text = "Generating routes and pages";
+  const appRoot = "app";
+  const generatedDir = join4(appRoot, "__generated__");
+  await rm(generatedDir, { recursive: true, force: true });
+  const routesDir = join4(appRoot, "routes");
+  await rm(routesDir, { recursive: true, force: true });
+  const routeFileTemplate = await readFile4(
+    normalize(
+      join4(
+        dirname2(fileURLToPath(new URL(import.meta.url))),
+        "..",
+        "templates",
+        "route-template.tsx"
+      )
+    ),
+    "utf8"
+  );
+  for (const [pathName, pageComponents] of Object.entries(componentsByPage)) {
+    const scope = createScope([
+      // manually maintained list of occupied identifiers
+      "useState",
+      "ReactNode",
+      "PageData",
+      "Asset",
+      "fontAssets",
+      "pageData",
+      "user",
+      "projectId",
+      "formsProperties",
+      "Page",
+      "props"
+    ]);
+    const namespaces = /* @__PURE__ */ new Map();
+    const BASE_NAMESPACE = "@webstudio-is/sdk-components-react";
+    const REMIX_NAMESPACE = "@webstudio-is/sdk-components-react-remix";
+    for (const component of pageComponents) {
+      const parsed = parseComponentName(component);
+      let [namespace] = parsed;
+      const [_namespace, shortName] = parsed;
+      if (namespace === void 0) {
+        if (shortName in remixComponentMetas) {
+          namespace = REMIX_NAMESPACE;
+        } else {
+          namespace = BASE_NAMESPACE;
+        }
+      }
+      if (namespaces.has(namespace) === false) {
+        namespaces.set(
+          namespace,
+          /* @__PURE__ */ new Set()
+        );
+      }
+      namespaces.get(namespace)?.add([shortName, component]);
+    }
+    let componentImports = "";
+    for (const [namespace, componentsSet] of namespaces.entries()) {
+      const specifiers = Array.from(componentsSet).map(
+        ([shortName, component]) => `${shortName} as ${scope.getName(component, shortName)}`
+      ).join(", ");
+      componentImports += `import { ${specifiers} } from "${namespace}";
+`;
+    }
+    const pageData = siteDataByPage[pathName];
+    const renderedPageData = {
+      page: pageData.page
+    };
+    const rootInstanceId = pageData.page.rootInstanceId;
+    const instances = new Map(pageData.build.instances);
+    const props = new Map(pageData.build.props);
+    const dataSources = new Map(pageData.build.dataSources);
+    const utilsExport = generateUtilsExport({
+      pages: siteData.build.pages,
+      props
+    });
+    const pageComponent = generatePageComponent({
+      scope,
+      rootInstanceId,
+      instances,
+      props,
+      dataSources,
+      indexesWithinAncestors: getIndexesWithinAncestors(
+        projectMetas,
+        instances,
+        [rootInstanceId]
+      )
+    });
+    const pageExports = `/* eslint-disable */
+/* This is a auto generated file for building the project */ 
+
+import { type ReactNode, useState } from "react";
+import type { PageData } from "~/routes/_index";
+import type { Asset } from "@webstudio-is/sdk";
+${componentImports}
+export const fontAssets: Asset[] = ${JSON.stringify(fontAssets)}
+export const pageData: PageData = ${JSON.stringify(renderedPageData)};
+export const user: { email: string | null } | undefined = ${JSON.stringify(
+      siteData.user
+    )};
+export const projectId = "${siteData.build.projectId}";
+
+${pageComponent}
+
+export { Page }
+
+${utilsExport}
+`;
+    const fileName = pathName === "main" || pathName === "index" ? "_index.tsx" : `${pathName.split("/").map((route) => `[${route}]`).join(".")}._index.tsx`;
+    const routeFileContent = routeFileTemplate.replace(
+      "../__generated__/index",
+      `../__generated__/${fileName}`
+    );
+    await ensureFileInPath(join4(routesDir, fileName), routeFileContent);
+    await ensureFileInPath(join4(generatedDir, fileName), pageExports);
+  }
+  spinner.text = "Generating css file";
+  const cssText = generateCssText(
+    {
+      assets: siteData.assets,
+      breakpoints: siteData.build?.breakpoints,
+      styles: siteData.build?.styles,
+      styleSourceSelections: siteData.build?.styleSourceSelections,
+      // pass only used metas to not generate unused preset styles
+      componentMetas: projectMetas
+    },
+    {
+      assetBaseUrl
+    }
+  );
+  await ensureFileInPath(join4(generatedDir, "index.css"), cssText);
+  spinner.text = "Downloading fonts and images";
+  await Promise.all(assetsToDownload);
+  spinner.succeed("Build finished");
+};
+
+// src/commands/build.ts
+var buildOptions = (yargs) => yargs.option("assets", {
+  type: "boolean",
+  default: true,
+  describe: "[Experimental] Download assets"
+}).option("preview", {
+  type: "boolean",
+  default: false,
+  describe: "[Experimental] Use preview version of the project"
+}).option("template", {
+  type: "string",
+  default: "vercel",
+  describe: `[Experimental] Template to use for the build [choices: ${PROJECT_TEMPALTES.toString()}]`
+});
+var build = async (options) => {
+  try {
+    await access3(LOCAL_DATA_FILE);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      throw new Error(
+        `You need to link a webstudio project before building it. Run \`webstudio link\` to link a project.`
+      );
+    }
+    throw error;
+  }
+  await prebuild(options);
+};
+
+// src/commands/init-flow.ts
+import { chdir, cwd as cwd4 } from "node:process";
+import { join as join5 } from "node:path";
+import ora3 from "ora";
+
+// src/prompts.ts
+import prompts from "prompts";
+var prompt = (prompt2) => {
+  return prompts([
+    {
+      ...prompt2,
+      onState: (state) => {
+        if (state.aborted) {
+          process.nextTick(() => {
+            process.exit(0);
+          });
+        }
+      }
+    }
+  ]);
+};
+
+// src/commands/init-flow.ts
+import pc2 from "picocolors";
+import { $ } from "execa";
+import { titleCase } from "title-case";
+var initFlow = async (options) => {
+  const isProjectConfigured = await isFileExists(".webstudio/config.json");
+  let shouldInstallDeps = false;
+  let folderName;
+  let projectTemplate = void 0;
+  if (isProjectConfigured === false) {
+    const { shouldCreateFolder } = await prompt({
+      type: "confirm",
+      name: "shouldCreateFolder",
+      message: "Would you like to create a project folder? (no to use current folder)",
+      initial: true
+    });
+    if (shouldCreateFolder === true) {
+      folderName = (await prompt({
+        type: "text",
+        name: "folderName",
+        message: "Please enter a project name"
+      })).folderName;
+      if (folderName === void 0) {
+        throw new Error("Folder name is required");
+      }
+      await ensureFolderExists(join5(cwd4(), folderName));
+      chdir(join5(cwd4(), folderName));
+    }
+    const { projectLink } = await prompt({
+      type: "text",
+      name: "projectLink",
+      message: "Please paste a link from the Share dialog in the builder"
+    });
+    if (projectLink === void 0) {
+      throw new Error(`Project Link is required`);
+    }
+    await link({ link: projectLink });
+    const { shouldSetupDeployTarget } = await prompt({
+      type: "confirm",
+      name: "shouldSetupDeployTarget",
+      message: "Would you like to setup a deploy target?",
+      initial: false
+    });
+    if (shouldSetupDeployTarget === true) {
+      const { deployTarget } = await prompt({
+        type: "select",
+        name: "deployTarget",
+        message: "Where would you like to deploy your project?",
+        choices: PROJECT_TEMPALTES.map((template) => {
+          return {
+            title: titleCase(template),
+            value: template
+          };
+        })
+      });
+      projectTemplate = deployTarget;
+    }
+    const { installDeps } = await prompt({
+      type: "confirm",
+      name: "installDeps",
+      message: "Would you like to install dependencies? (recommended)",
+      initial: true
+    });
+    shouldInstallDeps = installDeps;
+  }
+  await sync({ buildId: void 0, origin: void 0, authToken: void 0 });
+  await build({
+    ...options,
+    ...projectTemplate && { template: projectTemplate }
+  });
+  if (shouldInstallDeps === true) {
+    const spinner = ora3().start();
+    spinner.text = "Installing dependencies";
+    await $`npm install`;
+    spinner.succeed("Installed dependencies");
+  }
+  console.info(pc2.bold(pc2.green(`
+Your project was successfully synced \u{1F389}`)));
+  console.info(
+    [
+      "Now you can:",
+      folderName && `Go to your project: ${pc2.dim(`cd ${folderName}`)}`,
+      `Run ${pc2.dim("npm run dev")} to preview your site on a local server.`,
+      projectTemplate && getDeploymentInstructions(projectTemplate)
+    ].filter(Boolean).join("\n")
+  );
+};
+var getDeploymentInstructions = (deployTarget) => {
+  switch (deployTarget) {
+    case "vercel":
+      return `Run ${pc2.dim("npx vercel")} to publish on Vercel.`;
+    case "netlify-functions":
+    case "netlify-edge-functions":
+      return [
+        `To deploy to Netlify, run the following commands: `,
+        `Run ${pc2.dim("npx netlify-cli login")} to login to Netlify.`,
+        `Run ${pc2.dim("npx netlify-cli sites:create")} to create a new site.`,
+        `Run ${pc2.dim("npx netlify-cli build")} to build the site`,
+        `Run ${pc2.dim("npx netlify-cli deploy")} to deploy on Netlify.`
+      ].join("\n");
+  }
+};
+
+// src/cli.ts
+import makeCLI from "yargs";
+
+// package.json
+var package_default = {
+  name: "webstudio",
+  version: "0.105.0",
+  description: "Webstudio CLI",
+  author: "Webstudio <github@webstudio.is>",
+  homepage: "https://webstudio.is",
+  type: "module",
+  bin: {
+    "webstudio-cli": "./bin.js",
+    webstudio: "./bin.js"
+  },
+  files: [
+    "lib/*",
+    "templates/*",
+    "bin.js",
+    "!*.{test,stories}.*"
+  ],
+  scripts: {
+    typecheck: "tsc",
+    checks: "pnpm typecheck",
+    build: "rm -rf lib && esbuild src/cli.ts --outdir=lib --bundle --format=esm --packages=external",
+    "local-run": "tsx --no-warnings ./src/bin.ts",
+    dev: "esbuild src/cli.ts --watch --bundle --format=esm --packages=external --outdir=./lib"
+  },
+  license: "AGPL-3.0-or-later",
+  dependencies: {
+    "@webstudio-is/http-client": "workspace:*",
+    "@webstudio-is/image": "workspace:*",
+    "@webstudio-is/react-sdk": "workspace:*",
+    "@webstudio-is/sdk": "workspace:*",
+    "@webstudio-is/sdk-components-react": "workspace:*",
+    "@webstudio-is/sdk-components-react-radix": "workspace:*",
+    "@webstudio-is/sdk-components-react-remix": "workspace:*",
+    deepmerge: "^4.3.1",
+    "env-paths": "^3.0.0",
+    execa: "^7.2.0",
+    ora: "^7.0.1",
+    "p-limit": "^4.0.0",
+    picocolors: "^1.0.0",
+    prompts: "^2.4.2",
+    "strip-indent": "^4.0.0",
+    "title-case": "^4.1.0",
+    yargs: "^17.7.2",
+    zod: "^3.21.4"
+  },
+  devDependencies: {
+    "@types/node": "^18.17.1",
+    "@types/prompts": "^2.4.5",
+    "@webstudio-is/form-handlers": "workspace:*",
+    "@webstudio-is/tsconfig": "workspace:*",
+    tsx: "^3.12.8",
+    typescript: "5.2.2"
+  }
+};
+
+// src/cli.ts
+var main = async () => {
+  try {
+    await ensureFileInPath(GLOBAL_CONFIG_FILE, "{}");
+    const cmd = makeCLI(hideBin(argv)).strict().fail(function(msg, err, yargs) {
+      if (err) {
+        throw err;
+      }
+      console.error(msg);
+      console.error(yargs.help());
+      process.exit(1);
+    }).wrap(null).option("v", {
+      describe: "Show version number",
+      type: "boolean"
+    }).option("h", {
+      describe: "Show all commands",
+      alias: "help",
+      type: "boolean"
+    }).scriptName("webstudio").usage(
+      `Webstudio CLI (${package_default.version}) allows you to setup, sync, build and preview your project.`
+    );
+    cmd.version(package_default.version).alias("v", "version");
+    cmd.command(["build"], "Build the project", buildOptions, build);
+    cmd.command(["link"], "Link the project with the cloud", linkOptions, link);
+    cmd.command(["sync"], "Sync your project", syncOptions, sync);
+    cmd.command(["$0", "init"], "Setup the project", buildOptions, initFlow);
+    await cmd.parse();
+  } catch (error) {
+    console.error(error);
+    exit(1);
+  }
+};
+export {
+  main
+};