ozmoz 0.1.0

package/scripts/setup-lib.cjs

@@ -0,0 +1,748 @@
+//scripts/setup-lib.cjs
+const fs = require("fs");
+const path = require("path");
+const https = require("https");
+const { execSync } = require("child_process");
+
+// ANSI Escape Codes for Colors
+const COLOR_BLUE = "\x1b[38;2;231;233;237m";
+const COLOR_RED = "\x1b[31m";
+const COLOR_RESET = "\x1b[0m";
+
+function log(msg) {
+  console.log(`  ${COLOR_BLUE}${msg}${COLOR_RESET}`);
+}
+
+function logError(msg) {
+  console.error(`  ${COLOR_RED}${msg}${COLOR_RESET}`);
+}
+
+function parseArgs(args) {
+  const flags = {};
+  args.forEach((arg) => {
+    if (arg.startsWith("--")) {
+      const [key, value] = arg.slice(2).split("=");
+      if (key && value) {
+        flags[key] = value;
+      }
+    }
+  });
+  return flags;
+}
+
+function detectDependency(pkgPath, name) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    return Boolean(
+      (pkg.dependencies && pkg.dependencies[name]) ||
+      (pkg.devDependencies && pkg.devDependencies[name])
+    );
+  } catch (e) {
+    return false;
+  }
+}
+
+function isActuallyInstalled(projectRoot, name) {
+  try {
+    return fs.existsSync(path.join(projectRoot, "node_modules", name, "package.json"));
+  } catch (e) {
+    return false;
+  }
+}
+
+function detectPackageManager(projectRoot, pkgPath) {
+  if (fs.existsSync(path.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(projectRoot, "yarn.lock"))) return "yarn";
+  if (fs.existsSync(path.join(projectRoot, "bun.lockb"))) return "bun";
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    if (typeof pkg.packageManager === "string") {
+      if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
+      if (pkg.packageManager.startsWith("yarn")) return "yarn";
+      if (pkg.packageManager.startsWith("bun")) return "bun";
+    }
+  } catch (e) {}
+  return "npm";
+}
+
+function installPackageIfMissing(projectRoot, pkgPath) {
+  if (!detectDependency(pkgPath, "ozmoz") || !isActuallyInstalled(projectRoot, "ozmoz")) {
+    const pm = detectPackageManager(projectRoot, pkgPath);
+    const installCmd = {
+      pnpm: "pnpm add ozmoz",
+      yarn: "yarn add ozmoz",
+      bun: "bun add ozmoz",
+      npm: "npm install ozmoz",
+    }[pm];
+
+    log(`→ Installing ozmoz into the project (detected: ${pm})...`);
+    try {
+      execSync(installCmd, { cwd: projectRoot, stdio: "inherit" });
+      log("ozmoz installed successfully!");
+    } catch (e) {
+      logError(`⚠️ Automatic installation failed: ${e.message}`);
+      logError(`👉 Please run '${installCmd}' manually.`);
+    }
+  }
+}
+
+// Installs a dev dependency in the user's project when it is missing (same package manager as the project).
+function ensureDevPackage(projectRoot, pkgPath, name, versionSpec) {
+  if (detectDependency(pkgPath, name) && isActuallyInstalled(projectRoot, name)) return;
+  const pm = detectPackageManager(projectRoot, pkgPath);
+  const spec = `"${name}@${versionSpec}"`;
+  const installCmd = {
+    pnpm: `pnpm add -D ${spec}`,
+    yarn: `yarn add -D ${spec}`,
+    bun: `bun add -d ${spec}`,
+    npm: `npm install -D ${spec}`,
+  }[pm];
+
+  log(`→ Installing ${name} into the project (detected: ${pm})...`);
+  try {
+    execSync(installCmd, { cwd: projectRoot, stdio: "inherit" });
+    log(`${name} installed successfully!`);
+  } catch (e) {
+    logError(`⚠️ Automatic installation failed: ${e.message}`);
+    logError(`👉 Please run  manually.`);
+  }
+}
+
+function ensureSchemaFile(projectRoot) {
+  const schemaPath = path.join(projectRoot, "svro.schema.json");
+  if (fs.existsSync(schemaPath)) return;
+  const now = new Date().toISOString();
+  const initial = {
+    createdAt: now,
+    patchedAt: now,
+    schemaVersion: 1,
+    collections: {},
+  };
+  fs.writeFileSync(schemaPath, JSON.stringify(initial, null, 2) + "\n");
+  log("→ Created svro.schema.json at project root.");
+}
+
+function ensureEnvPrototype(projectRoot) {
+  const envPath = path.join(projectRoot, ".env");
+  const defaultVar = "\n# ozmoZ UI Sandbox Mode\n# true  = Sandbox mode: simulates writes locally for fluid UI testing; no DB access and IDE alert.\n# false = Strict production mode: enforces schema contracts and persists to DB\nOZ_PROTOTYPE=true\n";
+
+  if (!fs.existsSync(envPath)) {
+    fs.writeFileSync(envPath, defaultVar.trimStart());
+    log("→ Created .env with OZ_PROTOTYPE=true");
+  } else {
+    const content = fs.readFileSync(envPath, "utf8");
+    if (!content.includes("OZ_PROTOTYPE")) {
+      fs.appendFileSync(envPath, defaultVar);
+      log("→ Injected OZ_PROTOTYPE=true into existing .env");
+    }
+  }
+}
+
+function ensureAutoImportsDts(projectRoot) {
+  const srcDir = path.join(projectRoot, "src");
+  if (!fs.existsSync(srcDir)) return;
+  
+  const dtsPath = path.join(srcDir, "ozmoz.d.ts");
+  if (fs.existsSync(dtsPath)) return;
+
+  const stubContent = `/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+export {}
+
+type OzOtpOptions = {
+  email: string;
+  appName?: string;
+  subject?: string;
+  message?: string;
+  logoUrl?: string;
+};
+
+type OzPhoneOtpOptions = {
+  phoneNumber: string;
+  appName?: string;
+};
+
+type OzFacebookAuthOptions = {
+  accessToken?: string;
+  scope?: string;
+};
+
+type OzProp = {
+  value?: any;
+  fallback?: string;
+  'invalid-fallback'?: string;
+  currency?: string;
+  locale?: string;
+  allowed?: string;
+  alt?: string;
+  table?: any;
+  id?: string;
+  field?: string;
+  'label-true'?: string;
+  'label-false'?: string;
+  'orphan-fallback'?: string;
+  'loading-fallback'?: string;
+  'malformed-fallback'?: string;
+  class?: string;
+  className?: string;
+  children?: any;
+  [key: string]: any;
+};
+
+declare global {
+  interface ImportMetaEnv {
+    readonly OZ_DB_KEY?: string;
+    readonly OZ_ENTERPRISE_ID?: string;
+    readonly OZ_KEY_APP?: string;
+    readonly OZ_PROTOTYPE?: string;
+    readonly OZ_FACEBOOK_APP_ID?: string;
+    readonly [key: string]: any;
+  }
+
+  interface ImportMeta {
+    readonly env: ImportMetaEnv;
+  }
+
+  type OzTables = string;
+  const oz: typeof import('ozmoz')['oz'];
+
+  interface Window {
+    oz: typeof oz;
+    FB?: any;
+  }
+
+  namespace JSX {
+    interface IntrinsicElements {
+      'oz-text': OzProp;
+      'oz-number': OzProp;
+      'oz-toggle': OzProp;
+      'oz-date': OzProp;
+      'oz-enum': OzProp;
+      'oz-media': OzProp;
+      'oz-reference': OzProp;
+    }
+  }
+
+  namespace React {
+    namespace JSX {
+      interface IntrinsicElements {
+        'oz-text': OzProp;
+        'oz-number': OzProp;
+        'oz-toggle': OzProp;
+        'oz-date': OzProp;
+        'oz-enum': OzProp;
+        'oz-media': OzProp;
+        'oz-reference': OzProp;
+      }
+    }
+  }
+}
+`;
+  try {
+    fs.writeFileSync(dtsPath, stubContent);
+    log("→ Created src/ozmoz.d.ts stub with strict oz.* and <oz-*> typings.");
+  } catch (e) {
+    logError(`⚠️ Unable to create src/ozmoz.d.ts: ${e.message}`);
+  }
+}
+
+function ensureDts(packageRoot) {
+  const dtsPath = path.join(packageRoot, "index.d.ts");
+  if (fs.existsSync(dtsPath)) return;
+  log("→ Verified index.d.ts presence.");
+}
+
+function touchTsConfig(projectRoot) {
+  const candidates = ['tsconfig.json', 'jsconfig.json'];
+  for (const filename of candidates) {
+    const fullPath = path.join(projectRoot, filename);
+    if (fs.existsSync(fullPath)) {
+      const now = new Date();
+      fs.utimesSync(fullPath, now, now);
+      break;
+    }
+  }
+}
+
+function exchangeBootstrapToken(token) {
+  return new Promise((resolve, reject) => {
+    const postData = JSON.stringify({ token });
+    const options = {
+      hostname: "bootstrapproject-jqycakhlxa-uc.a.run.app",
+      path: "/",
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(postData),
+      },
+    };
+    const req = https.request(options, (res) => {
+      let data = "";
+      res.on("data", (chunk) => { data += chunk; });
+      res.on("end", () => {
+        if (res.statusCode >= 200 && res.statusCode < 300) {
+          try { resolve(JSON.parse(data)); }
+          catch (e) { reject(new Error("Invalid response received from ozmoZ server.")); }
+        } else {
+          try {
+            const parsed = JSON.parse(data);
+            reject(new Error(parsed.error || `Server error ${res.statusCode}`));
+          } catch (e) {
+            reject(new Error(`Server error ${res.statusCode}`));
+          }
+        }
+      });
+    });
+    req.on("error", (e) => reject(e));
+    req.write(postData);
+    req.end();
+  });
+}
+
+async function handleAuthAndEnv(projectRoot, args = []) {
+  const envPath = path.join(projectRoot, ".env");
+
+  if (fs.existsSync(envPath) && fs.readFileSync(envPath, "utf8").includes("OZ_DB_KEY")) {
+    log("→ ozmoZ environment variables already present in .env — skipping step.");
+    return;
+  }
+
+  const flags = parseArgs(args);
+  const keyApp = flags.keyApp;
+  const bootstrapToken = flags.token || flags.bootstrapToken;
+  const testerEmail = flags.email || "";
+
+  if (!keyApp || !bootstrapToken) {
+    logError("⚠️ Missing required parameters.");
+    logError("👉 Usage: npx ozmoz init --keyApp=YOUR_KEY --token=YOUR_TOKEN");
+    process.exit(1);
+  }
+
+  log("→ Exchanging bootstrap token for project keys...");
+  let keys;
+  try {
+    keys = await exchangeBootstrapToken(bootstrapToken);
+  } catch (err) {
+    logError(`⚠️ Token exchange failed: ${err.message}`);
+    logError("👉 The token may have expired (15 min limit) or was already used. Please regenerate one from the ozmoZ dashboard.");
+    process.exit(1);
+  }
+
+  if (!keys.enterpriseId || !keys.fleetboDBKey) {
+    logError("⚠️ Incomplete response from ozmoZ server.");
+    process.exit(1);
+  }
+
+  const fbAppId = keys.facebookAppId || flags.fbAppId || flags.facebookAppId || "11967268204758";
+
+  const envContent = `\nOZ_DB_KEY=${keys.fleetboDBKey}\nOZ_ENTERPRISE_ID=${keys.enterpriseId}\nOZ_KEY_APP=${keyApp}\n${testerEmail ? `OZ_TESTER_EMAIL=${testerEmail}\n` : ""}OZ_FACEBOOK_APP_ID=${fbAppId}\n`;
+
+  fs.appendFileSync(envPath, envContent);
+  log(".env file updated successfully with project keys!");
+}
+
+function cleanupLegacyRootDts(projectRoot) {
+  const legacyPath = path.join(projectRoot, "svro.d.ts");
+  if (fs.existsSync(legacyPath)) {
+    try {
+      fs.unlinkSync(legacyPath);
+      log("→ Removed legacy svro.d.ts from project root.");
+    } catch (e) {}
+  }
+}
+
+function patchJsOrTsConfig(projectRoot, pkgPath) {
+  if (process.env.FLEETBO_SKIP_TYPECHECK_SETUP) return;
+
+  const tsconfigPath = path.join(projectRoot, "tsconfig.json");
+  const jsconfigPath = path.join(projectRoot, "jsconfig.json");
+  const targetPath = fs.existsSync(tsconfigPath) ? tsconfigPath : jsconfigPath;
+  const isNew = !fs.existsSync(targetPath);
+
+  let config = {};
+  if (!isNew) {
+    try {
+      config = JSON.parse(fs.readFileSync(targetPath, "utf8"));
+    } catch (e) {
+      logError(`⚠️ Unable to read ${path.basename(targetPath)} (Invalid JSON).`);
+      return;
+    }
+  }
+
+  config.compilerOptions = config.compilerOptions || {};
+  let changed = false;
+
+  const isReact = detectDependency(pkgPath, "react");
+
+  if (isNew) {
+    config.compilerOptions.checkJs = true;
+    config.compilerOptions.allowJs = true;
+    config.compilerOptions.target = config.compilerOptions.target || "ES2020";
+    config.compilerOptions.module = config.compilerOptions.module || "ESNext";
+    config.compilerOptions.moduleResolution = config.compilerOptions.moduleResolution || "bundler";
+    config.include = ["src/**/*"];
+    changed = true;
+  } else {
+    if (config.compilerOptions.checkJs === undefined) {
+      config.compilerOptions.checkJs = true;
+      changed = true;
+    }
+    if (config.compilerOptions.allowJs === undefined) {
+      config.compilerOptions.allowJs = true;
+      changed = true;
+    }
+  }
+
+  if (isReact && config.compilerOptions.jsx === undefined) {
+    config.compilerOptions.jsx = "react-jsx";
+    changed = true;
+  }
+
+  if (Array.isArray(config.compilerOptions.types) && config.compilerOptions.types.includes("vite/client")) {
+    config.compilerOptions.types = config.compilerOptions.types.filter((t) => t !== "vite/client");
+    if (config.compilerOptions.types.length === 0) {
+      delete config.compilerOptions.types;
+    }
+    changed = true;
+    log(`→ Removed legacy "vite/client" entry from ${path.basename(targetPath)}.`);
+  }
+
+  if (changed) {
+    fs.writeFileSync(targetPath, JSON.stringify(config, null, 2) + "\n");
+    log(`→ Updated ${path.basename(targetPath)}.`);
+  }
+}
+
+function injectNextAppRouterRuntime(projectRoot) {
+  const candidates = [
+    'src/app/layout.tsx', 'src/app/layout.jsx', 'src/app/layout.js',
+    'app/layout.tsx', 'app/layout.jsx', 'app/layout.js'
+  ];
+  const rel = candidates.find((p) => fs.existsSync(path.join(projectRoot, p)));
+  if (!rel) return false;
+
+  const layoutPath = path.join(projectRoot, rel);
+  const dir = path.dirname(layoutPath);
+  const isTs = rel.endsWith('.tsx');
+  const ext = isTs ? 'tsx' : 'jsx';
+
+  const clientSrc = isTs
+    ? `'use client';\nimport 'ozmoz';\n\ntype OzConfig = { prototype: boolean; dbKey?: string; enterpriseId?: string };\n\n// Fichier généré par ozmoZ : embarque le SDK dans le navigateur et lui transmet la config du .env.\nexport default function OzClient({ config }: { config: OzConfig }) {\n  Object.assign(globalThis, { OZ_CONFIG: config });\n  return null;\n}\n`
+    : `'use client';\nimport 'ozmoz';\n\n// Fichier généré par ozmoZ : embarque le SDK dans le navigateur et lui transmet la config du .env.\nexport default function OzClient({ config }) {\n  globalThis.OZ_CONFIG = config;\n  return null;\n}\n`;
+  const runtimeSrc = `import OzClient from './ozmoz-client';\n\n// Fichier généré par ozmoZ : lit le .env côté serveur (source de vérité) et le transmet au navigateur.\nexport default function OzRuntime() {\n  const config = {\n    prototype: process.env.OZ_PROTOTYPE === 'true',\n    dbKey: process.env.OZ_DB_KEY,\n    enterpriseId: process.env.OZ_ENTERPRISE_ID,\n  };\n  return <OzClient config={config} />;\n}\n`;
+
+  const clientPath = path.join(dir, `ozmoz-client.${ext}`);
+  const runtimePath = path.join(dir, `ozmoz-runtime.${ext}`);
+  if (!fs.existsSync(clientPath)) { fs.writeFileSync(clientPath, clientSrc); log(`→ Created ${path.relative(projectRoot, clientPath)}.`); }
+  if (!fs.existsSync(runtimePath)) { fs.writeFileSync(runtimePath, runtimeSrc); log(`→ Created ${path.relative(projectRoot, runtimePath)}.`); }
+
+  let content = fs.readFileSync(layoutPath, 'utf8');
+  if (content.includes('OzRuntime')) return true;
+
+  content = content.replace(/^import 'ozmoz';\r?\n/, '');
+
+  if (/^\s*['"]use client['"]/.test(content) || !/<body\b[^>]*>/.test(content)) {
+    logError(`⚠️ Could not wire ${path.relative(projectRoot, layoutPath)} automatically.`);
+    logError("👉 Add `import OzRuntime from './ozmoz-runtime';` and render <OzRuntime /> inside <body>.");
+    return true;
+  }
+  content = `import OzRuntime from './ozmoz-runtime';\n` + content;
+  content = content.replace(/(<body\b[^>]*>)/, '$1\n        <OzRuntime />');
+  fs.writeFileSync(layoutPath, content);
+  log(`→ Wired <OzRuntime /> into ${path.relative(projectRoot, layoutPath)}.`);
+  return true;
+}
+
+const BUNDLER_DEPS = [
+  'vite', 'next', 'nuxt', 'astro', 'webpack', 'parcel', 'rollup', 'esbuild', 'snowpack', 'react-scripts',
+  '@sveltejs/kit', '@angular/cli', '@vue/cli-service', 'gatsby', 'remix', '@remix-run/dev'
+];
+const BUNDLER_CONFIGS = [
+  'vite.config.js', 'vite.config.ts', 'vite.config.mjs', 'next.config.js', 'next.config.mjs', 'next.config.ts',
+  'webpack.config.js', 'svelte.config.js', 'nuxt.config.ts', 'nuxt.config.js', 'astro.config.mjs', 'angular.json'
+];
+
+function hasBundler(projectRoot) {
+  if (BUNDLER_CONFIGS.some((f) => fs.existsSync(path.join(projectRoot, f)))) return true;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
+    const deps = Object.assign({}, pkg.dependencies, pkg.devDependencies);
+    return BUNDLER_DEPS.some((d) => d in deps);
+  } catch (_) {
+    return false;
+  }
+}
+
+function parseDotEnv(envPath) {
+  const out = {};
+  if (!fs.existsSync(envPath)) return out;
+  for (const line of fs.readFileSync(envPath, 'utf8').split(/\r?\n/)) {
+    const m = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*?)\s*$/);
+    if (m) out[m[1]] = m[2].replace(/^['"]|['"]$/g, '');
+  }
+  return out;
+}
+
+function writeBrowserConfig(projectRoot) {
+  if (hasBundler(projectRoot)) return false;
+  const htmlDir = ['.', 'public'].find((d) => fs.existsSync(path.join(projectRoot, d, 'index.html')));
+  if (htmlDir === undefined) return false;
+
+  const env = parseDotEnv(path.join(projectRoot, '.env'));
+  const config = {
+    prototype: env.OZ_PROTOTYPE === 'true',
+    dbKey: env.OZ_DB_KEY || '',
+    enterpriseId: env.OZ_ENTERPRISE_ID || ''
+  };
+  const target = path.join(projectRoot, htmlDir, 'ozmoz.config.js');
+  const body =
+    '// Généré par `npx ozmoz init` / `sync` depuis le .env : NE PAS MODIFIER À LA MAIN.\n' +
+    '// À charger AVANT le SDK : <script src="ozmoz.config.js"></script>\n' +
+    'window.OZ_CONFIG = ' + JSON.stringify(config, null, 2) + ';\n';
+  if (fs.existsSync(target) && fs.readFileSync(target, 'utf8') === body) return true;
+  fs.writeFileSync(target, body);
+  log(`→ Wrote ${path.join(htmlDir, 'ozmoz.config.js')} from .env (no bundler detected).`);
+  return true;
+}
+
+function injectUniversalRuntime(projectRoot) {
+  if (injectNextAppRouterRuntime(projectRoot)) return;
+
+  const entryFiles = [
+    'src/app/layout.tsx', 'src/app/layout.jsx', 'app/layout.tsx', 'app/layout.jsx',
+    'src/pages/_app.tsx', 'src/pages/_app.jsx', 'pages/_app.tsx', 'pages/_app.jsx',
+    'src/main.tsx', 'src/main.jsx', 'src/main.ts', 'src/main.js',
+    'src/index.tsx', 'src/index.jsx', 'src/index.ts', 'src/index.js',
+    'src/App.tsx', 'src/App.jsx', 'src/App.vue',
+    'app.vue', 'src/routes/+layout.svelte', 'src/routes/+layout.ts',
+    'src/main.singletons.ts'
+  ];
+
+  for (const relPath of entryFiles) {
+    const fullPath = path.join(projectRoot, relPath);
+    if (fs.existsSync(fullPath)) {
+      let content = fs.readFileSync(fullPath, 'utf8');
+      if (!content.includes('ozmoz')) {
+        if (content.startsWith('"use client"') || content.startsWith("'use client'")) {
+          content = content.replace(/(['"]use client['"];?\r?\n)/, `$1import 'ozmoz';\n`);
+        } else {
+          content = `import 'ozmoz';\n` + content;
+        }
+        fs.writeFileSync(fullPath, content);
+      }
+      return;
+    }
+  }
+}
+
+const SYNC_HANDLER_V2 = `      configureServer(server) {
+        // ozmoZ sync handler: la synchronisation ne bloque plus le dev server
+        let syncing = false;
+        let pending = false;
+        const runSync = async () => {
+          if (syncing) { pending = true; return; }
+          syncing = true;
+          try {
+            const fs = await import('node:fs');
+            const path = await import('node:path');
+            const { spawn } = await import('node:child_process');
+            const localCli = path.join(process.cwd(), 'node_modules', 'ozmoz', 'dist', 'cli.cjs');
+            const child = fs.existsSync(localCli)
+              ? spawn(process.execPath, [localCli, 'sync'], { stdio: 'ignore' })
+              : spawn('npx', ['--no-install', 'ozmoz', 'sync'], { stdio: 'ignore', shell: process.platform === 'win32' });
+            child.on('error', () => { syncing = false; });
+            child.on('exit', () => { syncing = false; if (pending) { pending = false; runSync(); } });
+          } catch (_) { syncing = false; }
+        };
+        server.middlewares.use('/__ozmoz_sync_schema', (req, res) => {
+          if (req.method !== 'POST') { res.writeHead(405).end(); return; }
+          let body = '';
+          req.on('data', (chunk) => { body += chunk; });
+          req.on('end', async () => {
+            try {
+              const { schema } = JSON.parse(body);
+              let queued = false;
+              if (schema) {
+                const fs = await import('node:fs');
+                const path = await import('node:path');
+                const schemaPath = path.join(process.cwd(), 'svro.schema.json');
+                let localVersion = 0;
+                try { localVersion = Number(JSON.parse(fs.readFileSync(schemaPath, 'utf8')).schemaVersion) || 0; } catch (_) {}
+                if ((Number(schema.schemaVersion) || 0) > localVersion) {
+                  fs.writeFileSync(schemaPath, JSON.stringify(schema, null, 2) + '\\n');
+                  queued = true;
+                  runSync();
+                }
+              }
+              res.writeHead(200, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ success: true, queued }));
+            } catch (e) {
+              res.writeHead(500, { 'Content-Type': 'application/json' });
+              res.end(JSON.stringify({ success: false, error: e.message }));
+            }
+          });
+        });
+      }`;
+
+function attemptViteAutoImportPatch(projectRoot, pkgPath) {
+  if (process.env.FLEETBO_SKIP_AUTOIMPORT_SETUP) return;
+
+  const candidates = ["vite.config.ts", "vite.config.js", "vite.config.mjs"];
+  let found = candidates.map(f => path.join(projectRoot, f)).find(p => fs.existsSync(p));
+  if (!found) {
+    // A plain `npm create vite` project has no vite.config file. Create a minimal one,
+    // otherwise envPrefix is never set and the OZ_* variables stay invisible in the browser.
+    if (!detectDependency(pkgPath, "vite") || detectDependency(pkgPath, "next")) return;
+    let isEsm = false;
+    try { isEsm = JSON.parse(fs.readFileSync(pkgPath, "utf8")).type === "module"; } catch (_) {}
+    found = path.join(projectRoot, isEsm ? "vite.config.js" : "vite.config.mjs");
+    fs.writeFileSync(found, "import { defineConfig } from 'vite';\n\nexport default defineConfig({\n  plugins: [],\n});\n");
+    log("→ Created " + path.basename(found) + " (none found) so the OZ_* variables reach the browser.");
+  }
+
+  let content;
+  try {
+    content = fs.readFileSync(found, "utf8");
+  } catch (e) {
+    return;
+  }
+
+  const importSource = "ozmoz";
+  let patched = content;
+
+  // Configuration de envPrefix pour rendre OZ_ accessible côté client dans import.meta.env
+  if (!patched.includes("envPrefix") && patched.includes("defineConfig({")) {
+    patched = patched.replace(
+      "defineConfig({",
+      "defineConfig({\n  envPrefix: ['VITE_', 'OZ_'],"
+    );
+  }
+
+  const autoRuntimePlugin = `{
+      name: 'ozmoz-auto-runtime',
+      transform(code, id) {
+        if (!id.includes('node_modules') && !code.includes('ozmoz') && /(src[\\\\/](main|index|App|root))\\.(jsx?|tsx?)(?:$|\\?)/i.test(id)) {
+          return {
+            code: "import 'ozmoz';\\n" + code,
+            map: null
+          };
+        }
+        return null;
+      },
+${SYNC_HANDLER_V2}
+    },`;
+
+  if (!patched.includes("svro.schema.json")) {
+    if (patched.includes("server:")) {
+      if (patched.includes("watch:")) {
+        patched = patched.replace(
+          /watch\s*:\s*\{/,
+          `watch: {\n      ignored: ['**/svro.schema.json', '**/src/auto-imports.d.ts'],`
+        );
+      } else {
+        patched = patched.replace(
+          /server\s*:\s*\{/,
+          `server: {\n    watch: {\n      ignored: ['**/svro.schema.json', '**/src/auto-imports.d.ts']\n    },`
+        );
+      }
+    } else if (patched.includes("defineConfig({")) {
+      patched = patched.replace(
+        "defineConfig({",
+        `defineConfig({\n  server: {\n    watch: {\n      ignored: ['**/svro.schema.json', '**/src/auto-imports.d.ts']\n    }\n  },`
+      );
+    }
+  }
+
+  if (!patched.includes("ozmoz-auto-runtime")) {
+    const pluginsArrayMatch = patched.match(/plugins\s*:\s*\[/);
+    if (pluginsArrayMatch) {
+      const insertIndex = pluginsArrayMatch.index + pluginsArrayMatch[0].length;
+      patched = patched.slice(0, insertIndex) + "\n    " + autoRuntimePlugin + patched.slice(insertIndex);
+    }
+  }
+
+  patched = patched.replace('(jsx?|tsx?|vue|svelte)/i.test(id)', () => '(jsx?|tsx?)(?:$|\\?)/i.test(id)');
+
+  if (patched !== content) {
+    fs.writeFileSync(found, patched);
+  }
+
+}
+
+function ensureVscodeCyanHints(projectRoot) {
+  const vscodeDir = path.join(projectRoot, ".vscode");
+  const settingsPath = path.join(vscodeDir, "settings.json");
+
+  try {
+    if (!fs.existsSync(vscodeDir)) {
+      fs.mkdirSync(vscodeDir, { recursive: true });
+    }
+
+    let settings = {};
+    if (fs.existsSync(settingsPath)) {
+      try {
+        settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+      } catch (_) {
+        settings = {};
+      }
+    }
+
+    settings["workbench.colorCustomizations"] = settings["workbench.colorCustomizations"] || {};
+    settings["workbench.colorCustomizations"]["editorInfo.foreground"] = "#00feae";
+    settings["workbench.colorCustomizations"]["editorHint.foreground"] = "#00feae";
+
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    log("→ Configured ozmoZ Cyan visual hints in .vscode/settings.json.");
+  } catch (e) {}
+}
+
+function patchAllowScripts(projectRoot) {
+  const pkgPath = path.join(projectRoot, "package.json");
+  if (!fs.existsSync(pkgPath)) return;
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    pkg.allowScripts = pkg.allowScripts || {};
+    if (pkg.allowScripts["fsevents"] === true) return;
+
+    pkg.allowScripts["fsevents"] = true;
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf8");
+    log("→ Silenced native build warnings (fsevents) in package.json.");
+  } catch (e) {}
+}
+
+function runFullSetup(projectRoot, pkgPath, options = {}) {
+  const { skipSelfInstall = false } = options;
+  const packageRoot = path.join(__dirname, "..");
+  if (!skipSelfInstall) {
+    installPackageIfMissing(projectRoot, pkgPath);
+  }
+  ensureSchemaFile(projectRoot);
+  ensureEnvPrototype(projectRoot);
+  ensureDts(packageRoot);
+  ensureAutoImportsDts(projectRoot);
+  ensureVscodeCyanHints(projectRoot); 
+  cleanupLegacyRootDts(projectRoot);
+  patchJsOrTsConfig(projectRoot, pkgPath);
+  attemptViteAutoImportPatch(projectRoot, pkgPath);
+  injectUniversalRuntime(projectRoot);
+  writeBrowserConfig(projectRoot);
+  patchAllowScripts(projectRoot);
+}
+
+module.exports = {
+  touchTsConfig,
+  log,
+  logError,
+  handleAuthAndEnv,
+  detectDependency,
+  cleanupLegacyRootDts,
+  patchJsOrTsConfig,
+  attemptViteAutoImportPatch,
+  injectUniversalRuntime,
+  injectNextAppRouterRuntime,
+  writeBrowserConfig,
+  runFullSetup,
+  patchAllowScripts
+};