xuanwu-cli 1.0.0

package/src/commands/deploy.ts

@@ -0,0 +1,90 @@
+/**
+ * 部署命令
+ */
+
+import { Command } from 'commander'
+import { configStore } from '../config/store'
+import { createClient } from '../api/client'
+import { OutputFormatter } from '../output/formatter'
+import { DeployOptions } from '../config/types'
+
+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')
+    .option('-r, --replicas <num>', 'Number of replicas', '1')
+    .option('--cpu <value>', 'CPU limit')
+    .option('--memory <value>', 'Memory limit')
+    .option('--domain <prefix>', 'Domain prefix')
+    .option('-e, --env <key=value>', 'Environment variables', (val, memo: Record<string, string> = {}) => {
+      const [key, value] = val.split('=')
+      memo[key] = value
+      return memo
+    }, {})
+    .action(async (namespace, serviceName, 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
+      }
+
+      // 根据类型添加配置
+      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 client = createClient(conn)
+      const result = await client.deploy(deployOptions)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      OutputFormatter.success(`Service "${serviceName}" deployed to ${namespace}`)
+    })
+
+  return cmd
+}

package/src/commands/env.ts

@@ -0,0 +1,144 @@
+/**
+ * 环境管理命令
+ */
+
+import { Command } from 'commander'
+import { configStore } from '../config/store'
+import { createClient } from '../api/client'
+import { OutputFormatter } from '../output/formatter'
+
+export function makeEnvCommand(): Command {
+  const cmd = new Command('env')
+    .description('Manage environments (K8s namespaces)')
+
+  cmd
+    .command('ls')
+    .description('List accessible environments')
+    .action(async () => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured. Run: xuanwu connect add <name> -e <endpoint> -t <token>')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.listNamespaces()
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      const spaces = result.data || []
+      if (spaces.length === 0) {
+        OutputFormatter.info('No environments found')
+        return
+      }
+
+      OutputFormatter.table(
+        ['Name', 'Identifier', 'Environment', 'Status'],
+        spaces.map((s: any) => [
+          s.name || s.identifier,
+          s.identifier,
+          s.environment,
+          s.status || 'active'
+        ])
+      )
+    })
+
+  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) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      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)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      OutputFormatter.success(`Environment "${namespace}" created`)
+    })
+
+  cmd
+    .command('rm <namespace>')
+    .description('Delete an environment')
+    .action(async (namespace) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      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)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      OutputFormatter.success(`Environment "${namespace}" deleted`)
+    })
+
+  cmd
+    .command('info <namespace>')
+    .description('Show environment details')
+    .action(async (namespace) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.getNamespaceInfo(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}`)
+    })
+
+  return cmd
+}

package/src/commands/logs.ts

@@ -0,0 +1,47 @@
+/**
+ * 日志命令
+ */
+
+import { Command } from 'commander'
+import { configStore } from '../config/store'
+import { createClient, APIClient } from '../api/client'
+import { OutputFormatter } from '../output/formatter'
+
+export function makeLogsCommand(): Command {
+  const cmd = new Command('logs')
+    .description('View service logs')
+    .argument('<namespace>', 'Target namespace')
+    .argument('<service-name>', 'Service name')
+    .option('-n, --lines <num>', 'Number of lines', '100')
+    .option('-f, --follow', 'Follow logs in real-time (SSE)')
+    .action(async (namespace, serviceName, options) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+
+      if (options.follow) {
+        // 使用 SSE 实时日志
+        await client.streamLogs(namespace, serviceName)
+      } else {
+        const result = await client.getLogs(
+          namespace,
+          serviceName,
+          parseInt(options.lines),
+          false
+        )
+
+        if (!result.success) {
+          OutputFormatter.error(result.error!.message)
+          return
+        }
+
+        console.log(result.data?.logs || result.data || '')
+      }
+    })
+
+  return cmd
+}

package/src/commands/pods.ts

@@ -0,0 +1,60 @@
+/**
+ * Pods 命令
+ */
+
+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 makePodsCommand(): Command {
+  const cmd = new Command('pods')
+    .description('List pods')
+    .argument('<namespace>', 'Target namespace')
+    .argument('<service-name>', 'Service name')
+    .action(async (namespace, serviceName) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.listPods(namespace, serviceName)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      const pods = Array.isArray(result.data) ? result.data : (result.data?.items || [])
+      if (pods.length === 0) {
+        OutputFormatter.info('No pods found')
+        return
+      }
+
+      OutputFormatter.table(
+        ['Name', 'Status', 'Ready', 'Restarts', 'Age'],
+        pods.map((p: any) => [
+          p.metadata?.name || 'unknown',
+          p.status?.phase || 'Unknown',
+          `${p.status?.containerStatuses?.filter((c: any) => c.ready).length || 0}/${p.spec?.containers?.length || 0}`,
+          p.status?.containerStatuses?.[0]?.restartCount?.toString() || '0',
+          getAge(p.metadata?.creationTimestamp)
+        ])
+      )
+    })
+
+  return cmd
+}

package/src/commands/scale.ts

@@ -0,0 +1,35 @@
+/**
+ * 扩缩容命令
+ */
+
+import { Command } from 'commander'
+import { configStore } from '../config/store'
+import { createClient } from '../api/client'
+import { OutputFormatter } from '../output/formatter'
+
+export function makeScaleCommand(): Command {
+  const cmd = new Command('scale')
+    .description('Scale services')
+    .argument('<namespace>', 'Target namespace')
+    .argument('<service-name>', 'Service name')
+    .requiredOption('-r, --replicas <num>', 'Number of replicas')
+    .action(async (namespace, serviceName, options) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.scale(namespace, serviceName, parseInt(options.replicas))
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      OutputFormatter.success(`Scaled to ${options.replicas} replicas`)
+    })
+
+  return cmd
+}

package/src/commands/svc.ts

@@ -0,0 +1,114 @@
+/**
+ * 服务管理命令
+ */
+
+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 makeSvcCommand(): Command {
+  const cmd = new Command('svc')
+    .description('Manage services')
+
+  cmd
+    .command('ls <namespace>')
+    .description('List services in namespace')
+    .action(async (namespace) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.listServices(namespace)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      const services = result.data || []
+      if (services.length === 0) {
+        OutputFormatter.info(`No services in ${namespace}`)
+        return
+      }
+
+      OutputFormatter.table(
+        ['Name', 'Ready', 'Up-to-date', 'Available', 'Age'],
+        services.map((s: any) => [
+          s.metadata?.name || 'unknown',
+          `${s.status?.readyReplicas || 0}/${s.status?.replicas || 0}`,
+          s.status?.updatedReplicas || 0,
+          s.status?.availableReplicas || 0,
+          getAge(s.metadata?.creationTimestamp)
+        ])
+      )
+    })
+
+  cmd
+    .command('status <namespace> <service-name>')
+    .description('Get service status')
+    .action(async (namespace, serviceName) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.getServiceStatus(namespace, serviceName)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      const info = result.data
+      OutputFormatter.info(`Service: ${info.name}`)
+      OutputFormatter.info(`Namespace: ${info.namespace}`)
+      OutputFormatter.info(`Replicas: ${info.replicas}`)
+      OutputFormatter.info(`Ready Replicas: ${info.readyReplicas}`)
+      OutputFormatter.info(`Available Replicas: ${info.availableReplicas}`)
+      OutputFormatter.info(`Image: ${info.image}`)
+      
+      if (info.labels) {
+        OutputFormatter.info(`Labels: ${JSON.stringify(info.labels)}`)
+      }
+    })
+
+  cmd
+    .command('rm <namespace> <service-name>')
+    .description('Delete a service')
+    .action(async (namespace, serviceName) => {
+      const conn = configStore.getDefaultConnection()
+      if (!conn) {
+        OutputFormatter.error('No connection configured')
+        return
+      }
+
+      const client = createClient(conn)
+      const result = await client.deleteService(namespace, serviceName)
+
+      if (!result.success) {
+        OutputFormatter.error(result.error!.message)
+        return
+      }
+
+      OutputFormatter.success(`Service "${serviceName}" deleted`)
+    })
+
+  return cmd
+}

package/src/config/store.ts

@@ -0,0 +1,86 @@
+/**
+ * 配置存储
+ */
+
+import * as fs from 'fs'
+import * as path from 'path'
+import * as os from 'os'
+import { Config, Connection } from './types'
+
+const CONFIG_DIR = path.join(os.homedir(), '.xuanwu')
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+
+const DEFAULT_CONFIG: Config = {
+  version: '1.0',
+  connections: []
+}
+
+export class ConfigStore {
+  private config: Config
+
+  constructor() {
+    this.config = this.load()
+  }
+
+  private load(): Config {
+    try {
+      if (fs.existsSync(CONFIG_FILE)) {
+        const data = fs.readFileSync(CONFIG_FILE, 'utf-8')
+        return JSON.parse(data)
+      }
+    } catch (error) {
+      console.error('Failed to load config:', error)
+    }
+    return { ...DEFAULT_CONFIG }
+  }
+
+  private save(): void {
+    try {
+      if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true })
+      }
+      fs.writeFileSync(CONFIG_FILE, JSON.stringify(this.config, null, 2))
+    } catch (error) {
+      console.error('Failed to save config:', error)
+      throw error
+    }
+  }
+
+  getConnections(): Connection[] {
+    return this.config.connections
+  }
+
+  getConnection(name: string): Connection | undefined {
+    return this.config.connections.find(c => c.name === name)
+  }
+
+  getDefaultConnection(): Connection | undefined {
+    return this.config.connections.find(c => c.isDefault)
+  }
+
+  addConnection(connection: Connection): void {
+    // Remove existing with same name
+    this.config.connections = this.config.connections.filter(c => c.name !== connection.name)
+    this.config.connections.push(connection)
+    this.save()
+  }
+
+  removeConnection(name: string): void {
+    this.config.connections = this.config.connections.filter(c => c.name !== name)
+    this.save()
+  }
+
+  setDefaultConnection(name: string): void {
+    this.config.connections = this.config.connections.map(c => ({
+      ...c,
+      isDefault: c.name === name
+    }))
+    this.save()
+  }
+
+  getConfig(): Config {
+    return this.config
+  }
+}
+
+export const configStore = new ConfigStore()

package/src/config/types.ts

@@ -0,0 +1,99 @@
+/**
+ * xuanwu-cli 类型定义
+ */
+
+export interface Connection {
+  name: string
+  endpoint: string
+  token: string
+  isDefault: boolean
+}
+
+export interface Config {
+  version: string
+  connections: Connection[]
+}
+
+export interface ServiceType {
+  type: 'application' | 'database' | 'image'
+}
+
+export interface ApplicationOptions extends ServiceType {
+  git?: string
+  gitBranch?: string
+  buildType?: 'template' | 'dockerfile'
+  language?: string
+  dockerfilePath?: string
+}
+
+export interface DatabaseOptions extends ServiceType {
+  dbType: 'mysql' | 'redis' | 'postgres' | 'elasticsearch'
+  dbVersion: string
+  rootPassword?: string
+  password?: string
+  user?: string
+  database?: string
+}
+
+export interface ImageOptions extends ServiceType {
+  image: string
+}
+
+export interface DeployOptions {
+  namespace: string
+  serviceName: string
+  type: 'application' | 'database' | 'image'
+  port?: number
+  replicas?: number
+  cpu?: string
+  memory?: string
+  domain?: string
+  envVars?: Record<string, string>
+  volume?: string
+  // application
+  git?: string
+  gitBranch?: string
+  buildType?: 'template' | 'dockerfile'
+  language?: string
+  dockerfilePath?: string
+  // database
+  dbType?: 'mysql' | 'redis' | 'postgres' | 'elasticsearch'
+  dbVersion?: string
+  rootPassword?: string
+  password?: string
+  user?: string
+  database?: string
+  // image
+  image?: string
+}
+
+export interface ServiceInfo {
+  name: string
+  type: string
+  status: string
+  ready: string
+  image: string
+  age: string
+  ports: number[]
+  endpoint?: string
+}
+
+export interface NamespaceInfo {
+  name: string
+  status: string
+  age: string
+}
+
+export interface CLIResult<T = any> {
+  success: boolean
+  data?: T
+  error?: {
+    code: string
+    message: string
+    details?: any
+  }
+  meta?: {
+    timestamp: string
+    duration?: number
+  }
+}