@trigger.dev/sdk 0.0.0-python-preview-20250226140121 → 0.0.0-rc-4-8-0-20261021151928

package/docs/config/extensions/additionalPackages.mdx

@@ -0,0 +1,40 @@
+---
+title: "Additional Packages"
+sidebarTitle: "additionalPackages"
+description: "Use the additionalPackages build extension to include additional packages in the build"
+---
+
+Import the `additionalPackages` build extension and use it in your `trigger.config.ts` file:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { additionalPackages } from "@trigger.dev/build/extensions/core";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    // Omit version for auto-resolution; for reproducible builds use e.g. packages: ["wrangler@X.Y.Z"]
+    extensions: [additionalPackages({ packages: ["wrangler"] })],
+  },
+});
+```
+
+This allows you to include additional packages in the build that are not automatically included via imports. This is useful if you want to install a package that includes a CLI tool you can invoke in your tasks via `exec`. We will try to automatically resolve the version of the package but you can specify the version by using the `@` symbol.
+
+If you omit the version, the build may use a cached or older resolution. For reproducible builds, pin the exact version (e.g. `wrangler@X.Y.Z`).
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { additionalPackages } from "@trigger.dev/build/extensions/core";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    extensions: [additionalPackages({ packages: ["wrangler@X.Y.Z"] })],
+  },
+});
+```
+
+This extension does not do anything in `dev` mode, but it will install the packages in the build directory when you run `deploy`. The packages will be installed in the `node_modules` directory in the build directory.

package/docs/config/extensions/aptGet.mdx

@@ -0,0 +1,34 @@
+---
+title: "apt-get"
+sidebarTitle: "aptGet"
+description: "Use the aptGet build extension to install system packages into the deployed image"
+---
+
+You can install system packages into the deployed image using the `aptGet` extension:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { aptGet } from "@trigger.dev/build/extensions/core";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    extensions: [aptGet({ packages: ["ffmpeg"] })],
+  },
+});
+```
+
+If you want to install a specific version of a package, you can specify the version like this:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    extensions: [aptGet({ packages: ["ffmpeg=6.0-4"] })],
+  },
+});
+```

package/docs/config/extensions/audioWaveform.mdx

@@ -0,0 +1,23 @@
+---
+title: "Audio Waveform"
+sidebarTitle: "audioWaveform"
+description: "Use the audioWaveform build extension to add support for Audio Waveform in your project"
+---
+
+Previously, we installed [Audio Waveform](https://github.com/bbc/audiowaveform) in the build image. That's been moved to a build extension:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { audioWaveform } from "@trigger.dev/build/extensions/audioWaveform";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    extensions: [audioWaveform()], // uses version 1.10.1 of audiowaveform by default
+  },
+});
+```
+
+To use a different version, pass the `version` and `checksum` options to `audioWaveform()`.
+

package/docs/config/extensions/custom.mdx

@@ -0,0 +1,393 @@
+---
+title: "Custom build extensions"
+sidebarTitle: "Custom"
+description: "Customize how your project is built and deployed to Trigger.dev with your own custom build extensions"
+---
+
+Build extensions allow you to hook into the build system and customize the build process or the resulting bundle and container image (in the case of deploying). See our [build extension overview](/config/extensions/overview) for more information on how to install and use our built-in extensions. Build extensions can do the following:
+
+- Add additional files to the build
+- Add dependencies to the list of externals
+- Add esbuild plugins
+- Add additional npm dependencies
+- Add additional system packages to the image build container
+- Add commands to run in the image build container
+- Add environment variables to the image build container
+- Sync environment variables to your Trigger.dev project
+
+## Creating a build extension
+
+Build extensions are added to your `trigger.config.ts` file, with a required `name` and optional build hook functions. Here's a simple example of a build extension that just logs a message when the build starts:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "my-project",
+  build: {
+    extensions: [
+      {
+        name: "my-extension",
+        onBuildStart: async (context) => {
+          console.log("Build starting!");
+        },
+      },
+    ],
+  },
+});
+```
+
+You can also extract that out into a function instead of defining it inline, in which case you will need to import the `BuildExtension` type from the `@trigger.dev/build` package:
+
+<Note>
+  You'll need to add the `@trigger.dev/build` package to your `devDependencies` before the below
+  code will work. Make sure it's version matches that of the installed `@trigger.dev/sdk` package.
+</Note>
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { BuildExtension } from "@trigger.dev/build";
+
+export default defineConfig({
+  project: "my-project",
+  build: {
+    extensions: [myExtension()],
+  },
+});
+
+function myExtension(): BuildExtension {
+  return {
+    name: "my-extension",
+    onBuildStart: async (context) => {
+      console.log("Build starting!");
+    },
+  };
+}
+```
+
+## Build hooks
+
+### externalsForTarget
+
+This allows the extension to add additional dependencies to the list of externals for the build. This is useful for dependencies that are not included in the bundle, but are expected to be available at runtime.
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "my-project",
+  build: {
+    extensions: [
+      {
+        name: "my-extension",
+        externalsForTarget: (target) => {
+          return ["my-dependency"];
+        },
+      },
+    ],
+  },
+});
+```
+
+### installedPackagesForTarget
+
+This tells build diagnostics which packages your extension installs into the deployed image for a given target, so warnings (like the one for packages loaded via `createRequire()`) don't fire for packages that will actually be available at runtime. The bundler ignores this hook, so declaring it never changes the build output. Only implement it if your extension installs packages; extensions without it are assumed to install none.
+
+```ts
+{
+  name: "my-extension",
+  installedPackagesForTarget: (target) => {
+    return target === "deploy" ? ["my-dependency"] : [];
+  },
+}
+```
+
+### onBuildStart
+
+This hook runs before the build starts. It receives the `BuildContext` object as an argument.
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "my-project",
+  build: {
+    extensions: [
+      {
+        name: "my-extension",
+        onBuildStart: async (context) => {
+          console.log("Build starting!");
+        },
+      },
+    ],
+  },
+});
+```
+
+If you want to add an esbuild plugin, you must do so in the `onBuildStart` hook. Here's an example of adding a custom esbuild plugin:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "my-project",
+  build: {
+    extensions: [
+      {
+        name: "my-extension",
+        onBuildStart: async (context) => {
+          context.registerPlugin({
+            name: "my-plugin",
+            setup(build) {
+              build.onLoad({ filter: /.*/, namespace: "file" }, async (args) => {
+                return {
+                  contents: "console.log('Hello, world!')",
+                  loader: "js",
+                };
+              });
+            },
+          });
+        },
+      },
+    ],
+  },
+});
+```
+
+You can use the `BuildContext.target` property to determine if the build is for `dev` or `deploy`:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "my-project",
+  build: {
+    extensions: [
+      {
+        name: "my-extension",
+        onBuildStart: async (context) => {
+          if (context.target === "dev") {
+            console.log("Building for dev");
+          } else {
+            console.log("Building for deploy");
+          }
+        },
+      },
+    ],
+  },
+});
+```
+
+### onBuildComplete
+
+This hook runs after the build completes. It receives the `BuildContext` object and a `BuildManifest` object as arguments. This is where you can add in one or more `BuildLayer`'s to the context.
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "my-project",
+  build: {
+    extensions: [
+      {
+        name: "my-extension",
+        onBuildComplete: async (context, manifest) => {
+          context.addLayer({
+            id: "more-dependencies",
+            dependencies,
+          });
+        },
+      },
+    ],
+  },
+});
+```
+
+See the [addLayer](#addlayer) documentation for more information on how to use `addLayer`.
+
+## BuildTarget
+
+Can either be `dev` or `deploy`, matching the CLI command name that is being run.
+
+```sh
+npx trigger.dev@latest dev # BuildTarget is "dev"
+npx trigger.dev@latest deploy # BuildTarget is "deploy"
+```
+
+## BuildContext
+
+### addLayer()
+
+<ParamField path="layer" type="BuildLayer">
+  The layer to add to the build context. See the [BuildLayer](#buildlayer) documentation for more
+  information.
+</ParamField>
+
+### registerPlugin()
+
+<ParamField path="plugin" type="esbuild.Plugin" required>
+  The esbuild plugin to register.
+</ParamField>
+
+<ParamField path="options" type="object">
+  <Expandable title="properties">
+    <ResponseField name="target" type="BuildTarget">
+      An optional target to register the plugin for. If not provided, the plugin will be registered
+      for all targets.
+    </ResponseField>
+    <ResponseField name="placement" type="first | last">
+      An optional placement for the plugin. If not provided, the plugin will be registered in place.
+      This allows you to control the order of plugins.
+    </ResponseField>
+  </Expandable>
+</ParamField>
+
+### resolvePath()
+
+Resolves a path relative to the project's working directory.
+
+<ParamField path="path" type="string">
+  The path to resolve.
+</ParamField>
+
+```ts
+const resolvedPath = context.resolvePath("my-other-dependency");
+```
+
+### properties
+
+<ParamField path="target" type="BuildTarget">
+  The target of the build, either `dev` or `deploy`.
+</ParamField>
+
+<ParamField path="config" type="ResolvedConfig">
+  <Expandable title="properties">
+    <ResponseField name="runtime" type="string">
+      The runtime of the project (either node or bun)
+    </ResponseField>
+    <ResponseField name="project" type="string">
+      The project ref
+    </ResponseField>
+    <ResponseField name="dirs" type="string[]">
+      The trigger directories to search for tasks
+    </ResponseField>
+    <ResponseField name="build" type="object">
+      The build configuration object
+    </ResponseField>
+    <ResponseField name="workingDir" type="string">
+      The working directory of the project
+    </ResponseField>
+    <ResponseField name="workspaceDir" type="string">
+      The root workspace directory of the project
+    </ResponseField>
+    <ResponseField name="packageJsonPath" type="string">
+      The path to the package.json file
+    </ResponseField>
+    <ResponseField name="lockfilePath" type="string">
+      The path to the lockfile (package-lock.json, yarn.lock, or pnpm-lock.yaml)
+    </ResponseField>
+    <ResponseField name="configFile" type="string">
+      The path to the trigger.config.ts file
+    </ResponseField>
+    <ResponseField name="tsconfigPath" type="string">
+      The path to the tsconfig.json file
+    </ResponseField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="logger" type="BuildLogger">
+  A logger object that can be used to log messages to the console.
+</ParamField>
+
+## BuildLayer
+
+<ParamField path="id" type="string">
+  A unique identifier for the layer.
+</ParamField>
+
+<ParamField path="commands" type="string[]">
+  An array of commands to run in the image build container.
+
+```ts
+commands: ["echo 'Hello, world!'"];
+```
+
+These commands are run after packages have been installed and the code copied into the container in the "build" stage of the Dockerfile. This means you cannot install system packages in these commands because they won't be available in the final stage. To do that, please use the `pkgs` property of the `image` object.
+
+</ParamField>
+
+<ParamField path="image" type="object">
+  <Expandable title="properties">
+    <ResponseField name="pkgs" type="string[]">
+      An array of system packages to install in the image build container.
+    </ResponseField>
+    <ResponseField name="instructions" type="string[]">
+      An array of instructions to add to the Dockerfile.
+    </ResponseField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="build" type="object">
+  <Expandable title="properties">
+    <ResponseField name="env" type="Record<string, string>">
+      Environment variables to add to the image build container, but only during the "build" stage
+      of the Dockerfile. This is where you'd put environment variables that are needed when running
+      any of the commands in the `commands` array.
+    </ResponseField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="deploy" type="object">
+  <Expandable title="properties">
+    <ResponseField name="env" type="Record<string, string>">
+      Environment variables that should sync to the Trigger.dev project, which will then be avalable
+      in your tasks at runtime. Importantly, these are NOT added to the image build container, but
+      are instead added to the Trigger.dev project and stored securely.
+    </ResponseField>
+  </Expandable>
+</ParamField>
+
+<ParamField path="dependencies" type="Record<string, string>">
+  An object of dependencies to add to the build. The key is the package name and the value is the
+  version.
+
+```ts
+dependencies: {
+  "my-dependency": "^1.0.0",
+};
+```
+
+</ParamField>
+
+### examples
+
+Add a command that will echo the value of an environment variable:
+
+```ts
+context.addLayer({
+  id: "my-layer",
+  commands: [`echo $MY_ENV_VAR`],
+  build: {
+    env: {
+      MY_ENV_VAR: "Hello, world!",
+    },
+  },
+});
+```
+
+## Troubleshooting
+
+When creating a build extension, you may run into issues with the build process. One thing that can help is turning on `debug` logging when running either `dev` or `deploy`:
+
+```sh
+npx trigger.dev@latest dev --log-level debug
+npx trigger.dev@latest deploy --log-level debug
+```
+
+Another helpful tool is the `--dry-run` flag on the `deploy` command, which will bundle your project and generate the Containerfile (e.g. the Dockerfile) without actually deploying it. This can help you see what the final image will look like and debug any issues with the build process.
+
+```sh
+npx trigger.dev@latest deploy --dry-run
+```
+
+You should also take a look at our built in extensions for inspiration on how to create your own. You can find them in in [the source code here](https://github.com/triggerdotdev/trigger.dev/tree/main/packages/build/src/extensions).

package/docs/config/extensions/emitDecoratorMetadata.mdx

@@ -0,0 +1,52 @@
+---
+title: "Emit Decorator Metadata"
+sidebarTitle: "emitDecoratorMetadata"
+description: "Use the emitDecoratorMetadata build extension to enable support for the emitDecoratorMetadata TypeScript compiler option"
+---
+
+If you need support for the `emitDecoratorMetadata` typescript compiler option, import the `emitDecoratorMetadata` build extension and use it in your `trigger.config.ts` file:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { emitDecoratorMetadata } from "@trigger.dev/build/extensions/typescript";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    extensions: [emitDecoratorMetadata()],
+  },
+});
+```
+
+This is usually required if you are using certain ORMs, like TypeORM, that require this option to be enabled. It's not enabled by default because there is a performance cost to enabling it.
+
+<Note>
+  `emitDecoratorMetadata` hooks into the esbuild bundle process and uses the TypeScript compiler API
+  to compile files containing decorators. Enable `emitDecoratorMetadata` in your `tsconfig.json` and
+  install `typescript` in your `devDependencies`.
+</Note>
+
+## Using with TypeScript 7
+
+TypeScript 7 does not expose the JavaScript compiler API required by this extension. Install the TypeScript 6 compatibility package alongside TypeScript 7:
+
+<CodeGroup>
+
+```bash npm
+npm install --save-dev @typescript/typescript6@latest
+```
+
+```bash pnpm
+pnpm add --save-dev @typescript/typescript6@latest
+```
+
+```bash bun
+bun add --dev @typescript/typescript6@latest
+```
+
+</CodeGroup>
+
+Your project continues using TypeScript 7 for its normal type checking and compiler commands. The extension loads the compatibility package only when it needs to emit decorator metadata.
+
+Restart the Trigger.dev dev server after installing the package.

package/docs/config/extensions/esbuildPlugin.mdx

@@ -0,0 +1,31 @@
+---
+title: "esbuild Plugin"
+sidebarTitle: "esbuildPlugin"
+description: "Use the esbuildPlugin build extension to add existing or custom esbuild plugins to your build process"
+---
+
+You can easily add existing or custom esbuild plugins to your build process using the `esbuildPlugin` extension:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { esbuildPlugin } from "@trigger.dev/build/extensions";
+import { sentryEsbuildPlugin } from "@sentry/esbuild-plugin";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    extensions: [
+      esbuildPlugin(
+        sentryEsbuildPlugin({
+          org: process.env.SENTRY_ORG,
+          project: process.env.SENTRY_PROJECT,
+          authToken: process.env.SENTRY_AUTH_TOKEN,
+        }),
+        // optional - only runs during the deploy command, and adds the plugin to the end of the list of plugins
+        { placement: "last", target: "deploy" }
+      ),
+    ],
+  },
+});
+```

package/docs/config/extensions/ffmpeg.mdx

@@ -0,0 +1,45 @@
+---
+title: "FFmpeg"
+sidebarTitle: "ffmpeg"
+description: "Use the ffmpeg build extension to include FFmpeg in your project"
+---
+
+You can add the `ffmpeg` build extension to your build process:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { ffmpeg } from "@trigger.dev/build/extensions/core";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    extensions: [ffmpeg()],
+  },
+});
+```
+
+By default, this will install the version of `ffmpeg` that is available in the Debian package manager (via `apt`).
+
+## FFmpeg 7.x (static build)
+
+If you need FFmpeg 7.x, you can pass `{ version: "7" }` to the extension. This will install a static build of FFmpeg 7.x instead of using the Debian package:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { ffmpeg } from "@trigger.dev/build/extensions/core";
+
+export default defineConfig({
+  project: "<project ref>",
+  // Your other config settings...
+  build: {
+    extensions: [ffmpeg({ version: "7" })],
+  },
+});
+```
+
+This extension will also add the `FFMPEG_PATH` and `FFPROBE_PATH` to your environment variables, making it easy to use popular ffmpeg libraries like `fluent-ffmpeg`.
+
+Note that `fluent-ffmpeg` needs to be added to [`external`](/config/config-file#external) in your `trigger.config.ts` file.
+
+Follow [this example](/guides/examples/ffmpeg-video-processing) to get setup with Trigger.dev and FFmpeg in your project.

package/docs/config/extensions/lightpanda.mdx

@@ -0,0 +1,56 @@
+---
+title: "Lightpanda build extension"
+sidebarTitle: "lightpanda"
+description: "Use the lightpanda build extension to add Lightpanda browser to your project"
+tag: "v4"
+---
+
+To use the Lightpanda browser in your project, add the extension to your `trigger.config.ts` file:
+
+```ts trigger.config.ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { lightpanda } from "@trigger.dev/build/extensions/lightpanda";
+
+export default defineConfig({
+  project: "<project ref>",
+  build: {
+    extensions: [lightpanda()],
+  },
+});
+```
+
+## Options
+
+- `version`: The version of the browser to install. Default: `"latest"`.
+- `disableTelemetry`: Whether to disable telemetry. Default: `false`.
+
+For example:
+
+```ts trigger.config.ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { lightpanda } from "@trigger.dev/build/extensions/lightpanda";
+
+export default defineConfig({
+  project: "<project ref>",
+  build: {
+    extensions: [
+      lightpanda({
+        version: "nightly",
+        disableTelemetry: true,
+      }),
+    ],
+  },
+});
+```
+
+## Development
+
+When running in dev, you will first have to download the Lightpanda browser binary and make sure it's in your `PATH`. See [Lightpanda's installation guide](https://lightpanda.io/docs/getting-started/installation).
+
+## Next steps
+
+<CardGroup>
+  <Card title="Lightpanda" color="#6ac6e2" icon="bolt" href="/guides/examples/lightpanda">
+    Learn how to use Lightpanda in your project.
+  </Card>
+</CardGroup>