sealos-cli 0.1.0 → 1.0.0

package/src/generated/template.ts

@@ -104,6 +104,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/templates/instances/{instanceName}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        post?: never;
+        /**
+         * Delete template instance
+         * @description Deletes a deployed template instance from the user namespace. Instances created with ownerReferences enabled delete their explicit PVCs first and then delete the Instance so Kubernetes garbage collection removes owned dependents. Legacy instances without the ownerReferences-ready marker use the comprehensive label-selector cleanup path before deleting the Instance.
+         */
+        delete: operations["deleteInstance"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
 }
 export type webhooks = Record<string, never>;
 export interface components {
@@ -1004,4 +1024,212 @@ export interface operations {
             };
         };
     };
+    deleteInstance: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Name of the deployed template instance to delete (must exist in user namespace) */
+                instanceName: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Instance deleted successfully. No response body. */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Bad request - invalid instance name parameter */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /**
+                             * @description High-level error type for categorization
+                             * @enum {string}
+                             */
+                            type: "validation_error";
+                            /**
+                             * @description Specific error code for programmatic handling and i18n
+                             * @enum {string}
+                             */
+                            code: "INVALID_PARAMETER";
+                            /** @description Human-readable error message */
+                            message: string;
+                            /** @description For INVALID_PARAMETER: Array<{ field, message }>. For INVALID_VALUE: optional string. Omitted for other codes. */
+                            details?: {
+                                /** @description Field path using dot/bracket notation, e.g. "ports[0].number" */
+                                field: string;
+                                /** @description Validation error message for this field */
+                                message: string;
+                            }[] | string;
+                        };
+                    };
+                };
+            };
+            /** @description Unauthorized - Missing or invalid kubeconfig */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /**
+                             * @description High-level error type for categorization
+                             * @constant
+                             */
+                            type: "authentication_error";
+                            /**
+                             * @description Specific error code for programmatic handling and i18n
+                             * @constant
+                             */
+                            code: "AUTHENTICATION_REQUIRED";
+                            /** @description Human-readable error message */
+                            message: string;
+                            /** @description Typically omitted. May contain additional context in edge cases. */
+                            details?: string;
+                        };
+                    };
+                };
+            };
+            /** @description Forbidden - Insufficient permissions */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /**
+                             * @description High-level error type for categorization
+                             * @constant
+                             */
+                            type: "authorization_error";
+                            /**
+                             * @description Specific error code for programmatic handling and i18n
+                             * @enum {string}
+                             */
+                            code: "PERMISSION_DENIED";
+                            /** @description Human-readable error message */
+                            message: string;
+                            /** @description Typically omitted. May contain additional context in edge cases. */
+                            details?: string;
+                        };
+                    };
+                };
+            };
+            /** @description Not Found - Instance not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /**
+                             * @description High-level error type for categorization
+                             * @constant
+                             */
+                            type: "resource_error";
+                            /**
+                             * @description Specific error code for programmatic handling and i18n
+                             * @constant
+                             */
+                            code: "NOT_FOUND";
+                            /** @description Human-readable error message */
+                            message: string;
+                            /** @description Typically omitted. May contain additional context in edge cases. */
+                            details?: string;
+                        };
+                    };
+                };
+            };
+            /** @description Method Not Allowed */
+            405: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /**
+                             * @description High-level error type for categorization
+                             * @constant
+                             */
+                            type: "client_error";
+                            /**
+                             * @description Specific error code for programmatic handling and i18n
+                             * @constant
+                             */
+                            code: "METHOD_NOT_ALLOWED";
+                            /** @description Human-readable error message */
+                            message: string;
+                            /** @description Typically omitted. */
+                            details?: string;
+                        };
+                    };
+                };
+            };
+            /** @description Internal Server Error - Kubernetes API error or unexpected failure */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /**
+                             * @description High-level error type for categorization
+                             * @enum {string}
+                             */
+                            type: "operation_error" | "internal_error";
+                            /**
+                             * @description Specific error code for programmatic handling and i18n
+                             * @enum {string}
+                             */
+                            code: "KUBERNETES_ERROR" | "INTERNAL_ERROR";
+                            /** @description Human-readable error message */
+                            message: string;
+                            /** @description Raw error string from the underlying system, for troubleshooting. */
+                            details?: string;
+                        };
+                    };
+                };
+            };
+            /** @description Service Unavailable - Kubernetes cluster temporarily unreachable */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        error: {
+                            /**
+                             * @description High-level error type for categorization
+                             * @constant
+                             */
+                            type: "internal_error";
+                            /**
+                             * @description Specific error code for programmatic handling and i18n
+                             * @constant
+                             */
+                            code: "SERVICE_UNAVAILABLE";
+                            /** @description Human-readable error message */
+                            message: string;
+                            /** @description Raw connection error from the underlying system (e.g. ECONNREFUSED). */
+                            details?: string;
+                        };
+                    };
+                };
+            };
+        };
+    };
 }

package/src/lib/api-client.ts

@@ -1,6 +1,7 @@
 import createClient from 'openapi-fetch'
 import type { paths as TemplatePaths } from '../generated/template.ts'
 import type { paths as DatabasePaths } from '../generated/database.ts'
+import type { paths as DevboxPaths } from '../generated/devbox.ts'
 import { DEFAULT_SEALOS_REGION, loadAuth } from './auth.ts'
 import { ConfigError } from './errors.ts'
 
@@ -27,6 +28,10 @@ export function resolveTemplateProviderHost (host: string): string {
   return resolvePrefixedHost(host, 'template')
 }
 
+export function resolveDevboxProviderHost (host: string): string {
+  return resolvePrefixedHost(host, 'devbox')
+}
+
 function resolvePrefixedHost (host: string, prefix: string): string {
   const url = new URL(host)
 
@@ -55,6 +60,15 @@ function resolveTemplateHost (options?: { baseUrl?: string }): string {
   return resolveTemplateProviderHost(resolveHost(options))
 }
 
+function resolveDevboxHost (options?: { baseUrl?: string }): string {
+  const override = process.env.SEALOS_DEVBOX_HOST?.trim()
+  if (override) {
+    return override.replace(/\/+$/, '')
+  }
+
+  return resolveDevboxProviderHost(resolveHost(options))
+}
+
 export function createTemplateClient (options?: { baseUrl?: string }) {
   return createClient<TemplatePaths>({ baseUrl: `${resolveTemplateHost(options)}/api/v2alpha` })
 }
@@ -62,3 +76,7 @@ export function createTemplateClient (options?: { baseUrl?: string }) {
 export function createDatabaseClient (options?: { baseUrl?: string }) {
   return createClient<DatabasePaths>({ baseUrl: `${resolveDatabaseHost(options)}/api/v2alpha` })
 }
+
+export function createDevboxClient (options?: { baseUrl?: string }) {
+  return createClient<DevboxPaths>({ baseUrl: `${resolveDevboxHost(options)}/api/v2alpha` })
+}

package/src/lib/auth.ts

@@ -147,7 +147,7 @@ export function loadAuth (deps: AuthDependencies = {}): SealosAuthData {
   return JSON.parse(readFileSync(paths.authPath, 'utf-8')) as SealosAuthData
 }
 
-export function getToken (deps: AuthDependencies = {}): string | null {
+export function getRegionalToken (deps: AuthDependencies = {}): string | null {
   try {
     return loadAuth(deps).regional_token || null
   } catch {
@@ -155,9 +155,18 @@ export function getToken (deps: AuthDependencies = {}): string | null {
   }
 }
 
+export function getKubeconfigContent (deps: AuthDependencies = {}): string | null {
+  const { paths } = withDeps(deps)
+  try {
+    return readFileSync(paths.kubeconfigPath, 'utf-8')
+  } catch {
+    return null
+  }
+}
+
 export function getAuthHeaders (deps: AuthDependencies = {}): { Authorization: string } | null {
-  const token = getToken(deps)
-  return token ? { Authorization: token } : null
+  const kubeconfig = getKubeconfigContent(deps)
+  return kubeconfig ? { Authorization: encodeURIComponent(kubeconfig) } : null
 }
 
 export function requireAuth (deps: AuthDependencies = {}): { Authorization: string } {

package/src/main.ts

@@ -3,12 +3,8 @@ import { Command } from 'commander'
 import { registerAuthCommands } from './commands/auth/index.ts'
 import { createWorkspaceCommand } from './commands/workspace/index.ts'
 import { createDevboxCommand } from './commands/devbox/index.ts'
-import { createS3Command } from './commands/s3/index.ts'
 import { createDatabaseCommand } from './commands/database/index.ts'
 import { createTemplateCommand } from './commands/template/index.ts'
-import { createQuotaCommand } from './commands/quota/index.ts'
-import { createAppCommand } from './commands/app/index.ts'
-import { createConfigCommand } from './commands/config/index.ts'
 import { handleError } from './lib/errors.ts'
 
 export function createProgram (): Command {
@@ -16,19 +12,15 @@ export function createProgram (): Command {
 
   program
     .name('sealos')
-    .description('Official CLI tool for Sealos Cloud - Manage devbox, applications, databases, and object storage')
+    .description('Official CLI tool for Sealos Cloud - Manage devbox, databases, templates, auth, and workspaces')
     .version('0.0.1')
 
   // Register all command modules
   registerAuthCommands(program)
   program.addCommand(createWorkspaceCommand())
   program.addCommand(createDevboxCommand())
-  program.addCommand(createS3Command())
   program.addCommand(createDatabaseCommand())
   program.addCommand(createTemplateCommand())
-  program.addCommand(createQuotaCommand())
-  program.addCommand(createAppCommand())
-  program.addCommand(createConfigCommand())
 
   return program
 }

package/src/types/index.ts

@@ -1,17 +1,5 @@
 // Core type definitions
 
-export interface SealosConfig {
-  currentContext: string
-  contexts: Context[]
-}
-
-export interface Context {
-  name: string
-  host: string
-  token: string
-  workspace: string
-}
-
 export interface DevboxConfig {
   name?: string
   template: string

package/src/commands/config/index.ts

@@ -1,54 +0,0 @@
-import { Command } from 'commander'
-import { readConfig, setConfigValue, getConfigValue } from '../../lib/config.ts'
-import { success, outputJson } from '../../lib/output.ts'
-import { handleError } from '../../lib/errors.ts'
-
-export function createConfigCommand (): Command {
-  const configCmd = new Command('config')
-    .description('Manage CLI configuration')
-
-  configCmd
-    .command('set')
-    .description('Set a config value')
-    .argument('<key>', 'Config key')
-    .argument('<value>', 'Config value')
-    .action(async (key, value) => {
-      try {
-        setConfigValue(key, value)
-        success(`Config ${key} set to ${value}`)
-      } catch (error) {
-        handleError(error)
-      }
-    })
-
-  configCmd
-    .command('get')
-    .description('Get a config value')
-    .argument('<key>', 'Config key')
-    .action(async (key) => {
-      try {
-        const value = getConfigValue(key)
-        if (value) {
-          console.log(value)
-        } else {
-          console.log(`Config key "${key}" not found`)
-        }
-      } catch (error) {
-        handleError(error)
-      }
-    })
-
-  configCmd
-    .command('list')
-    .description('List all config values')
-    .action(async () => {
-      try {
-        const config = readConfig()
-        outputJson(config)
-      } catch (error) {
-        handleError(error)
-      }
-    })
-
-  return configCmd
-}

package/src/lib/api.ts

@@ -1,83 +0,0 @@
-import axios, { type AxiosInstance, type AxiosRequestConfig } from 'axios'
-import { getCurrentContext } from './config.ts'
-
-/**
- * API client base class
- */
-export class ApiClient {
-  private client: AxiosInstance
-
-  constructor (baseURL?: string) {
-    const context = getCurrentContext()
-
-    this.client = axios.create({
-      baseURL: baseURL || context?.host || '',
-      timeout: 30000,
-      headers: {
-        'Content-Type': 'application/json'
-      }
-    })
-
-    // Request interceptor - add auth token
-    this.client.interceptors.request.use(
-      (config) => {
-        const context = getCurrentContext()
-        if (context?.token) {
-          config.headers.Authorization = `Bearer ${context.token}`
-        }
-
-        // Support KUBECONFIG environment variable
-        const kubeconfig = process.env.KUBECONFIG
-        if (kubeconfig) {
-          config.headers['X-Kubeconfig'] = kubeconfig
-        }
-
-        return config
-      },
-      async (error) => await Promise.reject(error)
-    )
-
-    // Response interceptor - unified error handling
-    this.client.interceptors.response.use(
-      (response) => response,
-      async (error) => {
-        if (error.response?.status === 401) {
-          throw new Error('Authentication failed. Please run "sealos login" first.')
-        }
-        return await Promise.reject(error)
-      }
-    )
-  }
-
-  async get<T = any> (url: string, config?: AxiosRequestConfig): Promise<T> {
-    const response = await this.client.get<T>(url, config)
-    return response.data
-  }
-
-  async post<T = any> (url: string, data?: any, config?: AxiosRequestConfig): Promise<T> {
-    const response = await this.client.post<T>(url, data, config)
-    return response.data
-  }
-
-  async put<T = any> (url: string, data?: any, config?: AxiosRequestConfig): Promise<T> {
-    const response = await this.client.put<T>(url, data, config)
-    return response.data
-  }
-
-  async delete<T = any> (url: string, config?: AxiosRequestConfig): Promise<T> {
-    const response = await this.client.delete<T>(url, config)
-    return response.data
-  }
-
-  async patch<T = any> (url: string, data?: any, config?: AxiosRequestConfig): Promise<T> {
-    const response = await this.client.patch<T>(url, data, config)
-    return response.data
-  }
-}
-
-/**
- * Create API client instance
- */
-export function createApiClient (baseURL?: string): ApiClient {
-  return new ApiClient(baseURL)
-}

package/src/lib/config.ts

@@ -1,134 +0,0 @@
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs'
-import type { SealosConfig, Context } from '../types/index.ts'
-
-const CONFIG_DIR = join(homedir(), '.sealos')
-const CONFIG_FILE = join(CONFIG_DIR, 'config.json')
-
-/**
- * Ensure config directory exists
- */
-export function ensureConfigDir (): void {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true })
-  }
-}
-
-/**
- * Read config file
- */
-export function readConfig (): SealosConfig {
-  ensureConfigDir()
-
-  if (!existsSync(CONFIG_FILE)) {
-    const defaultConfig: SealosConfig = {
-      currentContext: '',
-      contexts: []
-    }
-    return defaultConfig
-  }
-
-  try {
-    const content = readFileSync(CONFIG_FILE, 'utf-8')
-    return JSON.parse(content) as SealosConfig
-  } catch (error) {
-    throw new Error(`Failed to read config file: ${error}`)
-  }
-}
-
-/**
- * Write config file
- */
-export function writeConfig (config: SealosConfig): void {
-  ensureConfigDir()
-
-  try {
-    writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8')
-  } catch (error) {
-    throw new Error(`Failed to write config file: ${error}`)
-  }
-}
-
-/**
- * Get current context
- */
-export function getCurrentContext (): Context | null {
-  const config = readConfig()
-  if (!config.currentContext) {
-    return null
-  }
-
-  const context = config.contexts.find(ctx => ctx.name === config.currentContext)
-  return context || null
-}
-
-/**
- * Set current context
- */
-export function setCurrentContext (name: string): void {
-  const config = readConfig()
-  const context = config.contexts.find(ctx => ctx.name === name)
-
-  if (!context) {
-    throw new Error(`Context "${name}" not found`)
-  }
-
-  config.currentContext = name
-  writeConfig(config)
-}
-
-/**
- * Add or update context
- */
-export function upsertContext (context: Context): void {
-  const config = readConfig()
-  const existingIndex = config.contexts.findIndex(ctx => ctx.name === context.name)
-
-  if (existingIndex >= 0) {
-    config.contexts[existingIndex] = context
-  } else {
-    config.contexts.push(context)
-  }
-
-  // If this is the first context, set it as current automatically
-  if (!config.currentContext) {
-    config.currentContext = context.name
-  }
-
-  writeConfig(config)
-}
-
-/**
- * Remove context
- */
-export function removeContext (name: string): void {
-  const config = readConfig()
-  config.contexts = config.contexts.filter(ctx => ctx.name !== name)
-
-  // If removing current context, clear currentContext
-  if (config.currentContext === name) {
-    config.currentContext = config.contexts[0]?.name || ''
-  }
-
-  writeConfig(config)
-}
-
-/**
- * Get config value
- */
-export function getConfigValue (key: string): string | undefined {
-  const config = readConfig()
-  // TODO: Implement nested key access, e.g. "contexts.0.name"
-  return (config as unknown as Record<string, unknown>)[key] as string | undefined
-}
-
-/**
- * Set config value
- */
-export function setConfigValue (key: string, value: string): void {
-  const config = readConfig()
-  // TODO: Implement nested key setting
-  ;(config as unknown as Record<string, unknown>)[key] = value
-  writeConfig(config)
-}