Squashed commit of the following:

commit c028db2
Author: Matt Aitken <[email protected]>
Date:   Fri Oct 13 16:04:54 2023 +0100

    Some fixes for getting the endpoint id

commit e31b7ac
Author: Matt Aitken <[email protected]>
Date:   Fri Oct 13 15:39:18 2023 +0100

    Added a link in the instructions if Node isn’t detected

commit 1a59cce
Author: Matt Aitken <[email protected]>
Date:   Fri Oct 13 15:39:05 2023 +0100

    Fixed some conflict issues

commit 77263ed
Author: Matt Aitken <[email protected]>
Date:   Fri Oct 13 15:38:56 2023 +0100

    Added a changeset

commit 1a7df3f
Author: GuyBorderless <[email protected]>
Date:   Fri Oct 13 17:31:01 2023 +0300

    feat: enable deno  (#531)

    * adding deno reference project and JSRuntime file

    * accessing runtime specific functions through JsRuntime

    * adding support for both deno.json and deno.jsonc

    * no automatic setup for deno projects currently

    ---------

    Co-authored-by: Guy Kedem <[email protected]>
    Co-authored-by: Matt Aitken <[email protected]>

Author: matt-aitken

.changeset/famous-files-talk.md

@@ -0,0 +1,5 @@
+---
+"@trigger.dev/cli": patch
+---
+
+Detects JSRuntime (Node/Deno at the moment). Adds basic Deno support

.vscode/extensions.json

@@ -0,0 +1,9 @@
+{
+	"recommendations": [
+        "astro-build.astro-vscode",
+        "denoland.vscode-deno"
+    ],
+	"unwantedRecommendations": [
+		
+	]
+}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "deno.enablePaths": ["references/deno-reference"]
+}

packages/cli/src/commands/dev.ts

@@ -1,22 +1,18 @@
 import boxen from "boxen";
-import chalk from "chalk";
 import childProcess from "child_process";
 import chokidar from "chokidar";
-import fs from "fs/promises";
 import ngrok from "ngrok";
-import { run as ncuRun } from "npm-check-updates";
 import ora, { Ora } from "ora";
 import pRetry, { AbortError } from "p-retry";
-import pathModule from "path";
 import util from "util";
 import { z } from "zod";
-import { Framework, getFramework } from "../frameworks";
+import { Framework } from "../frameworks";
 import { standardWatchFilePaths, standardWatchIgnoreRegex } from "../frameworks/watchConfig";
 import { telemetryClient } from "../telemetry/telemetry";
 import { getEnvFilename } from "../utils/env";
 import fetch from "../utils/fetchUseProxy";
 import { getTriggerApiDetails } from "../utils/getTriggerApiDetails";
-import { getUserPackageManager } from "../utils/getUserPkgManager";
+import { JsRuntime, getJsRuntime } from "../utils/jsRuntime";
 import { logger } from "../utils/logger";
 import { resolvePath } from "../utils/parseNameAndPath";
 import { RequireKeys } from "../utils/requiredKeys";
@@ -45,6 +41,8 @@ const formattedDate = new Intl.DateTimeFormat("en", {
   second: "numeric",
 });
 
+let runtime: JsRuntime;
+
 export async function devCommand(path: string, anyOptions: any) {
   telemetryClient.dev.started(path, anyOptions);
 
@@ -57,12 +55,12 @@ export async function devCommand(path: string, anyOptions: any) {
   const options = result.data;
 
   const resolvedPath = resolvePath(path);
-
+  runtime = await getJsRuntime(resolvedPath, logger);
   //check for outdated packages, don't await this
-  checkForOutdatedPackages(resolvedPath);
+  runtime.checkForOutdatedPackages();
 
   // Read from package.json to get the endpointId
-  const endpointId = await getEndpointIdFromPackageJson(resolvedPath, options);
+  const endpointId = await getEndpointId(runtime, options.clientId);
   if (!endpointId) {
     logger.error(
       "You must run the `init` command first to setup the project – you are missing \n'trigger.dev': { 'endpointId': 'your-client-id' } from your package.json file, or pass in the --client-id option to this command"
@@ -73,8 +71,8 @@ export async function devCommand(path: string, anyOptions: any) {
   logger.success(`✔️ [trigger.dev] Detected TriggerClient id: ${endpointId}`);
 
   //resolve the options using the detected framework (use default if there isn't a matching framework)
-  const packageManager = await getUserPackageManager(resolvedPath);
-  const framework = await getFramework(resolvedPath, packageManager);
+  const packageManager = await runtime.getUserPackageManager();
+  const framework = await runtime.getFramework();
   const resolvedOptions = await resolveOptions(framework, resolvedPath, options);
 
   // Read from .env.local or .env to get the TRIGGER_API_KEY and TRIGGER_API_URL
@@ -250,8 +248,7 @@ async function startIndexing({
   apiClient,
 }: RefreshOptions & { apiClient: TriggerApi }) {
   spinner.start();
-
-  const refreshedEndpointId = await getEndpointIdFromPackageJson(path, resolvedOptions);
+  const refreshedEndpointId = await getEndpointId(runtime, resolvedOptions.clientId);
 
   const authorizedKey = await apiClient.whoami();
   if (!authorizedKey) {
@@ -396,43 +393,10 @@ async function verifyEndpoint(
   return;
 }
 
-export async function checkForOutdatedPackages(path: string) {
-  const updates = (await ncuRun({
-    packageFile: `${path}/package.json`,
-    filter: "/trigger.dev/.+$/",
-    upgrade: false,
-  })) as {
-    [key: string]: string;
-  };
-
-  if (typeof updates === "undefined" || Object.keys(updates).length === 0) {
-    return;
-  }
-
-  const packageFile = await fs.readFile(`${path}/package.json`);
-  const data = JSON.parse(Buffer.from(packageFile).toString("utf8"));
-  const dependencies = data.dependencies;
-  console.log(chalk.bgYellow("Updates available for trigger.dev packages"));
-  console.log(chalk.bgBlue("Run npx @trigger.dev/cli@latest update"));
-
-  for (let dep in updates) {
-    console.log(`${dep}  ${dependencies[dep]}  →  ${updates[dep]}`);
-  }
-}
-
-export async function getEndpointIdFromPackageJson(path: string, options: DevCommandOptions) {
-  if (options.clientId) {
-    return options.clientId;
-  }
-
-  const pkgJsonPath = pathModule.join(path, "package.json");
-  const pkgBuffer = await fs.readFile(pkgJsonPath);
-  const pkgJson = JSON.parse(pkgBuffer.toString());
-
-  const value = pkgJson["trigger.dev"]?.endpointId;
-  if (!value || typeof value !== "string") return;
-
-  return value as string;
+export function getEndpointId(runtime: JsRuntime, clientId?: string) {
+  if (clientId) {
+    return clientId;
+  } else return runtime.getEndpointId();
 }
 
 async function resolveEndpointUrl(apiUrl: string, port: number, hostname: string) {

packages/cli/src/commands/init.ts

@@ -22,6 +22,7 @@ import { resolvePath } from "../utils/parseNameAndPath";
 import { readPackageJson } from "../utils/readPackageJson";
 import { renderTitle } from "../utils/renderTitle";
 import { TriggerApi, WhoamiResponse } from "../utils/triggerApi";
+import { getJsRuntime } from "../utils/jsRuntime";
 
 export type InitCommandOptions = {
   projectPath: string;
@@ -38,6 +39,19 @@ export const initCommand = async (options: InitCommandOptions) => {
 
   const resolvedPath = resolvePath(options.projectPath);
 
+  // assuming nodejs by default
+  let runtimeId: string = "nodejs";
+  try {
+    runtimeId = (await getJsRuntime(resolvedPath, logger)).id;
+  } catch {}
+  if (runtimeId !== "nodejs") {
+    logger.error(
+      `We currently only support automatic setup for NodeJS projects. This is a ${runtimeId} project. View our manual installation guides here: https://trigger.dev/docs/documentation/quickstarts/introduction`
+    );
+    telemetryClient.init.failed("not_supported_runtime", options);
+    return;
+  }
+
   await renderTitle(resolvedPath);
 
   if (options.triggerUrl === CLOUD_TRIGGER_URL) {

packages/cli/src/commands/whoami.ts

@@ -2,9 +2,10 @@ import { z } from "zod";
 import { logger } from "../utils/logger";
 import { resolvePath } from "../utils/parseNameAndPath";
 import { TriggerApi } from "../utils/triggerApi";
-import { DevCommandOptions, getEndpointIdFromPackageJson } from "./dev";
+import { DevCommandOptions, getEndpointId } from "./dev";
 import ora from "ora";
 import { getTriggerApiDetails } from "../utils/getTriggerApiDetails";
+import { getJsRuntime } from "../utils/jsRuntime";
 
 export const WhoAmICommandOptionsSchema = z.object({
   envFile: z.string(),
@@ -26,7 +27,8 @@ export async function whoamiCommand(path: string, anyOptions: any) {
   const resolvedPath = resolvePath(path);
 
   // Read from package.json to get the endpointId
-  const endpointId = await getEndpointIdFromPackageJson(resolvedPath, options as DevCommandOptions);
+  const runtime = await getJsRuntime(resolvedPath, logger);
+  const endpointId = await getEndpointId(runtime);
   if (!endpointId) {
     logger.error(
       "You must run the `init` command first to setup the project – you are missing \n'trigger.dev': { 'endpointId': 'your-client-id' } from your package.json file, or pass in the --client-id option to this command"

packages/cli/src/utils/jsRuntime.ts

@@ -0,0 +1,137 @@
+import { Framework, getFramework } from "../frameworks";
+import { PackageManager, getUserPackageManager } from "./getUserPkgManager";
+import { Logger } from "./logger";
+import { run as ncuRun } from "npm-check-updates";
+import chalk from "chalk";
+import fs from "fs/promises";
+import pathModule from "path";
+
+export abstract class JsRuntime {
+  logger: Logger;
+  projectRootPath: string;
+  constructor(projectRootPath: string, logger: Logger) {
+    this.logger = logger;
+    this.projectRootPath = projectRootPath;
+  }
+  abstract get id(): string;
+  abstract checkForOutdatedPackages(): Promise<void>;
+  abstract getUserPackageManager(): Promise<PackageManager | undefined>;
+  abstract getFramework(): Promise<Framework | undefined>;
+  abstract getEndpointId(): Promise<string | undefined>;
+}
+
+export async function getJsRuntime(projectRootPath: string, logger: Logger): Promise<JsRuntime> {
+  if (await NodeJsRuntime.isNodeJsRuntime(projectRootPath)) {
+    return new NodeJsRuntime(projectRootPath, logger);
+  } else if (await DenoRuntime.isDenoJsRuntime(projectRootPath)) {
+    return new DenoRuntime(projectRootPath, logger);
+  }
+  throw new Error("Unsupported runtime");
+}
+
+class NodeJsRuntime extends JsRuntime {
+  static async isNodeJsRuntime(projectRootPath: string): Promise<boolean> {
+    try {
+      await fs.stat(pathModule.join(projectRootPath, "package.json"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  get id() {
+    return "nodejs";
+  }
+  get packageJsonPath(): string {
+    return pathModule.join(this.projectRootPath, "package.json");
+  }
+
+  async checkForOutdatedPackages(): Promise<void> {
+    const updates = (await ncuRun({
+      packageFile: `${this.packageJsonPath}`,
+      filter: "/trigger.dev/.+$/",
+      upgrade: false,
+    })) as {
+      [key: string]: string;
+    };
+
+    if (typeof updates === "undefined" || Object.keys(updates).length === 0) {
+      return;
+    }
+
+    const packageFile = await fs.readFile(this.packageJsonPath);
+    const data = JSON.parse(Buffer.from(packageFile).toString("utf8"));
+    const dependencies = data.dependencies;
+    console.log(chalk.bgYellow("Updates available for trigger.dev packages"));
+    console.log(chalk.bgBlue("Run npx @trigger.dev/cli@latest update"));
+
+    for (let dep in updates) {
+      console.log(`${dep}  ${dependencies[dep]}  →  ${updates[dep]}`);
+    }
+  }
+
+  async getUserPackageManager() {
+    return getUserPackageManager(this.projectRootPath);
+  }
+
+  async getFramework() {
+    const userPackageManager = await this.getUserPackageManager();
+    return getFramework(this.projectRootPath, userPackageManager);
+  }
+  async getEndpointId() {
+    const pkgJsonPath = pathModule.join(this.projectRootPath, "package.json");
+    const pkgBuffer = await fs.readFile(pkgJsonPath);
+    const pkgJson = JSON.parse(pkgBuffer.toString());
+    const value = pkgJson["trigger.dev"]?.endpointId;
+    if (!value || typeof value !== "string") return undefined;
+    return value;
+  }
+}
+
+class DenoRuntime extends JsRuntime {
+  getDenoJsonPath(): Promise<string> {
+    try {
+      return fs
+        .stat(pathModule.join(this.projectRootPath, "deno.json"))
+        .then(() => pathModule.join(this.projectRootPath, "deno.json"));
+    } catch {
+      return fs
+        .stat(pathModule.join(this.projectRootPath, "deno.jsonc"))
+        .then(() => pathModule.join(this.projectRootPath, "deno.jsonc"));
+    }
+  }
+
+  get id() {
+    return "deno";
+  }
+
+  static async isDenoJsRuntime(projectRootPath: string): Promise<boolean> {
+    try {
+      try {
+        await fs.stat(pathModule.join(projectRootPath, "deno.json"));
+      } catch (e) {
+        await fs.stat(pathModule.join(projectRootPath, "deno.jsonc"));
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async checkForOutdatedPackages() {
+    // not implemented currently
+  }
+  async getUserPackageManager() {
+    return undefined;
+  }
+  async getFramework() {
+    // not implemented currently
+    return undefined;
+  }
+  async getEndpointId() {
+    const pkgJsonPath = await this.getDenoJsonPath();
+    const pkgBuffer = await fs.readFile(pkgJsonPath);
+    const pkgJson = JSON.parse(pkgBuffer.toString());
+    return pkgJson["trigger.dev"]?.endpointId;
+  }
+}

packages/cli/src/utils/logger.ts

@@ -1,5 +1,6 @@
 import chalk from "chalk";
 
+export type Logger = typeof logger;
 export const logger = {
   error(...args: unknown[]) {
     console.log(chalk.red(...args));

references/deno-reference/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "deno.enable": true
+}

references/deno-reference/deno.json

@@ -0,0 +1,8 @@
+{
+  "trigger.dev": {
+    "endpointId": "borderless" 
+  },
+  "tasks": {
+    "dev": "deno run --watch main.ts"
+  }
+}