xuanwu-cli 2.2.0 → 2.3.3

package/src/commands/deploy.ts

@@ -6,27 +6,85 @@ import { Command } from 'commander'
 import { configStore } from '../config/store'
 import { createClient } from '../api/client'
 import { OutputFormatter } from '../output/formatter'
-import { DeployOptions } from '../config/types'
+
+function parseNamespaceName(input: string): { namespace: string; name: string } | null {
+  const parts = input.split('/')
+  if (parts.length !== 2) {
+    return null
+  }
+  return { namespace: parts[0], name: parts[1] }
+}
+
+function getAge(timestamp?: string): string {
+  if (!timestamp) return '-'
+  const created = new Date(timestamp)
+  const now = new Date()
+  const diff = Math.floor((now.getTime() - created.getTime()) / 1000)
+  if (diff < 60) return `${diff}s`
+  if (diff < 3600) return `${Math.floor(diff / 60)}m`
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h`
+  return `${Math.floor(diff / 86400)}d`
+}
 
 export function makeDeployCommand(): Command {
   const cmd = new Command('deploy')
     .description('Deploy services to environment')
-    .argument('<namespace>', 'Target namespace')
-    .argument('<service-name>', 'Service name')
-    .option('-t, --type <type>', 'Service type (application|database|image)', 'image')
-    .option('--git <url>', 'Git repository URL')
-    .option('--git-branch <branch>', 'Git branch', 'main')
-    .option('--build-type <type>', 'Build type (template|dockerfile)', 'template')
-    .option('--language <lang>', 'Language (java-springboot|nodejs|python|golang)')
-    .option('--dockerfile-path <path>', 'Dockerfile path')
-    .option('--db-type <type>', 'Database type (mysql|redis|postgres|elasticsearch)')
-    .option('--db-version <version>', 'Database version')
-    .option('--root-password <password>', 'Root password')
-    .option('--password <password>', 'Password')
-    .option('--user <user>', 'Username')
-    .option('--database <name>', 'Database name')
-    .option('--image <image>', 'Container image')
-    .option('-p, --port <port>', 'Container port')
+
+  cmd
+    .command('history <ns-name>')
+    .description('Show deployment history for a service')
+    .action(async (nsName) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const parsed = parseNamespaceName(nsName)
+      if (!parsed) {
+        OutputFormatter.error('Invalid format. Use: <namespace>/<service-name>')
+        return
+      }
+
+      const { namespace, name: serviceName } = parsed
+
+      const client = createClient(conn)
+      const result = await client.listServiceDeployments(namespace, serviceName)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      const data = result.data as any
+      const deployments = data?.deployments || data || []
+
+      if (deployments.length === 0) {
+        OutputFormatter.info('No deployments found')
+        return
+      }
+
+      OutputFormatter.table(
+        ['ID', 'Image', 'Status', 'Build', 'Created'],
+        deployments.map((d: any) => [
+          d.id.substring(0, 8),
+          d.image?.substring(0, 40) || '-',
+          d.status || '-',
+          d.build?.buildNumber ? `#${d.build.buildNumber}` : '-',
+          getAge(d.createdAt)
+        ])
+      )
+
+      if (data?.pagination) {
+        OutputFormatter.info(`Page ${data.pagination.page}/${data.pagination.totalPages}, Total: ${data.pagination.total}`)
+      }
+    })
+
+  cmd
+    .argument('<ns-name>', 'Target namespace and service name (format: namespace/service-name)')
+    .requiredOption('-i, --image <image>', 'Container image (required)')
+    .option('-p, --project <code>', 'Project code')
+    .option('--port <port>', 'Container port', '80')
     .option('-r, --replicas <num>', 'Number of replicas', '1')
     .option('--cpu <value>', 'CPU limit')
     .option('--memory <value>', 'Memory limit')
@@ -36,47 +94,34 @@ export function makeDeployCommand(): Command {
       memo[key] = value
       return memo
     }, {})
-    .action(async (namespace, serviceName, options) => {
+    .action(async (nsName, options) => {
       const conn = configStore.getDefaultConnection()
       if (!conn) {
         OutputFormatter.error('No connection configured')
         return
       }
 
-      const type = options.type as 'application' | 'database' | 'image'
-      
-      const deployOptions: DeployOptions = {
-        namespace,
-        serviceName,
-        type,
-        port: options.port ? parseInt(options.port) : undefined,
-        replicas: options.replicas ? parseInt(options.replicas) : undefined,
-        cpu: options.cpu,
-        memory: options.memory,
-        domain: options.domain,
-        envVars: options.env
+      const parsed = parseNamespaceName(nsName)
+      if (!parsed) {
+        OutputFormatter.error('Invalid format. Use: <namespace>/<service-name>')
+        return
       }
 
-      // 根据类型添加配置
-      if (type === 'application') {
-        deployOptions.git = options.git
-        deployOptions.gitBranch = options.gitBranch
-        deployOptions.buildType = options.buildType
-        deployOptions.language = options.language
-        deployOptions.dockerfilePath = options.dockerfilePath
-      } else if (type === 'database') {
-        deployOptions.dbType = options.dbType
-        deployOptions.dbVersion = options.dbVersion
-        deployOptions.rootPassword = options.rootPassword
-        deployOptions.password = options.password
-        deployOptions.user = options.user
-        deployOptions.database = options.database
-      } else if (type === 'image') {
-        deployOptions.image = options.image
-      }
+      const { namespace, name: serviceName } = parsed
 
       const client = createClient(conn)
-      const result = await client.deploy(deployOptions)
+      
+      const result = await client.deployService(
+        namespace,
+        serviceName,
+        options.image,
+        {
+          projectCode: options.project,
+          replicas: options.replicas ? parseInt(options.replicas) : 1,
+          port: options.port ? parseInt(options.port) : 80,
+          env: options.env
+        }
+      )
 
       if (!result.success) {
         OutputFormatter.error(result.error!.message)

package/src/commands/env.ts

@@ -13,16 +13,18 @@ export function makeEnvCommand(): Command {
 
   cmd
     .command('ls')
+    .alias('list')
     .description('List accessible environments')
-    .action(async () => {
+    .option('-p, --project <project-code>', 'Filter by project code')
+    .action(async (options) => {
       const conn = configStore.getDefaultConnection()
       if (!conn) {
-        OutputFormatter.error('No connection configured. Run: xuanwu connect add <name> -e <endpoint> -t <token>')
+        OutputFormatter.error('No connection configured. Run: xw connect add <name> -e <endpoint> -t <token>')
         return
       }
 
       const client = createClient(conn)
-      const result = await client.listNamespaces()
+      const result = await client.listEnvironments({ project: options.project })
 
       if (!result.success) {
         OutputFormatter.error(result.error!.message)
@@ -36,22 +38,20 @@ export function makeEnvCommand(): Command {
       }
 
       OutputFormatter.table(
-        ['Name', 'Identifier', 'Environment', 'Status'],
+        ['Name', 'Namespace', 'Project', 'Services'],
         spaces.map((s: any) => [
-          s.name || s.identifier,
-          s.identifier,
-          s.environment,
-          s.status || 'active'
+          s.name,
+          s.namespace,
+          s.project?.name || '-',
+          s._count?.services || 0
         ])
       )
     })
 
   cmd
-    .command('create <namespace>')
-    .description('Create a new environment (K8s namespace)')
-    .option('-p, --project-id <id>', 'Project ID')
-    .option('-e, --environment <env>', 'Environment type (development|staging|production)', 'development')
-    .action(async (namespace, options) => {
+    .command('get <namespace>')
+    .description('Get environment details')
+    .action(async (namespace) => {
       const conn = configStore.getDefaultConnection()
       if (!conn) {
         OutputFormatter.error('No connection configured')
@@ -59,34 +59,26 @@ export function makeEnvCommand(): Command {
       }
 
       const client = createClient(conn)
-      
-      let projectId = options.projectId
-      
-      // 如果没有指定 project-id，尝试获取第一个项目
-      if (!projectId) {
-        const projectsResult = await client.getProjects()
-        if (!projectsResult.success || !projectsResult.data || projectsResult.data.length === 0) {
-          OutputFormatter.error('No projects found. Please specify --project-id')
-          return
-        }
-        projectId = projectsResult.data[0].id
-        OutputFormatter.info(`Using project: ${projectsResult.data[0].name}`)
-      }
-
-      const result = await client.createNamespaceWithProject(namespace, projectId, options.environment)
+      const result = await client.getEnvironment(namespace)
 
       if (!result.success) {
         OutputFormatter.error(result.error!.message)
         return
       }
 
-      OutputFormatter.success(`Environment "${namespace}" created`)
+      const env = result.data
+      OutputFormatter.info(`Name: ${env.name}`)
+      OutputFormatter.info(`Namespace: ${env.namespace}`)
+      OutputFormatter.info(`Project: ${env.project?.name || '-'}`)
+      OutputFormatter.info(`Services: ${env.services?.length || 0}`)
     })
 
   cmd
-    .command('rm <namespace>')
-    .description('Delete an environment')
-    .action(async (namespace) => {
+    .command('create <namespace>')
+    .description('Create a new environment (K8s namespace)')
+    .option('-n, --name <name>', 'Environment name')
+    .option('-p, --project <project-code>', 'Project code')
+    .action(async (namespace, options) => {
       const conn = configStore.getDefaultConnection()
       if (!conn) {
         OutputFormatter.error('No connection configured')
@@ -95,28 +87,24 @@ export function makeEnvCommand(): Command {
 
       const client = createClient(conn)
       
-      // 先获取 namespace ID
-      const infoResult = await client.getNamespaceInfo(namespace)
-      if (!infoResult.success || !infoResult.data) {
-        OutputFormatter.error(`Environment "${namespace}" not found`)
-        return
-      }
-
-      const envData = Array.isArray(infoResult.data) ? infoResult.data[0] : infoResult.data
-      const id = envData.id
-      const result = await client.deleteNamespace(id)
+      const result = await client.createEnvironment(
+        options.name || namespace,
+        namespace,
+        options.project
+      )
 
       if (!result.success) {
         OutputFormatter.error(result.error!.message)
         return
       }
 
-      OutputFormatter.success(`Environment "${namespace}" deleted`)
+      OutputFormatter.success(`Environment "${namespace}" created`)
     })
 
   cmd
-    .command('info <namespace>')
-    .description('Show environment details')
+    .command('rm <namespace>')
+    .alias('delete')
+    .description('Delete an environment')
     .action(async (namespace) => {
       const conn = configStore.getDefaultConnection()
       if (!conn) {
@@ -125,19 +113,14 @@ export function makeEnvCommand(): Command {
       }
 
       const client = createClient(conn)
-      const result = await client.getNamespaceInfo(namespace)
+      const result = await client.deleteEnvironment(namespace)
 
       if (!result.success) {
         OutputFormatter.error(result.error!.message)
         return
       }
 
-      const info = result.data
-      OutputFormatter.info(`Name: ${info.name}`)
-      OutputFormatter.info(`Identifier: ${info.identifier}`)
-      OutputFormatter.info(`Namespace: ${info.namespace}`)
-      OutputFormatter.info(`Environment: ${info.environment}`)
-      OutputFormatter.info(`Status: ${info.status}`)
+      OutputFormatter.success(`Environment "${namespace}" deleted`)
     })
 
   return cmd

package/src/commands/project.ts

@@ -0,0 +1,153 @@
+/**
+ * 项目管理命令
+ */
+
+import { Command } from 'commander'
+import { configStore } from '../config/store'
+import { createClient } from '../api/client'
+import { OutputFormatter } from '../output/formatter'
+
+function getAge(timestamp?: string): string {
+  if (!timestamp) return '-'
+  const created = new Date(timestamp)
+  const now = new Date()
+  const diff = Math.floor((now.getTime() - created.getTime()) / 1000)
+  if (diff < 60) return `${diff}s`
+  if (diff < 3600) return `${Math.floor(diff / 60)}m`
+  if (diff < 86400) return `${Math.floor(diff / 3600)}h`
+  return `${Math.floor(diff / 86400)}d`
+}
+
+export function makeProjectCommand(): Command {
+  const cmd = new Command('project')
+    .description('Manage projects')
+
+  cmd
+    .command('ls')
+    .alias('list')
+    .description('List projects')
+    .option('-n, --name <name>', 'Filter by name')
+    .option('-c, --code <code>', 'Filter by code')
+    .action(async (options) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured. Run: xw connect add <name> -e <endpoint> -t <token>')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.listProjects({ name: options.name, code: options.code })
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      const projects = result.data || []
+      if (projects.length === 0) {
+        OutputFormatter.info('No projects found')
+        return
+      }
+
+      OutputFormatter.table(
+        ['Code', 'Name', 'Environments', 'Members', 'Created'],
+        projects.map((p: any) => [
+          p.code,
+          p.name,
+          p.environments?.length || 0,
+          p.members?.length || 0,
+          getAge(p.createdAt)
+        ])
+      )
+    })
+
+  cmd
+    .command('get <code>')
+    .alias('describe')
+    .description('Get project details')
+    .action(async (code) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.getProject(code)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      const project = result.data
+      OutputFormatter.info(`Code: ${project.code}`)
+      OutputFormatter.info(`Name: ${project.name}`)
+      OutputFormatter.info(`Description: ${project.description || '-'}`)
+      OutputFormatter.info(`Environments: ${project.environments?.length || 0}`)
+      OutputFormatter.info(`Members: ${project.members?.length || 0}`)
+      OutputFormatter.info(`Created: ${project.createdAt}`)
+
+      if (project.environments && project.environments.length > 0) {
+        OutputFormatter.info('\nEnvironments:')
+        project.environments.forEach((env: any) => {
+          OutputFormatter.info(`  - ${env.name} (${env.namespace})`)
+        })
+      }
+
+      if (project.members && project.members.length > 0) {
+        OutputFormatter.info('\nMembers:')
+        project.members.forEach((m: any) => {
+          OutputFormatter.info(`  - ${m.user.name || m.user.email} (${m.role})`)
+        })
+      }
+    })
+
+  cmd
+    .command('create')
+    .description('Create a new project')
+    .requiredOption('-n, --name <name>', 'Project name')
+    .requiredOption('-c, --code <code>', 'Project code (unique identifier, cannot be changed after creation)')
+    .option('-d, --description <description>', 'Project description')
+    .action(async (options) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.createProject(options.name, options.code, options.description)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      OutputFormatter.success(`Project "${options.name}" created with code "${options.code}"`)
+    })
+
+  cmd
+    .command('rm <code>')
+    .alias('delete')
+    .description('Delete a project')
+    .action(async (code) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.deleteProject(code)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      OutputFormatter.success(`Project "${code}" deleted`)
+    })
+
+  return cmd
+}

package/src/commands/svc.ts

@@ -323,6 +323,46 @@ export function makeSvcCommand(): Command {
       )
     })
 
+  cmd
+    .command('update <ns>/<name>')
+    .description('Update service configuration')
+    .option('-i, --image <image>', 'Container image')
+    .option('-r, --replicas <num>', 'Number of replicas')
+    .option('--port <port>', 'Container port')
+    .action(async (nsName, options) => {
+      const parsed = parseNamespaceName(nsName)
+      if (!parsed) {
+        OutputFormatter.error('Invalid format. Use: <namespace>/<service-name>')
+        return
+      }
+
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const updateData: any = {}
+      if (options.image) updateData.image = options.image
+      if (options.replicas) updateData.replicas = parseInt(options.replicas)
+      if (options.port) updateData.port = parseInt(options.port)
+
+      if (Object.keys(updateData).length === 0) {
+        OutputFormatter.error('No update options provided. Use --image, --replicas, or --port')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.updateK8sService(parsed.namespace, parsed.name, updateData)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      OutputFormatter.success(`Service "${nsName}" updated`)
+    })
+
   cmd
     .command('delete <ns>/<name>')
     .alias('rm')

package/src/config/types.ts

@@ -43,6 +43,7 @@ export interface DeployOptions {
   namespace: string
   serviceName: string
   type: 'application' | 'database' | 'image'
+  projectCode?: string
   port?: number
   replicas?: number
   cpu?: string

package/src/index.ts

@@ -5,6 +5,7 @@
 import { Command } from 'commander'
 import { configStore } from './config/store'
 import { makeConnectCommand } from './commands/connect'
+import { makeProjectCommand } from './commands/project'
 import { makeEnvCommand } from './commands/env'
 import { makeDeployCommand } from './commands/deploy'
 import { makeAppCommand } from './commands/app'
@@ -27,6 +28,7 @@ program
   .option('-o, --output <format>', 'Output format (human|json)', 'human')
 
 program.addCommand(makeConnectCommand())
+program.addCommand(makeProjectCommand())
 program.addCommand(makeEnvCommand())
 program.addCommand(makeAppCommand())
 program.addCommand(makeSvcCommand())