sealos-cli 0.1.0 → 1.1.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'
 
@@ -14,7 +15,7 @@ function resolveHost (options?: { baseUrl?: string }): string {
 
   const host = options?.baseUrl || process.env.SEALOS_REGION || authRegion || DEFAULT_SEALOS_REGION
   if (!host) {
-    throw new ConfigError('No Sealos Cloud host configured. Run "sealos login <host>" first.')
+    throw new ConfigError('No Sealos Cloud host configured. Run "sealos-cli login <host>" first.')
   }
   return host.replace(/\/+$/, '')
 }
@@ -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

@@ -141,13 +141,13 @@ export function saveAuth (auth: SealosAuthData, deps: AuthDependencies = {}): vo
 export function loadAuth (deps: AuthDependencies = {}): SealosAuthData {
   const { paths } = withDeps(deps)
   if (!existsSync(paths.authPath)) {
-    throw new Error('Not authenticated. Please run: sealos login')
+    throw new Error('Not authenticated. Please run: sealos-cli login')
   }
 
   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,15 +155,24 @@ 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 } {
   const headers = getAuthHeaders(deps)
   if (!headers) {
-    throw new Error('Authentication required. Please run "sealos login" first.')
+    throw new Error('Authentication required. Please run "sealos-cli login" first.')
   }
   return headers
 }
@@ -487,7 +496,7 @@ export async function loginWithDeviceFlow (region?: string, deps: AuthDependenci
 export async function listWorkspaces (deps: AuthDependencies = {}): Promise<WorkspaceListResult> {
   const auth = loadAuth(deps)
   if (!auth.regional_token) {
-    throw new Error('No regional_token found. Please run: sealos login')
+    throw new Error('No regional_token found. Please run: sealos-cli login')
   }
 
   const workspaces = await listRemoteWorkspaces(auth.region, auth.regional_token, deps)
@@ -505,13 +514,13 @@ export async function listWorkspaces (deps: AuthDependencies = {}): Promise<Work
 
 export async function switchWorkspace (target: string, deps: AuthDependencies = {}): Promise<SwitchWorkspaceResult> {
   if (!target) {
-    throw new Error('Usage: sealos auth switch <namespace-id-or-uid>')
+    throw new Error('Usage: sealos-cli auth switch <namespace-id-or-uid>')
   }
 
   const fullDeps = withDeps(deps)
   const auth = loadAuth(fullDeps)
   if (!auth.regional_token) {
-    throw new Error('No regional_token found. Please run: sealos login')
+    throw new Error('No regional_token found. Please run: sealos-cli login')
   }
 
   const workspaces = await listRemoteWorkspaces(auth.region, auth.regional_token, fullDeps)

package/src/lib/errors.ts

@@ -14,7 +14,7 @@ export class CliError extends Error {
  * Authentication error
  */
 export class AuthError extends CliError {
-  constructor (message: string = 'Authentication required. Please run "sealos login" first.') {
+  constructor (message: string = 'Authentication required. Please run "sealos-cli login" first.') {
     super(message, 1)
     this.name = 'AuthError'
   }

package/src/lib/output.ts

@@ -10,12 +10,11 @@ export function outputJson (data: any): void {
 }
 
 /**
- * Output YAML format
+ * Output YAML format.
+ * Generic YAML output is not part of the v1 command surface.
  */
-export function outputYaml (data: any): void {
-  // TODO: Use yaml library to implement
-  console.log('YAML output not implemented yet')
-  console.log(data)
+export function outputYaml (_data: any): never {
+  throw new Error('YAML output is not supported in the v1 release. Use json or table output.')
 }
 
 /**
@@ -87,7 +86,7 @@ export function spinner (text: string): Ora {
  * Confirmation prompt
  */
 export async function confirm (message: string): Promise<boolean> {
-  // TODO: Use inquirer or other interactive library
+  // Non-interactive default for v1. Replace with a prompt implementation when needed.
   console.log(chalk.yellow('?'), message)
   return true
 }

package/src/main.ts

@@ -3,32 +3,25 @@ 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'
+import packageJson from '../package.json' with { type: 'json' }
 
 export function createProgram (): Command {
   const program = new Command()
 
   program
-    .name('sealos')
-    .description('Official CLI tool for Sealos Cloud - Manage devbox, applications, databases, and object storage')
-    .version('0.0.1')
+    .name('sealos-cli')
+    .description('Official CLI tool for Sealos Cloud - Manage devbox, databases, templates, auth, and workspaces')
+    .version(packageJson.version)
 
   // 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)
-}