xuanwu-cli 1.0.0

package/dist/commands/deploy.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * 部署命令
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeployCommand = makeDeployCommand;
+const commander_1 = require("commander");
+const store_1 = require("../config/store");
+const client_1 = require("../api/client");
+const formatter_1 = require("../output/formatter");
+function makeDeployCommand() {
+    const cmd = new commander_1.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 = {}) => {
+        const [key, value] = val.split('=');
+        memo[key] = value;
+        return memo;
+    }, {})
+        .action(async (namespace, serviceName, options) => {
+        const conn = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const type = options.type;
+        const 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 = (0, client_1.createClient)(conn);
+        const result = await client.deploy(deployOptions);
+        if (!result.success) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        formatter_1.OutputFormatter.success(`Service "${serviceName}" deployed to ${namespace}`);
+    });
+    return cmd;
+}

package/dist/commands/env.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 环境管理命令
+ */
+import { Command } from 'commander';
+export declare function makeEnvCommand(): Command;

package/dist/commands/env.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * 环境管理命令
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEnvCommand = makeEnvCommand;
+const commander_1 = require("commander");
+const store_1 = require("../config/store");
+const client_1 = require("../api/client");
+const formatter_1 = require("../output/formatter");
+function makeEnvCommand() {
+    const cmd = new commander_1.Command('env')
+        .description('Manage environments (K8s namespaces)');
+    cmd
+        .command('ls')
+        .description('List accessible environments')
+        .action(async () => {
+        const conn = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured. Run: xuanwu connect add <name> -e <endpoint> -t <token>');
+            return;
+        }
+        const client = (0, client_1.createClient)(conn);
+        const result = await client.listNamespaces();
+        if (!result.success) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        const spaces = result.data || [];
+        if (spaces.length === 0) {
+            formatter_1.OutputFormatter.info('No environments found');
+            return;
+        }
+        formatter_1.OutputFormatter.table(['Name', 'Identifier', 'Environment', 'Status'], spaces.map((s) => [
+            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 = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const client = (0, client_1.createClient)(conn);
+        let projectId = options.projectId;
+        // 如果没有指定 project-id，尝试获取第一个项目
+        if (!projectId) {
+            const projectsResult = await client.getProjects();
+            if (!projectsResult.success || !projectsResult.data || projectsResult.data.length === 0) {
+                formatter_1.OutputFormatter.error('No projects found. Please specify --project-id');
+                return;
+            }
+            projectId = projectsResult.data[0].id;
+            formatter_1.OutputFormatter.info(`Using project: ${projectsResult.data[0].name}`);
+        }
+        const result = await client.createNamespaceWithProject(namespace, projectId, options.environment);
+        if (!result.success) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        formatter_1.OutputFormatter.success(`Environment "${namespace}" created`);
+    });
+    cmd
+        .command('rm <namespace>')
+        .description('Delete an environment')
+        .action(async (namespace) => {
+        const conn = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const client = (0, client_1.createClient)(conn);
+        // 先获取 namespace ID
+        const infoResult = await client.getNamespaceInfo(namespace);
+        if (!infoResult.success || !infoResult.data) {
+            formatter_1.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) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        formatter_1.OutputFormatter.success(`Environment "${namespace}" deleted`);
+    });
+    cmd
+        .command('info <namespace>')
+        .description('Show environment details')
+        .action(async (namespace) => {
+        const conn = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const client = (0, client_1.createClient)(conn);
+        const result = await client.getNamespaceInfo(namespace);
+        if (!result.success) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        const info = result.data;
+        formatter_1.OutputFormatter.info(`Name: ${info.name}`);
+        formatter_1.OutputFormatter.info(`Identifier: ${info.identifier}`);
+        formatter_1.OutputFormatter.info(`Namespace: ${info.namespace}`);
+        formatter_1.OutputFormatter.info(`Environment: ${info.environment}`);
+        formatter_1.OutputFormatter.info(`Status: ${info.status}`);
+    });
+    return cmd;
+}

package/dist/commands/logs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 日志命令
+ */
+import { Command } from 'commander';
+export declare function makeLogsCommand(): Command;

package/dist/commands/logs.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * 日志命令
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLogsCommand = makeLogsCommand;
+const commander_1 = require("commander");
+const store_1 = require("../config/store");
+const client_1 = require("../api/client");
+const formatter_1 = require("../output/formatter");
+function makeLogsCommand() {
+    const cmd = new commander_1.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 = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const client = (0, client_1.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) {
+                formatter_1.OutputFormatter.error(result.error.message);
+                return;
+            }
+            console.log(result.data?.logs || result.data || '');
+        }
+    });
+    return cmd;
+}

package/dist/commands/pods.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Pods 命令
+ */
+import { Command } from 'commander';
+export declare function makePodsCommand(): Command;

package/dist/commands/pods.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Pods 命令
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePodsCommand = makePodsCommand;
+const commander_1 = require("commander");
+const store_1 = require("../config/store");
+const client_1 = require("../api/client");
+const formatter_1 = require("../output/formatter");
+function getAge(timestamp) {
+    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`;
+}
+function makePodsCommand() {
+    const cmd = new commander_1.Command('pods')
+        .description('List pods')
+        .argument('<namespace>', 'Target namespace')
+        .argument('<service-name>', 'Service name')
+        .action(async (namespace, serviceName) => {
+        const conn = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const client = (0, client_1.createClient)(conn);
+        const result = await client.listPods(namespace, serviceName);
+        if (!result.success) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        const pods = Array.isArray(result.data) ? result.data : (result.data?.items || []);
+        if (pods.length === 0) {
+            formatter_1.OutputFormatter.info('No pods found');
+            return;
+        }
+        formatter_1.OutputFormatter.table(['Name', 'Status', 'Ready', 'Restarts', 'Age'], pods.map((p) => [
+            p.metadata?.name || 'unknown',
+            p.status?.phase || 'Unknown',
+            `${p.status?.containerStatuses?.filter((c) => c.ready).length || 0}/${p.spec?.containers?.length || 0}`,
+            p.status?.containerStatuses?.[0]?.restartCount?.toString() || '0',
+            getAge(p.metadata?.creationTimestamp)
+        ]));
+    });
+    return cmd;
+}

package/dist/commands/scale.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 扩缩容命令
+ */
+import { Command } from 'commander';
+export declare function makeScaleCommand(): Command;

package/dist/commands/scale.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * 扩缩容命令
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeScaleCommand = makeScaleCommand;
+const commander_1 = require("commander");
+const store_1 = require("../config/store");
+const client_1 = require("../api/client");
+const formatter_1 = require("../output/formatter");
+function makeScaleCommand() {
+    const cmd = new commander_1.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 = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const client = (0, client_1.createClient)(conn);
+        const result = await client.scale(namespace, serviceName, parseInt(options.replicas));
+        if (!result.success) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        formatter_1.OutputFormatter.success(`Scaled to ${options.replicas} replicas`);
+    });
+    return cmd;
+}

package/dist/commands/svc.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 服务管理命令
+ */
+import { Command } from 'commander';
+export declare function makeSvcCommand(): Command;

package/dist/commands/svc.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * 服务管理命令
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSvcCommand = makeSvcCommand;
+const commander_1 = require("commander");
+const store_1 = require("../config/store");
+const client_1 = require("../api/client");
+const formatter_1 = require("../output/formatter");
+function getAge(timestamp) {
+    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`;
+}
+function makeSvcCommand() {
+    const cmd = new commander_1.Command('svc')
+        .description('Manage services');
+    cmd
+        .command('ls <namespace>')
+        .description('List services in namespace')
+        .action(async (namespace) => {
+        const conn = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const client = (0, client_1.createClient)(conn);
+        const result = await client.listServices(namespace);
+        if (!result.success) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        const services = result.data || [];
+        if (services.length === 0) {
+            formatter_1.OutputFormatter.info(`No services in ${namespace}`);
+            return;
+        }
+        formatter_1.OutputFormatter.table(['Name', 'Ready', 'Up-to-date', 'Available', 'Age'], services.map((s) => [
+            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 = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const client = (0, client_1.createClient)(conn);
+        const result = await client.getServiceStatus(namespace, serviceName);
+        if (!result.success) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        const info = result.data;
+        formatter_1.OutputFormatter.info(`Service: ${info.name}`);
+        formatter_1.OutputFormatter.info(`Namespace: ${info.namespace}`);
+        formatter_1.OutputFormatter.info(`Replicas: ${info.replicas}`);
+        formatter_1.OutputFormatter.info(`Ready Replicas: ${info.readyReplicas}`);
+        formatter_1.OutputFormatter.info(`Available Replicas: ${info.availableReplicas}`);
+        formatter_1.OutputFormatter.info(`Image: ${info.image}`);
+        if (info.labels) {
+            formatter_1.OutputFormatter.info(`Labels: ${JSON.stringify(info.labels)}`);
+        }
+    });
+    cmd
+        .command('rm <namespace> <service-name>')
+        .description('Delete a service')
+        .action(async (namespace, serviceName) => {
+        const conn = store_1.configStore.getDefaultConnection();
+        if (!conn) {
+            formatter_1.OutputFormatter.error('No connection configured');
+            return;
+        }
+        const client = (0, client_1.createClient)(conn);
+        const result = await client.deleteService(namespace, serviceName);
+        if (!result.success) {
+            formatter_1.OutputFormatter.error(result.error.message);
+            return;
+        }
+        formatter_1.OutputFormatter.success(`Service "${serviceName}" deleted`);
+    });
+    return cmd;
+}

package/dist/config/store.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 配置存储
+ */
+import { Config, Connection } from './types';
+export declare class ConfigStore {
+    private config;
+    constructor();
+    private load;
+    private save;
+    getConnections(): Connection[];
+    getConnection(name: string): Connection | undefined;
+    getDefaultConnection(): Connection | undefined;
+    addConnection(connection: Connection): void;
+    removeConnection(name: string): void;
+    setDefaultConnection(name: string): void;
+    getConfig(): Config;
+}
+export declare const configStore: ConfigStore;

package/dist/config/store.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * 配置存储
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configStore = exports.ConfigStore = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = path.join(os.homedir(), '.xuanwu');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_CONFIG = {
+    version: '1.0',
+    connections: []
+};
+class ConfigStore {
+    constructor() {
+        this.config = this.load();
+    }
+    load() {
+        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 };
+    }
+    save() {
+        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() {
+        return this.config.connections;
+    }
+    getConnection(name) {
+        return this.config.connections.find(c => c.name === name);
+    }
+    getDefaultConnection() {
+        return this.config.connections.find(c => c.isDefault);
+    }
+    addConnection(connection) {
+        // 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) {
+        this.config.connections = this.config.connections.filter(c => c.name !== name);
+        this.save();
+    }
+    setDefaultConnection(name) {
+        this.config.connections = this.config.connections.map(c => ({
+            ...c,
+            isDefault: c.name === name
+        }));
+        this.save();
+    }
+    getConfig() {
+        return this.config;
+    }
+}
+exports.ConfigStore = ConfigStore;
+exports.configStore = new ConfigStore();

package/dist/config/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * 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;
+    git?: string;
+    gitBranch?: string;
+    buildType?: 'template' | 'dockerfile';
+    language?: string;
+    dockerfilePath?: string;
+    dbType?: 'mysql' | 'redis' | 'postgres' | 'elasticsearch';
+    dbVersion?: string;
+    rootPassword?: string;
+    password?: string;
+    user?: string;
+    database?: string;
+    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;
+    };
+}