@cedarjs/cli 0.0.4

package/dist/plugin.js

@@ -0,0 +1,223 @@
+import { getConfig } from "./lib/index.js";
+import {
+  loadCommandCache,
+  checkPluginListAndWarn,
+  saveCommandCache,
+  loadPluginPackage
+} from "./lib/plugin.js";
+async function loadPlugins(yargs) {
+  const namespaceIsExplicit = process.argv[2]?.startsWith("@");
+  const namespaceInUse = (namespaceIsExplicit ? process.argv[2] : "@cedarjs") ?? "@cedarjs";
+  const commandString = namespaceIsExplicit ? process.argv.slice(3).join(" ") : process.argv.slice(2).join(" ");
+  const commandFirstWord = commandString.split(" ")[0];
+  if (commandFirstWord === "--version" && namespaceInUse === "@cedarjs") {
+    return yargs;
+  }
+  const pluginCommandCache = loadCommandCache();
+  if (pluginCommandCache._builtin.includes(commandFirstWord) && namespaceInUse === "@cedarjs") {
+    return yargs;
+  }
+  const { plugins, autoInstall } = getConfig().experimental.cli;
+  const enabledPlugins = plugins.filter(
+    (p) => p.package !== void 0 && (p.enabled ?? true)
+  );
+  checkPluginListAndWarn(enabledPlugins);
+  const redwoodPackages = /* @__PURE__ */ new Set();
+  const thirdPartyPackages = /* @__PURE__ */ new Set();
+  for (const plugin of enabledPlugins) {
+    if (!plugin.package) {
+      continue;
+    }
+    if (!plugin.package.startsWith("@")) {
+      continue;
+    }
+    if (plugin.package.startsWith("@cedarjs/")) {
+      redwoodPackages.add(plugin.package);
+    } else {
+      thirdPartyPackages.add(plugin.package);
+    }
+  }
+  const namespaces = Array.from(thirdPartyPackages).map((p) => p.split("/")[0]).sort();
+  if (redwoodPackages.size > 0) {
+    namespaces.unshift("@cedarjs");
+  }
+  const showingHelpAtRootLevel = !namespaceIsExplicit && (commandFirstWord === "--help" || commandFirstWord === "-h" || commandFirstWord === "");
+  const namespaceIsUnknown = !namespaces.includes(namespaceInUse);
+  if (showingHelpAtRootLevel || namespaceIsUnknown) {
+    for (const namespace of namespaces) {
+      if (namespace === "@cedarjs") {
+        for (const redwoodPluginPackage of redwoodPackages) {
+          const commands = await loadCommandsFromCacheOrPackage(
+            redwoodPluginPackage,
+            pluginCommandCache,
+            autoInstall,
+            true
+          );
+          yargs.command(commands);
+        }
+      } else {
+        yargs.command({
+          command: `${namespace} <command>`,
+          describe: `Commands from ${namespace}`,
+          builder: () => {
+          },
+          handler: () => {
+          }
+        });
+      }
+    }
+    saveCommandCache(pluginCommandCache);
+    return yargs;
+  }
+  const showingHelpAtNamespaceLevel = namespaceIsExplicit && (commandFirstWord === "--help" || commandFirstWord === "-h" || commandFirstWord === "");
+  if (showingHelpAtNamespaceLevel) {
+    if (namespaceInUse === "@cedarjs") {
+      for (const redwoodPluginPackage of redwoodPackages) {
+        const commands = await loadCommandsFromCacheOrPackage(
+          redwoodPluginPackage,
+          pluginCommandCache,
+          autoInstall,
+          true
+        );
+        yargs.command(commands);
+      }
+    } else {
+      const packagesForNamespace = Array.from(thirdPartyPackages).filter(
+        (p) => p.startsWith(namespaceInUse)
+      );
+      for (const packageForNamespace of packagesForNamespace) {
+        const commands = await loadCommandsFromCacheOrPackage(
+          packageForNamespace,
+          pluginCommandCache,
+          autoInstall,
+          true
+        );
+        yargs.command({
+          command: `${namespaceInUse} <command>`,
+          describe: `Commands from ${namespaceInUse}`,
+          builder: (yargs2) => {
+            yargs2.command(commands).demandCommand();
+          },
+          handler: () => {
+          }
+        });
+      }
+    }
+    saveCommandCache(pluginCommandCache);
+    return yargs;
+  }
+  const packagesToLoad = /* @__PURE__ */ new Set();
+  for (const [packageName, cacheEntry] of Object.entries(pluginCommandCache)) {
+    if (packageName === "_builtin") {
+      continue;
+    }
+    const commandFirstWords = [];
+    for (const [command, info] of Object.entries(cacheEntry)) {
+      commandFirstWords.push(command.split(" ")[0]);
+      commandFirstWords.push(
+        ...info.aliases?.map((a) => a.split(" ")[0]) ?? []
+      );
+    }
+    if (commandFirstWords.includes(commandFirstWord) && packageName.startsWith(namespaceInUse)) {
+      packagesToLoad.add(packageName);
+      break;
+    }
+  }
+  const foundMatchingPackage = packagesToLoad.size > 0;
+  if (!foundMatchingPackage) {
+    for (const plugin of enabledPlugins) {
+      if (plugin.package.startsWith(namespaceInUse)) {
+        packagesToLoad.add(plugin.package);
+      }
+    }
+  }
+  const commandsToRegister = [];
+  if (foundMatchingPackage) {
+    const packageToLoad = packagesToLoad.values().next().value;
+    const commands = await loadCommandsFromCacheOrPackage(
+      packageToLoad,
+      pluginCommandCache,
+      autoInstall,
+      false
+    );
+    commandsToRegister.push(...commands);
+  } else {
+    for (const packageToLoad of packagesToLoad) {
+      const commands = await loadCommandsFromCacheOrPackage(
+        packageToLoad,
+        pluginCommandCache,
+        autoInstall,
+        true
+      );
+      commandsToRegister.push(...commands);
+    }
+  }
+  if (namespaceInUse === "@cedarjs") {
+    yargs.command(commandsToRegister);
+  } else {
+    yargs.command({
+      command: `${namespaceInUse} <command>`,
+      describe: `Commands from ${namespaceInUse}`,
+      builder: (yargs2) => {
+        yargs2.command(commandsToRegister).demandCommand();
+      },
+      handler: () => {
+      }
+    });
+  }
+  if (!namespaceIsExplicit) {
+    for (const namespace of namespaces) {
+      if (namespace === "@cedarjs") {
+        continue;
+      }
+      yargs.command({
+        command: `${namespace} <command>`,
+        describe: `Commands from ${namespace}`,
+        builder: () => {
+        },
+        handler: () => {
+        }
+      });
+    }
+  }
+  saveCommandCache(pluginCommandCache);
+  return yargs;
+}
+async function loadCommandsFromCacheOrPackage(packageName, cache, autoInstall, readFromCache) {
+  let cacheEntry = void 0;
+  if (readFromCache) {
+    cacheEntry = cache !== void 0 ? cache[packageName] : void 0;
+  }
+  if (cacheEntry !== void 0) {
+    const commands = Object.entries(cacheEntry).map(([command, info]) => {
+      return {
+        command,
+        describe: info.description,
+        aliases: info.aliases
+      };
+    });
+    return commands;
+  }
+  const plugin = await loadPluginPackage(packageName, void 0, autoInstall);
+  if (plugin) {
+    const commands = plugin.commands ?? [];
+    const cacheUpdate = {};
+    for (const command of commands) {
+      const info = {
+        aliases: command.aliases,
+        description: command.description
+      };
+      if (Object.values(info).some((value) => value !== void 0)) {
+        cacheUpdate[command.command] = info;
+      }
+    }
+    if (Object.keys(cacheUpdate).length > 0) {
+      cache[packageName] = cacheUpdate;
+    }
+    return commands;
+  }
+  return [];
+}
+export {
+  loadPlugins
+};

package/dist/rwfw.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import path from "path";
+import Configstore from "configstore";
+import execa from "execa";
+import fs from "fs-extra";
+import TerminalLink from "terminal-link";
+import { getConfigPath } from "@cedarjs/project-config";
+const config = new Configstore("@cedarjs/cli");
+const RWFW_PATH = process.env.RWFW_PATH || process.env.RW_PATH || config.get("RWFW_PATH");
+if (!RWFW_PATH) {
+  console.error("Error: You must specify the path to Redwood Framework");
+  console.error("Usage: `RWFW_PATH=~/gh/cedarjs/cedar yarn rwfw <command>");
+  process.exit(1);
+}
+if (!fs.existsSync(RWFW_PATH)) {
+  console.error(
+    `Error: The specified path to Redwood Framework (${RWFW_PATH}) does not exist.`
+  );
+  console.error("Usage: `RWFW_PATH=~/gh/cedarjs/cedar yarn rwfw <command>");
+  process.exit(1);
+}
+const absRwFwPath = path.resolve(process.cwd(), RWFW_PATH);
+config.set("RWFW_PATH", absRwFwPath);
+const projectPath = path.dirname(
+  getConfigPath(process.env.RWJS_CWD ?? process.cwd())
+);
+console.log(
+  "Redwood Framework Tools Path:",
+  TerminalLink(absRwFwPath, absRwFwPath)
+);
+let command = process.argv.slice(2);
+const helpCommands = ["help", "--help"];
+if (!command.length || command.some((cmd) => helpCommands.includes(cmd))) {
+  command = ["run"];
+}
+try {
+  execa.sync("yarn", [...command], {
+    stdio: "inherit",
+    shell: true,
+    cwd: absRwFwPath,
+    env: {
+      RWJS_CWD: projectPath
+    }
+  });
+} catch (e) {
+  console.log();
+}

package/dist/telemetry/exporter.js

@@ -0,0 +1,63 @@
+import path from "path";
+import fs from "fs-extra";
+import { getPaths } from "@cedarjs/project-config";
+class CustomFileExporter {
+  /**
+   * @type string
+   * @private
+   */
+  #storageFileName;
+  /**
+   * @type string
+   * @private
+   */
+  #storageFilePath;
+  /**
+   * @type boolean
+   * @private
+   */
+  #isShutdown = false;
+  constructor() {
+    this.#storageFileName = `${Date.now()}.json`;
+    this.#storageFilePath = path.join(
+      getPaths().generated.base,
+      "telemetry",
+      this.#storageFileName
+    );
+    fs.ensureDirSync(path.dirname(this.#storageFilePath));
+    fs.writeFileSync(this.#storageFilePath, "[");
+  }
+  /**
+   * Called to export sampled {@link ReadableSpan}s.
+   * @param spans the list of sampled Spans to be exported.
+   */
+  export(spans, resultCallback) {
+    for (let i = 0; i < spans.length; i++) {
+      const span = spans[i];
+      delete span["_spanProcessor"];
+      fs.appendFileSync(
+        this.#storageFilePath,
+        JSON.stringify(span, void 0, 2)
+      );
+      fs.appendFileSync(this.#storageFilePath, ",");
+    }
+    resultCallback({ code: 0 });
+  }
+  /** Stops the exporter. */
+  shutdown() {
+    if (!this.#isShutdown) {
+      fs.truncateSync(
+        this.#storageFilePath,
+        fs.statSync(this.#storageFilePath).size - 1
+      );
+      fs.appendFileSync(this.#storageFilePath, "]");
+      this.#isShutdown = true;
+    }
+  }
+  /** Immediately export all spans */
+  forceFlush() {
+  }
+}
+export {
+  CustomFileExporter
+};

package/dist/telemetry/index.js

@@ -0,0 +1,84 @@
+import path from "path";
+import { diag, DiagConsoleLogger, DiagLogLevel } from "@opentelemetry/api";
+import opentelemetry from "@opentelemetry/api";
+import {
+  NodeTracerProvider,
+  SimpleSpanProcessor,
+  SamplingDecision
+} from "@opentelemetry/sdk-trace-node";
+import { hideBin } from "yargs/helpers";
+import { spawnBackgroundProcess } from "../lib/background.js";
+import { CustomFileExporter } from "./exporter.js";
+let traceProvider;
+let traceProcessor;
+let traceExporter;
+let isStarted = false;
+let isShutdown = false;
+async function startTelemetry() {
+  if (isStarted) {
+    return;
+  }
+  isStarted = true;
+  try {
+    diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.ERROR);
+    traceProvider = new NodeTracerProvider({
+      sampler: {
+        shouldSample: () => {
+          return {
+            decision: isShutdown ? SamplingDecision.NOT_RECORD : SamplingDecision.RECORD_AND_SAMPLED
+          };
+        },
+        toString: () => {
+          return "AlwaysSampleWhenNotShutdown";
+        }
+      }
+    });
+    traceExporter = new CustomFileExporter();
+    traceProcessor = new SimpleSpanProcessor(traceExporter);
+    traceProvider.addSpanProcessor(traceProcessor);
+    traceProvider.register();
+    const cleanArgv = hideBin(process.argv);
+    if (!cleanArgv.includes("sb") && !cleanArgv.includes("storybook")) {
+      for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+        process.on(signal, () => {
+          if (process.listenerCount(signal) === 1) {
+            process.exit();
+          }
+        });
+      }
+    } else {
+      process.on("shutdown-telemetry", () => {
+        shutdownTelemetry();
+      });
+    }
+    process.on("exit", () => {
+      shutdownTelemetry();
+    });
+  } catch (error) {
+    console.error("Telemetry error");
+    console.error(error);
+  }
+}
+function shutdownTelemetry() {
+  if (isShutdown || !isStarted) {
+    return;
+  }
+  isShutdown = true;
+  try {
+    while (opentelemetry.trace.getActiveSpan()?.isRecording()) {
+      opentelemetry.trace.getActiveSpan()?.end();
+    }
+    traceExporter?.shutdown();
+    spawnBackgroundProcess("telemetry", "yarn", [
+      "node",
+      path.join(import.meta.dirname, "send.js")
+    ]);
+  } catch (error) {
+    console.error("Telemetry error");
+    console.error(error);
+  }
+}
+export {
+  shutdownTelemetry,
+  startTelemetry
+};

package/dist/telemetry/resource.js

@@ -0,0 +1,98 @@
+import path from "path";
+import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";
+import ci from "ci-info";
+import envinfo from "envinfo";
+import fs from "fs-extra";
+import system from "systeminformation";
+import { v4 as uuidv4, validate as validateUUID } from "uuid";
+import { getPaths, getRawConfig } from "@cedarjs/project-config";
+import { DefaultHost } from "@cedarjs/structure/dist/hosts";
+import { RWProject } from "@cedarjs/structure/dist/model/RWProject";
+import {
+  name as packageName,
+  version as packageVersion
+} from "../../package.js";
+async function getResources() {
+  let UID = uuidv4();
+  try {
+    const telemetryFile = path.join(getPaths().generated.base, "telemetry.txt");
+    if (!fs.existsSync(telemetryFile)) {
+      fs.ensureFileSync(telemetryFile);
+    }
+    if (fs.statSync(telemetryFile).mtimeMs < Date.now() - 864e5) {
+      fs.writeFileSync(telemetryFile, UID);
+    } else {
+      const storedUID = fs.readFileSync(telemetryFile, { encoding: "utf8" });
+      if (storedUID && validateUUID(storedUID)) {
+        UID = storedUID;
+      } else {
+        fs.writeFileSync(telemetryFile, UID);
+      }
+    }
+  } catch (_error) {
+  }
+  const info = JSON.parse(
+    await envinfo.run(
+      {
+        System: ["OS", "Shell"],
+        Binaries: ["Node", "Yarn", "npm"],
+        npmPackages: "@cedarjs/*",
+        IDEs: ["VSCode"]
+      },
+      { json: true }
+    )
+  );
+  const shell = info.System?.Shell;
+  if (shell?.path?.match("/")) {
+    info.System.Shell.name = info.System.Shell.path.split("/").pop();
+  } else if (shell?.path.match("\\")) {
+    info.System.Shell.name = info.System.Shell.path.split("\\").pop();
+  }
+  const cpu = await system.cpu();
+  const mem = await system.mem();
+  let developmentEnvironment = void 0;
+  if (Object.keys(process.env).some((key) => key.startsWith("GITPOD_"))) {
+    developmentEnvironment = "gitpod";
+  }
+  const experiments = Object.keys(getRawConfig()["experimental"] || {});
+  const project = new RWProject({
+    host: new DefaultHost(),
+    projectRoot: getPaths().base
+  });
+  const routes = project.getRouter().routes;
+  const prerenderedRoutes = routes.filter((route) => route.hasPrerender);
+  const complexity = [
+    routes.length,
+    prerenderedRoutes.length,
+    project.services.length,
+    project.cells.length,
+    project.pages.length
+  ].join(".");
+  const sides = project.sides.join(",");
+  return {
+    [SemanticResourceAttributes.SERVICE_NAME]: packageName,
+    [SemanticResourceAttributes.SERVICE_VERSION]: packageVersion,
+    [SemanticResourceAttributes.OS_TYPE]: info.System?.OS?.split(" ")[0],
+    [SemanticResourceAttributes.OS_VERSION]: info.System?.OS?.split(" ")[1],
+    "shell.name": info.System?.Shell?.name,
+    "node.version": info.Binaries?.Node?.version,
+    "yarn.version": info.Binaries?.Yarn?.version,
+    "npm.version": info.Binaries?.npm?.version,
+    "vscode.version": info.IDEs?.VSCode?.version,
+    "cpu.count": cpu.physicalCores,
+    "memory.gb": Math.round(mem.total / 1073741824),
+    "env.node_env": process.env.NODE_ENV || null,
+    "ci.redwood": !!process.env.REDWOOD_CI,
+    "ci.isci": ci.isCI,
+    "dev.environment": developmentEnvironment,
+    complexity,
+    sides,
+    experiments: JSON.stringify(experiments),
+    webBundler: "vite",
+    // Hardcoded because this is now the only supported bundler
+    uid: UID
+  };
+}
+export {
+  getResources
+};

package/dist/telemetry/send.js

@@ -0,0 +1,80 @@
+import path from "path";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { Resource } from "@opentelemetry/resources";
+import fs from "fs-extra";
+import { getPaths } from "@cedarjs/project-config";
+import { getResources } from "./resource.js";
+async function main() {
+  console.log(
+    "You can disable telemetry by:\n - setting the 'REDWOOD_DISABLE_TELEMETRY' environment variable\n - passing the '--no-telemetry' flag when using the CLI"
+  );
+  console.log(
+    "Information about Redwood telemetry can be found at:\n - https://telemetry.redwoodjs.com\n"
+  );
+  const telemetryDir = path.join(getPaths().generated.base, "telemetry");
+  fs.ensureDirSync(telemetryDir);
+  const telemetryFiles = fs.readdirSync(
+    path.join(getPaths().generated.base, "telemetry")
+  );
+  console.time("Computed resource information");
+  const customResourceData = await getResources();
+  console.timeEnd("Computed resource information");
+  const resource = Resource.default().merge(new Resource(customResourceData));
+  const url = process.env.REDWOOD_REDIRECT_TELEMETRY || "https://quark.quantumparticle.io/v1/traces";
+  const traceExporter = new OTLPTraceExporter({
+    url
+  });
+  console.log(`Sending telemetry data to '${url}'`);
+  for (const [index, file] of telemetryFiles.entries()) {
+    if (file.startsWith("_")) {
+      continue;
+    }
+    console.log(`Sending data from telemetry file '${file}'`);
+    let spans = [];
+    try {
+      spans = fs.readJSONSync(path.join(telemetryDir, file));
+    } catch (error) {
+      console.error(`Error reading telemetry file '${file}'`);
+      console.error(error);
+      console.error("Deleting this file to prevent further errors");
+      fs.unlinkSync(path.join(telemetryDir, file));
+      continue;
+    }
+    if (!Array.isArray(spans)) {
+      console.error(
+        `Telemetry file '${file}' does not contain an array of spans. Deleting this file to prevent further errors.`
+      );
+      fs.unlinkSync(path.join(telemetryDir, file));
+      continue;
+    }
+    for (const span of spans) {
+      span.resource = resource;
+      span.attributes ??= span._attributes ?? {};
+      span.spanContext = () => span._spanContext;
+      span.events = [];
+    }
+    traceExporter.export(spans, ({ code, error }) => {
+      if (code !== 0) {
+        console.error("Encountered:");
+        console.error(error);
+        console.error("while exporting the following spans:");
+        console.error(spans);
+      }
+    });
+    fs.writeJSONSync(path.join(telemetryDir, `_${file}`), spans, { spaces: 2 });
+    fs.unlinkSync(path.join(telemetryDir, file));
+    telemetryFiles[index] = `_${file}`;
+  }
+  traceExporter.shutdown();
+  console.log(
+    "Keeping the lastest 8 telemetry files for visibility/transparency."
+  );
+  const sortedTelemetryFiles = telemetryFiles.sort((a, b) => {
+    return parseInt(b.split(".")[0].replace("_", "")) - parseInt(a.split(".")[0].replace("_", ""));
+  });
+  for (let i = 8; i < sortedTelemetryFiles.length; i++) {
+    console.log(`Removing telemetry file '${sortedTelemetryFiles[i]}'`);
+    fs.unlinkSync(path.join(telemetryDir, sortedTelemetryFiles[i]));
+  }
+}
+main();