create-windy 0.1.0

package/dist/cli.js

@@ -0,0 +1,1662 @@
+#!/usr/bin/env node
+
+// src/arguments.ts
+import { resolve } from "node:path";
+
+// src/profile.ts
+var starterProfile = {
+  key: "private-enterprise",
+  label: "私有部署企业版",
+  isolation: "single-organization-single-tenant",
+  database: "postgresql",
+  includesLicenseAuthority: false
+};
+var projectLicenseKeys = ["UNLICENSED", "MIT", "Apache-2.0"];
+
+// src/optional-module-distribution.ts
+var optionalModuleManifests = [
+  {
+    ...module("system.storage", "文件存储", "上传、下载和对象生命周期。", [
+      "system",
+      "system.settings"
+    ]),
+    packages: ["packages/storage"],
+    fileRoots: ["apps/server/src/storage"],
+    documentation: ["docs/architecture/object-storage.md"],
+    schemaFiles: ["packages/database/src/schema/file-storage.ts"],
+    databaseTables: [
+      "file_upload_sessions",
+      "file_upload_parts",
+      "file_metadata"
+    ]
+  },
+  {
+    ...module("system.agent", "Agent Tool", "受控 Agent 工具宿主。", [
+      "system",
+      "system.audit"
+    ]),
+    fileRoots: [
+      "apps/server/src/agent",
+      "packages/modules/src/system-agent-tools.ts"
+    ],
+    documentation: ["docs/platform/agent-tools.md"]
+  },
+  {
+    ...module("system.scheduler", "任务调度", "任务、重试、历史和恢复。", [
+      "system",
+      "system.audit"
+    ]),
+    fileRoots: [
+      "apps/server/src/scheduler",
+      "apps/server/src/jobs",
+      "apps/server/src/application-services.ts",
+      "apps/web/src/pages/system/components/SchedulerOperationsPanel.vue",
+      "apps/web/src/pages/system/components/SchedulerOperationsPanel.webtest.ts",
+      "apps/web/src/pages/system/components/SchedulerRunTable.vue",
+      "apps/web/src/pages/system/components/SchedulerRunTable.webtest.ts",
+      "apps/web/src/pages/system/components/SchedulerStaleRecoveryForm.vue",
+      "apps/web/src/pages/system/components/SchedulerStaleRecoveryForm.webtest.ts",
+      "apps/web/src/pages/system/composables/useSchedulerOperations.ts",
+      "apps/web/src/pages/system/composables/useSchedulerOperations.webtest.ts"
+    ],
+    documentation: [
+      "docs/architecture/durable-jobs.md",
+      "docs/platform/scheduled-task-executor.md"
+    ],
+    schemaFiles: [
+      "packages/database/src/schema/durable-jobs.ts",
+      "packages/database/src/schema/scheduler.ts"
+    ],
+    databaseTables: [
+      "durable_jobs",
+      "durable_job_stages",
+      "durable_job_attempts",
+      "durable_job_leases",
+      "durable_job_progress",
+      "durable_job_artifacts",
+      "durable_job_failures",
+      "durable_job_recoveries",
+      "scheduled_tasks",
+      "scheduled_task_runs"
+    ]
+  },
+  {
+    ...module("system.notification", "站内通知", "通知发布、阅读和归档。", [
+      "system",
+      "system.identity"
+    ]),
+    fileRoots: [
+      "apps/server/src/notification",
+      "apps/web/src/layout/NotificationMenu.vue",
+      "apps/web/src/layout/NotificationMenu.webtest.ts",
+      "apps/web/src/pages/system/SystemNotificationsPage.vue",
+      "apps/web/src/pages/system/SystemNotificationsPage.webtest.ts",
+      "apps/web/src/pages/system/components/NotificationPublishForm.vue"
+    ],
+    documentation: ["docs/platform/notifications.md"],
+    schemaFiles: ["packages/database/src/schema/notifications.ts"],
+    databaseTables: ["platform_notifications", "notification_reads"]
+  },
+  {
+    ...module("system.workflow", "审批工作流", "审批、转交、超时和补偿。", [
+      "system",
+      "system.identity",
+      "system.notification",
+      "system.scheduler"
+    ]),
+    fileRoots: [
+      "apps/server/src/workflow",
+      "packages/database/src/schema-workflow-notification.test.ts"
+    ],
+    documentation: ["docs/architecture/minimal-approval-workflow.md"],
+    schemaFiles: ["packages/database/src/schema/workflow.ts"],
+    databaseTables: ["workflow_work_items", "workflow_transitions"]
+  },
+  {
+    ...module("system.bulk-data", "批量数据", "批量导入导出与结果留存。", [
+      "system",
+      "system.storage",
+      "system.scheduler"
+    ]),
+    fileRoots: [
+      "apps/server/src/bulk-data",
+      "apps/web/src/pages/system/components/dictionary-bulk",
+      "apps/web/src/pages/system/composables/useDictionaryBulkJobs.ts",
+      "apps/web/src/pages/system/dictionary-bulk-presenter.ts",
+      "apps/web/src/services/bulk-data-api.ts",
+      "packages/database/src/schema-durable-links.test.ts"
+    ],
+    documentation: ["docs/platform/bulk-data-jobs.md"],
+    schemaFiles: ["packages/database/src/schema/bulk-data.ts"],
+    databaseTables: ["bulk_data_jobs", "bulk_data_artifacts"]
+  },
+  {
+    ...module("system.search", "平台搜索", "权限感知搜索与 Provider 聚合。", [
+      "system"
+    ]),
+    fileRoots: [
+      "apps/server/src/search",
+      "apps/web/src/layout/NavigationSearchDialog.vue",
+      "apps/web/src/layout/NavigationSearchDialog.webtest.ts"
+    ],
+    documentation: ["docs/architecture/search-provider-protocol.md"]
+  },
+  {
+    ...module("system.data-governance", "数据治理", "敏感字段、明文访问和治理导出。", [
+      "system",
+      "system.identity",
+      "system.audit",
+      "system.storage",
+      "system.workflow",
+      "system.scheduler"
+    ]),
+    fileRoots: [
+      "apps/server/src/data-governance",
+      "packages/modules/src/system-api-data-governance.ts",
+      "packages/modules/src/system-data-governance.ts",
+      "packages/modules/src/system-governed-export-bindings.ts",
+      "packages/database/src/schema-governed-exports.test.ts"
+    ],
+    documentation: ["docs/architecture/sensitive-data-governance.md"],
+    schemaFiles: ["packages/database/src/schema/governed-exports.ts"],
+    databaseTables: ["governed_export_requests"]
+  },
+  {
+    ...module("work-order", "示例工单", "可替换的业务模块接入示例。", [
+      "system",
+      "system.identity",
+      "system.search",
+      "system.scheduler"
+    ]),
+    packages: ["packages/example-work-order"],
+    fileRoots: [
+      "apps/server/src/work-order",
+      "apps/server/src/example-modules.ts",
+      "apps/server/src/example-permissions.ts"
+    ],
+    documentation: ["docs/development/example-work-order.md"],
+    schemaFiles: ["packages/database/src/schema/work-orders.ts"],
+    databaseTables: ["work_orders"]
+  }
+];
+function module(name, label, description, dependencies) {
+  const selection = "optional";
+  return {
+    name,
+    version: "0.1.0",
+    label,
+    description,
+    selection,
+    dependencies,
+    conflicts: [],
+    packages: [],
+    fileRoots: [],
+    documentation: [],
+    schemaFiles: [],
+    databaseTables: [],
+    transientDatabaseTables: [],
+    databaseStatementTokens: [],
+    uninstallPolicy: "retain-data"
+  };
+}
+
+// src/module-distribution.ts
+var requiredModuleNames = ["system", "system.identity"];
+var recommendedModuleNames = [
+  "system.settings",
+  "system.configuration",
+  "system.audit",
+  "system.operations"
+];
+var platformModules = [
+  module2("system", "系统核心", "Admin 准入、Feature 与数据库基线。", "required"),
+  module2("system.identity", "身份与权限", "认证、用户、角色、组织和数据范围。", "required", ["system"]),
+  {
+    ...module2("system.settings", "平台设置", "品牌、Logo 与水印。", "recommended", ["system"]),
+    fileRoots: [
+      "apps/server/src/settings",
+      "apps/web/src/pages/settings",
+      "apps/web/src/layout/GlobalWatermark.vue",
+      "apps/web/src/services/platform-settings-api.ts",
+      "apps/web/src/composables/useWatermarkSettings.ts",
+      "apps/web/src/composables/watermark-settings.ts",
+      "apps/web/src/composables/watermark-settings.webtest.ts"
+    ],
+    documentation: ["docs/platform/platform-shell-settings.md"],
+    databaseTables: ["platform_branding_settings"]
+  },
+  {
+    ...module2("system.configuration", "配置版本", "类型化配置、应用和回滚。", "recommended", ["system"]),
+    fileRoots: [
+      "apps/server/src/configuration",
+      "apps/web/src/pages/configuration",
+      "apps/web/src/services/configuration-api.ts",
+      "apps/web/src/composables/useModuleConfigurations.ts"
+    ],
+    documentation: ["docs/platform/module-configuration.md"],
+    databaseTables: ["module_config_versions"],
+    databaseStatementTokens: [
+      "idx_module_config_versions_",
+      "uk_module_config_versions_"
+    ]
+  },
+  {
+    ...module2("system.license", "离线 License", "离线验签、安装和限制态。", "optional", ["system"]),
+    packages: ["packages/license-sdk"],
+    fileRoots: [
+      "apps/server/src/license",
+      "apps/web/src/components/license",
+      "apps/web/src/pages/license",
+      "apps/web/src/composables/useLicenseReminderRefresh.ts",
+      "apps/web/src/composables/useLicenseReminderRefresh.webtest.ts",
+      "apps/web/src/composables/useLicenseRuntime.ts",
+      "apps/web/src/services/license-api.ts",
+      "apps/web/src/pages/dashboard/dashboard-presenter.webtest.ts",
+      "apps/web/src/router/index.webtest.ts"
+    ],
+    documentation: ["docs/license/license-offline-activation-code.md"],
+    schemaFiles: [
+      "packages/database/src/schema/license-legacy.ts",
+      "packages/database/src/schema/license-v1.ts"
+    ],
+    databaseTables: [
+      "license_operators",
+      "license_operator_sessions",
+      "license_keys",
+      "license_key_compatibilities",
+      "license_governance_events",
+      "license_customers",
+      "license_projects",
+      "license_versions",
+      "license_contract_versions",
+      "license_nodes",
+      "licenses",
+      "license_replacements",
+      "license_events",
+      "legacy_license_projects",
+      "legacy_license_issue_records",
+      "legacy_licenses"
+    ],
+    transientDatabaseTables: ["license_issue_records"],
+    databaseStatementTokens: [
+      "reject_license_immutable_mutation",
+      "idx_licenses_",
+      "idx_license_",
+      "uk_license_",
+      "legacy_license_"
+    ]
+  },
+  {
+    ...module2("system.audit", "审计日志", "审计查询、可靠写入和恢复。", "recommended", ["system"]),
+    fileRoots: [
+      "apps/server/src/audit/drizzle-log-store.ts",
+      "apps/server/src/audit/recovery-queue.ts",
+      "apps/server/src/audit/recovery-queue.test.ts",
+      "apps/server/src/audit/reliable-writer.ts",
+      "apps/server/src/audit/reliable-writer.test.ts",
+      "apps/server/src/persistence.integration.test.ts",
+      "apps/server/src/system/audit-routes.ts",
+      "apps/server/src/system/audit-routes.test.ts",
+      "apps/web/src/pages/system/components/AuditActionCell.vue",
+      "apps/web/src/pages/system/components/AuditActionCell.webtest.ts",
+      "apps/web/src/pages/system/components/AuditLogFilters.vue",
+      "apps/web/src/pages/system/components/AuditLogFilters.webtest.ts"
+    ],
+    documentation: ["docs/platform/audit-reliability.md"],
+    databaseTables: ["audit_logs"],
+    databaseStatementTokens: ["idx_audit_logs_"]
+  },
+  {
+    ...module2("system.operations", "运维监控", "服务、数据库、缓存、磁盘和会话监控。", "recommended", ["system", "system.configuration"]),
+    fileRoots: [
+      "apps/server/src/system/operation-monitoring.ts",
+      "apps/server/src/system/operation-monitoring.test.ts",
+      "apps/server/src/system/operations.ts",
+      "apps/server/src/system/operations.test.ts",
+      "apps/server/src/system/postgres-monitoring.ts",
+      "apps/web/src/pages/system/SystemOperationsPage.vue",
+      "apps/web/src/pages/system/SystemOperationsPage.webtest.ts",
+      "apps/web/src/pages/system/components/OperationCacheMonitor.vue",
+      "apps/web/src/pages/system/components/DiskUsageChart.vue",
+      "apps/web/src/pages/system/components/OperationOnlineUsers.vue",
+      "apps/web/src/pages/system/components/OperationOnlineUsers.webtest.ts",
+      "apps/web/src/pages/system/components/OperationServiceMonitor.vue",
+      "apps/web/src/pages/system/components/OperationServiceMonitor.webtest.ts",
+      "apps/web/src/services/operations-api.ts"
+    ],
+    documentation: ["docs/platform/operations-overview.md"]
+  },
+  ...optionalModuleManifests
+];
+var moduleDistributionCatalog = validateCatalog(platformModules);
+function resolveModuleSelection(input = {}) {
+  const known = new Map(moduleDistributionCatalog.map((item) => [item.name, item]));
+  const selected = new Set(requiredModuleNames);
+  if (input.includeAll) {
+    for (const item of moduleDistributionCatalog)
+      selected.add(item.name);
+  } else if (input.includeRecommended !== false) {
+    for (const name of recommendedModuleNames)
+      selected.add(name);
+  }
+  for (const name of input.requested || []) {
+    if (!known.has(name))
+      throw new Error(`未知模块：${name}`);
+    selected.add(name);
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const name of selected) {
+      const manifest = known.get(name);
+      if (!manifest)
+        throw new Error(`未知模块：${name}`);
+      for (const dependency of manifest.dependencies) {
+        if (selected.has(dependency))
+          continue;
+        selected.add(dependency);
+        changed = true;
+      }
+    }
+  }
+  for (const name of selected) {
+    const manifest = known.get(name);
+    for (const conflict of manifest?.conflicts || []) {
+      if (selected.has(conflict))
+        throw new Error(`模块冲突：${name} 与 ${conflict}`);
+    }
+  }
+  return moduleDistributionCatalog.filter(({ name }) => selected.has(name)).map(({ name }) => name);
+}
+function selectedModuleManifests(names) {
+  const selected = new Set(names);
+  const resolved = resolveModuleSelection({
+    requested: names,
+    includeRecommended: false
+  });
+  if (resolved.some((name) => !selected.has(name))) {
+    throw new Error("模块选择缺少依赖，请先通过 resolveModuleSelection 解析");
+  }
+  return moduleDistributionCatalog.filter(({ name }) => selected.has(name));
+}
+function module2(name, label, description, selection, dependencies = []) {
+  return {
+    name,
+    version: "0.1.0",
+    label,
+    description,
+    selection,
+    dependencies,
+    conflicts: [],
+    packages: [],
+    fileRoots: [],
+    documentation: [],
+    schemaFiles: [],
+    databaseTables: [],
+    transientDatabaseTables: [],
+    databaseStatementTokens: [],
+    uninstallPolicy: "retain-data"
+  };
+}
+function validateCatalog(manifests) {
+  const names = new Set;
+  for (const manifest of manifests) {
+    if (names.has(manifest.name))
+      throw new Error(`分发模块重复：${manifest.name}`);
+    names.add(manifest.name);
+  }
+  for (const manifest of manifests) {
+    for (const dependency of manifest.dependencies) {
+      if (!names.has(dependency))
+        throw new Error(`${manifest.name} 依赖未知模块：${dependency}`);
+      if (dependency === manifest.name)
+        throw new Error(`${manifest.name} 不能依赖自身`);
+    }
+    for (const conflict of manifest.conflicts) {
+      if (!names.has(conflict))
+        throw new Error(`${manifest.name} 冲突模块未知：${conflict}`);
+    }
+  }
+  return manifests;
+}
+
+// src/arguments.ts
+function parseArguments(args) {
+  if (args.includes("--help") || args.includes("-h"))
+    return "help";
+  const projectName = readProjectName(args);
+  if (!projectName)
+    throw new Error("请提供项目名，例如：npx create-windy my-app");
+  const profile = readValue(args, "--profile") || starterProfile.key;
+  if (profile !== starterProfile.key) {
+    throw new Error(`当前只支持 ${starterProfile.key} profile`);
+  }
+  const requestedModules = readValues(args, "--module");
+  const includeAll = args.includes("--all-modules");
+  const noOptionalModules = args.includes("--no-optional-modules");
+  if (includeAll && noOptionalModules) {
+    throw new Error("--all-modules 不能与 --no-optional-modules 同时使用");
+  }
+  const projectLicense = readProjectLicense(args);
+  const selectedModules = resolveModuleSelection({
+    requested: requestedModules,
+    includeRecommended: !noOptionalModules,
+    includeAll
+  });
+  const explicitSelection = requestedModules.length > 0 || includeAll || noOptionalModules;
+  return {
+    projectName,
+    targetDirectory: resolve(process.cwd(), projectName),
+    profile,
+    install: !args.includes("--skip-install"),
+    verify: args.includes("--verify"),
+    keepOnError: args.includes("--keep-on-error"),
+    selectedModules,
+    includeExample: selectedModules.includes("work-order"),
+    includeOxc: !args.includes("--no-oxc"),
+    projectLicense,
+    licenseHolder: readValue(args, "--license-holder"),
+    interactive: !args.includes("--yes") && !explicitSelection,
+    initializeGit: !args.includes("--no-git")
+  };
+}
+function readProjectName(args) {
+  const flagsWithValues = new Set([
+    "--profile",
+    "--module",
+    "--license",
+    "--license-holder"
+  ]);
+  for (let index = 0;index < args.length; index += 1) {
+    const value = args[index];
+    if (!value)
+      continue;
+    if (flagsWithValues.has(value)) {
+      index += 1;
+      continue;
+    }
+    if (!value.startsWith("-"))
+      return value;
+  }
+}
+function readValue(args, flag) {
+  const index = args.indexOf(flag);
+  return index >= 0 ? args[index + 1] : undefined;
+}
+function readValues(args, flag) {
+  return args.flatMap((value, index) => value === flag && args[index + 1] ? [args[index + 1]] : []);
+}
+function readProjectLicense(args) {
+  const value = readValue(args, "--license") || "UNLICENSED";
+  if (!projectLicenseKeys.includes(value)) {
+    throw new Error(`不支持的项目许可证：${value}`);
+  }
+  return value;
+}
+var helpText = `create-windy <项目名> [选项]
+
+选项：
+  --profile private-enterprise  单组织、单租户、私有部署 profile
+  --skip-install                只生成文件，不执行 bun install
+  --verify                      安装后执行 typecheck、test 和 build
+  --keep-on-error               失败时保留新生成目录用于诊断
+  --module <key>                增加模块，可重复使用
+  --all-modules                 选择目录中的全部模块
+  --no-optional-modules         只生成 system 与 system.identity
+  --no-oxc                      不引入 Oxlint、Oxfmt 及其配置和脚本
+  --license <SPDX>              UNLICENSED、MIT 或 Apache-2.0
+  --license-holder <名称>       MIT 许可证的权利人名称
+  --yes                         接受默认选择，不进入交互问答
+  --no-git                      不初始化 Git 仓库和创建首次提交
+  -h, --help                    显示帮助
+`;
+
+// src/create-project.ts
+import { mkdir as mkdir4, readdir as readdir4, rm as rm4 } from "node:fs/promises";
+
+// src/commands.ts
+import { spawn } from "node:child_process";
+
+class CommandExecutionError extends Error {
+  constructor(command, args, exitCode, signal) {
+    const outcome = signal ? `信号 ${signal}` : `退出码 ${exitCode ?? "未知"}`;
+    super(`${command} ${args.join(" ")} 执行失败（${outcome}）`);
+    this.name = "CommandExecutionError";
+  }
+}
+async function runCommand(command, args, cwd) {
+  await new Promise((resolve2, reject) => {
+    const child = spawn(command, args, { cwd, stdio: "inherit" });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (code === 0)
+        resolve2();
+      else
+        reject(new CommandExecutionError(command, args, code, signal));
+    });
+  });
+}
+async function installAndVerify(targetDirectory, install, verify, execute = runCommand) {
+  if (install || verify)
+    await execute("bun", ["install"], targetDirectory);
+  if (!verify)
+    return;
+  await execute("bun", ["run", "typecheck"], targetDirectory);
+  await execute("bun", ["run", "test"], targetDirectory);
+  await execute("bun", ["run", "build"], targetDirectory);
+}
+
+// src/bun-runtime.ts
+import { spawn as spawn2 } from "node:child_process";
+var minimumBunVersion = "1.3.14";
+async function assertSupportedBun(readVersion = readBunVersion) {
+  let version;
+  try {
+    version = (await readVersion()).trim();
+  } catch (error) {
+    if (isMissingCommand(error)) {
+      throw new Error(`未检测到 Bun。请先安装 Bun ${minimumBunVersion} 或更高版本，再重新运行 create-windy。`, { cause: error });
+    }
+    throw error;
+  }
+  const parsed = parseVersion(version);
+  if (!parsed || compareVersions(parsed, parseVersion(minimumBunVersion)) < 0) {
+    throw new Error(`当前 Bun 版本为 ${version || "未知"}，create-windy 要求 Bun ${minimumBunVersion} 或更高版本。`);
+  }
+  return version;
+}
+async function readBunVersion() {
+  return await new Promise((resolve2, reject) => {
+    const child = spawn2("bun", ["--version"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => stdout += chunk);
+    child.stderr.on("data", (chunk) => stderr += chunk);
+    child.once("error", reject);
+    child.once("close", (code, signal) => {
+      if (code === 0)
+        resolve2(stdout);
+      else {
+        const outcome = signal ? `信号 ${signal}` : `退出码 ${code ?? "未知"}`;
+        reject(new Error(`bun --version 执行失败（${outcome}）：${stderr.trim()}`));
+      }
+    });
+  });
+}
+function parseVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  if (!match)
+    return;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compareVersions(left, right) {
+  for (let index = 0;index < left.length; index += 1) {
+    const difference = left[index] - right[index];
+    if (difference !== 0)
+      return difference;
+  }
+  return 0;
+}
+function isMissingCommand(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/git.ts
+async function initializeGitRepository(targetDirectory, execute = runCommand) {
+  try {
+    await execute("git", ["init", "-b", "main"], targetDirectory);
+  } catch (error) {
+    return {
+      status: "skipped",
+      warning: `未能初始化 Git 仓库，项目文件已保留。${recoveryHint(error)}`
+    };
+  }
+  try {
+    await execute("git", ["add", "--all"], targetDirectory);
+  } catch (error) {
+    return {
+      status: "skipped",
+      warning: `Git 仓库已初始化，但文件暂未加入暂存区。${recoveryHint(error)}`
+    };
+  }
+  try {
+    await execute("git", ["commit", "-m", "chore: initialize project"], targetDirectory);
+  } catch (error) {
+    return {
+      status: "skipped",
+      warning: "Git 仓库已初始化且文件已暂存，但首次提交未完成。请配置 Git 用户身份后运行 git commit。" + compactReason(error)
+    };
+  }
+  return { status: "committed" };
+}
+function recoveryHint(error) {
+  return `请确认已安装 Git 后手动运行 git init。${compactReason(error)}`;
+}
+function compactReason(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message ? `（原因：${message}）` : "";
+}
+
+// src/generator.ts
+import {
+  copyFile,
+  lstat as lstat3,
+  mkdir as mkdir3,
+  readFile as readFile7,
+  readdir as readdir3,
+  rm as rm3,
+  writeFile as writeFile7
+} from "node:fs/promises";
+import { basename as basename2, extname as extname2, join as join7 } from "node:path";
+
+// src/customer-docker.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var supplierWorkspaceCopies = [
+  "COPY apps/license/package.json apps/license/package.json",
+  "COPY apps/signing-service/package.json apps/signing-service/package.json",
+  "COPY packages/create-windy/package.json packages/create-windy/package.json"
+];
+async function prepareCustomerDockerfiles(root) {
+  await Promise.all(["apps/server/Dockerfile", "apps/web/Dockerfile"].map(async (path) => {
+    const absolutePath = join(root, path);
+    const source = await readFile(absolutePath, "utf8");
+    await writeFile(absolutePath, rewriteCustomerDockerfile(source));
+  }));
+}
+function rewriteCustomerDockerfile(source) {
+  const lines = source.split(`
+`).filter((line) => {
+    return !supplierWorkspaceCopies.includes(line) && !line.includes("deploy/production/server-entrypoint.sh");
+  });
+  return lines.join(`
+`).replace("COPY package.json bun.lock ./", "COPY package.json ./").replace("RUN bun install --frozen-lockfile", "RUN bun install");
+}
+
+// src/code-quality.ts
+import { readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var oxcStarterPolicy = [
+  "- 代码检查与格式化统一使用 Oxc：Oxlint 和 Oxfmt，不使用 ESLint 或 Prettier。",
+  "- Oxc 是 Starter 默认提供的代码质量方案；项目生成后由项目所有者决定是否保留、替换或并行使用其它工具。"
+].join(`
+`);
+var noCodeQualityPolicy = "- 本项目生成时未引入 lint 或 format 工具；项目所有者可按团队需要自行选择。";
+async function reflectCodeQualityChoice(targetDirectory, includeOxc) {
+  const path = join2(targetDirectory, "AGENTS.md");
+  const source = await readFile2(path, "utf8");
+  if (includeOxc)
+    return;
+  if (!source.includes(oxcStarterPolicy)) {
+    throw new Error("无法同步 --no-oxc 的项目开发约束");
+  }
+  await writeFile2(path, source.replace(oxcStarterPolicy, noCodeQualityPolicy));
+}
+
+// src/license-files.ts
+import { mkdir, readFile as readFile3, rm, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname, join as join3, resolve as resolve2 } from "node:path";
+import { fileURLToPath } from "node:url";
+var packageRoot = resolve2(dirname(fileURLToPath(import.meta.url)), "..");
+var apacheLicensePath = resolve2(packageRoot, "assets/LICENSE-Apache-2.0.txt");
+async function applyProjectLicense(targetDirectory, license, holder, year = new Date().getFullYear()) {
+  const target = join3(targetDirectory, "LICENSE");
+  if (license === "UNLICENSED") {
+    await rm(target, { force: true });
+    return;
+  }
+  if (license === "MIT") {
+    const owner = holder?.trim();
+    if (!owner)
+      throw new Error("选择 MIT 时必须填写许可证权利人名称");
+    await mkdir(targetDirectory, { recursive: true });
+    await writeFile3(target, mitLicense(year, owner));
+    return;
+  }
+  await mkdir(targetDirectory, { recursive: true });
+  await writeFile3(target, await readFile3(apacheLicensePath));
+}
+function mitLicense(year, holder) {
+  return `MIT License
+
+Copyright (c) ${year} ${holder}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+}
+
+// src/managed-files.ts
+import { createHash } from "node:crypto";
+import { lstat, readdir, readFile as readFile4, writeFile as writeFile4 } from "node:fs/promises";
+import { join as join4, relative, sep } from "node:path";
+var managedFilesManifestPath = ".windy/files.json";
+var ignoredDirectoryNames = new Set([".git", "node_modules", "dist"]);
+var ignoredFiles = new Set(["bun.lock", managedFilesManifestPath]);
+var projectOwnedRoots = [
+  "apps/web/src/app",
+  "apps/server/src/work-order",
+  "packages/example-work-order"
+];
+var sharedScaffoldRoots = [
+  "README.md",
+  "AGENTS.md",
+  ".env.example",
+  "docker-compose.yml",
+  "apps/web/src/layout",
+  "apps/web/src/router"
+];
+async function writeManagedFilesManifest(targetDirectory, generatorVersion) {
+  const paths = await collectFiles(targetDirectory);
+  const files = await Promise.all(paths.map(async (path) => {
+    const content = await readFile4(join4(targetDirectory, path));
+    return {
+      path,
+      ownership: classifyOwnership(path),
+      hash: createHash("sha256").update(content).digest("hex")
+    };
+  }));
+  const manifest = {
+    schemaVersion: 1,
+    generatorVersion,
+    algorithm: "sha256",
+    files
+  };
+  await writeFile4(join4(targetDirectory, managedFilesManifestPath), `${JSON.stringify(manifest, null, 2)}
+`);
+}
+function classifyOwnership(path) {
+  if (matchesRoot(path, projectOwnedRoots))
+    return "project-owned";
+  if (matchesRoot(path, sharedScaffoldRoots))
+    return "shared-scaffold";
+  return "windy-managed";
+}
+async function collectFiles(root) {
+  const files = [];
+  await visit(root, files);
+  return files.sort();
+  async function visit(directory, output) {
+    for (const name of (await readdir(directory)).sort()) {
+      if (ignoredDirectoryNames.has(name))
+        continue;
+      const path = join4(directory, name);
+      const metadata = await lstat(path);
+      if (metadata.isSymbolicLink())
+        continue;
+      if (metadata.isDirectory()) {
+        await visit(path, output);
+        continue;
+      }
+      const relativePath = relative(root, path).split(sep).join("/");
+      if (!ignoredFiles.has(relativePath))
+        output.push(relativePath);
+    }
+  }
+}
+function matchesRoot(path, roots) {
+  return roots.some((root) => path === root || path.startsWith(`${root}/`));
+}
+
+// src/module-materializer.ts
+import { lstat as lstat2, readFile as readFile5, readdir as readdir2, rm as rm2, writeFile as writeFile5 } from "node:fs/promises";
+import { basename, extname, join as join5, relative as relative2, sep as sep2 } from "node:path";
+var textExtensions = new Set([
+  ".css",
+  ".html",
+  ".json",
+  ".md",
+  ".mjs",
+  ".sql",
+  ".ts",
+  ".vue",
+  ".yaml",
+  ".yml"
+]);
+async function materializeSelectedModules(targetDirectory, selectedNames) {
+  selectedModuleManifests(selectedNames);
+  const selected = new Set(selectedNames);
+  const removed = moduleDistributionCatalog.filter(({ name }) => !selected.has(name));
+  const removedPackageNames = await readRemovedPackageNames(targetDirectory, removed.flatMap(({ packages }) => packages));
+  await stripModuleBlocks(targetDirectory, selected);
+  await pruneDatabaseArtifacts(targetDirectory, removed.flatMap(({ databaseTables, transientDatabaseTables }) => [
+    ...databaseTables,
+    ...transientDatabaseTables
+  ]), removed.flatMap(({ databaseStatementTokens }) => databaseStatementTokens));
+  const removedRoots = removed.flatMap((manifest) => [
+    ...manifest.packages,
+    ...manifest.fileRoots,
+    ...manifest.documentation,
+    ...manifest.schemaFiles
+  ]);
+  await Promise.all([...new Set(removedRoots)].map((path) => rm2(join5(targetDirectory, path), { recursive: true, force: true })));
+  await pruneWorkspaceReferences(targetDirectory, removedPackageNames, removedRoots);
+}
+async function stripModuleBlocks(root, selected) {
+  for (const path of await collectFiles2(root)) {
+    if (!textExtensions.has(extname(path)))
+      continue;
+    const source = await readFile5(path, "utf8");
+    if (!source.includes("@windy-module"))
+      continue;
+    const output = stripTaggedSource(source, selected, relativePath(root, path));
+    await writeFile5(path, output);
+  }
+}
+function stripTaggedSource(source, selected, path = "source") {
+  const stack = [];
+  const output = [];
+  for (const line of source.split(`
+`)) {
+    const marker = line.match(/@windy-module\s+([a-z0-9.-]+)\s+(begin|end)/);
+    if (marker?.[2] === "begin") {
+      const name = marker[1];
+      stack.push({ name, keep: selected.has(name) });
+      continue;
+    }
+    if (marker?.[2] === "end") {
+      const current = stack.pop();
+      if (!current || current.name !== marker[1]) {
+        throw new Error(`${path} 的模块组合标记不成对`);
+      }
+      continue;
+    }
+    if (stack.every(({ keep }) => keep))
+      output.push(line);
+  }
+  if (stack.length)
+    throw new Error(`${path} 的模块组合标记未闭合`);
+  return output.join(`
+`);
+}
+async function readRemovedPackageNames(root, roots) {
+  const names = new Set;
+  for (const packageRoot2 of roots) {
+    try {
+      const value = JSON.parse(await readFile5(join5(root, packageRoot2, "package.json"), "utf8"));
+      if (value.name)
+        names.add(value.name);
+    } catch (error) {
+      if (!isMissing(error))
+        throw error;
+    }
+  }
+  return names;
+}
+async function pruneWorkspaceReferences(root, removedPackages, removedRoots) {
+  for (const path of await collectFiles2(root)) {
+    if (basename(path) === "package.json") {
+      const value = JSON.parse(await readFile5(path, "utf8"));
+      let changed = false;
+      for (const section of ["dependencies", "devDependencies"]) {
+        const dependencies = value[section];
+        for (const name of removedPackages) {
+          if (!dependencies?.[name])
+            continue;
+          delete dependencies[name];
+          changed = true;
+        }
+      }
+      if (changed)
+        await writeFile5(path, `${JSON.stringify(value, null, 2)}
+`);
+      continue;
+    }
+    if (basename(path) !== "Dockerfile")
+      continue;
+    const source = await readFile5(path, "utf8");
+    const output = source.split(`
+`).filter((line) => !removedRoots.some((root2) => line.includes(root2))).join(`
+`);
+    if (output !== source)
+      await writeFile5(path, output);
+  }
+}
+async function pruneDatabaseArtifacts(root, tableNames, statementTokens) {
+  if (!tableNames.length && !statementTokens.length)
+    return;
+  const tablePatterns = tableNames.map((name) => new RegExp(`(?:"${escapeRegExp(name)}"|\\b${escapeRegExp(name)}\\b)`));
+  const drizzleRoot = join5(root, "packages/database/drizzle");
+  try {
+    for (const path of await collectFiles2(drizzleRoot)) {
+      if (path.endsWith(".sql")) {
+        const source = await readFile5(path, "utf8");
+        const statements = source.split("--> statement-breakpoint").map((statement) => statement.trim()).filter(Boolean).filter((statement) => !tablePatterns.some((pattern) => pattern.test(statement)) && !statementTokens.some((token) => statement.includes(token)));
+        await writeFile5(path, statements.length ? `${statements.join(`
+--> statement-breakpoint
+`)}
+` : `-- 此 migration 的模块未被当前项目选择。
+`);
+      } else if (path.endsWith("_snapshot.json")) {
+        const snapshot = JSON.parse(await readFile5(path, "utf8"));
+        for (const name of tableNames)
+          delete snapshot.tables?.[`public.${name}`];
+        await writeFile5(path, `${JSON.stringify(snapshot, null, 2)}
+`);
+      }
+    }
+  } catch (error) {
+    if (!isMissing(error))
+      throw error;
+  }
+}
+async function collectFiles2(root) {
+  const files = [];
+  await visit(root);
+  return files.sort();
+  async function visit(directory) {
+    for (const name of (await readdir2(directory)).sort()) {
+      if ([".git", "node_modules", "dist"].includes(name))
+        continue;
+      const path = join5(directory, name);
+      const metadata = await lstat2(path);
+      if (metadata.isSymbolicLink())
+        continue;
+      if (metadata.isDirectory())
+        await visit(path);
+      else
+        files.push(path);
+    }
+  }
+}
+function relativePath(root, path) {
+  return relative2(root, path).split(sep2).join("/");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isMissing(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/project-files.ts
+var starterCompose = `services:
+  postgres:
+    image: postgres:17-alpine
+    environment:
+      POSTGRES_DB: windy
+      POSTGRES_USER: windy
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:?请在 .env 中设置 POSTGRES_PASSWORD}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U windy -d windy"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+  migrate:
+    build:
+      context: .
+      dockerfile: apps/server/Dockerfile
+    command: ["bun", "run", "db:migrate"]
+    environment:
+      DATABASE_URL: postgresql://windy:\${POSTGRES_PASSWORD}@postgres:5432/windy
+    volumes:
+      - ./packages:/app/packages
+    depends_on:
+      postgres:
+        condition: service_healthy
+
+  server:
+    build:
+      context: .
+      dockerfile: apps/server/Dockerfile
+    command: ["bun", "run", "--cwd", "apps/server", "dev"]
+    environment:
+      NODE_ENV: development
+      PORT: 3000
+      DATABASE_URL: postgresql://windy:\${POSTGRES_PASSWORD}@postgres:5432/windy
+      WINDY_BOOTSTRAP_ADMIN_PASSWORD: \${WINDY_BOOTSTRAP_ADMIN_PASSWORD:?请在 .env 中设置管理员初始密码}
+      WINDY_AUDIT_QUEUE_FILE: /app/data/audit/recovery-queue.json
+      WINDY_CONTAINERIZED: "1"
+      WINDY_SYSTEM_USAGE_PATHS: /app/data/audit
+    ports:
+      - "3000:3000"
+    volumes:
+      - ./apps/server:/app/apps/server
+      - ./packages:/app/packages
+      - server-audit-data:/app/data/audit
+    depends_on:
+      migrate:
+        condition: service_completed_successfully
+
+  web:
+    build:
+      context: .
+      dockerfile: apps/web/Dockerfile
+    command: ["bun", "run", "--cwd", "apps/web", "dev"]
+    environment:
+      NODE_ENV: development
+      WINDY_DEV_PORT: 9746
+      API_UPSTREAM: http://server:3000
+      VITE_DEV_HOST: 0.0.0.0
+    ports:
+      - "9746:9746"
+    volumes:
+      - ./apps/web:/app/apps/web
+      - ./packages:/app/packages
+    depends_on:
+      - server
+
+volumes:
+  postgres-data:
+  server-audit-data:
+`;
+function environmentExample(includeExample) {
+  return `# 复制为 .env 后填写。不要提交真实密码。
+POSTGRES_PASSWORD=
+WINDY_BOOTSTRAP_ADMIN_PASSWORD=
+
+# 可选搜索配置；不配置时启用 Manifest 中默认开启的 Provider。${includeExample ? `
+# SEARCH_PROVIDER_KEYS=work-order.ticket.search` : `
+# 当前 core profile 没有业务 SearchProvider；接入业务模块后再配置 Key。`}
+# SEARCH_PROVIDER_TIMEOUT_MS=800
+# SEARCH_HEALTH_TIMEOUT_MS=500
+# SEARCH_MAX_REQUESTS_PER_MINUTE=30
+`;
+}
+function starterDocsReadme(includeOfflineLicense = true) {
+  return `# Windy Starter 文档
+
+本目录只包含客户运行项目需要的平台架构、开发接入和运维可观测性文档。
+License 签发中心、独立签名服务、Vault、发布治理、内部任务记录和模板产品
+规划属于软件供应方控制面，不进入客户 Starter。
+
+- 架构：从 [Module Manifest 组合](./architecture/module-manifest-composition.md) 开始。
+- 平台开发：从 [系统 CRUD API](./platform/system-crud-api.md) 和 [CRUD 生成器](./development/crud-generator.md) 开始。
+${includeOfflineLicense ? "- License 消费端：[离线激活与安装协议](./license/license-offline-activation-code.md)；运行时 SDK 位于 `packages/license-sdk`。" : ""}
+- 运维：[可观测性](./operations/observability.md) 与 [运维总览](./platform/operations-overview.md)。
+- 兼容：[RuoYi-Vue Adapter](./adapters/ruoyi-vue-compatibility.md)。
+`;
+}
+function starterReadme(projectName, includeExample = true, includeOxc = true, projectLicense = "UNLICENSED", selectedModules = []) {
+  const selected = new Set(selectedModules);
+  const moduleRows = moduleDistributionCatalog.map(({ name, description, selection }) => `| \`${name}\` | ${selected.has(name) ? "已包含" : "未包含"} | ${selection === "required" ? "H0" : "H2"} | ${description} |`).join(`
+`);
+  return `# ${projectName}
+
+${projectName} 是由 create-windy 生成的单组织、单租户企业应用项目。用户功能层位于
+\`/\`，平台管理控制面位于 \`/admin/**\`；业务功能可以按自己的产品习惯开发，不需要
+复用 Admin 页面结构。
+
+本项目固定使用 Bun 1.3.14 或更高版本，当前法律许可为 \`${projectLicense}\`。项目不包含
+软件供应方的 License Authority、内部签名服务、发布密钥或私有源仓库信息。
+${includeExample ? "创建时包含了 `work-order` 示例模块，用于演示 Module Manifest 接入；它不是生产工单产品，可以在正式开发前替换。" : "创建时未选择 `work-order` 示例模块，当前项目只包含平台模块。"}
+
+## 环境要求
+
+- Bun 1.3.14+
+- Docker 与 Docker Compose（推荐的本地完整运行方式）
+- Git（创建器默认已经初始化；使用 \`--no-git\` 时除外）
+
+不要使用 npm、Yarn 或 pnpm 安装本项目依赖，也不要提交它们产生的 lockfile；唯一的
+依赖锁文件是 \`bun.lock\`。
+
+## 第一次运行
+
+\`\`\`bash
+bun install
+cp .env.example .env
+# 为 POSTGRES_PASSWORD 和 WINDY_BOOTSTRAP_ADMIN_PASSWORD 设置本地值
+docker compose up --build
+\`\`\`
+
+| 服务 | 地址 |
+| ---- | ---- |
+| Web | http://localhost:9746 |
+| Server 健康检查 | http://localhost:3000/api/health |
+| PostgreSQL | localhost:5432 |
+
+Docker Web 固定使用 \`9746\`。只在宿主机运行 Web 时使用：
+
+\`\`\`bash
+bun run dev:web
+\`\`\`
+
+本地 Web 从 \`8746\` 开始探测。同一项目已经运行时会直接输出已有地址；其它服务占用
+时会自动使用后续端口，最多检查 100 个。实际地址始终以终端输出为准。
+
+## 页面与登录
+
+| 路径 | 访问要求 | 说明 |
+| ---- | -------- | ---- |
+| \`/login\` | 公开 | 登录成功后回到安全的站内目标，默认进入 \`/\` |
+| \`/\` | 已登录 | 最小用户首页，也是业务功能开发入口 |
+| \`/admin\` | Admin 准入能力 | 平台管理首页 |
+| \`/admin/**\` | 对应 Feature 与 RBAC | 平台配置、身份、审计和运维页面 |
+
+普通用户登录后不会加载 Admin Bootstrap。只有服务端确认 \`system.admin\` 可用且当前
+账号拥有 \`system.admin.access\` 时，首页才显示“进入管理后台”；直接访问 Admin 仍会
+独立校验权限。
+
+## 当前生成选择
+
+| 选项 | 当前项目 |
+| ---- | -------- |
+| Profile | \`private-enterprise\` |
+| Runtime / Package Manager | Bun |
+| 代码质量 | ${includeOxc ? "Oxlint + Oxfmt" : "未预装 lint/format 工具"} |
+| 示例工单 | ${includeExample ? "已包含" : "未包含"} |
+| 法律许可 | \`${projectLicense}\` |
+
+平台当前注册的全部模块如下。H0 表示 profile 锁定核心；H2 表示创建时可以物理包含或
+排除，并已有生成、类型检查、测试和构建证据。H2 不代表项目部署后已经支持无损安装、
+升级或卸载；那需要 H3 的生命周期命令与数据处置证据。
+
+| Module Key | 当前项目 | 热插拔可靠度 | 说明 |
+| ---------- | -------- | ------------ | ---- |
+${moduleRows}
+
+精确生成来源和选择记录在 \`.windy/generation.json\`。当前版本尚未提供通用
+\`module add/remove\` 或 \`windy update\`，不要把 Feature Flag 关闭当成模块已经卸载。
+
+## 常用命令
+
+\`\`\`bash
+bun run dev:web
+bun run dev:server
+bun run typecheck
+bun run test
+bun run build
+${includeOxc ? `bun run lint
+bun run format` : "# 本项目未预装 lint/format 工具，可按团队需要自行选择。"}
+\`\`\`
+
+## 开发约束
+
+- 新增路由默认需要登录；只有显式 public 的页面允许匿名访问。
+- 新功能必须在 Module Manifest 中使用同一稳定基础 key 注册 Feature、RBAC、API、
+  菜单或入口及审计动作。
+- 业务模块默认不进入 Admin；只有明确声明并通过 Guard 的管理能力才注册到
+  \`/admin/**\`。
+- 模块之间通过公开 service、Interface 或注册机制协作，不跨模块直连 Repository。
+- 数据访问通过 Repository + Drizzle，不在业务代码中依赖 PostgreSQL 方言。
+
+平台能力、二次开发约束和运维说明从 [docs/README.md](docs/README.md) 开始。
+
+## Git 与后续升级
+
+create-windy 默认建立 \`main\` 分支并创建 \`chore: initialize project\` 首次提交。若当时
+没有配置 Git 用户身份，文件会保留在暂存区；配置身份后手动提交即可。
+
+未来的 Windy 更新器会根据 project lock 和文件所有权执行三方合并，不会要求连接
+私有源仓库，也不会静默覆盖项目代码。该更新引擎当前尚未交付。
+
+## License
+
+本项目当前法律许可证为 \`${projectLicense}\`。${projectLicense === "UNLICENSED" ? "项目没有附带开源许可证。" : "完整许可证正文位于根目录 `LICENSE`。"}法律许可证与 \`system.license\` 离线运行时授权模块是两个不同概念；更换其中一个
+不会自动更换另一个。
+`;
+}
+
+// src/project-package.ts
+function createStarterPackage(source, projectName, includeOxc = true, projectLicense = "UNLICENSED", selectedModules = []) {
+  const devDependencies = { ...source.devDependencies };
+  if (!includeOxc) {
+    delete devDependencies.oxfmt;
+    delete devDependencies.oxlint;
+  }
+  return {
+    ...source,
+    name: projectName,
+    private: true,
+    license: projectLicense,
+    packageManager: "bun@1.3.14",
+    engines: { ...source.engines, bun: ">=1.3.14" },
+    scripts: {
+      dev: "bun run --cwd apps/web dev",
+      "dev:web": "bun run --cwd apps/web dev",
+      "dev:server": "bun run --cwd apps/server dev",
+      build: "bun run --cwd apps/web build",
+      "db:generate": "drizzle-kit generate --config drizzle.config.ts",
+      "db:migrate": "drizzle-kit migrate --config drizzle.config.ts",
+      "generate:crud": "bun run packages/crud-generator/src/cli.ts",
+      typecheck: [
+        "bun run --cwd apps/web typecheck",
+        "bun run --cwd apps/server typecheck",
+        ...selectedModules.includes("system.license") ? ["bun run --cwd packages/license-sdk typecheck"] : [],
+        ...selectedModules.includes("system.storage") ? ["bun run --cwd packages/storage typecheck"] : [],
+        "bun run --cwd packages/database typecheck",
+        "bun run --cwd packages/crud-generator typecheck"
+      ].join(" && "),
+      ...includeOxc ? { lint: "oxlint .", format: "oxfmt" } : {},
+      test: "bun test && bun run --cwd apps/web test"
+    },
+    devDependencies
+  };
+}
+
+// src/template-manifest.ts
+var templateRootFiles = [
+  ".dockerignore",
+  ".gitignore",
+  ".oxfmtrc.json",
+  ".oxlintrc.json",
+  "AGENTS.md",
+  "README.md",
+  "bunfig.toml",
+  "docker-compose.yml",
+  "drizzle.config.ts",
+  "package.json"
+];
+var templateDirectories = [
+  "apps/server",
+  "apps/web",
+  "examples",
+  "packages/config",
+  "packages/crud-generator",
+  "packages/database",
+  "packages/example-work-order",
+  "packages/license-sdk",
+  "packages/modules",
+  "packages/shared",
+  "packages/storage"
+];
+var templateDocumentationFiles = [
+  "docs/adapters/ruoyi-vue-compatibility.md",
+  "docs/architecture/admin-surface-boundary.md",
+  "docs/architecture/data-scope-query-enforcement.md",
+  "docs/architecture/durable-jobs.md",
+  "docs/architecture/minimal-approval-workflow.md",
+  "docs/architecture/module-manifest-composition.md",
+  "docs/architecture/object-storage.md",
+  "docs/architecture/search-provider-protocol.md",
+  "docs/development/crud-generator.md",
+  "docs/license/license-offline-activation-code.md",
+  "docs/operations/observability.md",
+  "docs/platform/agent-tools.md",
+  "docs/platform/audit-reliability.md",
+  "docs/platform/bulk-data-jobs.md",
+  "docs/platform/data-access-control.md",
+  "docs/platform/module-configuration.md",
+  "docs/platform/navigation-registry.md",
+  "docs/platform/notifications.md",
+  "docs/platform/operations-overview.md",
+  "docs/platform/organization-membership.md",
+  "docs/platform/platform-authentication.md",
+  "docs/platform/platform-shell-settings.md",
+  "docs/platform/scheduled-task-executor.md",
+  "docs/platform/system-crud-api.md",
+  "docs/platform/web-system-crud.md",
+  "docs/product/built-in-roles.md"
+];
+var templatePaths = [
+  ...templateRootFiles,
+  ...templateDirectories,
+  ...templateDocumentationFiles
+];
+function generationTemplatePaths(includeExample, includeOxc = true) {
+  return templatePaths.filter((path) => (includeExample || path !== "packages/example-work-order") && (includeOxc || path !== ".oxfmtrc.json" && path !== ".oxlintrc.json"));
+}
+var excludedNames = new Set([
+  ".DS_Store",
+  ".env",
+  ".git",
+  ".tmp",
+  "dist",
+  "node_modules"
+]);
+var excludedRuntimeFiles = new Set([
+  "credentials.json",
+  "license-state.json",
+  "recovery-queue.json"
+]);
+
+// src/provenance.ts
+import { mkdir as mkdir2, readFile as readFile6, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+var templateMetadataFile = ".windy-template.json";
+var generationMetadataFile = ".windy/generation.json";
+async function readTemplateMetadata(sourceRoot) {
+  const path = join6(sourceRoot, templateMetadataFile);
+  const parsed = JSON.parse(await readFile6(path, "utf8"));
+  if (!isTemplateMetadata(parsed)) {
+    throw new Error("create-windy 模板来源元数据无效");
+  }
+  return parsed;
+}
+async function writeGenerationProvenance(targetDirectory, metadata, profile, selectedModules, includeOxc, legalLicense) {
+  const requested = selectedModuleManifests(selectedModules);
+  const versions = new Map(metadata.modules.map((item) => [item.name, item]));
+  const modules = requested.map(({ name }) => {
+    const version = versions.get(name);
+    if (!version)
+      throw new Error(`模板来源缺少模块版本：${name}`);
+    return version;
+  });
+  const provenance = {
+    ...metadata,
+    windyVersion: metadata.generatorVersion,
+    profile,
+    modules,
+    toolchain: {
+      runtime: "bun",
+      codeQuality: includeOxc ? "oxc" : "none"
+    },
+    legalLicense,
+    appliedRecipes: [],
+    managedFilesManifest: ".windy/files.json",
+    choices: {
+      includeExample: selectedModules.includes("work-order"),
+      includeOxc
+    }
+  };
+  const path = join6(targetDirectory, generationMetadataFile);
+  await mkdir2(join6(path, ".."), { recursive: true });
+  await writeFile6(path, `${JSON.stringify(provenance, null, 2)}
+`);
+}
+function isTemplateMetadata(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const metadata = value;
+  return metadata.schemaVersion === 1 && typeof metadata.templateCommit === "string" && /^[0-9a-f]{40}$/.test(metadata.templateCommit) && typeof metadata.generatorVersion === "string" && metadata.generatorVersion.length > 0 && Array.isArray(metadata.modules) && metadata.modules.every(isModuleVersion);
+}
+function isModuleVersion(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const module3 = value;
+  return typeof module3.name === "string" && module3.name.length > 0 && typeof module3.version === "string" && module3.version.length > 0;
+}
+
+// src/generator.ts
+async function generateProject(input) {
+  validateProjectName(input.projectName);
+  await assertTargetAvailable(input.targetDirectory);
+  await mkdir3(input.targetDirectory, { recursive: true });
+  const includeExample = input.includeExample ?? true;
+  const includeOxc = input.includeOxc ?? true;
+  const projectLicense = input.projectLicense ?? "UNLICENSED";
+  const templateMetadata = await readTemplateMetadata(input.sourceRoot);
+  const selectedModules = input.selectedModules ?? templateMetadata.modules.filter(({ name }) => includeExample || name !== "work-order").map(({ name }) => name);
+  for (const relativePath2 of generationTemplatePaths(true, includeOxc)) {
+    await copyTree(join7(input.sourceRoot, relativePath2), join7(input.targetDirectory, relativePath2));
+  }
+  await materializeSelectedModules(input.targetDirectory, selectedModules);
+  const packagePath = join7(input.targetDirectory, "package.json");
+  const packageJson = JSON.parse(await readFile7(packagePath, "utf8"));
+  await writeFile7(packagePath, `${JSON.stringify(createStarterPackage(packageJson, input.projectName, includeOxc, projectLicense, selectedModules), null, 2)}
+`);
+  await writeFile7(join7(input.targetDirectory, "docker-compose.yml"), starterCompose);
+  await writeFile7(join7(input.targetDirectory, ".env.example"), environmentExample(includeExample));
+  await writeFile7(join7(input.targetDirectory, "README.md"), starterReadme(input.projectName, includeExample, includeOxc, projectLicense, selectedModules));
+  await writeFile7(join7(input.targetDirectory, "docs/README.md"), starterDocsReadme(selectedModules.includes("system.license")));
+  await reflectCodeQualityChoice(input.targetDirectory, includeOxc);
+  await applyProjectLicense(input.targetDirectory, projectLicense, input.licenseHolder);
+  await prepareCustomerDockerfiles(input.targetDirectory);
+  await writeGenerationProvenance(input.targetDirectory, templateMetadata, input.profile ?? starterProfile.key, selectedModules, includeOxc, projectLicense);
+  await rm3(join7(input.targetDirectory, "bun.lock"), { force: true });
+  await writeManagedFilesManifest(input.targetDirectory, templateMetadata.generatorVersion);
+}
+async function assertGeneratedProjectIsClean(targetDirectory) {
+  const violations = [];
+  await walk(targetDirectory, async (path) => {
+    const name = basename2(path);
+    const extension = extname2(name).toLowerCase();
+    if (excludedNames.has(name) || excludedRuntimeFiles.has(name) || [".key", ".pem", ".p12", ".pfx"].includes(extension)) {
+      violations.push(path.slice(targetDirectory.length + 1));
+    }
+  });
+  if (violations.length) {
+    throw new Error(`生成物包含禁止文件：${violations.sort().join("、")}`);
+  }
+}
+function validateProjectName(projectName) {
+  if (!/^[a-z0-9][a-z0-9._-]*$/.test(projectName)) {
+    throw new Error("项目名只能包含小写字母、数字、点、短横线和下划线");
+  }
+  if (projectName === "." || projectName === "..") {
+    throw new Error("项目名不能是当前目录或上级目录");
+  }
+}
+async function assertTargetAvailable(targetDirectory) {
+  try {
+    const entries = await readdir3(targetDirectory);
+    if (entries.length)
+      throw new Error("目标目录不是空目录");
+  } catch (error) {
+    if (isMissing2(error))
+      return;
+    throw error;
+  }
+}
+async function copyTree(source, target) {
+  const metadata = await lstat3(source);
+  const name = basename2(source);
+  if (shouldExclude(name) || metadata.isSymbolicLink())
+    return;
+  if (metadata.isDirectory()) {
+    await mkdir3(target, { recursive: true });
+    for (const child of await readdir3(source)) {
+      await copyTree(join7(source, child), join7(target, child));
+    }
+    return;
+  }
+  await mkdir3(join7(target, ".."), { recursive: true });
+  await copyFile(source, target);
+}
+function shouldExclude(name) {
+  return excludedNames.has(name) || excludedRuntimeFiles.has(name);
+}
+async function walk(directory, visit) {
+  for (const name of await readdir3(directory)) {
+    const path = join7(directory, name);
+    await visit(path);
+    if ((await lstat3(path)).isDirectory())
+      await walk(path, visit);
+  }
+}
+function isMissing2(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/template-root.ts
+import { access } from "node:fs/promises";
+import { dirname as dirname2, resolve as resolve3 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+async function resolveTemplateRoot() {
+  const currentDirectory = dirname2(fileURLToPath2(import.meta.url));
+  const templateRoot = resolve3(currentDirectory, "../template");
+  try {
+    await access(resolve3(templateRoot, "package.json"));
+    return templateRoot;
+  } catch {
+    throw new Error("create-windy 模板快照缺失。开发仓库请先执行 template:sync；发布包应自带模板。");
+  }
+}
+
+// src/create-project.ts
+async function createProject(options, dependencies = {}) {
+  const bunVersion = await (dependencies.checkBun ?? assertSupportedBun)();
+  const targetState = await inspectTarget(options.targetDirectory);
+  const generate = dependencies.generate ?? generateProject;
+  const inspect = dependencies.inspect ?? assertGeneratedProjectIsClean;
+  const resolveTemplate = dependencies.resolveTemplate ?? resolveTemplateRoot;
+  let stage = "生成文件";
+  try {
+    await generate({
+      sourceRoot: await resolveTemplate(),
+      targetDirectory: options.targetDirectory,
+      projectName: options.projectName,
+      includeExample: options.includeExample,
+      includeOxc: options.includeOxc,
+      selectedModules: options.selectedModules,
+      projectLicense: options.projectLicense,
+      licenseHolder: options.licenseHolder,
+      profile: options.profile
+    });
+    stage = "检查生成物";
+    await inspect(options.targetDirectory);
+    stage = "安装与验证";
+    await installAndVerify(options.targetDirectory, options.install, options.verify, dependencies.commandExecutor);
+  } catch (error) {
+    await rollbackFailedTarget(options, targetState);
+    throw stageError(stage, error);
+  }
+  const log = dependencies.log ?? console.log;
+  let gitInitialized = false;
+  if (options.initializeGit) {
+    const result = await (dependencies.initializeGit ?? initializeGitRepository)(options.targetDirectory, dependencies.commandExecutor);
+    gitInitialized = result.status === "committed";
+    if (result.status === "skipped")
+      log(`
+警告：${result.warning}`);
+  }
+  log(`
+已创建 ${options.projectName}`);
+  log(`运行时：Bun ${bunVersion}`);
+  log(options.initializeGit ? gitInitialized ? "Git：已创建 main 分支和首次提交" : "Git：项目已保留，请按上述提示完成初始化" : "Git：已按 --no-git 跳过");
+  log(`下一步：cd ${options.projectName} && bun run dev`);
+}
+async function inspectTarget(path) {
+  try {
+    return (await readdir4(path)).length === 0 ? "empty" : "non-empty";
+  } catch (error) {
+    if (isMissing3(error))
+      return "missing";
+    throw error;
+  }
+}
+async function rollbackFailedTarget(options, initialState) {
+  if (options.keepOnError || initialState === "non-empty")
+    return;
+  await rm4(options.targetDirectory, { recursive: true, force: true });
+  if (initialState === "empty") {
+    await mkdir4(options.targetDirectory, { recursive: true });
+  }
+}
+function stageError(stage, error) {
+  const reason = sanitizeReason(error instanceof Error ? error.message : String(error));
+  return new Error(`create-windy ${stage}阶段失败：${reason}`, {
+    cause: error
+  });
+}
+function sanitizeReason(reason) {
+  return reason.replace(/\b([A-Z][A-Z0-9_]*(?:PASSWORD|SECRET|TOKEN|DATABASE_URL)[A-Z0-9_]*)=\S+/g, "$1=[已隐藏]").replace(/:\/\/([^\s:/]+):([^\s@]+)@/g, "://$1:[已隐藏]@");
+}
+function isMissing3(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+// src/interactive-selection.ts
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+async function applyInteractiveSelection(options, prompter = terminalPrompter()) {
+  if (!options.interactive)
+    return options;
+  const optional = moduleDistributionCatalog.filter(({ name }) => !requiredModuleNames.includes(name));
+  const requested = await prompter.selectModules({
+    choices: optional.map(({ name, label, selection }) => ({
+      value: name,
+      label: `${label} (${name})`,
+      hint: selection === "recommended" ? "推荐，默认选中" : "可选"
+    })),
+    defaults: [...recommendedModuleNames]
+  });
+  const includeOxc = await prompter.confirm("是否引入 Oxlint + Oxfmt？", true);
+  const projectLicense = await prompter.selectLicense();
+  const licenseHolder = projectLicense === "MIT" ? (await prompter.text("MIT 许可证权利人名称：")).trim() : undefined;
+  if (projectLicense === "MIT" && !licenseHolder) {
+    throw new Error("选择 MIT 时必须填写许可证权利人名称");
+  }
+  const selectedModules = resolveModuleSelection({
+    includeRecommended: false,
+    requested
+  });
+  return {
+    ...options,
+    selectedModules,
+    includeExample: selectedModules.includes("work-order"),
+    includeOxc,
+    projectLicense,
+    licenseHolder,
+    interactive: false
+  };
+}
+function terminalPrompter() {
+  const question = async (message) => {
+    const readline = createInterface({ input: stdin, output: stdout });
+    try {
+      return await readline.question(message);
+    } finally {
+      readline.close();
+    }
+  };
+  return {
+    async selectModules({ choices, defaults }) {
+      stdout.write(`
+请选择要生成的平台模块（逗号分隔编号，直接回车采用推荐项）：
+`);
+      choices.forEach((choice, index) => {
+        const checked = defaults.includes(choice.value) ? "x" : " ";
+        stdout.write(`  ${index + 1}. [${checked}] ${choice.label} — ${choice.hint}
+`);
+      });
+      const answer = (await question("> ")).trim();
+      if (!answer)
+        return defaults;
+      const indexes = answer.split(",").map((part) => Number(part.trim()) - 1);
+      if (indexes.some((index) => !Number.isSafeInteger(index) || !choices[index])) {
+        throw new Error("模块选择包含无效编号");
+      }
+      return [...new Set(indexes.map((index) => choices[index].value))];
+    },
+    async confirm(message, defaultValue) {
+      const hint = defaultValue ? "Y/n" : "y/N";
+      const answer = (await question(`${message} (${hint}) `)).trim().toLowerCase();
+      if (!answer)
+        return defaultValue;
+      return answer === "y" || answer === "yes";
+    },
+    async selectLicense() {
+      const answer = (await question(`项目法律许可证：1. UNLICENSED（默认） 2. MIT 3. Apache-2.0
+> `)).trim();
+      if (!answer || answer === "1")
+        return "UNLICENSED";
+      if (answer === "2")
+        return "MIT";
+      if (answer === "3")
+        return "Apache-2.0";
+      throw new Error("许可证选择包含无效编号");
+    },
+    text(message) {
+      return question(message);
+    }
+  };
+}
+
+// src/cli.ts
+async function main() {
+  const options = parseArguments(process.argv.slice(2));
+  if (options === "help") {
+    console.log(helpText);
+    return;
+  }
+  await createProject(await applyInteractiveSelection(options));
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});