sealos-cli 0.1.0

package/src/commands/devbox/index.ts

@@ -0,0 +1,224 @@
+import { Command } from 'commander'
+import { getCurrentContext } from '../../lib/config.ts'
+import { success, spinner, outputTable, formatOutput, info } from '../../lib/output.ts'
+import { handleError, AuthError } from '../../lib/errors.ts'
+
+export function createDevboxCommand (): Command {
+  const devboxCmd = new Command('devbox')
+    .alias('dev')
+    .description('Manage devbox instances')
+
+  // devbox create
+  devboxCmd
+    .command('create')
+    .description('Create a new devbox')
+    .argument('[path]', 'Project path', '.')
+    .option('--name <name>', 'Devbox name')
+    .option('--template <template>', 'Template to use', 'default')
+    .option('--cpu <cpu>', 'CPU configuration', '1c')
+    .option('--memory <memory>', 'Memory configuration', '2g')
+    .option('--port <port>', 'Port number')
+    .option('--config <config>', 'Config file path')
+    .action(async (path, options) => {
+      try {
+        const context = getCurrentContext()
+        if (!context) {
+          throw new AuthError()
+        }
+
+        const spin = spinner('Creating devbox...')
+
+        // TODO: 实现创建 devbox
+        // 1. 读取配置文件（如果有）
+        // 2. 调用 API 创建 devbox
+        // const result = await api.post('/api/v1/devbox', {
+        //   name: options.name,
+        //   template: options.template,
+        //   resources: {
+        //     cpu: options.cpu,
+        //     memory: options.memory
+        //   }
+        // })
+
+        // 3. 等待创建完成
+        // 4. 返回访问地址
+
+        spin.succeed('Devbox created successfully')
+        success('Devbox URL: https://example.sealos.run')
+        info(`Run "sealos devbox connect ${options.name || 'devbox'}" to connect`)
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // devbox list
+  devboxCmd
+    .command('list')
+    .description('List all devboxes')
+    .option('-o, --output <format>', 'Output format: json, yaml, table', 'table')
+    .option('--selector <selector>', 'Label selector')
+    .action(async (options) => {
+      try {
+        const context = getCurrentContext()
+        if (!context) {
+          throw new AuthError()
+        }
+
+        // 示例数据
+        const data = [
+          ['NAME', 'STATUS', 'CPU', 'MEMORY', 'CREATED'],
+          ['my-devbox', 'Running', '2c', '4g', '2h ago'],
+          ['test-box', 'Stopped', '1c', '2g', '1d ago']
+        ]
+
+        if (options.output === 'json') {
+          formatOutput({ items: data.slice(1) }, 'json')
+        } else if (options.output === 'yaml') {
+          formatOutput({ items: data.slice(1) }, 'yaml')
+        } else {
+          outputTable(data)
+        }
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // devbox get
+  devboxCmd
+    .command('get')
+    .description('Get devbox details')
+    .argument('<name>', 'Devbox name')
+    .action(async (name) => {
+      try {
+        const context = getCurrentContext()
+        if (!context) {
+          throw new AuthError()
+        }
+
+        const data = [
+          ['Field', 'Value'],
+          ['Name', name],
+          ['Status', 'Running'],
+          ['CPU', '2c'],
+          ['Memory', '4g'],
+          ['URL', 'https://example.sealos.run']
+        ]
+
+        outputTable(data)
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // devbox start/stop/restart/delete
+  const actions = ['start', 'stop', 'restart', 'delete']
+  actions.forEach(action => {
+    const cmd = devboxCmd
+      .command(action)
+      .description(`${action.charAt(0).toUpperCase() + action.slice(1)} a devbox`)
+      .argument('<name>', 'Devbox name')
+
+    if (action === 'delete') {
+      cmd.option('-f, --force', 'Force delete without confirmation')
+    }
+
+    cmd.action(async (name, options) => {
+      try {
+        const context = getCurrentContext()
+        if (!context) {
+          throw new AuthError()
+        }
+
+        const spin = spinner(`${action}ing devbox...`)
+
+        // TODO: 实现对应操作
+        spin.succeed(`Devbox ${action}ed successfully`)
+      } catch (error) {
+        handleError(error)
+      }
+    })
+  })
+
+  // devbox connect
+  devboxCmd
+    .command('connect')
+    .description('Connect to a devbox')
+    .argument('<name>', 'Devbox name')
+    .option('--ide <ide>', 'IDE type: vscode, cursor', 'vscode')
+    .action(async (name, options) => {
+      try {
+        const context = getCurrentContext()
+        if (!context) {
+          throw new AuthError()
+        }
+
+        // TODO: 实现连接 devbox
+        // 1. 获取 devbox 信息
+        // 2. 根据 IDE 类型打开对应的连接
+
+        info(`Opening ${name} in ${options.ide}...`)
+        success(`Connect URL: ${options.ide}://remote-ssh/devbox-${name}`)
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // devbox publish
+  devboxCmd
+    .command('publish')
+    .description('Publish a devbox')
+    .argument('<name>', 'Devbox name')
+    .action(async (name) => {
+      try {
+        const context = getCurrentContext()
+        if (!context) {
+          throw new AuthError()
+        }
+
+        const spin = spinner('Publishing devbox...')
+
+        // TODO: 实现发布 devbox
+        spin.succeed('Devbox published successfully')
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // devbox template 子命令
+  const templateCmd = devboxCmd
+    .command('template')
+    .description('Manage devbox templates')
+
+  templateCmd
+    .command('build')
+    .description('Build a devbox template')
+    .option('--name <name>', 'Template name')
+    .action(async (options) => {
+      try {
+        // TODO: 实现构建 template
+        info('Building template...')
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  templateCmd
+    .command('list')
+    .description('List devbox templates')
+    .action(async () => {
+      try {
+        // TODO: 列出 devbox templates
+        const data = [
+          ['NAME', 'DESCRIPTION', 'VERSION'],
+          ['nextjs', 'Next.js development environment', '1.0.0'],
+          ['python', 'Python 3.11 environment', '1.0.0']
+        ]
+
+        outputTable(data)
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  return devboxCmd
+}

package/src/commands/quota/index.ts

@@ -0,0 +1,22 @@
+import { Command } from 'commander'
+import { handleError } from '../../lib/errors.ts'
+
+export function createQuotaCommand (): Command {
+  const quotaCmd = new Command('quota')
+    .description('View resource quotas')
+
+  // TODO: 实现配额相关命令
+
+  quotaCmd
+    .command('get')
+    .description('Get quota information')
+    .action(async () => {
+      try {
+        console.log('TODO: Implement quota get')
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  return quotaCmd
+}

package/src/commands/s3/index.ts

@@ -0,0 +1,35 @@
+import { Command } from 'commander'
+import { handleError } from '../../lib/errors.ts'
+
+export function createS3Command (): Command {
+  const s3Cmd = new Command('s3')
+    .description('Manage S3 object storage')
+
+  // TODO: 实现 S3 相关命令
+  // - upload
+  // - download
+  // - list
+  // - delete
+  // - sync
+  // - bucket (create/list/delete)
+
+  s3Cmd
+    .command('upload')
+    .description('Upload files to S3')
+    .argument('<source>', 'Source file or directory')
+    .argument('[destination]', 'Destination path')
+    .option('--bucket <bucket>', 'Bucket name')
+    .option('--acl <acl>', 'Access control: private, public-read')
+    .action(async (source, destination, options) => {
+      try {
+        console.log('TODO: Implement s3 upload', { source, destination, options })
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // 其他命令...
+  // 为了简洁，这里只实现 upload 作为示例
+
+  return s3Cmd
+}

package/src/commands/template/index.ts

@@ -0,0 +1,314 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { readFileSync } from 'node:fs'
+import { createTemplateClient } from '../../lib/api-client.ts'
+import { type ApiErrorBody, mapApiError } from '../../lib/errors.ts'
+import { outputJson, outputTable } from '../../lib/output.ts'
+import { withAuth, withErrorHandling } from '../../lib/with-auth.ts'
+
+interface TemplateDeployOptions {
+  name?: string
+  file?: string
+  yaml?: string
+  set: string[]
+  dryRun?: boolean
+}
+
+export type TemplateDeployMode = 'catalog' | 'raw'
+
+export function parseSetArgs (sets: string[]): Record<string, string> {
+  const args: Record<string, string> = {}
+  for (const s of sets) {
+    const idx = s.indexOf('=')
+    if (idx === -1) {
+      throw new Error(`Invalid --set format: "${s}". Expected KEY=VALUE`)
+    }
+    args[s.slice(0, idx)] = s.slice(idx + 1)
+  }
+  return args
+}
+
+function readStdin (): Promise<string> {
+  return new Promise((resolve, reject) => {
+    if (process.stdin.isTTY) {
+      reject(new Error('No input provided. Use --file, --yaml, or pipe YAML via stdin.'))
+      return
+    }
+    const chunks: Buffer[] = []
+    process.stdin.on('data', (chunk) => chunks.push(chunk))
+    process.stdin.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8').trim()))
+    process.stdin.on('error', reject)
+  })
+}
+
+async function resolveYaml (options: { file?: string; yaml?: string }, spinner: { stop: () => void; start: (text?: string) => void }): Promise<string> {
+  if (options.file) {
+    return readFileSync(options.file, 'utf-8')
+  }
+  if (options.yaml) {
+    return options.yaml
+  }
+  spinner.stop()
+  const content = await readStdin()
+  spinner.start('Deploying template...')
+  return content
+}
+
+export function resolveTemplateDeployMode (
+  template: string | undefined,
+  options: TemplateDeployOptions,
+  stdinIsTTY: boolean = process.stdin.isTTY
+): TemplateDeployMode {
+  const isRaw = !!(options.file || options.yaml || !stdinIsTTY)
+
+  if (template && isRaw) {
+    throw new Error('Cannot specify both a template name and --file/--yaml/stdin. Use one or the other.')
+  }
+  if (!template && !isRaw) {
+    throw new Error('Provide a template name or use --file/--yaml/stdin to supply raw YAML.')
+  }
+  if (template) {
+    if (!options.name) {
+      throw new Error('--name is required when deploying from the template catalog.')
+    }
+    if (options.dryRun) {
+      throw new Error('--dry-run is only supported for raw template deploys (--file, --yaml, or stdin).')
+    }
+    return 'catalog'
+  }
+
+  return 'raw'
+}
+
+export function buildCatalogTemplateDeployBody (
+  template: string,
+  options: Pick<TemplateDeployOptions, 'name' | 'set'>
+): { name: string; template: string; args?: Record<string, string> } {
+  const body: { name: string; template: string; args?: Record<string, string> } = {
+    name: options.name!,
+    template
+  }
+  if (options.set.length > 0) {
+    body.args = parseSetArgs(options.set)
+  }
+  return body
+}
+
+export function buildRawTemplateDeployBody (
+  yaml: string,
+  options: Pick<TemplateDeployOptions, 'set' | 'dryRun'>
+): { yaml: string; args?: Record<string, string>; dryRun?: boolean } {
+  const body: { yaml: string; args?: Record<string, string>; dryRun?: boolean } = {
+    yaml
+  }
+  if (options.set.length > 0) {
+    body.args = parseSetArgs(options.set)
+  }
+  if (options.dryRun) {
+    body.dryRun = true
+  }
+  return body
+}
+
+export function createTemplateCommand (): Command {
+  const tplCmd = new Command('template')
+    .alias('tpl')
+    .description('Manage templates')
+
+  const deployTemplate = withAuth({
+    spinnerText: 'Deploying template...'
+  }, async (
+    ctx,
+    catalogTemplate: string | undefined,
+    deployOptions: TemplateDeployOptions,
+    deployMode: TemplateDeployMode
+  ) => {
+    const client = createTemplateClient()
+
+    // ── deploy from catalog ──
+    if (deployMode === 'catalog') {
+      const body = buildCatalogTemplateDeployBody(catalogTemplate!, deployOptions)
+      const { data, error, response } = await client.POST('/templates/instances', {
+        headers: ctx.auth,
+        body
+      })
+
+      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)
+      }
+      return
+    }
+
+    // ── deploy from raw YAML ──
+    const yamlContent = await resolveYaml(deployOptions, ctx.spinner)
+    const body = buildRawTemplateDeployBody(yamlContent, deployOptions)
+
+    const { data, error, response } = await client.POST('/templates/raw', {
+      headers: ctx.auth,
+      body
+    })
+
+    if (error) throw mapApiError(response.status, error as ApiErrorBody)
+
+    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}`))
+        }
+      }
+      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}`))
+    }
+  })
+
+  // ── list ─────────────────────────────────────────────────────────
+  tplCmd
+    .command('list')
+    .description('List available templates')
+    .option('-c, --category <category>', 'Filter by category')
+    .option('-o, --output <format>', 'Output format (json|table)', 'table')
+    .action(withErrorHandling({ spinnerText: 'Loading templates...' }, async (ctx, options: { category?: string; output: string }) => {
+      const client = createTemplateClient()
+      const { data, error, response } = await client.GET('/templates', {
+        params: { query: {} }
+      })
+
+      if (error) throw mapApiError(response.status, error as ApiErrorBody)
+
+      ctx.spinner.stop()
+
+      let templates = data
+      if (options.category) {
+        templates = templates.filter((tpl: typeof data[number]) => tpl.category.includes(options.category!))
+      }
+
+      if (options.output === 'json') {
+        outputJson(templates)
+        return
+      }
+
+      const rows: string[][] = [
+        [chalk.bold('Name'), chalk.bold('Description'), chalk.bold('Category'), chalk.bold('Deploys')]
+      ]
+      for (const tpl of templates) {
+        rows.push([
+          tpl.name,
+          tpl.description.length > 50 ? tpl.description.slice(0, 47) + '...' : tpl.description,
+          tpl.category.join(', '),
+          String(tpl.deployCount)
+        ])
+      }
+      outputTable(rows)
+    }))
+
+  // ── get ──────────────────────────────────────────────────────────
+  tplCmd
+    .command('get <name>')
+    .alias('describe')
+    .description('Get template details')
+    .option('-o, --output <format>', 'Output format (json|table)', 'table')
+    .action(withErrorHandling({ spinnerText: 'Loading template...' }, async (ctx, name: string, options: { output: string }) => {
+      const client = createTemplateClient()
+      const { data, error, response } = await client.GET('/templates/{name}', {
+        params: {
+          path: { name }
+        }
+      })
+
+      if (error) throw mapApiError(response.status, error as ApiErrorBody)
+
+      ctx.spinner.stop()
+
+      if (options.output === 'json') {
+        outputJson(data)
+        return
+      }
+
+      console.log(chalk.bold(`\n  ${data.name}\n`))
+      console.log(`  ${chalk.dim('Description:')}  ${data.description}`)
+      console.log(`  ${chalk.dim('Category:')}     ${data.category.join(', ')}`)
+      console.log(`  ${chalk.dim('Git Repo:')}     ${data.gitRepo}`)
+      console.log(`  ${chalk.dim('Deploys:')}      ${data.deployCount}`)
+
+      if (data.quota) {
+        console.log(`\n  ${chalk.dim('Resources:')}`)
+        console.log(`    CPU:       ${data.quota.cpu} vCPU`)
+        console.log(`    Memory:    ${data.quota.memory} GiB`)
+        console.log(`    Storage:   ${data.quota.storage} GiB`)
+        console.log(`    NodePort:  ${data.quota.nodeport}`)
+      }
+
+      const argEntries = Object.entries(data.args)
+      if (argEntries.length > 0) {
+        console.log(`\n  ${chalk.dim('Arguments:')}`)
+        const argRows: string[][] = [
+          [chalk.bold('Name'), chalk.bold('Type'), chalk.bold('Required'), chalk.bold('Default'), chalk.bold('Description')]
+        ]
+        for (const [key, arg] of argEntries) {
+          argRows.push([
+            key,
+            arg.type,
+            arg.required ? chalk.red('yes') : 'no',
+            arg.default || chalk.dim('-'),
+            arg.description
+          ])
+        }
+        outputTable(argRows)
+      }
+    }))
+
+  // ── deploy ──────────────────────────────────────────────────────
+  tplCmd
+    .command('deploy [template]')
+    .description('Deploy a template (from catalog or raw YAML)')
+    .option('--name <name>', 'Instance name (required when deploying from catalog)')
+    .option('--file <path>', 'Path to template YAML file')
+    .option('--yaml <yaml>', 'Template YAML string')
+    .option('--set <KEY=VALUE...>', 'Set template arguments', (val: string, prev: string[]) => [...prev, val], [] as string[])
+    .option('--dry-run', 'Validate raw template YAML without creating resources')
+    .addHelpText('after', `
+Examples:
+  Catalog:
+    sealos 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
+`)
+    .action(async (template: string | undefined, options: TemplateDeployOptions) => {
+      const mode = resolveTemplateDeployMode(template, options)
+      await deployTemplate(template, options, mode)
+    })
+
+  return tplCmd
+}

package/src/commands/workspace/index.ts

@@ -0,0 +1,84 @@
+import { Command } from 'commander'
+import { getCurrentContext } from '../../lib/config.ts'
+import { success, outputTable, info } from '../../lib/output.ts'
+import { handleError, AuthError } from '../../lib/errors.ts'
+
+export function createWorkspaceCommand (): Command {
+  const workspaceCmd = new Command('workspace')
+    .alias('ws')
+    .description('Manage workspaces')
+
+  // workspace switch
+  workspaceCmd
+    .command('switch')
+    .description('Switch to another workspace')
+    .argument('<name>', 'Workspace name')
+    .action(async (name) => {
+      try {
+        // TODO: 调用 API 验证 workspace 是否存在
+        // const api = createApiClient()
+        // await api.get(`/api/v1/workspaces/${name}`)
+
+        // 更新配置
+        const context = getCurrentContext()
+        if (context) {
+          context.workspace = name
+          // TODO: 更新到配置文件
+        }
+
+        success(`Switched to workspace: ${name}`)
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // workspace list
+  workspaceCmd
+    .command('list')
+    .description('List all workspaces')
+    .action(async () => {
+      try {
+        const context = getCurrentContext()
+        if (!context) {
+          throw new AuthError()
+        }
+
+        // 示例数据
+        const data = [
+          ['NAME', 'STATUS', 'CURRENT'],
+          ['default', 'Active', context.workspace === 'default' ? '*' : ''],
+          ['production', 'Active', context.workspace === 'production' ? '*' : '']
+        ]
+
+        outputTable(data)
+        info('API integration needed for real data')
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  // workspace current
+  workspaceCmd
+    .command('current')
+    .description('Show current workspace')
+    .action(async () => {
+      try {
+        const context = getCurrentContext()
+        if (!context) {
+          throw new AuthError()
+        }
+
+        const data = [
+          ['Field', 'Value'],
+          ['Workspace', context.workspace],
+          ['Context', context.name]
+        ]
+
+        outputTable(data)
+      } catch (error) {
+        handleError(error)
+      }
+    })
+
+  return workspaceCmd
+}