buildx-cli 1.0.0

package/eslint.config.mjs

@@ -0,0 +1,119 @@
+import globals from "globals";
+import typescriptEslint from "@typescript-eslint/eslint-plugin";
+import tsParser from "@typescript-eslint/parser";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+    baseDirectory: __dirname,
+    recommendedConfig: js.configs.recommended,
+    allConfig: js.configs.all
+});
+
+export default [
+    {
+        ignores: ["build/**", "dist/**", "node_modules/**", "scripts/**", "rules/**", "docs/**"], // Excludes all files and subdirectories in `dest`
+    },
+    ...compat.extends(
+        "eslint:recommended",
+        "plugin:vitest-globals/recommended",
+        "plugin:@typescript-eslint/recommended",
+        "plugin:import/recommended",
+        "plugin:import/typescript"
+    ),
+    {
+        plugins: {
+            "@typescript-eslint": typescriptEslint,
+        },
+        languageOptions: {
+            parser: tsParser,
+            ecmaVersion: 2020,
+            sourceType: "module",
+            globals: {
+                ...globals.node,
+                vitest: "readonly",
+            },
+            parserOptions: {
+                "ecmaVersion": 2020,
+                "sourceType": "module",
+                "project": "./tsconfig.json"
+            },
+        },
+        files: ["**/*.ts"],
+        rules: {
+
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-unused-vars": ["warn", {
+                argsIgnorePattern: "^_",
+                varsIgnorePattern: "^_",
+                caughtErrors: "none",
+            }],
+            indent: ["error", "tab", {
+                SwitchCase: 1,
+            }],
+
+            "import/no-unresolved": "error",
+            "import/named": "error",
+            "import/default": "error",
+            "import/namespace": "error",
+
+            "no-tabs": 0,
+            quotes: ["error", "double"],
+            "max-len": 0,
+            semi: "error",
+            "no-debugger": "warn",
+            "object-curly-spacing": ["error", "always"],
+
+            "comma-spacing": ["error", {
+                before: false,
+                after: true,
+            }],
+
+            "no-multiple-empty-lines": "error",
+            "no-implicit-any": "off",
+            "prefer-const": "off",
+            "no-undef": "error",
+
+            // No console.log
+            "no-console": "warn",
+
+        },
+        "settings": {
+            "import/resolver": {
+                "typescript": {
+                    "alwaysTryTypes": true,
+                    "project": "./tsconfig.json"
+                }
+            }
+        }
+    },
+    {
+        files: ["**/*.cjs"],
+        languageOptions: {
+            ecmaVersion: 2020,
+            sourceType: "script", // CommonJS files are treated as scripts
+            globals: {
+                require: "readonly",
+                module: "readonly",
+                exports: "readonly",
+                process: "readonly",
+                __dirname: "readonly",
+            },
+        },
+        rules: {
+            "@typescript-eslint/no-require-imports": "off",
+            // "no-undef": "off"
+        }
+    },
+    {
+        files: ["eslint.config.mjs"],
+        rules: {
+            "import/no-unresolved": "off"
+        }
+    }
+];

package/jest.config.js

@@ -0,0 +1,16 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  testMatch: ['**/__tests__/**/*.ts', '**/?(*.)+(spec|test).ts'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest',
+  },
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/__tests__/**',
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: ['text', 'lcov', 'html'],
+}; 

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "buildx-cli",
+  "version": "1.0.0",
+  "description": "CLI tool for BuildX API with authentication and schema synchronization",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "buildx": "dist/index.js"
+  },
+  "scripts": {
+    "clean": "rimraf build",
+    "build": "yarn clean && rollup -c",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts",
+    "format": "prettier --write src/**/*.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "api",
+    "buildx",
+    "typescript",
+    "schema"
+  ],
+  "author": "BuildX Team",
+  "license": "MIT",
+  "dependencies": {
+    "@rollup/plugin-json": "^6.1.0",
+    "axios": "^1.10.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "conf": "^14.0.0",
+    "fs-extra": "^11.1.1",
+    "inquirer": "^9.2.12",
+    "ora": "^7.0.1"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/jest": "^29.5.6",
+    "@types/node": "^20.8.0",
+    "@typescript-eslint/eslint-plugin": "^8.14.0",
+    "@typescript-eslint/parser": "^8.14.0",
+    "@typescript-eslint/rule-tester": "^8.19.1",
+    "concurrently": "^9.1.2",
+    "esbuild": "^0.25.5",
+    "eslint": "^9.29.0",
+    "eslint-import-resolver-typescript": "^3.7.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-vitest-globals": "^1.5.0",
+    "jest": "^29.7.0",
+    "madge": "^8.0.0",
+    "prettier": "^3.0.3",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.44.0",
+    "rollup-plugin-dts": "^6.2.1",
+    "rollup-plugin-esbuild": "^6.2.1",
+    "tsx": "^4.20.3",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/rollup.config.mjs

@@ -0,0 +1,64 @@
+import esbuild from 'rollup-plugin-esbuild';
+import dts from 'rollup-plugin-dts';
+import { nodeResolve } from '@rollup/plugin-node-resolve';
+import commonjs from '@rollup/plugin-commonjs';
+import terser from '@rollup/plugin-terser';
+import json from '@rollup/plugin-json';
+
+const useTerser = true;
+
+const external = []
+
+const plugins = [
+	nodeResolve({
+		preferBuiltins: true,
+		exportConditions: ['node']
+	}),
+	commonjs({
+		ignoreDynamicRequires: true
+	}),
+	esbuild({
+		target: 'node16',
+		platform: 'node'
+	}),
+	json()
+];
+
+if (useTerser) {
+	plugins.push(terser(
+		{
+			mangle: false,        // Keep variable names
+			module: true,         // Tells terser you're using ES modules
+			keep_classnames: true,
+			keep_fnames: true,
+		}
+	))
+}
+
+export default [
+	{
+		input: 'src/index.ts',
+		output: [{
+			dir: 'dist',
+			format: 'esm',
+			entryFileNames: 'index.js',
+			exports: 'named',
+		},
+		{
+			dir: 'dist',
+			format: 'cjs',
+			entryFileNames: 'index.cjs',
+			exports: 'named',
+		}],
+		external,
+		plugins
+	},
+	{
+		input: 'src/index.ts',
+		output: [{
+			dir: 'dist',
+			format: 'esm',
+			entryFileNames: 'index.d.ts',
+		}],
+		plugins: [dts()]
+	}]

package/src/__tests__/config.test.ts

@@ -0,0 +1,102 @@
+import { ConfigManager } from '../config';
+
+describe('ConfigManager', () => {
+  let configManager: ConfigManager;
+
+  beforeEach(() => {
+    configManager = new ConfigManager();
+    configManager.clear();
+  });
+
+  afterEach(() => {
+    configManager.clear();
+  });
+
+  describe('Authentication', () => {
+    it('should store and retrieve auth token', () => {
+      const auth = {
+        token: 'test-token',
+        expiresAt: new Date().toISOString()
+      };
+
+      configManager.setAuth(auth);
+      const retrieved = configManager.getAuth();
+
+      expect(retrieved).toEqual(auth);
+    });
+
+    it('should clear auth token', () => {
+      const auth = {
+        token: 'test-token',
+        expiresAt: new Date().toISOString()
+      };
+
+      configManager.setAuth(auth);
+      configManager.clearAuth();
+
+      expect(configManager.getAuth()).toBeUndefined();
+    });
+
+    it('should check if authenticated', () => {
+      expect(configManager.isAuthenticated()).toBe(false);
+
+      const auth = {
+        token: 'test-token',
+        expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString() // 1 day from now
+      };
+
+      configManager.setAuth(auth);
+      expect(configManager.isAuthenticated()).toBe(true);
+    });
+
+    it('should handle expired token', () => {
+      const auth = {
+        token: 'test-token',
+        expiresAt: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString() // 1 day ago
+      };
+
+      configManager.setAuth(auth);
+      expect(configManager.isAuthenticated()).toBe(false);
+    });
+  });
+
+  describe('Projects', () => {
+    it('should store and retrieve projects', () => {
+      const projects = {
+        default: 'project-1',
+        list: [
+          { id: 'project-1', name: 'Project 1' },
+          { id: 'project-2', name: 'Project 2' }
+        ]
+      };
+
+      configManager.setProjects(projects);
+      const retrieved = configManager.getProjects();
+
+      expect(retrieved).toEqual(projects);
+    });
+
+    it('should set default project', () => {
+      const projects = {
+        list: [
+          { id: 'project-1', name: 'Project 1' },
+          { id: 'project-2', name: 'Project 2' }
+        ]
+      };
+
+      configManager.setProjects(projects);
+      configManager.setDefaultProject('project-2');
+
+      const updated = configManager.getProjects();
+      expect(updated?.default).toBe('project-2');
+    });
+
+    it('should add project', () => {
+      const project = { id: 'project-1', name: 'Project 1' };
+      configManager.addProject(project);
+
+      const retrieved = configManager.getProject('project-1');
+      expect(retrieved).toEqual(project);
+    });
+  });
+}); 

package/src/commands/auth/login.ts

@@ -0,0 +1,148 @@
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import { configManager } from '../../config/index';
+import { apiService } from '../../services/api';
+import { LoginOptions } from '../../types/index';
+
+export const loginCommand = new Command('login')
+  .description('Authenticate with BuildX API')
+  .option('-t, --token <token>', 'API token for authentication')
+  .option('-u, --username <username>', 'Username for authentication')
+  .option('-p, --password <password>', 'Password for authentication')
+  .option('-i, --interactive', 'Interactive login mode')
+  .action(async (options: LoginOptions) => {
+    try {
+      // Check if API is configured
+      if (!apiService.isConfigured()) {
+        console.error(chalk.red('❌ API not configured'));
+        console.log(chalk.yellow('Please configure your API endpoint and API key first:'));
+        console.log(chalk.cyan('  buildx config setup'));
+        process.exit(1);
+      }
+
+      let token = options.token;
+      let username = options.username;
+      let password = options.password;
+
+      // If no credentials provided, prompt for them
+      if (!token && !username && !password) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'authMethod',
+            message: 'Choose authentication method:',
+            choices: [
+              { name: 'Username & Password', value: 'credentials' },
+              { name: 'API Token', value: 'token' }
+            ]
+          }
+        ]);
+
+        if (answers.authMethod === 'credentials') {
+          const credentialAnswers = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'username',
+              message: 'Enter your username:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Username is required';
+                }
+                return true;
+              }
+            },
+            {
+              type: 'password',
+              name: 'password',
+              message: 'Enter your password:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Password is required';
+                }
+                return true;
+              }
+            }
+          ]);
+          username = credentialAnswers.username;
+          password = credentialAnswers.password;
+        } else {
+          const tokenAnswer = await inquirer.prompt([
+            {
+              type: 'password',
+              name: 'token',
+              message: 'Enter your API token:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Token is required';
+                }
+                return true;
+              }
+            }
+          ]);
+          token = tokenAnswer.token;
+        }
+      }
+
+      const spinner = ora('Authenticating...').start();
+
+      try {
+        // Only support username/password authentication
+        if (!username || !password) {
+          const credentialAnswers = await inquirer.prompt([
+            {
+              type: 'input',
+              name: 'username',
+              message: 'Enter your username:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Username is required';
+                }
+                return true;
+              }
+            },
+            {
+              type: 'password',
+              name: 'password',
+              message: 'Enter your password:',
+              validate: (input: string) => {
+                if (!input || input.trim().length === 0) {
+                  return 'Password is required';
+                }
+                return true;
+              }
+            }
+          ]);
+          username = credentialAnswers.username;
+          password = credentialAnswers.password;
+        }
+
+        // Username/password authentication only
+        const loginResponse = await apiService.login({ username, password });
+        let authToken = loginResponse.token;
+        let expiresAt = loginResponse.expiresAt;
+        username = username ?? '';
+        authToken = authToken ?? '';
+        expiresAt = expiresAt ?? new Date(Date.now() + 30 * 24 * 60 * 60 * 1000).toISOString();
+        configManager.setAuth({
+          token: authToken,
+          expiresAt: expiresAt,
+          username: username
+        });
+
+        spinner.succeed('Successfully authenticated!');
+        console.log(chalk.green('✓ Authentication stored securely'));
+        console.log(chalk.blue('You can now use other BuildX CLI commands'));
+
+      } catch (error) {
+        spinner.fail('Authentication failed');
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+        process.exit(1);
+      }
+
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }); 

package/src/commands/auth/logout.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+
+export const logoutCommand = new Command('logout')
+  .description('Logout and clear stored authentication')
+  .action(() => {
+    try {
+      configManager.clearAuth();
+      console.log(chalk.green('✓ Successfully logged out'));
+      console.log(chalk.blue('Authentication token has been cleared'));
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }); 

package/src/commands/auth/status.ts

@@ -0,0 +1,52 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+import { apiService } from '../../services/api';
+import ora from 'ora';
+
+export const authStatusCommand = new Command('auth:status')
+  .description('Check authentication status')
+  .action(async () => {
+    try {
+      // Check API configuration
+      if (!apiService.isConfigured()) {
+        console.error(chalk.red('❌ API not configured'));
+        console.log(chalk.yellow('Please configure your API endpoint and API key first:'));
+        console.log(chalk.cyan('  buildx config setup'));
+        process.exit(1);
+      }
+      const isAuthenticated = configManager.isAuthenticated();
+      const auth = configManager.getAuth();
+
+      if (isAuthenticated && auth) {
+        const spinner = ora('Validating session...').start();
+        try {
+          // Call /auth/me endpoint
+          const me = await apiService.getMe();
+          spinner.succeed('Authenticated');
+          console.log(chalk.green('✓ Authenticated'));
+          console.log(chalk.blue('Username:'), me.username);
+          if (auth.token) {
+            console.log(chalk.blue('Token:'), auth.token.substring(0, 8) + '...');
+          }
+          if (auth.expiresAt) {
+            console.log(chalk.blue('Expires:'), new Date(auth.expiresAt).toLocaleString());
+          }
+          // console.log(chalk.gray('Raw response:'), JSON.stringify(me, null, 2));
+          if (me.username) {
+            console.log(chalk.blue(`You are authenticated as ${me.source}:${me.username}`));
+          }
+        } catch (error) {
+          spinner.fail('Session invalid');
+          console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+          process.exit(1);
+        }
+      } else {
+        console.log(chalk.red('✗ Not authenticated'));
+        console.log(chalk.yellow('Run "buildx login" to authenticate'));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error:'), error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }); 

package/src/commands/config/clear.ts

@@ -0,0 +1,16 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../config/index';
+
+export const configClearCommand = new Command('clear')
+	.description('Clear all CLI configuration (API, auth, projects, sync)')
+	.action(() => {
+		try {
+			configManager.clear();
+			console.log(chalk.green('✅ All configuration cleared.'));
+			console.log(chalk.yellow('You must run "buildx config setup" before using the CLI again.'));
+		} catch (error) {
+			console.error(chalk.red('❌ Failed to clear configuration:'), error instanceof Error ? error.message : 'Unknown error');
+			process.exit(1);
+		}
+	}); 

package/src/commands/config/index.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import { setupCommand } from './setup';
+import { configShowCommand } from './show';
+import { configClearCommand } from './clear';
+
+export const configCommand = new Command('config')
+	.description('Manage CLI configuration')
+	.addCommand(setupCommand)
+	.addCommand(configShowCommand)
+	.addCommand(configClearCommand);