sealos-cli 0.1.0 → 1.1.0

package/src/commands/quota/index.ts

@@ -3,16 +3,17 @@ import { handleError } from '../../lib/errors.ts'
 
 export function createQuotaCommand (): Command {
   const quotaCmd = new Command('quota')
-    .description('View resource quotas')
+    .description('Future quota placeholder outside the v1 release surface')
 
-  // TODO: 实现配额相关命令
+  // Future, non-v1 placeholder. Do not register this command until quota APIs
+  // are implemented and ready for release.
 
   quotaCmd
     .command('get')
     .description('Get quota information')
     .action(async () => {
       try {
-        console.log('TODO: Implement quota get')
+        console.log('Quota commands are not part of the v1 release surface yet.')
       } catch (error) {
         handleError(error)
       }

package/src/commands/s3/index.ts

@@ -3,9 +3,10 @@ import { handleError } from '../../lib/errors.ts'
 
 export function createS3Command (): Command {
   const s3Cmd = new Command('s3')
-    .description('Manage S3 object storage')
+    .description('Future S3 placeholder outside the v1 release surface')
 
-  // TODO: 实现 S3 相关命令
+  // Future, non-v1 placeholder. Do not register this command until the S3 API
+  // integration is implemented and ready for release.
   // - upload
   // - download
   // - list
@@ -22,14 +23,13 @@ export function createS3Command (): Command {
     .option('--acl <acl>', 'Access control: private, public-read')
     .action(async (source, destination, options) => {
       try {
-        console.log('TODO: Implement s3 upload', { source, destination, options })
+        console.log('S3 commands are not part of the v1 release surface yet.', { source, destination, options })
       } catch (error) {
         handleError(error)
       }
     })
 
-  // 其他命令...
-  // 为了简洁，这里只实现 upload 作为示例
+  // This file is kept as a marker for future S3 work only.
 
   return s3Cmd
 }

package/src/commands/template/index.ts

@@ -16,6 +16,29 @@ interface TemplateDeployOptions {
 
 export type TemplateDeployMode = 'catalog' | 'raw'
 
+interface TemplateInstanceResource {
+  name: string
+  uid?: string
+  resourceType: string
+  quota?: {
+    cpu?: number
+    memory?: number
+    storage?: number
+    replicas?: number
+  }
+}
+
+interface TemplateInstanceResult {
+  name: string
+  uid?: string
+  displayName?: string
+  createdAt?: string
+  resourceType?: string
+  dryRun?: boolean
+  args?: Record<string, string>
+  resources?: TemplateInstanceResource[]
+}
+
 export function parseSetArgs (sets: string[]): Record<string, string> {
   const args: Record<string, string> = {}
   for (const s of sets) {
@@ -110,6 +133,56 @@ export function buildRawTemplateDeployBody (
   return body
 }
 
+function formatValue (value: unknown): string {
+  if (value === undefined || value === null || value === '') return '-'
+  return String(value)
+}
+
+function printInstanceResult (instance: TemplateInstanceResult, options: { template?: string; raw?: boolean; dryRun?: boolean } = {}): void {
+  if (options.dryRun) {
+    console.log(chalk.dim(`  Name: ${instance.name}`))
+  } else {
+    console.log(chalk.dim(`  Name:    ${instance.name}`))
+    if (instance.displayName) {
+      console.log(chalk.dim(`  Display: ${instance.displayName}`))
+    }
+    if (instance.uid) {
+      console.log(chalk.dim(`  UID:     ${instance.uid}`))
+    }
+    if (instance.createdAt) {
+      console.log(chalk.dim(`  Created: ${instance.createdAt}`))
+    }
+    if (options.template) {
+      console.log(chalk.dim(`  Template:${options.template}`))
+    }
+  }
+
+  const argEntries = Object.entries(instance.args ?? {})
+  if (argEntries.length > 0) {
+    console.log(chalk.dim('\n  Arguments:'))
+    outputTable([
+      [chalk.bold('Name'), chalk.bold('Value')],
+      ...argEntries.map(([key, value]) => [key, value])
+    ])
+  }
+
+  if (instance.resources && instance.resources.length > 0) {
+    console.log(chalk.dim(options.dryRun ? '\n  Resources that would be created:' : '\n  Resources:'))
+    outputTable([
+      [chalk.bold('Name'), chalk.bold('Type'), chalk.bold('UID'), chalk.bold('CPU'), chalk.bold('Memory'), chalk.bold('Storage'), chalk.bold('Replicas')],
+      ...instance.resources.map(resource => [
+        formatValue(resource.name),
+        formatValue(resource.resourceType),
+        formatValue(resource.uid),
+        resource.quota?.cpu != null ? `${resource.quota.cpu} vCPU` : '-',
+        resource.quota?.memory != null ? `${resource.quota.memory} GiB` : '-',
+        resource.quota?.storage != null ? `${resource.quota.storage} GiB` : '-',
+        formatValue(resource.quota?.replicas)
+      ])
+    ])
+  }
+}
+
 export function createTemplateCommand (): Command {
   const tplCmd = new Command('template')
     .alias('tpl')
@@ -135,26 +208,8 @@ export function createTemplateCommand (): Command {
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
 
-      ctx.spinner.succeed(`Instance "${data.name}" created successfully from catalog template "${catalogTemplate}"`)
-      console.log(chalk.dim(`  UID:     ${data.uid}`))
-      console.log(chalk.dim(`  Created: ${data.createdAt}`))
-
-      if (data.resources && data.resources.length > 0) {
-        console.log(chalk.dim('\n  Resources:'))
-        const rows: string[][] = [
-          [chalk.bold('Name'), chalk.bold('Type'), chalk.bold('CPU'), chalk.bold('Memory'), chalk.bold('Storage')]
-        ]
-        for (const r of data.resources) {
-          rows.push([
-            r.name,
-            r.resourceType,
-            r.quota?.cpu != null ? `${r.quota.cpu} vCPU` : '-',
-            r.quota?.memory != null ? `${r.quota.memory} GiB` : '-',
-            r.quota?.storage != null ? `${r.quota.storage} GiB` : '-'
-          ])
-        }
-        outputTable(rows)
-      }
+      ctx.spinner.succeed(`Instance "${data.name}" created successfully`)
+      printInstanceResult(data, { template: catalogTemplate })
       return
     }
 
@@ -171,23 +226,12 @@ export function createTemplateCommand (): Command {
 
     if (deployOptions.dryRun) {
       ctx.spinner.succeed('Raw template validation passed; no resources were created')
-      console.log(chalk.dim(`  Name: ${data.name}`))
-      if (data.resources && data.resources.length > 0) {
-        console.log(chalk.dim('\n  Resources that would be created:'))
-        for (const r of data.resources) {
-          console.log(chalk.dim(`    - ${r.resourceType}: ${r.name}`))
-        }
-      }
+      printInstanceResult(data, { raw: true, dryRun: true })
       return
     }
 
     ctx.spinner.succeed(`Raw template deployed as "${data.name}"`)
-    if ('uid' in data) {
-      console.log(chalk.dim(`  UID:     ${data.uid}`))
-    }
-    if ('createdAt' in data) {
-      console.log(chalk.dim(`  Created: ${data.createdAt}`))
-    }
+    printInstanceResult(data, { raw: true })
   })
 
   // ── list ─────────────────────────────────────────────────────────
@@ -195,11 +239,12 @@ export function createTemplateCommand (): Command {
     .command('list')
     .description('List available templates')
     .option('-c, --category <category>', 'Filter by category')
+    .option('-l, --language <language>', 'Language code (for example: en, zh)')
     .option('-o, --output <format>', 'Output format (json|table)', 'table')
-    .action(withErrorHandling({ spinnerText: 'Loading templates...' }, async (ctx, options: { category?: string; output: string }) => {
+    .action(withErrorHandling({ spinnerText: 'Loading templates...' }, async (ctx, options: { category?: string; language?: string; output: string }) => {
       const client = createTemplateClient()
       const { data, error, response } = await client.GET('/templates', {
-        params: { query: {} }
+        params: { query: options.language ? { language: options.language } : {} }
       })
 
       if (error) throw mapApiError(response.status, error as ApiErrorBody)
@@ -235,12 +280,14 @@ export function createTemplateCommand (): Command {
     .command('get <name>')
     .alias('describe')
     .description('Get template details')
+    .option('-l, --language <language>', 'Language code (for example: en, zh)')
     .option('-o, --output <format>', 'Output format (json|table)', 'table')
-    .action(withErrorHandling({ spinnerText: 'Loading template...' }, async (ctx, name: string, options: { output: string }) => {
+    .action(withErrorHandling({ spinnerText: 'Loading template...' }, async (ctx, name: string, options: { language?: string; output: string }) => {
       const client = createTemplateClient()
       const { data, error, response } = await client.GET('/templates/{name}', {
         params: {
-          path: { name }
+          path: { name },
+          query: options.language ? { language: options.language } : {}
         }
       })
 
@@ -286,6 +333,25 @@ export function createTemplateCommand (): Command {
       }
     }))
 
+  // -- delete --------------------------------------------------------
+  tplCmd
+    .command('delete <instance>')
+    .alias('rm')
+    .description('Delete a deployed template instance')
+    .action(withAuth({ spinnerText: 'Deleting template instance...' }, async (ctx, instance: string) => {
+      const client = createTemplateClient()
+      const { error, response } = await client.DELETE('/templates/instances/{instanceName}', {
+        headers: ctx.auth,
+        params: {
+          path: { instanceName: instance }
+        }
+      })
+
+      if (error) throw mapApiError(response.status, error as ApiErrorBody)
+
+      ctx.spinner.succeed(`Instance "${instance}" deleted`)
+    }))
+
   // ── deploy ──────────────────────────────────────────────────────
   tplCmd
     .command('deploy [template]')
@@ -298,12 +364,12 @@ export function createTemplateCommand (): Command {
     .addHelpText('after', `
 Examples:
   Catalog:
-    sealos template deploy perplexica --name my-app --set OPENAI_API_KEY=xxx
+    sealos-cli template deploy perplexica --name my-app --set OPENAI_API_KEY=xxx
 
   Raw:
-    sealos template deploy --file ./template.yaml --dry-run
-    sealos template deploy --yaml 'apiVersion: app.sealos.io/v1\nkind: Template\n...'
-    cat template.yaml | sealos template deploy --dry-run
+    sealos-cli template deploy --file ./template.yaml --dry-run
+    sealos-cli template deploy --yaml 'apiVersion: app.sealos.io/v1\nkind: Template\n...'
+    cat template.yaml | sealos-cli template deploy --dry-run
 `)
     .action(async (template: string | undefined, options: TemplateDeployOptions) => {
       const mode = resolveTemplateDeployMode(template, options)

package/src/commands/workspace/index.ts

@@ -1,6 +1,6 @@
 import { Command } from 'commander'
-import { getCurrentContext } from '../../lib/config.ts'
-import { success, outputTable, info } from '../../lib/output.ts'
+import { getAuthInfo, listWorkspaces, switchWorkspace } from '../../lib/auth.ts'
+import { success, outputJson, outputTable } from '../../lib/output.ts'
 import { handleError, AuthError } from '../../lib/errors.ts'
 
 export function createWorkspaceCommand (): Command {
@@ -8,73 +8,83 @@ export function createWorkspaceCommand (): Command {
     .alias('ws')
     .description('Manage workspaces')
 
-  // workspace switch
   workspaceCmd
     .command('switch')
     .description('Switch to another workspace')
-    .argument('<name>', 'Workspace name')
-    .action(async (name) => {
+    .argument('<namespace>', 'Workspace id, uid, or team name')
+    .option('-o, --output <format>', 'Output format: json, table', 'table')
+    .action(async (namespace, options) => {
       try {
-        // TODO: 调用 API 验证 workspace 是否存在
-        // const api = createApiClient()
-        // await api.get(`/api/v1/workspaces/${name}`)
-
-        // 更新配置
-        const context = getCurrentContext()
-        if (context) {
-          context.workspace = name
-          // TODO: 更新到配置文件
+        const result = await switchWorkspace(namespace)
+        if (options.output === 'json') {
+          outputJson(result)
+          return
         }
 
-        success(`Switched to workspace: ${name}`)
+        success(`Switched to workspace: ${result.workspace.id || result.workspace.uid || namespace}`)
       } catch (error) {
         handleError(error)
       }
     })
 
-  // workspace list
   workspaceCmd
     .command('list')
     .description('List all workspaces')
-    .action(async () => {
+    .option('-o, --output <format>', 'Output format: json, table', 'table')
+    .action(async (options) => {
       try {
-        const context = getCurrentContext()
-        if (!context) {
-          throw new AuthError()
+        const result = await listWorkspaces()
+        if (options.output === 'json') {
+          outputJson(result)
+          return
         }
 
-        // 示例数据
-        const data = [
-          ['NAME', 'STATUS', 'CURRENT'],
-          ['default', 'Active', context.workspace === 'default' ? '*' : ''],
-          ['production', 'Active', context.workspace === 'production' ? '*' : '']
-        ]
-
-        outputTable(data)
-        info('API integration needed for real data')
+        outputTable([
+          ['UID', 'ID', 'TEAM', 'ROLE', 'TYPE', 'CURRENT'],
+          ...result.workspaces.map(workspace => [
+            workspace.uid || '',
+            workspace.id || '',
+            workspace.teamName || '',
+            workspace.role || '',
+            workspace.nstype || '',
+            workspace.id === result.current ? '*' : ''
+          ])
+        ])
       } catch (error) {
         handleError(error)
       }
     })
 
-  // workspace current
   workspaceCmd
     .command('current')
     .description('Show current workspace')
-    .action(async () => {
+    .option('-o, --output <format>', 'Output format: json, table', 'table')
+    .action(async (options) => {
       try {
-        const context = getCurrentContext()
-        if (!context) {
+        const authInfo = getAuthInfo()
+        if (!authInfo.authenticated) {
           throw new AuthError()
         }
 
-        const data = [
-          ['Field', 'Value'],
-          ['Workspace', context.workspace],
-          ['Context', context.name]
-        ]
+        const workspace = authInfo.current_workspace || null
+        const result = {
+          workspace,
+          region: authInfo.region || 'unknown',
+          kubeconfig_path: authInfo.kubeconfig_path || 'unknown'
+        }
+
+        if (options.output === 'json') {
+          outputJson(result)
+          return
+        }
 
-        outputTable(data)
+        outputTable([
+          ['Field', 'Value'],
+          ['Workspace', workspace?.id || authInfo.workspace || 'unknown'],
+          ['Team', workspace?.teamName || 'unknown'],
+          ['Region', authInfo.region || 'unknown'],
+          ['Kubeconfig', authInfo.kubeconfig_path || 'unknown']
+        ])
       } catch (error) {
         handleError(error)
       }

package/src/docs/database_openapi.json

@@ -6889,46 +6889,29 @@
               "application/json": {
                 "schema": {
                   "type": "object",
-                  "properties": {
-                    "code": {
-                      "type": "number"
-                    },
-                    "message": {
+                  "propertyNames": {
+                    "type": "string",
+                    "enum": [
+                      "postgresql",
+                      "mongodb",
+                      "apecloud-mysql",
+                      "mysql",
+                      "redis",
+                      "kafka",
+                      "qdrant",
+                      "nebula",
+                      "weaviate",
+                      "milvus",
+                      "pulsar",
+                      "clickhouse"
+                    ]
+                  },
+                  "additionalProperties": {
+                    "type": "array",
+                    "items": {
                       "type": "string"
-                    },
-                    "data": {
-                      "type": "object",
-                      "propertyNames": {
-                        "type": "string",
-                        "enum": [
-                          "postgresql",
-                          "mongodb",
-                          "apecloud-mysql",
-                          "mysql",
-                          "redis",
-                          "kafka",
-                          "qdrant",
-                          "nebula",
-                          "weaviate",
-                          "milvus",
-                          "pulsar",
-                          "clickhouse"
-                        ]
-                      },
-                      "additionalProperties": {
-                        "type": "array",
-                        "items": {
-                          "type": "string"
-                        }
-                      }
                     }
-                  },
-                  "required": [
-                    "code",
-                    "message",
-                    "data"
-                  ],
-                  "additionalProperties": false
+                  }
                 }
               }
             }