create-fullstack-scaffold 0.4.10 → 0.4.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-fullstack-scaffold",
-  "version": "0.4.10",
+  "version": "0.4.11",
   "type": "module",
   "bin": {
     "create-fullstack-scaffold": "dist/cli/index.js"

package/template/src/cli/modules/admin/index.ts

@@ -0,0 +1,200 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerAdminCommands(site: SiteInstance) {
+  site.command('dashboard', {
+    description: 'Get dashboard statistics',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.dashboard.stats.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get dashboard stats')
+      }
+    },
+  })
+
+  site.command('stats', {
+    description: 'Get system statistics',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.stats.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get system stats')
+      }
+    },
+  })
+
+  site.command('health', {
+    description: 'Check system health',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.health.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to check health')
+      }
+    },
+  })
+
+  site.command('list-users', {
+    description: 'List all users',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list users')
+      }
+    },
+  })
+
+  site.command('get-user', {
+    description: 'Get a user by ID',
+    parameters: z.object({
+      id: z.string().describe('User ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get user')
+      }
+    },
+  })
+
+  site.command('create-user', {
+    description: 'Create a new user',
+    parameters: z.object({
+      username: z.string().min(1).describe('Username'),
+      email: z.string().email().describe('Email'),
+      password: z.string().min(6).describe('Password'),
+      role: z.enum(['super_admin', 'customer_service', 'user']).default('user').describe('Role'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as {
+        username: string
+        email: string
+        password: string
+        role: 'super_admin' | 'customer_service' | 'user'
+      }
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users.$post({
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          json: {
+            username: p.username,
+            email: p.email,
+            password: p.password,
+            role: p.role,
+          } as any,
+        })
+        const data = await res.json()
+        return ok(data, ['User created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create user')
+      }
+    },
+  })
+
+  site.command('update-user', {
+    description: 'Update a user',
+    parameters: z.object({
+      id: z.string().describe('User ID'),
+      username: z.string().optional().describe('New username'),
+      email: z.string().email().optional().describe('New email'),
+      role: z.enum(['super_admin', 'customer_service', 'user']).optional().describe('New role'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as {
+        id: string
+        username?: string
+        email?: string
+        role?: 'super_admin' | 'customer_service' | 'user'
+      }
+      const { id, ...rest } = p
+      const body: Record<string, string | undefined> = {}
+      if (rest.username) body.username = rest.username
+      if (rest.email) body.email = rest.email
+      if (rest.role) body.role = rest.role
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users[':id'].$put({ param: { id }, json: body as Record<string, string | null | undefined> })
+        const data = await res.json()
+        return ok(data, ['User updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update user')
+      }
+    },
+  })
+
+  site.command('delete-user', {
+    description: 'Delete a user',
+    parameters: z.object({
+      id: z.string().describe('User ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.admin.users[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['User deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete user')
+      }
+    },
+  })
+
+  site.command('activity', {
+    description: 'Get recent activity',
+    parameters: z.object({
+      limit: z.coerce.number().default(10).describe('Limit results'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { limit: number }
+      try {
+        const client = getClient()
+        const res = await client.api.admin.activity.$get({ query: { limit: String(p.limit) } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get activity')
+      }
+    },
+  })
+
+  site.command('clear-todos', {
+    description: 'Clear all todos (dangerous)',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.admin.todos.all.$delete()
+        const data = await res.json()
+        return ok(data, ['All todos cleared'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to clear todos')
+      }
+    },
+  })
+}

package/template/src/cli/modules/captcha/index.ts

@@ -0,0 +1,40 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerCaptchaCommands(site: SiteInstance) {
+  site.command('get', {
+    description: 'Get a new captcha',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.captcha.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get captcha')
+      }
+    },
+  })
+
+  site.command('verify', {
+    description: 'Verify a captcha code',
+    parameters: z.object({
+      id: z.string().describe('Captcha ID'),
+      code: z.string().min(1).describe('Captcha code'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; code: string }
+      try {
+        const client = getClient()
+        const res = await client.api['verify-captcha'].$post({ json: p })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to verify captcha')
+      }
+    },
+  })
+}

package/template/src/cli/modules/chat/index.ts

@@ -0,0 +1,21 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerChatCommands(site: SiteInstance) {
+  site.command('status', {
+    description: 'Get WebSocket connection status',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.chat.ws.status.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get chat status')
+      }
+    },
+  })
+}

package/template/src/cli/modules/content/index.ts

@@ -0,0 +1,144 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerContentCommands(site: SiteInstance) {
+  site.command('list', {
+    description: 'List all contents',
+    parameters: z.object({
+      limit: z.coerce.number().default(20).describe('Limit results'),
+      offset: z.coerce.number().default(0).describe('Offset'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { limit: number; offset: number }
+      try {
+        const client = getClient()
+        const res = await client.api.contents.$get({
+          query: { limit: String(p.limit), offset: String(p.offset) },
+        })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list contents')
+      }
+    },
+  })
+
+  site.command('get', {
+    description: 'Get content by ID',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get content')
+      }
+    },
+  })
+
+  site.command('create', {
+    description: 'Create new content',
+    parameters: z.object({
+      title: z.string().min(1).describe('Content title'),
+      content: z.string().min(1).describe('Content body'),
+      category: z.enum(['article', 'announcement', 'tutorial', 'news', 'policy']).default('article').describe('Category'),
+      tags: z.string().optional().describe('Comma-separated tags'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { title: string; content: string; category: string; tags?: string }
+      try {
+        const client = getClient()
+        const tags = p.tags ? p.tags.split(',') : undefined
+        const res = await client.api.contents.$post({
+          json: { title: p.title, content: p.content, category: p.category as 'article' | 'announcement' | 'tutorial' | 'news' | 'policy', tags },
+        })
+        const data = await res.json()
+        return ok(data, ['Content created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create content')
+      }
+    },
+  })
+
+  site.command('update', {
+    description: 'Update content',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+      title: z.string().optional().describe('New title'),
+      content: z.string().optional().describe('New body'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; title?: string; content?: string }
+      const { id, ...body } = p
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].$put({ param: { id }, json: body })
+        const data = await res.json()
+        return ok(data, ['Content updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update content')
+      }
+    },
+  })
+
+  site.command('delete', {
+    description: 'Delete content',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Content deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete content')
+      }
+    },
+  })
+
+  site.command('publish', {
+    description: 'Publish content',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].publish.$put({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Content published'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to publish content')
+      }
+    },
+  })
+
+  site.command('archive', {
+    description: 'Archive content',
+    parameters: z.object({
+      id: z.string().describe('Content ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.contents[':id'].archive.$put({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Content archived'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to archive content')
+      }
+    },
+  })
+}

package/template/src/cli/modules/dispute/index.ts

@@ -0,0 +1,150 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerDisputeCommands(site: SiteInstance) {
+  site.command('list', {
+    description: 'List all disputes',
+    parameters: z.object({
+      limit: z.coerce.number().default(20).describe('Limit results'),
+      offset: z.coerce.number().default(0).describe('Offset'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { limit: number; offset: number }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes.$get({
+          query: { limit: String(p.limit), offset: String(p.offset) },
+        })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list disputes')
+      }
+    },
+  })
+
+  site.command('get', {
+    description: 'Get dispute by ID',
+    parameters: z.object({
+      id: z.string().describe('Dispute ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get dispute')
+      }
+    },
+  })
+
+  site.command('create', {
+    description: 'Create a new dispute',
+    parameters: z.object({
+      'order-id': z.string().describe('Order ID'),
+      'order-no': z.string().describe('Order number'),
+      'customer-name': z.string().describe('Customer name'),
+      'customer-email': z.string().email().describe('Customer email'),
+      type: z.enum(['refund', 'product_quality', 'service_quality', 'delivery', 'other']).default('other').describe('Type'),
+      description: z.string().min(1).describe('Description'),
+      amount: z.coerce.number().positive().describe('Amount'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as {
+        'order-id': string
+        'order-no': string
+        'customer-name': string
+        'customer-email': string
+        type: string
+        description: string
+        amount: number
+      }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes.$post({
+          json: {
+            orderId: p['order-id'],
+            orderNo: p['order-no'],
+            customerName: p['customer-name'],
+            customerEmail: p['customer-email'],
+            type: p.type as 'refund' | 'product_quality' | 'service_quality' | 'delivery' | 'other',
+            description: p.description,
+            amount: p.amount,
+          },
+        })
+        const data = await res.json()
+        return ok(data, ['Dispute created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create dispute')
+      }
+    },
+  })
+
+  site.command('update', {
+    description: 'Update a dispute status',
+    parameters: z.object({
+      id: z.string().describe('Dispute ID'),
+      status: z.enum(['pending', 'resolved', 'investigating', 'rejected']).optional().describe('New status'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; status?: string }
+      const { id, ...rest } = p
+      const body: Record<string, string | null> = {}
+      if (rest.status) body.status = rest.status
+      try {
+        const client = getClient()
+        const res = await client.api.disputes[':id'].$put({ param: { id }, json: body })
+        const data = await res.json()
+        return ok(data, ['Dispute updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update dispute')
+      }
+    },
+  })
+
+  site.command('delete', {
+    description: 'Delete a dispute',
+    parameters: z.object({
+      id: z.string().describe('Dispute ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Dispute deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete dispute')
+      }
+    },
+  })
+
+  site.command('resolve', {
+    description: 'Resolve a dispute',
+    parameters: z.object({
+      id: z.string().describe('Dispute ID'),
+      resolution: z.string().min(1).describe('Resolution notes'),
+      'resolved-by': z.string().describe('Resolver name'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; resolution: string; 'resolved-by': string }
+      try {
+        const client = getClient()
+        const res = await client.api.disputes[':id'].resolve.$put({
+          param: { id: p.id },
+          json: { resolution: p.resolution, resolvedBy: p['resolved-by'] },
+        })
+        const data = await res.json()
+        return ok(data, ['Dispute resolved'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to resolve dispute')
+      }
+    },
+  })
+}

package/template/src/cli/modules/file/index.ts

@@ -0,0 +1,55 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerFileCommands(site: SiteInstance) {
+  site.command('generate-url', {
+    description: 'Generate a file URL',
+    parameters: z.object({
+      namespace: z.string().describe('File namespace'),
+      filename: z.string().describe('File name'),
+      private: z.boolean().default(false).describe('Generate private URL'),
+      'expiry-seconds': z.coerce.number().default(3600).describe('URL expiry in seconds'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { namespace: string; filename: string; private: boolean; 'expiry-seconds': number }
+      try {
+        const client = getClient()
+        const res = await client.api['generate-url'].$post({
+          json: {
+            namespace: p.namespace,
+            filename: p.filename,
+            isPrivate: p.private,
+            expirySeconds: p['expiry-seconds'],
+          },
+        })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to generate URL')
+      }
+    },
+  })
+
+  site.command('info', {
+    description: 'Check if a public file exists',
+    parameters: z.object({
+      namespace: z.string().describe('File namespace'),
+      filename: z.string().describe('File name'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { namespace: string; filename: string }
+      try {
+        const client = getClient()
+        const res = await client.api.public[':namespace'][':filename'].$get({
+          param: { namespace: p.namespace, filename: p.filename },
+        })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get file info')
+      }
+    },
+  })
+}

package/template/src/cli/modules/index.ts

@@ -4,15 +4,20 @@ import { registerNotificationCommands } from './notification'
 import { registerConfigCommands } from './config'
 import { registerPluginCommands } from './plugin'
 import { registerAuthCommands } from './auth'
+import { registerAdminCommands } from './admin'
+import { registerCaptchaCommands } from './captcha'
+import { registerChatCommands } from './chat'
+import { registerContentCommands } from './content'
+import { registerDisputeCommands } from './dispute'
+import { registerFileCommands } from './file'
+import { registerOrderCommands } from './order'
+import { registerPermissionCommands } from './permission'
+import { registerTenantCommands } from './tenant'
+import { registerTicketCommands } from './ticket'
 
-/**
- * Register all builtin CLI commands to xcli-core.
- * Each register function receives a SiteInstance for command registration.
- */
 export function registerBuiltinCommands(app: Core) {
   const api = app.loader.getAPI()
 
-  // Create a builtin site representing the local server
   const site = api.createSite({
     name: 'local-server',
     url: 'http://localhost:3010',
@@ -23,6 +28,16 @@ export function registerBuiltinCommands(app: Core) {
   registerConfigCommands(site)
   registerPluginCommands(site)
   registerAuthCommands(site)
+  registerAdminCommands(site)
+  registerCaptchaCommands(site)
+  registerChatCommands(site)
+  registerContentCommands(site)
+  registerDisputeCommands(site)
+  registerFileCommands(site)
+  registerOrderCommands(site)
+  registerPermissionCommands(site)
+  registerTenantCommands(site)
+  registerTicketCommands(site)
 }
 
 export {
@@ -31,4 +46,14 @@ export {
   registerConfigCommands,
   registerPluginCommands,
   registerAuthCommands,
+  registerAdminCommands,
+  registerCaptchaCommands,
+  registerChatCommands,
+  registerContentCommands,
+  registerDisputeCommands,
+  registerFileCommands,
+  registerOrderCommands,
+  registerPermissionCommands,
+  registerTenantCommands,
+  registerTicketCommands,
 }

package/template/src/cli/modules/order/index.ts

@@ -0,0 +1,170 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerOrderCommands(site: SiteInstance) {
+  site.command('list', {
+    description: 'List all orders',
+    parameters: z.object({
+      limit: z.coerce.number().default(20).describe('Limit results'),
+      offset: z.coerce.number().default(0).describe('Offset'),
+      status: z.string().optional().describe('Filter by status'),
+      'customer-name': z.string().optional().describe('Filter by customer name'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { limit: number; offset: number; status?: string; 'customer-name'?: string }
+      try {
+        const client = getClient()
+        const query: Record<string, string> = {
+          limit: String(p.limit),
+          offset: String(p.offset),
+        }
+        if (p.status) query.status = p.status
+        if (p['customer-name']) query.customerName = p['customer-name']
+        const res = await client.api.orders.$get({ query })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list orders')
+      }
+    },
+  })
+
+  site.command('get', {
+    description: 'Get order by ID',
+    parameters: z.object({
+      id: z.string().describe('Order ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.orders[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get order')
+      }
+    },
+  })
+
+  site.command('create', {
+    description: 'Create a new order',
+    parameters: z.object({
+      'customer-name': z.string().min(1).describe('Customer name'),
+      'customer-email': z.string().email().describe('Customer email'),
+      'product-name': z.string().min(1).describe('Product name'),
+      amount: z.coerce.number().positive().describe('Order amount'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { 'customer-name': string; 'customer-email': string; 'product-name': string; amount: number }
+      try {
+        const client = getClient()
+        const res = await client.api.orders.$post({
+          json: {
+            customerName: p['customer-name'],
+            customerEmail: p['customer-email'],
+            productName: p['product-name'],
+            amount: p.amount,
+          },
+        })
+        const data = await res.json()
+        return ok(data, ['Order created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create order')
+      }
+    },
+  })
+
+  site.command('update', {
+    description: 'Update order status',
+    parameters: z.object({
+      id: z.string().describe('Order ID'),
+      status: z.enum(['pending', 'processing', 'completed', 'cancelled', 'disputed']).optional().describe('New status'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; status?: string }
+      const { id, ...rest } = p
+      const body: Record<string, string | null> = {}
+      if (rest.status) body.status = rest.status
+      try {
+        const client = getClient()
+        const res = await client.api.orders[':id'].$put({ param: { id }, json: body })
+        const data = await res.json()
+        return ok(data, ['Order updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update order')
+      }
+    },
+  })
+
+  site.command('delete', {
+    description: 'Delete an order',
+    parameters: z.object({
+      id: z.string().describe('Order ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.orders[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Order deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete order')
+      }
+    },
+  })
+
+  site.command('process', {
+    description: 'Process an order',
+    parameters: z.object({
+      id: z.string().describe('Order ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.orders[':id'].process.$put({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Order processed'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to process order')
+      }
+    },
+  })
+
+  site.command('cancel', {
+    description: 'Cancel an order',
+    parameters: z.object({
+      id: z.string().describe('Order ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.orders[':id'].cancel.$put({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Order cancelled'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to cancel order')
+      }
+    },
+  })
+
+  site.command('cart', {
+    description: 'Get current cart',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.cart.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get cart')
+      }
+    },
+  })
+}

package/template/src/cli/modules/permission/index.ts

@@ -0,0 +1,195 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerPermissionCommands(site: SiteInstance) {
+  site.command('roles', {
+    description: 'List all roles',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.permissions.roles.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list roles')
+      }
+    },
+  })
+
+  site.command('get-role', {
+    description: 'Get role details by ID',
+    parameters: z.object({
+      id: z.string().describe('Role ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.roles[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get role')
+      }
+    },
+  })
+
+  site.command('create-role', {
+    description: 'Create a new role',
+    parameters: z.object({
+      name: z.string().min(1).describe('Role name'),
+      code: z.string().min(1).describe('Role code'),
+      label: z.string().min(1).describe('Role display label'),
+      description: z.string().optional().describe('Role description'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { name: string; code: string; label: string; description?: string }
+      try {
+        const client = getClient()
+        const res = await client.api.roles.$post({ json: p })
+        const data = await res.json()
+        return ok(data, ['Role created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create role')
+      }
+    },
+  })
+
+  site.command('update-role', {
+    description: 'Update a role',
+    parameters: z.object({
+      id: z.string().describe('Role ID'),
+      name: z.string().optional().describe('New name'),
+      description: z.string().optional().describe('New description'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; name?: string; description?: string }
+      const { id, ...body } = p
+      try {
+        const client = getClient()
+        const res = await client.api.roles[':id'].$put({ param: { id }, json: body })
+        const data = await res.json()
+        return ok(data, ['Role updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update role')
+      }
+    },
+  })
+
+  site.command('delete-role', {
+    description: 'Delete a role',
+    parameters: z.object({
+      id: z.string().describe('Role ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.roles[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Role deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete role')
+      }
+    },
+  })
+
+  site.command('permissions', {
+    description: 'List all permissions',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.permissions.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list permissions')
+      }
+    },
+  })
+
+  site.command('categories', {
+    description: 'List permission categories',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.permissions.categories.$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list categories')
+      }
+    },
+  })
+
+  site.command('menu-config', {
+    description: 'Get menu configuration',
+    parameters: z.object({}),
+    handler: async () => {
+      try {
+        const client = getClient()
+        const res = await client.api.permissions['menu-config'].$get()
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get menu config')
+      }
+    },
+  })
+
+  site.command('audit-logs', {
+    description: 'List audit logs',
+    parameters: z.object({
+      limit: z.coerce.number().default(50).describe('Limit results'),
+      offset: z.coerce.number().default(0).describe('Offset'),
+      'user-id': z.string().optional().describe('Filter by user ID'),
+      action: z.string().optional().describe('Filter by action'),
+      'resource-type': z.string().optional().describe('Filter by resource type'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { limit: number; offset: number; 'user-id'?: string; action?: string; 'resource-type'?: string }
+      try {
+        const client = getClient()
+        const query: Record<string, string> = {
+          limit: String(p.limit),
+          offset: String(p.offset),
+        }
+        if (p['user-id']) query.userId = p['user-id']
+        if (p.action) query.action = p.action
+        if (p['resource-type']) query.resourceType = p['resource-type']
+        const res = await client.api['audit-logs'].$get({ query })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list audit logs')
+      }
+    },
+  })
+
+  site.command('update-role-permissions', {
+    description: 'Update permissions for a role',
+    parameters: z.object({
+      id: z.string().describe('Role ID'),
+      'permission-ids': z.string().describe('Comma-separated permission IDs'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; 'permission-ids': string }
+      try {
+        const client = getClient()
+        const res = await client.api.roles[':id'].permissions.$put({
+          param: { id: p.id },
+          json: { permissionIds: p['permission-ids'].split(',') },
+        })
+        const data = await res.json()
+        return ok(data, ['Role permissions updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update role permissions')
+      }
+    },
+  })
+}

package/template/src/cli/modules/tenant/index.ts

@@ -0,0 +1,142 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerTenantCommands(site: SiteInstance) {
+  site.command('list', {
+    description: 'List all tenants',
+    parameters: z.object({
+      page: z.coerce.number().default(1).describe('Page number'),
+      'page-size': z.coerce.number().default(20).describe('Page size'),
+      status: z.string().optional().describe('Filter by status'),
+      plan: z.string().optional().describe('Filter by plan'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { page: number; 'page-size': number; status?: string; plan?: string }
+      try {
+        const client = getClient()
+        const query: Record<string, string> = {
+          page: String(p.page),
+          pageSize: String(p['page-size']),
+        }
+        if (p.status) query.status = p.status
+        if (p.plan) query.plan = p.plan
+        const res = await client.api.tenants.$get({ query })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list tenants')
+      }
+    },
+  })
+
+  site.command('get', {
+    description: 'Get tenant by ID',
+    parameters: z.object({
+      id: z.string().describe('Tenant ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.tenants[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get tenant')
+      }
+    },
+  })
+
+  site.command('get-by-slug', {
+    description: 'Get tenant by slug',
+    parameters: z.object({
+      slug: z.string().describe('Tenant slug'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { slug: string }
+      try {
+        const client = getClient()
+        const res = await client.api.tenants.slug[':slug'].$get({ param: { slug: p.slug } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get tenant by slug')
+      }
+    },
+  })
+
+  site.command('create', {
+    description: 'Create a new tenant',
+    parameters: z.object({
+      name: z.string().min(1).describe('Tenant name'),
+      slug: z.string().min(1).describe('Tenant slug (lowercase, hyphens)'),
+      plan: z.enum(['free', 'starter', 'pro', 'enterprise']).default('free').describe('Plan'),
+      'max-users': z.coerce.number().int().min(1).max(1000).default(5).describe('Max users'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { name: string; slug: string; plan: string; 'max-users': number }
+      try {
+        const client = getClient()
+        const res = await client.api.tenants.$post({
+          json: {
+            name: p.name,
+            slug: p.slug,
+            plan: p.plan as 'free' | 'starter' | 'pro' | 'enterprise',
+            maxUsers: p['max-users'],
+            settings: null,
+          },
+        })
+        const data = await res.json()
+        return ok(data, ['Tenant created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create tenant')
+      }
+    },
+  })
+
+  site.command('update', {
+    description: 'Update a tenant',
+    parameters: z.object({
+      id: z.string().describe('Tenant ID'),
+      name: z.string().optional().describe('New name'),
+      plan: z.enum(['free', 'starter', 'pro', 'enterprise']).optional().describe('New plan'),
+      status: z.enum(['active', 'suspended', 'trial']).optional().describe('New status'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; name?: string; plan?: string; status?: string }
+      const { id, ...rest } = p
+      const body: Record<string, string | null> = {}
+      if (rest.name) body.name = rest.name
+      if (rest.plan) body.plan = rest.plan
+      if (rest.status) body.status = rest.status
+      try {
+        const client = getClient()
+        const res = await client.api.tenants[':id'].$put({ param: { id }, json: body })
+        const data = await res.json()
+        return ok(data, ['Tenant updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update tenant')
+      }
+    },
+  })
+
+  site.command('delete', {
+    description: 'Delete a tenant',
+    parameters: z.object({
+      id: z.string().describe('Tenant ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.tenants[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Tenant deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete tenant')
+      }
+    },
+  })
+}

package/template/src/cli/modules/ticket/index.ts

@@ -0,0 +1,167 @@
+import type { SiteInstance } from '@dyyz1993/xcli-core'
+import { ok, fail } from '@dyyz1993/xcli-core'
+import { z } from 'zod'
+import { getClient } from '@cli/utils/api'
+
+export function registerTicketCommands(site: SiteInstance) {
+  site.command('list', {
+    description: 'List all tickets',
+    parameters: z.object({
+      limit: z.coerce.number().default(20).describe('Limit results'),
+      offset: z.coerce.number().default(0).describe('Offset'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { limit: number; offset: number }
+      try {
+        const client = getClient()
+        const res = await client.api.tickets.$get({
+          query: { limit: String(p.limit), offset: String(p.offset) },
+        })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to list tickets')
+      }
+    },
+  })
+
+  site.command('get', {
+    description: 'Get ticket by ID',
+    parameters: z.object({
+      id: z.string().describe('Ticket ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.tickets[':id'].$get({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data)
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to get ticket')
+      }
+    },
+  })
+
+  site.command('create', {
+    description: 'Create a new ticket',
+    parameters: z.object({
+      'customer-name': z.string().min(1).describe('Customer name'),
+      'customer-email': z.string().email().describe('Customer email'),
+      subject: z.string().min(1).describe('Ticket subject'),
+      description: z.string().min(1).describe('Ticket description'),
+      category: z.enum(['technical', 'billing', 'feature_request', 'bug_report', 'general']).default('general').describe('Category'),
+      priority: z.enum(['low', 'medium', 'high', 'urgent']).default('medium').describe('Priority'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as {
+        'customer-name': string
+        'customer-email': string
+        subject: string
+        description: string
+        category: string
+        priority: string
+      }
+      try {
+        const client = getClient()
+        const res = await client.api.tickets.$post({
+          json: {
+            customerName: p['customer-name'],
+            customerEmail: p['customer-email'],
+            subject: p.subject,
+            description: p.description,
+            category: p.category as 'technical' | 'billing' | 'feature_request' | 'bug_report' | 'general',
+            priority: p.priority as 'low' | 'medium' | 'high' | 'urgent',
+          },
+        })
+        const data = await res.json()
+        return ok(data, ['Ticket created'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to create ticket')
+      }
+    },
+  })
+
+  site.command('update', {
+    description: 'Update ticket status',
+    parameters: z.object({
+      id: z.string().describe('Ticket ID'),
+      status: z.enum(['open', 'closed', 'in_progress', 'waiting_customer', 'resolved']).optional().describe('New status'),
+      'assigned-to': z.string().optional().describe('Assign to user'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; status?: string; 'assigned-to'?: string }
+      const { id, ...rest } = p
+      const body: Record<string, string> = {}
+      if (rest.status) body.status = rest.status
+      if (rest['assigned-to']) body.assignedTo = rest['assigned-to']
+      try {
+        const client = getClient()
+        const res = await client.api.tickets[':id'].$put({ param: { id }, json: body })
+        const data = await res.json()
+        return ok(data, ['Ticket updated'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to update ticket')
+      }
+    },
+  })
+
+  site.command('delete', {
+    description: 'Delete a ticket',
+    parameters: z.object({
+      id: z.string().describe('Ticket ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.tickets[':id'].$delete({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Ticket deleted'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to delete ticket')
+      }
+    },
+  })
+
+  site.command('reply', {
+    description: 'Reply to a ticket',
+    parameters: z.object({
+      id: z.string().describe('Ticket ID'),
+      content: z.string().min(1).describe('Reply content'),
+      author: z.string().min(1).describe('Author name'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string; content: string; author: string }
+      try {
+        const client = getClient()
+        const res = await client.api.tickets[':id'].reply.$post({
+          param: { id: p.id },
+          json: { content: p.content, author: p.author },
+        })
+        const data = await res.json()
+        return ok(data, ['Reply sent'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to reply ticket')
+      }
+    },
+  })
+
+  site.command('close', {
+    description: 'Close a ticket',
+    parameters: z.object({
+      id: z.string().describe('Ticket ID'),
+    }),
+    handler: async (params: unknown) => {
+      const p = params as { id: string }
+      try {
+        const client = getClient()
+        const res = await client.api.tickets[':id'].close.$put({ param: { id: p.id } })
+        const data = await res.json()
+        return ok(data, ['Ticket closed'])
+      } catch (err) {
+        return fail(err instanceof Error ? err.message : 'Failed to close ticket')
+      }
+    },
+  })
+}

package/template/src/cli/rpc/client.ts

@@ -1,5 +1,5 @@
 import { hc } from 'hono/client'
-import type { ClientApiType, AppType } from '@server/index'
+import type { AppType } from '@server/index'
 import { WSClientImpl } from '@shared/core/ws-client'
 import { SSEClientImpl } from '@shared/core/sse-client'
 
@@ -16,7 +16,7 @@ export interface CliFetchExtendOptions {
 }
 
 export function createRPCClient(baseUrl: string) {
-  return hc<ClientApiType>(baseUrl, {
+  return hc<AppType>(baseUrl, {
     webSocket: url => new WSClientImpl(url) as unknown as WebSocket,
     sse: url => new SSEClientImpl(url),
   })