@mastra/editor 0.9.1-alpha.1 → 0.10.0-alpha.3

package/dist/index.js

@@ -518,6 +518,36 @@ var EditorMCPNamespace = class _EditorMCPNamespace extends CrudEditorNamespace {
 };
 
 // src/namespaces/agent.ts
+var BUILDER_DEFAULT_FIELDS = ["memory", "workspace", "browser"];
+function defaultModelToStored(entry) {
+  return { provider: entry.provider, name: entry.modelId };
+}
+var BUILDER_BASELINE_DEFAULTS = {
+  memory: { observationalMemory: true }
+};
+function applyBuilderDefaults(input, builderAgentConfig) {
+  const defaults = {};
+  for (const field of BUILDER_DEFAULT_FIELDS) {
+    if (input[field] !== void 0) continue;
+    const adminValue = builderAgentConfig?.[field];
+    if (adminValue !== void 0) {
+      defaults[field] = adminValue;
+      continue;
+    }
+    const baseline = BUILDER_BASELINE_DEFAULTS[field];
+    if (baseline !== void 0) {
+      defaults[field] = baseline;
+    }
+  }
+  if (input.model === void 0 && builderAgentConfig) {
+    const models = builderAgentConfig.models ?? void 0;
+    const adminDefault = models?.default;
+    if (adminDefault && typeof adminDefault.provider === "string" && typeof adminDefault.modelId === "string") {
+      defaults.model = defaultModelToStored(adminDefault);
+    }
+  }
+  return Object.keys(defaults).length > 0 ? { ...input, ...defaults } : input;
+}
 var EditorAgentNamespace = class extends CrudEditorNamespace {
   async getStorageAdapter() {
     const storage = this.mastra?.getStorage();
@@ -560,6 +590,67 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
   async hydrate(storedAgent) {
     return this.createAgentFromStoredConfig(storedAgent);
   }
+  /**
+   * Create a new agent, applying builder defaults for fields not specified in input.
+   * Also ensures the referenced workspace (if any) is persisted as a stored workspace.
+   */
+  async create(input) {
+    let finalInput = input;
+    if (this.editor.hasEnabledBuilderConfig()) {
+      const builder = await this.editor.resolveBuilder();
+      const agentConfig = builder?.getConfiguration()?.agent;
+      finalInput = applyBuilderDefaults(input, agentConfig);
+    }
+    await this.ensureStoredWorkspace(finalInput.workspace);
+    return super.create(finalInput);
+  }
+  /**
+   * Ensure a workspace reference is persisted in the DB.
+   *
+   * For `type: 'id'`: looks up the runtime workspace, serializes its config,
+   * and creates a stored workspace record if one doesn't already exist.
+   *
+   * For `type: 'inline'`: derives a deterministic ID from the config and
+   * persists it as a stored workspace if one doesn't already exist.
+   */
+  async ensureStoredWorkspace(workspaceRef) {
+    if (!workspaceRef) return;
+    const workspaceNs = this.editor.workspace;
+    if (!workspaceNs) return;
+    try {
+      if (workspaceRef.type === "id") {
+        const existing = await workspaceNs.getById(workspaceRef.workspaceId);
+        if (existing) return;
+        const runtimeWorkspace = this.mastra?.getWorkspaceById(workspaceRef.workspaceId);
+        if (!runtimeWorkspace) {
+          this.logger?.warn(
+            `[ensureStoredWorkspace] Workspace '${workspaceRef.workspaceId}' not found in runtime registry, cannot persist`
+          );
+          return;
+        }
+        const snapshot = await workspaceNs.snapshotFromWorkspace(runtimeWorkspace);
+        await workspaceNs.create({
+          id: workspaceRef.workspaceId,
+          metadata: { source: "builder", builderWorkspaceId: workspaceRef.workspaceId },
+          ...snapshot
+        });
+        this.logger?.debug(`[ensureStoredWorkspace] Persisted runtime workspace '${workspaceRef.workspaceId}' to DB`);
+      } else if (workspaceRef.type === "inline") {
+        const configHash = createHash("sha256").update(JSON.stringify(workspaceRef.config)).digest("hex").slice(0, 12);
+        const workspaceId = `inline-${configHash}`;
+        const existing = await workspaceNs.getById(workspaceId);
+        if (existing) return;
+        await workspaceNs.create({
+          id: workspaceId,
+          metadata: { source: "builder", builderConfigHash: configHash },
+          ...workspaceRef.config
+        });
+        this.logger?.debug(`[ensureStoredWorkspace] Persisted inline workspace '${workspaceId}' to DB`);
+      }
+    } catch (error) {
+      this.logger?.warn("[ensureStoredWorkspace] Failed to persist workspace", { error });
+    }
+  }
   onCacheEvict(id) {
     try {
       const existing = this.mastra?.getAgentById(id);
@@ -749,6 +840,7 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     const hasConditionalDefaultOptions = storedAgent.defaultOptions != null && this.isConditionalVariants(storedAgent.defaultOptions);
     const hasConditionalModel = this.isConditionalVariants(storedAgent.model);
     const hasConditionalWorkspace = storedAgent.workspace != null && this.isConditionalVariants(storedAgent.workspace);
+    const hasConditionalBrowser = storedAgent.browser != null && this.isConditionalVariants(storedAgent.browser);
     const hasIntegrationTools = storedAgent.integrationTools != null;
     const isDynamicTools = hasConditionalTools || hasConditionalMCPClients || hasConditionalIntegrationTools || hasIntegrationTools;
     let tools;
@@ -915,6 +1007,14 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
       );
       return this.resolveStoredWorkspace(resolvedRef, skillSource);
     } : await this.resolveStoredWorkspace(storedAgent.workspace, skillSource);
+    const browser = hasConditionalBrowser ? async ({ requestContext }) => {
+      const ctx = requestContext.toJSON();
+      const resolvedRef = this.accumulateObjectVariants(
+        storedAgent.browser,
+        ctx
+      );
+      return this.resolveStoredBrowser(resolvedRef);
+    } : await this.resolveStoredBrowser(storedAgent.browser);
     const skillsFormat = storedAgent.skillsFormat;
     const agent = new Agent({
       id: storedAgent.id,
@@ -935,6 +1035,7 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
       defaultOptions,
       requestContextSchema,
       workspace,
+      browser,
       ...skillsFormat && { skillsFormat }
     });
     const existingCodeAgent = (() => {
@@ -1333,7 +1434,8 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
       scorers: storedScorers,
       defaultOptions: storageDefaultOptions,
       metadata: resolvedMetadata,
-      authorId: options.authorId
+      authorId: options.authorId,
+      visibility: options.visibility
     };
     const adapter = await this.getStorageAdapter();
     await adapter.create(createInput);
@@ -1365,13 +1467,23 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     const hydrateOptions = skillSource ? { skillSource } : void 0;
     if (workspaceRef.type === "id") {
       const resolved = await workspaceNs.getById(workspaceRef.workspaceId);
-      if (!resolved) {
-        this.logger?.warn(
-          `[resolveStoredWorkspace] Workspace '${workspaceRef.workspaceId}' not found in storage, skipping`
-        );
-        return void 0;
+      if (resolved) {
+        return workspaceNs.hydrateSnapshotToWorkspace(workspaceRef.workspaceId, resolved, hydrateOptions);
+      }
+      try {
+        const runtimeWorkspace = this.mastra?.getWorkspaceById(workspaceRef.workspaceId);
+        if (runtimeWorkspace) {
+          this.logger?.debug(
+            `[resolveStoredWorkspace] Workspace '${workspaceRef.workspaceId}' found in runtime registry (not in DB)`
+          );
+          return runtimeWorkspace;
+        }
+      } catch {
       }
-      return workspaceNs.hydrateSnapshotToWorkspace(workspaceRef.workspaceId, resolved, hydrateOptions);
+      this.logger?.warn(
+        `[resolveStoredWorkspace] Workspace '${workspaceRef.workspaceId}' not found in storage or runtime registry, skipping`
+      );
+      return void 0;
     }
     if (workspaceRef.type === "inline") {
       const configHash = createHash("sha256").update(JSON.stringify(workspaceRef.config)).digest("hex").slice(0, 12);
@@ -1379,6 +1491,26 @@ var EditorAgentNamespace = class extends CrudEditorNamespace {
     }
     return void 0;
   }
+  /**
+   * Resolve a stored browser config to a runtime MastraBrowser instance.
+   * Looks up the provider by ID in the editor's browser registry.
+   * Only supports `type: 'inline'` refs (config is embedded in the agent snapshot).
+   */
+  async resolveStoredBrowser(browserRef) {
+    if (!browserRef) return void 0;
+    if (browserRef.type === "inline") {
+      const { provider: providerId, ...config } = browserRef.config;
+      const browserProvider = this.editor.__browsers.get(providerId);
+      if (!browserProvider) {
+        this.logger?.warn(
+          `[resolveStoredBrowser] Browser provider "${providerId}" is not registered. Register it via new MastraEditor({ browsers: { '${providerId}': yourProvider } })`
+        );
+        return void 0;
+      }
+      return await browserProvider.createBrowser(config);
+    }
+    return void 0;
+  }
   /**
    * Resolve agent-level skill configurations into a CompositeVersionedSkillSource.
    *
@@ -2014,9 +2146,35 @@ var localSandboxProvider = {
   createSandbox: (config) => new LocalSandbox(config)
 };
 
+// src/snapshots-match.ts
+function snapshotsMatch(stored, runtime) {
+  const keys = [
+    "name",
+    "description",
+    "filesystem",
+    "sandbox",
+    "mounts",
+    "search",
+    "skills",
+    "tools",
+    "autoSync",
+    "operationTimeout"
+  ];
+  const replacer = (_k, v) => v === false || v === null || v === 0 ? void 0 : v;
+  for (const key of keys) {
+    const storedVal = stored[key];
+    const runtimeVal = runtime[key];
+    const storedJSON = storedVal == null || storedVal === false ? void 0 : JSON.stringify(storedVal, replacer);
+    const runtimeJSON = runtimeVal == null || runtimeVal === false ? void 0 : JSON.stringify(runtimeVal, replacer);
+    if (storedJSON !== runtimeJSON) return false;
+  }
+  return true;
+}
+
 // src/index.ts
 var MastraEditor = class {
   constructor(config) {
+    this.__builderResolved = false;
     this.__logger = config?.logger;
     this.__toolProviders = config?.toolProviders ?? {};
     this.__processorProviders = { ...BUILT_IN_PROCESSOR_PROVIDERS, ...config?.processorProviders };
@@ -2034,6 +2192,10 @@ var MastraEditor = class {
     for (const [id, provider] of Object.entries(config?.blobStores ?? {})) {
       this.__blobStores.set(id, provider);
     }
+    this.__browsers = /* @__PURE__ */ new Map();
+    for (const [id, provider] of Object.entries(config?.browsers ?? {})) {
+      this.__browsers.set(id, provider);
+    }
     this.agent = new EditorAgentNamespace(this);
     this.mcp = new EditorMCPNamespace(this);
     this.mcpServer = new EditorMCPServerNamespace(this);
@@ -2042,6 +2204,7 @@ var MastraEditor = class {
     this.workspace = new EditorWorkspaceNamespace(this);
     this.skill = new EditorSkillNamespace(this);
     this.favorites = new EditorFavoritesNamespace(this);
+    this.__builderConfig = config?.builder;
   }
   /**
    * Register this editor with a Mastra instance.
@@ -2052,11 +2215,171 @@ var MastraEditor = class {
     if (!this.__logger) {
       this.__logger = mastra.getLogger();
     }
+    this.ensureBuilderWorkspaces().then(() => this.reconcileBuilderWorkspaces()).catch((err) => {
+      this.__logger?.warn("[MastraEditor] Failed to persist/reconcile builder workspaces on startup", {
+        error: err
+      });
+    });
+  }
+  /**
+   * Ensure the builder default workspace is persisted to the DB.
+   * Called automatically on startup when the editor registers with Mastra.
+   * Goes through the normal create() path so hydration validates that
+   * all providers (filesystem, sandbox) are properly registered.
+   *
+   * If the workspace already exists but its config has drifted from the
+   * runtime workspace, the DB record is updated (creating a new version).
+   * Builder-created workspaces are tagged with `metadata.source = 'builder'`
+   * so they can be identified during reconciliation.
+   */
+  async ensureBuilderWorkspaces() {
+    if (!this.hasEnabledBuilderConfig()) return;
+    const builder = await this.resolveBuilder();
+    const agentConfig = builder?.getConfiguration()?.agent;
+    const workspaceRef = agentConfig?.workspace;
+    if (!workspaceRef || workspaceRef.type !== "id" || !workspaceRef.workspaceId) return;
+    const runtimeWorkspace = this.__mastra?.getWorkspaceById(workspaceRef.workspaceId);
+    if (!runtimeWorkspace) return;
+    const snapshot = await this.workspace.snapshotFromWorkspace(runtimeWorkspace);
+    const builderMetadata = { source: "builder", builderWorkspaceId: workspaceRef.workspaceId };
+    const existing = await this.workspace.getById(workspaceRef.workspaceId);
+    if (!existing) {
+      await this.workspace.create({
+        id: workspaceRef.workspaceId,
+        metadata: builderMetadata,
+        ...snapshot
+      });
+      this.__logger?.info(`[MastraEditor] Persisted builder workspace '${workspaceRef.workspaceId}' to DB`);
+      return;
+    }
+    const needsMetadataBackfill = !existing.metadata?.source;
+    const configDrifted = !snapshotsMatch(existing, snapshot);
+    if (needsMetadataBackfill || configDrifted) {
+      const updateInput = { id: workspaceRef.workspaceId };
+      if (needsMetadataBackfill) {
+        updateInput.metadata = { ...existing.metadata, ...builderMetadata };
+      }
+      if (configDrifted) {
+        Object.assign(updateInput, snapshot);
+        this.__logger?.info(
+          `[MastraEditor] Workspace '${workspaceRef.workspaceId}' config drifted \u2014 updating DB record`
+        );
+      }
+      await this.workspace.update(updateInput);
+    }
+  }
+  /**
+   * Archive builder-created workspaces that no longer match the current
+   * builder configuration. Called after `ensureBuilderWorkspaces()` on startup.
+   *
+   * Only touches workspaces tagged with `metadata.source === 'builder'`.
+   * The current builder workspace (if any) is never archived.
+   */
+  async reconcileBuilderWorkspaces() {
+    if (!this.hasEnabledBuilderConfig()) return;
+    const builder = await this.resolveBuilder();
+    const agentConfig = builder?.getConfiguration()?.agent;
+    const workspaceRef = agentConfig?.workspace;
+    let currentWorkspaceId;
+    if (workspaceRef?.type === "id" && workspaceRef.workspaceId) {
+      currentWorkspaceId = workspaceRef.workspaceId;
+    }
+    if (!currentWorkspaceId) return;
+    const { workspaces: allWorkspaces } = await this.workspace.listResolved({
+      perPage: false,
+      // fetch all
+      metadata: { source: "builder" }
+    });
+    for (const ws of allWorkspaces) {
+      if (ws.id === currentWorkspaceId) continue;
+      if (ws.status === "archived") continue;
+      try {
+        await this.workspace.update({ id: ws.id, status: "archived" });
+        this.__logger?.info(`[MastraEditor] Archived orphaned builder workspace '${ws.id}'`);
+      } catch (err) {
+        this.__logger?.warn(`[MastraEditor] Failed to archive workspace '${ws.id}'`, { error: err });
+      }
+    }
+  }
+  /**
+   * Sync. OSS-safe. Does NOT import @mastra/editor/ee.
+   * Returns true if builder config is present and enabled.
+   */
+  hasEnabledBuilderConfig() {
+    if (!this.__builderConfig) return false;
+    return this.__builderConfig.enabled !== false;
+  }
+  /**
+   * Async. Dynamic-imports @mastra/editor/ee on first call. Caches result.
+   * Returns undefined if builder is not enabled.
+   */
+  async resolveBuilder() {
+    if (this.__builderResolved) {
+      return this.__builderInstance;
+    }
+    if (!this.hasEnabledBuilderConfig()) {
+      this.__builderResolved = true;
+      return void 0;
+    }
+    await this.assertAgentBuilderLicensed();
+    const { EditorAgentBuilder } = await import("./ee/index.js");
+    this.__builderInstance = new EditorAgentBuilder(this.__builderConfig);
+    const browserRef = this.__builderInstance.getConfiguration()?.agent?.browser;
+    const browserFeatureOn = this.__builderInstance.getFeatures()?.agent?.browser === true;
+    if (browserFeatureOn && browserRef?.config?.provider) {
+      const providerId = browserRef.config.provider;
+      if (!this.__browsers.has(providerId)) {
+        const warning = `Agent Builder browser config references provider "${providerId}" but no matching browser provider is registered in \`editor.browsers\`. The browser toggle will be hidden. Register the provider: \`new MastraEditor({ browsers: { "${providerId}": yourProvider } })\`.`;
+        console.warn(`[mastra:editor] ${warning}`);
+        const features = this.__builderInstance.getFeatures()?.agent;
+        if (features) {
+          features.browser = false;
+        }
+      }
+    }
+    this.__builderResolved = true;
+    return this.__builderInstance;
+  }
+  /**
+   * Defense-in-depth license guard for the Agent Builder. Mirrors the
+   * startup-time check in `MastraServer.validateAgentBuilderLicense()` so the
+   * builder cannot be instantiated outside the server boot path without a
+   * valid EE license. Dev environments bypass via `isEEEnabled()`.
+   */
+  async assertAgentBuilderLicensed() {
+    try {
+      const { isEEEnabled } = await import("@mastra/core/auth/ee");
+      if (!isEEEnabled()) {
+        throw new Error(
+          "[mastra/auth-ee] Agent Builder is configured but no valid EE license was found.\nAgent Builder requires a Mastra Enterprise License for production use.\nSet the MASTRA_EE_LICENSE environment variable with your license key.\nLearn more: https://github.com/mastra-ai/mastra/blob/main/ee/LICENSE"
+        );
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.startsWith("[mastra/auth-ee]")) {
+        throw err;
+      }
+      throw new Error(
+        "[mastra/auth-ee] Agent Builder is configured but the EE module (@mastra/core/auth/ee) could not be loaded.\nEnsure @mastra/core is updated to a version that includes EE support."
+      );
+    }
   }
   /** Registered tool providers */
   getToolProvider(id) {
     return this.__toolProviders[id];
   }
+  /**
+   * Like {@link getToolProvider}, but throws {@link UnknownToolProviderError}
+   * when the id is unknown.
+   */
+  getToolProviderOrThrow(id) {
+    const provider = this.__toolProviders[id];
+    if (!provider) {
+      throw new Error(
+        `Unknown tool provider "${id}". Available: ${Object.keys(this.__toolProviders).join(", ") || "(none)"}`
+      );
+    }
+    return provider;
+  }
   /** List all registered tool providers */
   getToolProviders() {
     return this.__toolProviders;
@@ -2128,3 +2451,4 @@ export {
   renderTemplate,
   resolveInstructionBlocks
 };
+//# sourceMappingURL=index.js.map