@zucker-framework/cli 1.0.1 → 1.0.2

package/dist/index.mjs

@@ -0,0 +1,828 @@
+#!/usr/bin/env node
+import {
+  __name
+} from "./chunk-O6YSETKJ.mjs";
+
+// src/bin.ts
+import "dotenv/config";
+import { Command as Command6 } from "commander";
+import { readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve5 } from "path";
+
+// src/commands/doctor.ts
+import { Command } from "commander";
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+async function runDiagnostics() {
+  const results = [];
+  const cwd = process.cwd();
+  const pkgPath = resolve(cwd, "package.json");
+  if (!existsSync(pkgPath)) {
+    results.push({
+      name: "package.json",
+      status: "error",
+      message: "package.json not found. Are you in a Zucker project directory?"
+    });
+    return results;
+  }
+  results.push({
+    name: "package.json",
+    status: "ok",
+    message: "Found"
+  });
+  const nodeVersion = process.versions.node;
+  const major = parseInt(nodeVersion.split(".")[0], 10);
+  if (major < 20) {
+    results.push({
+      name: "Node.js",
+      status: "error",
+      message: `v${nodeVersion} detected. Zucker requires Node.js >= 20.`
+    });
+  } else {
+    results.push({
+      name: "Node.js",
+      status: "ok",
+      message: `v${nodeVersion}`
+    });
+  }
+  let pkg = {};
+  try {
+    pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  } catch {
+    results.push({
+      name: "package.json",
+      status: "error",
+      message: "Failed to parse package.json"
+    });
+    return results;
+  }
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  const requiredPkgs = [
+    "@zucker-framework/core",
+    "@zucker-framework/crud",
+    "@zucker-framework/common"
+  ];
+  for (const name of requiredPkgs) {
+    if (deps[name]) {
+      results.push({
+        name,
+        status: "ok",
+        message: deps[name]
+      });
+    } else {
+      results.push({
+        name,
+        status: "warn",
+        message: "Not installed"
+      });
+    }
+  }
+  const envChecks = [
+    {
+      name: "JWT_SECRET",
+      envVar: "JWT_SECRET",
+      required: true
+    },
+    {
+      name: "DATABASE_URL",
+      envVar: "DATABASE_URL",
+      required: false
+    }
+  ];
+  for (const check of envChecks) {
+    const value = process.env[check.envVar];
+    if (value) {
+      results.push({
+        name: check.name,
+        status: "ok",
+        message: `Set (${value.substring(0, 8)}...)`
+      });
+    } else if (check.required) {
+      results.push({
+        name: check.name,
+        status: "warn",
+        message: "Not set. Required for production."
+      });
+    } else {
+      results.push({
+        name: check.name,
+        status: "ok",
+        message: "Not set (optional \u2014 will use InMemoryAdapter)"
+      });
+    }
+  }
+  const envLocalPath = resolve(cwd, ".env.local");
+  if (existsSync(envLocalPath)) {
+    results.push({
+      name: ".env.local",
+      status: "ok",
+      message: "Found"
+    });
+  } else {
+    results.push({
+      name: ".env.local",
+      status: "warn",
+      message: "Not found. Consider creating one for local development."
+    });
+  }
+  const tsconfigPath = resolve(cwd, "tsconfig.json");
+  if (existsSync(tsconfigPath)) {
+    results.push({
+      name: "tsconfig.json",
+      status: "ok",
+      message: "Found"
+    });
+  } else {
+    results.push({
+      name: "tsconfig.json",
+      status: "error",
+      message: "Not found"
+    });
+  }
+  return results;
+}
+__name(runDiagnostics, "runDiagnostics");
+function formatStatus(status) {
+  switch (status) {
+    case "ok":
+      return "\x1B[32m[OK]\x1B[0m";
+    case "warn":
+      return "\x1B[33m[WARN]\x1B[0m";
+    case "error":
+      return "\x1B[31m[ERROR]\x1B[0m";
+  }
+}
+__name(formatStatus, "formatStatus");
+var doctorCommand = new Command("doctor").description("Check project health and configuration").action(async () => {
+  console.log("\n  Zucker Doctor\n");
+  console.log("  Running diagnostics...\n");
+  const results = await runDiagnostics();
+  const maxNameLen = Math.max(...results.map((r) => r.name.length));
+  for (const result of results) {
+    const padding = " ".repeat(maxNameLen - result.name.length);
+    console.log(`  ${formatStatus(result.status)}  ${result.name}${padding}  ${result.message}`);
+  }
+  const errors = results.filter((r) => r.status === "error");
+  const warnings = results.filter((r) => r.status === "warn");
+  console.log("");
+  if (errors.length > 0) {
+    console.log(`  \x1B[31m${errors.length} error(s)\x1B[0m found. Please fix them before proceeding.`);
+  } else if (warnings.length > 0) {
+    console.log(`  \x1B[33m${warnings.length} warning(s)\x1B[0m found. Review them for production readiness.`);
+  } else {
+    console.log("  \x1B[32mAll checks passed!\x1B[0m");
+  }
+  console.log("");
+});
+
+// src/commands/init.ts
+import { Command as Command2 } from "commander";
+import { existsSync as existsSync2, mkdirSync, writeFileSync, readFileSync as readFileSync2, cpSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { randomBytes } from "crypto";
+function readReleaseCatalog() {
+  const path = resolve2(__dirname, "release-catalog.json");
+  if (!existsSync2(path)) throw new Error("CLI release catalog is missing; build or reinstall the CLI package.");
+  return JSON.parse(readFileSync2(path, "utf8"));
+}
+__name(readReleaseCatalog, "readReleaseCatalog");
+var initCommand = new Command2("init").description("Initialize a new Zucker project").argument("[name]", "Project name", "zucker-app").option("--template <template>", "Template to use (server, admin, web)", "server").action(async (name, options) => {
+  if (![
+    "server",
+    "admin",
+    "web"
+  ].includes(options.template)) {
+    throw new Error(`Unsupported template: ${options.template}`);
+  }
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(name)) throw new Error("Project name must use lowercase letters, digits, dots, underscores or hyphens.");
+  const catalog = readReleaseCatalog();
+  const targetDir = resolve2(process.cwd(), name);
+  console.log(`
+  Initializing Zucker project: ${name}`);
+  console.log(`  Template: ${options.template}`);
+  console.log(`  Directory: ${targetDir}
+`);
+  if (existsSync2(targetDir)) {
+    console.log(`  \x1B[31mError:\x1B[0m Directory "${name}" already exists.`);
+    process.exit(1);
+  }
+  const monorepoTemplate = resolve2(__dirname, "..", "..", "..", "templates", options.template);
+  const templateDir2 = existsSync2(monorepoTemplate) ? monorepoTemplate : null;
+  if (!templateDir2) {
+    if (options.template !== "server") {
+      throw new Error(`The ${options.template} template requires a framework checkout. The installed CLI includes the standalone server scaffold.`);
+    }
+    console.log(`  \x1B[33mNote:\x1B[0m Template "${options.template}" not found locally.`);
+    console.log("  Generating minimal project scaffold instead.\n");
+    mkdirSync(resolve2(targetDir, "src"), {
+      recursive: true
+    });
+    const pkg = {
+      name,
+      version: "0.1.0",
+      private: true,
+      type: "commonjs",
+      engines: {
+        node: ">=22.12.0"
+      },
+      scripts: {
+        dev: "nest start --watch",
+        build: "nest build",
+        start: "node dist/main.js"
+      },
+      dependencies: catalog.server.dependencies,
+      devDependencies: catalog.server.devDependencies
+    };
+    writeFileSync(resolve2(targetDir, "package.json"), JSON.stringify(pkg, null, 2) + "\n");
+    const tsconfig = {
+      compilerOptions: {
+        module: "NodeNext",
+        moduleResolution: "NodeNext",
+        target: "ES2022",
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+        sourceMap: false,
+        declarationMap: false,
+        outDir: "dist",
+        rootDir: "src"
+      },
+      include: [
+        "src"
+      ]
+    };
+    writeFileSync(resolve2(targetDir, "tsconfig.json"), JSON.stringify(tsconfig, null, 2) + "\n");
+    writeFileSync(resolve2(targetDir, "nest-cli.json"), JSON.stringify({
+      sourceRoot: "src",
+      compilerOptions: {
+        deleteOutDir: true
+      }
+    }, null, 2) + "\n");
+    writeFileSync(resolve2(targetDir, ".gitignore"), "node_modules/\ndist/\n.env\n.env.local\n");
+    writeFileSync(resolve2(targetDir, ".env"), `JWT_SECRET=${randomBytes(32).toString("hex")}
+`, {
+      mode: 384
+    });
+    writeFileSync(resolve2(targetDir, ".env.example"), [
+      "# JWT secret \u2014 required for production",
+      "# JWT_SECRET=your-secure-secret-here",
+      "",
+      "# Database URL \u2014 leave unset to use InMemoryAdapter",
+      "# DATABASE_URL=postgresql://user:pass@localhost:5432/zucker",
+      ""
+    ].join("\n"));
+    writeFileSync(resolve2(targetDir, "src", "main.ts"), [
+      "import 'dotenv/config';",
+      "import { NestFactory } from '@nestjs/core';",
+      "import { ValidationPipe, Logger } from '@nestjs/common';",
+      "import { HttpExceptionFilter } from '@zucker-framework/common';",
+      "import { AppModule } from './app.module';",
+      "",
+      "async function bootstrap() {",
+      "  const startTime = performance.now();",
+      "  const app = await NestFactory.create(AppModule);",
+      "",
+      "  app.setGlobalPrefix('api');",
+      "  app.useGlobalFilters(new HttpExceptionFilter());",
+      "  app.useGlobalPipes(new ValidationPipe({ transform: true }));",
+      "",
+      "  const port = process.env.PORT || 4200;",
+      "  await app.listen(port);",
+      "",
+      "  const elapsed = (performance.now() - startTime).toFixed(0);",
+      "  Logger.log(`Server ready on http://localhost:${port} (${elapsed}ms)`, 'Bootstrap');",
+      "}",
+      "",
+      "bootstrap();",
+      ""
+    ].join("\n"));
+    writeFileSync(resolve2(targetDir, "src", "app.module.ts"), [
+      "import { Module } from '@nestjs/common';",
+      "import { EventEmitterModule } from '@nestjs/event-emitter';",
+      "import { ZuckerEventModule } from '@zucker-framework/event';",
+      "import { ZuckerCommonModule } from '@zucker-framework/common';",
+      "import { ZuckerCrudModule, InMemoryAdapter } from '@zucker-framework/crud';",
+      "import { ZuckerAuthModule } from '@zucker-framework/auth';",
+      "",
+      "@Module({",
+      "  imports: [",
+      "    EventEmitterModule.forRoot(),",
+      "    ZuckerEventModule.forRoot(),",
+      "    ZuckerCommonModule,",
+      "    ZuckerCrudModule.forRoot({ adapterClass: InMemoryAdapter }),",
+      "    ZuckerAuthModule.forRoot({ jwtSecret: process.env.JWT_SECRET }),",
+      "  ],",
+      "})",
+      "export class AppModule {}",
+      ""
+    ].join("\n"));
+    console.log("  \x1B[32mProject scaffolded successfully!\x1B[0m\n");
+    console.log("  Next steps:");
+    console.log(`    cd ${name}`);
+    console.log("    pnpm install");
+    console.log("    pnpm dev\n");
+    return;
+  }
+  console.log(`  Copying template from ${templateDir2}...
+`);
+  cpSync(templateDir2, targetDir, {
+    recursive: true,
+    filter: /* @__PURE__ */ __name((src) => !src.split(/[\\/]/).some((part) => [
+      "node_modules",
+      "dist",
+      ".turbo",
+      ".next",
+      ".cache",
+      "generated"
+    ].includes(part) || part.startsWith(".env") && part !== ".env.example" || part.endsWith(".tsbuildinfo")), "filter")
+  });
+  const copiedManifestPath = resolve2(targetDir, "package.json");
+  const copiedManifest = JSON.parse(readFileSync2(copiedManifestPath, "utf8"));
+  copiedManifest.name = name;
+  for (const field of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies"
+  ]) {
+    const entries = copiedManifest[field];
+    for (const [dependency, version] of Object.entries(entries ?? {})) {
+      if (!version.startsWith("workspace:")) continue;
+      const releasedVersion = catalog.versions[dependency];
+      if (!releasedVersion) throw new Error(`No release version found for ${dependency}`);
+      entries[dependency] = releasedVersion;
+    }
+  }
+  writeFileSync(copiedManifestPath, JSON.stringify(copiedManifest, null, 2) + "\n");
+  console.log("  \x1B[32mProject created successfully!\x1B[0m\n");
+  console.log("  Next steps:");
+  console.log(`    cd ${name}`);
+  console.log("    pnpm install");
+  console.log("    pnpm dev\n");
+});
+
+// src/commands/add.ts
+import { Command as Command3 } from "commander";
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+import { execSync } from "child_process";
+var MODULE_REGISTRY = {
+  auth: {
+    pkg: "@zucker-framework/auth",
+    peerDeps: [
+      "@nestjs/passport",
+      "@nestjs/jwt"
+    ],
+    moduleImport: "import { ZuckerAuthModule } from '@zucker-framework/auth';",
+    moduleSetup: "ZuckerAuthModule.forRoot({ jwtSecret: process.env.JWT_SECRET })"
+  },
+  logging: {
+    pkg: "@zucker-framework/logging",
+    moduleImport: "import { ZuckerLoggingModule } from '@zucker-framework/logging';",
+    moduleSetup: "ZuckerLoggingModule.forRoot()"
+  },
+  config: {
+    pkg: "@zucker-framework/config",
+    moduleImport: "import { ZuckerConfigModule } from '@zucker-framework/config';",
+    moduleSetup: "ZuckerConfigModule.forRoot()"
+  },
+  dictionary: {
+    pkg: "@zucker-framework/dictionary",
+    moduleImport: "import { ZuckerDictionaryModule } from '@zucker-framework/dictionary';",
+    moduleSetup: "ZuckerDictionaryModule.forRoot()"
+  },
+  cache: {
+    pkg: "@zucker-framework/cache",
+    moduleImport: "import { ZuckerCacheModule } from '@zucker-framework/cache';",
+    moduleSetup: "ZuckerCacheModule.forRoot({ provider: 'memory' })"
+  },
+  storage: {
+    pkg: "@zucker-framework/storage",
+    moduleImport: "import { ZuckerStorageModule } from '@zucker-framework/storage';",
+    moduleSetup: "ZuckerStorageModule.forRoot({ provider: 'local', basePath: './uploads' })"
+  },
+  notification: {
+    pkg: "@zucker-framework/notification",
+    moduleImport: "import { ZuckerNotificationModule } from '@zucker-framework/notification';",
+    moduleSetup: "ZuckerNotificationModule.forRoot({ providers: [] })"
+  },
+  credit: {
+    pkg: "@zucker-framework/credit",
+    moduleImport: "import { ZuckerCreditModule } from '@zucker-framework/credit';",
+    moduleSetup: "ZuckerCreditModule.forRoot()"
+  },
+  ai: {
+    pkg: "@zucker-framework/ai",
+    moduleImport: "import { ZuckerAIModule } from '@zucker-framework/ai';",
+    moduleSetup: "ZuckerAIModule.forRoot()"
+  },
+  tenant: {
+    pkg: "@zucker-framework/tenant",
+    moduleImport: "import { ZuckerTenantModule } from '@zucker-framework/tenant';",
+    moduleSetup: "ZuckerTenantModule.forRoot()"
+  },
+  form: {
+    pkg: "@zucker-framework/form",
+    moduleImport: "import { ZuckerFormModule } from '@zucker-framework/form';",
+    moduleSetup: "ZuckerFormModule.forRoot()"
+  },
+  monitoring: {
+    pkg: "@zucker-framework/monitoring",
+    moduleImport: "import { ZuckerMonitoringModule } from '@zucker-framework/monitoring';",
+    moduleSetup: "ZuckerMonitoringModule"
+  },
+  "rate-limiter": {
+    pkg: "@zucker-framework/rate-limiter",
+    moduleImport: "import { ZuckerRateLimiterModule } from '@zucker-framework/rate-limiter';",
+    moduleSetup: `ZuckerRateLimiterModule.forRoot({
+      limiters: {
+        login: { points: 5, duration: 900 },
+        'api-default': { points: 100, duration: 60 },
+      },
+    })`
+  }
+};
+function detectPackageManager() {
+  const cwd = process.cwd();
+  if (existsSync3(resolve3(cwd, "pnpm-lock.yaml")) || existsSync3(resolve3(cwd, "pnpm-workspace.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync3(resolve3(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+__name(detectPackageManager, "detectPackageManager");
+var addCommand = new Command3("add").description("Add a Zucker module to the current project").argument("<module>", `Module name (${Object.keys(MODULE_REGISTRY).join(", ")})`).option("--dry-run", "Show what would be done without making changes", false).action(async (moduleName, options) => {
+  const entry = MODULE_REGISTRY[moduleName];
+  if (!entry) {
+    console.log(`
+  \x1B[31mError:\x1B[0m Unknown module "${moduleName}".`);
+    console.log(`  Available modules: ${Object.keys(MODULE_REGISTRY).join(", ")}
+`);
+    process.exit(1);
+  }
+  console.log(`
+  Adding @zucker-framework/${moduleName} to your project...
+`);
+  const pm = detectPackageManager();
+  const pkgs = [
+    entry.pkg,
+    ...entry.peerDeps ?? []
+  ];
+  const installCmd = pm === "pnpm" ? `pnpm add ${pkgs.join(" ")}` : pm === "yarn" ? `yarn add ${pkgs.join(" ")}` : `npm install ${pkgs.join(" ")}`;
+  if (options.dryRun) {
+    console.log(`  [dry-run] Would run: ${installCmd}`);
+  } else {
+    console.log(`  Running: ${installCmd}`);
+    try {
+      execSync(installCmd, {
+        stdio: "inherit",
+        cwd: process.cwd()
+      });
+    } catch {
+      console.log(`
+  \x1B[33mWarning:\x1B[0m Package install failed. You may need to install manually.
+`);
+    }
+  }
+  console.log("\n  Add the following to your AppModule:\n");
+  console.log(`  \x1B[36m// Import:\x1B[0m`);
+  console.log(`  ${entry.moduleImport}
+`);
+  console.log(`  \x1B[36m// In @Module imports array:\x1B[0m`);
+  console.log(`  ${entry.moduleSetup},
+`);
+  console.log("  \x1B[32mDone!\x1B[0m\n");
+});
+
+// src/commands/ext.ts
+import { Command as Command4 } from "commander";
+import { cpSync as cpSync2, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { join, resolve as resolve4 } from "path";
+var monorepoRoot = resolve4(__dirname, "..", "..", "..");
+var kitDir = join(monorepoRoot, "packages", "ext-kit");
+var templateDir = join(monorepoRoot, "templates", "extension");
+var VENDORED = [
+  {
+    from: join(kitDir, "dist", "ext-kit.js"),
+    to: "lib/ext-kit.js"
+  },
+  {
+    from: join(kitDir, "dist", "ext-kit-popup.js"),
+    to: "lib/ext-kit-popup.js"
+  },
+  {
+    from: join(kitDir, "assets", "offscreen.html"),
+    to: "offscreen.html"
+  },
+  {
+    from: join(kitDir, "assets", "offscreen.js"),
+    to: "offscreen.js"
+  },
+  {
+    from: join(kitDir, "assets", "package.mjs"),
+    to: "scripts/package.mjs"
+  }
+];
+function syncVendored(extDir) {
+  const updated = [];
+  for (const file of VENDORED) {
+    if (!existsSync4(file.from)) {
+      throw new Error(`Kit artifact missing: ${file.from} \u2014 run \`pnpm --filter @zucker-framework/ext-kit build\` first.`);
+    }
+    const dest = join(extDir, file.to);
+    mkdirSync2(join(dest, ".."), {
+      recursive: true
+    });
+    const next = readFileSync3(file.from);
+    const prev = existsSync4(dest) ? readFileSync3(dest) : null;
+    if (!prev || !prev.equals(next)) {
+      writeFileSync2(dest, next);
+      updated.push(file.to);
+    }
+  }
+  return updated;
+}
+__name(syncVendored, "syncVendored");
+function isExtensionDir(dir) {
+  return existsSync4(join(dir, "manifest.json")) && existsSync4(join(dir, "lib", "ext-kit.js"));
+}
+__name(isExtensionDir, "isExtensionDir");
+var createCommand = new Command4("create").description("Scaffold a new browser extension on top of @zucker-framework/ext-kit").argument("<slug>", 'Product slug, lowercase (e.g. "sampleext") \u2014 storage keys & server product id').option("--name <name>", 'Store display name (e.g. "Sample Extension")').option("--brand <brand>", 'Brand word (e.g. "Sample") \u2014 folder prefix, wordmark').option("--desc <desc>", "Store description").option("--accent <color>", "Accent color", "#7c8cff").option("--accent-deep <color>", "Deep accent color", "#5a6cf0").option("--badge <color>", "Badge background color", "#4353d9").option("--dir <dir>", "Target directory (default: <slug>-extension)").action((slug, options) => {
+  if (!/^[a-z][a-z0-9]*$/.test(slug)) {
+    console.log('  \x1B[31mError:\x1B[0m slug must be lowercase alphanumeric, e.g. "sampleext".');
+    process.exit(1);
+  }
+  const brand = options.brand || slug.charAt(0).toUpperCase() + slug.slice(1);
+  const name = options.name || `${brand} Extension`;
+  const desc = options.desc || `${brand} browser extension.`;
+  const targetDir = resolve4(process.cwd(), options.dir || `${slug}-extension`);
+  if (existsSync4(targetDir)) {
+    console.log(`  \x1B[31mError:\x1B[0m Directory already exists: ${targetDir}`);
+    process.exit(1);
+  }
+  if (!existsSync4(templateDir)) {
+    console.log(`  \x1B[31mError:\x1B[0m Template not found: ${templateDir}`);
+    process.exit(1);
+  }
+  cpSync2(templateDir, targetDir, {
+    recursive: true
+  });
+  const repls = [
+    [
+      "__EXT_NAME__",
+      name
+    ],
+    [
+      "__EXT_DESC__",
+      desc
+    ],
+    [
+      "__EXT_BRAND__",
+      brand
+    ],
+    [
+      "__EXT_PREFIX__",
+      slug.toUpperCase()
+    ],
+    [
+      "__EXT_SLUG__",
+      slug
+    ],
+    [
+      "__EXT_ACCENT_DEEP__",
+      options.accentDeep
+    ],
+    [
+      "__EXT_ACCENT__",
+      options.accent
+    ],
+    [
+      "__EXT_BADGE_COLOR__",
+      options.badge
+    ]
+  ];
+  const walk = /* @__PURE__ */ __name((dir) => {
+    for (const entry of readdirSync(dir)) {
+      const p = join(dir, entry);
+      if (statSync(p).isDirectory()) {
+        walk(p);
+      } else {
+        let content = readFileSync3(p, "utf8");
+        for (const [a, b] of repls) {
+          content = content.split(a).join(b);
+        }
+        writeFileSync2(p, content);
+      }
+    }
+  }, "walk");
+  walk(targetDir);
+  const updated = syncVendored(targetDir);
+  console.log(`
+  Created ${targetDir}`);
+  console.log(`  Vendored: ${updated.join(", ")}`);
+  console.log("\n  Next steps:");
+  console.log("  1. Implement capture() in background.js (default: full-page screenshot).");
+  console.log("  2. Adjust popup settings fields in popup/popup.html + popup.js.");
+  console.log("  3. Add icons/ and the manifest icons field.");
+  console.log(`  4. Register product "${slug}" on the licensing server + create a Stripe Payment Link.
+`);
+});
+var syncCommand = new Command4("sync").description("Refresh vendored ext-kit artifacts (lib/ext-kit*.js, offscreen, package script) in extensions").argument("[dirs...]", "Extension directories (default: scan cwd + direct children)").action((dirs) => {
+  let targets = (dirs || []).map((d) => resolve4(process.cwd(), d));
+  if (!targets.length) {
+    const cwd = process.cwd();
+    targets = isExtensionDir(cwd) ? [
+      cwd
+    ] : readdirSync(cwd).map((entry) => join(cwd, entry)).filter((p) => statSync(p).isDirectory() && isExtensionDir(p));
+  }
+  if (!targets.length) {
+    console.log("  No extension directories found (need manifest.json + lib/ext-kit.js).");
+    process.exit(1);
+  }
+  for (const dir of targets) {
+    if (!isExtensionDir(dir)) {
+      console.log(`  Skipped (not an ext-kit extension): ${dir}`);
+      continue;
+    }
+    const updated = syncVendored(dir);
+    console.log(`  ${dir}: ${updated.length ? `updated ${updated.join(", ")}` : "already up to date"}`);
+  }
+});
+var SERVER_FILES = [
+  "core.ts",
+  "stripe.ts",
+  "types.ts"
+];
+var SERVER_BANNER = "// AUTO-GENERATED from zucker-framework packages/ext-server \u2014 DO NOT EDIT.\n// \u4FEE\u6539\u8BF7\u6539\u6846\u67B6\u6E90\u7801\u540E\u8FD0\u884C `zucker ext sync-server <dir>` \u91CD\u65B0\u5206\u53D1\u3002\n";
+var syncServerCommand = new Command4("sync-server").description("Vendor @zucker-framework/ext-server sources (core/stripe/types) into a NestJS app directory").argument("<dir>", "Target directory (e.g. apps/server/src/extension/core)").action((dir) => {
+  const target = resolve4(process.cwd(), dir);
+  mkdirSync2(target, {
+    recursive: true
+  });
+  const updated = [];
+  for (const name of SERVER_FILES) {
+    const src = join(monorepoRoot, "packages", "ext-server", "src", name);
+    if (!existsSync4(src)) {
+      console.log(`  \x1B[31mError:\x1B[0m Missing ${src}`);
+      process.exit(1);
+    }
+    const content = SERVER_BANNER + readFileSync3(src, "utf8");
+    const dest = join(target, name);
+    if (!existsSync4(dest) || readFileSync3(dest, "utf8") !== content) {
+      writeFileSync2(dest, content);
+      updated.push(name);
+    }
+  }
+  console.log(`  ${target}: ${updated.length ? `updated ${updated.join(", ")}` : "already up to date"}`);
+  console.log("  Reminder: prisma \u7247\u6BB5\u89C1 packages/ext-server/assets/extension-product.prisma\uFF08\u624B\u52A8\u5E76\u5165\u6D88\u8D39\u65B9 schema\uFF09");
+});
+var extCommand = new Command4("ext").description("Browser extension scaffolding & vendored kit management").addCommand(createCommand).addCommand(syncCommand).addCommand(syncServerCommand);
+
+// src/commands/ai.ts
+import { Command as Command5 } from "commander";
+import { Pool } from "pg";
+import { AIAccessProviderRegistry, PostgresCredentialProfileStore } from "@zucker-framework/ai-access";
+import { createOpenAICodexAccessProvider } from "@zucker-framework/ai-access/openai-codex";
+function createAICommand(dependencies = {}) {
+  const registry = dependencies.registry ?? createDefaultRegistry();
+  const createStore = dependencies.createStore ?? createPostgresStore;
+  const env = dependencies.env ?? process.env;
+  const write = dependencies.write ?? ((message) => process.stdout.write(`${message}
+`));
+  const line = /* @__PURE__ */ __name((message = "") => write(message), "line");
+  const withStore = /* @__PURE__ */ __name(async (operation) => {
+    const resource = await createStore(requiredDatabaseUrl(env));
+    try {
+      await resource.store.ensureSchema?.();
+      return await operation(resource.store);
+    } finally {
+      await resource.close();
+    }
+  }, "withStore");
+  const providersCommand = new Command5("providers").description("\u5217\u51FA\u5DF2\u5B89\u88C5\u7684 AI Provider").action(() => {
+    for (const provider of registry.list()) {
+      const auth = provider.authMethods.map((method) => method.id).join(", ") || "\u65E0";
+      const sources = provider.credentialSources.map((source) => source.id).join(", ") || "\u65E0";
+      line(`${provider.id}  ${provider.name}`);
+      line(`  \u8BA4\u8BC1\u65B9\u5F0F\uFF1A${auth}`);
+      line(`  \u51ED\u636E\u6765\u6E90\uFF1A${sources}`);
+    }
+  });
+  const storeCommand = new Command5("store").description("\u7BA1\u7406 AI Profile \u5B58\u50A8").addCommand(new Command5("init").description("\u521D\u59CB\u5316 PostgreSQL Profile \u8868").action(async () => {
+    await withStore(async () => void 0);
+    line("AI Profile \u5B58\u50A8\u5DF2\u521D\u59CB\u5316\u3002");
+  }));
+  const loginCommand = new Command5("login").description("\u767B\u5F55 AI Provider \u5E76\u4FDD\u5B58 Profile").argument("<provider>", "Provider ID").option("--profile <name>", "Profile \u540D\u79F0", "default").option("--method <method>", "\u8BA4\u8BC1\u65B9\u5F0F ID").action(async (providerId, options) => {
+    const provider = registry.get(providerId);
+    const method = options.method ? provider.authMethods.find((candidate) => candidate.id === options.method) : provider.authMethods[0];
+    if (!method) throw new Error(`Provider ${providerId} \u4E0D\u652F\u6301\u6307\u5B9A\u7684\u8BA4\u8BC1\u65B9\u5F0F\u3002`);
+    await withStore(async (store) => {
+      await method.login({
+        store,
+        profileName: options.profile,
+        onVerification: /* @__PURE__ */ __name((verification) => {
+          line(`\u8BF7\u6253\u5F00\uFF1A${verification.verificationUrl}`);
+          line(`\u5E76\u8F93\u5165\u8BBE\u5907\u7801\uFF1A${verification.userCode}`);
+        }, "onVerification")
+      });
+    });
+    line(`Provider ${providerId} \u7684 Profile ${options.profile} \u5DF2\u767B\u5F55\u3002`);
+  });
+  const statusCommand = new Command5("status").description("\u67E5\u770B\u5DF2\u4FDD\u5B58\u7684 AI Profile\uFF0C\u4E0D\u663E\u793A\u51ED\u636E\u5185\u5BB9").argument("[provider]", "Provider ID").action(async (providerId) => {
+    if (providerId) registry.get(providerId);
+    const profiles = await withStore((store) => store.list(providerId));
+    if (profiles.length === 0) {
+      line("\u6CA1\u6709\u5DF2\u4FDD\u5B58\u7684 AI Profile\u3002");
+      return;
+    }
+    for (const profile of profiles) line(formatProfileStatus(profile));
+  });
+  const importCommand = new Command5("import").description("\u4ECE\u6587\u4EF6\u5BFC\u5165 Provider Profile").argument("<provider>", "Provider ID").requiredOption("--from-file <path>", "\u51ED\u636E\u6587\u4EF6\u8DEF\u5F84").option("--profile <name>", "Profile \u540D\u79F0", "default").action(async (providerId, options) => {
+    const provider = registry.get(providerId);
+    const source = provider.credentialSources.find((candidate) => candidate.kind === "file");
+    if (!source) throw new Error(`Provider ${providerId} \u4E0D\u652F\u6301\u4ECE\u6587\u4EF6\u5BFC\u5165 Profile\u3002`);
+    const profiles = await source.discover({
+      profileName: options.profile,
+      location: options.fromFile
+    });
+    await withStore(async (store) => {
+      for (const profile of profiles) {
+        if (profile.providerId !== providerId) {
+          throw new Error(`\u51ED\u636E\u6E90\u8FD4\u56DE\u4E86\u9519\u8BEF\u7684 Provider\uFF1A${profile.providerId}`);
+        }
+        await store.save(profile);
+      }
+    });
+    line(`\u5DF2\u5BFC\u5165 ${profiles.length} \u4E2A ${providerId} Profile\u3002`);
+  });
+  const profileCommand = new Command5("profile").description("\u7BA1\u7406 AI Profile").addCommand(importCommand);
+  const smokeCommand = new Command5("smoke").description("\u4F7F\u7528\u6307\u5B9A Profile \u53D1\u8D77\u4E00\u6B21\u6700\u5C0F\u771F\u5B9E\u8BF7\u6C42").argument("<provider>", "Provider ID").requiredOption("--model <model>", "\u6A21\u578B\u540D\u79F0").option("--profile <name>", "Profile \u540D\u79F0", "default").option("--input <text>", "\u6D4B\u8BD5\u8F93\u5165", "\u8BF7\u53EA\u56DE\u590D\uFF1A\u8FDE\u63A5\u6210\u529F").action(async (providerId, options) => {
+    const provider = registry.get(providerId);
+    const result = await withStore((store) => provider.runtime.complete({
+      model: options.model,
+      input: options.input,
+      reasoningEffort: "low",
+      textVerbosity: "low"
+    }, {
+      store,
+      profileName: options.profile
+    }));
+    line(result.content.trim());
+    line(`Token\uFF1A\u8F93\u5165 ${result.tokenUsage.input}\uFF0C\u8F93\u51FA ${result.tokenUsage.output}\uFF0C\u5408\u8BA1 ${result.tokenUsage.total}`);
+  });
+  return new Command5("ai").description("\u7BA1\u7406 AI Provider\u3001\u8BA4\u8BC1 Profile \u4E0E\u8C03\u7528\u9A8C\u8BC1").addCommand(providersCommand).addCommand(storeCommand).addCommand(loginCommand).addCommand(statusCommand).addCommand(profileCommand).addCommand(smokeCommand);
+}
+__name(createAICommand, "createAICommand");
+function createDefaultRegistry() {
+  const registry = new AIAccessProviderRegistry();
+  registry.register(createOpenAICodexAccessProvider());
+  return registry;
+}
+__name(createDefaultRegistry, "createDefaultRegistry");
+async function createPostgresStore(databaseUrl) {
+  const pool = new Pool({
+    connectionString: databaseUrl
+  });
+  return {
+    store: new PostgresCredentialProfileStore({
+      pool
+    }),
+    close: /* @__PURE__ */ __name(() => pool.end(), "close")
+  };
+}
+__name(createPostgresStore, "createPostgresStore");
+function requiredDatabaseUrl(env) {
+  const databaseUrl = env.AI_ACCESS_DATABASE_URL?.trim() || env.DATABASE_URL?.trim();
+  if (!databaseUrl) {
+    throw new Error("\u8BF7\u8BBE\u7F6E AI_ACCESS_DATABASE_URL \u6216 DATABASE_URL \u540E\u518D\u4F7F\u7528 AI Profile\u3002");
+  }
+  return databaseUrl;
+}
+__name(requiredDatabaseUrl, "requiredDatabaseUrl");
+function formatProfileStatus(profile) {
+  const expiresAt = profile.expiresAt;
+  const status = expiresAt && expiresAt <= Date.now() ? "\u5DF2\u8FC7\u671F\uFF0C\u53EF\u5C1D\u8BD5\u81EA\u52A8\u5237\u65B0" : "\u53EF\u7528";
+  const expiry = expiresAt ? new Date(expiresAt).toISOString() : "\u957F\u671F\u6709\u6548";
+  return `${profile.providerId}/${profile.profileName}  ${status}  \u8BA4\u8BC1=${profile.authMethod}  \u5230\u671F=${expiry}`;
+}
+__name(formatProfileStatus, "formatProfileStatus");
+
+// src/bin.ts
+var program = new Command6();
+program.name("zucker").description("CLI tool for Zucker Framework").version(JSON.parse(readFileSync4(resolve5(__dirname, "../package.json"), "utf8")).version);
+program.addCommand(initCommand);
+program.addCommand(doctorCommand);
+program.addCommand(addCommand);
+program.addCommand(extCommand);
+program.addCommand(createAICommand());
+program.parseAsync().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`\u9519\u8BEF\uFF1A${message}
+`);
+  process.exitCode = 1;
+});