create-fullstack-scaffold 0.4.25 → 0.5.1

package/dist/cli/index.js

@@ -149,6 +149,15 @@ function getAdminPages(resolved) {
 // src/generators/file-filter.ts
 function getExcludePatterns(resolved, allManifests) {
   const excludes = [];
+  if (!resolved.hasClient) {
+    excludes.push(
+      "playwright.config.ts",
+      "src/shared/hooks",
+      "src/server/entries/cloudflare.ts",
+      "tests/e2e"
+    );
+  }
+  excludes.push("src/server/rpc-type-canary.ts");
   for (const [name, manifest] of allManifests) {
     if (resolved.modules.has(name)) continue;
     excludes.push(`src/server/module-${name}`);
@@ -274,6 +283,9 @@ function getExcludePatterns(resolved, allManifests) {
 function getGeneratedFiles(resolved) {
   const files = [
     "src/server/route-registry.ts",
+    "src/server/rpc-surface.ts",
+    "src/server/isr-modules.ts",
+    "src/client/stores/entry-stores.ts",
     "src/server/db/schema/index.ts",
     "src/shared/modules/index.ts",
     "src/shared/schemas/index.ts",
@@ -358,9 +370,11 @@ function generateRouteRegistry(resolved) {
   let content = imports.join("\n") + "\n\n";
   content += `const apiRateLimit = rateLimitMiddleware({
 `;
-  content += `  windowMs: 60 * 1000,
+  content += `  windowMs: 60_000,
 `;
   content += `  max: 100,
+`;
+  content += `  message: 'Too many requests, please try again later',
 `;
   content += `})
 
@@ -393,9 +407,7 @@ function generateRouteRegistry(resolved) {
 
 `;
   }
-  content += `export type ClientApiRoutes = typeof clientApiRoutes
-`;
-  content += `export type AdminApiRoutes = typeof adminApiRoutes
+  content += `// \u7C7B\u578B\u51FA\u53E3\u5DF2\u79FB\u9664\uFF1A\u5DE8\u578B merge \u7C7B\u578B\u662F TS2589 \u6839\u6E90\uFF0C\u5BA2\u6237\u7AEF\u6539\u7528 rpc-surface.ts \u95E8\u9762
 `;
   return content;
 }
@@ -413,6 +425,211 @@ function getStandaloneRoutes(resolved) {
   return routes;
 }
 
+// src/generators/rpc-surface.ts
+function extractApiTypes(content) {
+  const re = /export type (\w+ApiType)\s*=\s*typeof\s+(\w+)/g;
+  const names = [];
+  let m;
+  while ((m = re.exec(content)) !== null) names.push(m[1]);
+  return names;
+}
+function extractSegments(content, readRouteFile, baseDir, depth = 0) {
+  const segs = /* @__PURE__ */ new Set();
+  const pathRe = /path:\s*'\/([a-zA-Z][a-zA-Z-]*)/g;
+  let m;
+  while ((m = pathRe.exec(content)) !== null) segs.add(m[1]);
+  if (depth < 3) {
+    const importRe = /import\s*\{([^}]+)\}\s*from\s*'(\.\/[a-zA-Z-]+)'/g;
+    while ((m = importRe.exec(content)) !== null) {
+      const names = m[1].split(",").map((s) => s.trim().split(" as ")[0]).filter(Boolean);
+      const subPath = m[2].replace(/^\.\//, "");
+      const isMounted = names.some(
+        (n) => new RegExp(`\\.route\\(\\s*'/'\\s*,\\s*${n}\\s*\\)`).test(content)
+      );
+      if (!isMounted) continue;
+      const sub = readRouteFile(`${baseDir}/${subPath}`);
+      if (sub) {
+        for (const s of extractSegments(sub, readRouteFile, baseDir, depth + 1)) segs.add(s);
+      }
+    }
+  }
+  return [...segs];
+}
+function generateRpcSurface(resolved, readRouteFile) {
+  const sources = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  const collect = (moduleName, manifest, key2) => {
+    const raw = manifest.routes[key2];
+    if (!raw) return;
+    const list = Array.isArray(raw) ? raw : [raw];
+    for (const entry of list) {
+      const routePath = `module-${moduleName}/${entry.importPath.replace(/^\.\//, "").replace(/\.ts$/, "")}`;
+      let localName = usedNames.has(entry.exportName) ? `${routePath.split("/").pop().replace(
+        /-([a-z])/g,
+        (_, c) => c.toUpperCase()
+      )}${entry.exportName.charAt(0).toUpperCase()}${entry.exportName.slice(1)}` : entry.exportName;
+      while (usedNames.has(localName)) localName += "X";
+      usedNames.add(localName);
+      const content = readRouteFile(routePath);
+      if (!content) continue;
+      const typeNames = extractApiTypes(content);
+      const segments = extractSegments(
+        content,
+        readRouteFile,
+        routePath.split("/").slice(0, -1).join("/")
+      );
+      for (const typeName of typeNames) {
+        sources.push({ routePath, localName, typeName, segments });
+      }
+    }
+  };
+  for (const [moduleName, manifest] of [...resolved.modules.entries()]) {
+    collect(moduleName, manifest, "client");
+    collect(moduleName, manifest, "admin");
+  }
+  const segmentOwners = /* @__PURE__ */ new Map();
+  sources.forEach((s, idx) => {
+    for (const seg of s.segments) {
+      const list = segmentOwners.get(seg) ?? [];
+      list.push({ localName: s.localName, typeName: s.typeName, routePath: s.routePath, idx });
+      segmentOwners.set(seg, list);
+    }
+  });
+  const hasMergedSegments = [...segmentOwners.values()].some((owners) => owners.length > 1);
+  const imports = [
+    `import { hc } from 'hono/client'`,
+    ...hasMergedSegments ? [`import { mergeRpcObjects } from './rpc-merge'`] : []
+  ];
+  for (const s of sources) {
+    imports.push(`import type { ${s.typeName} } from './${s.routePath}'`);
+  }
+  const clients = [];
+  sources.forEach((s, i) => {
+    clients.push(`  const ${s.localName}Client${i} = hc<${s.typeName}>(api, options)`);
+  });
+  const entries = [];
+  const key = (seg) => /^[a-zA-Z][a-zA-Z0-9]*$/.test(seg) ? seg : `'${seg}'`;
+  const access = (seg) => /^[a-zA-Z][a-zA-Z0-9]*$/.test(seg) ? `.${seg}` : `['${seg}']`;
+  for (const [seg, owners] of segmentOwners) {
+    owners.sort((a, b) => a.idx - b.idx);
+    const refs = owners.map((o) => `${o.localName}Client${o.idx}${access(seg)}`);
+    entries.push(
+      refs.length === 1 ? `      ${key(seg)}: ${refs[0]},` : `      ${key(seg)}: mergeRpcObjects(${refs.join(", ")}),`
+    );
+  }
+  return `/**
+ * @framework-baseline rpc-surface-v1
+ *
+ * \u6309\u6A21\u5757\u62C6\u5206\u7684\u7C7B\u578B\u5B89\u5168 RPC \u95E8\u9762\uFF08\u672C\u6587\u4EF6\u7531 CLI \u751F\u6210\uFF0C\u52FF\u624B\u6539\uFF09\u3002
+ * \u751F\u6210\u5668: src/generators/rpc-surface.ts
+ *
+ * \u6BCF\u4E2A\u6A21\u5757\u5355\u72EC\u5B9E\u4F8B\u5316\u7A84\u5BA2\u6237\u7AEF\uFF08\u6DF1\u5EA6 = 1 \u4E2A\u6A21\u5757\uFF09\uFF0C\u7EC4\u88C5\u6210\u4E0E\u65E7
+ * \`hc<MergedApiType>\` \u5B8C\u5168\u540C\u5F62\u7684\u95E8\u9762\u3002\u7981\u6B62\u5BFC\u51FA\u94FE\u5F0F merge \u7C7B\u578B
+ * \uFF08eslint: no-merged-api-type-export\uFF09\u3002
+ */
+
+${imports.join("\n")}
+
+/** hono hc \u7684\u9009\u9879\u7C7B\u578B\uFF08fetch / webSocket / sse / headers \u7B49\uFF09 */
+export type RpcClientOptions = NonNullable<Parameters<typeof hc>[1]>
+
+/**
+ * \u521B\u5EFA\u6309\u6A21\u5757\u62C6\u5206\u7684 RPC \u95E8\u9762\u3002
+ * \u8C03\u7528\u5F62\u6001\u4E0E\u65E7 mega \u5BA2\u6237\u7AEF\u517C\u5BB9\uFF1Afacade.api.todos.$get()\u3002
+ */
+export function createApiFacade(baseUrl: string, options: RpcClientOptions = {}) {
+  const api = \`\${baseUrl.replace(/\\/$/, '')}/api\`
+
+${clients.join("\n")}
+
+  return {
+    api: {
+${entries.join("\n")}
+    },
+  }
+}
+
+export type ApiFacade = ReturnType<typeof createApiFacade>
+`;
+}
+
+// src/generators/isr-modules.ts
+function generateIsrModules(resolved, moduleFileExists) {
+  const imports = [];
+  for (const [moduleName] of [...resolved.modules.entries()]) {
+    if (moduleFileExists(moduleName, "isr.ts")) {
+      imports.push(`import '@server/module-${moduleName}/isr'`);
+    }
+  }
+  return `/**
+ * ISR \u6A21\u5757\u6CE8\u518C\u6C47\u603B\uFF08\u672C\u6587\u4EF6\u7531 CLI \u751F\u6210\uFF0C\u52FF\u624B\u6539\uFF09\u3002
+ * \u751F\u6210\u5668: src/generators/isr-modules.ts
+ *
+ * \u6309 preset \u53EA\u5BFC\u5165\u9009\u4E2D\u6A21\u5757\u7684 ISR \u6CE8\u518C\u526F\u4F5C\u7528\uFF1B\u672A\u88AB\u88C1\u526A\u98CE\u9669\u7684\u5355\u4E00\u5165\u53E3
+ * \u7531 entries/cloudflare.ts import \u672C\u6587\u4EF6\u3002
+ */
+
+${imports.join("\n")}
+`;
+}
+
+// src/generators/entry-stores.ts
+function generateEntryStores(resolved, moduleFileExists) {
+  const hasTodos = resolved.modules.has("todos") && moduleFileExists("todos", "todoStore.ts");
+  if (!hasTodos) {
+    return `/**
+ * Entry SSR store \u79CD\u5B50\uFF08\u672C\u6587\u4EF6\u7531 CLI \u751F\u6210\uFF0C\u52FF\u624B\u6539\uFF09\u3002
+ * \u5F53\u524D preset \u4E0D\u542B todo \u6A21\u5757\uFF1A\u65E0 store \u9700\u8981\u9884\u586B\u5145\uFF0C\u5168\u90E8\u4E3A\u7A7A\u5B9E\u73B0\u3002
+ */
+
+export interface SSRData {
+  [key: string]: unknown
+}
+
+export function snapshotEntryStores(): Record<string, unknown> {
+  return {}
+}
+
+export function seedEntryStores(_data: SSRData): void {}
+
+export function restoreEntryStores(_snapshot: Record<string, unknown>): void {}
+`;
+  }
+  return `/**
+ * Entry SSR store \u79CD\u5B50\uFF08\u672C\u6587\u4EF6\u7531 CLI \u751F\u6210\uFF0C\u52FF\u624B\u6539\uFF09\u3002
+ * todo \u6A21\u5757\u5728\u9009\u4E2D\u5217\u8868\u4E2D\uFF1A\u9884\u586B\u5145 todoStore \u4F9B ISR \u6E32\u67D3\u771F\u5B9E\u5185\u5BB9\u3002
+ */
+
+import { useTodoStore } from './todoStore'
+import type { Todo } from '@shared/schemas'
+
+export interface SSRData {
+  todos?: Todo[]
+  [key: string]: unknown
+}
+
+export interface EntryStoreSnapshot {
+  todos: Todo[]
+  loading: boolean
+}
+
+export function snapshotEntryStores(): EntryStoreSnapshot {
+  const state = useTodoStore.getState()
+  return { todos: state.todos, loading: state.loading }
+}
+
+export function seedEntryStores(data: SSRData): void {
+  if (data.todos) {
+    useTodoStore.setState({ todos: data.todos, loading: false })
+  }
+}
+
+export function restoreEntryStores(snapshot: EntryStoreSnapshot): void {
+  useTodoStore.setState({ todos: snapshot.todos, loading: snapshot.loading })
+}
+`;
+}
+
 // src/generators/client-navigation.ts
 var DEFAULT_ICON = "Circle";
 var ICON_MAP = {
@@ -589,7 +806,10 @@ describe('App Component', () => {
   describe('Initial Render', () => {
     it('should render navigation', () => {
       render(<App />)
-      expect(screen.getByTestId('app-nav')).toBeInTheDocument()
+      // \u5E03\u5C40\u611F\u77E5\uFF1Atop-nav \u6709 app-nav\uFF1Bsidebar \u5E03\u5C40\u6CA1\u6709\u9876\u680F\uFF08\u6709 app-container/app-main\uFF09
+      expect(
+        document.querySelector('[data-testid="app-nav"], [data-testid="app-container"]')
+      ).toBeTruthy()
     })
 
     it('should render main content area', () => {
@@ -606,7 +826,11 @@ describe('App Component', () => {
   describe('Navigation Links', () => {
     it('should render footer', () => {
       render(<App />)
-      expect(screen.getByTestId('app-footer')).toBeInTheDocument()
+      // \u9875\u811A\u4EC5 top-nav \u5E03\u5C40\u6E32\u67D3\uFF08Layout: showFooter = layout === 'top-nav'\uFF09
+      expect(
+        document.querySelector('[data-testid="app-footer"]') ||
+          document.querySelector('[data-testid="app-container"]')
+      ).toBeTruthy()
     })
   })
 })
@@ -668,7 +892,11 @@ describe('Navigation', () => {
   })
 
   it('should render nav items', () => {
-    renderWithRouter(<Navigation />)
+    renderWithRouter(
+      <Navigation
+        items={[{ label: '${firstLabel}', icon: 'CheckSquare', path: '${firstPage.route}' }]}
+      />
+    )
     expect(screen.getByText('${firstLabel}')).toBeInTheDocument()
   })
 })
@@ -771,11 +999,10 @@ function generateAdminApiClient(resolved) {
  * @impact Captcha module excluded = no captchaStore import
  */
 
-import { hc } from 'hono/client'
 import { WSClientImpl } from '@shared/core/ws-client'
 import { SSEClientImpl } from '@shared/core/sse-client'
 import { createRequestInterceptor } from './requestInterceptor'
-${captchaImport}import type { AdminApiType } from '@server/index'
+${captchaImport}import { createApiFacade } from '@server/rpc-surface'
 
 const baseUrl = import.meta.env.API_BASE_URL || window.location.origin
 
@@ -807,7 +1034,7 @@ ${captchaFetchSetup}  return createRequestInterceptor({
 ${captchaHandler}  })
 }
 
-export const apiClient = hc<AdminApiType>(baseUrl, {
+export const apiClient = createApiFacade(baseUrl, {
   fetch: createCustomFetch() as typeof fetch,
   webSocket: url => new WSClientImpl(url) as unknown as WebSocket,
   sse: url => {
@@ -1371,7 +1598,10 @@ export function createApp<T extends AppBindings = AppBindings>(_options: CreateA
         return c.json({ status: 'ok', timestamp: new Date().toISOString(), db: 'not configured' })
       }
     })
-    .post('/api/__test__/cleanup', async c => {
+  // \u6D4B\u8BD5\u8F85\u52A9\u7AEF\u70B9\uFF1A\u4EC5\u5F00\u53D1/\u6D4B\u8BD5\u73AF\u5883\u6CE8\u518C\uFF08Cloudflare \u6784\u5EFA\u65F6 NODE_ENV \u88AB\u66FF\u6362\u4E3A
+  // "production"\uFF0C\u6B64\u7AEF\u70B9\u4E0D\u4F1A\u51FA\u73B0\u5728\u751F\u4EA7 bundle \u4E2D\uFF09
+  if (process.env.NODE_ENV !== 'production') {
+    app.post('/api/__test__/cleanup', async c => {
       try {
         const { cleanupTestDatabase } = await import('./db/test-setup')
         await cleanupTestDatabase()
@@ -1381,6 +1611,7 @@ export function createApp<T extends AppBindings = AppBindings>(_options: CreateA
         return c.json({ success: false as const, message: 'Failed to cleanup database' }, 500)
       }
     })
+  }
 
   autoRegisterRealtime(app as unknown as Parameters<typeof autoRegisterRealtime>[0])
 
@@ -1427,9 +1658,6 @@ export function createApp<T extends AppBindings = AppBindings>(_options: CreateA
 
   return app
 }
-export type AdminApiType = typeof adminApiRoutes
-export type ClientApiType = typeof clientApiRoutes
-export type AppType = ReturnType<typeof createApp>
 `;
 }
 
@@ -1562,6 +1790,39 @@ var MODULE_EXPORTS = {
       "type PluginListQuery"
     ]
   },
+  plugins: {
+    namedExports: [
+      "PluginSchema",
+      "PluginStatusSchema",
+      "CreatePluginSchema",
+      "UpdatePluginSchema",
+      "PluginVersionStatusSchema",
+      "VersionSchema",
+      "CategorySchema",
+      "ReviewSchema",
+      "CreateReviewSchema",
+      "MarketplaceStatsSchema",
+      "PluginListResponseSchema",
+      "AdminPluginSchema",
+      "AdminDashboardStatsSchema",
+      "PluginListQuerySchema",
+      "PluginSlugSchema",
+      "type Plugin",
+      "type PluginStatus",
+      "type CreatePluginInput",
+      "type UpdatePluginInput",
+      "type PluginVersionStatus",
+      "type Version",
+      "type Category",
+      "type Review",
+      "type CreateReviewInput",
+      "type MarketplaceStats",
+      "type PluginListResponse",
+      "type AdminPlugin",
+      "type AdminDashboardStats",
+      "type PluginListQuery"
+    ]
+  },
   merchant: {
     namedExports: [
       "ProductSchema",
@@ -1773,6 +2034,7 @@ function generateSharedModulesIndex(resolved) {
     "permission",
     "auth",
     "plugin",
+    "plugins",
     "merchant",
     "tenant",
     "order",
@@ -1863,6 +2125,10 @@ var MODULE_EXPORTS2 = {
       "TodoWithAttachmentsSchema",
       "UploadFileSchema",
       "AttachmentIdResponseSchema",
+      "TodoListResponseSchema",
+      "TodoListQuerySchema",
+      "type TodoListResponse",
+      "type TodoListQuery",
       "type Todo",
       "type TodoStatus",
       "type CreateTodoInput",
@@ -1958,6 +2224,56 @@ var MODULE_EXPORTS2 = {
       "type PluginListQuery"
     ]
   },
+  plugins: {
+    namedExports: [
+      "PluginSchema",
+      "PluginStatusSchema",
+      "CreatePluginSchema",
+      "UpdatePluginSchema",
+      "PluginVersionStatusSchema",
+      "VersionSchema",
+      "CategorySchema",
+      "ReviewSchema",
+      "CreateReviewSchema",
+      "MarketplaceStatsSchema",
+      "PluginListResponseSchema",
+      "AdminPluginSchema",
+      "AdminDashboardStatsSchema",
+      "PluginListQuerySchema",
+      "PluginSlugSchema",
+      "PluginSearchQuerySchema",
+      "PluginDeleteResponseSchema",
+      "ReviewIdParamsSchema",
+      "ReviewDeleteResponseSchema",
+      "CategorySlugParamsSchema",
+      "CategoryPluginsQuerySchema",
+      "PluginListAdminSchema",
+      "AdminListQuerySchema",
+      "AdminListAllQuerySchema",
+      "RejectPluginBodySchema",
+      "BulkApproveBodySchema",
+      "BulkRejectBodySchema",
+      "BulkResponseSchema",
+      "CreateCategoryBodySchema",
+      "UpdateCategoryBodySchema",
+      "CategoryIdParamsSchema",
+      "CategoryIdResponseSchema",
+      "type Plugin",
+      "type PluginStatus",
+      "type CreatePluginInput",
+      "type UpdatePluginInput",
+      "type PluginVersionStatus",
+      "type Version",
+      "type Category",
+      "type Review",
+      "type CreateReviewInput",
+      "type MarketplaceStats",
+      "type PluginListResponse",
+      "type AdminPlugin",
+      "type AdminDashboardStats",
+      "type PluginListQuery"
+    ]
+  },
   admin: {
     namedExports: [
       "SystemStatsSchema",
@@ -2256,6 +2572,7 @@ var moduleOrder = [
   "notifications",
   "auth",
   "plugin",
+  "plugins",
   "admin",
   "audit",
   "captcha",
@@ -2438,6 +2755,34 @@ function extractToken(authHeader: string | undefined): string | null {
   return authHeader.slice(7)
 }
 
+// dev tokens\uFF1A\u4E0E\u6A21\u677F\u5B8C\u6574\u7248 auth.ts \u8BED\u4E49\u4E00\u81F4\uFF08\u5F00\u53D1/\u6D4B\u8BD5\u4FBF\u5229\u540E\u95E8\uFF0Cproduction \u9ED8\u8BA4\u7981\u7528\uFF09
+function isDevTokensEnabled(): boolean {
+  if (process.env.ENABLE_DEV_TOKENS === 'true') return true
+  if (process.env.ENABLE_DEV_TOKENS === 'false') return false
+  if (process.env.NODE_ENV === 'production') return false
+  return true
+}
+
+function verifyDevToken(token: string): AuthUser | null {
+  if (token === 'admin-token' || token === 'super-admin-token') {
+    return {
+      id: 'super-admin-1',
+      username: 'superadmin',
+      email: 'superadmin@example.com',
+      role: 'admin',
+    }
+  }
+  if (token === 'user-token') {
+    return {
+      id: 'user-1',
+      username: 'Demo User',
+      email: 'demo@example.com',
+      role: 'user',
+    }
+  }
+  return null
+}
+
 export function authMiddleware(_options: AuthMiddlewareOptions = {}): MiddlewareHandler {
   const log = createModuleLoggerSync('auth')
 
@@ -2449,6 +2794,16 @@ export function authMiddleware(_options: AuthMiddlewareOptions = {}): Middleware
       return c.json({ success: false, error: 'Authentication required', status: 401 }, 401)
     }
 
+    if (isDevTokensEnabled()) {
+      const devUser = verifyDevToken(token)
+      if (devUser) {
+        c.set('authUser', devUser)
+        log.warn({ module: 'auth' }, 'DEV TOKEN USED - This should not appear in production!')
+        await next()
+        return
+      }
+    }
+
     try {
       const jwt = await import('jsonwebtoken')
       const secretKey = process.env.AUTH_SECRET_KEY || 'dev-secret-key-change-in-production'
@@ -2733,7 +3088,7 @@ var MODULE_PACKAGES = {
   admin: ["bcryptjs"],
   auth: ["bcryptjs"]
 };
-var ADMIN_PANEL_PACKAGES = ["antd"];
+var ADMIN_PANEL_PACKAGES = ["antd", "@ant-design/icons"];
 var CLI_PACKAGES = ["commander"];
 var UNUSED_PACKAGES = ["lodash-es", "chalk", "mysql2"];
 var CLIENT_PACKAGES = [
@@ -2759,6 +3114,7 @@ var CLIENT_DEV_PACKAGES = [
   "playwright",
   "@prerenderer/renderer-jsdom",
   "@prerenderer/renderer-puppeteer",
+  "puppeteer",
   "@prerenderer/rollup-plugin",
   "eventsource"
 ];
@@ -3833,6 +4189,50 @@ async function createProject(projectNameOrOptions, useCurrentDir = false, preset
     const genSpinner = ora("Generating module-specific files...").start();
     const routeRegistryContent = generateRouteRegistry(resolved);
     await fs.writeFile(path.join(targetDir, "src/server/route-registry.ts"), routeRegistryContent);
+    const rpcSurfaceContent = generateRpcSurface(resolved, (relPath) => {
+      const full = path.join(targetDir, "src/server", `${relPath}.ts`);
+      return fs.existsSync(full) ? fs.readFileSync(full, "utf-8") : null;
+    });
+    await fs.writeFile(path.join(targetDir, "src/server/rpc-surface.ts"), rpcSurfaceContent);
+    for (const [rel, from, to] of [
+      ["src/client/App.tsx", "presetId = 'todo'", `presetId = '${selectedPreset.id}'`],
+      [
+        "src/client/entry-server.tsx",
+        "const preset = 'todo'",
+        `const preset = '${selectedPreset.id}'`
+      ]
+    ]) {
+      const p = path.join(targetDir, rel);
+      if (await fs.pathExists(p)) {
+        let content = await fs.readFile(p, "utf-8");
+        content = content.split(from).join(to);
+        await fs.writeFile(p, content);
+      }
+    }
+    if (!resolved.hasClient) {
+      const barrelPath = path.join(targetDir, "src/shared/index.ts");
+      if (await fs.pathExists(barrelPath)) {
+        let barrel = await fs.readFile(barrelPath, "utf-8");
+        barrel = barrel.replaceAll("export * from './hooks'\n", "");
+        await fs.writeFile(barrelPath, barrel);
+      }
+    }
+    const isrModulesContent = generateIsrModules(
+      resolved,
+      (moduleName, relPath) => fs.existsSync(path.join(targetDir, "src/server", `module-${moduleName}`, relPath))
+    );
+    await fs.writeFile(path.join(targetDir, "src/server/isr-modules.ts"), isrModulesContent);
+    if (resolved.hasClient) {
+      const entryStoresContent = generateEntryStores(
+        resolved,
+        (_moduleName, relPath) => fs.existsSync(path.join(targetDir, "src/client/stores", relPath))
+      );
+      await fs.ensureDir(path.join(targetDir, "src/client/stores"));
+      await fs.writeFile(
+        path.join(targetDir, "src/client/stores/entry-stores.ts"),
+        entryStoresContent
+      );
+    }
     const dbSchemaContent = generateDbSchemaBarrel(resolved);
     await fs.writeFile(path.join(targetDir, "src/server/db/schema/index.ts"), dbSchemaContent);
     if (resolved.hasClient) {
@@ -3939,6 +4339,7 @@ async function createProject(projectNameOrOptions, useCurrentDir = false, preset
       try {
         const { execSync } = await import('child_process');
         execSync("npm install --legacy-peer-deps", {
+          env: { ...process.env, PUPPETEER_SKIP_DOWNLOAD: "1" },
           cwd: targetDir,
           stdio: "pipe",
           timeout: 3e5
@@ -3997,6 +4398,22 @@ async function createProject(projectNameOrOptions, useCurrentDir = false, preset
     }
     console.log("");
     console.log(chalk.gray("  Happy coding! \u{1F41F}"));
+    const home = process.env.HOME || "";
+    const agents = [];
+    if (home) {
+      if (await fs.pathExists(path.join(home, ".zcode"))) agents.push("ZCode");
+      if (await fs.pathExists(path.join(home, ".codex"))) agents.push("Codex");
+      if (await fs.pathExists(path.join(home, ".claude"))) agents.push("Claude Code");
+      if (await fs.pathExists(path.join(home, ".cursor"))) agents.push("Cursor");
+    }
+    if (agents.length > 0) {
+      console.log("");
+      console.log(chalk.cyan(`  \u{1FA9D} Agent hooks (\u68C0\u6D4B\u5230 ${agents.join(" / ")}):`));
+      console.log(
+        chalk.gray("    \u5DE5\u4F5C\u533A\u94A9\u5B50\u5DF2\u751F\u6210\uFF08.zcode/\uFF0C\u7981\u6B62 --no-verify \u63D0\u4EA4\uFF09\uFF0CZCode \u81EA\u52A8\u751F\u6548")
+      );
+      console.log(chalk.gray("    \u540C\u6B65\u5230\u5168\u5C40\uFF08Codex \u7B49\uFF09\uFF1Anpm run hooks:sync -- --global"));
+    }
     console.log("");
   } catch (error) {
     if (error instanceof ScaffoldError) throw error;