@multiplatform.one/cli 2.1.7 → 2.1.8

package/lib/bin/multiplatformOne.mjs

@@ -1,43 +1,68 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/bin/multiplatformOne.ts
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import axios from "axios";
+import {
+  formatServiceList,
+  projectRoot,
+  waitForApi,
+  waitForFrappe,
+  waitForKeycloak,
+  waitForPostgres,
+  waitServices
+} from "@multiplatform.one/utils/dev";
 import { program } from "commander";
 import dotenv from "dotenv";
 import { execa } from "execa";
 import inquirer from "inquirer";
 import ora from "ora";
-import pg from "pg";
-var availableBackends = [
-  "api",
-  "frappe"
-];
+var availableServices = ["api", "frappe", "solana", "ethereum", "sui"];
+var defaultDotenvPath = path.resolve(projectRoot, ".env");
 var availablePlatforms = [
   "electron",
   "expo",
   "keycloak",
-  "next",
+  "one",
   "storybook",
-  "storybook-expo"
+  "storybook-expo",
+  "vocs",
+  "vscode",
+  "webext"
 ];
-process.env.COOKIECUTTER = `sh ${path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/cookiecutter.sh")}`;
+process.env.COOKIECUTTER = `sh ${path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "../../scripts/cookiecutter.sh"
+)}`;
 program.name("multiplatform.one");
-program.version(JSON.parse(fsSync.readFileSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../package.json"), "utf8"))?.version);
-program.command("init").option("-r, --remote <remote>", "the remote to use", "https://gitlab.com/bitspur/multiplatform.one/cookiecutter").option("-c, --checkout <branch>", "branch, tag or commit to checkout", "main").option("-p, --platforms <platforms>", "platforms to keep").option("-b, --backends <backends>", "backends to keep").argument("[name]", "the name of the project", "").description("init multiplatform.one").action(async (name, options) => {
-  let { backends, platforms } = options;
-  if ((await execa("git", [
-    "rev-parse",
-    "--is-inside-work-tree"
-  ], {
+program.version(
+  JSON.parse(
+    fsSync.readFileSync(
+      path.resolve(
+        path.dirname(fileURLToPath(import.meta.url)),
+        "../../package.json"
+      ),
+      "utf8"
+    )
+  )?.version
+);
+program.command("init").option(
+  "-r, --remote <remote>",
+  "the remote to use",
+  "https://gitlab.com/bitspur/multiplatform.one/cookiecutter"
+).option(
+  "-c, --checkout <branch>",
+  "branch, tag or commit to checkout",
+  "main"
+).option("-p, --platforms <platforms>", "platforms to use").option("-s, --services <services>", "services to use").argument("[name]", "the name of the project", "").description("init multiplatform.one").action(async (name, options) => {
+  let { services, platforms } = options;
+  if ((await execa("git", ["rev-parse", "--is-inside-work-tree"], {
     reject: false
   })).exitCode === 0) {
-    throw new Error("multiplatform.one cannot be initialized inside a git repository");
+    throw new Error(
+      "multiplatform.one cannot be initialized inside a git repository"
+    );
   }
   if (!name) {
     name = (await inquirer.prompt([
@@ -48,18 +73,16 @@ program.command("init").option("-r, --remote <remote>", "the remote to use", "ht
       }
     ])).name;
   }
-  if (!backends) {
-    const backendsResult = (await inquirer.prompt([
+  if (!services) {
+    const servicesResult = (await inquirer.prompt([
       {
-        message: "What backends are you using?",
-        name: "backends",
+        message: "What services are you using?",
+        name: "services",
         type: "checkbox",
-        choices: availableBackends.map((name2) => ({
-          name: name2
-        }))
+        choices: availableServices.map((name2) => ({ name: name2 }))
       }
-    ])).backends;
-    backends = backendsResult.join(",");
+    ])).services;
+    services = servicesResult.join(",");
   }
   if (!platforms) {
     const platformsResult = (await inquirer.prompt([
@@ -67,56 +90,66 @@ program.command("init").option("-r, --remote <remote>", "the remote to use", "ht
         message: "What platforms are you using?",
         name: "platforms",
         type: "checkbox",
-        choices: availablePlatforms.map((name2) => ({
-          name: name2
-        }))
+        choices: availablePlatforms.map((name2) => ({ name: name2 }))
       }
     ])).platforms;
     platforms = platformsResult.join(",");
   }
   const cookieCutterConfig = {
-    default_context: {
-      name,
-      platforms,
-      backends
-    }
+    default_context: { name, platforms, services }
   };
-  const cookieCutterConfigFile = path.join(await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")), "config.json");
+  const cookieCutterConfigFile = path.join(
+    await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")),
+    "config.json"
+  );
   try {
-    await fs.writeFile(cookieCutterConfigFile, JSON.stringify(cookieCutterConfig, null, 2));
-    await execa("sh", [
-      path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/init.sh"),
-      "--no-input",
-      "-f",
-      "--config-file",
+    await fs.writeFile(
       cookieCutterConfigFile,
-      "--checkout",
-      options.checkout,
-      options.remote
-    ], {
-      stdio: "inherit"
-    });
+      JSON.stringify(cookieCutterConfig, null, 2)
+    );
+    await execa(
+      "sh",
+      [
+        path.resolve(
+          path.dirname(fileURLToPath(import.meta.url)),
+          "../../scripts/init.sh"
+        ),
+        "--no-input",
+        "-f",
+        "--config-file",
+        cookieCutterConfigFile,
+        "--checkout",
+        options.checkout,
+        options.remote
+      ],
+      {
+        stdio: "inherit"
+      }
+    );
   } finally {
-    await fs.rm(cookieCutterConfigFile, {
-      recursive: true,
-      force: true
-    });
+    await fs.rm(cookieCutterConfigFile, { recursive: true, force: true });
   }
 });
-program.command("update").option("-r, --remote <remote>", "the remote to use", "https://gitlab.com/bitspur/multiplatform.one/cookiecutter").option("-c, --checkout <branch>", "branch, tag or commit to checkout", "main").option("-p, --platforms <platforms>", "platforms to keep").option("-b, --backends <backends>", "backends to keep").description("update multiplatform.one").action(async (options) => {
-  let { backends, platforms } = options;
-  if (!backends) {
-    const backendsResult = await inquirer.prompt([
+program.command("update").option(
+  "-r, --remote <remote>",
+  "the remote to use",
+  "https://gitlab.com/bitspur/multiplatform.one/cookiecutter"
+).option(
+  "-c, --checkout <branch>",
+  "branch, tag or commit to checkout",
+  "main"
+).option("-p, --platforms <platforms>", "platforms to keep").option("-s, --services <services>", "services to keep").description("update multiplatform.one").action(async (options) => {
+  let { services, platforms } = options;
+  if (!services) {
+    const servicesResult = await inquirer.prompt([
       {
-        message: "What backends are you using?",
-        name: "backends",
+        message: "What services are you using?",
+        name: "services",
         type: "checkbox",
-        choices: availableBackends.map((name) => ({
-          name
-        }))
+        choices: availableServices.map((name) => ({ name }))
       }
     ]);
-    backends = backendsResult.backends.join(",");
+    services = servicesResult.services.join(",");
   }
   if (!platforms) {
     const platformsResult = await inquirer.prompt([
@@ -124,202 +157,391 @@ program.command("update").option("-r, --remote <remote>", "the remote to use", "
         message: "What platforms are you using?",
         name: "platforms",
         type: "checkbox",
-        choices: availablePlatforms.map((name) => ({
-          name
-        }))
+        choices: availablePlatforms.map((name) => ({ name }))
       }
     ]);
     platforms = platformsResult.platforms.join(",");
   }
-  if ((await execa("git", [
-    "rev-parse",
-    "--is-inside-work-tree"
-  ], {
+  if ((await execa("git", ["rev-parse", "--is-inside-work-tree"], {
     reject: false
   })).exitCode !== 0) {
-    throw new Error("multiplatform.one cannot be updated outside of a git repository");
+    throw new Error(
+      "multiplatform.one cannot be updated outside of a git repository"
+    );
   }
-  if ((await execa("git", [
-    "diff",
-    "--cached",
-    "--quiet"
-  ], {
+  if ((await execa("git", ["diff", "--cached", "--quiet"], {
     reject: false
   })).exitCode !== 0) {
-    throw new Error("multiplatform.one cannot be updated with uncommitted changes");
+    throw new Error(
+      "multiplatform.one cannot be updated with uncommitted changes"
+    );
   }
-  const projectRoot = (await execa("git", [
-    "rev-parse",
-    "--show-toplevel"
-  ])).stdout.trim();
+  const projectRoot2 = (await execa("git", ["rev-parse", "--show-toplevel"])).stdout.trim();
   let cookieCutterConfig;
-  if ((await fs.stat(path.resolve(projectRoot, "package.json"))).isFile() && (await fs.stat(path.resolve(projectRoot, "app/package.json"))).isFile() && JSON.parse(await fs.readFile(path.resolve(projectRoot, "app/package.json"), "utf8"))?.dependencies?.["multiplatform.one"]?.length) {
-    const name = JSON.parse(await fs.readFile(path.resolve(projectRoot, "package.json"), "utf8"))?.name;
+  if ((await fs.stat(path.resolve(projectRoot2, "package.json"))).isFile() && (await fs.stat(path.resolve(projectRoot2, "app/package.json"))).isFile() && JSON.parse(
+    await fs.readFile(
+      path.resolve(projectRoot2, "app/package.json"),
+      "utf8"
+    )
+  )?.dependencies?.["multiplatform.one"]?.length) {
+    const name = JSON.parse(
+      await fs.readFile(path.resolve(projectRoot2, "package.json"), "utf8")
+    )?.name;
     if (name) {
       cookieCutterConfig = {
-        default_context: {
-          name,
-          backends,
-          platforms
-        }
+        default_context: { name, services, platforms }
       };
     }
   }
   if (!cookieCutterConfig) throw new Error("not a multiplatform.one project");
-  const cookieCutterConfigFile = path.join(await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")), "config.json");
+  const cookieCutterConfigFile = path.join(
+    await fs.mkdtemp(path.join(os.tmpdir(), "multiplatform-")),
+    "config.json"
+  );
   try {
-    await fs.writeFile(cookieCutterConfigFile, JSON.stringify(cookieCutterConfig, null, 2));
-    await execa("sh", [
-      path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scripts/update.sh"),
-      "--no-input",
-      "-f",
-      "--config-file",
+    await fs.writeFile(
       cookieCutterConfigFile,
-      "--checkout",
-      options.checkout,
-      options.remote
-    ], {
-      cwd: projectRoot,
-      stdio: "inherit"
-    });
+      JSON.stringify(cookieCutterConfig, null, 2)
+    );
+    await execa(
+      "sh",
+      [
+        path.resolve(
+          path.dirname(fileURLToPath(import.meta.url)),
+          "../../scripts/update.sh"
+        ),
+        "--no-input",
+        "-f",
+        "--config-file",
+        cookieCutterConfigFile,
+        "--checkout",
+        options.checkout,
+        options.remote
+      ],
+      {
+        cwd: projectRoot2,
+        stdio: "inherit"
+      }
+    );
   } finally {
-    await fs.rm(cookieCutterConfigFile, {
-      recursive: true,
-      force: true
-    });
+    await fs.rm(cookieCutterConfigFile, { recursive: true, force: true });
   }
 });
-var waitServices = [
-  "api",
-  "frappe",
-  "postgres",
-  "keycloak"
-];
-program.command("wait").description("wait for a service to be ready").option("-i, --interval <interval>", "interval to wait for", "1000").option("-t, --timeout <timeout>", "timeout to wait for", "600000").option("-e, --dotenv <dotenv>", "dotenv file path", ".env").argument("<services>", `the services to wait for (${waitServices.join(", ")})`).action(async (servicesString, options) => {
-  dotenv.config({
-    path: options.dotenv
-  });
+program.command("wait").description("wait for a service to be ready").option("-i, --interval <interval>", "interval to wait for", "1000").option("-t, --timeout <timeout>", "timeout to wait for", "600000").option("-e, --dotenv <dotenv>", "dotenv file path", ".env").argument(
+  "<services>",
+  `the services to wait for (${waitServices.join(", ")})`
+).action(async (servicesString, options) => {
+  dotenv.config({ path: options.dotenv || defaultDotenvPath });
   const interval = Number.parseInt(options.interval);
   const timeout = Number.parseInt(options.timeout);
   const services = servicesString.split(",");
-  const unreadyServices = [
-    ...services
+  try {
+    await waitWithSpinner(services, { interval, timeout });
+  } catch (err) {
+    process.exit(1);
+  }
+});
+program.command("mesh").description("start the mesh server").option("-a, --api", "use api", false).option("-e, --dotenv <dotenv>", "dotenv file path", ".env").option("-f, --frappe", "use frappe", false).option("-i, --interval <interval>", "interval to wait for", "1000").option("-p, --port <port>", "port to run mesh on", "5002").option("-t, --timeout <timeout>", "timeout to wait for", "600000").action(async (options) => {
+  dotenv.config({ path: options.dotenv || defaultDotenvPath });
+  process.env.UWS_HTTP_MAX_HEADERS_SIZE = "16384";
+  if (options.frappe || options.api) {
+    process.env.MESH_API = options.api ? "1" : "0";
+    process.env.MESH_FRAPPE = options.frappe ? "1" : "0";
+  }
+  if (!await fs.stat(path.resolve(projectRoot, "app/main.ts")).catch(() => false)) {
+    process.env.MESH_APP = "0";
+  }
+  if (!await fs.stat(path.resolve(projectRoot, "frappe/package.json")).catch(() => false)) {
+    process.env.MESH_FRAPPE = "0";
+  }
+  const services = [
+    ...process.env.MESH_API === "1" ? ["api"] : [],
+    ...process.env.MESH_FRAPPE === "1" ? ["frappe"] : []
   ];
-  const spinner = ora(`waiting for ${formatServiceList(unreadyServices)}`).start();
+  if (services.length > 0) {
+    const interval = Number.parseInt(options.interval);
+    const timeout = Number.parseInt(options.timeout);
+    try {
+      await waitWithSpinner(services, { interval, timeout });
+    } catch (err) {
+      process.exit(1);
+    }
+  }
+  await execa(
+    "mesh",
+    [
+      "dev",
+      "--port",
+      Number(options.port || process.env.MESH_PORT || 5002).toString()
+    ],
+    {
+      stdio: "inherit"
+    }
+  );
+});
+program.command("build").argument(
+  "[args...]",
+  `build to run: ${[...availableServices, "packages"].join(", ")} (default: all)`
+).description("run build command").action(async (args) => {
+  args = args.flatMap((arg) => arg.split(","));
+  const packages = args.includes("packages");
+  const projects = args.filter((arg) => arg !== "packages");
+  if (!projects.length && !packages || packages) {
+    await execa(
+      "turbo",
+      [
+        "run",
+        "build",
+        "--filter",
+        "'!./platforms/*'",
+        "--filter",
+        "'!./api'",
+        "--filter",
+        "'!./solana'",
+        "--filter",
+        "'!./ethereum'",
+        "--filter",
+        "'!./sui'"
+      ],
+      {
+        stdio: "inherit",
+        shell: true,
+        cwd: projectRoot
+      }
+    );
+  }
+  for (const platform of await fs.readdir("platforms")) {
+    if ((!projects.length && !packages || projects.includes(platform)) && await fs.access(path.join(projectRoot, "platforms", platform, "package.json")).then(
+      () => JSON.parse(
+        fsSync.readFileSync(
+          path.join(projectRoot, "platforms", platform, "package.json"),
+          "utf8"
+        )
+      ).scripts?.build
+    ).catch(() => false)) {
+      await execa("./mkpm", [`${platform}/build`], {
+        stdio: "inherit",
+        shell: true,
+        cwd: projectRoot
+      });
+    }
+  }
+  for (const service of availableServices) {
+    if ((!projects.length && !packages || projects.includes(service)) && await fs.access(path.join(projectRoot, service, "package.json")).then(
+      () => JSON.parse(
+        fsSync.readFileSync(
+          path.join(projectRoot, service, "package.json"),
+          "utf8"
+        )
+      ).scripts?.build
+    ).catch(() => false)) {
+      await execa("./mkpm", [`${service}/build`], {
+        stdio: "inherit",
+        shell: true,
+        cwd: projectRoot
+      });
+    }
+  }
+});
+program.command("test").argument(
+  "[args...]",
+  `test to run: ${[...availableServices, "packages"].join(", ")} (default: all)`
+).description("run test command").action(async (args) => {
+  args = args.flatMap((arg) => arg.split(","));
+  const packages = args.includes("packages");
+  const projects = args.filter((arg) => arg !== "packages");
+  if (!projects.length && !packages || packages) {
+    await execa(
+      "turbo",
+      [
+        "run",
+        "test",
+        "--filter",
+        "'!./platforms/*'",
+        "--filter",
+        "'!./api'",
+        "--filter",
+        "'!./solana'",
+        "--filter",
+        "'!./ethereum'",
+        "--filter",
+        "'!./sui'"
+      ],
+      {
+        stdio: "inherit",
+        shell: true,
+        cwd: projectRoot
+      }
+    );
+  }
+  for (const platform of await fs.readdir("platforms")) {
+    if ((!projects.length && !packages || projects.includes(platform)) && await fs.access(path.join(projectRoot, "platforms", platform, "package.json")).then(
+      () => JSON.parse(
+        fsSync.readFileSync(
+          path.join(projectRoot, "platforms", platform, "package.json"),
+          "utf8"
+        )
+      ).scripts?.test
+    ).catch(() => false)) {
+      await execa("./mkpm", [`${platform}/test`], {
+        stdio: "inherit",
+        shell: true,
+        cwd: projectRoot
+      });
+    }
+  }
+  for (const service of availableServices) {
+    if ((!projects.length && !packages || projects.includes(service)) && await fs.access(path.join(projectRoot, service, "package.json")).then(
+      () => JSON.parse(
+        fsSync.readFileSync(
+          path.join(projectRoot, service, "package.json"),
+          "utf8"
+        )
+      ).scripts?.test
+    ).catch(() => false)) {
+      await execa("./mkpm", [`${service}/test`], {
+        stdio: "inherit",
+        shell: true,
+        cwd: projectRoot
+      });
+    }
+  }
+});
+program.command("check").argument("[args...]", "checks to run: spelling, types, lint (default: all)").description("run check command").action(async (args) => {
+  args = args.flatMap((arg) => arg.split(","));
+  const spelling = !args.length || args.includes("spelling");
+  const types = !args.length || args.includes("types");
+  const lint = !args.length || args.includes("lint");
+  let exitCode = 0;
+  if (spelling) {
+    try {
+      await execa(
+        "cspell",
+        [
+          "--unique",
+          "`(git ls-files && (git lfs ls-files | cut -d' ' -f3))`"
+        ],
+        {
+          stdio: "inherit",
+          shell: true,
+          cwd: projectRoot
+        }
+      );
+    } catch (err) {
+      if (err instanceof Error && "exitCode" in err) {
+        exitCode = err.exitCode;
+      } else {
+        exitCode = 1;
+      }
+    }
+  }
+  if (types) {
+    try {
+      await execa("turbo", ["run", "typecheck"], {
+        stdio: "inherit",
+        shell: true,
+        cwd: projectRoot
+      });
+    } catch (err) {
+      if (err instanceof Error && "exitCode" in err) {
+        exitCode = err.exitCode;
+      } else {
+        exitCode = 1;
+      }
+    }
+  }
+  if (lint) {
+    try {
+      await execa(
+        "biome",
+        [
+          "check",
+          "--fix",
+          "--unsafe",
+          "`(git ls-files && (git lfs ls-files | cut -d' ' -f3)) | sort | uniq -u | grep -E '(html)|(s?css)|(md)|(json)|(yaml)|([jt]sx?)$'`"
+        ],
+        {
+          stdio: "inherit",
+          shell: true,
+          cwd: projectRoot
+        }
+      );
+    } catch (err) {
+      if (err instanceof Error && "exitCode" in err) {
+        exitCode = err.exitCode;
+      } else {
+        exitCode = 1;
+      }
+    }
+  }
+  process.exit(exitCode);
+});
+program.command("count").description("count lines of code").action(async () => {
+  await execa(
+    "cloc",
+    [
+      "`(git ls-files && (git lfs ls-files | cut -d' ' -f3)) | sort | uniq -u | grep -E '(html)|(s?css)|(md)|(json)|(yaml)|([jt]sx?)$'`"
+    ],
+    {
+      stdio: "inherit",
+      shell: true,
+      cwd: projectRoot
+    }
+  );
+});
+program.command("generate").description("run generate command").action(async () => {
+  await execa("turbo", ["run", "generate"], {
+    stdio: "inherit",
+    shell: true,
+    cwd: projectRoot
+  });
+});
+program.parse(process.argv);
+async function waitWithSpinner(services, options = {}) {
+  const { interval = 1e3, timeout = 6e5 } = options;
+  const waitFunctions = {
+    api: waitForApi,
+    frappe: waitForFrappe,
+    postgres: waitForPostgres,
+    keycloak: waitForKeycloak
+  };
+  const unreadyServices = [...services];
+  const spinner = ora(
+    `waiting for ${formatServiceList(unreadyServices)}`
+  ).start();
   function updateSpinner(readyService) {
     unreadyServices.splice(unreadyServices.indexOf(readyService), 1);
-    spinner.stop();
     spinner.succeed(`${readyService} is ready`);
-    if (!unreadyServices.length) return;
-    spinner.start(`waiting for ${formatServiceList(unreadyServices)}`);
+    if (unreadyServices.length) {
+      spinner.start(`waiting for ${formatServiceList(unreadyServices)}`);
+    }
   }
-  __name(updateSpinner, "updateSpinner");
   let timeoutId;
   try {
     await Promise.race([
-      Promise.all(services.map(async (service) => {
-        switch (service) {
-          case "api": {
-            await waitForApi(interval);
-            updateSpinner("api");
-            return;
-          }
-          case "frappe": {
-            await waitForFrappe(interval);
-            updateSpinner("frappe");
-            return;
-          }
-          case "postgres": {
-            await waitForPostgres(interval);
-            updateSpinner("postgres");
-            return;
-          }
-          case "keycloak": {
-            await waitForKeycloak(interval);
-            updateSpinner("keycloak");
-            return;
-          }
-        }
-        ora(`available services are ${formatServiceList(waitServices)}`).fail();
-      })),
+      Promise.all(
+        services.map(async (service) => {
+          const waitFn = waitFunctions[service];
+          if (!waitFn) throw new Error(`Unknown service: ${service}`);
+          await waitFn(interval);
+          updateSpinner(service);
+        })
+      ),
       new Promise((_, reject) => {
         timeoutId = setTimeout(() => reject(new Error("Timeout")), timeout);
       })
     ]);
   } catch (err) {
-    if (err instanceof Error && err.message === "Timeout") {
-      spinner.fail(`${formatServiceList(unreadyServices)} timed out after ${timeout}ms`);
+    const error = err;
+    if (error.message === "Timeout") {
+      spinner.fail(
+        `${formatServiceList(unreadyServices)} timed out after ${timeout}ms`
+      );
     } else {
-      spinner.fail(err);
+      spinner.fail(error.message);
     }
-    process.exit(1);
+    throw error;
   } finally {
     clearTimeout(timeoutId);
   }
-});
-function formatServiceList(services) {
-  if (services.length === 1) return services[0];
-  if (services.length === 2) return `${services[0]} and ${services[1]}`;
-  return `${services.slice(0, -1).join(", ")} and ${services[services.length - 1]}`;
-}
-__name(formatServiceList, "formatServiceList");
-program.parse(process.argv);
-async function waitForApi(interval) {
-  try {
-    const res = await axios.get(`http://localhost:${process.env.API_PORT || "5001"}/healthz`);
-    if ((res?.status || 500) < 300) {
-      return;
-    }
-  } catch (err) {
-  }
-  await new Promise((resolve) => setTimeout(resolve, interval));
-  return waitForApi(interval);
-}
-__name(waitForApi, "waitForApi");
-async function waitForFrappe(interval) {
-  try {
-    const res = await axios.get(`${process.env.FRAPPE_BASE_URL || "http://frappe.localhost"}/api/method/ping`);
-    if ((res?.status || 500) < 300) {
-      return;
-    }
-  } catch (err) {
-  }
-  await new Promise((resolve) => setTimeout(resolve, interval));
-  return waitForFrappe(interval);
-}
-__name(waitForFrappe, "waitForFrappe");
-async function waitForPostgres(interval) {
-  const client = new pg.Client({
-    database: process.env.POSTGRES_DATABASE || "postgres",
-    host: process.env.POSTGRES_HOSTNAME || "localhost",
-    password: process.env.POSTGRES_PASSWORD || "postgres",
-    port: Number.parseInt(process.env.POSTGRES_PORT || "5432"),
-    user: process.env.POSTGRES_USERNAME || "postgres"
-  });
-  try {
-    await client.connect();
-    while (true) {
-      try {
-        await client.query("SELECT 1");
-        return;
-      } catch (error) {
-      }
-      await new Promise((resolve) => setTimeout(resolve, interval));
-    }
-  } finally {
-    await client.end();
-  }
-}
-__name(waitForPostgres, "waitForPostgres");
-async function waitForKeycloak(interval) {
-  try {
-    const res = await axios.get(`${process.env.KEYCLOAK_BASE_URL || "http://localhost:8080"}/realms/master/.well-known/openid-configuration`);
-    if ((res?.status || 500) < 300) {
-      return;
-    }
-  } catch (err) {
-  }
-  await new Promise((resolve) => setTimeout(resolve, interval));
-  return waitForKeycloak(interval);
 }
-__name(waitForKeycloak, "waitForKeycloak");