@ultikits/cli 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## 1.0.0 (2026-02-14)
+
+Initial release.
+
+### Features
+
+- **Authentication**: Browser-based magic link login and developer access token support
+- **CI/CD**: `ULTIKITS_TOKEN` environment variable for automated pipelines
+- **Publishing**: `ultikits publish` with automatic JAR detection and `plugin.yml` metadata extraction
+- **Project config**: `ultikits init` creates `ultikits.json` for persistent module metadata
+- **Module management**: List, inspect, and delete modules via `ultikits modules`
+- **Version management**: List and delete versions via `ultikits versions`

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 UltiKits
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+# @ultikits/cli
+
+Command-line tool for publishing [UltiTools](https://github.com/UltiKits/UltiTools-Reborn) plugin modules to [UltiCloud](https://panel.ultikits.com) marketplace.
+
+## Installation
+
+```bash
+npm install -g @ultikits/cli
+```
+
+Requires Node.js 18 or later.
+
+## Quick Start
+
+```bash
+# 1. Log in to your UltiKits developer account
+ultikits login
+
+# 2. Initialize project config (optional, recommended)
+ultikits init
+
+# 3. Build your plugin and publish
+mvn clean package
+ultikits publish
+```
+
+## Authentication
+
+### Interactive login (browser)
+
+```bash
+ultikits login
+# Choose "Browser login (magic link)"
+# A browser window opens — approve the request
+```
+
+### Access token (developer portal)
+
+```bash
+ultikits login
+# Choose "Access token (from developer portal)"
+# Paste your access token from panel.ultikits.com/developer
+```
+
+### CI/CD (environment variable)
+
+Set the `ULTIKITS_TOKEN` environment variable with your developer access token. No `login` step is needed.
+
+```yaml
+# GitHub Actions example
+- name: Publish to UltiCloud
+  env:
+    ULTIKITS_TOKEN: ${{ secrets.ULTIKITS_TOKEN }}
+  run: ultikits publish --yes
+```
+
+Credentials are stored in `~/.ultikits/credentials.json`.
+
+## Commands
+
+### `ultikits login`
+
+Authenticate with UltiKits. Choose between browser-based magic link or pasting an access token.
+
+### `ultikits logout`
+
+Remove stored credentials.
+
+### `ultikits whoami`
+
+Check current authentication status.
+
+### `ultikits init`
+
+Create an `ultikits.json` project config in the current directory. Interactive prompts for module ID, name, description, and category.
+
+```json
+{
+  "identifyString": "my.awesome.plugin",
+  "name": "My Awesome Plugin",
+  "shortDescription": "A great UltiTools module",
+  "categoryId": 1
+}
+```
+
+### `ultikits publish [jar-path]`
+
+Publish a plugin module JAR to UltiCloud.
+
+If no JAR path is given, automatically finds the built JAR in `./target/` (skips `-sources.jar` and `-javadoc.jar`).
+
+**Options:**
+
+| Flag | Description |
+|------|-------------|
+| `--id <string>` | Module identify string |
+| `--name <string>` | Module display name |
+| `--version <string>` | Module version |
+| `--changelog <text>` | Version changelog |
+| `--short-description <text>` | Short description |
+| `-y, --yes` | Skip confirmation prompts |
+
+**Metadata resolution priority:** CLI flags > `ultikits.json` > `plugin.yml` from JAR.
+
+**Example:**
+
+```bash
+# Auto-detect JAR and metadata from plugin.yml + ultikits.json
+ultikits publish
+
+# Explicit JAR path with overrides
+ultikits publish target/MyPlugin-1.0.0.jar --version 1.0.1 --changelog "Bug fix"
+
+# CI/CD mode (no prompts)
+ultikits publish --yes
+```
+
+### `ultikits modules list`
+
+List all your published modules.
+
+### `ultikits modules info <identifyString>`
+
+Show details of a specific module.
+
+### `ultikits modules delete <identifyString>`
+
+Delete a module (with confirmation prompt).
+
+### `ultikits versions list <identifyString>`
+
+List all versions of a module.
+
+### `ultikits versions delete <identifyString> <version>`
+
+Delete a specific version (with confirmation prompt).
+
+## Project Config (`ultikits.json`)
+
+Create with `ultikits init` or manually. Fields are used as fallback metadata during `publish`:
+
+```json
+{
+  "identifyString": "com.example.myplugin",
+  "name": "My Plugin",
+  "shortDescription": "Does amazing things",
+  "categoryId": 1
+}
+```
+
+**Categories:**
+
+| ID | Name |
+|----|------|
+| 1 | Utilities |
+| 2 | Economy |
+| 3 | World Management |
+| 4 | Social & Chat |
+| 5 | Permissions & Security |
+| 6 | Gameplay |
+
+## Development
+
+```bash
+git clone https://github.com/UltiKits/ultikits-cli.git
+cd ultikits-cli
+npm install
+npm run build
+npm test
+```
+
+## License
+
+[MIT](LICENSE)

package/dist/bin/ultikits.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/ultikits.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerLoginCommand } from '../src/commands/login.js';
+import { registerLogoutCommand } from '../src/commands/logout.js';
+import { registerWhoamiCommand } from '../src/commands/whoami.js';
+import { registerInitCommand } from '../src/commands/init.js';
+import { registerPublishCommand } from '../src/commands/publish.js';
+import { registerModulesCommand } from '../src/commands/modules.js';
+import { registerVersionsCommand } from '../src/commands/versions.js';
+const program = new Command();
+program
+    .name('ultikits')
+    .description('CLI for publishing UltiTools plugin modules to UltiCloud')
+    .version('1.0.0');
+registerLoginCommand(program);
+registerLogoutCommand(program);
+registerWhoamiCommand(program);
+registerInitCommand(program);
+registerPublishCommand(program);
+registerModulesCommand(program);
+registerVersionsCommand(program);
+program.parse();
+//# sourceMappingURL=ultikits.js.map

package/dist/src/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerInitCommand(program: Command): void;

package/dist/src/commands/init.js

@@ -0,0 +1,62 @@
+import inquirer from 'inquirer';
+import { readProjectConfig, writeProjectConfig } from '../lib/project-config.js';
+import * as log from '../lib/logger.js';
+const CATEGORIES = [
+    { name: 'Utilities', value: 1 },
+    { name: 'Economy', value: 2 },
+    { name: 'World Management', value: 3 },
+    { name: 'Social & Chat', value: 4 },
+    { name: 'Permissions & Security', value: 5 },
+    { name: 'Gameplay', value: 6 },
+];
+export function registerInitCommand(program) {
+    program
+        .command('init')
+        .description('Create ultikits.json project config')
+        .action(async () => {
+        const existing = readProjectConfig();
+        if (existing) {
+            const { overwrite } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'overwrite',
+                    message: 'ultikits.json already exists. Overwrite?',
+                    default: false,
+                },
+            ]);
+            if (!overwrite)
+                return;
+        }
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'identifyString',
+                message: 'Module identify string (e.g., my.awesome.plugin):',
+                validate: (v) => /^[a-z][a-z0-9_.]{2,63}$/.test(v)
+                    ? true
+                    : 'Must be 3-64 chars, lowercase, start with letter, only a-z 0-9 . _',
+            },
+            {
+                type: 'input',
+                name: 'name',
+                message: 'Display name:',
+                validate: (v) => (v.trim().length > 0 ? true : 'Required'),
+            },
+            {
+                type: 'input',
+                name: 'shortDescription',
+                message: 'Short description (max 200 chars):',
+                validate: (v) => v.length <= 200 ? true : 'Must be 200 characters or fewer',
+            },
+            {
+                type: 'list',
+                name: 'categoryId',
+                message: 'Category:',
+                choices: CATEGORIES,
+            },
+        ]);
+        writeProjectConfig(answers);
+        log.success('Created ultikits.json');
+    });
+}
+//# sourceMappingURL=init.js.map

package/dist/src/commands/login.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLoginCommand(program: Command): void;

package/dist/src/commands/login.js

@@ -0,0 +1,120 @@
+import inquirer from 'inquirer';
+import open from 'open';
+import { writeCredentials } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import * as log from '../lib/logger.js';
+const POLL_INTERVAL_MS = 2000;
+const API_URL = 'https://api.ultikits.com';
+export function registerLoginCommand(program) {
+    program
+        .command('login')
+        .description('Authenticate with UltiKits')
+        .action(async () => {
+        const { method } = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'method',
+                message: 'How would you like to authenticate?',
+                choices: [
+                    { name: 'Browser login (magic link)', value: 'magic-link' },
+                    { name: 'Access token (from developer portal)', value: 'access-token' },
+                ],
+            },
+        ]);
+        if (method === 'magic-link') {
+            await loginWithMagicLink();
+        }
+        else {
+            await loginWithAccessToken();
+        }
+    });
+}
+async function loginWithMagicLink() {
+    const spin = log.spinner('Requesting authentication...');
+    spin.start();
+    try {
+        const response = await fetch(`${API_URL}/auth/cli/request`, { method: 'POST' });
+        const body = await response.json();
+        if (body.code !== '200') {
+            spin.fail('Failed to create auth request: ' + body.msg);
+            return;
+        }
+        const { requestId, code, url } = body.data;
+        spin.stop();
+        console.log();
+        log.info(`Opening browser to authenticate...`);
+        log.info(`If it doesn't open, visit: ${url}`);
+        console.log();
+        try {
+            await open(url);
+        }
+        catch {
+            // Browser didn't open — user has the URL
+        }
+        spin.text = 'Waiting for authentication...';
+        spin.start();
+        // Poll for completion
+        const deadline = Date.now() + 10 * 60 * 1000; // 10 minute timeout
+        while (Date.now() < deadline) {
+            await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+            const pollRes = await fetch(`${API_URL}/auth/cli/poll?requestId=${requestId}`);
+            const pollBody = await pollRes.json();
+            if (pollBody.data?.status === 'completed') {
+                writeCredentials({
+                    type: 'oauth',
+                    access_token: pollBody.data.access_token,
+                    refresh_token: pollBody.data.refresh_token,
+                    expires_at: new Date(Date.now() + 3600 * 1000).toISOString(),
+                    api_url: API_URL,
+                });
+                spin.succeed('Logged in successfully');
+                log.info('Credentials saved to ~/.ultikits/credentials.json');
+                return;
+            }
+            if (pollBody.data?.status === 'expired') {
+                spin.fail('Authentication request expired. Run `ultikits login` again.');
+                return;
+            }
+        }
+        spin.fail('Authentication timed out.');
+    }
+    catch (err) {
+        spin.fail('Login failed: ' + err.message);
+    }
+}
+async function loginWithAccessToken() {
+    const { token } = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'token',
+            message: 'Paste your access token:',
+            mask: '●',
+        },
+    ]);
+    const spin = log.spinner('Validating token...');
+    spin.start();
+    try {
+        // Validate by trying to list developer modules
+        const client = new ApiClient({
+            type: 'access_token',
+            token,
+            api_url: API_URL,
+        });
+        const res = await client.get('/developer/modules');
+        if (res.code !== '200') {
+            spin.fail('Invalid token. Get yours at panel.ultikits.com/developer');
+            return;
+        }
+        writeCredentials({
+            type: 'access_token',
+            token,
+            api_url: API_URL,
+        });
+        spin.succeed('Token verified — logged in');
+        log.info('Credentials saved to ~/.ultikits/credentials.json');
+    }
+    catch (err) {
+        spin.fail('Token validation failed: ' + err.message);
+    }
+}
+//# sourceMappingURL=login.js.map

package/dist/src/commands/logout.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerLogoutCommand(program: Command): void;

package/dist/src/commands/logout.js

@@ -0,0 +1,12 @@
+import { deleteCredentials } from '../lib/config.js';
+import * as log from '../lib/logger.js';
+export function registerLogoutCommand(program) {
+    program
+        .command('logout')
+        .description('Remove stored credentials')
+        .action(() => {
+        deleteCredentials();
+        log.success('Logged out. Credentials removed.');
+    });
+}
+//# sourceMappingURL=logout.js.map

package/dist/src/commands/modules.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerModulesCommand(program: Command): void;

package/dist/src/commands/modules.js

@@ -0,0 +1,92 @@
+import inquirer from 'inquirer';
+import { readCredentials } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import * as log from '../lib/logger.js';
+export function registerModulesCommand(program) {
+    const modules = program
+        .command('modules')
+        .description('Manage your marketplace modules');
+    modules
+        .command('list')
+        .description('List your modules')
+        .action(async () => {
+        const client = getClient();
+        const spin = log.spinner('Loading modules...');
+        spin.start();
+        const res = await client.get('/developer/modules');
+        if (res.code !== '200') {
+            spin.fail('Failed to list modules: ' + res.msg);
+            process.exit(1);
+        }
+        spin.stop();
+        const modulesList = res.data;
+        if (modulesList.length === 0) {
+            log.info('No modules found. Create one with `ultikits publish`.');
+            return;
+        }
+        console.log();
+        for (const mod of modulesList) {
+            const version = mod.latestVersion?.version ?? 'no versions';
+            console.log(`  ${mod.identifyString} — ${mod.name} (${version})`);
+        }
+        console.log();
+        log.info(`${modulesList.length} module(s)`);
+    });
+    modules
+        .command('info <identifyString>')
+        .description('Show module details')
+        .action(async (identifyString) => {
+        const client = getClient();
+        const res = await client.get(`/plugin/get?identifyString=${identifyString}`);
+        if (res.code !== '200' || !res.data) {
+            log.error('Module not found: ' + identifyString);
+            process.exit(1);
+        }
+        const mod = res.data;
+        console.log();
+        console.log(`  Name:        ${mod.name}`);
+        console.log(`  ID:          ${mod.identifyString}`);
+        console.log(`  Description: ${mod.shortDescription || 'N/A'}`);
+        console.log(`  Downloads:   ${mod.downloads ?? 0}`);
+        console.log(`  Version:     ${mod.latestVersion?.version ?? 'N/A'}`);
+        console.log();
+    });
+    modules
+        .command('delete <identifyString>')
+        .description('Delete a module')
+        .action(async (identifyString) => {
+        const client = getClient();
+        // Get module ID first
+        const infoRes = await client.get(`/plugin/get?identifyString=${identifyString}`);
+        if (infoRes.code !== '200' || !infoRes.data) {
+            log.error('Module not found: ' + identifyString);
+            process.exit(1);
+        }
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Delete module "${identifyString}"? This cannot be undone.`,
+                default: false,
+            },
+        ]);
+        if (!confirm)
+            return;
+        const res = await client.delete(`/developer/modules/${infoRes.data.id}`);
+        if (res.code !== '200') {
+            log.error('Failed to delete: ' + res.msg);
+            process.exit(1);
+        }
+        log.success(`Deleted module: ${identifyString}`);
+    });
+}
+function getClient() {
+    const credentials = readCredentials();
+    const client = ApiClient.fromEnvOrCredentials(credentials);
+    if (!client) {
+        log.error('Not logged in. Run `ultikits login` or set ULTIKITS_TOKEN.');
+        process.exit(1);
+    }
+    return client;
+}
+//# sourceMappingURL=modules.js.map

package/dist/src/commands/publish.d.ts

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+import type { ModuleMetadata, ProjectConfig, PluginYml } from '../types.js';
+interface PublishFlags {
+    id?: string;
+    name?: string;
+    version?: string;
+    changelog?: string;
+    shortDescription?: string;
+}
+export declare function resolveMetadata(flags: PublishFlags, projectConfig: ProjectConfig | null, pluginYml: PluginYml | null): ModuleMetadata;
+export declare function registerPublishCommand(program: Command): void;
+export {};

package/dist/src/commands/publish.js

@@ -0,0 +1,171 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import inquirer from 'inquirer';
+import { readCredentials } from '../lib/config.js';
+import { readProjectConfig } from '../lib/project-config.js';
+import { readPluginYml, findJarInTarget } from '../lib/jar-reader.js';
+import { ApiClient } from '../lib/api-client.js';
+import * as log from '../lib/logger.js';
+export function resolveMetadata(flags, projectConfig, pluginYml) {
+    const identifyString = flags.id ?? projectConfig?.identifyString;
+    const name = flags.name ?? projectConfig?.name ?? pluginYml?.name;
+    const version = flags.version ?? pluginYml?.version;
+    const shortDescription = flags.shortDescription ?? projectConfig?.shortDescription ?? pluginYml?.description;
+    const changelog = flags.changelog;
+    const categoryId = projectConfig?.categoryId;
+    const missing = [];
+    if (!identifyString)
+        missing.push('identifyString (use --id or ultikits.json)');
+    if (!name)
+        missing.push('name (use --name, ultikits.json, or plugin.yml)');
+    if (!version)
+        missing.push('version (use --version or plugin.yml in JAR)');
+    if (missing.length > 0) {
+        throw new Error('Missing required fields:\n  - ' + missing.join('\n  - '));
+    }
+    return {
+        identifyString: identifyString,
+        name: name,
+        version: version,
+        shortDescription,
+        changelog,
+        categoryId,
+    };
+}
+export function registerPublishCommand(program) {
+    program
+        .command('publish [jar-path]')
+        .description('Publish a plugin module to UltiCloud')
+        .option('--id <identifyString>', 'Module identify string')
+        .option('--name <name>', 'Module display name')
+        .option('--version <version>', 'Module version')
+        .option('--changelog <text>', 'Version changelog')
+        .option('--short-description <text>', 'Short description')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .action(async (jarPath, options) => {
+        // 1. Resolve auth
+        const credentials = readCredentials();
+        const client = ApiClient.fromEnvOrCredentials(credentials);
+        if (!client) {
+            log.error('Not logged in. Run `ultikits login` or set ULTIKITS_TOKEN.');
+            process.exit(1);
+        }
+        // 2. Resolve JAR path
+        const resolvedJarPath = jarPath ?? findJarInTarget();
+        if (!resolvedJarPath) {
+            log.error('No JAR file specified and none found in ./target/');
+            log.info('Usage: ultikits publish <path-to-jar>');
+            process.exit(1);
+        }
+        if (!fs.existsSync(resolvedJarPath)) {
+            log.error(`File not found: ${resolvedJarPath}`);
+            process.exit(1);
+        }
+        // 3. Read plugin.yml from JAR
+        const pluginYml = await readPluginYml(resolvedJarPath);
+        if (pluginYml) {
+            log.success(`Read plugin.yml from JAR: name=${pluginYml.name}, version=${pluginYml.version}`);
+        }
+        // 4. Read project config
+        const projectConfig = readProjectConfig();
+        if (projectConfig) {
+            log.success(`Using config from ultikits.json: id=${projectConfig.identifyString}`);
+        }
+        // 5. Resolve metadata
+        let metadata;
+        try {
+            metadata = resolveMetadata(options, projectConfig, pluginYml);
+        }
+        catch (err) {
+            log.error(err.message);
+            process.exit(1);
+        }
+        // 6. Show summary
+        const fileSize = fs.statSync(resolvedJarPath).size;
+        console.log();
+        console.log(`  Module:  ${metadata.name}`);
+        console.log(`  ID:      ${metadata.identifyString}`);
+        console.log(`  Version: ${metadata.version}`);
+        console.log(`  Size:    ${(fileSize / 1024).toFixed(0)} KB`);
+        console.log();
+        // 7. Ask for changelog if not provided
+        if (!metadata.changelog && !options.yes) {
+            const { changelog } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'changelog',
+                    message: 'Changelog (optional):',
+                },
+            ]);
+            if (changelog)
+                metadata.changelog = changelog;
+        }
+        // 8. Confirm
+        if (!options.yes) {
+            const { confirm } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'confirm',
+                    message: `Publish ${metadata.identifyString}@${metadata.version}?`,
+                    default: true,
+                },
+            ]);
+            if (!confirm)
+                return;
+        }
+        // 9. Check if module exists
+        const spin = log.spinner('Checking module...');
+        spin.start();
+        const pluginRes = await client.get(`/plugin/get?identifyString=${metadata.identifyString}`);
+        let moduleId;
+        if (pluginRes.code !== '200' || !pluginRes.data) {
+            // Module doesn't exist — create it
+            spin.text = 'Creating module...';
+            const createRes = await client.post('/developer/modules', {
+                name: metadata.name,
+                identifyString: metadata.identifyString,
+                shortDescription: metadata.shortDescription ?? '',
+                categoryId: metadata.categoryId,
+            });
+            if (createRes.code !== '200') {
+                spin.fail('Failed to create module: ' + createRes.msg);
+                process.exit(1);
+            }
+            moduleId = createRes.data.id;
+            spin.succeed('Module created');
+        }
+        else {
+            moduleId = pluginRes.data.id;
+            spin.succeed('Module found');
+        }
+        // 10. Create version
+        const versionSpin = log.spinner(`Creating version ${metadata.version}...`);
+        versionSpin.start();
+        const versionRes = await client.post(`/developer/modules/${moduleId}/versions`, {
+            version: metadata.version,
+            changelog: metadata.changelog,
+        });
+        if (versionRes.code !== '200') {
+            versionSpin.fail('Failed to create version: ' + versionRes.msg);
+            process.exit(1);
+        }
+        const { uploadToken } = versionRes.data;
+        versionSpin.succeed('Upload token acquired');
+        // 11. Upload JAR
+        const uploadSpin = log.spinner('Uploading JAR...');
+        uploadSpin.start();
+        const fileBuffer = fs.readFileSync(resolvedJarPath);
+        const blob = new Blob([fileBuffer]);
+        const formData = new FormData();
+        formData.append('file', blob, path.basename(resolvedJarPath));
+        const uploadRes = await client.postMultipart(`/developer/modules/${moduleId}/upload`, formData, { 'X-Upload-Token': uploadToken });
+        if (uploadRes.code !== '200') {
+            uploadSpin.fail('Upload failed: ' + uploadRes.msg);
+            process.exit(1);
+        }
+        uploadSpin.succeed(`Published ${metadata.identifyString}@${metadata.version}`);
+        console.log();
+        log.info(`https://panel.ultikits.com/modules/${metadata.identifyString}`);
+    });
+}
+//# sourceMappingURL=publish.js.map

package/dist/src/commands/versions.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerVersionsCommand(program: Command): void;

package/dist/src/commands/versions.js

@@ -0,0 +1,76 @@
+import inquirer from 'inquirer';
+import { readCredentials } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import * as log from '../lib/logger.js';
+export function registerVersionsCommand(program) {
+    const versions = program
+        .command('versions')
+        .description('Manage module versions');
+    versions
+        .command('list <identifyString>')
+        .description('List versions of a module')
+        .action(async (identifyString) => {
+        const client = getClient();
+        // Get module ID
+        const infoRes = await client.get(`/plugin/get?identifyString=${identifyString}`);
+        if (infoRes.code !== '200' || !infoRes.data) {
+            log.error('Module not found: ' + identifyString);
+            process.exit(1);
+        }
+        const res = await client.get(`/plugin/${infoRes.data.id}/versions`);
+        if (res.code !== '200') {
+            log.error('Failed to list versions: ' + res.msg);
+            process.exit(1);
+        }
+        const versionsList = res.data;
+        if (versionsList.length === 0) {
+            log.info('No versions published yet.');
+            return;
+        }
+        console.log();
+        for (const v of versionsList) {
+            const latest = v.is_latest ? ' (latest)' : '';
+            const size = v.file_size ? ` ${(v.file_size / 1024).toFixed(0)} KB` : '';
+            console.log(`  ${v.version}${latest}${size} — ${v.created_at}`);
+        }
+        console.log();
+        log.info(`${versionsList.length} version(s)`);
+    });
+    versions
+        .command('delete <identifyString> <version>')
+        .description('Delete a specific version')
+        .action(async (identifyString, version) => {
+        const client = getClient();
+        const infoRes = await client.get(`/plugin/get?identifyString=${identifyString}`);
+        if (infoRes.code !== '200' || !infoRes.data) {
+            log.error('Module not found: ' + identifyString);
+            process.exit(1);
+        }
+        const { confirm } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'confirm',
+                message: `Delete version ${version} of "${identifyString}"?`,
+                default: false,
+            },
+        ]);
+        if (!confirm)
+            return;
+        const res = await client.delete(`/developer/modules/${infoRes.data.id}/versions/${version}`);
+        if (res.code !== '200') {
+            log.error('Failed to delete version: ' + res.msg);
+            process.exit(1);
+        }
+        log.success(`Deleted version ${version}`);
+    });
+}
+function getClient() {
+    const credentials = readCredentials();
+    const client = ApiClient.fromEnvOrCredentials(credentials);
+    if (!client) {
+        log.error('Not logged in. Run `ultikits login` or set ULTIKITS_TOKEN.');
+        process.exit(1);
+    }
+    return client;
+}
+//# sourceMappingURL=versions.js.map

package/dist/src/commands/whoami.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerWhoamiCommand(program: Command): void;

package/dist/src/commands/whoami.js

@@ -0,0 +1,32 @@
+import { readCredentials } from '../lib/config.js';
+import { ApiClient } from '../lib/api-client.js';
+import * as log from '../lib/logger.js';
+export function registerWhoamiCommand(program) {
+    program
+        .command('whoami')
+        .description('Show current authenticated user')
+        .action(async () => {
+        const credentials = readCredentials();
+        const client = ApiClient.fromEnvOrCredentials(credentials);
+        if (!client) {
+            log.error('Not logged in. Run `ultikits login` or set ULTIKITS_TOKEN.');
+            process.exit(1);
+        }
+        const spin = log.spinner('Checking...');
+        spin.start();
+        try {
+            const res = await client.get('/developer/modules');
+            if (res.code === '200') {
+                spin.succeed('Authenticated as developer');
+                log.info(`Auth type: ${credentials?.type ?? 'env var'}`);
+            }
+            else {
+                spin.fail('Authentication failed: ' + res.msg);
+            }
+        }
+        catch (err) {
+            spin.fail('Failed to verify: ' + err.message);
+        }
+    });
+}
+//# sourceMappingURL=whoami.js.map

package/dist/src/lib/api-client.d.ts

@@ -0,0 +1,12 @@
+import type { Credentials, ApiResponse } from '../types.js';
+export declare class ApiClient {
+    private baseUrl;
+    private credentials;
+    constructor(credentials: Credentials);
+    static fromEnvOrCredentials(credentials: Credentials | null): ApiClient | null;
+    private getHeaders;
+    get<T = any>(path: string): Promise<ApiResponse<T>>;
+    post<T = any>(path: string, body?: any): Promise<ApiResponse<T>>;
+    postMultipart<T = any>(path: string, formData: FormData, extraHeaders?: Record<string, string>): Promise<ApiResponse<T>>;
+    delete<T = any>(path: string): Promise<ApiResponse<T>>;
+}

package/dist/src/lib/api-client.js

@@ -0,0 +1,71 @@
+export class ApiClient {
+    baseUrl;
+    credentials;
+    constructor(credentials) {
+        this.credentials = credentials;
+        this.baseUrl = credentials.api_url;
+    }
+    static fromEnvOrCredentials(credentials) {
+        const envToken = process.env.ULTIKITS_TOKEN;
+        if (envToken) {
+            return new ApiClient({
+                type: 'access_token',
+                token: envToken,
+                api_url: 'https://api.ultikits.com',
+            });
+        }
+        if (credentials) {
+            return new ApiClient(credentials);
+        }
+        return null;
+    }
+    getHeaders() {
+        const headers = {};
+        if (this.credentials.type === 'oauth') {
+            headers['Authorization'] = `Bearer ${this.credentials.access_token}`;
+        }
+        else {
+            headers['X-Access-Token'] = this.credentials.token;
+        }
+        return headers;
+    }
+    async get(path) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'GET',
+            headers: this.getHeaders(),
+        });
+        return response.json();
+    }
+    async post(path, body) {
+        const headers = {
+            ...this.getHeaders(),
+            'Content-Type': 'application/json',
+        };
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        return response.json();
+    }
+    async postMultipart(path, formData, extraHeaders) {
+        const headers = {
+            ...this.getHeaders(),
+            ...(extraHeaders ?? {}),
+        };
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers,
+            body: formData,
+        });
+        return response.json();
+    }
+    async delete(path) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'DELETE',
+            headers: this.getHeaders(),
+        });
+        return response.json();
+    }
+}
+//# sourceMappingURL=api-client.js.map

package/dist/src/lib/config.d.ts

@@ -0,0 +1,6 @@
+import type { Credentials } from '../types.js';
+export declare function getConfigDir(): string;
+export declare function readCredentials(configDir?: string): Credentials | null;
+export declare function writeCredentials(credentials: Credentials, configDir?: string): void;
+export declare function deleteCredentials(configDir?: string): void;
+export declare function getApiUrl(credentials: Credentials | null): string;

package/dist/src/lib/config.js

@@ -0,0 +1,39 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const CREDENTIALS_FILE = 'credentials.json';
+const DEFAULT_API_URL = 'https://api.ultikits.com';
+export function getConfigDir() {
+    return path.join(os.homedir(), '.ultikits');
+}
+export function readCredentials(configDir) {
+    const dir = configDir ?? getConfigDir();
+    const filePath = path.join(dir, CREDENTIALS_FILE);
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCredentials(credentials, configDir) {
+    const dir = configDir ?? getConfigDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const filePath = path.join(dir, CREDENTIALS_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(credentials, null, 2), { mode: 0o600 });
+}
+export function deleteCredentials(configDir) {
+    const dir = configDir ?? getConfigDir();
+    const filePath = path.join(dir, CREDENTIALS_FILE);
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch {
+        // Already gone
+    }
+}
+export function getApiUrl(credentials) {
+    return credentials?.api_url ?? DEFAULT_API_URL;
+}
+//# sourceMappingURL=config.js.map

package/dist/src/lib/jar-reader.d.ts

@@ -0,0 +1,3 @@
+import type { PluginYml } from '../types.js';
+export declare function readPluginYml(jarPath: string): Promise<PluginYml | null>;
+export declare function findJarInTarget(dir?: string): string | null;

package/dist/src/lib/jar-reader.js

@@ -0,0 +1,42 @@
+import JSZip from 'jszip';
+import yaml from 'js-yaml';
+import fs from 'node:fs';
+import path from 'node:path';
+export async function readPluginYml(jarPath) {
+    try {
+        const data = fs.readFileSync(jarPath);
+        const zip = await JSZip.loadAsync(data);
+        const pluginYml = zip.file('plugin.yml');
+        if (!pluginYml)
+            return null;
+        const content = await pluginYml.async('text');
+        const parsed = yaml.load(content);
+        return {
+            name: parsed.name,
+            version: String(parsed.version),
+            description: parsed.description,
+            authors: parsed.authors,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function findJarInTarget(dir) {
+    const targetDir = path.join(dir ?? process.cwd(), 'target');
+    try {
+        const files = fs.readdirSync(targetDir);
+        const jars = files.filter((f) => f.endsWith('.jar') && !f.endsWith('-sources.jar') && !f.endsWith('-javadoc.jar'));
+        if (jars.length === 0)
+            return null;
+        if (jars.length === 1)
+            return path.join(targetDir, jars[0]);
+        // Multiple JARs — prefer the shaded/fat JAR (without classifier)
+        const simple = jars.find((f) => !f.includes('-original'));
+        return path.join(targetDir, simple ?? jars[0]);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=jar-reader.js.map

package/dist/src/lib/logger.d.ts

@@ -0,0 +1,5 @@
+export declare function success(msg: string): void;
+export declare function error(msg: string): void;
+export declare function info(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function spinner(text: string): import("ora").Ora;

package/dist/src/lib/logger.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import ora from 'ora';
+export function success(msg) {
+    console.log(chalk.green('✓') + ' ' + msg);
+}
+export function error(msg) {
+    console.error(chalk.red('✗') + ' ' + msg);
+}
+export function info(msg) {
+    console.log(chalk.blue('ℹ') + ' ' + msg);
+}
+export function warn(msg) {
+    console.log(chalk.yellow('⚠') + ' ' + msg);
+}
+export function spinner(text) {
+    return ora({ text, color: 'cyan' });
+}
+//# sourceMappingURL=logger.js.map

package/dist/src/lib/project-config.d.ts

@@ -0,0 +1,3 @@
+import type { ProjectConfig } from '../types.js';
+export declare function readProjectConfig(dir?: string): ProjectConfig | null;
+export declare function writeProjectConfig(config: ProjectConfig, dir?: string): void;

package/dist/src/lib/project-config.js

@@ -0,0 +1,18 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const CONFIG_FILE = 'ultikits.json';
+export function readProjectConfig(dir) {
+    const filePath = path.join(dir ?? process.cwd(), CONFIG_FILE);
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function writeProjectConfig(config, dir) {
+    const filePath = path.join(dir ?? process.cwd(), CONFIG_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n');
+}
+//# sourceMappingURL=project-config.js.map

package/dist/src/types.d.ts

@@ -0,0 +1,38 @@
+export interface OAuthCredentials {
+    type: 'oauth';
+    access_token: string;
+    refresh_token: string;
+    expires_at: string;
+    api_url: string;
+}
+export interface AccessTokenCredentials {
+    type: 'access_token';
+    token: string;
+    api_url: string;
+}
+export type Credentials = OAuthCredentials | AccessTokenCredentials;
+export interface ProjectConfig {
+    identifyString: string;
+    name: string;
+    shortDescription?: string;
+    categoryId?: number;
+}
+export interface PluginYml {
+    name: string;
+    version: string;
+    description?: string;
+    authors?: string[];
+}
+export interface ModuleMetadata {
+    identifyString: string;
+    name: string;
+    version: string;
+    shortDescription?: string;
+    changelog?: string;
+    categoryId?: number;
+}
+export interface ApiResponse<T = any> {
+    code: string;
+    msg: string;
+    data?: T;
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@ultikits/cli",
+  "version": "1.0.0",
+  "description": "CLI tool for publishing UltiTools plugin modules to UltiCloud marketplace",
+  "type": "module",
+  "bin": {
+    "ultikits": "dist/bin/ultikits.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "keywords": [
+    "ultikits",
+    "minecraft",
+    "spigot",
+    "paper",
+    "plugin",
+    "cli",
+    "marketplace",
+    "module",
+    "publish"
+  ],
+  "author": "UltiKits <dev@ultikits.com> (https://ultikits.com)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/UltiKits/ultikits-cli.git"
+  },
+  "homepage": "https://github.com/UltiKits/ultikits-cli#readme",
+  "bugs": {
+    "url": "https://github.com/UltiKits/ultikits-cli/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "dependencies": {
+    "commander": "^12.1.0",
+    "inquirer": "^9.3.0",
+    "ora": "^8.1.0",
+    "chalk": "^5.3.0",
+    "jszip": "^3.10.1",
+    "js-yaml": "^4.1.0",
+    "open": "^10.1.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.7",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^20.14.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  }
+}