Skip to content

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

feat(ts/e2e): add e2e tests for Deno

jkomyno63aa197d0f13
diff --git a/.dvmrc b/.dvmrc
new file mode 100644
index 000000000..e261122d5
--- /dev/null
+++ b/.dvmrc
@@ -0,0 +1 @@
+2.6.7
diff --git a/.github/workflows/ts.test-e2e.yml b/.github/workflows/ts.test-e2e.yml
index 841057b38..afffda129 100644
--- a/.github/workflows/ts.test-e2e.yml
+++ b/.github/workflows/ts.test-e2e.yml
@@ -41,23 +41,46 @@ jobs:
- name: Build
run: pnpm run build:packages
- - name: Verify API Key
- run: |
- if [ -z "$COMPOSIO_API_KEY" ]; then
- echo "::error::COMPOSIO_API_KEY is not set"
- exit 1
- fi
- echo "✅ COMPOSIO_API_KEY is configured"
- if [ -z "$OPENAI_API_KEY" ]; then
- echo "::error::OPENAI_API_KEY is not set"
- exit 1
- fi
- echo "✅ OPENAI_API_KEY is configured"
-
- name: Run Node.js E2E Tests
run: pnpm run test:e2e:node
- env:
- OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+
+ # Deno E2E tests, running in Docker to isolate environment
+ # Each test suite defines its own versions.deno in e2e.test.ts
+ # Tests that don't support the matrix version are automatically skipped
+ test-e2e-deno-docker:
+ name: E2E Test Deno ${{ matrix.deno-version }}
+ runs-on: ubuntu-24.04
+ permissions: read-all
+ strategy:
+ fail-fast: false
+ matrix:
+ deno-version: ['2.6.7']
+ env:
+ CI: 1
+ COMPOSIO_API_KEY: ${{ secrets.COMPOSIO_API_KEY }}
+ COMPOSIO_E2E_DENO_VERSION: ${{ matrix.deno-version }}
+ OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+
+ steps:
+ - name: Checkout Code
+ uses: actions/checkout@v6
+
+ - name: Setup Deno
+ uses: denoland/setup-deno@v2
+ with:
+ deno-version: ${{ matrix.deno-version }}
+
+ - name: Setup Node.js, pnpm, Bun
+ uses: ./.github/actions/setup-node-pnpm-bun
+
+ - name: Install Dependencies
+ run: pnpm install --frozen-lockfile
+
+ - name: Build
+ run: pnpm run build:packages
+
+ - name: Run Deno E2E Tests
+ run: pnpm run test:e2e:deno
# Cloudflare Workerd E2E tests
test-e2e-cloudflare:
diff --git a/CLAUDE.md b/CLAUDE.md
index ebc0e4ef8..9d7537dd4 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -196,17 +196,23 @@ pnpm test:ui
E2E tests for `@composio/core` are located in `ts/e2e-tests/` and test runtime compatibility across different JavaScript environments.
```bash
-# Run all e2e tests (Node.js + Cloudflare)
+# Run all e2e tests (Node.js + Deno + Cloudflare)
pnpm test:e2e
# Run only Node.js e2e tests (CJS/ESM compatibility, runs in Docker)
pnpm test:e2e:node
+# Run only Deno e2e tests (npm: specifier compatibility, runs in Docker)
+pnpm test:e2e:deno
+
# Run only Cloudflare Workers e2e tests
pnpm test:e2e:cloudflare
# Run Node.js tests with a specific Node version
COMPOSIO_E2E_NODE_VERSION=22.12.0 pnpm test:e2e:node
+
+# Run Deno tests with a specific Deno version
+COMPOSIO_E2E_DENO_VERSION=2.6.7 pnpm test:e2e:deno
```
**E2E Test Structure:**
@@ -217,6 +223,8 @@ ts/e2e-tests/
│ ├── node/ # Node.js runtime tests
│ │ ├── cjs-basic/ # CommonJS compatibility
│ │ └── esm-basic/ # ESM compatibility
+│ ├── deno/ # Deno runtime tests
+│ │ └── esm-basic/ # npm: specifier compatibility
│ └── cloudflare/ # Cloudflare runtime tests
│ └── cf-workers-basic/ # Cloudflare Workers tests
└── README.md # E2E test documentation
diff --git a/package.json b/package.json
index e9de868e6..dd7c2fbfc 100644
--- a/package.json
+++ b/package.json
@@ -15,6 +15,7 @@
"test": "turbo test --filter=./ts/packages/** --filter=!@e2e-tests/*",
"test:e2e": "turbo test:e2e --filter='@e2e-tests/*'",
"test:e2e:node": "turbo test:e2e:node --filter='@e2e-tests/node-*'",
+ "test:e2e:deno": "turbo test:e2e:deno --filter='@e2e-tests/deno-*'",
"test:e2e:cloudflare": "turbo test:e2e:cloudflare --filter='@e2e-tests/cf-*'",
"test:ui": "vitest --ui",
"typecheck": "turbo typecheck --filter=./ts/packages/**",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 07ddc23ec..0e2eeb442 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -242,6 +242,15 @@ importers:
specifier: 'catalog:'
version: 4.60.0(@cloudflare/[email protected])
+ ts/e2e-tests/runtimes/deno/esm-basic:
+ devDependencies:
+ '@composio/core':
+ specifier: workspace:*
+ version: link:../../../../packages/core
+ '@e2e-tests/utils':
+ specifier: workspace:*
+ version: link:../../../_utils
+
ts/e2e-tests/runtimes/node/cjs-basic:
devDependencies:
'@composio/core':
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index f99c3fcd3..53d3f59d3 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,6 +1,7 @@
packages:
- ts/e2e-tests/_utils
- ts/e2e-tests/runtimes/node/*
+ - ts/e2e-tests/runtimes/deno/*
- ts/e2e-tests/runtimes/cloudflare/*
- ts/examples/*
- ts/packages/cli
diff --git a/ts/e2e-tests/README.md b/ts/e2e-tests/README.md
index 61b032367..19ba2d222 100644
--- a/ts/e2e-tests/README.md
+++ b/ts/e2e-tests/README.md
@@ -8,12 +8,13 @@ End-to-end tests for `@composio/core` across different JavaScript runtimes.
ts/e2e-tests/
├── _utils/ # Shared test infrastructure
│ ├── Dockerfile.node # Docker image for Node.js tests
+│ ├── Dockerfile.deno # Docker image for Deno tests
│ ├── scripts/ # Docker build and cleanup scripts
-│ │ ├── docker-build.ts # Pre-build images for all Node versions
+│ │ ├── docker-build.ts # Pre-build images for all Node/Deno versions
│ │ └── docker-clean.ts # Remove all e2e Docker images
│ ├── src/ # TypeScript runner utilities
│ │ ├── config.ts # Configuration utilities
-│ │ ├── const.ts # Well-known Node.js versions and timeouts
+│ │ ├── const.ts # Well-known Node.js/Deno versions and timeouts
│ │ ├── e2e.ts # Main e2e test entry point
│ │ ├── image-lifecycle.ts # Docker image build/run utilities
│ │ ├── index.ts # Public exports
@@ -32,6 +33,8 @@ ts/e2e-tests/
│ ├── mastra-tool-router-zod-v4/ # @composio/mastra Tool Router + Zod v4 tests
│ ├── openai-zod4-compat/ # OpenAI + Zod v4 compatibility tests
│ └── typescript-mjs-import-nodenext/ # TypeScript moduleResolution: nodenext tests
+ ├── deno/ # Deno runtime tests
+ │ └── esm-basic/ # ESM compatibility tests via npm: specifier
└── cloudflare/ # Cloudflare runtime tests
├── cf-workers-basic/ # Basic Cloudflare Workers tests
├── cf-workers-files/ # Cloudflare Workers file handling tests
@@ -52,7 +55,7 @@ pnpm test:e2e
pnpm test:e2e:node
```
-Runs Node.js tests in Docker using `bun test`. The default Node.js version is determined by the current runtime.
+Runs Node.js tests in Docker using `bun test`. The default Node.js version is determined by `.nvmrc`.
To run with a specific Node.js version:
@@ -60,6 +63,20 @@ To run with a specific Node.js version:
COMPOSIO_E2E_NODE_VERSION=22.12.0 pnpm test:e2e:node
```
+### Deno Tests Only
+
+```bash
+pnpm test:e2e:deno
+```
+
+Runs Deno tests in Docker using `bun test`. The default Deno version is determined by `.dvmrc`.
+
+To run with a specific Deno version:
+
+```bash
+COMPOSIO_E2E_DENO_VERSION=2.6.7 pnpm test:e2e:deno
+```
+
### Cloudflare Workers Tests Only
```bash
@@ -80,9 +97,11 @@ import { e2e, type E2ETestResult } from '@e2e-tests/utils';
import { describe, it, expect, beforeAll } from 'bun:test';
e2e(import.meta.url, {
- nodeVersions: ['20.18.0', '22.12.0'], // Optional: defaults to current runtime
+ versions: {
+ node: ['20.18.0', '22.12.0'], // Optional: defaults to .nvmrc version
+ },
env: { MY_VAR: process.env.MY_VAR }, // Optional: env vars (validated at startup)
- defineTests: ({ runFixture }) => {
+ defineTests: ({ runtime, runFixture }) => {
let result: E2ETestResult;
beforeAll(async () => {
@@ -104,6 +123,44 @@ e2e(import.meta.url, {
5. Add fixture files in a `fixtures/` directory
+### Deno Runtime Tests
+
+1. Create a new directory under `runtimes/deno/` (e.g., `runtimes/deno/my-test`)
+2. Add a `package.json` with name `@e2e-tests/deno-my-test`
+3. Add `test:e2e` and `test:e2e:deno` scripts
+4. Create an `e2e.test.ts` file with inline configuration:
+
+```typescript
+import { e2e, type E2ETestResult } from '@e2e-tests/utils';
+import { describe, it, expect, beforeAll } from 'bun:test';
+
+e2e(import.meta.url, {
+ versions: {
+ deno: ['2.6.7'], // Optional: defaults to .dvmrc version
+ },
+ usesFixtures: true,
+ defineTests: ({ runtime, runFixture }) => {
+ let result: E2ETestResult;
+
+ beforeAll(async () => {
+ result = await runFixture({ filename: 'test.ts' });
+ });
+
+ describe('output', () => {
+ it('exits successfully', () => {
+ expect(result.exitCode).toBe(0);
+ });
+
+ it('contains expected output', () => {
+ expect(result.stdout).toContain('expected text');
+ });
+ });
+ },
+});
+```
+
+5. Add fixture files in a `fixtures/` directory. Fixtures use Deno's `npm:` specifier to import packages.
+
### Tests with External Dependencies (npm install)
For tests that need to install npm packages at runtime, use `usesFixtures: true` and the `setup` option:
diff --git a/ts/e2e-tests/_utils/Dockerfile.deno b/ts/e2e-tests/_utils/Dockerfile.deno
new file mode 100644
index 000000000..3c1096123
--- /dev/null
+++ b/ts/e2e-tests/_utils/Dockerfile.deno
@@ -0,0 +1,80 @@
+# syntax=docker/dockerfile:1
+# Reusable Dockerfile for Deno e2e tests
+# Usage: docker build -f Dockerfile.deno --build-arg DENO_VERSION=2.6.7 -t test-name .
+#
+# Uses official denoland/deno images. For multi-version testing, run the build/run
+# multiple times with different DENO_VERSION values from the shell script.
+
+ARG DENO_VERSION=2.6.7
+
+FROM denoland/deno:${DENO_VERSION}
+
+ENV PNPM_HOME="/pnpm"
+ENV BUN_INSTALL="/usr/local"
+ENV PATH="$BUN_INSTALL/bin:$PNPM_HOME:$PATH"
+
+# Switch to root for installation
+USER root
+
+WORKDIR /app
+
+# Install system dependencies with cache mounts
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
+ --mount=type=cache,target=/var/lib/apt,sharing=locked \
+ apt-get update && \
+ apt-get install -y --no-install-recommends ca-certificates curl unzip && \
+ rm -rf /var/lib/apt/lists/*
+
+# Install Node.js (needed for pnpm and building packages)
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
+ apt-get install -y nodejs && \
+ rm -rf /var/lib/apt/lists/*
+
+# Install corepack (for pnpm) with npm cache mount
+RUN --mount=type=cache,target=/root/.npm \
+ npm i -g corepack@latest && \
+ corepack enable
+
+# Install bun (version from .bun-version)
+COPY .bun-version ./
+RUN curl -fsSL https://bun.sh/install | BUN_INSTALL=/usr/local bash -s "bun-v$(cat .bun-version)" && \
+ bun --version
+
+# Copy lockfile first for optimal layer caching
+COPY pnpm-lock.yaml ./
+
+# Copy workspace configuration files
+COPY package.json \
+ pnpm-workspace.yaml \
+ .pnpmfile.cjs \
+ tsconfig.base.json \
+ tsdown.config.base.ts \
+ ./
+
+# Copy pre-install scripts (rarely change)
+COPY ts/scripts/pre-install.sh ./ts/scripts/pre-install.sh
+COPY ts/scripts/pre-install/ ./ts/scripts/pre-install/
+
+# Copy all ts/packages (pre-built)
+COPY ts/packages/ ./ts/packages/
+
+# Install dependencies using pnpm
+# Note: We intentionally don't use --mount=type=cache for the pnpm store here
+# because it causes native binding issues (e.g., rolldown-binding) across builds
+RUN pnpm install --frozen-lockfile
+
+# Copy e2e tests last (changes frequently)
+COPY ts/e2e-tests/ ./ts/e2e-tests/
+
+# Create deno user and group (to match the official image's user)
+RUN groupadd -g 1000 deno 2>/dev/null || true && \
+ useradd -u 1000 -g deno -m deno 2>/dev/null || true && \
+ chown -R deno:deno /app
+
+# Pre-create Deno cache directory
+ENV DENO_DIR="/home/deno/.cache/deno"
+RUN mkdir -p $DENO_DIR && chown -R deno:deno /home/deno
+
+USER deno
+
+CMD ["sh"]
diff --git a/ts/e2e-tests/_utils/README.md b/ts/e2e-tests/_utils/README.md
index 7196fb895..b45242341 100644
--- a/ts/e2e-tests/_utils/README.md
+++ b/ts/e2e-tests/_utils/README.md
@@ -9,6 +9,7 @@ Shared infrastructure for running `@composio/core` end-to-end tests in isolated
| `src/` | TypeScript utilities (e2e runner, config, types) |
| `scripts/` | Docker build and cleanup scripts |
| `Dockerfile.node` | Multi-stage Dockerfile for Node.js test environments |
+| `Dockerfile.deno` | Dockerfile for Deno test environments |
## API
@@ -21,9 +22,12 @@ import { e2e, type E2ETestResult } from '@e2e-tests/utils';
import { describe, it, expect, beforeAll } from 'bun:test';
e2e(import.meta.url, {
- nodeVersions: ['20.18.0', '20.19.0', '22.12.0'], // optional
- env: { MY_VAR: 'value' }, // optional env vars
- defineTests: ({ runCmd, runFixture }) => {
+ versions: {
+ node: ['20.18.0', '20.19.0', '22.12.0'], // optional, defaults to .nvmrc
+ deno: ['2.6.7'], // optional, defaults to .dvmrc
+ },
+ env: { MY_VAR: 'value' }, // optional env vars
+ defineTests: ({ runtime, runCmd, runFixture }) => {
let result: E2ETestResult;
beforeAll(async () => {
@@ -45,17 +49,26 @@ Configuration object passed to `e2e()`:
| Property | Type | Description |
| -------------- | ------------------------------------- | ---------------------------------------------------------------- |
-| `nodeVersions` | `readonly NodeVersionFromUser[]` | Node.js versions to test. Defaults to current runtime |
+| `versions` | `RuntimeVersions` | Runtime versions to test. See RuntimeVersions below |
+| `nodeVersions` | `readonly NodeVersionFromUser[]` | **Deprecated.** Use `versions.node` instead |
| `env` | `Record<string, string \| undefined>` | Environment variables for Docker. Validated at startup |
| `usesFixtures` | `boolean` | When true, sets cwd to `{testDir}/fixtures`. Default: `false` |
| `defineTests` | `(ctx: DefineTestsContext) => void` | Callback to define tests using bun:test primitives |
+### `RuntimeVersions`
+
+| Property | Type | Description |
+| -------- | -------------------------------- | ------------------------------------------------ |
+| `node` | `readonly NodeVersionFromUser[]` | Node.js versions. Defaults to `.nvmrc` |
+| `deno` | `readonly DenoVersionFromUser[]` | Deno versions. Defaults to `.dvmrc` |
+
### `DefineTestsContext`
The context passed to the `defineTests` callback:
-| Function | Signature | Description |
+| Property | Type/Signature | Description |
| ------------ | ---------------------------------------------------------------- | ---------------------------------------------- |
+| `runtime` | `'node' \| 'deno'` | Current runtime being tested |
| `runCmd` | `(command: string) => Promise<E2ETestResult>` | Run arbitrary command in Docker container |
| `runFixture` | `(options: RunFixtureOptions) => Promise<E2ETestResult \| E2ETestResultWithSetup>` | Run fixture with optional setup phase |
@@ -142,13 +155,15 @@ it('calls LLM', async () => {
| `LLM_SHORT` | `15_000` | Quick LLM calls |
| `LLM_LONG` | `60_000` | Complex LLM operations |
-## Node Version Resolution
+## Version Resolution
+
+### Node.js Version Resolution
Node.js versions to test are resolved in this order:
1. **`COMPOSIO_E2E_NODE_VERSION` env var** (highest priority): Use `[env_value]`
-2. **`config.nodeVersions`**: Use the provided array
-3. **Default**: Use `[process.versions.node]` (current runtime)
+2. **`config.versions.node`** or **`config.nodeVersions`**: Use the provided array
+3. **Default**: Use version from `.nvmrc` file
### Well-Known Node Versions
@@ -157,7 +172,22 @@ The following versions are pre-defined in `const.ts`:
- `20.18.0`
- `20.19.0`
- `22.12.0`
-- `current` (resolves to current Node runtime version)
+- `current` (resolves to `.nvmrc` version)
+
+### Deno Version Resolution
+
+Deno versions to test are resolved in this order:
+
+1. **`COMPOSIO_E2E_DENO_VERSION` env var** (highest priority): Use `[env_value]`
+2. **`config.versions.deno`**: Use the provided array
+3. **Default**: Use version from `.dvmrc` file
+
+### Well-Known Deno Versions
+
+The following versions are pre-defined in `const.ts`:
+
+- `2.6.7`
+- `current` (resolves to `.dvmrc` version)
## Environment Variable Validation
@@ -198,16 +228,16 @@ e2e(import.meta.url, {
## Scripts
```bash
-# Pre-build Docker images for all well-known Node versions
+# Pre-build Docker images for all well-known Node and Deno versions
pnpm docker:build
-# Remove all e2e Docker images
+# Remove all e2e Docker images (both Node.js and Deno)
pnpm docker:clean
```
## DEBUG.log Output
-Each test suite generates a `DEBUG.log` file with structured output grouped by Node version:
+Each test suite generates a `DEBUG.log` file with structured output grouped by runtime version:
```
================================================================================
diff --git a/ts/e2e-tests/_utils/scripts/docker-build.ts b/ts/e2e-tests/_utils/scripts/docker-build.ts
index 5b65707ee..aae07abac 100644
--- a/ts/e2e-tests/_utils/scripts/docker-build.ts
+++ b/ts/e2e-tests/_utils/scripts/docker-build.ts
@@ -1,18 +1,19 @@
#!/usr/bin/env bun
/**
- * Builds Docker images for Node.js e2e tests.
+ * Builds Docker images for Node.js and Deno e2e tests.
*
- * In CI mode (COMPOSIO_E2E_NODE_VERSION set):
+ * In CI mode (COMPOSIO_E2E_NODE_VERSION or COMPOSIO_E2E_DENO_VERSION set):
* Only builds the image for the specified version.
*
* In local mode:
- * Builds images for all versions in WELL_KNOWN_NODE_VERSIONS.
+ * Builds images for all versions in WELL_KNOWN_NODE_VERSIONS and WELL_KNOWN_DENO_VERSIONS.
*/
import { $ } from 'bun';
import { resolve, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
-import { WELL_KNOWN_NODE_VERSIONS } from '../src/const';
+import { readFileSync } from 'node:fs';
+import { WELL_KNOWN_NODE_VERSIONS, WELL_KNOWN_DENO_VERSIONS } from '../src/const';
const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -21,11 +22,31 @@ function getRepoRoot(): string {
return resolve(__dirname, '../../../..');
}
+function getNvmrcVersion(repoRoot: string): string {
+ try {
+ return readFileSync(resolve(repoRoot, '.nvmrc'), 'utf-8').trim();
+ } catch {
+ return process.versions.node;
+ }
+}
+
+function getDvmrcVersion(repoRoot: string): string {
+ try {
+ return readFileSync(resolve(repoRoot, '.dvmrc'), 'utf-8').trim();
+ } catch {
+ return '2.6.7'; // fallback default
+ }
+}
+
+// ============================================================================
+// Node.js image building
+// ============================================================================
+
function imageTagForNodeVersion(nodeVersion: string): string {
return `composio-e2e-node:${nodeVersion}`;
}
-function defaultLabels(nodeVersion: string): Record<string, string> {
+function defaultNodeLabels(nodeVersion: string): Record<string, string> {
return {
'composio.e2e': 'true',
'composio.runtime': 'node',
@@ -33,10 +54,10 @@ function defaultLabels(nodeVersion: string): Record<string, string> {
};
}
-async function buildImage(nodeVersion: string, repoRoot: string): Promise<boolean> {
+async function buildNodeImage(nodeVersion: string, repoRoot: string): Promise<boolean> {
const dockerfilePath = resolve(repoRoot, 'ts/e2e-tests/_utils/Dockerfile.node');
const imageTag = imageTagForNodeVersion(nodeVersion);
- const labels = defaultLabels(nodeVersion);
+ const labels = defaultNodeLabels(nodeVersion);
const labelArgs = Object.entries(labels)
.map(([k, v]) => `--label=${k}=${v}`)
.join(' ');
@@ -57,45 +78,127 @@ async function buildImage(nodeVersion: string, repoRoot: string): Promise<boolea
return true;
}
-async function main() {
- const repoRoot = getRepoRoot();
- const currentNodeVersion = process.versions.node;
- const envVersion = Bun.env.COMPOSIO_E2E_NODE_VERSION;
+// ============================================================================
+// Deno image building
+// ============================================================================
+
+function imageTagForDenoVersion(denoVersion: string): string {
+ return `composio-e2e-deno:${denoVersion}`;
+}
+
+function defaultDenoLabels(denoVersion: string): Record<string, string> {
+ return {
+ 'composio.e2e': 'true',
+ 'composio.runtime': 'deno',
+ 'composio.deno_version': denoVersion,
+ };
+}
+
+async function buildDenoImage(denoVersion: string, repoRoot: string): Promise<boolean> {
+ const dockerfilePath = resolve(repoRoot, 'ts/e2e-tests/_utils/Dockerfile.deno');
+ const imageTag = imageTagForDenoVersion(denoVersion);
+ const labels = defaultDenoLabels(denoVersion);
+ const labelArgs = Object.entries(labels)
+ .map(([k, v]) => `--label=${k}=${v}`)
+ .join(' ');
+
+ console.log(`\nBuilding image for Deno ${denoVersion}...`);
+
+ const result = await $`docker build -f ${dockerfilePath} --build-arg DENO_VERSION=${denoVersion} ${{ raw: labelArgs }} -t ${imageTag} ${repoRoot}`
+ .cwd(repoRoot)
+ .nothrow();
+
+ if (result.exitCode !== 0) {
+ console.error(` Failed to build ${imageTag}:`);
+ console.error(result.stderr.toString() || result.stdout.toString());
+ return false;
+ }
- // In CI mode with COMPOSIO_E2E_NODE_VERSION set, only build that specific version
- // Otherwise, build all well-known versions (for local development)
- const versions = new Set<string>();
+ console.log(` Built ${imageTag}`);
+ return true;
+}
+
+// ============================================================================
+// Main
+// ============================================================================
- if (envVersion) {
- versions.add(envVersion);
- console.log(`Building Docker image for CI matrix version: ${envVersion}`);
- } else {
+async function main() {
+ const repoRoot = getRepoRoot();
+ const currentNodeVersion = getNvmrcVersion(repoRoot);
+ const currentDenoVersion = getDvmrcVersion(repoRoot);
+ const envNodeVersion = Bun.env.COMPOSIO_E2E_NODE_VERSION;
+ const envDenoVersion = Bun.env.COMPOSIO_E2E_DENO_VERSION;
+
+ const nodeVersions = new Set<string>();
+ const denoVersions = new Set<string>();
+
+ // Determine which Node.js versions to build
+ if (envNodeVersion) {
+ nodeVersions.add(envNodeVersion);
+ console.log(`Building Docker image for CI matrix Node.js version: ${envNodeVersion}`);
+ } else if (!envDenoVersion) {
+ // Build all Node.js versions only if no specific runtime was requested
for (const version of WELL_KNOWN_NODE_VERSIONS) {
if (version === 'current') {
- versions.add(currentNodeVersion);
+ nodeVersions.add(currentNodeVersion);
} else {
- versions.add(version);
+ nodeVersions.add(version);
}
}
- console.log('Building Docker images for Node.js versions:');
- for (const v of versions) {
- const isCurrent = v === currentNodeVersion ? ' (current)' : '';
- console.log(` - ${v}${isCurrent}`);
+ if (nodeVersions.size > 0) {
+ console.log('Building Docker images for Node.js versions:');
+ for (const v of nodeVersions) {
+ const isCurrent = v === currentNodeVersion ? ' (current)' : '';
+ console.log(` - ${v}${isCurrent}`);
+ }
}
}
- const versionList = Array.from(versions);
+ // Determine which Deno versions to build
+ if (envDenoVersion) {
+ denoVersions.add(envDenoVersion);
+ console.log(`Building Docker image for CI matrix Deno version: ${envDenoVersion}`);
+ } else if (!envNodeVersion) {
+ // Build all Deno versions only if no specific runtime was requested
+ for (const version of WELL_KNOWN_DENO_VERSIONS) {
+ if (version === 'current') {
+ denoVersions.add(currentDenoVersion);
+ } else {
+ denoVersions.add(version);
+ }
+ }
+ if (denoVersions.size > 0) {
+ console.log('Building Docker images for Deno versions:');
+ for (const v of denoVersions) {
+ const isCurrent = v === currentDenoVersion ? ' (current)' : '';
+ console.log(` - ${v}${isCurrent}`);
+ }
+ }
+ }
let failed = 0;
- for (const version of versionList) {
- const success = await buildImage(version, repoRoot);
+ let total = 0;
+
+ // Build Node.js images
+ for (const version of nodeVersions) {
+ total++;
+ const success = await buildNodeImage(version, repoRoot);
+ if (!success) {
+ failed++;
+ }
+ }
+
+ // Build Deno images
+ for (const version of denoVersions) {
+ total++;
+ const success = await buildDenoImage(version, repoRoot);
if (!success) {
failed++;
}
}
console.log('\n---');
- console.log(`Built ${versionList.length - failed}/${versionList.length} images.`);
+ console.log(`Built ${total - failed}/${total} images.`);
if (failed > 0) {
process.exit(1);
diff --git a/ts/e2e-tests/_utils/scripts/docker-clean.ts b/ts/e2e-tests/_utils/scripts/docker-clean.ts
index 42123077a..6554c726e 100644
--- a/ts/e2e-tests/_utils/scripts/docker-clean.ts
+++ b/ts/e2e-tests/_utils/scripts/docker-clean.ts
@@ -1,22 +1,22 @@
#!/usr/bin/env bun
/**
- * Removes all Docker images used by the Node.js e2e tests.
- * Images are identified by the label `composio.e2e=true` and `composio.runtime=node`.
+ * Removes all Docker images used by Node.js and Deno e2e tests.
+ * Images are identified by the label `composio.e2e=true`.
*/
import { $ } from 'bun';
-async function main() {
- console.log('Finding e2e Node.js Docker images...');
+async function cleanImages(runtime: 'node' | 'deno'): Promise<number> {
+ console.log(`Finding e2e ${runtime === 'node' ? 'Node.js' : 'Deno'} Docker images...`);
// Find all images with the e2e labels
- const result = await $`docker images --filter label=composio.e2e=true --filter label=composio.runtime=node --format {{.Repository}}:{{.Tag}}`
+ const result = await $`docker images --filter label=composio.e2e=true --filter label=composio.runtime=${runtime} --format {{.Repository}}:{{.Tag}}`
.nothrow()
.quiet();
if (result.exitCode !== 0) {
- console.error('Failed to list Docker images:', result.stderr.toString());
- process.exit(1);
+ console.error(`Failed to list Docker images:`, result.stderr.toString());
+ return 1;
}
const images = result.stdout
@@ -26,8 +26,8 @@ async function main() {
.filter((img) => img.length > 0 && !img.includes('<none>'));
if (images.length === 0) {
- console.log('No e2e Node.js Docker images found.');
- return;
+ console.log(`No e2e ${runtime === 'node' ? 'Node.js' : 'Deno'} Docker images found.`);
+ return 0;
}
console.log(`Found ${images.length} image(s) to remove:`);
@@ -47,12 +47,24 @@ async function main() {
}
}
- if (removeFailures > 0) {
- console.error(`Failed to remove ${removeFailures} image(s).`);
+ return removeFailures;
+}
+
+async function main() {
+ let totalFailures = 0;
+
+ // Clean Node.js images
+ totalFailures += await cleanImages('node');
+
+ // Clean Deno images
+ totalFailures += await cleanImages('deno');
+
+ if (totalFailures > 0) {
+ console.error(`\nFailed to remove ${totalFailures} image(s).`);
process.exit(1);
}
- console.log('Done.');
+ console.log('\nDone.');
}
main().catch((err) => {
diff --git a/ts/e2e-tests/_utils/src/config.ts b/ts/e2e-tests/_utils/src/config.ts
index 845765286..ca78782e0 100644
--- a/ts/e2e-tests/_utils/src/config.ts
+++ b/ts/e2e-tests/_utils/src/config.ts
@@ -2,12 +2,13 @@ import { dirname, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import { readFileSync } from 'node:fs';
import process from 'node:process';
-import type { NodeVersionMeta, NodeVersionFromUser, SkipInCI, NonEmptyArray } from './types';
+import type { NodeVersionMeta, NodeVersionFromUser, DenoVersionMeta, DenoVersionFromUser, SkipInCI, NonEmptyArray } from './types';
declare module 'bun' {
interface Env {
CI?: string;
COMPOSIO_E2E_NODE_VERSION?: string;
+ COMPOSIO_E2E_DENO_VERSION?: string;
}
}
@@ -104,3 +105,80 @@ export function getNvmrcVersion(): string {
}
}
+/**
+ * Read the Deno version from .dvmrc file.
+ * Used to determine the version for 'current' tests.
+ *
+ * @throws Error if .dvmrc file does not exist
+ */
+export function getDvmrcVersion(): string {
+ try {
+ const dvmrc = readFileSync(resolve(getRepoRoot(), '.dvmrc'), 'utf-8');
+ return dvmrc.trim();
+ } catch {
+ throw new Error(
+ 'Failed to read .dvmrc for Deno version resolution. ' +
+ 'Create a .dvmrc file at the repo root with the desired Deno version (e.g., "2.6.7").'
+ );
+ }
+}
+
+/**
+ * Compute skip state for a Deno version in CI mode.
+ */
+function computeSkipForDenoVersion(
+ envVersion: string | undefined,
+ versionValue: string
+): SkipInCI {
+ if (!isCI() || !envVersion) {
+ return { value: false };
+ }
+
+ if (versionValue !== envVersion) {
+ return {
+ value: true,
+ reason: `Deno ${versionValue} not selected (running ${envVersion})`,
+ };
+ }
+
+ return { value: false };
+}
+
+/**
+ * Resolve the Deno versions to test against, with CI skip state.
+ *
+ * The `'current'` version always resolves to the value in `.dvmrc`.
+ *
+ * In CI mode (CI env var set + COMPOSIO_E2E_DENO_VERSION set):
+ * - Versions not matching COMPOSIO_E2E_DENO_VERSION are marked to skip
+ *
+ * In local mode:
+ * - COMPOSIO_E2E_DENO_VERSION overrides everything (single version, no skip)
+ * - Otherwise returns all configured versions (no skip)
+ */
+export function resolveDenoVersionMetaList(
+ configDenoVersions?: readonly DenoVersionFromUser[]
+): NonEmptyArray<DenoVersionMeta> {
+ const envVersion = Bun.env.COMPOSIO_E2E_DENO_VERSION;
+ const dvmrcVersion = getDvmrcVersion();
+
+ // Local mode with env override: single version, no skip
+ if (!isCI() && envVersion) {
+ return [{ kind: 'overridden', value: envVersion, skip: { value: false } }];
+ }
+
+ // No config provided: use .dvmrc version
+ if (configDenoVersions === undefined || configDenoVersions.length === 0) {
+ return [{ kind: 'current', value: dvmrcVersion, skip: { value: false } }];
+ }
+
+ const resolvedVersions = configDenoVersions.map((v): DenoVersionMeta => {
+ if (v === 'current') {
+ return { kind: 'current', value: dvmrcVersion, skip: computeSkipForDenoVersion(envVersion, dvmrcVersion) };
+ }
+ return { kind: 'static', value: v, skip: computeSkipForDenoVersion(envVersion, v) };
+ });
+
+ return resolvedVersions as NonEmptyArray<DenoVersionMeta>;
+}
+
diff --git a/ts/e2e-tests/_utils/src/const.ts b/ts/e2e-tests/_utils/src/const.ts
index 1b2f7b711..1258df48f 100644
--- a/ts/e2e-tests/_utils/src/const.ts
+++ b/ts/e2e-tests/_utils/src/const.ts
@@ -9,6 +9,12 @@ export const WELL_KNOWN_ENV_VARS = ['COMPOSIO_API_KEY', 'OPENAI_API_KEY'] as con
*/
export const WELL_KNOWN_NODE_VERSIONS = ['20.18.0', '20.19.0', '22.12.0', 'current'] as const;
+/**
+ * Deno versions that are well-known to the CI matrix strategy.
+ * `current` refers to the Deno version specified in `.dvmrc`.
+ */
+export const WELL_KNOWN_DENO_VERSIONS = ['2.6.7', 'current'] as const;
+
export const TIMEOUTS = {
DEFAULT: 5_000,
LLM_SHORT: 15_000,
diff --git a/ts/e2e-tests/_utils/src/image-lifecycle.ts b/ts/e2e-tests/_utils/src/image-lifecycle.ts
index 6baa4ce84..8faeeaea7 100644
--- a/ts/e2e-tests/_utils/src/image-lifecycle.ts
+++ b/ts/e2e-tests/_utils/src/image-lifecycle.ts
@@ -79,9 +79,9 @@ function escapeShellArg(arg: string): string {
}
/**
- * Creates default Docker labels for e2e images.
+ * Creates default Docker labels for Node.js e2e images.
*/
-function defaultLabels(nodeVersion?: string): Record<string, string> {
+function defaultNodeLabels(nodeVersion?: string): Record<string, string> {
const labels: Record<string, string> = {
'composio.e2e': 'true',
'composio.runtime': 'node',
@@ -92,6 +92,20 @@ function defaultLabels(nodeVersion?: string): Record<string, string> {
return labels;
}
+/**
+ * Creates default Docker labels for Deno e2e images.
+ */
+function defaultDenoLabels(denoVersion?: string): Record<string, string> {
+ const labels: Record<string, string> = {
+ 'composio.e2e': 'true',
+ 'composio.runtime': 'deno',
+ };
+ if (denoVersion) {
+ labels['composio.deno_version'] = denoVersion;
+ }
+ return labels;
+}
+
/**
* Converts labels object to Docker CLI arguments array.
*/
@@ -180,7 +194,7 @@ export async function ensureNodeImage(
dockerfilePath,
'--build-arg',
`NODE_VERSION=${nodeVersion}`,
- ...labelsToArgs(defaultLabels(nodeVersion)),
+ ...labelsToArgs(defaultNodeLabels(nodeVersion)),
'-t',
imageTag,
repoRoot,
@@ -211,7 +225,7 @@ export async function runNodeContainer(options: RunNodeContainerOptions): Promis
const dockerArgs = ['run', '--rm'];
- dockerArgs.push(...labelsToArgs({ ...defaultLabels(nodeVersion), ...(labels ?? {}) }));
+ dockerArgs.push(...labelsToArgs({ ...defaultNodeLabels(nodeVersion), ...(labels ?? {}) }));
// Assign a custom container name for easier identification and cleanup.
if (name) {
@@ -275,3 +289,168 @@ export async function runNodeContainer(options: RunNodeContainerOptions): Promis
return exec('docker', dockerArgs);
}
+
+// ============================================================================
+// Deno Docker utilities
+// ============================================================================
+
+/**
+ * Options for running a Deno container.
+ */
+export interface RunDenoContainerOptions {
+ imageTag: string;
+ cmd: string | string[];
+ cwd?: string;
+ mounts?: DockerMount[];
+ /** Named volume mounts (volumes must be created beforehand with `docker volume create`) */
+ volumes?: DockerVolumeMount[];
+ env?: Record<string, string | undefined>;
+ labels?: Record<string, string>;
+ name?: string;
+}
+
+/**
+ * Options for ensureDenoImage.
+ */
+export interface EnsureDenoImageOptions {
+ repoRoot?: string;
+ dockerfilePath?: string;
+}
+
+/**
+ * Creates image tag for a given Deno version.
+ */
+function imageTagForDenoVersion(denoVersion: string): string {
+ return `composio-e2e-deno:${denoVersion}`;
+}
+
+/**
+ * Parses Deno version from an image tag.
+ */
+function parseDenoVersionFromImageTag(imageTag: string): string | undefined {
+ const match = /^composio-e2e-deno:(.+)$/.exec(imageTag);
+ return match?.[1];
+}
+
+/**
+ * Ensures a Docker image exists for the given Deno version, building it if necessary.
+ */
+export async function ensureDenoImage(
+ denoVersion: string,
+ options: EnsureDenoImageOptions = {}
+): Promise<string> {
+ if (!denoVersion || typeof denoVersion !== 'string') {
+ throw new Error(`ensureDenoImage(${denoVersion}): denoVersion must be a non-empty string`);
+ }
+
+ const repoRoot = options.repoRoot ?? getRepoRoot();
+ const dockerfilePath = options.dockerfilePath ?? resolve(repoRoot, 'ts/e2e-tests/_utils/Dockerfile.deno');
+ const imageTag = imageTagForDenoVersion(denoVersion);
+
+ const inspect = await exec('docker', ['image', 'inspect', imageTag], { cwd: repoRoot });
+ if (inspect.exitCode === 0) {
+ return imageTag;
+ }
+
+ const buildArgs = [
+ 'build',
+ '-f',
+ dockerfilePath,
+ '--build-arg',
+ `DENO_VERSION=${denoVersion}`,
+ ...labelsToArgs(defaultDenoLabels(denoVersion)),
+ '-t',
+ imageTag,
+ repoRoot,
+ ];
+
+ const built = await exec('docker', buildArgs, { cwd: repoRoot });
+ if (built.exitCode !== 0) {
+ const err = new Error(`Failed to build Docker image ${imageTag}`);
+ (err as Error & { cause: Error }).cause = new Error(built.stderr || built.stdout);
+ throw err;
+ }
+
+ return imageTag;
+}
+
+/**
+ * Runs a command in a Deno Docker container.
+ */
+export async function runDenoContainer(options: RunDenoContainerOptions): Promise<ExecResult> {
+ const { imageTag, cmd, cwd, mounts, volumes, env, labels, name } = options;
+
+ // Validate imageTag is provided, as it determines which Docker image to run.
+ if (!imageTag || typeof imageTag !== 'string') {
+ throw new Error('runDenoContainer({ imageTag, ... }): imageTag must be a non-empty string');
+ }
+
+ const denoVersion = parseDenoVersionFromImageTag(imageTag);
+
+ const dockerArgs = ['run', '--rm'];
+
+ dockerArgs.push(...labelsToArgs({ ...defaultDenoLabels(denoVersion), ...(labels ?? {}) }));
+
+ // Assign a custom container name for easier identification and cleanup.
+ if (name) {
+ dockerArgs.push('--name', name);
+ }
+
+ // Set the working directory inside the container, defaulting relative paths to /app.
+ if (cwd) {
+ const containerCwd = cwd.startsWith('/') ? cwd : `/app/${cwd}`;
+ dockerArgs.push('--workdir', containerCwd);
+ }
+
+ // Pass environment variables to the container for runtime configuration.
+ if (env) {
+ for (const [k, v] of Object.entries(env)) {
+ // Skip undefined values to avoid passing empty env vars to Docker.
+ if (v === undefined) continue;
+ dockerArgs.push('-e', `${k}=${v}`);
+ }
+ }
+
+ // Configure bind mounts to share host directories with the container.
+ if (mounts) {
+ for (const m of mounts) {
+ // Ensure each mount has required source and target paths.
+ if (!m?.source || !m?.target) {
+ throw new Error('runDenoContainer(...): each mount must have { source, target }');
+ }
+ const parts = [`type=bind`, `src=${m.source}`, `dst=${m.target}`];
+ // Mark mount as read-only to prevent container from modifying host files.
+ if (m.readonly) parts.push('readonly');
+ dockerArgs.push('--mount', parts.join(','));
+ }
+ }
+
+ // Configure named volume mounts for sharing state between container runs.
+ if (volumes) {
+ for (const v of volumes) {
+ // Ensure each volume mount has required volume name and target path.
+ if (!v?.volume || !v?.target) {
+ throw new Error('runDenoContainer(...): each volume must have { volume, target }');
+ }
+ const parts = [`type=volume`, `src=${v.volume}`, `dst=${v.target}`];
+ // Mark mount as read-only if specified.
+ if (v.readonly) parts.push('readonly');
+ dockerArgs.push('--mount', parts.join(','));
+ }
+ }
+
+ dockerArgs.push(imageTag);
+
+ // Handle cmd as array for direct execution without shell interpretation.
+ if (Array.isArray(cmd)) {
+ dockerArgs.push(...cmd.map(String));
+ // Handle cmd as string by wrapping in deno run with necessary permissions.
+ } else if (typeof cmd === 'string' && cmd.length > 0) {
+ // Use deno run with all permissions for e2e tests
+ dockerArgs.push('sh', '-lc', `deno run --allow-all ${cmd}`);
+ } else {
+ throw new Error('runDenoContainer({ cmd, ... }): cmd must be a non-empty string or string[]');
+ }
+
+ return exec('docker', dockerArgs);
+}
diff --git a/ts/e2e-tests/_utils/src/index.ts b/ts/e2e-tests/_utils/src/index.ts
index c6d7756e8..61a26e38c 100644
--- a/ts/e2e-tests/_utils/src/index.ts
+++ b/ts/e2e-tests/_utils/src/index.ts
@@ -1,3 +1,14 @@
-export type { E2EConfig, E2ETestResult, E2ETestResultWithSetup, RunFixtureOptions, DefineTestsContext, NodeVersionMeta as NodeVersion, SkipInCI } from './types';
+export type {
+ E2EConfig,
+ E2ETestResult,
+ E2ETestResultWithSetup,
+ RunFixtureOptions,
+ DefineTestsContext,
+ NodeVersionMeta as NodeVersion,
+ DenoVersionMeta as DenoVersion,
+ RuntimeVersions,
+ RuntimeKind,
+ SkipInCI,
+} from './types';
export { e2e } from './e2e';
export { sanitizeOutput } from './sanitize';
diff --git a/ts/e2e-tests/_utils/src/runner.ts b/ts/e2e-tests/_utils/src/runner.ts
index 779379621..6415b74ca 100644
--- a/ts/e2e-tests/_utils/src/runner.ts
+++ b/ts/e2e-tests/_utils/src/runner.ts
@@ -1,9 +1,20 @@
import { describe, beforeAll, afterAll, it } from 'bun:test';
import { appendFile, writeFile } from 'node:fs/promises';
import { resolve } from 'node:path';
-import type { DefineTestsContext, E2EConfig, E2ETestResult, E2ETestResultWithSetup, NodeVersionMeta, NonEmptyString, RunFixtureOptions } from './types';
-import { getRepoRoot, resolveNodeVersionMetaList } from './config';
-import { ensureNodeImage, runNodeContainer } from './image-lifecycle';
+import type {
+ DefineTestsContext,
+ E2EConfig,
+ E2ETestResult,
+ E2ETestResultWithSetup,
+ NodeVersionMeta,
+ DenoVersionMeta,
+ NonEmptyString,
+ RunFixtureOptions,
+ RuntimeVersions,
+ RuntimeKind,
+} from './types';
+import { getRepoRoot, resolveNodeVersionMetaList, resolveDenoVersionMetaList } from './config';
+import { ensureNodeImage, runNodeContainer, ensureDenoImage, runDenoContainer } from './image-lifecycle';
import { WELL_KNOWN_ENV_VARS } from './const';
import { createVolume, generateVolumeName, initializeVolumeOwnership, removeVolume } from './volume';
@@ -27,9 +38,10 @@ interface PhaseResult {
}
/**
- * Aggregated results for a Node version.
+ * Aggregated results for a runtime version.
*/
interface VersionResult {
+ runtime: RuntimeKind;
version: string;
status: 'pass' | 'fail' | 'skipped';
reason?: string;
@@ -45,12 +57,12 @@ interface DebugLogManagerOptions {
logPath: string;
suiteName: string;
testFilePath: string;
- nodeVersions: string[];
+ runtimeVersions: string[];
}
/**
* Manages structured DEBUG.log output for e2e tests.
- * Clears the file at initialization, groups phases by Node version,
+ * Clears the file at initialization, groups phases by runtime version,
* and writes a summary at the end.
*/
class DebugLogManager {
@@ -103,7 +115,7 @@ class DebugLogManager {
`E2E Test: ${this.options.suiteName}`,
`Started: ${this.startTime.toISOString()}`,
`Test file: ${this.options.testFilePath}`,
- `Node versions: ${this.options.nodeVersions.join(', ')}`,
+ `Runtime versions: ${this.options.runtimeVersions.join(', ')}`,
divider,
'',
].join('\n');
@@ -111,10 +123,11 @@ class DebugLogManager {
private formatVersionSection(result: VersionResult): string {
const dividerHeavy = '#'.repeat(80);
+ const runtimeLabel = result.runtime === 'node' ? 'Node.js' : 'Deno';
const lines: string[] = [
'',
dividerHeavy,
- `### Node.js ${result.version}${result.status === 'skipped' ? ' (SKIPPED)' : ''}`,
+ `### ${runtimeLabel} ${result.version}${result.status === 'skipped' ? ' (SKIPPED)' : ''}`,
dividerHeavy,
];
@@ -168,15 +181,16 @@ class DebugLogManager {
];
for (const result of this.versionResults) {
+ const runtimeLabel = result.runtime === 'node' ? 'Node.js' : 'Deno';
if (result.status === 'skipped') {
- lines.push(`Node.js ${result.version}: SKIPPED`);
+ lines.push(`${runtimeLabel} ${result.version}: SKIPPED`);
} else {
const status = result.status.toUpperCase();
const phaseCount = result.phases.length;
const versionDurationSec = result.totalDurationMs
? (result.totalDurationMs / 1000).toFixed(2)
: '?';
- lines.push(`Node.js ${result.version}: ${status} (${phaseCount} phases, ${versionDurationSec}s total)`);
+ lines.push(`${runtimeLabel} ${result.version}: ${status} (${phaseCount} phases, ${versionDurationSec}s total)`);
}
}
@@ -190,6 +204,11 @@ class DebugLogManager {
}
}
+// ============================================================================
+// Container environment utilities
+// ============================================================================
+
+
/**
* Builds environment variables to pass to the container.
* Merges auto-passthrough vars with explicitly provided env vars.
@@ -256,11 +275,14 @@ interface VersionExecutionContext {
imageTag: string;
}
+// ============================================================================
+// Node.js Docker Executors
+// ============================================================================
+
/**
- * Creates Docker execution utilities for a specific Node version.
- * Now tracks phase results for the DebugLogManager.
+ * Creates Docker execution utilities for a specific Node.js version.
*/
-function createDockerExecutors(
+function createNodeDockerExecutors(
config: RunE2EInternalConfig,
nodeVersion: string,
imageTag: string,
@@ -269,11 +291,8 @@ function createDockerExecutors(
) {
const { cwd, suiteName, env, usesFixtures } = config;
const containerEnv = buildContainerEnv(env);
-
- // Compute effective cwd based on usesFixtures flag
const effectiveCwd = usesFixtures ? `${cwd}/fixtures` : cwd;
- // Track execution context for this version
const context: VersionExecutionContext = {
phases: [],
versionStartTime: Date.now(),
@@ -281,7 +300,7 @@ function createDockerExecutors(
};
const runCmd = async (command: string): Promise<E2ETestResult> => {
- const containerName = `e2e-${suiteName}-${nodeVersion.replace(/\./g, '-')}-${Date.now()}`;
+ const containerName = `e2e-${suiteName}-node-${nodeVersion.replace(/\./g, '-')}-${Date.now()}`;
const startTime = Date.now();
const result = await runNodeContainer({
@@ -294,11 +313,10 @@ function createDockerExecutors(
const durationMs = Date.now() - startTime;
- // Track as a standalone phase (not pre/fixture)
context.phases.push({
phase: 'fixture',
phaseIndex: context.phases.length + 1,
- totalPhases: context.phases.length + 1, // Updated later if more phases
+ totalPhases: context.phases.length + 1,
command,
containerName,
durationMs,
@@ -322,26 +340,18 @@ function createDockerExecutors(
async function runFixture(options: RunFixtureOptions): Promise<E2ETestResult | E2ETestResultWithSetup> {
const { filename, setup } = options;
- // Smart mode: no setup (or empty string) = no volumes, just run directly
if (!setup) {
return runCmd(`node ${filename}`);
}
- // With setup: use Docker volumes
const volumeName = generateVolumeName(suiteName, nodeVersion);
- const containerBaseName = `e2e-${suiteName}-${nodeVersion.replace(/\./g, '-')}-${Date.now()}`;
-
- // The volume mounts at node_modules relative to the effective cwd
+ const containerBaseName = `e2e-${suiteName}-node-${nodeVersion.replace(/\./g, '-')}-${Date.now()}`;
const volumeTarget = `${effectiveCwd.startsWith('/') ? effectiveCwd : `/app/${effectiveCwd}`}/node_modules`;
try {
- // 1. Create volume
await createVolume(volumeName);
-
- // 2. Initialize volume with correct ownership for node user (UID 1000)
await initializeVolumeOwnership(volumeName, imageTag);
- // 3. Run setup command with volume mounted read-write
const setupContainerName = `${containerBaseName}-setup`;
const setupStartTime = Date.now();
const setupResult = await runNodeContainer({
@@ -350,15 +360,10 @@ function createDockerExecutors(
cwd: effectiveCwd,
env: containerEnv,
name: setupContainerName,
- volumes: [{
- volume: volumeName,
- target: volumeTarget,
- readonly: false,
- }],
+ volumes: [{ volume: volumeName, target: volumeTarget, readonly: false }],
});
const setupDurationMs = Date.now() - setupStartTime;
- // Track setup phase
context.phases.push({
phase: 'setup',
phaseIndex: 1,
@@ -371,7 +376,6 @@ function createDockerExecutors(
stderr: setupResult.stderr,
});
- // 4. Run fixture with volume mounted read-only (runs regardless of setup exit code)
const fixtureContainerName = `${containerBaseName}-fixture`;
const fixtureStartTime = Date.now();
const fixtureResult = await runNodeContainer({
@@ -380,15 +384,10 @@ function createDockerExecutors(
cwd: effectiveCwd,
env: containerEnv,
name: fixtureContainerName,
- volumes: [{
- volume: volumeName,
- target: volumeTarget,
- readonly: true,
- }],
+ volumes: [{ volume: volumeName, target: volumeTarget, readonly: true }],
});
const fixtureDurationMs = Date.now() - fixtureStartTime;
- // Track fixture phase
context.phases.push({
phase: 'fixture',
phaseIndex: 2,
@@ -401,29 +400,19 @@ function createDockerExecutors(
stderr: fixtureResult.stderr,
});
- // 5. Return combined result (top-level is fixture result)
- return {
- ...fixtureResult,
- setup: setupResult,
- };
+ return { ...fixtureResult, setup: setupResult };
} finally {
- // 6. Always cleanup volume (best-effort, doesn't throw)
await removeVolume(volumeName);
}
}
- /**
- * Finalize this version's log output.
- * Call this after all test phases have completed.
- */
const finalizeVersionLog = async (): Promise<void> => {
const totalDurationMs = Date.now() - context.versionStartTime;
-
- // Determine overall status based on exit codes
const allPassed = context.phases.every(p => p.exitCode === 0);
const status: 'pass' | 'fail' = allPassed ? 'pass' : 'fail';
await logManager.writeVersionSection({
+ runtime: 'node',
version: nodeVersion,
status,
imageTag: context.imageTag,
@@ -435,12 +424,209 @@ function createDockerExecutors(
return { runCmd, runFixture, finalizeVersionLog, context };
}
+// ============================================================================
+// Deno Docker Executors
+// ============================================================================
+
+/**
+ * Creates Docker execution utilities for a specific Deno version.
+ */
+function createDenoDockerExecutors(
+ config: RunE2EInternalConfig,
+ denoVersion: string,
+ imageTag: string,
+ repoRoot: string,
+ logManager: DebugLogManager
+) {
+ const { cwd, suiteName, env, usesFixtures } = config;
+ const containerEnv = buildContainerEnv(env);
+ const effectiveCwd = usesFixtures ? `${cwd}/fixtures` : cwd;
+
+ const context: VersionExecutionContext = {
+ phases: [],
+ versionStartTime: Date.now(),
+ imageTag,
+ };
+
+ const runCmd = async (command: string): Promise<E2ETestResult> => {
+ const containerName = `e2e-${suiteName}-deno-${denoVersion.replace(/\./g, '-')}-${Date.now()}`;
+ const startTime = Date.now();
+
+ const result = await runDenoContainer({
+ imageTag,
+ cmd: command,
+ cwd: effectiveCwd,
+ env: containerEnv,
+ name: containerName,
+ });
+
+ const durationMs = Date.now() - startTime;
+
+ context.phases.push({
+ phase: 'fixture',
+ phaseIndex: context.phases.length + 1,
+ totalPhases: context.phases.length + 1,
+ command,
+ containerName,
+ durationMs,
+ exitCode: result.exitCode,
+ stdout: result.stdout,
+ stderr: result.stderr,
+ });
+
+ return result;
+ };
+
+ function runFixture(options: { filename: string }): Promise<E2ETestResult>;
+ function runFixture(options: { filename: string; setup: string }): Promise<E2ETestResultWithSetup>;
+ async function runFixture(options: RunFixtureOptions): Promise<E2ETestResult | E2ETestResultWithSetup> {
+ const { filename, setup } = options;
+
+ // For Deno without setup, just run the file directly
+ if (!setup) {
+ return runCmd(filename);
+ }
+
+ // Deno with setup: use Docker volumes for caching
+ const volumeName = generateVolumeName(suiteName, denoVersion);
+ const containerBaseName = `e2e-${suiteName}-deno-${denoVersion.replace(/\./g, '-')}-${Date.now()}`;
+ // Deno caches to DENO_DIR, but we also support node_modules for npm packages
+ const volumeTarget = `${effectiveCwd.startsWith('/') ? effectiveCwd : `/app/${effectiveCwd}`}/node_modules`;
+
+ try {
+ await createVolume(volumeName);
+ await initializeVolumeOwnership(volumeName, imageTag);
+
+ const setupContainerName = `${containerBaseName}-setup`;
+ const setupStartTime = Date.now();
+ const setupResult = await runDenoContainer({
+ imageTag,
+ cmd: setup,
+ cwd: effectiveCwd,
+ env: containerEnv,
+ name: setupContainerName,
+ volumes: [{ volume: volumeName, target: volumeTarget, readonly: false }],
+ });
+ const setupDurationMs = Date.now() - setupStartTime;
+
+ context.phases.push({
+ phase: 'setup',
+ phaseIndex: 1,
+ totalPhases: 2,
+ command: setup,
+ containerName: setupContainerName,
+ durationMs: setupDurationMs,
+ exitCode: setupResult.exitCode,
+ stdout: setupResult.stdout,
+ stderr: setupResult.stderr,
+ });
+
+ const fixtureContainerName = `${containerBaseName}-fixture`;
+ const fixtureStartTime = Date.now();
+ const fixtureResult = await runDenoContainer({
+ imageTag,
+ cmd: filename,
+ cwd: effectiveCwd,
+ env: containerEnv,
+ name: fixtureContainerName,
+ volumes: [{ volume: volumeName, target: volumeTarget, readonly: true }],
+ });
+ const fixtureDurationMs = Date.now() - fixtureStartTime;
+
+ context.phases.push({
+ phase: 'fixture',
+ phaseIndex: 2,
+ totalPhases: 2,
+ command: filename,
+ containerName: fixtureContainerName,
+ durationMs: fixtureDurationMs,
+ exitCode: fixtureResult.exitCode,
+ stdout: fixtureResult.stdout,
+ stderr: fixtureResult.stderr,
+ });
+
+ return { ...fixtureResult, setup: setupResult };
+ } finally {
+ await removeVolume(volumeName);
+ }
+ }
+
+ const finalizeVersionLog = async (): Promise<void> => {
+ const totalDurationMs = Date.now() - context.versionStartTime;
+ const allPassed = context.phases.every(p => p.exitCode === 0);
+ const status: 'pass' | 'fail' = allPassed ? 'pass' : 'fail';
+
+ await logManager.writeVersionSection({
+ runtime: 'deno',
+ version: denoVersion,
+ status,
+ imageTag: context.imageTag,
+ phases: context.phases,
+ totalDurationMs,
+ });
+ };
+
+ return { runCmd, runFixture, finalizeVersionLog, context };
+}
+
+// ============================================================================
+// Version normalization and resolution
+// ============================================================================
+
+/**
+ * Normalize config to support both old (nodeVersions) and new (versions) formats.
+ */
+function normalizeVersionConfig(config: E2EConfig): RuntimeVersions {
+ // New format takes precedence
+ if (config.versions) {
+ return config.versions;
+ }
+ // Legacy format
+ if (config.nodeVersions) {
+ return { node: config.nodeVersions };
+ }
+ // Default: use current Node.js version
+ return { node: ['current'] };
+}
+
+/**
+ * Render a Node.js version meta for display in test names.
+ */
+function renderNodeVersionMeta({ kind, value }: NodeVersionMeta): string {
+ switch (kind) {
+ case 'current':
+ return `Node.js ${value} [current]`;
+ case 'overridden':
+ return `Node.js ${value} [overridden]`;
+ case 'static':
+ return `Node.js ${value}`;
+ }
+}
+
+/**
+ * Render a Deno version meta for display in test names.
+ */
+function renderDenoVersionMeta({ kind, value }: DenoVersionMeta): string {
+ switch (kind) {
+ case 'current':
+ return `Deno ${value} [current]`;
+ case 'overridden':
+ return `Deno ${value} [overridden]`;
+ case 'static':
+ return `Deno ${value}`;
+ }
+}
+
+// ============================================================================
+// Main test runner
+// ============================================================================
+
/**
* Runs e2e tests using bun:test.
- * Creates a describe block per Node version and passes test utilities to defineTests.
+ * Creates a describe block per runtime version and passes test utilities to defineTests.
*
- * In CI mode, versions not matching COMPOSIO_E2E_NODE_VERSION are skipped.
- * Each version's skipInCI state is computed by resolveNodeVersionMetaList().
+ * Supports both Node.js and Deno runtimes.
+ * In CI mode, versions not matching their respective env vars are skipped.
*/
export function runE2E(config: RunE2EInternalConfig): void {
const { cwd, suiteName, defineTests, env } = config;
@@ -448,30 +634,28 @@ export function runE2E(config: RunE2EInternalConfig): void {
// Validate env vars early, before any Docker operations
validateRequiredEnvVars(env, suiteName);
- const nodeVersionMetaList = resolveNodeVersionMetaList(config.nodeVersions);
+ const versions = normalizeVersionConfig(config);
const repoRoot = getRepoRoot();
+ // Resolve versions for each runtime
+ const nodeVersionMetaList = versions.node ? resolveNodeVersionMetaList(versions.node) : [];
+ const denoVersionMetaList = versions.deno ? resolveDenoVersionMetaList(versions.deno) : [];
+
+ // Build runtime version labels for logging
+ const allRuntimeVersions = [
+ ...nodeVersionMetaList.map(v => `Node.js ${v.value}`),
+ ...denoVersionMetaList.map(v => `Deno ${v.value}`),
+ ];
+
// Create the debug log manager for structured output
const logPath = resolve(repoRoot, cwd, 'DEBUG.log');
- const allVersions = nodeVersionMetaList.map(v => v.value);
const logManager = new DebugLogManager({
logPath,
suiteName,
testFilePath: `${cwd}/e2e.test.ts`,
- nodeVersions: allVersions,
+ runtimeVersions: allRuntimeVersions,
});
- function renderNodeVersionMeta({ kind, value }: NodeVersionMeta) {
- switch (kind) {
- case 'current':
- return `Node.js ${value} [current]`;
- case 'overridden':
- return `Node.js ${value} [overridden]`;
- case 'static':
- return `Node.js ${value}`;
- }
- }
-
// Wrap all tests in a top-level describe to handle initialization and summary
describe(suiteName, () => {
// Initialize log file before any tests run
@@ -479,6 +663,7 @@ export function runE2E(config: RunE2EInternalConfig): void {
await logManager.initialize();
});
+ // =========== Node.js Tests ===========
for (const nodeVersionMeta of nodeVersionMetaList) {
const testName = renderNodeVersionMeta(nodeVersionMeta);
@@ -486,8 +671,8 @@ export function runE2E(config: RunE2EInternalConfig): void {
if (nodeVersionMeta.skip.value) {
describe(`${testName} - skipped: ${nodeVersionMeta.skip.reason}`, () => {
beforeAll(async () => {
- // Write skip marker to log
await logManager.writeVersionSection({
+ runtime: 'node',
version: nodeVersionMeta.value,
status: 'skipped',
reason: nodeVersionMeta.skip.reason || 'Skipped in CI',
@@ -501,21 +686,63 @@ export function runE2E(config: RunE2EInternalConfig): void {
}
describe(testName, () => {
- let executors: ReturnType<typeof createDockerExecutors>;
+ let executors: ReturnType<typeof createNodeDockerExecutors>;
- // Ensure Docker image exists before tests run
beforeAll(async () => {
const imageTag = await ensureNodeImage(nodeVersionMeta.value, { repoRoot });
- executors = createDockerExecutors(config, nodeVersionMeta.value, imageTag, repoRoot, logManager);
- }, 600_000); // 10 minute timeout for Docker image build
+ executors = createNodeDockerExecutors(config, nodeVersionMeta.value, imageTag, repoRoot, logManager);
+ }, 600_000);
+
+ defineTests({
+ runtime: 'node',
+ runCmd: (cmd) => executors.runCmd(cmd),
+ runFixture: ((opts: RunFixtureOptions) => executors.runFixture(opts)) as DefineTestsContext['runFixture'],
+ });
+
+ afterAll(async () => {
+ if (executors) {
+ await executors.finalizeVersionLog();
+ }
+ });
+ });
+ }
+
+ // =========== Deno Tests ===========
+ for (const denoVersionMeta of denoVersionMetaList) {
+ const testName = renderDenoVersionMeta(denoVersionMeta);
+
+ // Skip this version in CI if not selected
+ if (denoVersionMeta.skip.value) {
+ describe(`${testName} - skipped: ${denoVersionMeta.skip.reason}`, () => {
+ beforeAll(async () => {
+ await logManager.writeVersionSection({
+ runtime: 'deno',
+ version: denoVersionMeta.value,
+ status: 'skipped',
+ reason: denoVersionMeta.skip.reason || 'Skipped in CI',
+ phases: [],
+ });
+ });
+
+ it('this version should not run in this CI matrix job', () => {});
+ });
+ continue;
+ }
+
+ describe(testName, () => {
+ let executors: ReturnType<typeof createDenoDockerExecutors>;
+
+ beforeAll(async () => {
+ const imageTag = await ensureDenoImage(denoVersionMeta.value, { repoRoot });
+ executors = createDenoDockerExecutors(config, denoVersionMeta.value, imageTag, repoRoot, logManager);
+ }, 600_000);
- // Call user's defineTests with bun:test functions and Docker utilities
defineTests({
+ runtime: 'deno',
runCmd: (cmd) => executors.runCmd(cmd),
runFixture: ((opts: RunFixtureOptions) => executors.runFixture(opts)) as DefineTestsContext['runFixture'],
});
- // Write version section after all tests for this version complete
afterAll(async () => {
if (executors) {
await executors.finalizeVersionLog();
diff --git a/ts/e2e-tests/_utils/src/types.ts b/ts/e2e-tests/_utils/src/types.ts
index dc859aa7a..a0fc7106c 100644
--- a/ts/e2e-tests/_utils/src/types.ts
+++ b/ts/e2e-tests/_utils/src/types.ts
@@ -1,4 +1,4 @@
-import { WELL_KNOWN_NODE_VERSIONS } from './const';
+import { WELL_KNOWN_NODE_VERSIONS, WELL_KNOWN_DENO_VERSIONS } from './const';
export type NonEmptyArray<T> = [T, ...T[]];
@@ -14,6 +14,7 @@ export type NonEmptyArray<T> = [T, ...T[]];
export type NonEmptyString<T extends string> = T extends '' ? never : T;
export type NodeVersionFromUser = typeof WELL_KNOWN_NODE_VERSIONS[number];
+export type DenoVersionFromUser = typeof WELL_KNOWN_DENO_VERSIONS[number];
/**
* Result of CI skip check for a specific Node version.
@@ -32,6 +33,26 @@ export type NodeVersionMeta =
| { kind: 'overridden'; value: string; skip: SkipInCI }
| { kind: 'current'; value: string; skip: SkipInCI };
+/**
+ * Metadata for a resolved Deno version to test against.
+ * Includes skip state for CI mode.
+ */
+export type DenoVersionMeta =
+ | { kind: 'static'; value: Exclude<typeof WELL_KNOWN_DENO_VERSIONS[number], 'current'>; skip: SkipInCI }
+ | { kind: 'overridden'; value: string; skip: SkipInCI }
+ | { kind: 'current'; value: string; skip: SkipInCI };
+
+/**
+ * Runtime versions to test against.
+ * Supports both Node.js and Deno runtimes.
+ */
+export interface RuntimeVersions {
+ /** Node.js versions to test */
+ node?: readonly NodeVersionFromUser[];
+ /** Deno versions to test */
+ deno?: readonly DenoVersionFromUser[];
+}
+
/**
* Result of executing a command in a Docker container.
*/
@@ -63,10 +84,17 @@ export interface RunFixtureOptions {
setup?: string;
}
+/**
+ * Supported runtime environments for e2e tests.
+ */
+export type RuntimeKind = 'node' | 'deno';
+
/**
* Context passed to defineTests callback.
*/
export interface DefineTestsContext {
+ /** The runtime environment for this test execution */
+ runtime: RuntimeKind;
/** Run an arbitrary command in the Docker container */
runCmd: (command: string) => Promise<E2ETestResult>;
/**
@@ -109,9 +137,26 @@ export interface E2EConfig {
* Node.js versions to test against.
* Each version creates a separate describe block.
* If not provided, defaults to the current Node runtime version.
+ *
+ * @deprecated Use `versions.node` instead. This property will be removed in a future version.
*/
nodeVersions?: readonly NodeVersionFromUser[];
+ /**
+ * Runtime versions to test against.
+ * Supports Node.js and Deno runtimes.
+ * Takes precedence over the deprecated `nodeVersions` property.
+ *
+ * @example
+ * ```typescript
+ * versions: {
+ * node: ['20.19.0', '22.12.0'],
+ * deno: ['2.6.7'],
+ * }
+ * ```
+ */
+ versions?: RuntimeVersions;
+
/**
* Environment variables to pass to the Docker container.
*/
diff --git a/ts/e2e-tests/runtimes/deno/esm-basic/README.md b/ts/e2e-tests/runtimes/deno/esm-basic/README.md
new file mode 100644
index 000000000..d03d94db7
--- /dev/null
+++ b/ts/e2e-tests/runtimes/deno/esm-basic/README.md
@@ -0,0 +1,47 @@
+# Deno ESM Compatibility Test
+
+Verifies that `@composio/core` works correctly when imported via `npm:` specifier in Deno.
+
+## Why This Exists
+
+Deno v2.0+ supports npm packages via the `npm:` specifier. This suite ensures:
+
+- `import('npm:@composio/core')` resolves without errors
+- Named imports work
+- All public exports are accessible
+- No Node.js-only patterns break Deno consumers
+
+## What It Tests
+
+| Test | Description |
+| --------------------- | ------------------------------------------------ |
+| Dynamic import | `import('npm:@composio/core')` doesn't throw |
+| Composio class | Main class is exported and constructible |
+| OpenAIProvider | Provider class exports and instantiation |
+| AuthScheme | Auth enum is accessible |
+| ComposioError | Error classes are exported |
+| jsonSchemaToZodSchema | Utility function is exported |
+| constants | Constants namespace is accessible |
+| logger | Logger instance is exported |
+
+## Fixture
+
+```
+fixtures/
+├── deno.jsonc # Deno config to use local workspace packages
+└── test.ts # Deno test script using npm: specifier
+```
+
+The fixture uses Deno's native `npm:` specifier to import `@composio/core` and validates each export.
+
+The `deno.jsonc` file configures `nodeModulesDir: "auto"`, which tells Deno to resolve `npm:` imports from the local `node_modules` directory (populated by pnpm with symlinks to workspace packages). This ensures we test the local build of `@composio/core` rather than the published npm version.
+
+## Isolation Tool
+
+**Docker** with Deno version: 2.6.7
+
+## Running
+
+```bash
+pnpm test:e2e:deno
+```
diff --git a/ts/e2e-tests/runtimes/deno/esm-basic/e2e.test.ts b/ts/e2e-tests/runtimes/deno/esm-basic/e2e.test.ts
new file mode 100644
index 000000000..5c2a8f214
--- /dev/null
+++ b/ts/e2e-tests/runtimes/deno/esm-basic/e2e.test.ts
@@ -0,0 +1,68 @@
+/**
+ * ESM compatibility e2e test for Deno
+ *
+ * Verifies that @composio/core can be imported using npm: specifier in Deno.
+ */
+
+import { e2e, type E2ETestResult } from '@e2e-tests/utils';
+import { describe, it, expect, beforeAll } from 'bun:test';
+
+e2e(import.meta.url, {
+ versions: {
+ deno: ['2.6.7'],
+ },
+ usesFixtures: true,
+ defineTests: ({ runFixture }) => {
+ let result: E2ETestResult;
+
+ beforeAll(async () => {
+ result = await runFixture({ filename: 'test.ts' });
+ });
+
+ describe('ESM compatibility (Deno)', () => {
+ it('exits successfully', () => {
+ expect(result.exitCode).toBe(0);
+ });
+
+ it('import npm:@composio/core succeeds', () => {
+ expect(result.stdout).toContain('Test 1 passed: import() succeeded');
+ });
+
+ it('exports Composio class', () => {
+ expect(result.stdout).toContain('Test 2 passed: Composio class is exported');
+ });
+
+ it('exports OpenAIProvider class', () => {
+ expect(result.stdout).toContain('Test 3 passed: OpenAIProvider class is exported');
+ });
+
+ it('instantiates OpenAIProvider successfully', () => {
+ expect(result.stdout).toContain('Test 4 passed: OpenAIProvider instantiated successfully');
+ });
+
+ it('exports AuthScheme', () => {
+ expect(result.stdout).toContain('Test 5 passed: AuthScheme is exported');
+ });
+
+ it('exports Error classes', () => {
+ expect(result.stdout).toContain('Test 6 passed: Error classes are exported');
+ });
+
+ it('exports jsonSchemaToZodSchema', () => {
+ expect(result.stdout).toContain('Test 7 passed: jsonSchemaToZodSchema is exported');
+ });
+
+ it('exports constants namespace', () => {
+ expect(result.stdout).toContain('Test 8 passed: constants namespace is exported');
+ });
+
+ it('exports logger', () => {
+ expect(result.stdout).toContain('Test 9 passed: logger is exported');
+ });
+
+ it('completes all tests', () => {
+ expect(result.stdout).toContain('All ESM compatibility tests passed!');
+ });
+ });
+ },
+});
diff --git a/ts/e2e-tests/runtimes/deno/esm-basic/fixtures/deno.jsonc b/ts/e2e-tests/runtimes/deno/esm-basic/fixtures/deno.jsonc
new file mode 100644
index 000000000..8a7b43807
--- /dev/null
+++ b/ts/e2e-tests/runtimes/deno/esm-basic/fixtures/deno.jsonc
@@ -0,0 +1,6 @@
+{
+ "$schema": "https://deno.land/x/deno/cli/schemas/config-file.v1.json",
+ // Use the existing node_modules from pnpm workspace
+ // This resolves npm:@composio/core to the local workspace package
+ "nodeModulesDir": "auto"
+}
diff --git a/ts/e2e-tests/runtimes/deno/esm-basic/fixtures/test.ts b/ts/e2e-tests/runtimes/deno/esm-basic/fixtures/test.ts
new file mode 100644
index 000000000..a4e9f0d0b
--- /dev/null
+++ b/ts/e2e-tests/runtimes/deno/esm-basic/fixtures/test.ts
@@ -0,0 +1,76 @@
+/**
+ * ESM compatibility test for @composio/core in Deno
+ * Uses npm: specifier to import the package
+ */
+
+import { assert } from 'jsr:@std/assert@^1.0.0';
+
+console.log('Testing ESM compatibility for @composio/core in Deno...\n');
+
+// Test 1: Dynamic import works via npm: specifier
+console.log('Test 1: import("npm:@composio/core") should not throw...');
+let composioModule: Record<string, unknown>;
+try {
+ composioModule = await import('npm:@composio/core');
+ console.log('Test 1 passed: import() succeeded\n');
+} catch (error) {
+ console.error('Test 1 failed: import() threw an error');
+ console.error(error);
+ Deno.exit(1);
+}
+
+// Test 2: Composio class is exported
+console.log('Test 2: Composio class should be exported...');
+assert(composioModule.Composio, 'Composio class should be exported');
+assert(typeof composioModule.Composio === 'function', 'Composio should be a constructor');
+console.log('Test 2 passed: Composio class is exported\n');
+
+// Test 3: OpenAIProvider class is exported
+console.log('Test 3: OpenAIProvider class should be exported...');
+assert(composioModule.OpenAIProvider, 'OpenAIProvider class should be exported');
+assert(typeof composioModule.OpenAIProvider === 'function', 'OpenAIProvider should be a constructor');
+console.log('Test 3 passed: OpenAIProvider class is exported\n');
+
+// Test 4: Can instantiate OpenAIProvider
+console.log('Test 4: OpenAIProvider should be instantiable...');
+try {
+ const OpenAIProvider = composioModule.OpenAIProvider as new () => unknown;
+ const provider = new OpenAIProvider();
+ assert(provider, 'Provider instance should exist');
+ console.log('Test 4 passed: OpenAIProvider instantiated successfully\n');
+} catch (error) {
+ console.error('Test 4 failed: Could not instantiate OpenAIProvider');
+ console.error(error);
+ Deno.exit(1);
+}
+
+// Test 5: AuthScheme is exported
+console.log('Test 5: AuthScheme should be exported...');
+assert(composioModule.AuthScheme, 'AuthScheme should be exported');
+console.log('Test 5 passed: AuthScheme is exported\n');
+
+// Test 6: Error classes are exported
+console.log('Test 6: Error classes should be exported...');
+assert(composioModule.ComposioError, 'ComposioError should be exported');
+console.log('Test 6 passed: Error classes are exported\n');
+
+// Test 7: jsonSchemaToZodSchema utility is exported
+console.log('Test 7: jsonSchemaToZodSchema should be exported...');
+assert(composioModule.jsonSchemaToZodSchema, 'jsonSchemaToZodSchema should be exported');
+assert(typeof composioModule.jsonSchemaToZodSchema === 'function', 'jsonSchemaToZodSchema should be a function');
+console.log('Test 7 passed: jsonSchemaToZodSchema is exported\n');
+
+// Test 8: constants namespace is exported
+console.log('Test 8: constants namespace should be exported...');
+assert(composioModule.constants, 'constants should be exported');
+console.log('Test 8 passed: constants namespace is exported\n');
+
+// Test 9: logger is exported
+console.log('Test 9: logger should be exported...');
+assert(composioModule.logger, 'logger should be exported');
+console.log('Test 9 passed: logger is exported\n');
+
+console.log('========================================');
+console.log('All ESM compatibility tests passed!');
+console.log('========================================');
+Deno.exit(0);
diff --git a/ts/e2e-tests/runtimes/deno/esm-basic/package.json b/ts/e2e-tests/runtimes/deno/esm-basic/package.json
new file mode 100644
index 000000000..cf42e6b6e
--- /dev/null
+++ b/ts/e2e-tests/runtimes/deno/esm-basic/package.json
@@ -0,0 +1,15 @@
+{
+ "name": "@e2e-tests/deno-esm-basic",
+ "version": "0.0.0",
+ "private": true,
+ "type": "module",
+ "scripts": {
+ "typecheck": "tsc --noEmit",
+ "test:e2e": "bun test e2e.test.ts",
+ "test:e2e:deno": "bun test e2e.test.ts"
+ },
+ "devDependencies": {
+ "@composio/core": "workspace:*",
+ "@e2e-tests/utils": "workspace:*"
+ }
+}
diff --git a/ts/e2e-tests/runtimes/deno/esm-basic/tsconfig.json b/ts/e2e-tests/runtimes/deno/esm-basic/tsconfig.json
new file mode 100644
index 000000000..3eeaa418d
--- /dev/null
+++ b/ts/e2e-tests/runtimes/deno/esm-basic/tsconfig.json
@@ -0,0 +1,12 @@
+{
+ "$schema": "https://json.schemastore.org/tsconfig",
+ "compilerOptions": {
+ "target": "es2022",
+ "module": "esnext",
+ "moduleResolution": "bundler",
+ "strict": true,
+ "skipLibCheck": true,
+ "noEmit": true
+ },
+ "include": ["e2e.test.ts"]
+}
diff --git a/turbo.jsonc b/turbo.jsonc
index 45bb0fe74..eff0da018 100644
--- a/turbo.jsonc
+++ b/turbo.jsonc
@@ -27,6 +27,11 @@
"env": ["COMPOSIO_API_KEY", "COMPOSIO_E2E_NODE_VERSION", "OPENAI_API_KEY"],
"cache": false
},
+ "test:e2e:deno": {
+ "dependsOn": ["^build"],
+ "env": ["COMPOSIO_API_KEY", "COMPOSIO_E2E_DENO_VERSION", "OPENAI_API_KEY"],
+ "cache": false
+ },
"test:e2e:cloudflare": {
"dependsOn": ["^build"],
"env": ["COMPOSIO_API_KEY", "OPENAI_API_KEY"],