qarpeo 0.0.0-alpha.10

package/dist/cli/index.mjs

@@ -0,0 +1,1085 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from 'citty';
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, writeFileSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import { loadNuxtConfig } from '@nuxt/kit';
+import { resolve, join } from 'pathe';
+import { f as findSchemaFiles, r as resolveBinaryPath, e as ensurePackage, g as getLocalDatabaseContext, a as getJiti, b as resolveProjectName, c as checkDrizzleVersion, d as findLocalD1Database } from '../chunks/wrangler.mjs';
+import { reset, seed } from 'drizzle-seed';
+import 'node:module';
+import 'drizzle-orm/node-sqlite';
+import 'node:process';
+import 'node:readline/promises';
+import 'node:url';
+import 'node:fs/promises';
+import 'defu';
+
+const generate = defineCommand({
+  meta: {
+    name: "generate",
+    description: "Generate SQL migrations from your Drizzle database schema"
+  },
+  args: {
+    name: {
+      type: "string",
+      description: "Migration file name (e.g. --name add_users)"
+    },
+    custom: {
+      type: "boolean",
+      description: "Create an empty custom SQL migration file",
+      default: false
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory",
+      default: "."
+    }
+  },
+  async run({ args }) {
+    const cwd = resolve(process.cwd(), args.cwd);
+    console.log("\u26A1 [qarpeo] Preparing database schema for migration generation...");
+    const nuxtConfig = await loadNuxtConfig({ cwd });
+    const layers = nuxtConfig._layers || [{ cwd, config: nuxtConfig }];
+    const schemaFiles = findSchemaFiles(layers);
+    if (schemaFiles.length === 0) {
+      console.error(
+        "\u274C [qarpeo] No database schema files found. Create a schema file at server/db/schema.ts first."
+      );
+      process.exit(1);
+    }
+    const qarpeoDir = resolve(cwd, ".qarpeo");
+    const schemaPath = resolve(qarpeoDir, "schema.ts");
+    if (!existsSync(qarpeoDir)) {
+      mkdirSync(qarpeoDir, { recursive: true });
+    }
+    const schemaLines = ["// Auto-generated by qarpeo across all Nuxt layers"];
+    const nuxtDir = resolve(cwd, ".nuxt/qarpeo");
+    const builtInSchemas = [
+      { name: "auth", path: resolve(nuxtDir, "auth-schema.ts") },
+      { name: "cms", path: resolve(nuxtDir, "cms-schema.ts") },
+      { name: "payments", path: resolve(nuxtDir, "payments-schema.ts") },
+      { name: "tenants", path: resolve(nuxtDir, "tenants-schema.ts") }
+    ];
+    for (const s of builtInSchemas) {
+      if (existsSync(s.path)) {
+        schemaLines.push(`export * from "${s.path.replace(/\\/g, "/").replace(/\.ts$/, "")}";`);
+      }
+    }
+    for (const f of schemaFiles) {
+      schemaLines.push(`export * from "${f.replace(/\\/g, "/").replace(/\.ts$/, "")}";`);
+    }
+    const schemaContent = schemaLines.join("\n");
+    writeFileSync(schemaPath, schemaContent, "utf-8");
+    const serverDir = nuxtConfig.serverDir || resolve(nuxtConfig.rootDir || cwd, "server");
+    const migrationsDir = resolve(serverDir, "db/migrations");
+    if (!existsSync(migrationsDir)) {
+      mkdirSync(migrationsDir, { recursive: true });
+    }
+    console.log(`\u{1F4E6} [qarpeo] Discovered ${schemaFiles.length} schema file(s):`);
+    for (const f of schemaFiles) {
+      console.log(`   - ${f}`);
+    }
+    const drizzleKitArgs = [
+      "generate",
+      "--dialect",
+      "sqlite",
+      "--schema",
+      schemaPath,
+      "--out",
+      migrationsDir
+    ];
+    if (args.name) {
+      drizzleKitArgs.push("--name", args.name);
+    }
+    if (args.custom) {
+      drizzleKitArgs.push("--custom");
+    }
+    let execPath = resolveBinaryPath("drizzle-kit", cwd);
+    if (!execPath) {
+      const ok = await ensurePackage("drizzle-kit@1.0.0-rc.5", {
+        cwd,
+        dev: true,
+        purpose: "generating database migrations"
+      });
+      if (!ok) {
+        process.exit(1);
+      }
+      execPath = resolveBinaryPath("drizzle-kit", cwd) || (process.platform === "win32" ? "drizzle-kit.cmd" : "drizzle-kit");
+    }
+    console.log("\u{1F680} [qarpeo] Running drizzle-kit generate...");
+    const result = spawnSync(execPath, drizzleKitArgs, {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+      // .cmd files require shell:true on Windows
+    });
+    if (result.status !== 0) {
+      process.exit(result.status ?? 1);
+    }
+    console.log(`\u2705 [qarpeo] Migrations successfully generated in: ${migrationsDir}`);
+  }
+});
+
+const cleanCommand = defineCommand({
+  meta: {
+    name: "clean",
+    description: "Clean/truncate all tables in local Cloudflare D1 database (reset data)"
+  },
+  args: {
+    remote: {
+      type: "boolean",
+      description: "Restricted \u2014 database cleaning is blocked on production to prevent data loss",
+      default: false
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory",
+      default: "."
+    }
+  },
+  async run({ args }) {
+    if (args.remote) {
+      console.error(
+        "\u274C [qarpeo] `qp db:clean` is restricted to local development to protect production data (Decision 15)."
+      );
+      process.exit(1);
+    }
+    const cwd = resolve(process.cwd(), args.cwd);
+    const nuxtConfig = await loadNuxtConfig({ cwd });
+    console.log("\u23F3 [qarpeo] Connecting to local D1 database...");
+    let ctx;
+    try {
+      ctx = await getLocalDatabaseContext(cwd, nuxtConfig);
+    } catch (err) {
+      console.error(`\u274C [qarpeo] ${err?.message || err}`);
+      process.exit(1);
+    }
+    const { db, schema, sqlitePath } = ctx;
+    try {
+      console.log("\u23F3 [qarpeo] Resetting tables with drizzle-seed...");
+      await reset(db, schema);
+      console.log(
+        `\u2705 [qarpeo] Local D1 database cleanly reset (0 rows across all tables): ${sqlitePath}`
+      );
+    } catch (err) {
+      console.error(`\u274C [qarpeo] Failed to reset database: ${err?.message || err}`);
+      process.exit(1);
+    }
+  }
+});
+
+const migrate = defineCommand({
+  meta: {
+    name: "migrate",
+    description: "Apply database migrations to Cloudflare D1 (local or remote)"
+  },
+  args: {
+    remote: {
+      type: "boolean",
+      description: "Apply migrations to remote Cloudflare D1 database (production)",
+      default: false
+    },
+    prune: {
+      type: "boolean",
+      description: "Safely drop deprecated _qarpeo_* auth tables when corresponding features are disabled in nuxt.config.ts",
+      default: false
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory",
+      default: "."
+    }
+  },
+  async run({ args }) {
+    const cwd = resolve(process.cwd(), args.cwd);
+    const nuxtConfig = await loadNuxtConfig({ cwd });
+    const qarpeoOpts = nuxtConfig.qarpeo || {};
+    const dbOpts = typeof qarpeoOpts.db === "object" ? qarpeoOpts.db : {};
+    const dbBinding = dbOpts.binding || process.env.QARPEO_DB_BINDING || "DB";
+    const dbName = dbBinding;
+    console.log(
+      `\u26A1 [qarpeo] Applying migrations to Cloudflare D1 (${args.remote ? "remote" : "local dev"})...`
+    );
+    let execPath = resolveBinaryPath("wrangler", cwd);
+    if (!execPath) {
+      const ok = await ensurePackage("wrangler", {
+        cwd,
+        dev: true,
+        purpose: "applying Cloudflare D1 migrations"
+      });
+      if (!ok) {
+        process.exit(1);
+      }
+      execPath = resolveBinaryPath("wrangler", cwd) || (process.platform === "win32" ? "wrangler.cmd" : "wrangler");
+    }
+    let wranglerConfigPath = null;
+    if (existsSync(resolve(cwd, "wrangler.jsonc"))) {
+      wranglerConfigPath = resolve(cwd, "wrangler.jsonc");
+    } else if (existsSync(resolve(cwd, "wrangler.json"))) {
+      wranglerConfigPath = resolve(cwd, "wrangler.json");
+    } else if (existsSync(resolve(cwd, ".nuxt/wrangler.json"))) {
+      wranglerConfigPath = resolve(cwd, ".nuxt/wrangler.json");
+    } else {
+      const { generateDevWranglerConfig } = await import('../chunks/wrangler.mjs').then(function (n) { return n.w; });
+      const buildDir = resolve(cwd, ".nuxt");
+      wranglerConfigPath = await generateDevWranglerConfig(
+        {
+          options: {
+            ...nuxtConfig,
+            rootDir: cwd,
+            buildDir
+          }
+        },
+        {
+          ...qarpeoOpts,
+          db: qarpeoOpts.db ?? true
+        }
+      );
+    }
+    const wranglerArgs = ["d1", "migrations", "apply", dbName];
+    if (wranglerConfigPath) {
+      wranglerArgs.push("-c", wranglerConfigPath);
+    }
+    if (args.remote) {
+      wranglerArgs.push("--remote");
+    } else {
+      wranglerArgs.push("--local", "--persist-to", resolve(cwd, ".wrangler/state"));
+    }
+    console.log(`\u{1F680} [qarpeo] Running: wrangler ${wranglerArgs.join(" ")}`);
+    const result = spawnSync(execPath, wranglerArgs, {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+      // .cmd files require shell:true on Windows
+    });
+    if (result.status !== 0) {
+      process.exit(result.status ?? 1);
+    }
+    console.log(`\u2705 [qarpeo] Migrations applied successfully!`);
+    if (args.prune) {
+      const { getActiveAuthTableNames, ALL_AUTH_TABLE_NAMES } = await import('../chunks/auth-schema.mjs');
+      const { findLocalD1Database } = await import('../chunks/wrangler.mjs').then(function (n) { return n.n; });
+      const authConfig = nuxtConfig.qarpeo?.auth || nuxtConfig.auth;
+      const activeTables = getActiveAuthTableNames(authConfig);
+      const deprecatedTables = ALL_AUTH_TABLE_NAMES.filter(
+        (tbl) => !activeTables.includes(tbl)
+      );
+      if (deprecatedTables.length > 0) {
+        console.log(`
+\u{1F9F9} [qarpeo] Checking for deprecated auth tables to prune...`);
+        if (!args.remote) {
+          const sqlitePath = findLocalD1Database(cwd);
+          if (sqlitePath) {
+            try {
+              const { DatabaseSync } = await import('node:sqlite');
+              const sqlite = new DatabaseSync(sqlitePath);
+              for (const tbl of deprecatedTables) {
+                try {
+                  sqlite.exec(`DROP TABLE IF EXISTS ${tbl};`);
+                  console.log(`  \u2713 Dropped table: ${tbl}`);
+                } catch {
+                }
+              }
+              sqlite.close();
+              console.log(`\u2705 [qarpeo] Local auth tables pruned successfully.`);
+            } catch (err) {
+              console.warn(`  \u26A0\uFE0F Could not prune local tables: ${err.message}`);
+            }
+          }
+        } else {
+          for (const tbl of deprecatedTables) {
+            const dropArgs = [
+              "d1",
+              "execute",
+              dbName,
+              "--remote",
+              `--command=DROP TABLE IF EXISTS ${tbl};`
+            ];
+            if (wranglerConfigPath) dropArgs.push("-c", wranglerConfigPath);
+            spawnSync(execPath, dropArgs, { cwd, stdio: "inherit", shell: process.platform === "win32" });
+            console.log(`  \u2713 Dropped remote table: ${tbl}`);
+          }
+          console.log(`\u2705 [qarpeo] Remote auth tables pruned successfully.`);
+        }
+      } else {
+        console.log(`\u2728 [qarpeo] All auth tables are active. Nothing to prune.`);
+      }
+    }
+  }
+});
+
+const push = defineCommand({
+  meta: {
+    name: "push",
+    description: "Directly push schema changes to local D1 SQLite database (prototyping)"
+  },
+  args: {
+    force: {
+      type: "boolean",
+      description: "Auto-approve all statements",
+      default: false
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory",
+      default: "."
+    }
+  },
+  async run({ args }) {
+    const cwd = resolve(process.cwd(), args.cwd);
+    console.log("\u26A1 [qarpeo] Preparing database schema for push...");
+    const nuxtConfig = await loadNuxtConfig({ cwd });
+    const layers = nuxtConfig._layers || [{ cwd, config: nuxtConfig }];
+    const schemaFiles = findSchemaFiles(layers);
+    if (schemaFiles.length === 0) {
+      console.error("\u274C [qarpeo] No schema files found in server/db/schema.ts");
+      process.exit(1);
+    }
+    const qarpeoDir = resolve(cwd, ".qarpeo");
+    const schemaPath = resolve(qarpeoDir, "schema.ts");
+    if (!existsSync(qarpeoDir)) {
+      mkdirSync(qarpeoDir, { recursive: true });
+    }
+    const schemaContent = [
+      "// Auto-generated by qarpeo across all Nuxt layers",
+      ...schemaFiles.map((f) => `export * from "${f.replace(/\\/g, "/").replace(/\.ts$/, "")}";`)
+    ].join("\n");
+    writeFileSync(schemaPath, schemaContent, "utf-8");
+    let execPath = resolveBinaryPath("drizzle-kit", cwd);
+    if (!execPath) {
+      const ok = await ensurePackage("drizzle-kit@1.0.0-rc.5", {
+        cwd,
+        dev: true,
+        purpose: "pushing schema changes to SQLite"
+      });
+      if (!ok) {
+        process.exit(1);
+      }
+      execPath = resolveBinaryPath("drizzle-kit", cwd) || (process.platform === "win32" ? "drizzle-kit.cmd" : "drizzle-kit");
+    }
+    const drizzleArgs = ["push", "--dialect", "sqlite", "--schema", schemaPath];
+    if (args.force) {
+      drizzleArgs.push("--force");
+    }
+    console.log("\u{1F680} [qarpeo] Running drizzle-kit push...");
+    const result = spawnSync(execPath, drizzleArgs, {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+      // .cmd files require shell:true on Windows
+    });
+    if (result.status !== 0) {
+      process.exit(result.status ?? 1);
+    }
+    console.log("\u2705 [qarpeo] Schema push completed!");
+  }
+});
+
+const seedCommand = defineCommand({
+  meta: {
+    name: "seed",
+    description: "Seed local Cloudflare D1 database with mock data or custom seed script"
+  },
+  args: {
+    clean: {
+      type: "boolean",
+      description: "Clean/truncate existing records before seeding",
+      default: false
+    },
+    reset: {
+      type: "boolean",
+      description: "Alias for --clean",
+      default: false
+    },
+    count: {
+      type: "string",
+      description: "Number of mock rows to generate per table (defaults to 10)",
+      default: "10"
+    },
+    seedNumber: {
+      type: "string",
+      description: "Optional deterministic seed number for reproducible data"
+    },
+    remote: {
+      type: "boolean",
+      description: "Restricted \u2014 seeding is blocked on production to prevent data loss",
+      default: false
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory",
+      default: "."
+    }
+  },
+  async run({ args }) {
+    if (args.remote) {
+      console.error(
+        "\u274C [qarpeo] `qp db:seed` is restricted to local development to protect production data (Decision 15)."
+      );
+      process.exit(1);
+    }
+    const cwd = resolve(process.cwd(), args.cwd);
+    const nuxtConfig = await loadNuxtConfig({ cwd });
+    console.log("\u{1F331} [qarpeo] Preparing database for seeding...");
+    let ctx;
+    try {
+      ctx = await getLocalDatabaseContext(cwd, nuxtConfig);
+    } catch (err) {
+      console.error(`\u274C [qarpeo] ${err?.message || err}`);
+      process.exit(1);
+    }
+    const { db, schema, customSeedPath, sqlitePath } = ctx;
+    const shouldClean = Boolean(args.clean || args.reset);
+    if (shouldClean) {
+      console.log("\u23F3 [qarpeo] Resetting existing records...");
+      await reset(db, schema);
+      console.log("\u2714 [qarpeo] Existing tables cleanly truncated.");
+    }
+    if (customSeedPath) {
+      console.log(`\u{1F680} [qarpeo] Running custom seed script: ${customSeedPath}`);
+      try {
+        const jiti = await getJiti(cwd);
+        const userSeed = await jiti.import(customSeedPath);
+        const seedFn = userSeed.default || userSeed.seed || userSeed;
+        if (typeof seedFn === "function") {
+          await seedFn({ db, schema, seed, reset });
+          console.log("\u2705 [qarpeo] Custom seed script completed successfully!");
+          return;
+        } else {
+          console.log(
+            "\u2139 [qarpeo] Custom seed script does not export a default function. Falling back to drizzle-seed."
+          );
+        }
+      } catch (err) {
+        console.error(`\u274C [qarpeo] Error running custom seed script: ${err?.message || err}`);
+        process.exit(1);
+      }
+    }
+    const count = parseInt(args.count || "10", 10);
+    const seedNumber = args.seedNumber ? parseInt(args.seedNumber, 10) : void 0;
+    console.log(`\u{1F331} [qarpeo] Generating mock data with drizzle-seed (${count} rows per table)...`);
+    try {
+      await seed(db, schema, {
+        count,
+        seed: seedNumber
+      });
+      console.log(`\u2705 [qarpeo] Successfully seeded local D1 database: ${sqlitePath}`);
+    } catch (err) {
+      console.error(`\u274C [qarpeo] Error during drizzle-seed: ${err?.message || err}`);
+      process.exit(1);
+    }
+  }
+});
+
+const db = defineCommand({
+  meta: {
+    name: "db",
+    description: "Manage Cloudflare D1 database, Drizzle ORM migrations, and seeding"
+  },
+  subCommands: {
+    generate,
+    migrate,
+    push,
+    seed: seedCommand,
+    clean: cleanCommand,
+    reset: cleanCommand
+  }
+});
+
+function loadDotEnv(cwd) {
+  const envPath = join(cwd, ".env");
+  if (!existsSync(envPath)) return;
+  try {
+    const raw = readFileSync(envPath, "utf8");
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      const key = trimmed.slice(0, eqIdx).trim();
+      let val = trimmed.slice(eqIdx + 1).trim();
+      if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+        val = val.slice(1, -1);
+      }
+      if (process.env[key] === void 0) {
+        process.env[key] = val;
+      }
+    }
+  } catch {
+  }
+}
+const doctor = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Validate Wrangler config, Cloudflare bindings, migrations, and security before deploy"
+  },
+  args: {
+    remote: {
+      type: "boolean",
+      description: "Validate against Cloudflare production/remote deployment criteria",
+      default: false
+    },
+    cwd: {
+      type: "string",
+      description: "Working directory",
+      default: "."
+    }
+  },
+  async run({ args }) {
+    const cwd = resolve(process.cwd(), args.cwd);
+    loadDotEnv(cwd);
+    const isRemote = Boolean(args.remote);
+    const categories = [];
+    console.log(`
+\u26A1 Qarpeo Doctor \u2014 System & Deployment Readiness`);
+    console.log(`   Working directory: ${cwd}`);
+    console.log(
+      `   Target mode:       ${isRemote ? "\u2601\uFE0F  Production (--remote)" : "\u{1F4BB} Local Development"}
+`
+    );
+    const envItems = [];
+    const nodeVer = process.version;
+    const major = parseInt(nodeVer.replace(/^v/, "").split(".")[0] || "0", 10);
+    if (major >= 20) {
+      envItems.push({
+        status: "pass",
+        title: "Node.js Version",
+        message: `${nodeVer} (compatible)`
+      });
+    } else if (major >= 18) {
+      envItems.push({
+        status: "warn",
+        title: "Node.js Version",
+        message: `${nodeVer} (Node 20+ strongly recommended for Cloudflare Workers compatibility)`
+      });
+    } else {
+      envItems.push({
+        status: "fail",
+        title: "Node.js Version",
+        message: `${nodeVer} (unsupported \u2014 requires Node 18.20.0+ or Node 20+)`,
+        help: "Upgrade your Node.js runtime."
+      });
+    }
+    const wranglerBin = resolveBinaryPath("wrangler", cwd);
+    if (wranglerBin) {
+      try {
+        const proc = process.platform === "win32" ? spawnSync(`"${wranglerBin}" --version`, {
+          cwd,
+          encoding: "utf8",
+          shell: true
+        }) : spawnSync(wranglerBin, ["--version"], {
+          cwd,
+          encoding: "utf8"
+        });
+        const out = proc.stdout ? proc.stdout.trim() : "";
+        envItems.push({
+          status: "pass",
+          title: "Wrangler CLI",
+          message: out || "installed"
+        });
+      } catch {
+        envItems.push({
+          status: "pass",
+          title: "Wrangler CLI",
+          message: "installed"
+        });
+      }
+    } else {
+      envItems.push({
+        status: isRemote ? "fail" : "warn",
+        title: "Wrangler CLI",
+        message: "Not found locally in node_modules or PATH",
+        help: "Install wrangler as a dev dependency: pnpm add -D wrangler"
+      });
+    }
+    categories.push({
+      title: "Environment & Tooling",
+      icon: "\u{1F6E0}\uFE0F ",
+      items: envItems
+    });
+    const configItems = [];
+    let nuxtConfig = null;
+    try {
+      nuxtConfig = await loadNuxtConfig({ cwd });
+      configItems.push({
+        status: "pass",
+        title: "Nuxt Configuration",
+        message: "nuxt.config successfully loaded"
+      });
+    } catch (err) {
+      configItems.push({
+        status: "fail",
+        title: "Nuxt Configuration",
+        message: `Failed to load nuxt.config: ${err.message}`,
+        help: "Check nuxt.config.ts for syntax errors or invalid imports."
+      });
+    }
+    const qarpeoConfig = nuxtConfig?.qarpeo || {};
+    const modules = nuxtConfig?.modules || [];
+    const hasQarpeo = modules.some(
+      (m) => typeof m === "string" ? m === "qarpeo" || m.includes("qarpeo") || m.includes("src/module") || m.includes("dist/module") : m?.name === "qarpeo" || m?.name?.includes("qarpeo")
+    ) || Boolean(nuxtConfig?.qarpeo);
+    if (hasQarpeo) {
+      configItems.push({
+        status: "pass",
+        title: "Module Registration",
+        message: "'qarpeo' is registered in nuxt.config modules"
+      });
+    } else {
+      configItems.push({
+        status: "fail",
+        title: "Module Registration",
+        message: "'qarpeo' is not registered in modules array",
+        help: "Add 'qarpeo' to the `modules` list in nuxt.config.ts."
+      });
+    }
+    if (qarpeoConfig.cf) {
+      configItems.push({
+        status: "warn",
+        title: "Legacy Config: `cf`",
+        message: "Deprecated 'qarpeo.cf' object detected. Options have moved directly to top-level 'qarpeo: {}'",
+        help: "Replace 'qarpeo: { cf: { ... } }' with top-level keys like 'qarpeo: { db: true, kv: true }'."
+      });
+    }
+    if (qarpeoConfig.storage) {
+      configItems.push({
+        status: "warn",
+        title: "Deprecated Option: `storage`",
+        message: "'storage' option is deprecated. Use 'blob' instead.",
+        help: "Replace 'qarpeo: { storage: true }' with 'qarpeo: { blob: true }'."
+      });
+    }
+    const featureKeys = [
+      "db",
+      "blob",
+      "kv",
+      "auth",
+      "cms",
+      "realtime",
+      "payments",
+      "ai",
+      "vectorize",
+      "queue",
+      "analytics",
+      "ratelimit",
+      "hyperdrive",
+      "browser",
+      "do",
+      "cron",
+      "email",
+      "multitenant"
+    ];
+    const enabledFeatures = featureKeys.filter((k) => Boolean(qarpeoConfig[k]));
+    configItems.push({
+      status: "info",
+      title: "Active Features",
+      message: enabledFeatures.length > 0 ? enabledFeatures.join(", ") : "None explicitly enabled (running bare runtime)"
+    });
+    const projectName = resolveProjectName({ options: { ...nuxtConfig, rootDir: cwd } }, qarpeoConfig);
+    configItems.push({
+      status: "info",
+      title: "Project / Worker Name",
+      message: projectName
+    });
+    categories.push({
+      title: "Nuxt & Qarpeo Configuration",
+      icon: "\u2699\uFE0F ",
+      items: configItems
+    });
+    const bindingItems = [];
+    let wranglerPath = null;
+    for (const f of ["wrangler.jsonc", "wrangler.json", ".nuxt/wrangler.json"]) {
+      const p = resolve(cwd, f);
+      if (existsSync(p)) {
+        wranglerPath = p;
+        break;
+      }
+    }
+    if (wranglerPath) {
+      bindingItems.push({
+        status: "pass",
+        title: "Wrangler Configuration",
+        message: `Found ${join(".", wranglerPath.replace(cwd, "")).replace(/^[\\/]/, "")}`
+      });
+    } else {
+      bindingItems.push({
+        status: "info",
+        title: "Wrangler Configuration",
+        message: "No root wrangler.json found; Qarpeo generates .nuxt/wrangler.json automatically on dev/build"
+      });
+    }
+    const cfAccountId = process.env.CLOUDFLARE_ACCOUNT_ID || process.env.CF_ACCOUNT_ID;
+    if (cfAccountId && cfAccountId !== "dummy-dev-account-id") {
+      bindingItems.push({
+        status: "pass",
+        title: "Cloudflare Account ID",
+        message: `Configured (${cfAccountId.slice(0, 6)}...${cfAccountId.slice(-4)})`
+      });
+    } else if (isRemote) {
+      bindingItems.push({
+        status: "fail",
+        title: "Cloudflare Account ID",
+        message: "CLOUDFLARE_ACCOUNT_ID is missing or set to a placeholder",
+        help: "Set CLOUDFLARE_ACCOUNT_ID in your environment or .env file before deploying to production."
+      });
+    } else {
+      bindingItems.push({
+        status: "info",
+        title: "Cloudflare Account ID",
+        message: "Local dev uses Miniflare emulation (no account ID required)"
+      });
+    }
+    const isDbEnabled = Boolean(qarpeoConfig.db || qarpeoConfig.d1 || qarpeoConfig.cms || qarpeoConfig.auth || qarpeoConfig.payments);
+    if (isDbEnabled) {
+      const dbBinding = typeof qarpeoConfig.db === "object" && qarpeoConfig.db?.binding ? qarpeoConfig.db.binding : process.env.QARPEO_DB_BINDING || "DB";
+      const dbId = typeof qarpeoConfig.db === "object" && qarpeoConfig.db?.databaseId || process.env.QARPEO_DB_ID || process.env.DATABASE_ID || process.env.DB_ID;
+      if (isRemote) {
+        if (!dbId || dbId.includes("LOCAL_DEV")) {
+          bindingItems.push({
+            status: "fail",
+            title: "D1 Database ID",
+            message: `Remote deploy requires a real Cloudflare D1 UUID for binding '${dbBinding}'`,
+            help: "Create a D1 database via `wrangler d1 create <name>` and set QARPEO_DB_ID or DATABASE_ID in .env."
+          });
+        } else {
+          bindingItems.push({
+            status: "pass",
+            title: "D1 Database Binding",
+            message: `Binding '${dbBinding}' bound to remote ID ${dbId}`
+          });
+        }
+      } else {
+        bindingItems.push({
+          status: "pass",
+          title: "D1 Database Binding",
+          message: `Binding '${dbBinding}' active (Miniflare emulation)`
+        });
+      }
+    }
+    const isBlobEnabled = Boolean(qarpeoConfig.blob || qarpeoConfig.r2 || qarpeoConfig.cms || qarpeoConfig.storage);
+    if (isBlobEnabled) {
+      const blobBucket = process.env.QARPEO_BLOB_BUCKET || process.env.BLOB_NAME || typeof qarpeoConfig.blob === "object" && qarpeoConfig.blob?.bucket;
+      if (isRemote && (!blobBucket || blobBucket.includes("local-dev"))) {
+        bindingItems.push({
+          status: "warn",
+          title: "R2 Bucket Name",
+          message: "No custom R2 bucket configured for remote deployment",
+          help: "Create an R2 bucket via `wrangler r2 bucket create <name>` and set QARPEO_BLOB_BUCKET in .env."
+        });
+      } else {
+        bindingItems.push({
+          status: "pass",
+          title: "R2 Blob Storage",
+          message: `Bucket: ${blobBucket || "local simulation bucket"}`
+        });
+      }
+    }
+    if (qarpeoConfig.ai || qarpeoConfig.agents) {
+      const cfApiToken = process.env.CLOUDFLARE_API_TOKEN;
+      if (!cfApiToken || cfApiToken === "dummy-dev-api-token") {
+        bindingItems.push({
+          status: isRemote ? "fail" : "warn",
+          title: "Workers AI Credentials",
+          message: "CLOUDFLARE_API_TOKEN is required for Workers AI inference",
+          help: "Obtain an API token from Cloudflare dashboard with Workers AI permissions and set CLOUDFLARE_API_TOKEN."
+        });
+      } else {
+        bindingItems.push({
+          status: "pass",
+          title: "Workers AI Credentials",
+          message: "CLOUDFLARE_API_TOKEN detected"
+        });
+      }
+    }
+    categories.push({
+      title: "Cloudflare & Wrangler Bindings",
+      icon: "\u2601\uFE0F ",
+      items: bindingItems
+    });
+    if (isDbEnabled) {
+      const dbItems = [];
+      const drizzleCheck = checkDrizzleVersion(cwd);
+      if (drizzleCheck.installed) {
+        if (drizzleCheck.isRC) {
+          dbItems.push({
+            status: "pass",
+            title: "Drizzle ORM",
+            message: `v${drizzleCheck.version} (v1.0.0 RC compliant)`
+          });
+        } else {
+          dbItems.push({
+            status: "fail",
+            title: "Drizzle ORM",
+            message: drizzleCheck.error || `Outdated version v${drizzleCheck.version}`,
+            help: "Upgrade drizzle-orm to v1.0.0 RC: pnpm add drizzle-orm@rc"
+          });
+        }
+      } else {
+        dbItems.push({
+          status: "pass",
+          title: "Drizzle ORM",
+          message: "Bundled directly by Qarpeo runtime"
+        });
+      }
+      const layers = nuxtConfig?._layers || [{ cwd }];
+      const schemaFiles = findSchemaFiles(layers);
+      if (schemaFiles.length > 0) {
+        dbItems.push({
+          status: "pass",
+          title: "Schema Definitions",
+          message: `Found ${schemaFiles.length} schema file(s)`
+        });
+      } else {
+        dbItems.push({
+          status: "warn",
+          title: "Schema Definitions",
+          message: "No custom Drizzle schema files found in server/db/schema/",
+          help: "Create table definitions in server/db/schema/ (e.g. server/db/schema/users.ts)."
+        });
+      }
+      const migrationsDir = resolve(cwd, "server/db/migrations");
+      if (existsSync(migrationsDir)) {
+        try {
+          const migrationEntries = readdirSync(migrationsDir).filter((e) => {
+            const p = join(migrationsDir, e);
+            return statSync(p).isDirectory() || e.endsWith(".sql");
+          });
+          if (migrationEntries.length === 0) {
+            dbItems.push({
+              status: schemaFiles.length > 0 ? "warn" : "info",
+              title: "D1 Migrations",
+              message: "Migrations directory exists but contains no migration files",
+              help: "Run `qp generate` to create initial D1 SQL migrations."
+            });
+          } else {
+            let latestMigrationMtime = 0;
+            for (const entry of migrationEntries) {
+              const mtime = statSync(join(migrationsDir, entry)).mtimeMs;
+              if (mtime > latestMigrationMtime) latestMigrationMtime = mtime;
+            }
+            let newestSchemaMtime = 0;
+            for (const s of schemaFiles) {
+              const mtime = statSync(s).mtimeMs;
+              if (mtime > newestSchemaMtime) newestSchemaMtime = mtime;
+            }
+            if (newestSchemaMtime > latestMigrationMtime + 3e3) {
+              dbItems.push({
+                status: "warn",
+                title: "D1 Migrations Freshness",
+                message: `${migrationEntries.length} migration(s) found, but schema files were modified more recently`,
+                help: "Run `qp generate` to generate new migrations for the latest schema changes."
+              });
+            } else {
+              dbItems.push({
+                status: "pass",
+                title: "D1 Migrations",
+                message: `${migrationEntries.length} migration(s) generated and up to date with schemas`
+              });
+            }
+          }
+        } catch {
+          dbItems.push({
+            status: "info",
+            title: "D1 Migrations",
+            message: "Unable to inspect migrations directory"
+          });
+        }
+      } else if (schemaFiles.length > 0) {
+        dbItems.push({
+          status: "warn",
+          title: "D1 Migrations",
+          message: "No server/db/migrations directory found",
+          help: "Run `qp generate` to generate D1 migrations from your schema files."
+        });
+      }
+      if (!isRemote) {
+        const localDbPath = findLocalD1Database(cwd);
+        if (localDbPath) {
+          dbItems.push({
+            status: "pass",
+            title: "Local Database File",
+            message: `Found: ${join(".", localDbPath.replace(cwd, "")).replace(/^[\\/]/, "")}`
+          });
+        } else {
+          dbItems.push({
+            status: "info",
+            title: "Local Database File",
+            message: "No local SQLite file yet (Miniflare initializes it automatically on `nuxt dev`)"
+          });
+        }
+      }
+      categories.push({
+        title: "Database & Migrations",
+        icon: "\u{1F5C4}\uFE0F ",
+        items: dbItems
+      });
+    }
+    if (qarpeoConfig.auth) {
+      const authItems = [];
+      const secret = process.env.NUXT_APP_SECRET || process.env.NUXT_SESSION_PASSWORD;
+      const isDummySecret = secret === "dev-app-secret-must-be-at-least-32-chars-long" || secret === "dev-session-password-must-be-at-least-32-chars-long";
+      if (!secret) {
+        authItems.push({
+          status: isRemote ? "fail" : "warn",
+          title: "Application Secret",
+          message: "NUXT_APP_SECRET is not set in environment or .env",
+          help: "Generate a 32+ character random secret and set NUXT_APP_SECRET in .env."
+        });
+      } else if (isDummySecret) {
+        if (isRemote) {
+          authItems.push({
+            status: "fail",
+            title: "Application Secret",
+            message: "Cannot deploy default development dummy secret to production!",
+            help: "Replace NUXT_APP_SECRET with a cryptographically secure random 32+ char secret for production."
+          });
+        } else {
+          authItems.push({
+            status: "warn",
+            title: "Application Secret",
+            message: "Using default local development dummy secret",
+            help: "Remember to set a unique NUXT_APP_SECRET before deploying to production."
+          });
+        }
+      } else if (secret.length < 32) {
+        authItems.push({
+          status: "fail",
+          title: "Application Secret Length",
+          message: `NUXT_APP_SECRET is only ${secret.length} characters (minimum 32 required for AES-256 seal)`,
+          help: "Generate a 32+ character secret: `openssl rand -base64 32`."
+        });
+      } else {
+        authItems.push({
+          status: "pass",
+          title: "Application Secret",
+          message: `Configured (${secret.length} chars)`
+        });
+      }
+      const authOpts = typeof qarpeoConfig.auth === "object" ? qarpeoConfig.auth : {};
+      const providers = Array.isArray(authOpts.providers) ? authOpts.providers : [];
+      for (const provider of providers) {
+        const envPrefix = `NUXT_OAUTH_${provider.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
+        const clientId = process.env[`${envPrefix}_CLIENT_ID`];
+        const clientSecret = process.env[`${envPrefix}_CLIENT_SECRET`];
+        if (!clientId || !clientSecret) {
+          authItems.push({
+            status: isRemote ? "fail" : "warn",
+            title: `OAuth: ${provider}`,
+            message: `Missing ${envPrefix}_CLIENT_ID or ${envPrefix}_CLIENT_SECRET`,
+            help: `Add ${envPrefix}_CLIENT_ID and ${envPrefix}_CLIENT_SECRET to .env.`
+          });
+        } else {
+          authItems.push({
+            status: "pass",
+            title: `OAuth: ${provider}`,
+            message: "Credentials configured"
+          });
+        }
+      }
+      categories.push({
+        title: "Authentication & Security",
+        icon: "\u{1F510}",
+        items: authItems
+      });
+    }
+    if (qarpeoConfig.payments) {
+      const paymentItems = [];
+      const paymentsOpts = typeof qarpeoConfig.payments === "object" ? qarpeoConfig.payments : {};
+      const provider = paymentsOpts.provider || "stripe";
+      if (provider === "stripe") {
+        const stripeKey = process.env.STRIPE_SECRET_KEY;
+        const stripeWebhook = process.env.STRIPE_WEBHOOK_SECRET;
+        if (!stripeKey) {
+          paymentItems.push({
+            status: isRemote ? "fail" : "warn",
+            title: "Stripe Secret Key",
+            message: "STRIPE_SECRET_KEY is not set",
+            help: "Set STRIPE_SECRET_KEY in your .env file."
+          });
+        } else {
+          paymentItems.push({
+            status: "pass",
+            title: "Stripe Secret Key",
+            message: `Configured (${stripeKey.slice(0, 7)}...)`
+          });
+        }
+        if (!stripeWebhook && isRemote) {
+          paymentItems.push({
+            status: "warn",
+            title: "Stripe Webhook Secret",
+            message: "STRIPE_WEBHOOK_SECRET is not set for signature verification",
+            help: "Set STRIPE_WEBHOOK_SECRET from your Stripe dashboard webhooks settings."
+          });
+        }
+      }
+      categories.push({
+        title: "Payments",
+        icon: "\u{1F4B3}",
+        items: paymentItems
+      });
+    }
+    let passCount = 0;
+    let warnCount = 0;
+    let failCount = 0;
+    for (const cat of categories) {
+      console.log(`
+${cat.icon} ${cat.title}`);
+      console.log("\u2500".repeat(50));
+      for (const item of cat.items) {
+        let badge = "";
+        if (item.status === "pass") {
+          badge = "  \u2713";
+          passCount++;
+        } else if (item.status === "warn") {
+          badge = "  \u26A0\uFE0F ";
+          warnCount++;
+        } else if (item.status === "fail") {
+          badge = "  \u274C";
+          failCount++;
+        } else {
+          badge = "  \u2139 ";
+        }
+        console.log(`${badge} [${item.title}] ${item.message}`);
+        if (item.help && (item.status === "warn" || item.status === "fail")) {
+          console.log(`     \u{1F449} ${item.help}`);
+        }
+      }
+    }
+    console.log(`
+` + "\u2550".repeat(50));
+    console.log(
+      `\u{1F4CA} Doctor Summary: ${passCount} passed, ${warnCount} warning(s), ${failCount} error(s)`
+    );
+    if (failCount > 0) {
+      console.log(
+        `
+\u274C [qarpeo doctor] Found ${failCount} critical error(s) that should be resolved before deployment.`
+      );
+      process.exit(1);
+    } else if (warnCount > 0) {
+      console.log(
+        `
+\u26A0\uFE0F  [qarpeo doctor] System is operational with ${warnCount} recommendation(s). Review above.`
+      );
+    } else {
+      console.log(`
+\u2728 [qarpeo doctor] Everything is healthy and ready to go!`);
+    }
+  }
+});
+
+const main = defineCommand({
+  meta: {
+    name: "qp",
+    version: "0.0.1",
+    description: "Cloudflare-native powerhouse module for Nuxt"
+  },
+  subCommands: {
+    db,
+    doctor,
+    generate,
+    migrate,
+    push
+  }
+});
+void runMain(main);