@cedarjs/cli 9.0.0-canary.1784 → 9.0.0-canary.3124

package/dist/commands/dev/devHandler.js

@@ -1,12 +1,16 @@
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { Writable } from "node:stream";
 import concurrently from "concurrently";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { formatRunBinCommand } from "@cedarjs/cli-helpers/packageManager/display";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { shutdownPort } from "@cedarjs/internal/dist/dev";
+import { generateGqlormArtifacts } from "@cedarjs/internal/dist/generate/gqlormSchema";
 import { getConfig, getConfigPath } from "@cedarjs/project-config";
+import { getPackageManager } from "@cedarjs/project-config/packageManager";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import c from "../../lib/colors.js";
 import { exitWithError } from "../../lib/exit.js";
 import { generatePrismaClient } from "../../lib/generatePrismaClient.js";
 import { getPaths } from "../../lib/index.js";
@@ -14,11 +18,39 @@ import { getFreePort } from "../../lib/ports.js";
 import { serverFileExists } from "../../lib/project.js";
 import { getApiDebugFlag } from "./apiDebugFlag.js";
 import { getPackageWatchCommands } from "./packageWatchCommands.js";
+const createdRequire = createRequire(import.meta.url);
+function formatViteDevBinCommand(binName, extraNodeArgs = "") {
+  let vitePackageJsonPath;
+  let vitePackageJson;
+  try {
+    vitePackageJsonPath = createdRequire.resolve("@cedarjs/vite/package.json");
+    vitePackageJson = createdRequire("@cedarjs/vite/package.json");
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    throw new Error(
+      `Could not resolve @cedarjs/vite, which the dev server needs to run. Is it installed? (${message})`
+    );
+  }
+  const binRelativePath = vitePackageJson.bin?.[binName];
+  if (!binRelativePath) {
+    throw new Error(
+      `@cedarjs/vite does not declare a "${binName}" bin. This is a bug in CedarJS.`
+    );
+  }
+  const binPath = path.join(path.dirname(vitePackageJsonPath), binRelativePath);
+  const nodeLauncher = getPackageManager() === "yarn" ? "yarn node" : "node";
+  const flags = extraNodeArgs ? `${extraNodeArgs} ` : "";
+  return `${nodeLauncher} ${flags}"${binPath}"`;
+}
 const handler = async ({
   workspace = ["api", "web", "packages/*"],
   forward = "",
   generate = true,
-  apiDebugPort
+  apiDebugPort,
+  debugBrk,
+  ud = false,
+  nodeArgs = "",
+  jobs: jobsOption
 }) => {
   recordTelemetryAttributes({
     command: "dev",
@@ -28,13 +60,8 @@ const handler = async ({
   const cedarPaths = getPaths();
   const serverFile = serverFileExists();
   const apiPreferredPort = parseInt(String(getConfig().api.port));
-  let webPreferredPort = parseInt(
-    String(getConfig().web.port)
-  );
   let apiAvailablePort = apiPreferredPort;
   let apiPortChangeNeeded = false;
-  let webAvailablePort = webPreferredPort;
-  let webPortChangeNeeded = false;
   if (workspace.includes("api") && !serverFile) {
     apiAvailablePort = await getFreePort(apiPreferredPort);
     if (apiAvailablePort === -1) {
@@ -44,6 +71,11 @@ const handler = async ({
     }
     apiPortChangeNeeded = apiAvailablePort !== apiPreferredPort;
   }
+  let webPreferredPort = parseInt(
+    String(getConfig().web.port)
+  );
+  let webAvailablePort = webPreferredPort;
+  let webPortChangeNeeded = false;
   if (workspace.includes("web")) {
     const forwardedPortMatches = [
       ...forward.matchAll(/\-\-port(\=|\s)(?<port>[^\s]*)/g)
@@ -52,10 +84,10 @@ const handler = async ({
       const port = forwardedPortMatches.pop()?.groups?.port;
       webPreferredPort = port ? parseInt(port, 10) : void 0;
     }
-    webAvailablePort = await getFreePort(webPreferredPort, [
-      apiPreferredPort,
-      apiAvailablePort
-    ]);
+    webAvailablePort = await getFreePort(
+      webPreferredPort,
+      apiAvailablePort !== void 0 ? [apiPreferredPort, apiAvailablePort] : [apiPreferredPort]
+    );
     if (webAvailablePort === -1) {
       exitWithError(void 0, {
         message: `Could not determine a free port for the web server`
@@ -63,36 +95,60 @@ const handler = async ({
     }
     webPortChangeNeeded = webAvailablePort !== webPreferredPort;
   }
-  if (apiPortChangeNeeded || webPortChangeNeeded) {
-    const message = [
-      "The currently configured ports for the development server are",
-      "unavailable. Suggested changes to your ports, which can be changed in",
-      "cedar.toml (or redwood.toml), are:\n",
-      apiPortChangeNeeded && ` - API to use port ${apiAvailablePort} instead`,
-      apiPortChangeNeeded && "of your currently configured",
-      apiPortChangeNeeded && `${apiPreferredPort}
+  if (ud) {
+    if (webPortChangeNeeded) {
+      const message = [
+        "The currently configured port for the development server is",
+        "unavailable. Suggested change to your port, which can be changed in",
+        "cedar.toml (or redwood.toml):\n",
+        ` - Web to use port ${webAvailablePort} instead`,
+        "of your currently configured",
+        `${webPreferredPort}
 `,
-      webPortChangeNeeded && ` - Web to use port ${webAvailablePort} instead`,
-      webPortChangeNeeded && "of your currently configured",
-      webPortChangeNeeded && `${webPreferredPort}
+        "\nCannot run the development server until your configured port is",
+        "changed or becomes available."
+      ].filter(Boolean).join(" ");
+      exitWithError(void 0, { message });
+    }
+  } else {
+    if (apiPortChangeNeeded || webPortChangeNeeded) {
+      const message = [
+        "The currently configured ports for the development server are",
+        "unavailable. Suggested changes to your ports, which can be changed in",
+        "cedar.toml (or redwood.toml), are:\n",
+        apiPortChangeNeeded && ` - API to use port ${apiAvailablePort} instead`,
+        apiPortChangeNeeded && "of your currently configured",
+        apiPortChangeNeeded && `${apiPreferredPort}
 `,
-      "\nCannot run the development server until your configured ports are",
-      "changed or become available."
-    ].filter(Boolean).join(" ");
-    exitWithError(void 0, { message });
+        webPortChangeNeeded && ` - Web to use port ${webAvailablePort} instead`,
+        webPortChangeNeeded && "of your currently configured",
+        webPortChangeNeeded && `${webPreferredPort}
+`,
+        "\nCannot run the development server until your configured ports are",
+        "changed or become available."
+      ].filter(Boolean).join(" ");
+      exitWithError(void 0, { message });
+    }
   }
   if (workspace.includes("api")) {
-    try {
-      await generatePrismaClient({
-        verbose: false,
-        force: false
-      });
-    } catch (e) {
-      const message = getErrorMessage(e);
-      errorTelemetry(process.argv, `Error generating prisma client: ${message}`);
-      console.error(c.error(message));
+    if (generate) {
+      try {
+        await generatePrismaClient({ verbose: false });
+      } catch (e) {
+        const message = getErrorMessage(e);
+        errorTelemetry(
+          process.argv,
+          `Error generating prisma client: ${message}`
+        );
+        console.error(c.error(message));
+      }
     }
-    if (!serverFile) {
+    if (!ud && !serverFile) {
+      if (typeof apiAvailablePort === "undefined" || apiAvailablePort === -1) {
+        exitWithError(void 0, {
+          message: `Could not determine a free port for the api server`
+        });
+      }
       try {
         await shutdownPort(apiAvailablePort);
       } catch (e) {
@@ -104,7 +160,7 @@ const handler = async ({
       }
     }
   }
-  if (workspace.includes("web")) {
+  if (workspace.includes("web") && webAvailablePort !== void 0) {
     try {
       await shutdownPort(webAvailablePort);
     } catch (e) {
@@ -115,56 +171,151 @@ const handler = async ({
       );
     }
   }
-  const cedarConfigPath = getConfigPath();
+  if (generate && workspace.includes("web") && getConfig().experimental?.gqlorm?.enabled) {
+    try {
+      await generateGqlormArtifacts();
+    } catch (e) {
+      const message = getErrorMessage(e);
+      console.error(c.error(`Error generating gqlorm schema: ${message}`));
+    }
+  }
   const streamingSsrEnabled = getConfig().experimental?.streamingSsr?.enabled;
   process.env.VITE_CJS_IGNORE_WARNING = "true";
-  let webCommand = `yarn cross-env NODE_ENV=development rw-vite-dev ${forward}`;
-  if (streamingSsrEnabled) {
-    webCommand = `yarn cross-env NODE_ENV=development rw-dev-fe ${forward}`;
-  }
   const rootPackageJsonPath = path.join(cedarPaths.base, "package.json");
   const rootPackageJson = JSON.parse(
     fs.readFileSync(rootPackageJsonPath, "utf8")
   );
-  const isEsm = rootPackageJson.type === "module";
-  const serverWatchCommand = isEsm ? `cedarjs-api-server-watch` : `rw-api-server-watch`;
+  const buildUnifiedDevCommand = () => {
+    if (!ud) {
+      return null;
+    }
+    if (streamingSsrEnabled) {
+      return null;
+    }
+    if (!workspace.includes("api") || !workspace.includes("web")) {
+      return null;
+    }
+    if (serverFile) {
+      return null;
+    }
+    if (!fs.existsSync(cedarPaths.api.src) || !fs.existsSync(cedarPaths.web.src)) {
+      console.log("api.src or web.src does not exist");
+      return null;
+    }
+    return [
+      formatViteDevBinCommand("cedar-unified-dev", nodeArgs),
+      `  --port ${webAvailablePort}`,
+      `  --apiPort ${apiAvailablePort}`,
+      getApiDebugFlag(apiDebugPort, apiAvailablePort),
+      debugBrk ? "--debug-brk" : "",
+      // `cedar-unified-dev` starts its own in-process jobs worker pool (see
+      // `jobsDevMiddleware.ts`) rather than relying on the nodemon-wrapped
+      // worker pushed below, so `--no-jobs` has to be forwarded explicitly -
+      // it isn't part of `forward` unless the user passed it after `--`.
+      jobsOption === false ? "--no-jobs" : "",
+      forward
+    ].join(" ").replace(/\s+/g, " ").trim();
+  };
+  const unifiedDevCommand = buildUnifiedDevCommand();
+  if (!unifiedDevCommand && apiPortChangeNeeded) {
+    const message = [
+      "The currently configured port for the development server is",
+      "unavailable. Suggested change to your port, which can be changed in",
+      "cedar.toml (or redwood.toml):\n",
+      ` - API to use port ${apiAvailablePort} instead`,
+      "of your currently configured",
+      `${apiPreferredPort}
+`,
+      "\nCannot run the development server until your configured port is",
+      "changed or becomes available."
+    ].filter(Boolean).join(" ");
+    exitWithError(void 0, { message });
+  }
   const jobs = [];
-  if (workspace.includes("api")) {
+  if (unifiedDevCommand) {
     jobs.push({
-      name: "api",
-      command: [
-        "yarn nodemon",
-        "  --quiet",
-        `  --watch "${cedarConfigPath}"`,
-        `  --exec "yarn ${serverWatchCommand}`,
-        `    --port ${apiAvailablePort}`,
-        `    ${getApiDebugFlag(apiDebugPort)}`,
-        '    | rw-log-formatter"'
-      ].join(" ").replace(/\s+/g, " "),
+      name: "dev",
+      command: unifiedDevCommand,
       env: {
         NODE_ENV: "development",
         NODE_OPTIONS: getDevNodeOptions()
       },
       prefixColor: "cyan",
-      runWhen: () => fs.existsSync(cedarPaths.api.src)
-    });
-  }
-  if (workspace.includes("web")) {
-    jobs.push({
-      name: "web",
-      command: webCommand,
-      prefixColor: "blue",
-      cwd: cedarPaths.web.base,
-      runWhen: () => fs.existsSync(cedarPaths.web.src)
+      cwd: cedarPaths.web.base
     });
+  } else {
+    if (workspace.includes("api")) {
+      const cedarConfigPath = getConfigPath();
+      jobs.push({
+        name: "api",
+        command: formatRunBinCommand("nodemon", [
+          "--quiet",
+          `--watch "${cedarConfigPath}"`,
+          `--exec "${formatRunBinCommand("cedar-api-server-watch")} --port ${apiAvailablePort} ${getApiDebugFlag(apiDebugPort, apiAvailablePort)} | ${formatRunBinCommand("cedar-log-formatter")}"`
+        ]),
+        env: {
+          NODE_ENV: "development",
+          NODE_OPTIONS: getDevNodeOptions()
+        },
+        prefixColor: "cyan",
+        runWhen: () => fs.existsSync(cedarPaths.api.src)
+      });
+    }
+    if (workspace.includes("web")) {
+      let webCommand = `${formatViteDevBinCommand("cedar-vite-dev", nodeArgs)} ${forward}`;
+      if (streamingSsrEnabled) {
+        webCommand = `${formatViteDevBinCommand("cedar-dev-fe", nodeArgs)} ${forward}`;
+      }
+      jobs.push({
+        name: "web",
+        command: webCommand,
+        env: {
+          NODE_ENV: "development"
+        },
+        prefixColor: "blue",
+        cwd: cedarPaths.web.base,
+        runWhen: () => fs.existsSync(cedarPaths.web.src)
+      });
+    }
   }
   if (generate) {
     jobs.push({
       name: "gen",
-      command: "yarn rw-gen-watch",
+      command: formatRunBinCommand("cedar-gen-watch"),
       prefixColor: "green"
     });
   }
+  const jobsConfigured = jobsOption !== false && workspace.includes("api") && !!cedarPaths.api.jobsConfig && // `getPaths()` resolves `jobsConfig` once and caches it in-process, so
+  // if `api/src/lib/jobs.ts` is deleted mid-session the cached path would
+  // otherwise still look "configured". Guard against starting a worker
+  // that can't load a jobs config that no longer exists.
+  fs.existsSync(cedarPaths.api.jobsConfig) && fs.existsSync(cedarPaths.api.jobs) && // Job files always live in `api/src/jobs/<ComponentName>Job/`
+  // subdirectories (see `generate/job/jobHandler.ts`), so entries here are
+  // directories, not files — only the `.keep` placeholder (and any stray
+  // dotfiles, e.g. `.DS_Store`) should be excluded.
+  fs.readdirSync(cedarPaths.api.jobs).some((entry) => !entry.startsWith("."));
+  if (jobsConfigured && unifiedDevCommand) {
+  } else if (jobsConfigured) {
+    jobs.push({
+      name: "jobs",
+      // `cedar-jobs work` loads its config and job files from `api/dist`
+      // (compiled output), not `api/src`. That dist output is only written
+      // once the `api` watcher's initial build finishes, which happens
+      // asynchronously — so on a clean `cedar dev` start there's a window
+      // where `api/dist` doesn't exist yet and the worker would exit
+      // immediately. Wrapping it in nodemon (same tool the `api` job above
+      // uses) means it retries as soon as `api/dist` changes, instead of
+      // staying dead for the rest of the session. This also means the
+      // worker restarts automatically whenever job code is rebuilt, since
+      // Node's ESM cache would otherwise keep serving stale job code.
+      command: formatRunBinCommand("nodemon", [
+        "--quiet",
+        `--watch "${cedarPaths.api.dist}"`,
+        `--exec "${formatRunBinCommand("cedar-jobs", ["work"])}"`
+      ]),
+      prefixColor: "magenta"
+    });
+  }
   const packageWorkspaces = workspace.filter(
     (w) => w !== "api" && w !== "web" && w !== "gen"
   );
@@ -211,7 +362,7 @@ const handler = async ({
     handleInput: true,
     outputStream
   });
-  result.catch((e) => {
+  result.then(() => process.exit(0)).catch((e) => {
     if (e?.message) {
       errorTelemetry(
         process.argv,

package/dist/commands/dev/packageWatchCommands.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { importStatementPath } from "@cedarjs/project-config";
-import c from "../../lib/colors.js";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { getConfig, importStatementPath } from "@cedarjs/project-config";
 import { getPaths } from "../../lib/index.js";
 async function getPackageWatchCommands(packageWorkspaces) {
   const cedarPaths = getPaths();
@@ -17,6 +17,7 @@ async function getPackageWatchCommands(packageWorkspaces) {
     }
     return importStatementPath(workspacePath);
   });
+  const packagesWorkspaceConfig = getConfig().experimental.packagesWorkspace;
   const watchablePackages = [];
   const packagesWithoutWatch = [];
   for (const workspacePath of workspacePaths) {
@@ -29,7 +30,11 @@ async function getPackageWatchCommands(packageWorkspaces) {
     if (packageJson.scripts?.watch) {
       watchablePackages.push(workspacePath);
     } else {
-      packagesWithoutWatch.push(packageName);
+      const packageConfig = packageName && packagesWorkspaceConfig[packageName];
+      const skipWatchWarning = typeof packageConfig === "object" && packageConfig.skipWatchWarning;
+      if (!skipWatchWarning) {
+        packagesWithoutWatch.push(packageName);
+      }
     }
   }
   if (packagesWithoutWatch.length > 0) {

package/dist/commands/dev.js

@@ -1,5 +1,5 @@
 import { terminalLink } from "termi-link";
-import c from "../lib/colors.js";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
 import { workspaces } from "../lib/project.js";
 import { checkNodeVersion } from "../middleware/checkNodeVersion.js";
 const command = "dev [workspace..]";
@@ -13,17 +13,27 @@ const builder = (yargs) => {
   }).option("forward", {
     alias: "fwd",
     description: 'String of one or more vite dev server config options, for example: `--fwd="--port=1234 --open=false"`',
-    type: "string",
-    // The reason `forward` is hidden is that it's been broken with Vite and
-    // it's not clear how to fix it.
-    hidden: true
+    type: "string"
   }).option("generate", {
     type: "boolean",
     default: true,
     description: "Generate artifacts"
   }).option("apiDebugPort", {
     type: "number",
-    description: "Port on which to expose API server debugger. If you supply the flag with no value it defaults to 18911."
+    description: "Port on which to expose API server debugger. If you supply the flag with no value it defaults to 1 prepended to the api port (e.g. api port 8913 -> debug port 18913)."
+  }).option("debugBrk", {
+    type: "boolean",
+    description: "Wait for a debugger to connect before starting the API dev server, similar to Node.js --inspect-brk. Only works in --ud mode."
+  }).option("ud", {
+    type: "boolean",
+    default: false,
+    description: "Use the unified Vite dev server that handles both web and API in a single process (experimental)."
+  }).option("nodeArgs", {
+    type: "string",
+    description: 'CLI args to pass to the node process running the web dev server, for example: `--node-args="--inspect --max-old-space-size=8192"`.'
+  }).option("jobs", {
+    type: "boolean",
+    description: "Start the background jobs worker alongside the other dev servers when jobs are configured (`cedar setup jobs` + at least one `cedar g job`). Pass `--no-jobs` to opt out and run `cedar jobs work` yourself instead."
   }).middleware(() => {
     const check = checkNodeVersion();
     if (check.ok) {

package/dist/commands/execHandler.js

@@ -3,25 +3,29 @@ import path from "node:path";
 import { context } from "@opentelemetry/api";
 import { suppressTracing } from "@opentelemetry/core";
 import { Listr } from "listr2";
-import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { Parser } from "yargs/helpers";
+import { colors as c } from "@cedarjs/cli-helpers/colors";
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
 import { findScripts } from "@cedarjs/internal/dist/files";
-import c from "../lib/colors.js";
 import { runScriptFunction } from "../lib/exec.js";
 import { generatePrismaClient } from "../lib/generatePrismaClient.js";
 import { getPaths } from "../lib/index.js";
 const printAvailableScriptsToConsole = () => {
-  const scripts = findScripts(getPaths().scripts).reduce((acc, scriptPath) => {
-    const relativePath = path.relative(getPaths().scripts, scriptPath);
-    const ext = path.parse(relativePath).ext;
-    const pathNoExt = relativePath.slice(0, -ext.length);
-    acc[pathNoExt] ||= [];
-    acc[pathNoExt].push(relativePath);
-    return acc;
-  }, {});
+  const scripts = findScripts(getPaths().scripts).reduce(
+    (acc, scriptPath) => {
+      const relativePath = path.relative(getPaths().scripts, scriptPath);
+      const ext = path.parse(relativePath).ext;
+      const pathNoExt = relativePath.slice(0, -ext.length);
+      acc[pathNoExt] ||= [];
+      acc[pathNoExt].push(relativePath);
+      return acc;
+    },
+    {}
+  );
   console.log("Available scripts:");
-  Object.entries(scripts).forEach(([name, paths]) => {
-    if (paths.length > 1) {
-      paths.forEach((scriptPath) => {
+  Object.entries(scripts).forEach(([name, scriptPaths]) => {
+    if (scriptPaths.length > 1) {
+      scriptPaths.forEach((scriptPath) => {
         console.log(c.info(`- ${scriptPath}`));
       });
     } else {
@@ -33,19 +37,32 @@ const printAvailableScriptsToConsole = () => {
 const handler = async (args) => {
   recordTelemetryAttributes({
     command: "exec",
-    prisma: args.prisma,
-    list: args.list
+    prisma: !!args.prisma,
+    list: !!args.list
   });
   const { name, prisma, list, ...scriptArgs } = args;
   if (list || !name) {
     printAvailableScriptsToConsole();
     return;
   }
-  scriptArgs._ = scriptArgs._.slice(1);
+  if (Array.isArray(scriptArgs._)) {
+    scriptArgs._ = scriptArgs._.slice(1);
+  }
   delete scriptArgs.$0;
   delete scriptArgs.l;
   delete scriptArgs.s;
   delete scriptArgs.silent;
+  if (Array.isArray(scriptArgs._)) {
+    const dashBlockIndex = scriptArgs._.findIndex(
+      (arg) => typeof arg === "string" && arg.startsWith("-")
+    );
+    if (dashBlockIndex !== -1) {
+      const unparsedTail = scriptArgs._.splice(dashBlockIndex);
+      const { _: reparsedPositionals, ...reparsedFlags } = Parser(unparsedTail);
+      scriptArgs._.push(...reparsedPositionals);
+      Object.assign(scriptArgs, reparsedFlags);
+    }
+  }
   const scriptPath = resolveScriptPath(name);
   if (!scriptPath) {
     console.error(
@@ -59,11 +76,10 @@ No script called \`${name}\` in the ./scripts folder.
   const scriptTasks = [
     {
       title: "Generating Prisma client",
-      enabled: () => prisma,
+      enabled: () => !!prisma,
       task: () => generatePrismaClient({
-        force: false,
         verbose: !args.silent,
-        silent: args.silent
+        silent: !!args.silent
       })
     },
     {
@@ -75,20 +91,24 @@ No script called \`${name}\` in the ./scripts folder.
             functionName: "default",
             args: { args: scriptArgs }
           });
-        } catch (e) {
-          console.error(c.error(`Error in script: ${e.message}`));
-          throw e;
+        } catch (error) {
+          console.error(c.error("\nError in script:"));
+          console.error(error);
+          throw error;
         }
       }
     }
   ];
   const tasks = new Listr(scriptTasks, {
-    rendererOptions: { collapseSubtasks: false },
     renderer: args.silent ? "silent" : "verbose"
   });
-  await context.with(suppressTracing(context.active()), async () => {
-    await tasks.run();
-  });
+  try {
+    await context.with(suppressTracing(context.active()), async () => {
+      await tasks.run();
+    });
+  } catch {
+    process.exit(1);
+  }
 };
 function resolveScriptPath(name) {
   const scriptPath = path.join(getPaths().scripts, name);
@@ -98,9 +118,9 @@ function resolveScriptPath(name) {
   const extensions = [".js", ".jsx", ".ts", ".tsx"];
   const matches = [];
   for (const extension of extensions) {
-    const p = scriptPath + extension;
-    if (fs.existsSync(p)) {
-      matches.push(p);
+    const candidate = scriptPath + extension;
+    if (fs.existsSync(candidate)) {
+      matches.push(candidate);
     }
   }
   if (matches.length === 1) {

package/dist/commands/experimental/live-queries/liveQueries.js

@@ -0,0 +1,32 @@
+import { recordTelemetryAttributes } from "@cedarjs/cli-helpers/telemetry";
+import { getEpilogue } from "../util.js";
+const command = "setup-live-queries";
+const description = "Setup live query invalidation with Postgres notifications";
+function builder(yargs) {
+  return yargs.option("force", {
+    alias: "f",
+    default: false,
+    description: "Overwrite existing configuration",
+    type: "boolean"
+  }).option("verbose", {
+    alias: "v",
+    default: false,
+    description: "Print more logs",
+    type: "boolean"
+  }).epilogue(getEpilogue(command, description));
+}
+async function handler(options) {
+  recordTelemetryAttributes({
+    command: `experimental ${command}`,
+    force: options.force,
+    verbose: options.verbose
+  });
+  const { handler: handler2 } = await import("./liveQueriesHandler.js");
+  return handler2(options);
+}
+export {
+  builder,
+  command,
+  description,
+  handler
+};