mastra 0.2.0-alpha.140 → 0.2.0-alpha.145

package/dist/index.js

@@ -1,34 +1,28 @@
 #! /usr/bin/env node
 import { PosthogAnalytics } from './chunk-K5HPNH5H.js';
 export { PosthogAnalytics } from './chunk-K5HPNH5H.js';
-import { DepsService, create, checkPkgJson, checkAndInstallCoreDeps, interactivePrompt, init, logger, FileService } from './chunk-EY6ROB2P.js';
-export { create } from './chunk-EY6ROB2P.js';
+import { DepsService, create, checkPkgJson, checkAndInstallCoreDeps, interactivePrompt, init, FileService, logger } from './chunk-AKW5JN32.js';
+export { create } from './chunk-AKW5JN32.js';
 import { Command } from 'commander';
-import color from 'picocolors';
-import path4, { join, dirname } from 'node:path';
-import { MastraBundler } from '@mastra/core/bundler';
-import { getDeployer, FileService as FileService$1, getBundler, getWatcher } from '@mastra/deployer';
-import virtual from '@rollup/plugin-virtual';
-import * as fsExtra from 'fs-extra';
+import 'picocolors';
+import { join, dirname } from 'node:path';
+import { FileService as FileService$1, getWatcherInputOptions, createWatcher } from '@mastra/deployer/build';
+import { Bundler } from '@mastra/deployer/bundler';
+import * as fsExtra2 from 'fs-extra';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath as fileURLToPath$1 } from 'node:url';
-import path2, { join as join$1 } from 'path';
+import { getDeployer, FileService as FileService$2 } from '@mastra/deployer';
+import { join as join$1 } from 'path';
 import 'child_process';
-import { execa, ExecaError } from 'execa';
-import fs, { writeFileSync } from 'fs';
+import { execa } from 'execa';
+import { writeFileSync } from 'fs';
 import { fileURLToPath } from 'url';
-import * as p from '@clack/prompts';
-import { spinner as spinner$1, intro, note } from '@clack/prompts';
-import yoctoSpinner from 'yocto-spinner';
-import { check } from 'tcp-port-used';
-import dotenv from 'dotenv';
+import { MastraBundler } from '@mastra/core/bundler';
+import 'dotenv';
 
-var BuildBundler = class extends MastraBundler {
+var BuildBundler = class extends Bundler {
   constructor() {
-    super({
-      name: "Build",
-      component: "BUNDLER"
-    });
+    super("Build");
   }
   getEnvFiles() {
     const possibleFiles = [".env.production", ".env"];
@@ -41,25 +35,16 @@ var BuildBundler = class extends MastraBundler {
     return Promise.resolve([]);
   }
   async prepare(outputDirectory) {
-    await fsExtra.ensureDir(outputDirectory);
-    await fsExtra.emptyDir(outputDirectory);
+    await super.prepare(outputDirectory);
     const __filename2 = fileURLToPath$1(import.meta.url);
     const __dirname = dirname(__filename2);
-    const playgroundServePath = join(outputDirectory, "playground");
-    await fsExtra.copy(join(dirname(__dirname), "src/playground/dist"), playgroundServePath, {
+    const playgroundServePath = join(outputDirectory, ".build", "playground");
+    await fsExtra2.copy(join(dirname(__dirname), "src/playground/dist"), playgroundServePath, {
       overwrite: true
     });
   }
-  async bundle(mastraDir, outputDirectory) {
-    const bundler = await getBundler({
-      input: "#entry",
-      plugins: [virtual({ "#entry": this.getEntry() })]
-    });
-    await bundler.write({
-      file: `${outputDirectory}/index.mjs`,
-      format: "es",
-      inlineDynamicImports: true
-    });
+  bundle(entryFile, outputDirectory) {
+    return this._bundle(this.getEntry(), entryFile, outputDirectory);
   }
   getEntry() {
     const __filename2 = fileURLToPath$1(import.meta.url);
@@ -73,21 +58,29 @@ async function build({ dir }) {
   const mastraDir = dir ?? process.cwd();
   const outputDirectory = join(mastraDir, ".mastra");
   const deployer = new BuildBundler();
+  const fs2 = new FileService();
+  const mastraEntryFile = fs2.getFirstExistingFile([
+    join(mastraDir, "src", "mastra", "index.ts"),
+    join(mastraDir, "src", "mastra", "index.js")
+  ]);
+  console.log(join(mastraDir, "index.ts"), join(mastraDir, "index.js"));
   await deployer.prepare(outputDirectory);
-  await deployer.bundle(mastraDir, outputDirectory);
+  await deployer.bundle(mastraEntryFile, outputDirectory);
 }
 async function deploy({ dir }) {
   let mastraDir = dir || join$1(process.cwd(), "src/mastra");
   try {
     const outputDirectory = join$1(process.cwd(), ".mastra");
-    const deployer = await getDeployer(mastraDir, outputDirectory);
+    const fs2 = new FileService();
+    const mastraEntryFile = fs2.getFirstExistingFile([join$1(mastraDir, "index.ts"), join$1(mastraDir, "index.js")]);
+    const deployer = await getDeployer(mastraEntryFile, outputDirectory);
     if (!deployer) {
       logger.warn("No deployer found.");
       return;
     }
     try {
       await deployer.prepare(outputDirectory);
-      await deployer.bundle(mastraDir, outputDirectory);
+      await deployer.bundle(mastraEntryFile, outputDirectory);
       try {
         await deployer.deploy(outputDirectory);
       } catch (error) {
@@ -106,45 +99,59 @@ async function deploy({ dir }) {
   }
 }
 var DevBundler = class extends MastraBundler {
-  constructor() {
+  mastraDir;
+  constructor(mastraDir) {
     super({
       name: "Dev",
       component: "BUNDLER"
     });
+    this.mastraDir = mastraDir;
   }
   getEnvFiles() {
     const possibleFiles = [".env.development", ".env"];
     try {
-      const fileService = new FileService$1();
+      const fileService = new FileService$2();
       const envFile = fileService.getFirstExistingFile(possibleFiles);
       return Promise.resolve([envFile]);
     } catch (err) {
     }
     return Promise.resolve([]);
   }
+  async writePackageJson() {
+  }
   async prepare(outputDirectory) {
-    await fsExtra.ensureDir(outputDirectory);
-    await fsExtra.emptyDir(outputDirectory);
+    await fsExtra2.ensureDir(outputDirectory);
+    await fsExtra2.emptyDir(outputDirectory);
     const __filename2 = fileURLToPath$1(import.meta.url);
     const __dirname = dirname(__filename2);
     const playgroundServePath = join(outputDirectory, "playground");
-    await fsExtra.copy(join(dirname(__dirname), "src/playground/dist"), playgroundServePath, {
+    await fsExtra2.copy(join(dirname(__dirname), "src/playground/dist"), playgroundServePath, {
       overwrite: true
     });
   }
   async watch(outputDirectory) {
-    const watcher = await getWatcher({
-      ...this.getInputOptions(),
-      // @ts-ignore
-      output: {
-        dir: outputDirectory,
-        format: "es",
-        entryFileNames: "[name].mjs"
+    const __filename2 = fileURLToPath$1(import.meta.url);
+    const __dirname = dirname(__filename2);
+    const fileService = new FileService$2();
+    const entryFile = fileService.getFirstExistingFile([
+      join(this.mastraDir, "index.ts"),
+      join(this.mastraDir, "index.js")
+    ]);
+    const inputOptions = await getWatcherInputOptions(entryFile, "node");
+    const watcher = await createWatcher(
+      {
+        ...inputOptions,
+        input: {
+          index: join(__dirname, "templates", "dev.entry.js")
+        },
+        watch: {
+          include: await this.getEnvFiles()
+        }
       },
-      watch: {
-        include: await this.getEnvFiles()
+      {
+        dir: outputDirectory
       }
-    });
+    );
     this.logger.info("Starting watcher...");
     return new Promise((resolve, reject) => {
       const cb = (event) => {
@@ -154,6 +161,7 @@ var DevBundler = class extends MastraBundler {
           resolve(watcher);
         }
         if (event.code === "ERROR") {
+          console.log(event);
           this.logger.error("Bundling failed, stopping watcher...");
           watcher.off("event", cb);
           reject(event);
@@ -164,19 +172,6 @@ var DevBundler = class extends MastraBundler {
   }
   async bundle() {
   }
-  getEntry() {
-    const __filename2 = fileURLToPath$1(import.meta.url);
-    const __dirname = dirname(__filename2);
-    return readFileSync(join(__dirname, "templates", "dev.entry.js"), "utf8");
-  }
-  getInputOptions() {
-    return {
-      input: {
-        index: "#entry"
-      },
-      plugins: [virtual({ "#entry": this.getEntry() })]
-    };
-  }
 };
 
 // src/commands/dev/dev.ts
@@ -250,9 +245,9 @@ async function rebundleAndRestart(dotMastraPath, port, bundler) {
 }
 async function dev({ port, dir, root }) {
   const rootDir = root || process.cwd();
-  join$1(rootDir, dir || "src/mastra");
+  const mastraDir = join$1(rootDir, dir || "src/mastra");
   const dotMastraPath = join$1(rootDir, ".mastra");
-  const bundler = new DevBundler();
+  const bundler = new DevBundler(mastraDir);
   const env = await bundler.loadEnvVars();
   await bundler.prepare(dotMastraPath);
   writeFileSync(join$1(dotMastraPath, "evals.json"), ``);
@@ -273,357 +268,6 @@ async function dev({ port, dir, root }) {
     process.exit(0);
   });
 }
-var DockerService = class {
-  sanitizeName(name) {
-    let sanitized = name.toLowerCase();
-    sanitized = sanitized.replace(/[^a-z0-9-]/g, "-");
-    sanitized = sanitized.replace(/^-+|-+$/g, "");
-    if (sanitized.length < 2) {
-      throw new Error("Name must be at least 2 characters long.");
-    }
-    if (sanitized.length > 255) {
-      sanitized = sanitized.substring(0, 255);
-    }
-    return sanitized;
-  }
-  async isPortOpen(port) {
-    return new Promise((resolve) => {
-      check(port).then((inUse) => {
-        resolve(!inUse);
-      });
-    });
-  }
-  async provision(projectName) {
-    const sanitizedProjectName = this.sanitizeName(projectName);
-    const { postgresPort } = await this.getInfraPorts();
-    try {
-      if (!await this.checkDockerRunning()) {
-        throw new Error("Docker Daemon is not running. Please start Docker and try again\n");
-      }
-      const { dbUrl } = await this.prepareComposeFile({
-        sanitizedProjectName,
-        postgresPort
-      });
-      return { dbUrl };
-    } catch (error) {
-      throw error;
-    }
-  }
-  async getNextOpenPort(startFrom = 2222) {
-    for (const port of Array.from({ length: 20 }, (_, i) => startFrom + i)) {
-      const isOpen = await this.isPortOpen(port);
-      if (isOpen) {
-        return port;
-      }
-    }
-    throw new Error("No open ports found after 20 attempts");
-  }
-  async getInfraPorts({
-    defaultPostgresPort
-  } = {}) {
-    let postgresPort = defaultPostgresPort || 5432;
-    const dbPortOpen = await this.isPortOpen(postgresPort);
-    if (!dbPortOpen) {
-      postgresPort = await this.getNextOpenPort(postgresPort);
-    }
-    return { postgresPort };
-  }
-  async checkDockerRunning() {
-    try {
-      await execa("docker", ["info"], { stdio: "ignore", shell: true });
-      return true;
-    } catch (error) {
-      return false;
-    }
-  }
-  async startDockerContainer(dockerComposeFile) {
-    try {
-      await execa("docker", ["compose", "-f", dockerComposeFile, "up", "-d"], { stdio: "inherit" });
-      return true;
-    } catch (error) {
-      return false;
-    }
-  }
-  async stopDockerContainer(dockerComposeFile) {
-    try {
-      await execa("docker", ["compose", "-f", dockerComposeFile, "down"], { stdio: "inherit" });
-      return true;
-    } catch (error) {
-      return false;
-    }
-  }
-  async prepareComposeFile({
-    sanitizedProjectName,
-    postgresPort
-  }) {
-    let dbUrl = `postgresql://postgres:postgres@localhost:${postgresPort}/mastra`;
-    this.editComposeFile({ sanitizedProjectName, postgresPort });
-    const fileService = new FileService();
-    await fileService.copyStarterFile("mastra-pg.docker-compose.yaml", "mastra-pg.docker-compose.yaml");
-    return { dbUrl: String(dbUrl) };
-  }
-  editComposeFile({
-    sanitizedProjectName,
-    postgresPort
-  }) {
-    const __filename2 = fileURLToPath(import.meta.url);
-    const __dirname = path2.dirname(__filename2);
-    const filePath = path2.resolve(__dirname, "starter-files", "mastra-pg.docker-compose.yaml");
-    const fileService = new FileService();
-    fileService.replaceValuesInFile({
-      filePath,
-      replacements: [
-        { replace: sanitizedProjectName, search: "REPLACE_PROJECT_NAME" },
-        { replace: `${postgresPort}`, search: "REPLACE_DB_PORT" }
-      ]
-    });
-  }
-  getComposeFile(composePath) {
-    const fileService = new FileService();
-    let composeFile;
-    if (composePath) {
-      if (!fs.existsSync(composePath)) {
-        throw new Error(`Docker compose file not found: ${composePath}`);
-      }
-      composeFile = composePath;
-    } else {
-      composeFile = fileService.getFirstExistingFile([
-        "mastra-pg.docker-compose.yaml",
-        "mastra-pg.docker-compose.yml",
-        "docker-compose.yaml",
-        "docker-compose.yml"
-      ]);
-    }
-    return composeFile;
-  }
-};
-
-// src/commands/engine/add.ts
-var DOCKER_COMPOSE_FILE = "mastra-pg.docker-compose.yaml";
-async function add() {
-  const spinner3 = yoctoSpinner();
-  try {
-    await checkAndInstallEngineDeps();
-    const depsService2 = new DepsService();
-    const projectName = await depsService2.getProjectName();
-    const dockerService = new DockerService();
-    spinner3.start("Provisioning Mastra database");
-    const { dbUrl } = await dockerService.provision(projectName);
-    spinner3.success("Mastra database provisioned");
-    spinner3.start("Starting Mastra engine");
-    dockerService.startDockerContainer(DOCKER_COMPOSE_FILE);
-    spinner3.success("Mastra engine started");
-    const fileService = new FileService();
-    await fileService.setupEnvFile({ dbUrl });
-    spinner3.success("Mastra engine setup complete");
-  } catch (error) {
-    spinner3.error("Failed to start Mastra engine");
-    throw error;
-  }
-}
-async function checkAndInstallEngineDeps() {
-  const depsService2 = new DepsService();
-  const depCheck = await depsService2.checkDependencies(["@mastra/engine", "drizzle-kit"]);
-  if (depCheck !== "ok") {
-    await installEngineDeps();
-  }
-}
-async function installEngineDeps() {
-  const spinner3 = yoctoSpinner({ text: "Installing Mastra engine dependencies\n" });
-  try {
-    const confirm2 = await p.confirm({
-      message: "Do you want to install the required dependencies (@mastra/engine and drizzle-kit)?",
-      initialValue: false
-    });
-    if (p.isCancel(confirm2)) {
-      p.cancel("Installation Cancelled");
-      process.exit(0);
-    }
-    if (!confirm2) {
-      p.cancel("Installation Cancelled");
-      process.exit(0);
-    }
-    const depsService2 = new DepsService();
-    spinner3.start();
-    await depsService2.installPackages(["@mastra/engine@alpha", "drizzle-kit"]);
-    spinner3.success("Dependencies installed successfully");
-  } catch (err) {
-    spinner3.error("Could not install dependencies");
-    console.error(err);
-  }
-}
-async function down(composePath) {
-  const spinner3 = yoctoSpinner({ text: "Shutting down docker container\n" });
-  spinner3.start();
-  try {
-    const dockerService = new DockerService();
-    const composeFile = dockerService.getComposeFile(composePath);
-    await dockerService.stopDockerContainer(composeFile);
-    spinner3.success("Docker container shut down successfully\n");
-  } catch (error) {
-    spinner3.error("Failed to shut down Docker container\n");
-    throw error;
-  }
-}
-function getEnginePath() {
-  const possibleEnginePaths = [
-    path2.resolve(process.cwd(), "node_modules", "@mastra/engine"),
-    path2.resolve(process.cwd(), "..", "node_modules", "@mastra/engine"),
-    path2.resolve(process.cwd(), "..", "..", "node_modules", "@mastra/engine"),
-    path2.resolve(process.cwd(), "./packages/engine")
-    // For CI
-  ];
-  const fileService = new FileService();
-  return fileService.getFirstExistingFile(possibleEnginePaths);
-}
-
-// src/commands/engine/generate.ts
-var spinner = yoctoSpinner({ text: "Generating drizzle client\n" });
-var checkDrizzleInstallation = async () => {
-  const depsService2 = new DepsService();
-  if (await depsService2.checkDependencies(["drizzle-kit"]) === "ok") {
-    return true;
-  } else {
-    return false;
-  }
-};
-var installDrizzleKit = async () => {
-  const depsService2 = new DepsService();
-  await depsService2.installPackages(["drizzle-kit"]);
-};
-async function generate(dbUrl) {
-  try {
-    spinner.start();
-    const isDrizzleInstalled = await checkDrizzleInstallation();
-    if (!isDrizzleInstalled) {
-      spinner.text = "Installing drizzle kit\n";
-      await installDrizzleKit();
-    }
-    await generateDrizzleClient(dbUrl);
-    spinner.success("Drizzle client generated\n");
-  } catch (err) {
-    spinner.error("Could not generate drizzle client\n");
-    console.error(err);
-  }
-}
-async function generateDrizzleClient(dbUrl) {
-  const enginePath = getEnginePath();
-  try {
-    await execa(
-      `npx drizzle-kit generate --out=./dist/postgres/drizzle --dialect=postgresql --schema=./dist/postgres/db/schema.js`,
-      {
-        env: {
-          ...process.env,
-          DB_URL: dbUrl
-        },
-        cwd: enginePath,
-        shell: true,
-        all: true,
-        stdio: "inherit"
-        // inherit will pipe directly to parent process stdout/stderr
-      }
-    );
-  } catch (err) {
-    throw err;
-  }
-}
-var s = spinner$1();
-async function migrate(dbUrl) {
-  intro(`${color.bgCyan(color.black(" Mastra migrate "))}`);
-  s.start("Migrating Database\n");
-  try {
-    await checkPostgresReady(dbUrl);
-    s.stop();
-    note("Migration complete! Your project is ready to go.");
-    process.exit(0);
-  } catch (error) {
-    s.stop("Could not migrate database");
-    if (error instanceof ExecaError) {
-      console.error("error");
-    } else {
-      console.log(`Error: ${error.message}`);
-    }
-    process.exit(1);
-  }
-}
-async function _migrate(dbUrl, swallow = false) {
-  const enginePath = getEnginePath();
-  const stdioMode = swallow ? "pipe" : "inherit";
-  const newPath = path2.join(enginePath, "dist", "postgres", "migrate.js");
-  const subprocess = execa(`node`, [`${newPath}`], {
-    env: {
-      ...process.env,
-      DB_URL: dbUrl
-    },
-    shell: true,
-    all: true,
-    stdio: ["pipe", stdioMode, stdioMode],
-    timeout: 6e4
-  });
-  subprocess.stdout?.pipe(process.stdout);
-  if (subprocess.stdin) {
-    subprocess.on("spawn", () => {
-      const responses = ["y\n", "yes\n"];
-      const respondToPrompts = setInterval(() => {
-        if (subprocess.stdin && !subprocess.stdin.destroyed) {
-          responses.forEach((response) => {
-            subprocess.stdin.write(response);
-          });
-        }
-      }, 100);
-      subprocess.on("exit", () => {
-        clearInterval(respondToPrompts);
-        subprocess.stdin?.end();
-      });
-    });
-  }
-  try {
-    const { stdout, stderr } = await subprocess;
-    return { stdout: stdout || "", stderr: stderr || "" };
-  } catch (error) {
-    if (error.killed && error.timedOut) {
-      throw new Error(`Command timed out after 60000ms`);
-    }
-    throw error;
-  }
-}
-async function checkPostgresReady(dbUrl) {
-  for (let i = 0; i < 10; i++) {
-    try {
-      await _migrate(dbUrl);
-      return true;
-    } catch (error) {
-      if (error instanceof Error) {
-        console.error(error.message);
-      }
-      console.log(`Waiting for postgres to be ready, attempt ${i + 1} of 10`);
-    }
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
-  }
-  throw new Error("Postgres is not ready, aborting");
-}
-async function up(composePath) {
-  const spinner3 = yoctoSpinner({ text: "Starting docker container\n" });
-  spinner3.start();
-  try {
-    const dockerService = new DockerService();
-    const composeFile = dockerService.getComposeFile(composePath);
-    await dockerService.startDockerContainer(composeFile);
-    spinner3.success("Docker containers started successfully\n");
-  } catch (error) {
-    spinner3.error("Failed to start Docker containers\n");
-    throw error;
-  }
-}
-function getEnv() {
-  const projectDir = process.cwd();
-  const dotenvPath = path4.join(projectDir, ".env.development");
-  if (fs.existsSync(dotenvPath)) {
-    dotenv.config({ path: dotenvPath });
-  }
-  const dbUrl = process.env.DB_URL || "";
-  return dbUrl;
-}
 
 // src/index.ts
 var depsService = new DepsService();
@@ -711,60 +355,6 @@ program.command("dev").description("Start mastra server").option("-d, --dir <dir
     root: args?.root
   });
 });
-var engine = program.command("engine").description("Manage the mastra engine");
-engine.command("add").description("Add the mastra engine to your application").action(async () => {
-  await analytics.trackCommandExecution({
-    command: "engine add",
-    args: {},
-    execution: async () => {
-      await add();
-    }
-  });
-});
-engine.command("generate").description("Generate types and drizzle client").action(async () => {
-  await analytics.trackCommandExecution({
-    command: "engine generate",
-    args: {},
-    execution: async () => {
-      await generate(process.env.DB_URL);
-    }
-  });
-});
-engine.command("up").description("Runs docker-compose up to start docker containers").option("-f, --file <path>", "Path to docker-compose file").action(async (args) => {
-  await analytics.trackCommandExecution({
-    command: "engine up",
-    args,
-    execution: async () => {
-      await up(args.file);
-    }
-  });
-});
-engine.command("down").description("Runs docker-compose down to shut down docker containers").option("-f, --file <path>", "Path to docker-compose file").action(async (args) => {
-  await analytics.trackCommandExecution({
-    command: "engine down",
-    args: {},
-    execution: async () => {
-      await down(args.file);
-    }
-  });
-});
-engine.command("migrate").description("Migrate the Mastra database forward").action(async () => {
-  await analytics.trackCommandExecution({
-    command: "engine migrate",
-    args: {},
-    execution: async () => {
-      const dbUrl = getEnv();
-      if (dbUrl) {
-        await migrate(dbUrl);
-      } else {
-        logger.debug("Please add DB_URL to your .env.development file");
-        logger.debug(
-          `Run ${color.blueBright("mastra engine add")} to get started with a Postgres DB in a docker container`
-        );
-      }
-    }
-  });
-});
 program.command("build").description("Build your Mastra project").option("-d, --dir <path>", "Path to directory").action(async (args) => {
   await analytics.trackCommandExecution({
     command: "mastra build",

package/dist/starter-files/workflow.ts

@@ -83,7 +83,7 @@ const planActivities = new Step({
 
     const llm = mastra.llm({
       provider: 'OPEN_AI',
-      name: 'gpt-4o',
+      name: 'gpt-4o-mini',
     });
 
     const response = await llm.stream([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mastra",
-  "version": "0.2.0-alpha.140",
+  "version": "0.2.0-alpha.145",
   "license": "MIT",
   "description": "cli for mastra",
   "type": "module",
@@ -36,7 +36,6 @@
   "dependencies": {
     "@clack/prompts": "^0.8.2",
     "@dagrejs/dagre": "^1.1.4",
-    "@rollup/plugin-virtual": "^3.0.2",
     "@swc/core": "^1.9.3",
     "chokidar": "^4.0.3",
     "commander": "^12.1.0",
@@ -56,8 +55,8 @@
     "yocto-spinner": "^0.1.1",
     "zod": "^3.24.1",
     "zod-to-json-schema": "^3.24.1",
-    "@mastra/deployer": "^0.1.0-alpha.33",
-    "@mastra/core": "^0.2.0-alpha.87"
+    "@mastra/core": "^0.2.0-alpha.92",
+    "@mastra/deployer": "^0.1.0-alpha.38"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",