@mastra/deployer 1.54.0-alpha.0 → 1.54.0-alpha.2

package/dist/chunk-YO5OFXPN.cjs

@@ -1,819 +0,0 @@
-'use strict';
-
-var chunk36AWZH7Z_cjs = require('./chunk-36AWZH7Z.cjs');
-var chunk743HRNWT_cjs = require('./chunk-743HRNWT.cjs');
-var chunk3XIMK24X_cjs = require('./chunk-3XIMK24X.cjs');
-var chunkJZRFRUGM_cjs = require('./chunk-JZRFRUGM.cjs');
-var path = require('path');
-var logger = require('@mastra/core/logger');
-var pkg = require('empathic/package');
-var rollup = require('rollup');
-var promises = require('fs/promises');
-var core = require('@babel/core');
-var agent = require('@mastra/core/agent');
-var matter = require('gray-matter');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var pkg__namespace = /*#__PURE__*/_interopNamespace(pkg);
-var matter__default = /*#__PURE__*/_interopDefault(matter);
-
-async function getInputOptions2(entryFile, platform, env, {
-  sourcemap = false,
-  bundlerOptions = {
-    enableSourcemap: false,
-    enableEsmShim: true,
-    externals: true
-  },
-  analysisEntries = [entryFile]
-} = {}) {
-  const closestPkgJson = pkg__namespace.up({ cwd: path.dirname(entryFile) });
-  const projectRoot = closestPkgJson ? path.dirname(chunkJZRFRUGM_cjs.slash(closestPkgJson)) : chunkJZRFRUGM_cjs.slash(process.cwd());
-  const { workspaceMap, workspaceRoot } = await chunk743HRNWT_cjs.getWorkspaceInformation({ mastraEntryFile: entryFile });
-  const analyzeEntryResult = await chunk743HRNWT_cjs.analyzeBundle(
-    analysisEntries,
-    entryFile,
-    {
-      outputDir: path.posix.join(process.cwd(), ".mastra", ".build"),
-      projectRoot: workspaceRoot || process.cwd(),
-      platform,
-      isDev: true,
-      bundlerOptions
-    },
-    logger.noopLogger
-  );
-  const deps = /* @__PURE__ */ new Map();
-  for (const [dep, metadata] of analyzeEntryResult.dependencies.entries()) {
-    const pkgName = chunkJZRFRUGM_cjs.getPackageName(dep);
-    if (pkgName && workspaceMap.has(pkgName)) {
-      deps.set(dep, metadata);
-    }
-  }
-  const inputOptions = await chunk3XIMK24X_cjs.getInputOptions(
-    entryFile,
-    {
-      dependencies: deps,
-      externalDependencies: /* @__PURE__ */ new Map(),
-      workspaceMap
-    },
-    platform,
-    env,
-    { sourcemap, isDev: true, workspaceRoot, projectRoot, externalsPreset: bundlerOptions?.externals === true }
-  );
-  if (Array.isArray(inputOptions.plugins)) {
-    const plugins = [];
-    inputOptions.plugins.forEach((plugin) => {
-      if (plugin?.name === "node-resolve") {
-        return;
-      }
-      if (plugin?.name === "tsconfig-paths") {
-        plugins.push(
-          chunk3XIMK24X_cjs.tsConfigPaths({
-            localResolve: true
-          })
-        );
-        return;
-      }
-      plugins.push(plugin);
-    });
-    inputOptions.plugins = plugins;
-    inputOptions.plugins.push(chunk743HRNWT_cjs.aliasHono());
-    inputOptions.plugins.push(chunk3XIMK24X_cjs.nodeModulesExtensionResolver());
-  }
-  return inputOptions;
-}
-async function createWatcher(inputOptions, outputOptions) {
-  const watcher = await rollup.watch({
-    ...inputOptions,
-    output: {
-      ...outputOptions,
-      format: "esm",
-      entryFileNames: "[name].mjs",
-      chunkFileNames: "[name].mjs"
-    }
-  });
-  return watcher;
-}
-async function analyzeEntryProjectType(mastraEntry) {
-  const code = await promises.readFile(mastraEntry, "utf-8");
-  const result = { hasValidConfig: false };
-  await core.transformAsync(code, {
-    filename: mastraEntry,
-    presets: [undefined("@babel/preset-typescript")],
-    plugins: [() => chunk743HRNWT_cjs.checkConfigExport(result)]
-  });
-  return result.projectType;
-}
-
-// src/build/serverOptions.ts
-async function getServerOptions(entryFile, outputDir, logger) {
-  const result = await chunk36AWZH7Z_cjs.extractMastraOption("server", entryFile, outputDir, logger);
-  if (!result) {
-    return null;
-  }
-  return result.getConfig();
-}
-var CONFIG_BASENAMES = ["config.ts", "config.js"];
-var WORKSPACE_BASENAMES = ["workspace.ts", "workspace.js"];
-var MEMORY_BASENAMES = ["memory.ts", "memory.js"];
-var INSTRUCTIONS_BASENAME = "instructions.md";
-var TOOL_EXTENSIONS = [".ts", ".js"];
-var SKILL_MODULE_EXTENSIONS = [".ts", ".js"];
-var SKILL_MD_BASENAME = "SKILL.md";
-async function exists(path) {
-  try {
-    return !(await promises.lstat(path)).isSymbolicLink();
-  } catch {
-    return false;
-  }
-}
-async function realDirectory(path) {
-  try {
-    const info = await promises.lstat(path);
-    if (info.isDirectory() && !info.isSymbolicLink()) {
-      return chunkJZRFRUGM_cjs.slash(path);
-    }
-  } catch {
-  }
-  return void 0;
-}
-async function directoryExists(path) {
-  return realDirectory(path);
-}
-async function firstExisting(dir, basenames) {
-  for (const basename of basenames) {
-    const candidate = path.join(dir, basename);
-    if (await exists(candidate)) {
-      return chunkJZRFRUGM_cjs.slash(candidate);
-    }
-  }
-  return void 0;
-}
-function isTestFile(basename) {
-  return /\.(test|spec)\.(ts|js)$/.test(basename);
-}
-function toolKey(basename) {
-  return basename.replace(/\.(ts|js)$/, "");
-}
-async function discoverModuleDir(dir) {
-  if (!await exists(dir)) {
-    return [];
-  }
-  let entries;
-  try {
-    entries = await promises.readdir(dir);
-  } catch {
-    return [];
-  }
-  const modules = [];
-  for (const basename of entries.sort()) {
-    if (isTestFile(basename)) {
-      continue;
-    }
-    if (!TOOL_EXTENSIONS.some((ext) => basename.endsWith(ext))) {
-      continue;
-    }
-    const path$1 = path.join(dir, basename);
-    const stats = await promises.lstat(path$1);
-    if (stats.isSymbolicLink() || stats.isDirectory()) {
-      continue;
-    }
-    modules.push({ key: toolKey(basename), path: chunkJZRFRUGM_cjs.slash(path$1) });
-  }
-  return modules;
-}
-async function discoverTools(toolsDir) {
-  return discoverModuleDir(toolsDir);
-}
-async function discoverProcessors(processorsDir) {
-  const result = { input: [], output: [] };
-  for (const type of ["input", "output"]) {
-    const typeDir = path.join(processorsDir, type);
-    if (!await exists(typeDir)) {
-      continue;
-    }
-    let entries;
-    try {
-      entries = await promises.readdir(typeDir);
-    } catch {
-      continue;
-    }
-    for (const basename of entries.sort()) {
-      if (isTestFile(basename)) {
-        continue;
-      }
-      if (!TOOL_EXTENSIONS.some((ext) => basename.endsWith(ext))) {
-        continue;
-      }
-      const path$1 = path.join(typeDir, basename);
-      const stats = await promises.lstat(path$1);
-      if (stats.isSymbolicLink() || stats.isDirectory()) {
-        continue;
-      }
-      result[type].push({ key: toolKey(basename), path: chunkJZRFRUGM_cjs.slash(path$1) });
-    }
-  }
-  return result;
-}
-async function readReferences(referencesDir) {
-  if (!await exists(referencesDir)) {
-    return {};
-  }
-  const references = {};
-  let entries;
-  try {
-    entries = await promises.readdir(referencesDir);
-  } catch {
-    return {};
-  }
-  for (const basename of entries.sort()) {
-    const path$1 = path.join(referencesDir, basename);
-    const stats = await promises.lstat(path$1);
-    if (stats.isSymbolicLink() || stats.isDirectory()) {
-      continue;
-    }
-    references[basename] = await promises.readFile(path$1, "utf-8");
-  }
-  return references;
-}
-async function parsePackagedSkill(skillMdPath, fallbackName, references = {}) {
-  const raw = await promises.readFile(skillMdPath, "utf-8");
-  const parsed = matter__default.default(raw);
-  const frontmatter = parsed.data;
-  const name = frontmatter.name ?? fallbackName;
-  const description = frontmatter.description;
-  if (!description) {
-    throw new Error(
-      `Skill "${name}" in ${skillMdPath} is missing a required "description". Add a YAML frontmatter block with a "description:" field. See https://agentskills.io/specification for the SKILL.md format.`
-    );
-  }
-  const instructions = parsed.content.trim();
-  return { kind: "packaged", name, description, instructions, references };
-}
-function skillModuleName(basename) {
-  return basename.replace(/\.(ts|js)$/, "");
-}
-async function discoverSkills(skillsDir) {
-  if (!await exists(skillsDir)) {
-    return [];
-  }
-  let entries;
-  try {
-    entries = await promises.readdir(skillsDir);
-  } catch {
-    return [];
-  }
-  const skills = [];
-  for (const basename of entries.sort()) {
-    if (isTestFile(basename)) {
-      continue;
-    }
-    const path$1 = path.join(skillsDir, basename);
-    const stats = await promises.lstat(path$1);
-    if (stats.isSymbolicLink()) {
-      continue;
-    }
-    const isDir = stats.isDirectory();
-    if (isDir) {
-      const skillMd = path.join(path$1, SKILL_MD_BASENAME);
-      if (await exists(skillMd)) {
-        const references = await readReferences(path.join(path$1, "references"));
-        skills.push(await parsePackagedSkill(skillMd, skillModuleName(basename), references));
-      }
-      continue;
-    }
-    if (SKILL_MODULE_EXTENSIONS.some((ext) => basename.endsWith(ext))) {
-      skills.push({ kind: "module", path: chunkJZRFRUGM_cjs.slash(path$1) });
-      continue;
-    }
-    if (basename.endsWith(".md")) {
-      const skill = await parsePackagedSkill(path$1, basename.replace(/\.md$/, ""));
-      skills.push(skill);
-    }
-  }
-  return skills;
-}
-async function discoverAgentDir(dir, name, depth, onWarn) {
-  const configPath = await firstExisting(dir, CONFIG_BASENAMES);
-  const instructionsPath = await exists(path.join(dir, INSTRUCTIONS_BASENAME)) ? chunkJZRFRUGM_cjs.slash(path.join(dir, INSTRUCTIONS_BASENAME)) : void 0;
-  if (!configPath && !instructionsPath) {
-    return void 0;
-  }
-  const workspacePath = await firstExisting(dir, WORKSPACE_BASENAMES);
-  const memoryPath = await firstExisting(dir, MEMORY_BASENAMES);
-  const workspaceSeedDir = await directoryExists(path.join(dir, "workspace"));
-  const tools = await discoverTools(path.join(dir, "tools"));
-  const processors = await discoverProcessors(path.join(dir, "processors"));
-  const scorers = await discoverModuleDir(path.join(dir, "scorers"));
-  const skills = await discoverSkills(path.join(dir, "skills"));
-  const subagents = await discoverSubagents(dir, depth, onWarn);
-  return {
-    name,
-    dir: chunkJZRFRUGM_cjs.slash(dir),
-    configPath,
-    instructionsPath,
-    workspacePath,
-    memoryPath,
-    workspaceSeedDir,
-    tools,
-    inputProcessors: processors.input,
-    outputProcessors: processors.output,
-    scorers,
-    skills,
-    subagents
-  };
-}
-async function discoverSubagents(parentDir, parentDepth, onWarn) {
-  const subagentsDir = path.join(parentDir, "subagents");
-  if (!await exists(subagentsDir)) {
-    return [];
-  }
-  if (parentDepth >= agent.MAX_FS_SUBAGENT_DEPTH) {
-    onWarn?.(
-      `Ignoring subagents in "${chunkJZRFRUGM_cjs.slash(subagentsDir)}": subagents may only nest ${agent.MAX_FS_SUBAGENT_DEPTH} levels below a top-level agent.`
-    );
-    return [];
-  }
-  let entries;
-  try {
-    entries = await promises.readdir(subagentsDir);
-  } catch {
-    return [];
-  }
-  const subagents = [];
-  for (const name of entries.sort()) {
-    const dir = path.join(subagentsDir, name);
-    if (!await realDirectory(dir)) {
-      continue;
-    }
-    const child = await discoverAgentDir(dir, name, parentDepth + 1, onWarn);
-    if (child) {
-      subagents.push(child);
-    }
-  }
-  return subagents;
-}
-async function discoverFsAgents(mastraDir, onWarn) {
-  const agentsDir = path.join(mastraDir, "agents");
-  if (!await exists(agentsDir)) {
-    return [];
-  }
-  let entries;
-  try {
-    entries = await promises.readdir(agentsDir);
-  } catch {
-    return [];
-  }
-  const discovered = [];
-  for (const name of entries.sort()) {
-    const dir = path.join(agentsDir, name);
-    if (!await realDirectory(dir)) {
-      continue;
-    }
-    const agent = await discoverAgentDir(dir, name, 0, onWarn);
-    if (agent) {
-      discovered.push(agent);
-    }
-  }
-  return discovered;
-}
-async function discoverFsWorkflows(mastraDir) {
-  const workflowsDir = path.join(mastraDir, "workflows");
-  if (!await exists(workflowsDir)) {
-    return [];
-  }
-  let entries;
-  try {
-    entries = await promises.readdir(workflowsDir);
-  } catch {
-    return [];
-  }
-  const discovered = [];
-  for (const basename of entries.sort()) {
-    if (isTestFile(basename)) {
-      continue;
-    }
-    if (!TOOL_EXTENSIONS.some((ext) => basename.endsWith(ext))) {
-      continue;
-    }
-    const path$1 = path.join(workflowsDir, basename);
-    const stats = await promises.lstat(path$1);
-    if (stats.isSymbolicLink() || stats.isDirectory()) {
-      continue;
-    }
-    const source = await promises.readFile(path$1, "utf-8");
-    if (!/\bexport\s+default\b/.test(source)) {
-      continue;
-    }
-    discovered.push({ key: toolKey(basename), path: chunkJZRFRUGM_cjs.slash(path$1) });
-  }
-  return discovered;
-}
-var SINGLETON_EXTENSIONS = [".ts", ".js", ".mts", ".mjs"];
-var SINGLETON_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
-async function discoverFsSingleton(mastraDir, name) {
-  if (!SINGLETON_NAME_PATTERN.test(name)) {
-    throw new Error(`Invalid fs-singleton name ${JSON.stringify(name)}: expected a bare identifier.`);
-  }
-  for (const ext of SINGLETON_EXTENSIONS) {
-    const candidate = path.join(mastraDir, `${name}${ext}`);
-    try {
-      const stats = await promises.lstat(candidate);
-      if (!stats.isFile() || stats.isSymbolicLink()) {
-        continue;
-      }
-      const source = await promises.readFile(candidate, "utf-8");
-      if (!/\bexport\s+default\b/.test(source)) {
-        continue;
-      }
-      return { path: chunkJZRFRUGM_cjs.slash(candidate) };
-    } catch {
-    }
-  }
-  return void 0;
-}
-function sanitizeIdentifier(name, prefix, index) {
-  const cleaned = name.replace(/[^a-zA-Z0-9_$]/g, "_");
-  return `${prefix}_${index}_${cleaned}`;
-}
-async function emitAgentEntry(agent, idPath, workspaceName, lines) {
-  const configIdent = sanitizeIdentifier(agent.name, "config", idPath);
-  const toolIdents = [];
-  if (agent.configPath) {
-    lines.push(`import ${configIdent} from ${JSON.stringify(agent.configPath)};`);
-  }
-  let workspaceIdent;
-  if (agent.workspacePath) {
-    workspaceIdent = sanitizeIdentifier(`${agent.name}_workspace`, "workspace", idPath);
-    lines.push(`import ${workspaceIdent} from ${JSON.stringify(agent.workspacePath)};`);
-  }
-  let memoryIdent;
-  if (agent.memoryPath) {
-    memoryIdent = sanitizeIdentifier(`${agent.name}_memory`, "memory", idPath);
-    lines.push(`import ${memoryIdent} from ${JSON.stringify(agent.memoryPath)};`);
-  }
-  for (let t = 0; t < agent.tools.length; t++) {
-    const tool = agent.tools[t];
-    const ident = sanitizeIdentifier(`${agent.name}_${tool.key}`, "tool", `${idPath}_${t}`);
-    lines.push(`import ${ident} from ${JSON.stringify(tool.path)};`);
-    toolIdents.push({ key: tool.key, ident });
-  }
-  const inputProcessorIdents = [];
-  for (let p = 0; p < agent.inputProcessors.length; p++) {
-    const proc = agent.inputProcessors[p];
-    const ident = sanitizeIdentifier(`${agent.name}_inputProc_${proc.key}`, "proc", `${idPath}_ip${p}`);
-    lines.push(`import ${ident} from ${JSON.stringify(proc.path)};`);
-    inputProcessorIdents.push(ident);
-  }
-  const outputProcessorIdents = [];
-  for (let p = 0; p < agent.outputProcessors.length; p++) {
-    const proc = agent.outputProcessors[p];
-    const ident = sanitizeIdentifier(`${agent.name}_outputProc_${proc.key}`, "proc", `${idPath}_op${p}`);
-    lines.push(`import ${ident} from ${JSON.stringify(proc.path)};`);
-    outputProcessorIdents.push(ident);
-  }
-  const scorerIdents = [];
-  for (let s = 0; s < agent.scorers.length; s++) {
-    const scorer = agent.scorers[s];
-    const ident = sanitizeIdentifier(`${agent.name}_scorer_${scorer.key}`, "scorer", `${idPath}_${s}`);
-    lines.push(`import ${ident} from ${JSON.stringify(scorer.path)};`);
-    scorerIdents.push({ key: scorer.key, ident });
-  }
-  const skillExprs = [];
-  const agentSkills = agent.skills ?? [];
-  for (let s = 0; s < agentSkills.length; s++) {
-    const skill = agentSkills[s];
-    if (skill.kind === "module") {
-      const ident = sanitizeIdentifier(`${agent.name}_skill`, "skill", `${idPath}_${s}`);
-      lines.push(`import ${ident} from ${JSON.stringify(skill.path)};`);
-      skillExprs.push(ident);
-    } else {
-      const referenceFields = Object.entries(skill.references).map(
-        ([key, value]) => `${JSON.stringify(key)}: ${JSON.stringify(value)}`
-      );
-      const skillFields = [
-        `name: ${JSON.stringify(skill.name)}`,
-        `description: ${JSON.stringify(skill.description)}`,
-        `instructions: ${JSON.stringify(skill.instructions)}`
-      ];
-      if (referenceFields.length > 0) {
-        skillFields.push(`references: { ${referenceFields.join(", ")} }`);
-      }
-      skillExprs.push(`__createSkill({ ${skillFields.join(", ")} })`);
-    }
-  }
-  let instructionsMd;
-  if (agent.instructionsPath) {
-    instructionsMd = await promises.readFile(agent.instructionsPath, "utf-8");
-  }
-  const subagentExprs = [];
-  for (let c = 0; c < agent.subagents.length; c++) {
-    const child = agent.subagents[c];
-    const childExpr = await emitAgentEntry(child, `${idPath}_${c}`, `${workspaceName}/${child.name}`, lines);
-    subagentExprs.push(childExpr);
-  }
-  const entryFields = [`name: ${JSON.stringify(agent.name)}`];
-  if (agent.configPath) {
-    entryFields.push(`config: ${configIdent}`);
-  }
-  if (instructionsMd !== void 0) {
-    entryFields.push(`instructionsMd: ${JSON.stringify(instructionsMd)}`);
-  }
-  if (toolIdents.length > 0) {
-    const toolEntries = toolIdents.map(({ key, ident }) => `{ key: ${JSON.stringify(key)}, tool: ${ident} }`);
-    entryFields.push(`tools: [${toolEntries.join(", ")}]`);
-  }
-  if (skillExprs.length > 0) {
-    entryFields.push(`skills: [${skillExprs.join(", ")}]`);
-  }
-  if (inputProcessorIdents.length > 0) {
-    entryFields.push(`inputProcessors: [${inputProcessorIdents.join(", ")}]`);
-  }
-  if (outputProcessorIdents.length > 0) {
-    entryFields.push(`outputProcessors: [${outputProcessorIdents.join(", ")}]`);
-  }
-  if (scorerIdents.length > 0) {
-    const scorerEntries = scorerIdents.map(({ key, ident }) => `{ key: ${JSON.stringify(key)}, scorer: ${ident} }`);
-    entryFields.push(`scorers: [${scorerEntries.join(", ")}]`);
-  }
-  if (subagentExprs.length > 0) {
-    entryFields.push(`subagents: [${subagentExprs.join(", ")}]`);
-  }
-  if (workspaceIdent) {
-    entryFields.push(`workspace: ${workspaceIdent}`);
-  }
-  if (memoryIdent) {
-    entryFields.push(`memory: ${memoryIdent}`);
-  }
-  entryFields.push(`defaultWorkspaceBasePath: __workspaceBasePath(${JSON.stringify(workspaceName)})`);
-  return `{ ${entryFields.join(", ")} }`;
-}
-async function generateFsAgentsModule(userEntry, agents, options) {
-  const workflows = options?.workflows ?? [];
-  const storage = options?.storage;
-  const observability = options?.observability;
-  const logger = options?.logger;
-  const server = options?.server;
-  const studio = options?.studio;
-  const standalone = userEntry === void 0;
-  const lines = [];
-  const hasInlineSkills = (function check(list) {
-    return list.some((a) => (a.skills ?? []).some((s) => s.kind === "packaged") || check(a.subagents ?? []));
-  })(agents);
-  lines.push(`import { assembleAgentFromFsEntry } from '@mastra/core/agent';`);
-  if (hasInlineSkills) {
-    lines.push(`import { createSkill as __createSkill } from '@mastra/core/skills';`);
-  }
-  if (standalone) {
-    lines.push(`import { Mastra } from '@mastra/core';`);
-  }
-  lines.push(`import { fileURLToPath as __fileURLToPath } from 'node:url';`);
-  lines.push(`import { dirname as __dirname, join as __join } from 'node:path';`);
-  if (userEntry) {
-    lines.push(`import * as __userEntry from ${JSON.stringify(userEntry)};`);
-    lines.push(`export * from ${JSON.stringify(userEntry)};`);
-  }
-  lines.push(``);
-  lines.push(`const __bundleDir = __dirname(__fileURLToPath(import.meta.url));`);
-  lines.push(`const __workspaceBasePath = name => __join(__bundleDir, 'workspace', ...name.split('/'));`);
-  lines.push(``);
-  const singletonImports = [];
-  if (storage) {
-    singletonImports.push(`import __fsStorage from ${JSON.stringify(storage.path)};`);
-  }
-  if (observability) {
-    singletonImports.push(`import __fsObservability from ${JSON.stringify(observability.path)};`);
-  }
-  if (logger) {
-    singletonImports.push(`import __fsLogger from ${JSON.stringify(logger.path)};`);
-  }
-  if (server) {
-    singletonImports.push(`import __fsServer from ${JSON.stringify(server.path)};`);
-  }
-  if (studio) {
-    singletonImports.push(`import __fsStudio from ${JSON.stringify(studio.path)};`);
-  }
-  if (singletonImports.length > 0) {
-    lines.push(...singletonImports);
-    lines.push(``);
-  }
-  const wfCodegen = workflows.length > 0 ? generateFsWorkflowsCodegen(workflows) : void 0;
-  if (wfCodegen) {
-    for (const line of wfCodegen.importLines) {
-      lines.push(line);
-    }
-    lines.push(``);
-  }
-  const entryExprs = [];
-  for (let i = 0; i < agents.length; i++) {
-    const agent = agents[i];
-    const expr = await emitAgentEntry(agent, `${i}`, agent.name, lines);
-    entryExprs.push(expr);
-  }
-  if (standalone) {
-    lines.push(``);
-    lines.push(`const __mastra = new Mastra({});`);
-  } else {
-    lines.push(``);
-    lines.push(`const __mastra = __userEntry.mastra;`);
-  }
-  lines.push(``);
-  lines.push(`const __fsAgentEntries = [`);
-  for (const expr of entryExprs) {
-    lines.push(`  ${expr},`);
-  }
-  lines.push(`];`);
-  lines.push(``);
-  lines.push(`const __fsAgents = Object.create(null);`);
-  lines.push(`for (const __entry of __fsAgentEntries) {`);
-  lines.push(`  __fsAgents[__entry.name] = assembleAgentFromFsEntry(__entry, {`);
-  lines.push(`    onWarn: msg => __mastra?.getLogger?.()?.warn?.(msg) ?? console.warn(msg),`);
-  lines.push(`  });`);
-  lines.push(`}`);
-  lines.push(``);
-  if (logger) {
-    lines.push(`if (__mastra && typeof __mastra.__registerFsLogger === 'function') {`);
-    lines.push(`  __mastra.__registerFsLogger(__fsLogger);`);
-    lines.push(`}`);
-    lines.push(``);
-  }
-  if (storage) {
-    lines.push(`if (__mastra && typeof __mastra.__registerFsStorage === 'function') {`);
-    lines.push(`  __mastra.__registerFsStorage(__fsStorage);`);
-    lines.push(`}`);
-    lines.push(``);
-  }
-  if (observability) {
-    lines.push(`if (__mastra && typeof __mastra.__registerFsObservability === 'function') {`);
-    lines.push(`  __mastra.__registerFsObservability(__fsObservability);`);
-    lines.push(`}`);
-    lines.push(``);
-  }
-  if (server) {
-    lines.push(`if (__mastra && typeof __mastra.__registerFsServer === 'function') {`);
-    lines.push(`  __mastra.__registerFsServer(__fsServer);`);
-    lines.push(`}`);
-    lines.push(``);
-  }
-  if (studio) {
-    lines.push(`if (__mastra && typeof __mastra.__registerFsStudio === 'function') {`);
-    lines.push(`  __mastra.__registerFsStudio(__fsStudio);`);
-    lines.push(`}`);
-    lines.push(``);
-  }
-  lines.push(`if (__mastra && typeof __mastra.__registerFsAgents === 'function') {`);
-  lines.push(`  __mastra.__registerFsAgents(__fsAgents);`);
-  lines.push(`}`);
-  if (wfCodegen) {
-    lines.push(``);
-    for (const line of wfCodegen.registrationLines) {
-      lines.push(line);
-    }
-  }
-  lines.push(``);
-  lines.push(`export const mastra = __mastra;`);
-  return lines.join("\n");
-}
-function generateFsWorkflowsCodegen(workflows) {
-  const importLines = [];
-  const registrationLines = [];
-  for (let i = 0; i < workflows.length; i++) {
-    const wf = workflows[i];
-    const ident = sanitizeIdentifier(wf.key, "workflow", `${i}`);
-    importLines.push(`import ${ident} from ${JSON.stringify(wf.path)};`);
-  }
-  registrationLines.push(`const __fsWorkflows = Object.create(null);`);
-  for (let i = 0; i < workflows.length; i++) {
-    const wf = workflows[i];
-    const ident = sanitizeIdentifier(wf.key, "workflow", `${i}`);
-    registrationLines.push(`__fsWorkflows[${JSON.stringify(wf.key)}] = ${ident};`);
-  }
-  registrationLines.push(``);
-  registrationLines.push(`if (__mastra && typeof __mastra.__registerFsWorkflows === 'function') {`);
-  registrationLines.push(`  __mastra.__registerFsWorkflows(__fsWorkflows);`);
-  registrationLines.push(`}`);
-  return { importLines, registrationLines };
-}
-async function prepareFsAgentsEntry(mastraDir, entryFile, outputDirectory) {
-  const [agents, workflows, storage, observability, logger, server, studio] = await Promise.all([
-    discoverFsAgents(mastraDir),
-    discoverFsWorkflows(mastraDir),
-    discoverFsSingleton(mastraDir, "storage"),
-    discoverFsSingleton(mastraDir, "observability"),
-    discoverFsSingleton(mastraDir, "logger"),
-    discoverFsSingleton(mastraDir, "server"),
-    discoverFsSingleton(mastraDir, "studio")
-  ]);
-  const standalone = entryFile === void 0;
-  const hasFsPrimitives = agents.length > 0 || workflows.length > 0 || !!storage || !!observability || !!logger || !!server || !!studio;
-  if (!hasFsPrimitives && entryFile !== void 0) {
-    return {
-      entryFile,
-      standalone: false,
-      toolPaths: [],
-      agentCount: 0,
-      workflowCount: 0,
-      hasStorage: false,
-      hasObservability: false,
-      hasLogger: false,
-      hasServer: false,
-      hasStudio: false
-    };
-  }
-  if (!hasFsPrimitives && standalone) {
-    throw new Error(
-      "No index.ts and no file-based primitives found. Create src/mastra/index.ts with a Mastra instance, or add file-based agents/workflows/storage."
-    );
-  }
-  const moduleSource = await generateFsAgentsModule(entryFile ? chunkJZRFRUGM_cjs.slash(entryFile) : void 0, agents, {
-    workflows,
-    storage,
-    observability,
-    logger,
-    server,
-    studio
-  });
-  const generatedEntry = path.join(outputDirectory, ".mastra-fs-agents-entry.mjs");
-  const normalizedMastraDir = chunkJZRFRUGM_cjs.slash(mastraDir);
-  const toolPaths = agents.length > 0 ? [
-    path.posix.join(normalizedMastraDir, "agents/*/tools/**/*.{js,ts}"),
-    `!${path.posix.join(normalizedMastraDir, "agents/*/tools/**/*.{test,spec}.{js,ts}")}`,
-    `!${path.posix.join(normalizedMastraDir, "agents/*/tools/**/__tests__/**")}`
-  ] : [];
-  return {
-    entryFile: generatedEntry,
-    standalone,
-    toolPaths,
-    agentCount: agents.length,
-    workflowCount: workflows.length,
-    hasStorage: !!storage,
-    hasObservability: !!observability,
-    hasLogger: !!logger,
-    hasServer: !!server,
-    hasStudio: !!studio,
-    moduleSource
-  };
-}
-async function writeFsAgentsEntry(result) {
-  if (!result.moduleSource) {
-    return;
-  }
-  await promises.mkdir(path.dirname(result.entryFile), { recursive: true });
-  await promises.writeFile(result.entryFile, result.moduleSource, "utf-8");
-}
-async function rejectSymlinks(source) {
-  const stats = await promises.lstat(source);
-  return !stats.isSymbolicLink();
-}
-async function mirrorAgentSeeds(agent, workspaceName, bundleDir, mirrored) {
-  if (agent.workspaceSeedDir) {
-    const destination = path.join(bundleDir, "workspace", ...workspaceName.split("/"));
-    await promises.mkdir(destination, { recursive: true });
-    await promises.cp(agent.workspaceSeedDir, destination, { recursive: true, filter: rejectSymlinks });
-    mirrored.push(workspaceName);
-  }
-  for (const child of agent.subagents ?? []) {
-    await mirrorAgentSeeds(child, `${workspaceName}/${child.name}`, bundleDir, mirrored);
-  }
-}
-async function mirrorFsAgentWorkspaces(mastraDir, bundleDir) {
-  const agents = await discoverFsAgents(mastraDir);
-  const mirrored = [];
-  for (const agent of agents) {
-    await mirrorAgentSeeds(agent, agent.name, bundleDir, mirrored);
-  }
-  return mirrored;
-}
-
-exports.analyzeEntryProjectType = analyzeEntryProjectType;
-exports.createWatcher = createWatcher;
-exports.discoverFsAgents = discoverFsAgents;
-exports.discoverFsSingleton = discoverFsSingleton;
-exports.discoverFsWorkflows = discoverFsWorkflows;
-exports.generateFsAgentsModule = generateFsAgentsModule;
-exports.generateFsWorkflowsCodegen = generateFsWorkflowsCodegen;
-exports.getInputOptions = getInputOptions2;
-exports.getServerOptions = getServerOptions;
-exports.mirrorFsAgentWorkspaces = mirrorFsAgentWorkspaces;
-exports.prepareFsAgentsEntry = prepareFsAgentsEntry;
-exports.writeFsAgentsEntry = writeFsAgentsEntry;
-//# sourceMappingURL=chunk-YO5OFXPN.cjs.map
-//# sourceMappingURL=chunk-YO5OFXPN.cjs.map