create-mastra 1.22.0 → 1.23.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # create-mastra
 
+## 1.23.0-alpha.1
+
+### Patch Changes
+
+- Fixed prerelease project creation to keep using the running create-mastra release channel when npm dist-tags have not finished updating. ([#20723](https://github.com/mastra-ai/mastra/pull/20723))
+
+## 1.22.1-alpha.0
+
 ## 1.22.0
 
 ### Patch Changes

package/dist/index.js

@@ -21619,69 +21619,52 @@ async function writeEmptyScaffold({ projectPath, projectName, versionTag, packag
 const MANAGED_PROVIDER_CONFIGS = {
   openai: {
     displayName: "OpenAI",
-    sdkPackage: "@ai-sdk/openai",
-    providerIdentifier: "openai",
-    apiKeyEnv: "OPENAI_API_KEY",
-    apiKeyPrerequisite: "An OpenAI API key",
-    featureDescription: "OpenAI web search and direct web page fetching"
+    apiKeyEnv: "OPENAI_API_KEY"
   },
   anthropic: {
     displayName: "Anthropic",
-    sdkPackage: "@ai-sdk/anthropic",
-    sdkVersion: "^3.0.96",
-    providerIdentifier: "anthropic",
     primaryModel: "anthropic/claude-sonnet-5",
     observationalModel: "anthropic/claude-haiku-4-5",
-    apiKeyEnv: "ANTHROPIC_API_KEY",
-    apiKeyPrerequisite: "An Anthropic API key",
-    featureDescription: "Anthropic web search and direct web page fetching",
-    webSearchEntry: "anthropic.tools.webSearch_20250305()"
+    apiKeyEnv: "ANTHROPIC_API_KEY"
   },
   google: {
     displayName: "Google Gemini",
-    sdkPackage: "@ai-sdk/google",
-    sdkVersion: "^3.0.91",
-    providerIdentifier: "google",
     primaryModel: "google/gemini-3.5-flash",
     observationalModel: "google/gemini-3.5-flash",
-    apiKeyEnv: "GOOGLE_GENERATIVE_AI_API_KEY",
-    apiKeyPrerequisite: "A Google Gemini API key",
-    featureDescription: "Google Gemini web search and direct web page fetching",
-    webSearchEntry: "google.tools.googleSearch({})"
+    apiKeyEnv: "GOOGLE_GENERATIVE_AI_API_KEY"
   },
   xai: {
     displayName: "xAI",
-    sdkPackage: "@ai-sdk/xai",
-    sdkVersion: "^3.0.106",
-    providerIdentifier: "xai",
     primaryModel: "xai/grok-4.3",
     observationalModel: "xai/grok-4.3",
-    apiKeyEnv: "XAI_API_KEY",
-    apiKeyPrerequisite: "An xAI API key",
-    featureDescription: "xAI web search and direct web page fetching",
-    webSearchEntry: "xai.tools.webSearch()"
+    apiKeyEnv: "XAI_API_KEY"
   }
 };
-const PROVIDER_SDK_PACKAGES = Object.values(MANAGED_PROVIDER_CONFIGS).map((config) => config.sdkPackage);
-const OPENAI_SDK_PACKAGE = "@ai-sdk/openai";
 const OPENAI_API_KEY = "OPENAI_API_KEY";
-const OPENAI_IMPORT = /^import\s*\{\s*openai\s*\}\s*from\s*['"]@ai-sdk\/openai['"];?\s*$/m;
-const OPENAI_MODEL = /(\bmodel\s*:\s*['"])openai\/[^'"]+(['"])/g;
-const WEB_SEARCH_PROPERTY = /^([ \t]*)web_search\s*:\s*([^\n]+?)(?:,)?\s*$/m;
+const PRIMARY_OPENAI_MODEL = /(\bmodel\s*:\s*['"])openai\/[^'"]+(['"])(?=\s*,?\s*\n\s*defaultOptions\s*:)/g;
+const OBSERVATIONAL_OPENAI_MODEL = /(observationalMemory\s*:\s*\{[^{}]*?\bmodel\s*:\s*['"])openai\/[^'"]+(['"])/g;
 function findMatches(content, pattern) {
   const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
   return [...content.matchAll(new RegExp(pattern.source, flags))];
 }
-function replaceSingleMatch(content, pattern, replacement, description, fileName) {
-  const matches = findMatches(content, pattern);
-  if (matches.length !== 1) throw new Error(`Default template compatibility error: expected one ${description} in ${fileName}, found ${matches.length}.`);
-  if (typeof replacement === "string") return content.replace(pattern, replacement);
-  return content.replace(pattern, replacement);
+function replaceSingleMatch(content, pattern, replacement) {
+  if (findMatches(content, pattern).length !== 1) return {
+    applied: false,
+    content
+  };
+  if (typeof replacement === "string") return {
+    applied: true,
+    content: content.replace(pattern, replacement)
+  };
+  return {
+    applied: true,
+    content: content.replace(pattern, replacement)
+  };
 }
 function getDependencyMap(manifest, section) {
   const value = manifest[section];
   if (value === void 0 && section === "devDependencies") return void 0;
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Default template compatibility error: package.json has invalid ${section}.`);
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   return value;
 }
 function collectMastraPackages(manifestSource) {
@@ -21700,120 +21683,157 @@ function collectMastraPackages(manifestSource) {
   }
   return [...names];
 }
-function normalizeManagedManifest(content, provider, mastraVersions, fallbackTag) {
+function normalizeManagedManifest(content, mastraVersions, fallbackTag) {
   let manifest;
   try {
     manifest = JSON.parse(content);
   } catch {
-    throw new Error("Default template compatibility error: package.json is not valid JSON.");
+    return {
+      applied: false,
+      content
+    };
   }
-  const dependencySections = [getDependencyMap(manifest, "dependencies"), getDependencyMap(manifest, "devDependencies")].filter((section) => section !== void 0);
-  const openAiLocations = dependencySections.filter((section) => Object.hasOwn(section, OPENAI_SDK_PACKAGE));
-  if (openAiLocations.length !== 1) throw new Error(`Default template compatibility error: package.json must contain ${OPENAI_SDK_PACKAGE} in exactly one dependency section.`);
-  const sourceSection = openAiLocations[0];
-  const templateOpenAiVersion = sourceSection[OPENAI_SDK_PACKAGE];
-  if (typeof templateOpenAiVersion !== "string" || templateOpenAiVersion.trim() === "") throw new Error(`Default template compatibility error: package.json must contain a nonempty ${OPENAI_SDK_PACKAGE} version.`);
-  for (const section of dependencySections) for (const packageName of PROVIDER_SDK_PACKAGES) delete section[packageName];
-  const sdkVersion = provider.sdkPackage === OPENAI_SDK_PACKAGE ? templateOpenAiVersion : provider.sdkVersion;
-  if (!sdkVersion) throw new Error(`Default template compatibility error: no SDK version is configured for ${provider.displayName}.`);
-  sourceSection[provider.sdkPackage] = sdkVersion;
+  const dependencies = getDependencyMap(manifest, "dependencies");
+  const devDependencies = getDependencyMap(manifest, "devDependencies");
+  if (!dependencies || manifest.devDependencies !== void 0 && !devDependencies) return {
+    applied: false,
+    content
+  };
+  const dependencySections = [dependencies, devDependencies].filter((section) => section !== void 0);
   for (const section of dependencySections) for (const packageName of Object.keys(section)) if (packageName === "mastra" || packageName.startsWith("@mastra/")) section[packageName] = mastraVersions?.[packageName] ?? fallbackTag;
   return {
+    applied: true,
     content: `${JSON.stringify(manifest, null, 2)}
-`,
-    sdkVersion
+`
   };
 }
 function adaptAgentSource(source, provider, config) {
-  if (provider === "openai") return source;
-  if (!config.primaryModel || !config.observationalModel) throw new Error(`Default template compatibility error: model configuration is missing for ${config.displayName}.`);
-  let next = replaceSingleMatch(source, OPENAI_IMPORT, `import { ${config.providerIdentifier} } from '${config.sdkPackage}';`, "OpenAI provider import", "src/mastra/agents/agent.ts");
-  const modelMatches = findMatches(next, OPENAI_MODEL);
-  if (modelMatches.length !== 2) throw new Error(`Default template compatibility error: expected two OpenAI model assignments in src/mastra/agents/agent.ts, found ${modelMatches.length}.`);
-  const models = [config.primaryModel, config.observationalModel];
-  let modelIndex = 0;
-  next = next.replace(OPENAI_MODEL, (_match, prefix, suffix) => {
-    return `${prefix}${models[modelIndex++]}${suffix}`;
-  });
-  const webSearchMatches = findMatches(next, WEB_SEARCH_PROPERTY);
-  if (webSearchMatches.length > 1) throw new Error(`Default template compatibility error: expected at most one web_search property in src/mastra/agents/agent.ts, found ${webSearchMatches.length}.`);
-  if (webSearchMatches.length === 1) {
-    const match = webSearchMatches[0];
-    if (!match[2]?.includes("openai.")) throw new Error("Default template compatibility error: the existing web_search property is not owned by the OpenAI template.");
-    next = next.replace(WEB_SEARCH_PROPERTY, config.webSearchEntry ? `${match[1]}web_search: ${config.webSearchEntry},` : "");
-  } else if (config.webSearchEntry) next = replaceSingleMatch(next, /^([ \t]*)web_fetch\s*:\s*[^\n]+$/m, (_line, indentation) => `${indentation}web_fetch: webFetchTool,
-${indentation}web_search: ${config.webSearchEntry},`, "web_fetch property used to place web_search", "src/mastra/agents/agent.ts");
-  return next;
+  if (provider === "openai") return {
+    applied: true,
+    content: source
+  };
+  if (!config.primaryModel || !config.observationalModel) return {
+    applied: false,
+    content: source
+  };
+  if (findMatches(source, PRIMARY_OPENAI_MODEL).length !== 1) return {
+    applied: false,
+    content: source
+  };
+  if (findMatches(source, OBSERVATIONAL_OPENAI_MODEL).length !== 1) return {
+    applied: false,
+    content: source
+  };
+  return {
+    applied: true,
+    content: source.replace(PRIMARY_OPENAI_MODEL, `$1${config.primaryModel}$2`).replace(OBSERVATIONAL_OPENAI_MODEL, `$1${config.observationalModel}$2`)
+  };
 }
 function replaceEnvKey(source, nextKey) {
-  return replaceSingleMatch(source, new RegExp(`^([ \\t]*)${OPENAI_API_KEY}[ \\t]*=.*$`, "m"), (_line, indentation) => `${indentation}${nextKey}=`, `${OPENAI_API_KEY} assignment`, ".env.example");
+  return replaceSingleMatch(source, new RegExp(`^([ \\t]*)${OPENAI_API_KEY}[ \\t]*=.*$`, "m"), (_line, indentation) => `${indentation}${nextKey}=`);
 }
 function setEnvValue(source, key, value) {
-  return replaceSingleMatch(source, new RegExp(`^([ \\t]*)${key}[ \\t]*=.*$`, "m"), (_line, indentation) => `${indentation}${key}=${value}`, `${key} assignment`, ".env");
+  return replaceSingleMatch(source, new RegExp(`^([ \\t]*)${key}[ \\t]*=.*$`, "m"), (_line, indentation) => `${indentation}${key}=${value}`);
 }
 function adaptReadme(source, provider, config, projectName, packageManager) {
-  return source.replace(/^# .+$/m, `# ${projectName}`).replaceAll("npm run dev", `${packageManager} run dev`).replace(/^- .*OpenAI web search.*$/m, `- ${config.featureDescription}`).replace(/^- .*OpenAI API key.*$/m, `- ${config.apiKeyPrerequisite}`).replace(/^([ \t]*)npx create-mastra@\S+.*$/m, `$1npx create-mastra@latest <project-name> --llm ${provider}`).replaceAll(OPENAI_API_KEY, config.apiKeyEnv);
-}
-function assertNoProviderResidue(provider, files) {
-  for (const [otherProvider, config] of Object.entries(MANAGED_PROVIDER_CONFIGS)) {
-    if (otherProvider === provider) continue;
-    const checks = [
-      [files.manifest, config.sdkPackage],
-      [files.agent, `${config.providerIdentifier}/`],
-      [files.agent, `${config.providerIdentifier}.tools`],
-      [files.envExample, config.apiKeyEnv]
-    ];
-    if (files.env !== void 0) checks.push([files.env, config.apiKeyEnv]);
-    for (const [content, residue] of checks) if (content.includes(residue)) throw new Error(`Default template compatibility error: generated project still contains ${JSON.stringify(residue)} from ${config.displayName}.`);
+  if (!(source.includes(OPENAI_API_KEY) || /^([ \t]*)npx create-mastra@\S+.*$/m.test(source))) return {
+    applied: false,
+    content: source
+  };
+  return {
+    applied: true,
+    content: source.replace(/^# .+$/m, `# ${projectName}`).replaceAll("npm run dev", `${packageManager} run dev`).replace(/^([ \t]*)npx create-mastra@\S+.*$/m, `$1npx create-mastra@latest <project-name> --llm ${provider}`).replaceAll(OPENAI_API_KEY, config.apiKeyEnv)
+  };
+}
+async function writeSecureEnv(envPath, content) {
+  const tempPath = path.join(path.dirname(envPath), `.env.mastra-create-${process.pid}-${randomUUID()}.tmp`);
+  try {
+    await fsPromises__default.writeFile(tempPath, content, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    if (process.platform !== "win32") await fsPromises__default.chmod(tempPath, 384);
+    await fsPromises__default.rename(tempPath, envPath);
+    return true;
+  } catch {
+    try {
+      await fsPromises__default.rm(tempPath, { force: true });
+    } catch {
+    }
+    return false;
   }
 }
 async function adaptDefaultTemplate({ projectPath, projectName, packageManager, provider, apiKey, versionTag }) {
   const config = MANAGED_PROVIDER_CONFIGS[provider];
+  let adaptationFailed = false;
+  const write = async (filePath, content) => {
+    try {
+      await fsPromises__default.writeFile(filePath, content, "utf8");
+      return true;
+    } catch {
+      adaptationFailed = true;
+      return false;
+    }
+  };
   const agentPath = path.join(projectPath, "src/mastra/agents/agent.ts");
+  if (provider !== "openai") try {
+    const result = adaptAgentSource(await fsPromises__default.readFile(agentPath, "utf8"), provider, config);
+    if (!result.applied) adaptationFailed = true;
+    else await write(agentPath, result.content);
+  } catch {
+    adaptationFailed = true;
+  }
   const packageJsonPath = path.join(projectPath, "package.json");
+  try {
+    const source = await fsPromises__default.readFile(packageJsonPath, "utf8");
+    const mastraPackages = collectMastraPackages(source);
+    const resolvedVersions = await resolveMastraPackageVersions(mastraPackages, versionTag);
+    if (resolvedVersions === void 0 && mastraPackages.length > 0) console.warn(`We could not resolve exact Mastra package versions for the "${versionTag}" channel, using the channel tag instead`);
+    const result = normalizeManagedManifest(source, resolvedVersions, versionTag);
+    if (!result.applied) adaptationFailed = true;
+    else await write(packageJsonPath, result.content);
+  } catch {
+    adaptationFailed = true;
+  }
   const envExamplePath = path.join(projectPath, ".env.example");
   const envPath = path.join(projectPath, ".env");
+  let adaptedEnvExample;
+  try {
+    const result = replaceEnvKey(await fsPromises__default.readFile(envExamplePath, "utf8"), config.apiKeyEnv);
+    if (!result.applied) adaptationFailed = true;
+    else if (await write(envExamplePath, result.content)) adaptedEnvExample = result.content;
+  } catch {
+    adaptationFailed = true;
+  }
+  let apiKeyWritten = false;
+  if (adaptedEnvExample === void 0) {
+    if (apiKey) adaptationFailed = true;
+  } else if (apiKey) {
+    const result = setEnvValue(adaptedEnvExample, config.apiKeyEnv, apiKey);
+    if (!result.applied) adaptationFailed = true;
+    else {
+      apiKeyWritten = await writeSecureEnv(envPath, result.content);
+      if (!apiKeyWritten) adaptationFailed = true;
+    }
+  } else try {
+    await fsPromises__default.rm(envPath, { force: true });
+  } catch {
+    adaptationFailed = true;
+  }
   const readmePath = path.join(projectPath, "README.md");
-  let agentSource;
-  let packageJsonSource;
-  let envExampleSource;
   try {
-    [agentSource, packageJsonSource, envExampleSource] = await Promise.all([
-      fsPromises__default.readFile(agentPath, "utf8"),
-      fsPromises__default.readFile(packageJsonPath, "utf8"),
-      fsPromises__default.readFile(envExamplePath, "utf8")
-    ]);
-  } catch (error) {
-    throw new Error(`Default template compatibility error: required template file is missing or unreadable: ${error instanceof Error ? error.message : "Unknown error"}`);
+    const result = adaptReadme(await fsPromises__default.readFile(readmePath, "utf8"), provider, config, projectName, packageManager);
+    if (!result.applied) adaptationFailed = true;
+    else await write(readmePath, result.content);
+  } catch {
+    adaptationFailed = true;
   }
-  const readmeSource = await fsPromises__default.readFile(readmePath, "utf8").catch(() => void 0);
-  const nextAgent = adaptAgentSource(agentSource, provider, config);
-  const mastraPackages = collectMastraPackages(packageJsonSource);
-  const resolvedVersions = await resolveMastraPackageVersions(mastraPackages, versionTag);
-  if (resolvedVersions === void 0 && mastraPackages.length > 0) console.warn(`We could not resolve exact Mastra package versions for the "${versionTag}" channel, using the channel tag instead`);
-  const normalizedManifest = normalizeManagedManifest(packageJsonSource, config, resolvedVersions, versionTag);
-  const nextEnvExample = replaceEnvKey(envExampleSource, config.apiKeyEnv);
-  const nextEnv = apiKey ? setEnvValue(nextEnvExample, config.apiKeyEnv, apiKey) : void 0;
-  const nextReadme = readmeSource === void 0 ? void 0 : adaptReadme(readmeSource, provider, config, projectName, packageManager);
-  assertNoProviderResidue(provider, {
-    agent: nextAgent,
-    manifest: normalizedManifest.content,
-    envExample: nextEnvExample,
-    env: nextEnv
-  });
-  const writes = [
-    fsPromises__default.writeFile(agentPath, nextAgent, "utf8"),
-    fsPromises__default.writeFile(packageJsonPath, normalizedManifest.content, "utf8"),
-    fsPromises__default.writeFile(envExamplePath, nextEnvExample, "utf8"),
-    nextEnv === void 0 ? fsPromises__default.rm(envPath, { force: true }) : fsPromises__default.writeFile(envPath, nextEnv, "utf8")
-  ];
-  if (nextReadme !== void 0) writes.push(fsPromises__default.writeFile(readmePath, nextReadme, "utf8"));
-  if (packageManager === "pnpm") writes.push(fsPromises__default.writeFile(path.join(projectPath, "pnpm-workspace.yaml"), PNPM_WORKSPACE, "utf8"));
-  await Promise.all(writes);
-  if (nextEnv !== void 0 && process.platform !== "win32") await fsPromises__default.chmod(envPath, 384);
+  if (packageManager === "pnpm") await write(path.join(projectPath, "pnpm-workspace.yaml"), PNPM_WORKSPACE);
   return {
     ...config,
-    sdkVersion: normalizedManifest.sdkVersion
+    apiKeyWritten,
+    adaptationFailed
   };
 }
 const DEFAULT_TEMPLATE = {
@@ -21822,7 +21842,7 @@ const DEFAULT_TEMPLATE = {
   slug: "template-agent-harness",
   agents: ["agent"],
   mcp: [],
-  tools: ["web-fetch"],
+  tools: [],
   networks: [],
   workflows: []
 };
@@ -22042,6 +22062,7 @@ const create = async (args) => {
   process.on("SIGINT", handleSigint);
   process.on("SIGTERM", handleSigterm);
   let selectedApiKeyEnv;
+  let selectedApiKeyWritten = false;
   let materializationError;
   try {
     if (mode === "empty") {
@@ -22064,14 +22085,17 @@ const create = async (args) => {
         ...observabilityEnabled ? { silent: true } : {}
       });
       if (isManaged) {
-        selectedApiKeyEnv = (await adaptDefaultTemplate({
+        const providerConfig = await adaptDefaultTemplate({
           projectPath: staging.projectPath,
           projectName,
           packageManager,
           provider: llmProvider,
           apiKey: llmApiKey,
           versionTag: versionTag ?? "latest"
-        })).apiKeyEnv;
+        });
+        selectedApiKeyEnv = providerConfig.apiKeyEnv;
+        selectedApiKeyWritten = providerConfig.apiKeyWritten;
+        if (providerConfig.adaptationFailed) log.warn("Some provider setup could not be applied. Review the generated project before running it.");
         materializationController.signal.throwIfAborted();
       }
     }
@@ -22175,7 +22199,7 @@ ${placeholderSummary}1. Visit ${color.cyan("https://projects.mastra.ai")} to cre
 2. Paste the token into ${color.cyan("MASTRA_PLATFORM_ACCESS_TOKEN")} and the project id into ${color.cyan("MASTRA_PROJECT_ID")}.`;
   }
   if (mode === "managed") {
-    const apiKeySummary = llmApiKey ? `Your ${selectedApiKeyEnv} value was written to ${color.cyan(".env")}.` : platformEnvWritten ? `Set ${selectedApiKeyEnv} in ${color.cyan(".env")} before starting.` : `Copy ${color.cyan(".env.example")} to ${color.cyan(".env")} and set ${selectedApiKeyEnv} before starting.`;
+    const apiKeySummary = llmApiKey ? selectedApiKeyWritten ? `Your ${selectedApiKeyEnv} value was written to ${color.cyan(".env")}.` : `Set ${selectedApiKeyEnv} in ${color.cyan(".env")} before starting.` : platformEnvWritten ? `Set ${selectedApiKeyEnv} in ${color.cyan(".env")} before starting.` : `Copy ${color.cyan(".env.example")} to ${color.cyan(".env")} and set ${selectedApiKeyEnv} before starting.`;
     note(`${color.green("Success!")}
 
 ${apiKeySummary}${observabilitySummary ? `
@@ -22395,6 +22419,8 @@ async function getCreateVersionTag(version) {
     if (tag) return tag;
   } catch {
   }
+  const prereleaseChannel = getPrereleaseChannel(version);
+  if (prereleaseChannel) return prereleaseChannel;
   console.error('We could not resolve the create-mastra version tag, falling back to "latest"');
   return "latest";
 }