wexts 3.0.2 → 4.1.0

package/dist/cli/index.mjs

@@ -1,333 +1,718 @@
 #!/usr/bin/env node
 import {
   logger
-} from "../chunk-VNNVLQLJ.mjs";
+} from "../chunk-JHOVXH3X.mjs";
+import {
+  WextsError,
+  formatWextsError
+} from "../chunk-7TLSPR65.mjs";
 import {
   __dirname,
+  __filename,
   __name
-} from "../chunk-FCEZDH42.mjs";
+} from "../chunk-7WULUGLH.mjs";
 
 // src/cli/index.ts
 import { Command } from "commander";
-import * as pc from "picocolors";
-import inquirer from "inquirer";
 import * as fs from "fs";
 import * as path from "path";
-import { execSync } from "child_process";
-var program = new Command();
-program.name("wexts").description("Wexts Framework - Next.js 16 + NestJS 11").version("2.0.0");
-program.action(async () => {
-  console.log(pc.cyan(`
-\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
-\u2551                                          \u2551
-\u2551      ${pc.bold("\u{1F680} Wexts Framework v2.0")}          \u2551
-\u2551                                          \u2551
-\u2551  Next.js 16 + NestJS 11 Full-Stack      \u2551
-\u2551                                          \u2551
-\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
-        `));
-  const { action } = await inquirer.prompt([
-    {
-      type: "list",
-      name: "action",
-      message: "What would you like to do?",
-      choices: [
-        {
-          name: "\u{1F4E6} Create a new project",
-          value: "create"
-        },
-        {
-          name: "\u{1F680} Start development server",
-          value: "dev"
-        },
-        {
-          name: "\u{1F528} Build for production",
-          value: "build"
-        },
-        {
-          name: "\u26A1 Generate code",
-          value: "generate"
-        },
-        {
-          name: "\u{1F916} Generate API client",
-          value: "codegen"
-        },
-        {
-          name: "\u274C Exit",
-          value: "exit"
-        }
-      ]
-    }
-  ]);
-  if (action === "exit") {
-    logger.info("Goodbye! \u{1F44B}");
-    process.exit(0);
-  }
-  if (action === "create") {
-    const { projectName, template } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "projectName",
-        message: "Project name:",
-        default: "my-wexts-app"
-      },
-      {
-        type: "list",
-        name: "template",
-        message: "Select template:",
-        choices: [
-          {
-            name: "\u{1F4E6} Monorepo (Next.js + NestJS)",
-            value: "monorepo"
-          },
-          {
-            name: "\u{1F3AF} API only (NestJS)",
-            value: "api"
-          },
-          {
-            name: "\u{1F310} Web only (Next.js)",
-            value: "web"
-          }
-        ]
-      }
-    ]);
-    await createProject(projectName, template);
-  } else if (action === "dev") {
-    logger.info(pc.green("\u{1F680} Starting development servers...\n"));
-    logger.warn("Dev server not yet implemented");
-  } else if (action === "build") {
-    logger.info(pc.blue("\u{1F528} Building project...\n"));
-    logger.warn("Build not yet implemented");
-  } else if (action === "generate") {
-    const { type, name } = await inquirer.prompt([
-      {
-        type: "list",
-        name: "type",
-        message: "What to generate?",
-        choices: [
-          "controller",
-          "module",
-          "service",
-          "page"
-        ]
-      },
-      {
-        type: "input",
-        name: "name",
-        message: "Name:"
-      }
-    ]);
-    logger.info(pc.magenta(`
-\u26A1 Generating ${type}: ${name}
-`));
-    logger.warn("Code generation not yet implemented");
-  } else if (action === "codegen") {
-    logger.info(pc.cyan("\n\u{1F916} Generating API client...\n"));
-    logger.warn("Codegen not yet implemented");
-  }
-});
-program.command("create <project-name>").description("Create a new wexts project").option("-t, --template <template>", "Template to use (monorepo|api|web)", "monorepo").action(async (projectName, options) => {
-  await createProject(projectName, options.template);
-});
-program.command("dev").description("Start development servers").option("-a, --api <path>", "Path to API project", "./apps/api").option("-w, --web <path>", "Path to Web project", "./apps/web").option("-p, --port <port>", "Port for web server", "3000").option("--api-port <port>", "Port for API server", "5050").option("--no-proxy", "Disable proxy server").action(async (options) => {
-  logger.info(pc.green("\u{1F680} Starting Wexts development servers...\n"));
-  const { FusionDevServer } = await import("../dev-server/index.mjs");
-  const server = new FusionDevServer();
-  try {
+import { spawnSync } from "child_process";
+import { createRequire } from "module";
+function createCliProgram() {
+  const program = new Command();
+  program.name("wexts").description("Wexts - production-focused single-runtime Next.js + NestJS toolkit").version(readPackageVersion());
+  program.command("create <project-name>").description("Create a verified Wexts starter").option("-t, --template <template>", "Template to use (starter|legacy)", "starter").option("--skip-install", "Skip dependency installation", false).action(async (projectName, options) => {
+    await createProject(projectName, options.template, {
+      skipInstall: options.skipInstall
+    });
+  });
+  program.command("dev").description("Start local development processes").option("-a, --api <path>", "Path to API project", "./apps/api").option("-w, --web <path>", "Path to Web project", "./apps/web").option("-p, --port <port>", "Port for web server", "3000").option("--api-port <port>", "Port for API server", "5050").option("--proxy", "Enable development proxy on a separate proxy port", false).action(async (options) => {
+    const { FusionDevServer } = await import("../dev-server/index.mjs");
+    const server = new FusionDevServer();
     await server.start({
       apiPath: options.api,
       webPath: options.web,
-      webPort: parseInt(options.port),
-      apiPort: parseInt(options.apiPort),
+      webPort: Number(options.port),
+      apiPort: Number(options.apiPort),
       useProxy: options.proxy
     });
-  } catch (error) {
-    logger.error("Failed to start dev server:", error.message);
-    process.exit(1);
-  }
-});
-program.command("build").description("Build for production").action(async () => {
-  logger.info(pc.blue("Building Wexts project..."));
-  logger.warn("Build not yet implemented");
-});
-program.command("generate <type> <name>").alias("g").description("Generate code (controller|module|page)").action(async (type, name) => {
-  logger.info(pc.magenta(`Generating ${type}: ${name}`));
-  logger.warn("Code generation not yet implemented");
-});
-program.command("codegen").description("Generate API client from NestJS controllers").option("-w, --watch", "Watch mode - regenerate on changes").option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output path for generated client", "./packages/api-client/src").action(async (options) => {
-  const { NestJSParser, ClientGenerator, CodegenWatcher } = await import("../codegen/index.mjs");
-  if (options.watch) {
-    logger.info(pc.cyan("Starting codegen in watch mode..."));
-    const watcher = new CodegenWatcher();
-    await watcher.watch({
-      projectPath: options.project,
-      outputPath: options.output
+  });
+  program.command("generate [type] [name]").alias("g").description("Generate RPC manifest/client, or scaffold a minimal RPC service").option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output directory for generated RPC client", "./apps/web/lib/wexts").option("--force", "Overwrite generated files if they already exist", false).action(async (type, name, options) => {
+    if (!type || type === "rpc" && !name) {
+      const { generateRpcClient } = await import("../codegen/index.mjs");
+      const manifest = await generateRpcClient({
+        projectPath: path.resolve(options.project),
+        outputPath: path.resolve(options.output)
+      });
+      logger.success(`Generated Wexts RPC client for ${manifest.services.length} service(s).`);
+      return;
+    }
+    if (isScaffoldGenerator(type)) {
+      const targetRoot = type === "config" ? process.cwd() : path.resolve(options.project);
+      const changedFiles = await scaffoldGenerator({
+        type,
+        name,
+        targetRoot,
+        force: options.force
+      });
+      for (const file of changedFiles) logger.info(`created ${path.relative(process.cwd(), file)}`);
+      logger.success(`Generated ${type}${name ? ` ${name}` : ""}.`);
+      return;
+    }
+    throw new Error(`Unknown generator "${type}". Supported generators: rpc, service, module, entity, guard, config.`);
+  });
+  program.command("codegen").description("Alias for wexts generate rpc").option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output directory for generated RPC client", "./apps/web/lib/wexts").action(async (options) => {
+    const { generateRpcClient } = await import("../codegen/index.mjs");
+    const manifest = await generateRpcClient({
+      projectPath: path.resolve(options.project),
+      outputPath: path.resolve(options.output)
     });
-  } else {
-    logger.info(pc.cyan("Generating API client..."));
-    const parser = new NestJSParser(options.project);
-    const controllers = parser.findFusionControllers();
-    const generator = new ClientGenerator();
-    await generator.generate({
-      controllers,
-      outputPath: options.output
+    logger.success(`Generated Wexts RPC client for ${manifest.services.length} service(s).`);
+  });
+  program.command("build").description("Build a Wexts project for production").option("--skip-generate", "Skip RPC generation before build", false).option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output directory for generated RPC client", "./apps/web/lib/wexts").action(async (options) => {
+    if (!options.skipGenerate && fs.existsSync(options.project)) {
+      const { generateRpcClient } = await import("../codegen/index.mjs");
+      await generateRpcClient({
+        projectPath: path.resolve(options.project),
+        outputPath: path.resolve(options.output)
+      });
+    }
+    runScript("build", {
+      cwd: process.cwd()
     });
+  });
+  program.command("start").description("Start the production Wexts runtime").option("-c, --config <path>", "Runtime config module path", "./wexts.runtime.js").option("-p, --port <port>", "Port to listen on", process.env.PORT ?? "3000").action(async (options) => {
+    const { startWextsRuntime } = await import("../runtime/index.mjs");
+    const configPath = path.resolve(options.config);
+    const runtimeConfig = fs.existsSync(configPath) ? await loadRuntimeConfig(configPath) : {};
+    await startWextsRuntime({
+      ...runtimeConfig,
+      port: Number(options.port),
+      dev: false
+    });
+  });
+  program.command("vercel-build").description("Build for Vercel using Build Output API v3").option("-p, --project <path>", "Path to NestJS project", "./apps/api").option("-o, --output <path>", "Output dir for RPC client", "./apps/web/lib/wexts").option("-c, --config <path>", "Runtime config module path", "./wexts.runtime.js").option("--skip-codegen", "Skip RPC generation", false).option("--skip-build", "Skip project build step", false).option("--node-version <version>", "Node.js version for Vercel function", "20").option("--max-duration <seconds>", "Max duration for serverless function", "30").action(async (options) => {
+    const { buildVercelOutput } = await import("../vercel-builder/index.mjs");
+    const result = await buildVercelOutput({
+      rootDir: process.cwd(),
+      apiProjectPath: options.project,
+      rpcOutputPath: options.output,
+      runtimeConfigPath: options.config,
+      skipCodegen: options.skipCodegen,
+      skipBuild: options.skipBuild,
+      nodeVersion: options.nodeVersion,
+      maxDuration: Number(options.maxDuration)
+    });
+    if (result.warnings.length > 0) {
+      for (const warning of result.warnings) logger.warn(warning);
+    }
+    if (result.errors.length > 0) {
+      for (const error of result.errors) logger.error(error);
+      process.exit(1);
+    }
+    logger.success("Vercel build output ready at .vercel/output");
+  });
+  program.command("doctor").description("Validate Wexts project configuration").option("--security", "Run security-specific checks", false).action(async (options) => {
+    const result = runDoctor(process.cwd(), options.security);
+    for (const warning of result.warnings) logger.warn(warning);
+    for (const error of result.errors) logger.error(error);
+    if (result.errors.length > 0) process.exit(1);
+    logger.success(options.security ? "Security doctor passed." : "Doctor passed.");
+  });
+  return program;
+}
+__name(createCliProgram, "createCliProgram");
+function runDoctor(cwd, security = false) {
+  const result = {
+    errors: [],
+    warnings: []
+  };
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) {
+    result.errors.push("package.json not found.");
+    return result;
   }
-});
-async function createProject(projectName, template) {
-  logger.info(pc.cyan(`Creating wexts project: ${pc.bold(projectName)}`));
-  logger.info(`Template: ${template}`);
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  if (!pkg.packageManager?.startsWith("pnpm@")) {
+    result.warnings.push("packageManager should pin pnpm.");
+  }
+  for (const dir of [
+    "apps/api",
+    "apps/web"
+  ]) {
+    if (!fs.existsSync(path.join(cwd, dir))) {
+      result.warnings.push(`${dir} not found; some Wexts commands may need explicit paths.`);
+    }
+  }
+  if (fs.existsSync(path.join(cwd, "apps/api")) && fs.existsSync(path.join(cwd, "apps/web"))) {
+    result.warnings.push("Development mode starts separate web/API processes. Single-port serving is the production `wexts start` runtime path.");
+  }
+  if (security) {
+    const source = readAllText(cwd, [
+      "apps/api/src",
+      "packages/templates/nestjs-api/src"
+    ]);
+    if (source.includes("default-secret")) {
+      result.errors.push('JWT fallback "default-secret" found. Production apps must fail without a strong JWT_SECRET.');
+    }
+    if (/origin:\s*['"]\*['"]/.test(source)) {
+      result.errors.push("Wildcard CORS origin found. Use an explicit origin allowlist.");
+    }
+  }
+  return result;
+}
+__name(runDoctor, "runDoctor");
+async function createProject(projectName, template, options) {
   const projectPath = path.join(process.cwd(), projectName);
   if (fs.existsSync(projectPath)) {
-    logger.error(`Directory ${projectName} already exists!`);
-    process.exit(1);
+    throw new Error(`Directory already exists: ${projectName}`);
   }
-  function getTemplatePath() {
-    const possiblePaths = [
-      path.join(__dirname, "../../templates"),
-      path.join(__dirname, "../templates"),
-      path.join(process.cwd(), "templates"),
-      path.resolve(__dirname, "..", "..", "templates")
-      // Absolute resolve
-    ];
-    for (const p of possiblePaths) {
-      if (fs.existsSync(p)) {
-        return p;
+  fs.mkdirSync(projectPath, {
+    recursive: true
+  });
+  if (template === "starter") {
+    await createVerifiedStarter(projectPath, projectName, options.wextsDependency ?? resolveCreateWextsDependency(projectPath));
+  } else if (template === "legacy") {
+    createLegacyProject(projectPath, projectName);
+  } else {
+    throw new Error(`Unknown template "${template}". Supported templates: starter, legacy.`);
+  }
+  if (!options.skipInstall) {
+    runCommand(detectPackageManager(projectPath), [
+      "install"
+    ], projectPath);
+  }
+}
+__name(createProject, "createProject");
+async function createVerifiedStarter(projectPath, projectName, wextsDependency) {
+  const files = {
+    "pnpm-workspace.yaml": "packages:\n  - 'apps/*'\n",
+    "package.json": JSON.stringify({
+      name: projectName,
+      version: "0.1.0",
+      private: true,
+      packageManager: "pnpm@10.22.0",
+      scripts: {
+        dev: "wexts dev",
+        generate: "wexts generate -p apps/api -o apps/web/lib/wexts",
+        build: "pnpm run generate && tsc -p apps/api/tsconfig.json && next build apps/web",
+        start: "wexts start -c ./wexts.runtime.js",
+        "vercel-build": "wexts vercel-build -p apps/api -o apps/web/lib/wexts -c ./wexts.runtime.js",
+        doctor: "wexts doctor",
+        "doctor:security": "wexts doctor --security"
+      },
+      dependencies: {
+        "@nestjs/common": "^11.1.19",
+        "@nestjs/core": "^11.1.19",
+        "@nestjs/platform-fastify": "^11.1.19",
+        next: "16.2.4",
+        react: "^19.2.5",
+        "react-dom": "^19.2.5",
+        "reflect-metadata": "^0.2.2",
+        rxjs: "^7.8.1",
+        wexts: wextsDependency
+      },
+      devDependencies: {
+        "@types/node": "^22.19.1",
+        "@types/react": "^19.2.14",
+        "@types/react-dom": "^19.2.3",
+        typescript: "^5.9.3"
       }
-    }
-    return "";
+    }, null, 2),
+    "apps/api/package.json": JSON.stringify({
+      name: `${projectName}-api`,
+      private: true,
+      scripts: {
+        "start:dev": "tsc -w -p tsconfig.json"
+      }
+    }, null, 2),
+    "apps/api/tsconfig.json": JSON.stringify({
+      compilerOptions: {
+        target: "ES2023",
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        outDir: "dist",
+        rootDir: "src"
+      },
+      include: [
+        "src/**/*.ts"
+      ]
+    }, null, 2),
+    "apps/api/src/hello.service.ts": `import { Injectable } from '@nestjs/common';
+import { RpcMethod, RpcService } from 'wexts/nest';
+
+@Injectable()
+@RpcService({ name: 'hello', requireAuth: false })
+export class HelloService {
+  @RpcMethod()
+  async sayHello(name: string): Promise<string> {
+    return \`Hello, \${name}!\`;
   }
-  __name(getTemplatePath, "getTemplatePath");
-  const templatePath = getTemplatePath();
-  if (!templatePath) {
-    logger.error(`\u274C Template directory not found!`);
-    logger.info(`Searched in:`);
-    logger.info(`  - ${path.join(__dirname, "../../templates")}`);
-    logger.info(`  - ${path.join(__dirname, "../templates")}`);
-    logger.info(`  - ${path.join(process.cwd(), "templates")}`);
-    logger.warn("\u26A0\uFE0F Using fallback scaffolding (empty structure)");
-    fs.mkdirSync(projectPath, {
-      recursive: true
-    });
-    fs.mkdirSync(path.join(projectPath, "apps"), {
-      recursive: true
-    });
-    fs.mkdirSync(path.join(projectPath, "packages"), {
-      recursive: true
-    });
-  } else {
-    logger.info(`\u{1F4E6} Copying templates from: ${templatePath}`);
-    fs.mkdirSync(projectPath, {
-      recursive: true
-    });
-    fs.mkdirSync(path.join(projectPath, "apps"), {
-      recursive: true
-    });
-    fs.mkdirSync(path.join(projectPath, "packages"), {
+}
+`,
+    "apps/web/package.json": JSON.stringify({
+      name: `${projectName}-web`,
+      private: true,
+      scripts: {
+        dev: "next dev -p 3000"
+      }
+    }, null, 2),
+    "apps/web/tsconfig.json": JSON.stringify({
+      compilerOptions: {
+        target: "ES2022",
+        lib: [
+          "dom",
+          "dom.iterable",
+          "es2022"
+        ],
+        allowJs: false,
+        skipLibCheck: true,
+        strict: true,
+        noEmit: true,
+        esModuleInterop: true,
+        module: "esnext",
+        moduleResolution: "bundler",
+        resolveJsonModule: true,
+        isolatedModules: true,
+        jsx: "react-jsx",
+        incremental: true,
+        plugins: [
+          {
+            name: "next"
+          }
+        ]
+      },
+      include: [
+        "next-env.d.ts",
+        "**/*.ts",
+        "**/*.tsx",
+        ".next/types/**/*.ts",
+        ".next/dev/types/**/*.ts"
+      ],
+      exclude: [
+        "node_modules"
+      ]
+    }, null, 2),
+    "apps/web/next-env.d.ts": `/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+
+// This file is generated by Next.js. Do not edit.
+`,
+    "apps/web/next.config.ts": `import type { NextConfig } from 'next';
+
+const nextConfig: NextConfig = {
+  output: 'standalone',
+};
+
+export default nextConfig;
+`,
+    "apps/web/app/layout.tsx": `import type { ReactNode } from 'react';
+import { WextsProvider } from '../lib/wexts-provider';
+
+export default function RootLayout({ children }: { children: ReactNode }) {
+  return (
+    <html lang="en">
+      <body>
+        <WextsProvider>{children}</WextsProvider>
+      </body>
+    </html>
+  );
+}
+`,
+    "apps/web/app/page.tsx": `'use client';
+
+import { useState } from 'react';
+import { useWexts } from '../lib/wexts-provider';
+
+export default function Page() {
+  const wexts = useWexts();
+  const [message, setMessage] = useState('Not called yet');
+
+  return (
+    <main>
+      <h1>Wexts Hello RPC</h1>
+      <button
+        type="button"
+        onClick={async () => {
+          setMessage(await wexts.hello.sayHello('Bob'));
+        }}
+      >
+        Call RPC
+      </button>
+      <p>{message}</p>
+    </main>
+  );
+}
+`,
+    "apps/web/lib/wexts-provider.tsx": `'use client';
+
+import { FusionProvider, useWexts as useGeneratedWexts } from 'wexts/next';
+import { createWextsClient, type WextsClient } from './wexts/client';
+
+export function WextsProvider({ children }: { children: React.ReactNode }) {
+  return (
+    <FusionProvider rpcClient={createWextsClient({ baseUrl: '/rpc' })}>
+      {children}
+    </FusionProvider>
+  );
+}
+
+export function useWexts(): WextsClient {
+  return useGeneratedWexts<WextsClient>();
+}
+`,
+    "wexts.runtime.js": `const { HelloService } = require('./apps/api/dist/hello.service.js');
+
+module.exports = {
+  nextDir: './apps/web',
+  rpcManifestPath: './apps/web/lib/wexts/wexts.rpc.manifest.json',
+  rpcServices: {
+    hello: new HelloService(),
+  },
+  security: {
+    allowedOrigins: ['http://localhost:3000'],
+  },
+};
+`,
+    "README.md": `# ${projectName}
+
+Verified Wexts starter with a generated Hello RPC client.
+
+\`\`\`bash
+pnpm install
+pnpm run generate
+pnpm run build
+pnpm run doctor
+pnpm run doctor:security
+pnpm run start
+\`\`\`
+`
+  };
+  for (const [relativePath, content] of Object.entries(files)) {
+    const absolutePath = path.join(projectPath, relativePath);
+    fs.mkdirSync(path.dirname(absolutePath), {
       recursive: true
     });
-    const apiTemplatePath = path.join(templatePath, "nestjs-api");
-    const apiDestPath = path.join(projectPath, "apps/api");
-    if (fs.existsSync(apiTemplatePath)) {
-      fs.cpSync(apiTemplatePath, apiDestPath, {
-        recursive: true
-      });
-      logger.success("  - Copied API template");
-      const envExamplePath = path.join(apiDestPath, ".env.example");
-      const envPath = path.join(apiDestPath, ".env");
-      if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
-        fs.copyFileSync(envExamplePath, envPath);
-        logger.success("  - Created .env from .env.example");
-      }
-    } else {
-      logger.warn(`  \u26A0\uFE0F API template not found at ${apiTemplatePath}`);
-    }
-    const webTemplatePath = path.join(templatePath, "nextjs-web");
-    const webDestPath = path.join(projectPath, "apps/web");
-    if (fs.existsSync(webTemplatePath)) {
-      fs.cpSync(webTemplatePath, webDestPath, {
-        recursive: true
-      });
-      logger.success("  - Copied Web template");
-    } else {
-      logger.warn(`  \u26A0\uFE0F Web template not found at ${webTemplatePath}`);
-    }
+    fs.writeFileSync(absolutePath, content);
   }
-  const packageJson = {
+  const { generateRpcClient } = await import("../codegen/index.mjs");
+  await generateRpcClient({
+    projectPath: path.join(projectPath, "apps/api"),
+    outputPath: path.join(projectPath, "apps/web/lib/wexts")
+  });
+}
+__name(createVerifiedStarter, "createVerifiedStarter");
+function createLegacyProject(projectPath, projectName) {
+  const templatePath = findTemplatePath();
+  if (!templatePath) {
+    throw new Error("Template directory not found in package.");
+  }
+  fs.mkdirSync(path.join(projectPath, "apps"), {
+    recursive: true
+  });
+  fs.cpSync(path.join(templatePath, "nestjs-api"), path.join(projectPath, "apps/api"), {
+    recursive: true
+  });
+  fs.cpSync(path.join(templatePath, "nextjs-web"), path.join(projectPath, "apps/web"), {
+    recursive: true
+  });
+  fs.rmSync(path.join(projectPath, "apps/web/package-lock.json"), {
+    force: true
+  });
+  fs.rmSync(path.join(projectPath, "apps/api/package-lock.json"), {
+    force: true
+  });
+  fs.writeFileSync(path.join(projectPath, "pnpm-workspace.yaml"), "packages:\n  - 'apps/*'\n");
+  fs.writeFileSync(path.join(projectPath, "package.json"), JSON.stringify({
     name: projectName,
-    version: "0.0.0",
     private: true,
+    packageManager: "pnpm@10.22.0",
     scripts: {
-      "build": "pnpm exec turbo build",
-      "dev": "pnpm exec turbo dev",
-      "lint": "pnpm exec turbo lint",
-      "format": 'prettier --write "**/*.{ts,tsx,md}"'
+      dev: "wexts dev",
+      generate: "wexts generate",
+      build: "wexts build",
+      start: "wexts start",
+      doctor: "wexts doctor"
     },
     devDependencies: {
-      "turbo": "^2.6.1",
-      "prettier": "latest",
-      "typescript": "^5.9.3",
-      "wexts": "latest"
-    },
-    packageManager: "pnpm@10.0.0"
-  };
-  fs.writeFileSync(path.join(projectPath, "package.json"), JSON.stringify(packageJson, null, 2));
-  const turboJson = {
-    "$schema": "https://turbo.build/schema.json",
-    "tasks": {
-      "build": {
-        "dependsOn": [
-          "^build"
-        ],
-        "outputs": [
-          ".next/**",
-          "!.next/cache/**",
-          "dist/**"
-        ]
-      },
-      "lint": {},
-      "dev": {
-        "cache": false,
-        "persistent": true
-      }
+      wexts: `^${readPackageVersion()}`
     }
-  };
-  fs.writeFileSync(path.join(projectPath, "turbo.json"), JSON.stringify(turboJson, null, 2));
-  const pnpmWorkspace = `packages:
-  - 'apps/*'
-  - 'packages/*'
-`;
-  fs.writeFileSync(path.join(projectPath, "pnpm-workspace.yaml"), pnpmWorkspace);
-  logger.success("\u2705 Project structure created");
-  logger.info("\u{1F4E6} Installing dependencies...");
+  }, null, 2));
+}
+__name(createLegacyProject, "createLegacyProject");
+function resolveCreateWextsDependency(projectPath) {
+  const packageRoot = path.resolve(__dirname, "../..");
+  const cwdLocalPackage = path.join(process.cwd(), "node_modules/wexts");
   try {
-    try {
-      execSync("pnpm --version", {
-        stdio: "ignore"
-      });
-    } catch {
-      logger.info("Installing pnpm...");
-      execSync("npm install -g pnpm", {
-        stdio: "ignore"
+    if (fs.existsSync(cwdLocalPackage) && fs.realpathSync(cwdLocalPackage) === fs.realpathSync(packageRoot)) {
+      return `file:${path.relative(projectPath, cwdLocalPackage)}`;
+    }
+  } catch {
+  }
+  return `^${readPackageVersion()}`;
+}
+__name(resolveCreateWextsDependency, "resolveCreateWextsDependency");
+async function scaffoldGenerator(options) {
+  if (options.type !== "config" && !options.name) {
+    throw new WextsError({
+      code: "WEXTS_CLI_GENERATOR_NAME_REQUIRED",
+      message: `Generator "${options.type}" requires a name.`,
+      suggestedFix: `Run \`wexts generate ${options.type} hello\` or use \`wexts generate config\`.`,
+      docsSlug: "cli"
+    });
+  }
+  if (options.type === "config") {
+    return writeGeneratedFiles(options.targetRoot, [
+      {
+        relativePath: "wexts.runtime.js",
+        content: `/** @type {import('wexts/runtime').WextsRuntimeConfig} */
+module.exports = {
+  rootDir: __dirname,
+  port: Number(process.env.PORT || 3000),
+  rpcManifestPath: 'apps/web/lib/wexts/wexts.rpc.manifest.json',
+  security: {
+    enabled: true,
+    production: process.env.NODE_ENV === 'production',
+    allowedOrigins: process.env.WEXTS_ALLOWED_ORIGINS?.split(',').filter(Boolean) || [],
+  },
+};
+`
+      }
+    ], Boolean(options.force));
+  }
+  const rawName = options.name;
+  const name = toKebabCase(rawName);
+  const classBase = toPascalCase(name);
+  const srcRoot = path.join(options.targetRoot, "src");
+  const filesByType = {
+    rpc: rpcServiceFiles(name, classBase),
+    service: [
+      {
+        relativePath: path.join("src", name, `${name}.service.ts`),
+        content: `import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ${classBase}Service {
+  async execute(): Promise<string> {
+    return '${toCamelCase(name)}';
+  }
+}
+`
+      }
+    ],
+    module: [
+      {
+        relativePath: path.join("src", name, `${name}.module.ts`),
+        content: `import { Module } from '@nestjs/common';
+
+@Module({})
+export class ${classBase}Module {}
+`
+      }
+    ],
+    entity: [
+      {
+        relativePath: path.join("src", name, `${name}.entity.ts`),
+        content: `export interface ${classBase}Entity {
+  id: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+`
+      }
+    ],
+    guard: [
+      {
+        relativePath: path.join("src", name, `${name}.guard.ts`),
+        content: `import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
+
+@Injectable()
+export class ${classBase}Guard implements CanActivate {
+  canActivate(_context: ExecutionContext): boolean {
+    return true;
+  }
+}
+`
+      }
+    ]
+  };
+  fs.mkdirSync(srcRoot, {
+    recursive: true
+  });
+  return writeGeneratedFiles(options.targetRoot, filesByType[options.type], Boolean(options.force));
+}
+__name(scaffoldGenerator, "scaffoldGenerator");
+function isScaffoldGenerator(type) {
+  return [
+    "rpc",
+    "service",
+    "module",
+    "entity",
+    "guard",
+    "config"
+  ].includes(type);
+}
+__name(isScaffoldGenerator, "isScaffoldGenerator");
+function rpcServiceFiles(serviceName, classBase) {
+  return [
+    {
+      relativePath: path.join("src", serviceName, `${serviceName}.service.ts`),
+      content: `import { Injectable } from '@nestjs/common';
+import { RpcMethod, RpcService } from 'wexts/nest';
+
+@Injectable()
+@RpcService({ name: '${toCamelCase(serviceName)}', requireAuth: false })
+export class ${classBase}Service {
+  @RpcMethod()
+  async sayHello(name: string): Promise<string> {
+    return \`Hello, \${name}!\`;
+  }
+}
+`
+    }
+  ];
+}
+__name(rpcServiceFiles, "rpcServiceFiles");
+function writeGeneratedFiles(root, files, force) {
+  const changedFiles = [];
+  for (const file of files) {
+    const absolutePath = path.join(root, file.relativePath);
+    if (fs.existsSync(absolutePath) && !force) {
+      throw new WextsError({
+        code: "WEXTS_CLI_GENERATOR_FILE_EXISTS",
+        message: `Refusing to overwrite existing file: ${absolutePath}`,
+        suggestedFix: "Review the file, then rerun with --force if overwriting is intentional.",
+        docsSlug: "cli"
       });
     }
-    execSync("pnpm install", {
-      cwd: projectPath,
-      stdio: "inherit"
+    fs.mkdirSync(path.dirname(absolutePath), {
+      recursive: true
     });
-    logger.success("\u2705 Dependencies installed");
-    logger.info(pc.green(`
-\u{1F389} Project ${projectName} created successfully!`));
-    logger.info(`
-To get started:
-`);
-    logger.info(pc.cyan(`  cd ${projectName}`));
-    logger.info(pc.cyan(`  pnpm dev
-`));
-  } catch (error) {
-    logger.error("Failed to install dependencies");
+    fs.writeFileSync(absolutePath, file.content);
+    changedFiles.push(absolutePath);
   }
+  return changedFiles;
 }
-__name(createProject, "createProject");
-program.parse();
+__name(writeGeneratedFiles, "writeGeneratedFiles");
+function runScript(script, options) {
+  const cwd = options.cwd ?? process.cwd();
+  const packageManager = detectPackageManager(cwd);
+  const args = packageManager === "npm" ? [
+    "run",
+    script
+  ] : [
+    "run",
+    script
+  ];
+  runCommand(packageManager, args, cwd);
+}
+__name(runScript, "runScript");
+function runCommand(command, args, cwd) {
+  const result = spawnSync(command, args, {
+    cwd,
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  });
+  if (result.status !== 0) {
+    throw new Error(`${command} ${args.join(" ")} failed with exit code ${result.status}`);
+  }
+}
+__name(runCommand, "runCommand");
+function detectPackageManager(cwd) {
+  const packageJsonPath = path.join(cwd, "package.json");
+  if (fs.existsSync(packageJsonPath)) {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    if (pkg.packageManager?.startsWith("pnpm@")) return "pnpm";
+  }
+  if (fs.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs.existsSync(path.join(cwd, "pnpm-workspace.yaml"))) return "pnpm";
+  return "npm";
+}
+__name(detectPackageManager, "detectPackageManager");
+function findTemplatePath() {
+  const candidates = [
+    path.resolve(__dirname, "../../templates"),
+    path.resolve(__dirname, "../templates"),
+    path.resolve(process.cwd(), "packages/templates")
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate));
+}
+__name(findTemplatePath, "findTemplatePath");
+function readPackageVersion() {
+  const packageJsonPath = path.resolve(__dirname, "../../package.json");
+  if (!fs.existsSync(packageJsonPath)) return "0.0.0";
+  return JSON.parse(fs.readFileSync(packageJsonPath, "utf8")).version;
+}
+__name(readPackageVersion, "readPackageVersion");
+function readAllText(cwd, dirs) {
+  let text = "";
+  for (const dir of dirs) {
+    const absolute = path.join(cwd, dir);
+    if (!fs.existsSync(absolute)) continue;
+    for (const file of walk(absolute)) {
+      if (file.endsWith(".ts") || file.endsWith(".tsx") || file.endsWith(".js")) {
+        text += fs.readFileSync(file, "utf8");
+      }
+    }
+  }
+  return text;
+}
+__name(readAllText, "readAllText");
+function walk(dir) {
+  return fs.readdirSync(dir, {
+    withFileTypes: true
+  }).flatMap((entry) => {
+    const absolute = path.join(dir, entry.name);
+    if (entry.isDirectory()) return walk(absolute);
+    return [
+      absolute
+    ];
+  });
+}
+__name(walk, "walk");
+function toKebabCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[_\s]+/g, "-").toLowerCase();
+}
+__name(toKebabCase, "toKebabCase");
+function toPascalCase(value) {
+  return toKebabCase(value).split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+__name(toPascalCase, "toPascalCase");
+function toCamelCase(value) {
+  const pascal = toPascalCase(value);
+  return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+__name(toCamelCase, "toCamelCase");
+function pathToFileUrl(filePath) {
+  return `file://${filePath}`;
+}
+__name(pathToFileUrl, "pathToFileUrl");
+async function loadRuntimeConfig(configPath) {
+  if (configPath.endsWith(".mjs")) {
+    const mod2 = await import(pathToFileUrl(configPath));
+    return mod2.default ?? mod2;
+  }
+  const require2 = createRequire(__filename);
+  const mod = require2(configPath);
+  return mod.default ?? mod;
+}
+__name(loadRuntimeConfig, "loadRuntimeConfig");
+var invokedAsCli = process.argv[1] && (path.basename(process.argv[1]) === "wexts" || path.basename(process.argv[1]) === "wexts.cjs" || path.resolve(process.argv[1]).includes(`${path.sep}dist${path.sep}cli${path.sep}index`));
+if (invokedAsCli && !process.env.VITEST) {
+  createCliProgram().parseAsync(process.argv).catch((error) => {
+    logger.error(formatWextsError(error));
+    process.exit(1);
+  });
+}
+export {
+  createCliProgram,
+  createProject,
+  runDoctor,
+  scaffoldGenerator
+};
 //# sourceMappingURL=index.mjs.map