@amerged/ohmyhost-mcp 0.1.32 → 0.1.33

package/src/packages/contracts/src/framework-admission-corpus.ts

@@ -48,6 +48,47 @@ const CORPUS_NEXT_PAGE = `export default function Home() {
   return <main>Hello from ohmyho.st</main>;
 }
 `;
+// The config `create-next-app@16.4.0 --yes --no-tailwind` writes: Cache Components with partial
+// prefetching.
+const CREATE_NEXT_APP_CONFIG = `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+  cacheComponents: true,
+  partialPrefetching: true,
+};
+
+export default nextConfig;
+`;
+// With Tailwind CSS, which --yes selects, create-next-app on its default Turbopack bundler adds this
+// rule instead of a postcss.config.mjs; the Webpack build ignores turbopack.rules.
+const CREATE_NEXT_APP_TAILWIND_RULE = `  turbopack: {
+    rules: {
+      "*.css": {
+        loaders: ["@tailwindcss/turbopack"],
+        as: "*.css",
+      },
+    },
+  },
+`;
+const CREATE_NEXT_APP_POSTCSS_CONFIG = `const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;
+`;
+const CREATE_NEXT_APP_LAYOUT = `import "./globals.css";
+
+export default function RootLayout({ children }: Readonly<{ children: React.ReactNode }>) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}
+`;
 const CORPUS_TANSTACK_CONFIG = `import { tanstackStart } from "@tanstack/react-start/plugin/vite";
 import viteReact from "@vitejs/plugin-react";
 import { defineConfig } from "vite";
@@ -93,6 +134,14 @@ export const FRAMEWORK_ADMISSION_CONFORMANCE_CORPUS: Readonly<{
       viteSource({ declared: "^8.2.0", resolved: "8.3.4" }),
     ),
     corpusCase("TanStack Start 1.168.60 prerendered for the static runtime", tanStackSource()),
+    corpusCase(
+      "create-next-app 16.4 --yes --no-tailwind: Cache Components with partial prefetching",
+      createNextAppSource({ tailwind: false }),
+    ),
+    corpusCase(
+      "create-next-app 16.4 --yes with a postcss.config.mjs added beside its Turbopack rule",
+      createNextAppSource({ tailwind: true, postcss: true }),
+    ),
   ]),
   pending: Object.freeze([
     Object.freeze({
@@ -148,6 +197,11 @@ export const FRAMEWORK_ADMISSION_CONFORMANCE_CORPUS: Readonly<{
       }),
       { code: "next_base_path_unsupported", path: "next.config.ts" },
     ),
+    refusedCase(
+      "create-next-app 16.4 --yes: Tailwind CSS only in a Turbopack rule",
+      createNextAppSource({ tailwind: true }),
+      { code: "next_tailwind_turbopack_only", path: "next.config.ts" },
+    ),
     refusedCase(
       "Next.js build script with a second step",
       nextSource({ build: "next build && next-sitemap" }),
@@ -325,6 +379,49 @@ function nextSource(
   });
 }
 
+/**
+ * The next.config.ts and Tailwind CSS files and packages `create-next-app@16.4.0 --yes` writes, in
+ * an App Router source with the packageManager, lockfile and ohmyhost.yaml ohmyho.st requires;
+ * `tailwind: false` is its --no-tailwind output. On Turbopack, its default bundler, it adds only the
+ * Turbopack rule for Tailwind CSS; `postcss` adds the postcss.config.mjs and @tailwindcss/postcss it
+ * writes for any other bundler.
+ */
+function createNextAppSource(
+  options: Readonly<{ tailwind: boolean; postcss?: boolean }>,
+): Readonly<Record<string, string>> {
+  const [packageManager, lockfile] = CORPUS_MANAGERS.npm;
+  const runtime = { next: "16.4.0", react: "19.3.0", "react-dom": "19.3.0" };
+  const postcss = options.postcss === true;
+  return Object.freeze({
+    "ohmyhost.yaml": corpusConfiguration("npm", ".open-next/assets", "edge"),
+    "package.json": corpusJson({
+      name: "website",
+      version: "0.1.0",
+      private: true,
+      packageManager,
+      scripts: { dev: "next dev", build: "next build", start: "next start" },
+      dependencies: runtime,
+      ...(options.tailwind
+        ? {
+            devDependencies: {
+              ...(postcss ? { "@tailwindcss/postcss": "^4" } : {}),
+              "@tailwindcss/turbopack": "^4",
+              tailwindcss: "^4",
+            },
+          }
+        : {}),
+    }),
+    [lockfile]: corpusLockfile("npm", runtime, runtime),
+    "next.config.ts": options.tailwind
+      ? CREATE_NEXT_APP_CONFIG.replace("};\n", `${CREATE_NEXT_APP_TAILWIND_RULE}};\n`)
+      : CREATE_NEXT_APP_CONFIG,
+    ...(postcss ? { "postcss.config.mjs": CREATE_NEXT_APP_POSTCSS_CONFIG } : {}),
+    "app/globals.css": options.tailwind ? '@import "tailwindcss";\n' : "body {\n  margin: 0;\n}\n",
+    "app/layout.tsx": CREATE_NEXT_APP_LAYOUT,
+    "app/page.tsx": CORPUS_NEXT_PAGE,
+  });
+}
+
 function viteSource(
   options: Readonly<{ declared?: string; resolved?: string; config?: string }> = {},
 ): Readonly<Record<string, string>> {

package/src/packages/contracts/src/framework-admission.ts

@@ -373,9 +373,9 @@ const FRAMEWORK_CONVERSION_DETAILS = Object.freeze({
     paths: ["framework_config"],
     template: `"{{path}}" does not follow the TanStack Start plugin contract: import tanstackStart from "@tanstack/react-start/plugin/vite"; on runtime edge also import cloudflare from "@cloudflare/vite-plugin" and call cloudflare({ viteEnvironment: { name: "ssr" } }) before tanstackStart(); on runtime static do not import the Cloudflare plugin. ${PUSH_AND_PLAN}`,
   },
-  next_cache_components_unsupported: {
+  next_tailwind_turbopack_only: {
     paths: ["framework_config"],
-    template: `"{{path}}" sets cacheComponents: true, which ohmyho.st does not support; remove it or set it to false. ${PUSH_AND_PLAN}`,
+    template: `"{{path}}" loads Tailwind CSS through the Turbopack rule "@tailwindcss/turbopack", which the Webpack build on ohmyho.st ignores, and the application root has no PostCSS configuration that Webpack reads, so the site would deploy without its Tailwind classes. Add postcss.config.mjs to the application root with export default { plugins: { "@tailwindcss/postcss": {} } } and remove the Turbopack rule. Use the package manager to add @tailwindcss/postcss to devDependencies at the same version as tailwindcss and to remove @tailwindcss/turbopack, so the lockfile records both. ${PUSH_AND_PLAN}`,
   },
   framework_version_unsupported: {
     paths: ["manifest", "lockfile"],

package/src/packages/contracts/src/framework-source-rules.ts

@@ -119,6 +119,10 @@ const BUILD_OUTPUTS: Readonly<Partial<Record<FrameworkSourceFramework, string>>>
 });
 const REQUIRED_CONFIG_PATHS: Readonly<Partial<Record<FrameworkSourceFramework, string>>> =
   Object.freeze({ nextjs: "next.config.ts", "tanstack-start": "vite.config.ts" });
+// The PostCSS configuration the Next.js Webpack build reads: package.json "postcss" or one of these
+// files at the application root. It never reads a TypeScript one such as postcss.config.ts.
+const POSTCSS_CONFIG_PATH = /^(?:postcss\.config\.(?:[cm]?js|json)|\.postcssrc\.(?:js|json))$/u;
+const TAILWIND_TURBOPACK_LOADER = "@tailwindcss/turbopack";
 const MAXIMUM_LOCKFILE_LENGTH = 5 * 1024 * 1024;
 const MAXIMUM_PNPM_LOCKFILE_HEAD = 256 * 1024;
 const PNPM_LOCKFILE_BODY = /^(?:packages|snapshots):/mu;
@@ -327,12 +331,15 @@ export function repositorySourceFindings(
 
 /**
  * The Next.js config rules: inspection size, comment and string syntax, the root origin
- * (basePath, assetPrefix), output, cacheComponents and the default export; next.config.js may
- * assign module.exports instead.
+ * (basePath, assetPrefix), output, the "@tailwindcss/turbopack" loader and the default export;
+ * next.config.js may assign module.exports instead. ohmyho.st builds with Webpack, which ignores
+ * Turbopack rules and applies Tailwind CSS only through PostCSS, so that loader is refused unless
+ * `postcss` reports a PostCSS configuration Webpack reads at the application root.
  */
 export function nextConfigFindings(
   text: string,
   path: string,
+  postcss: boolean,
 ): readonly FrameworkConversionDiagnostic[] {
   const lexed = lexFrameworkConfig(text, path);
   if ("finding" in lexed) return Object.freeze([lexed.finding]);
@@ -342,8 +349,11 @@ export function nextConfigFindings(
     findings.push(diagnostic({ code: "next_base_path_unsupported", path }));
   if (hasProperty(tokens, "output", "export") || hasProperty(tokens, "output", "standalone"))
     findings.push(diagnostic({ code: "next_output_unsupported", path }));
-  if (hasProperty(tokens, "cacheComponents", "true"))
-    findings.push(diagnostic({ code: "next_cache_components_unsupported", path }));
+  if (
+    !postcss &&
+    tokens.some(({ kind, value }) => kind === "string" && value === TAILWIND_TURBOPACK_LOADER)
+  )
+    findings.push(diagnostic({ code: "next_tailwind_turbopack_only", path }));
   if (
     !hasExportDefault(tokens) &&
     !(path.slice(path.lastIndexOf("/") + 1) === "next.config.js" && hasModuleExports(tokens))
@@ -619,12 +629,19 @@ function frameworkConfigFindings(
   const { frameworkConfig, framework } = input;
   if (frameworkConfig === null || framework === "functions") return [];
   const { path, text } = frameworkConfig;
-  if (framework === "nextjs") return nextConfigFindings(text, path);
+  if (framework === "nextjs") return nextConfigFindings(text, path, hasPostcssConfiguration(input));
   if (framework === "vite-static") return viteConfigFindings(text, path);
   const mode = input.configuration.runtime.mode;
   return tanStackViteConfigFindings(text, path, mode === "edge" || mode === "static" ? mode : null);
 }
 
+/** Whether package.json or a file at the application root configures PostCSS for Webpack. */
+function hasPostcssConfiguration({ files, manifest }: FrameworkSourceRuleInput): boolean {
+  return (
+    isRecord(ownValue(manifest, "postcss")) || files.some((path) => POSTCSS_CONFIG_PATH.test(path))
+  );
+}
+
 function repositoryConfiguration(text: string | null | undefined): OhmyhostConfig | null {
   if (typeof text !== "string") return null;
   try {

package/src/packages/sdk-ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohmyhost/sdk-ts",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "private": true,
   "type": "module",
   "exports": {