trigger.dev 0.0.0-v3-prerelease-20240708183321 → 0.0.0-v3-prerelease-20240730135037

package/dist/Containerfile.prod

@@ -43,12 +43,14 @@ ARG TRIGGER_DEPLOYMENT_ID
 ARG TRIGGER_DEPLOYMENT_VERSION
 ARG TRIGGER_CONTENT_HASH
 ARG TRIGGER_PROJECT_REF
+ARG NODE_EXTRA_CA_CERTS
 
 ENV TRIGGER_PROJECT_ID=${TRIGGER_PROJECT_ID} \
     TRIGGER_DEPLOYMENT_ID=${TRIGGER_DEPLOYMENT_ID} \
     TRIGGER_DEPLOYMENT_VERSION=${TRIGGER_DEPLOYMENT_VERSION} \
     TRIGGER_CONTENT_HASH=${TRIGGER_CONTENT_HASH} \
     TRIGGER_PROJECT_REF=${TRIGGER_PROJECT_REF} \
+    NODE_EXTRA_CA_CERTS=${NODE_EXTRA_CA_CERTS} \
     NODE_ENV=production
 
 USER node

package/dist/index.js

@@ -798,7 +798,7 @@ import invariant from "tiny-invariant";
 import { z as z4 } from "zod";
 
 // package.json
-var version = "0.0.0-v3-prerelease-20240708183321";
+var version = "0.0.0-v3-prerelease-20240730135037";
 var dependencies = {
   "@anatine/esbuild-decorators": "^0.2.19",
   "@clack/prompts": "^0.7.0",
@@ -815,7 +815,7 @@ var dependencies = {
   "@opentelemetry/sdk-trace-base": "^1.22.0",
   "@opentelemetry/sdk-trace-node": "^1.22.0",
   "@opentelemetry/semantic-conventions": "^1.22.0",
-  "@trigger.dev/core": "workspace:0.0.0-v3-prerelease-20240708183321",
+  "@trigger.dev/core": "workspace:0.0.0-v3-prerelease-20240730135037",
   "@types/degit": "^2.8.3",
   chalk: "^5.2.0",
   chokidar: "^3.5.3",
@@ -1321,7 +1321,7 @@ function initializeTracing() {
     resource,
     spanLimits: {
       attributeCountLimit: 1e3,
-      attributeValueLengthLimit: 1e3,
+      attributeValueLengthLimit: 2048,
       eventCountLimit: 100,
       attributePerEventCountLimit: 100,
       linkCountLimit: 10,
@@ -1793,6 +1793,13 @@ async function resolveConfig(path7, config) {
   if (!config.tsconfigPath) {
     config.tsconfigPath = await findFilePath(path7, "tsconfig.json");
   }
+  if (!config.additionalFiles) {
+    config.additionalFiles = [];
+  }
+  if (config.extraCACerts) {
+    config.additionalFiles.push(config.extraCACerts);
+    config.extraCACerts = config.extraCACerts.replace(/^(\.[.]?\/)+/, "");
+  }
   return config;
 }
 async function normalizeConfig(config, overrides) {
@@ -2651,6 +2658,30 @@ URL: ${chalkLink(authentication.auth.apiUrl)}
   return userData;
 }
 
+// src/utilities/linux.ts
+import { spawn } from "child_process";
+var isLinuxServer = async () => {
+  if (process.platform !== "linux") {
+    return false;
+  }
+  const xdgAvailable = await new Promise((res) => {
+    const xdg = spawn("xdg-open");
+    xdg.on("error", (error) => {
+      logger.debug("Error while checking for xdg-open", error);
+      res(false);
+    });
+    xdg.on("spawn", () => {
+      res(true);
+    });
+    xdg.on("exit", (code) => {
+      res(code === 0);
+    });
+    xdg.unref();
+  });
+  logger.debug("xdg-open available:", xdgAvailable);
+  return !xdgAvailable;
+};
+
 // src/commands/login.ts
 var LoginCommandOptions = CommonCommandOptions.extend({
   apiUrl: z3.string()
@@ -2793,7 +2824,13 @@ async function login(options) {
         `Please visit the following URL to login:
 ${chalkLink(authorizationCodeResult.url)}`
       );
-      await open_default(authorizationCodeResult.url);
+      if (await isLinuxServer()) {
+        logger.debug(
+          "Will not open login URL automatically, please install `xdg-utils` to change this behavior."
+        );
+      } else {
+        await open_default(authorizationCodeResult.url);
+      }
       const getPersonalAccessTokenSpinner = spinner();
       getPersonalAccessTokenSpinner.start("Waiting for you to login");
       try {
@@ -3006,7 +3043,7 @@ function workerSetupImportConfigPlugin(configPath) {
     }
   };
 }
-function bundleDependenciesPlugin(buildIdentifier, dependenciesToBundle, tsconfigPath) {
+function bundleDependenciesPlugin(buildIdentifier, dependencies2, dependenciesToBundle, tsconfigPath) {
   const matchPath = tsconfigPath ? createMatchPath(tsconfigPath) : void 0;
   function resolvePath(id) {
     if (!matchPath) {
@@ -3038,6 +3075,9 @@ function bundleDependenciesPlugin(buildIdentifier, dependenciesToBundle, tsconfi
             return void 0;
           }
         }
+        if (dependencies2[args.path] && !dependencies2[args.path].external) {
+          return void 0;
+        }
         logger.debug(`[${buildIdentifier}] Externalizing ${args.path}`, {
           ...args
         });
@@ -3437,10 +3477,33 @@ var JavascriptProject = class {
       });
     }
   }
-  async resolveAll(packageNames, options) {
+  async extractDirectDependenciesMeta() {
+    return tracer.startActiveSpan(
+      "JavascriptProject.extractDirectDependenciesMeta",
+      async (span) => {
+        const command = await this.#getCommand();
+        span.setAttributes({
+          packageManager: command.name
+        });
+        try {
+          span.end();
+          return await command.extractDirectDependenciesMeta({
+            cwd: this.projectPath
+          });
+        } catch (error) {
+          recordSpanException4(span, error);
+          span.end();
+          logger.debug(`Failed to resolve internal dependencies using ${command.name}`, {
+            error
+          });
+          throw error;
+        }
+      }
+    );
+  }
+  async resolveAll(packageNames) {
     return tracer.startActiveSpan("JavascriptProject.resolveAll", async (span) => {
       const externalPackages = packageNames.filter((packageName) => !isBuiltInModule(packageName));
-      const opts = { allowDev: false, ...options };
       const command = await this.#getCommand();
       span.setAttributes({
         externalPackages,
@@ -3468,15 +3531,6 @@ var JavascriptProject = class {
             });
             missingPackageVersions[packageName] = packageJsonVersion;
           }
-          if (opts.allowDev) {
-            const devPackageJsonVersion = this.packageJson.devDependencies?.[packageName];
-            if (typeof devPackageJsonVersion === "string") {
-              logger.debug(`Resolved ${packageName} version using devDependencies`, {
-                devPackageJsonVersion
-              });
-              missingPackageVersions[packageName] = devPackageJsonVersion;
-            }
-          }
         }
         span.setAttributes({
           ...flattenAttributes2(missingPackageVersions, "missingPackageVersions"),
@@ -3586,6 +3640,36 @@ var PNPMCommands = class {
     }
     return results;
   }
+  async extractDirectDependenciesMeta(options) {
+    const result = await this.#listDirectDependencies(options);
+    logger.debug(`Extracting direct dependencies metadata using ${this.name}`);
+    const results = {};
+    for (const projectPkg of result) {
+      results[projectPkg.name] = { version: projectPkg.version, external: false };
+      if (projectPkg.dependencies) {
+        for (const [name, dep] of Object.entries(projectPkg.dependencies)) {
+          const { version: version2 } = dep;
+          results[name] = {
+            version: version2,
+            external: !version2.startsWith("link:")
+          };
+        }
+      }
+    }
+    return results;
+  }
+  async #listDirectDependencies(options) {
+    const childProcess2 = await $({
+      cwd: options.cwd,
+      reject: false
+    })`${this.cmd} list --recursive --json`;
+    if (childProcess2.failed) {
+      logger.debug("Failed to list dependencies, using stdout anyway...", {
+        error: childProcess2
+      });
+    }
+    return JSON.parse(childProcess2.stdout);
+  }
   async #listDependencies(packageNames, options) {
     const childProcess2 = await $({
       cwd: options.cwd,
@@ -3593,7 +3677,7 @@ var PNPMCommands = class {
     })`${this.cmd} list ${packageNames} -r --json`;
     if (childProcess2.failed) {
       logger.debug("Failed to list dependencies, using stdout anyway...", {
-        error: childProcess2.stderr
+        error: childProcess2
       });
     }
     return JSON.parse(childProcess2.stdout);
@@ -3628,6 +3712,23 @@ var NPMCommands = class {
     }
     return results;
   }
+  async extractDirectDependenciesMeta(options) {
+    const result = await this.#listDirectDependencies(options);
+    logger.debug(`Extracting direct dependencies metadata using ${this.name}`);
+    return result.dependencies ? this.#flattenDependenciesMeta(result.dependencies) : {};
+  }
+  async #listDirectDependencies(options) {
+    const childProcess2 = await $({
+      cwd: options.cwd,
+      reject: false
+    })`${this.cmd} list --json`;
+    if (childProcess2.failed) {
+      logger.debug("Failed to list dependencies, using stdout anyway...", {
+        error: childProcess2
+      });
+    }
+    return JSON.parse(childProcess2.stdout);
+  }
   async #listDependencies(packageNames, options) {
     const childProcess2 = await $({
       cwd: options.cwd,
@@ -3635,7 +3736,7 @@ var NPMCommands = class {
     })`${this.cmd} list ${packageNames} --json`;
     if (childProcess2.failed) {
       logger.debug("Failed to list dependencies, using stdout anyway...", {
-        error: childProcess2.stderr
+        error: childProcess2
       });
     }
     return JSON.parse(childProcess2.stdout);
@@ -3653,6 +3754,17 @@ var NPMCommands = class {
       }
     }
   }
+  #flattenDependenciesMeta(dependencies2) {
+    let results = {};
+    for (const [name, dep] of Object.entries(dependencies2)) {
+      const { version: version2, resolved, dependencies: children } = dep;
+      results[name] = { version: version2, external: !!resolved && !resolved.startsWith("file:") };
+      if (children) {
+        results = { ...results, ...this.#flattenDependenciesMeta(children) };
+      }
+    }
+    return results;
+  }
 };
 var YarnCommands = class {
   get name() {
@@ -3690,6 +3802,30 @@ var YarnCommands = class {
     }
     return results;
   }
+  async extractDirectDependenciesMeta(options) {
+    const result = await this.#listDirectDependencies(options);
+    const rawPackagesData = result.split("\n");
+    logger.debug(`Extracting direct dependencies metadata using ${this.name}`);
+    const results = {};
+    for (const rawPackageData of rawPackagesData) {
+      const packageData = JSON.parse(rawPackageData);
+      const [name, dependencyMeta] = this.#parseYarnValueIntoDependencyMeta(packageData.value);
+      results[name] = dependencyMeta;
+    }
+    return results;
+  }
+  async #listDirectDependencies(options) {
+    const childProcess2 = await $({
+      cwd: options.cwd,
+      reject: false
+    })`${this.cmd} info --all --json`;
+    if (childProcess2.failed) {
+      logger.debug("Failed to list dependencies, using stdout anyway...", {
+        error: childProcess2
+      });
+    }
+    return childProcess2.stdout;
+  }
   async #listDependencies(packageNames, options) {
     const childProcess2 = await $({
       cwd: options.cwd,
@@ -3697,7 +3833,7 @@ var YarnCommands = class {
     })`${this.cmd} info ${packageNames} --json`;
     if (childProcess2.failed) {
       logger.debug("Failed to list dependencies, using stdout anyway...", {
-        error: childProcess2.stderr
+        error: childProcess2
       });
     }
     return childProcess2.stdout;
@@ -3713,6 +3849,26 @@ var YarnCommands = class {
     }
     return parts[0];
   }
+  #parseYarnValueIntoDependencyMeta(value) {
+    const parts = value.split("@");
+    let name, protocol, version2;
+    if (parts.length === 3) {
+      name = `@${parts[1]}`;
+      [protocol = "", version2 = ""] = parts[2].split(":");
+    } else if (parts.length === 2) {
+      name = parts[0].toString();
+      [protocol = "", version2 = ""] = parts[1].split(":");
+    } else {
+      throw new Error("Failed parsing ${value} into dependency meta");
+    }
+    return [
+      name,
+      {
+        version: version2,
+        external: protocol !== "workspace" && protocol !== "file"
+      }
+    ];
+  }
 };
 function isBuiltInModule(module) {
   if (module.startsWith("node:")) {
@@ -4202,7 +4358,8 @@ ${authorization.error}`
         buildPlatform: options.buildPlatform,
         pushImage: options.push,
         selfHostedRegistry: !!options.registry,
-        noCache: options.noCache
+        noCache: options.noCache,
+        extraCACerts: resolvedConfig.config.extraCACerts
       });
     }
     if (!deploymentResponse.data.externalBuildData) {
@@ -4226,7 +4383,8 @@ ${authorization.error}`
         projectRef: resolvedConfig.config.project,
         loadImage: options.loadImage,
         buildPlatform: options.buildPlatform,
-        noCache: options.noCache
+        noCache: options.noCache,
+        extraCACerts: resolvedConfig.config.extraCACerts
       },
       deploymentSpinner
     );
@@ -4443,6 +4601,14 @@ Did you include it in config.additionalFiles? ${cliLink(
         docs.config.prisma
       )}`
     },
+    {
+      regex: /@prisma\/client did not initialize yet/,
+      message: `Prisma client not initialized yet.
+Did you forget to add the postinstall script? ${cliLink(
+        "Config docs",
+        docs.config.prisma
+      )}`
+    },
     {
       regex: /sh: 1: (?<packageOrBinary>.*): not found/,
       message: `$packageOrBinary not found
@@ -4563,6 +4729,7 @@ async function buildAndPushImage(options, updater) {
       `TRIGGER_CONTENT_HASH=${options.contentHash}`,
       "--build-arg",
       `TRIGGER_PROJECT_REF=${options.projectRef}`,
+      ...options.extraCACerts ? ["--build-arg", `NODE_EXTRA_CA_CERTS=${options.extraCACerts}`] : [],
       "-t",
       `${options.registryHost}/${options.imageTag}`,
       ".",
@@ -4653,6 +4820,7 @@ async function buildAndPushSelfHostedImage(options) {
       `TRIGGER_CONTENT_HASH=${options.contentHash}`,
       "--build-arg",
       `TRIGGER_PROJECT_REF=${options.projectRef}`,
+      ...options.extraCACerts ? ["--build-arg", `NODE_EXTRA_CA_CERTS=${options.extraCACerts}`] : [],
       "-t",
       imageRef,
       "."
@@ -4824,6 +4992,7 @@ async function compileProject(config, options, configPath) {
           mockServerOnlyPlugin(),
           bundleDependenciesPlugin(
             "workerFacade",
+            {},
             config.dependenciesToBundle,
             config.tsconfigPath
           ),
@@ -4875,6 +5044,7 @@ async function compileProject(config, options, configPath) {
         plugins: [
           bundleDependenciesPlugin(
             "entryPoint.ts",
+            {},
             config.dependenciesToBundle,
             config.tsconfigPath
           )
@@ -5707,20 +5877,31 @@ var BackgroundWorker = class {
       }, 2e4);
       child.on("message", async (msg) => {
         const message = this._handler.parseMessage(msg);
-        if (message.type === "TASKS_READY" && !resolved) {
+        if (!message.success) {
           clearTimeout(timeout);
           resolved = true;
-          resolve6(message.payload.tasks);
+          reject(new Error(`Failed to parse message: ${message.error}`));
           child.kill();
-        } else if (message.type === "UNCAUGHT_EXCEPTION") {
+          return;
+        }
+        if (message.data.type === "TASKS_READY" && !resolved) {
           clearTimeout(timeout);
           resolved = true;
-          reject(new UncaughtExceptionError(message.payload.error, message.payload.origin));
+          resolve6(message.data.payload.tasks);
+          child.kill();
+        } else if (message.data.type === "UNCAUGHT_EXCEPTION") {
+          clearTimeout(timeout);
+          resolved = true;
+          reject(
+            new UncaughtExceptionError(message.data.payload.error, message.data.payload.origin)
+          );
           child.kill();
-        } else if (message.type === "TASKS_FAILED_TO_PARSE") {
+        } else if (message.data.type === "TASKS_FAILED_TO_PARSE") {
           clearTimeout(timeout);
           resolved = true;
-          reject(new TaskMetadataParseError(message.payload.zodIssues, message.payload.tasks));
+          reject(
+            new TaskMetadataParseError(message.data.payload.zodIssues, message.data.payload.tasks)
+          );
           child.kill();
         }
       });
@@ -6123,9 +6304,13 @@ var TaskRunProcess = class {
   }
   async #handleMessage(msg) {
     const message = this._handler.parseMessage(msg);
-    switch (message.type) {
+    if (!message.success) {
+      logger.error(`Dropping message: ${message.error}`, { message });
+      return;
+    }
+    switch (message.data.type) {
       case "TASK_RUN_COMPLETED": {
-        const { result, execution } = message.payload;
+        const { result, execution } = message.data.payload;
         logger.debug(`[${this.runId}] task run completed`, {
           result
         });
@@ -6151,7 +6336,7 @@ var TaskRunProcess = class {
         if (this.messageId) {
           this.onTaskRunHeartbeat.post(this.messageId);
         } else {
-          this.onTaskHeartbeat.post(message.payload.id);
+          this.onTaskHeartbeat.post(message.data.payload.id);
         }
         break;
       }
@@ -6460,10 +6645,14 @@ function useDev({
       `${dashboardUrl}/projects/v3/${config.project}`
     );
     websocket.addEventListener("open", async (event) => {
+      logger.debug("WebSocket opened", { event });
     });
     websocket.addEventListener("close", (event) => {
+      logger.debug("WebSocket closed", { event });
     });
     websocket.addEventListener("error", (event) => {
+      logger.log(`${chalkError("WebSocketError:")} ${event.error.message}`);
+      logger.debug("WebSocket error", { event, rawError: event.error });
     });
     backgroundWorkerCoordinator.onWorkerTaskHeartbeat.attach(
       async ({ worker, backgroundWorkerId, id }) => {
@@ -6521,29 +6710,40 @@ function useDev({
       });
     });
     websocket.addEventListener("message", async (event) => {
-      const data = JSON.parse(
-        typeof event.data === "string" ? event.data : new TextDecoder("utf-8").decode(event.data)
-      );
-      const messageHandler = new ZodMessageHandler2({
-        schema: serverWebsocketMessages,
-        messages: {
-          SERVER_READY: async (payload) => {
-            for (const worker of backgroundWorkerCoordinator.currentWorkers) {
-              await sender.send("READY_FOR_TASKS", {
-                backgroundWorkerId: worker.id,
-                inProgressRuns: worker.worker.inProgressRuns
-              });
+      try {
+        const data = JSON.parse(
+          typeof event.data === "string" ? event.data : new TextDecoder("utf-8").decode(event.data)
+        );
+        const messageHandler = new ZodMessageHandler2({
+          schema: serverWebsocketMessages,
+          messages: {
+            SERVER_READY: async (payload) => {
+              for (const worker of backgroundWorkerCoordinator.currentWorkers) {
+                await sender.send("READY_FOR_TASKS", {
+                  backgroundWorkerId: worker.id,
+                  inProgressRuns: worker.worker.inProgressRuns
+                });
+              }
+            },
+            BACKGROUND_WORKER_MESSAGE: async (payload) => {
+              await backgroundWorkerCoordinator.handleMessage(
+                payload.backgroundWorkerId,
+                payload.data
+              );
             }
-          },
-          BACKGROUND_WORKER_MESSAGE: async (payload) => {
-            await backgroundWorkerCoordinator.handleMessage(
-              payload.backgroundWorkerId,
-              payload.data
-            );
           }
+        });
+        await messageHandler.handleMessage(data);
+      } catch (error) {
+        if (error instanceof Error) {
+          logger.error("Error while handling websocket message", { error: error.message });
+        } else {
+          logger.error(
+            "Unkown error while handling websocket message, use `-l debug` for additional output"
+          );
+          logger.debug("Error while handling websocket message", { error });
         }
-      });
-      await messageHandler.handleMessage(data);
+      }
     });
     let ctx;
     let firstBuild = true;
@@ -6608,6 +6808,7 @@ function useDev({
           bundleTriggerDevCore("workerFacade", config.tsconfigPath),
           bundleDependenciesPlugin(
             "workerFacade",
+            {},
             (config.dependenciesToBundle ?? []).concat([/^@trigger.dev/]),
             config.tsconfigPath
           ),