@mastra/deployer 1.48.0-alpha.6 → 1.48.0-alpha.8

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # @mastra/deployer
 
+## 1.48.0-alpha.8
+
+### Patch Changes
+
+- Updated dependencies [[`0ac14ce`](https://github.com/mastra-ai/mastra/commit/0ac14cea48e1b0a7857782153c78f7242fdf7e1a), [`c2f0b7f`](https://github.com/mastra-ai/mastra/commit/c2f0b7f1370f4428d165f51f0d1d9a48331cc257)]:
+  - @mastra/core@1.48.0-alpha.8
+  - @mastra/server@1.48.0-alpha.8
+
+## 1.48.0-alpha.7
+
+### Minor Changes
+
+- You can now define agents by file convention instead of registering each one in code: drop a directory under `src/mastra/agents/<name>/`, run a Mastra build/dev, and the agent is bundled and registered onto your Mastra instance automatically. A directory becomes an agent when it has a `config.ts` or `instructions.md`; `tools/*.ts` add tools, `skills/` add skills (a `createSkill()` module, a packaged `SKILL.md` with its `references/`, or a flat `<skill>.md`), and `subagents/<childId>/` (one level deep) add delegatable subagents. Each agent gets a default workspace unless `workspace.ts` / `config.workspace` overrides it, and files committed under `agents/<name>/workspace/` are mirrored into the bundle to seed that workspace at runtime. Projects with no file-based agents are unaffected — the original entry is used unchanged. ([#18609](https://github.com/mastra-ai/mastra/pull/18609))
+
+  ```text
+  src/mastra/agents/weather/
+    config.ts          # export default agentConfig({ model: 'openai/gpt-4o' })
+    instructions.md
+    tools/get_weather.ts
+    workspace/cities.json   # mirrored into the agent's workspace
+  ```
+
+### Patch Changes
+
+- Fix `ENOENT: .mastra-fs-agents-entry.mjs` when running `mastra dev`/`mastra build` in a project that uses file-based agents. The generated fs-agents wrapper entry was written before `bundler.prepare()` emptied the output directory, so it was wiped before the bundler could read it. Wrapper generation is now split: `prepareFsAgentsEntry` returns the generated source without writing, and the new `writeFsAgentsEntry` writes it after `prepare()` runs. ([#18694](https://github.com/mastra-ai/mastra/pull/18694))
+
+  ```ts
+  const fsAgents = await prepareFsAgentsEntry({ entryFile, mastraDir, outputDirectory });
+  await bundler.prepare(outputDirectory); // empties output dir
+  await writeFsAgentsEntry(fsAgents); // wrapper now survives for the bundler
+  ```
+
+- Updated dependencies [[`8be63b0`](https://github.com/mastra-ai/mastra/commit/8be63b015fb8d72cea1220f05e7dc3bb997cc249), [`ee14cae`](https://github.com/mastra-ai/mastra/commit/ee14cae244805783bde518a6142de28b744b169c), [`345eecc`](https://github.com/mastra-ai/mastra/commit/345eecce6ba519b5d987f0e10b5de4c8e5734580), [`ee14cae`](https://github.com/mastra-ai/mastra/commit/ee14cae244805783bde518a6142de28b744b169c)]:
+  - @mastra/core@1.48.0-alpha.7
+  - @mastra/server@1.48.0-alpha.7
+
 ## 1.48.0-alpha.6
 
 ### Patch Changes

package/dist/build/fs-routing/codegen.d.ts

@@ -0,0 +1,22 @@
+import type { DiscoveredFsAgent } from './discover.js';
+/**
+ * Generate the source of a wrapper module that:
+ * 1. imports the user's real Mastra entry,
+ * 2. imports each discovered `config.ts`, `tools/*.ts`, `skills/*.ts`
+ *    (`createSkill(...)` modules), `workspace.ts`, and `memory.ts`, inlining
+ *    packaged `SKILL.md` skills,
+ * 3. assembles `Agent` instances via `assembleAgentFromFsEntry`, wiring any
+ *    declared `subagents/` into the parent (one level deep),
+ * 4. registers them onto the user's `mastra` instance (code-registered agents
+ *    win on name collisions), and
+ * 5. re-exports everything from the user's entry so this module is a drop-in
+ *    replacement for the original `#mastra` target.
+ *
+ * `instructions.md` contents are inlined at codegen time so no markdown loader
+ * plugin is required in the bundler graph.
+ *
+ * @param userEntry slash-normalized absolute path to the user's mastra entry.
+ * @param agents discovered fs-routed agents (absolute, slash-normalized paths).
+ */
+export declare function generateFsAgentsModule(userEntry: string, agents: DiscoveredFsAgent[]): Promise<string>;
+//# sourceMappingURL=codegen.d.ts.map

package/dist/build/fs-routing/codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../../src/build/fs-routing/codegen.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA6HpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAoD5G"}

package/dist/build/fs-routing/discover.d.ts

@@ -0,0 +1,70 @@
+/**
+ * A file-system routed agent directory discovered under `<mastraDir>/agents/`.
+ * All paths are absolute and slash-normalized so they can be embedded into
+ * generated module source on any platform.
+ */
+export interface DiscoveredFsAgent {
+    /** Agent directory name. Used as the default `id`/`name`. */
+    name: string;
+    /** Absolute, slash-normalized path to the agent directory. */
+    dir: string;
+    /** Absolute path to `config.ts`/`config.js`, if present. */
+    configPath?: string;
+    /** Absolute path to `instructions.md`, if present. */
+    instructionsPath?: string;
+    /** Absolute path to `workspace.ts`/`workspace.js`, if present. */
+    workspacePath?: string;
+    /** Absolute path to `memory.ts`/`memory.js`, if present. */
+    memoryPath?: string;
+    /**
+     * Absolute, slash-normalized path to an authored `workspace/` directory of
+     * seed files, if present. These are mirrored into the deployed workspace at
+     * build time (Eve parity) so the agent starts with them on disk.
+     */
+    workspaceSeedDir?: string;
+    /** Tools discovered under `tools/`, in stable (sorted) order. */
+    tools: {
+        key: string;
+        path: string;
+    }[];
+    /** Skills discovered under `skills/`, in stable (sorted) order. */
+    skills: DiscoveredFsSkill[];
+    /**
+     * Declared subagents discovered under `subagents/`, in stable (sorted) order.
+     * Subagents are one level deep only: a discovered subagent never carries its
+     * own `subagents` (nested `subagents/` directories are ignored with a warning).
+     */
+    subagents: DiscoveredFsAgent[];
+}
+/**
+ * A skill discovered under `agents/<name>/skills/`.
+ *
+ * - `kind: 'module'` — a `.ts`/`.js` file whose default export is a `createSkill(...)`
+ *   result. Codegen imports it directly; `name`/`description`/`instructions` are
+ *   unknown at discovery time and resolved at runtime from the module.
+ * - `kind: 'packaged'` — a `SKILL.md` (optionally with a `references/` subdir) or a
+ *   flat `<skill>.md`. Codegen inlines it via `createSkill(...)` using the parsed
+ *   fields below so the deployed bundle carries no filesystem dependency.
+ */
+export type DiscoveredFsSkill = {
+    kind: 'module';
+    /** Absolute, slash-normalized path to the `.ts`/`.js` skill module. */
+    path: string;
+} | {
+    kind: 'packaged';
+    name: string;
+    description: string;
+    instructions: string;
+    /** Reference file contents keyed by relative path (from `references/`). */
+    references: Record<string, string>;
+};
+/**
+ * Scan `<mastraDir>/agents/*` for file-system routed agents. A directory is
+ * treated as an agent only when it contains a `config.(ts|js)` or an
+ * `instructions.md`; other directories are ignored. Each top-level agent may
+ * declare one level of `subagents/`. Returns descriptors with absolute,
+ * slash-normalized paths ready for codegen. Performs no module evaluation —
+ * only filesystem inspection.
+ */
+export declare function discoverFsAgents(mastraDir: string, onWarn?: (message: string) => void): Promise<DiscoveredFsAgent[]>;
+//# sourceMappingURL=discover.d.ts.map

package/dist/build/fs-routing/discover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover.d.ts","sourceRoot":"","sources":["../../../src/build/fs-routing/discover.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,GAAG,EAAE,MAAM,CAAC;IACZ,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kEAAkE;IAClE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iEAAiE;IACjE,KAAK,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACvC,mEAAmE;IACnE,MAAM,EAAE,iBAAiB,EAAE,CAAC;IAC5B;;;;OAIG;IACH,SAAS,EAAE,iBAAiB,EAAE,CAAC;CAChC;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GACzB;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;CACd,GACD;IACE,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,2EAA2E;IAC3E,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,CAAC;AA4RN;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GACjC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA0B9B"}

package/dist/build/fs-routing/mirror.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Mirror authored `agents/<name>/workspace/**` seed files into the bundled
+ * output so each fs-routed agent starts with them on disk (Eve parity). Files
+ * are copied to `<bundleDir>/workspace/<name>`, which is exactly where the
+ * generated entry roots each agent's default workspace at runtime (resolved
+ * relative to the bundled module via `import.meta.url`). Declared subagents
+ * mirror to the nested `<bundleDir>/workspace/<parent>/<child>` path.
+ *
+ * Must run AFTER the bundle step, since bundling recreates the output dir.
+ *
+ * @param mastraDir   The user's `src/mastra` directory (source of seeds).
+ * @param bundleDir   The final bundle directory (e.g. `<outputDirectory>/output`).
+ * @returns the workspace names whose seeds were mirrored (`<parent>/<child>` for subagents).
+ */
+export declare function mirrorFsAgentWorkspaces(mastraDir: string, bundleDir: string): Promise<string[]>;
+//# sourceMappingURL=mirror.d.ts.map

package/dist/build/fs-routing/mirror.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mirror.d.ts","sourceRoot":"","sources":["../../../src/build/fs-routing/mirror.ts"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,uBAAuB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CASrG"}

package/dist/build/fs-routing/prepare.d.ts

@@ -0,0 +1,44 @@
+export interface PrepareFsAgentsEntryResult {
+    /**
+     * The entry file that should be fed to the bundler/analyzer. When fs-routed
+     * agents are found this is a generated wrapper module that registers them onto
+     * the user's mastra instance; otherwise it is the original entry unchanged.
+     */
+    entryFile: string;
+    /**
+     * Glob tool paths for tools defined under `agents/*\/tools` so they are
+     * bundled alongside the top-level `tools/` directory.
+     */
+    toolPaths: string[];
+    /** Number of fs-routed agents discovered. */
+    agentCount: number;
+    /**
+     * Generated wrapper source to write to {@link entryFile}, or `undefined` when
+     * there are no fs-routed agents. The write is deferred so callers can run it
+     * *after* `bundler.prepare()` empties the output directory — otherwise the
+     * wrapper is wiped before the bundler reads it.
+     */
+    moduleSource?: string;
+}
+/**
+ * Discover fs-routed agents under `<mastraDir>/agents/*` and, if any exist,
+ * generate a wrapper entry module that registers them onto the user's mastra
+ * instance. Returns the entry the bundler should use plus extra tool glob paths
+ * so `agents/*\/tools` are bundled.
+ *
+ * This does NOT write the wrapper to disk; call {@link writeFsAgentsEntry} with
+ * the result after `bundler.prepare()` so the generated file is not wiped when
+ * the output directory is emptied.
+ *
+ * When no fs-routed agents are present the original entry is returned unchanged,
+ * so existing code-only projects are completely unaffected.
+ */
+export declare function prepareFsAgentsEntry(mastraDir: string, entryFile: string, outputDirectory: string): Promise<PrepareFsAgentsEntryResult>;
+/**
+ * Write the generated fs-agents wrapper produced by {@link prepareFsAgentsEntry}
+ * to its `entryFile`. No-op when there are no fs-routed agents. Call this AFTER
+ * `bundler.prepare()` (which empties the output directory) so the wrapper
+ * survives for the bundler/watcher to read.
+ */
+export declare function writeFsAgentsEntry(result: PrepareFsAgentsEntryResult): Promise<void>;
+//# sourceMappingURL=prepare.d.ts.map

package/dist/build/fs-routing/prepare.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prepare.d.ts","sourceRoot":"","sources":["../../../src/build/fs-routing/prepare.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,0BAA0B;IACzC;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,6CAA6C;IAC7C,UAAU,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,0BAA0B,CAAC,CAkBrC;AAED;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,0BAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAO1F"}

package/dist/build/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkY476PH5A_cjs = require('../chunk-Y476PH5A.cjs');
+var chunkIYKMQHY2_cjs = require('../chunk-IYKMQHY2.cjs');
 var chunkVZYB4EVX_cjs = require('../chunk-VZYB4EVX.cjs');
 var chunk47KJ3RKB_cjs = require('../chunk-47KJ3RKB.cjs');
 var chunkFBL7GBNM_cjs = require('../chunk-FBL7GBNM.cjs');
@@ -11,15 +11,35 @@ var chunk7PMC7SBC_cjs = require('../chunk-7PMC7SBC.cjs');
 
 Object.defineProperty(exports, "createWatcher", {
   enumerable: true,
-  get: function () { return chunkY476PH5A_cjs.createWatcher; }
+  get: function () { return chunkIYKMQHY2_cjs.createWatcher; }
+});
+Object.defineProperty(exports, "discoverFsAgents", {
+  enumerable: true,
+  get: function () { return chunkIYKMQHY2_cjs.discoverFsAgents; }
+});
+Object.defineProperty(exports, "generateFsAgentsModule", {
+  enumerable: true,
+  get: function () { return chunkIYKMQHY2_cjs.generateFsAgentsModule; }
 });
 Object.defineProperty(exports, "getServerOptions", {
   enumerable: true,
-  get: function () { return chunkY476PH5A_cjs.getServerOptions; }
+  get: function () { return chunkIYKMQHY2_cjs.getServerOptions; }
 });
 Object.defineProperty(exports, "getWatcherInputOptions", {
   enumerable: true,
-  get: function () { return chunkY476PH5A_cjs.getInputOptions; }
+  get: function () { return chunkIYKMQHY2_cjs.getInputOptions; }
+});
+Object.defineProperty(exports, "mirrorFsAgentWorkspaces", {
+  enumerable: true,
+  get: function () { return chunkIYKMQHY2_cjs.mirrorFsAgentWorkspaces; }
+});
+Object.defineProperty(exports, "prepareFsAgentsEntry", {
+  enumerable: true,
+  get: function () { return chunkIYKMQHY2_cjs.prepareFsAgentsEntry; }
+});
+Object.defineProperty(exports, "writeFsAgentsEntry", {
+  enumerable: true,
+  get: function () { return chunkIYKMQHY2_cjs.writeFsAgentsEntry; }
 });
 Object.defineProperty(exports, "getBundlerOptions", {
   enumerable: true,

package/dist/build/index.d.ts

@@ -7,4 +7,10 @@ export { getServerOptions } from './serverOptions.js';
 export { getBundlerOptions } from './bundlerOptions.js';
 export { normalizeStudioBase, detectRuntime, injectStudioHtmlConfig } from './utils.js';
 export type { RuntimePlatform, BundlerPlatform, StudioInjectionConfig } from './utils.js';
+export { discoverFsAgents } from './fs-routing/discover.js';
+export type { DiscoveredFsAgent } from './fs-routing/discover.js';
+export { generateFsAgentsModule } from './fs-routing/codegen.js';
+export { prepareFsAgentsEntry, writeFsAgentsEntry } from './fs-routing/prepare.js';
+export type { PrepareFsAgentsEntryResult } from './fs-routing/prepare.js';
+export { mirrorFsAgentWorkspaces } from './fs-routing/mirror.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/build/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,eAAe,IAAI,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,eAAe,IAAI,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACrF,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/build/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,eAAe,IAAI,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,eAAe,IAAI,sBAAsB,EAAE,MAAM,WAAW,CAAC;AACrF,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,kBAAkB,CAAC;AACxC,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,mBAAmB,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AACrF,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AACvF,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAChF,YAAY,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AACvE,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/build/index.js

@@ -1,4 +1,4 @@
-export { createWatcher, getServerOptions, getInputOptions as getWatcherInputOptions } from '../chunk-EVWJBGLA.js';
+export { createWatcher, discoverFsAgents, generateFsAgentsModule, getServerOptions, getInputOptions as getWatcherInputOptions, mirrorFsAgentWorkspaces, prepareFsAgentsEntry, writeFsAgentsEntry } from '../chunk-TDNEF2M5.js';
 export { getBundlerOptions } from '../chunk-MPEFRVWJ.js';
 export { analyzeBundle } from '../chunk-FQC6UUHS.js';
 export { createBundler, getInputOptions as getBundlerInputOptions } from '../chunk-2WEUOK6I.js';