zelune 1.5.6 → 1.6.1

package/vite.config.ts

@@ -1,7 +1,7 @@
-import { defineConfig } from 'vite';
+import { parse } from '@babel/parser';
+import { build, defineConfig, loadEnv } from 'vite';
 import react from '@vitejs/plugin-react';
 import fs from 'node:fs';
-import { createRequire } from 'node:module';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { viteRnSourceInject } from './plugins/viteRnSourceInject';
@@ -11,7 +11,6 @@ import { viteCanvasApiMiddleware } from './src/server/apiMiddleware';
 import { findMobileAppRoot } from './src/server/astEngine';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const requireFromZelune = createRequire(import.meta.url);
 
 const rawTargetRoot = process.env.ANTIGRAVITY_TARGET_PROJECT
   ? path.resolve(process.env.ANTIGRAVITY_TARGET_PROJECT)
@@ -34,8 +33,8 @@ function safeRealpath(targetPath: string): string {
 
 function resolvePackageRootDir(pkgName: string): string {
   try {
-    const pkgJsonPath = requireFromZelune.resolve(`${pkgName}/package.json`);
-    return path.dirname(pkgJsonPath);
+    const pkgJsonUrl = import.meta.resolve(`${pkgName}/package.json`);
+    return path.dirname(fileURLToPath(pkgJsonUrl));
   } catch {
     return pkgName;
   }
@@ -46,55 +45,169 @@ const resolvedReactDomDir = resolvePackageRootDir('react-dom');
 const resolvedRnWebDir = resolvePackageRootDir('react-native-web');
 const resolvedLucideDir = resolvePackageRootDir('lucide-react');
 
-/**
- * Loads only safe client-public environment variables (EXPO_PUBLIC_*, NEXT_PUBLIC_*, VITE_*)
- * from the target project's .env files so top-level SDK initializers in mobile screens work.
- */
 function loadPublicProjectEnv(roots: string[]): Record<string, string> {
   const publicEnv: Record<string, string> = {
     NODE_ENV: 'development',
     EXPO_PUBLIC_PLATFORM: 'web',
   };
-  const envFiles = ['.env', '.env.development', '.env.local'];
   const uniqueRoots = Array.from(new Set(roots.map((r) => path.resolve(r))));
 
   for (const rootDir of uniqueRoots) {
-    for (const fileName of envFiles) {
-      const fullPath = path.join(rootDir, fileName);
-      try {
-        if (!fs.existsSync(fullPath)) continue;
-        const raw = fs.readFileSync(fullPath, 'utf-8');
-        for (const line of raw.split(/\r?\n/)) {
-          const trimmed = line.trim();
-          if (!trimmed || trimmed.startsWith('#')) continue;
-          const eqIdx = trimmed.indexOf('=');
-          if (eqIdx <= 0) continue;
-          const key = trimmed.slice(0, eqIdx).trim();
-          if (
-            !key.startsWith('EXPO_PUBLIC_') &&
-            !key.startsWith('NEXT_PUBLIC_') &&
-            !key.startsWith('VITE_')
-          ) {
-            continue;
-          }
-          let val = trimmed.slice(eqIdx + 1).trim();
-          if (
-            (val.startsWith('"') && val.endsWith('"')) ||
-            (val.startsWith("'") && val.endsWith("'"))
-          ) {
-            val = val.slice(1, -1);
+    try {
+      const loaded = loadEnv('development', rootDir, ['EXPO_PUBLIC_', 'NEXT_PUBLIC_', 'VITE_']);
+      Object.assign(publicEnv, loaded);
+    } catch {
+      // Ignore unreadable env directories
+    }
+  }
+  return publicEnv;
+}
+
+const publicProjectEnv = loadPublicProjectEnv([workspaceRoot, rawTargetRoot, targetProjectRoot]);
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractStaticAstValue(node: any, scope: Map<string, unknown>, depth = 0): unknown {
+  if (!node || depth > 12) return undefined;
+
+  switch (node.type) {
+    case 'StringLiteral':
+    case 'NumericLiteral':
+    case 'BooleanLiteral':
+      return node.value;
+    case 'NullLiteral':
+      return null;
+    case 'UnaryExpression': {
+      const arg = extractStaticAstValue(node.argument, scope, depth + 1);
+      if (typeof arg === 'number') {
+        if (node.operator === '-') return -arg;
+        if (node.operator === '+') return +arg;
+      }
+      return undefined;
+    }
+    case 'TemplateLiteral': {
+      if (Array.isArray(node.expressions) && node.expressions.length === 0) {
+        return node.quasis?.[0]?.value?.cooked ?? node.quasis?.[0]?.value?.raw ?? '';
+      }
+      return undefined;
+    }
+    case 'ArrayExpression': {
+      const items: unknown[] = [];
+      for (const el of node.elements ?? []) {
+        if (!el) continue;
+        if (el.type === 'SpreadElement') {
+          const spreadVal = extractStaticAstValue(el.argument, scope, depth + 1);
+          if (Array.isArray(spreadVal)) items.push(...spreadVal);
+        } else {
+          const val = extractStaticAstValue(el, scope, depth + 1);
+          if (val !== undefined) items.push(val);
+        }
+      }
+      return items;
+    }
+    case 'ObjectExpression': {
+      const result: Record<string, unknown> = {};
+      for (const prop of node.properties ?? []) {
+        if (prop.type === 'SpreadElement') {
+          const spreadObj = extractStaticAstValue(prop.argument, scope, depth + 1);
+          if (spreadObj && typeof spreadObj === 'object' && !Array.isArray(spreadObj)) {
+            Object.assign(result, spreadObj);
           }
-          publicEnv[key] = val;
+          continue;
+        }
+        if (prop.type !== 'ObjectProperty' || prop.computed) continue;
+        const key =
+          prop.key?.type === 'Identifier'
+            ? prop.key.name
+            : prop.key?.type === 'StringLiteral' || prop.key?.type === 'NumericLiteral'
+              ? String(prop.key.value)
+              : null;
+        if (!key) continue;
+        const val = extractStaticAstValue(prop.value, scope, depth + 1);
+        if (val !== undefined) {
+          result[key] = val;
         }
-      } catch {
-        // Ignore unreadable .env files
       }
+      return result;
     }
+    case 'TSAsExpression':
+    case 'TSSatisfiesExpression':
+    case 'TSTypeAssertion':
+    case 'ParenthesizedExpression':
+      return extractStaticAstValue(node.expression, scope, depth + 1);
+    case 'Identifier':
+      return scope.get(node.name);
+    default:
+      return undefined;
   }
-  return publicEnv;
 }
 
-const publicProjectEnv = loadPublicProjectEnv([workspaceRoot, rawTargetRoot, targetProjectRoot]);
+export function parseTailwindConfigSource(raw: string): Record<string, unknown> {
+  try {
+    const ast = parse(raw, {
+      sourceType: 'unambiguous',
+      plugins: ['typescript', 'jsx'],
+      errorRecovery: true,
+    });
+
+    const scope = new Map<string, unknown>();
+    let exportedConfig: unknown;
+
+    for (const stmt of ast.program.body) {
+      if (stmt.type === 'VariableDeclaration') {
+        for (const decl of stmt.declarations) {
+          if (decl.id.type === 'Identifier' && decl.init) {
+            const val = extractStaticAstValue(decl.init, scope);
+            if (val !== undefined) {
+              scope.set(decl.id.name, val);
+            }
+          }
+        }
+      } else if (stmt.type === 'ExportDefaultDeclaration') {
+        exportedConfig = extractStaticAstValue(stmt.declaration, scope);
+      } else if (
+        stmt.type === 'ExpressionStatement' &&
+        stmt.expression.type === 'AssignmentExpression'
+      ) {
+        const left = stmt.expression.left;
+        if (
+          left.type === 'MemberExpression' &&
+          left.object.type === 'Identifier' &&
+          left.property.type === 'Identifier' &&
+          ((left.object.name === 'module' && left.property.name === 'exports') ||
+            (left.object.name === 'exports' && left.property.name === 'default'))
+        ) {
+          exportedConfig = extractStaticAstValue(stmt.expression.right, scope);
+        }
+      }
+    }
+
+    const cfg = exportedConfig as
+      | { theme?: Record<string, unknown> & { extend?: Record<string, unknown> } }
+      | undefined;
+
+    if (cfg?.theme && typeof cfg.theme === 'object') {
+      const baseTheme = { ...cfg.theme };
+      const extendTheme =
+        cfg.theme.extend && typeof cfg.theme.extend === 'object' ? cfg.theme.extend : {};
+      delete baseTheme.extend;
+      const merged: Record<string, unknown> = { ...baseTheme };
+      for (const [k, v] of Object.entries(extendTheme)) {
+        if (v && typeof v === 'object' && !Array.isArray(v)) {
+          merged[k] = {
+            ...((baseTheme[k] as Record<string, unknown>) ?? {}),
+            ...(v as Record<string, unknown>),
+          };
+        } else {
+          merged[k] = v;
+        }
+      }
+      return merged;
+    }
+  } catch {
+    // Ignore tailwind config parse errors
+  }
+  return {};
+}
 
 function loadProjectTailwindTheme(roots: string[]): Record<string, unknown> {
   const candidates = [
@@ -110,36 +223,12 @@ function loadProjectTailwindTheme(roots: string[]): Record<string, unknown> {
       try {
         if (!fs.existsSync(fullPath)) continue;
         const raw = fs.readFileSync(fullPath, 'utf-8');
-        const cleaned = raw
-          .replace(/^import\s+.*$/gm, '')
-          .replace(/export\s+default\s+/, 'module.exports = ');
-        const mod = { exports: {} as Record<string, unknown> };
-        const fakeRequire = () => ({});
-        const fn = new Function('module', 'exports', 'require', cleaned);
-        fn(mod, mod.exports, fakeRequire);
-        const cfg = mod.exports as {
-          theme?: Record<string, unknown> & { extend?: Record<string, unknown> };
-        };
-        if (cfg?.theme && typeof cfg.theme === 'object') {
-          const baseTheme = { ...cfg.theme };
-          const extendTheme =
-            cfg.theme.extend && typeof cfg.theme.extend === 'object' ? cfg.theme.extend : {};
-          delete baseTheme.extend;
-          const merged: Record<string, unknown> = { ...baseTheme };
-          for (const [k, v] of Object.entries(extendTheme)) {
-            if (v && typeof v === 'object' && !Array.isArray(v)) {
-              merged[k] = {
-                ...((baseTheme[k] as Record<string, unknown>) ?? {}),
-                ...(v as Record<string, unknown>),
-              };
-            } else {
-              merged[k] = v;
-            }
-          }
-          return merged;
+        const parsedTheme = parseTailwindConfigSource(raw);
+        if (Object.keys(parsedTheme).length > 0) {
+          return parsedTheme;
         }
       } catch {
-        // Ignore tailwind config parse errors
+        // Ignore unreadable tailwind config files
       }
     }
   }
@@ -172,53 +261,29 @@ export default defineConfig({
       transformIndexHtml(html) {
         const serializedEnv = JSON.stringify(publicProjectEnv);
         const serializedTailwindTheme = JSON.stringify(projectTailwindTheme);
-        const envScript = `<script>
-(function() {
-  window.__ZELUNE_TAILWIND_THEME__ = ${serializedTailwindTheme};
-  var baseEnv = ${serializedEnv};
-  var envProxy = new Proxy(baseEnv, {
-    get: function(target, prop) {
-      if (typeof prop !== 'string') return target[prop];
-      if (prop in target && target[prop] !== undefined && target[prop] !== '') {
-        return target[prop];
-      }
-      var upper = prop.toUpperCase();
-      if (upper.includes('URL') || upper.includes('ENDPOINT') || upper.includes('HOST')) {
-        return 'https://placeholder.example.com';
-      }
-      if (upper.includes('KEY') || upper.includes('TOKEN') || upper.includes('ID') || upper.includes('SECRET')) {
-        return 'placeholder-public-token';
-      }
-      return '';
-    }
-  });
-  function createRequireProxy() {
-    var fn = function() { return proxy; };
-    var proxy = new Proxy(fn, {
-      get: function(_t, prop) {
-        if (prop === Symbol.toPrimitive) return function(hint) { return hint === 'number' ? 0 : ''; };
-        if (prop === 'valueOf') return function() { return 0; };
-        if (prop === 'toString') return function() { return ''; };
-        if (prop === 'uri' || prop === 'default') return '';
-        return proxy;
-      }
-    });
-    return proxy;
-  }
-  window.global = window;
-  window.__DEV__ = true;
-  window.process = window.process || { env: envProxy, platform: 'browser', version: '', cwd: function() { return '/'; } };
-  window.process.env = envProxy;
-  window.require = window.require || function(modId) {
-    if (typeof modId === 'string' && /\\.(png|jpe?g|gif|webp|svg|avif|bmp)$/i.test(modId)) {
-      return { uri: modId, default: modId };
-    }
-    return createRequireProxy();
-  };
-})();
-</script>`;
+        const envScript = `<script>window.__ZELUNE_TAILWIND_THEME__ = ${serializedTailwindTheme}; window.__ZELUNE_PUBLIC_ENV__ = ${serializedEnv};</script>`;
         return html.replace('<head>', `<head>\n    ${envScript}`);
       },
+      async closeBundle() {
+        await build({
+          configFile: false,
+          css: { postcss: {} },
+          logLevel: 'silent',
+          build: {
+            ssr: path.resolve(__dirname, 'mcp/server.ts'),
+            outDir: path.resolve(__dirname, 'mcp'),
+            emptyOutDir: false,
+            minify: false,
+            rollupOptions: {
+              external: [/^node:/, /^@babel\//],
+              output: {
+                format: 'es',
+                entryFileNames: 'server.mjs',
+              },
+            },
+          },
+        });
+      },
     },
     viteReactNativeFallbackPlugin(targetProjectRoot, mockNavShimPath, workspaceRoot),
     viteVirtualScreensPlugin(targetProjectRoot),