kustom-mc 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,219 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+export const initCommand = new Command('init')
+    .description('Initialize a new kustompack project')
+    .argument('[project-name]', 'Name of the project directory')
+    .option('-f, --force', 'Overwrite existing files')
+    .action(async (projectName, options) => {
+    const targetDir = projectName ? path.resolve(process.cwd(), projectName) : process.cwd();
+    const dirName = path.basename(targetDir);
+    // Convert directory name to valid pack ID (lowercase, alphanumeric, hyphens)
+    const packId = dirName.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-+/g, '-');
+    console.log(chalk.blue(`Initializing kustompack project: ${chalk.bold(packId)}`));
+    console.log(`  Directory: ${targetDir}`);
+    // Create directory if it doesn't exist
+    if (projectName && !fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+    }
+    // Check for existing files
+    const existingFiles = ['tsconfig.json', 'kustom.config.json', 'package.json'];
+    for (const file of existingFiles) {
+        const filePath = path.join(targetDir, file);
+        if (fs.existsSync(filePath) && !options.force) {
+            console.error(chalk.red(`Error: ${file} already exists. Use --force to overwrite.`));
+            process.exit(1);
+        }
+    }
+    // Create directory structure
+    const dirs = [
+        'scripts/lib',
+        'blocks',
+        'items',
+        'textures',
+        'gui',
+        'models',
+        'sounds',
+        'sounds/music',
+        'lang',
+        'definitions'
+    ];
+    for (const dir of dirs) {
+        const dirPath = path.join(targetDir, dir);
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+            // Add .gitkeep to empty directories
+            if (!['scripts', 'scripts/lib'].includes(dir)) {
+                fs.writeFileSync(path.join(dirPath, '.gitkeep'), '');
+            }
+        }
+    }
+    // Write tsconfig.json
+    const tsconfig = {
+        compilerOptions: {
+            target: "ES2020",
+            module: "ESNext",
+            lib: ["ES2020"],
+            moduleResolution: "node",
+            strict: true,
+            noEmit: true,
+            isolatedModules: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            baseUrl: ".",
+            paths: {
+                "@lib/*": ["scripts/lib/*"]
+            }
+        },
+        include: [
+            "scripts/**/*.ts",
+            "blocks/**/*.ts",
+            "items/**/*.ts",
+            "dist/types/**/*.d.ts",
+            ".kustom/types/**/*.d.ts",
+            "node_modules/kustom-mc/dist/types/globals.d.ts"
+        ],
+        exclude: []
+    };
+    fs.writeFileSync(path.join(targetDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+    // Write kustom.config.json with manifest
+    const kustomConfig = {
+        include: [
+            "scripts/**/*.ts",
+            "blocks/**/*.ts",
+            "items/**/*.ts"
+        ],
+        exclude: [
+            "**/*.test.ts",
+            "**/*.spec.ts"
+        ],
+        outDir: ".",
+        lib: ["scripts/lib"],
+        manifest: {
+            id: packId,
+            name: dirName,
+            version: "1.0.0",
+            description: "A kustompack project",
+            author: "",
+            scope: "global",
+            priority: 0
+        },
+        dependencies: [],
+        server: {
+            url: "http://localhost:8765"
+        },
+        deploy: {
+            target: "../run/plugins/kustom-plugin/packs",
+            reloadCommand: "/kustom pack reload"
+        },
+        bundle: {
+            output: `dist/${packId}.zip`,
+            include: [
+                "**/*.js",
+                "textures/**/*",
+                "gui/**/*",
+                "models/**/*",
+                "sounds/**/*",
+                "lang/**/*",
+                "definitions/**/*"
+            ]
+        }
+    };
+    fs.writeFileSync(path.join(targetDir, 'kustom.config.json'), JSON.stringify(kustomConfig, null, 2));
+    // Write package.json
+    const packageJson = {
+        name: packId,
+        version: "1.0.0",
+        type: "module",
+        scripts: {
+            build: "kustom build",
+            watch: "kustom build --watch",
+            deploy: "kustom build --deploy",
+            bundle: "kustom bundle",
+            validate: "kustom validate",
+            push: "kustom push"
+        },
+        devDependencies: {
+            "kustom-mc": "^0.1.0",
+            "typescript": "^5.0.0"
+        }
+    };
+    fs.writeFileSync(path.join(targetDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+    // Write example script
+    const exampleScript = `import { defineScript, Props } from 'kustom-mc';
+
+export default defineScript({
+  props: {
+    message: Props.String("Hello from ${packId}!"),
+  },
+  
+  run({ executor, props }) {
+    const player = executor.asPlayer();
+    if (!player) {
+      console.error("This script requires a player executor");
+      return;
+    }
+    
+    player.sendMessage(props.message);
+  }
+});
+`;
+    fs.writeFileSync(path.join(targetDir, 'scripts', 'example.ts'), exampleScript);
+    // Write lib/utils.ts
+    const utilsScript = `/**
+ * Shared utility functions for ${packId} scripts.
+ * Import these in your scripts using:
+ * import { formatMessage } from './lib/utils';
+ */
+
+/**
+ * Format a message with a prefix.
+ */
+export function formatMessage(prefix: string, message: string): string {
+  return \`[\${prefix}] \${message}\`;
+}
+
+/**
+ * Wait for a specified number of milliseconds.
+ */
+export function delay(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+`;
+    fs.writeFileSync(path.join(targetDir, 'scripts', 'lib', 'utils.ts'), utilsScript);
+    // Write .gitignore
+    const gitignore = `node_modules/
+dist/
+.kustom/
+*.js
+!scripts/lib/**/*.js
+`;
+    fs.writeFileSync(path.join(targetDir, '.gitignore'), gitignore);
+    console.log(chalk.green('\nProject initialized successfully!'));
+    console.log('\n' + chalk.bold('Project structure:'));
+    console.log(`  ${packId}/
+  ├── kustom.config.json   # Pack configuration & manifest
+  ├── tsconfig.json        # TypeScript configuration
+  ├── package.json         # npm configuration
+  ├── scripts/             # General scripts
+  │   ├── example.ts       # Example script
+  │   └── lib/             # Shared utilities
+  ├── blocks/              # Block definitions
+  ├── items/               # Item definitions
+  ├── textures/            # Texture files
+  ├── models/              # Model files
+  ├── sounds/              # Sound files
+  └── lang/                # Language files`);
+    console.log('\n' + chalk.bold('Next steps:'));
+    if (projectName) {
+        console.log(chalk.cyan(`  cd ${projectName}`));
+    }
+    console.log(chalk.cyan('  npm install'));
+    console.log(chalk.cyan('  npm run build'));
+    console.log('\n' + chalk.bold('Available commands:'));
+    console.log('  npm run build    - Compile TypeScript');
+    console.log('  npm run watch    - Watch mode');
+    console.log('  npm run deploy   - Build and deploy to server');
+    console.log('  npm run bundle   - Create distributable zip');
+});

package/dist/commands/list.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+/**
+ * List command - fetch and display packs from server.
+ *
+ * Usage:
+ *   npx kustom-mc list              # List all packs
+ *   npx kustom-mc list <pack-id>    # Show details for specific pack
+ *   npx kustom-mc list --verbose    # Show detailed info for all packs
+ */
+export declare const listCommand: Command;

package/dist/commands/list.js

@@ -0,0 +1,167 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loadConfig } from '../config.js';
+import { getServerToken, normalizeServerUrl } from '../credentials.js';
+/**
+ * Fetch pack list from server.
+ */
+async function fetchPackList(serverUrl) {
+    const url = `${normalizeServerUrl(serverUrl)}/packs`;
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json'
+        }
+    });
+    if (!response.ok) {
+        if (response.status === 404) {
+            throw new Error('Server does not have registry API enabled');
+        }
+        throw new Error(`Server returned ${response.status}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.packs || [];
+}
+/**
+ * Fetch detailed info for a specific pack.
+ */
+async function fetchPackInfo(serverUrl, packId) {
+    const url = `${normalizeServerUrl(serverUrl)}/packs/${encodeURIComponent(packId)}`;
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Accept': 'application/json'
+        }
+    });
+    if (response.status === 404) {
+        return null;
+    }
+    if (!response.ok) {
+        throw new Error(`Server returned ${response.status}: ${response.statusText}`);
+    }
+    return await response.json();
+}
+/**
+ * Format a pack for display.
+ */
+function formatPack(pack, verbose) {
+    const lines = [];
+    const nameDisplay = pack.name !== pack.id ? `${pack.name} (${pack.id})` : pack.id;
+    lines.push(`${chalk.cyan(nameDisplay)} ${chalk.gray(`v${pack.version}`)}`);
+    if (verbose) {
+        if (pack.description) {
+            lines.push(`  ${pack.description}`);
+        }
+        if (pack.author) {
+            lines.push(`  ${chalk.gray('Author:')} ${pack.author}`);
+        }
+        lines.push(`  ${chalk.gray('Scope:')} ${pack.scope} ${chalk.gray('Priority:')} ${pack.priority}`);
+        const counts = [];
+        if (pack.scriptCount > 0)
+            counts.push(`${pack.scriptCount} scripts`);
+        if (pack.itemCount > 0)
+            counts.push(`${pack.itemCount} items`);
+        if (pack.shaperCount > 0)
+            counts.push(`${pack.shaperCount} blocks`);
+        if (pack.dependencyCount > 0)
+            counts.push(`${pack.dependencyCount} dependencies`);
+        if (counts.length > 0) {
+            lines.push(`  ${chalk.gray('Contains:')} ${counts.join(', ')}`);
+        }
+    }
+    else {
+        const info = [`v${pack.version}`];
+        if (pack.scope !== 'global')
+            info.push(pack.scope);
+        if (pack.author)
+            info.push(`by ${pack.author}`);
+        // Already included version above, just add description if short
+        if (pack.description && pack.description.length < 50) {
+            lines[0] = `${chalk.cyan(nameDisplay)} ${chalk.gray(`v${pack.version}`)} - ${pack.description}`;
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * List command - fetch and display packs from server.
+ *
+ * Usage:
+ *   npx kustom-mc list              # List all packs
+ *   npx kustom-mc list <pack-id>    # Show details for specific pack
+ *   npx kustom-mc list --verbose    # Show detailed info for all packs
+ */
+export const listCommand = new Command('list')
+    .description('List packs available on the connected server')
+    .argument('[pack-id]', 'Show details for a specific pack')
+    .option('-s, --server <url>', 'Server URL (overrides config)')
+    .option('-v, --verbose', 'Show detailed information')
+    .option('--json', 'Output as JSON')
+    .action(async (packId, options) => {
+    // Determine server URL
+    let serverUrl;
+    if (options?.server) {
+        serverUrl = options.server;
+    }
+    else {
+        const config = loadConfig(process.cwd());
+        if (!config.server?.url) {
+            console.error(chalk.red('Error: No server URL configured'));
+            console.log('Set server.url in kustom.config.json or use --server flag');
+            process.exit(1);
+        }
+        serverUrl = config.server.url;
+    }
+    serverUrl = normalizeServerUrl(serverUrl);
+    // Check if logged in (for display purposes)
+    const token = getServerToken(serverUrl);
+    const loggedIn = token !== null;
+    try {
+        if (packId) {
+            // Fetch specific pack
+            console.log(chalk.blue(`Fetching pack info from ${serverUrl}...`));
+            const pack = await fetchPackInfo(serverUrl, packId);
+            if (!pack) {
+                console.error(chalk.red(`Pack not found: ${packId}`));
+                process.exit(1);
+            }
+            if (options?.json) {
+                console.log(JSON.stringify(pack, null, 2));
+            }
+            else {
+                console.log();
+                console.log(formatPack(pack, true));
+                console.log();
+            }
+        }
+        else {
+            // Fetch all packs
+            console.log(chalk.blue(`Fetching pack list from ${serverUrl}...`));
+            const packs = await fetchPackList(serverUrl);
+            if (options?.json) {
+                console.log(JSON.stringify(packs, null, 2));
+                return;
+            }
+            if (packs.length === 0) {
+                console.log(chalk.yellow('\nNo packs found on server.'));
+                return;
+            }
+            console.log(chalk.green(`\nFound ${packs.length} pack(s):\n`));
+            for (const pack of packs) {
+                console.log(formatPack(pack, options?.verbose || false));
+                if (options?.verbose) {
+                    console.log(); // Extra spacing in verbose mode
+                }
+            }
+            if (!options?.verbose) {
+                console.log(chalk.gray('\nUse --verbose for more details, or list <pack-id> for specific pack.'));
+            }
+        }
+        if (!loggedIn) {
+            console.log(chalk.gray('\nTip: Run `npx kustom-mc login` to authenticate for push access.'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Failed to fetch packs: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+});

package/dist/commands/login.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+/**
+ * Login command - authenticate with a server using a token.
+ *
+ * Usage:
+ *   npx kustom-mc login <server-url> <token>
+ *   npx kustom-mc login <token>  (uses server.url from config)
+ */
+export declare const loginCommand: Command;

package/dist/commands/login.js

@@ -0,0 +1,167 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { loadConfig } from '../config.js';
+import { saveServerToken, getServerCredential, normalizeServerUrl, listStoredServers, removeServerCredential } from '../credentials.js';
+/**
+ * Validate a token with the server.
+ */
+async function validateToken(serverUrl, token) {
+    const url = `${normalizeServerUrl(serverUrl)}/token/validate`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ token })
+    });
+    if (!response.ok) {
+        if (response.status === 404) {
+            throw new Error('Server does not support token validation. Is the registry API enabled?');
+        }
+        throw new Error(`Server returned ${response.status}: ${response.statusText}`);
+    }
+    return await response.json();
+}
+/**
+ * Login command - authenticate with a server using a token.
+ *
+ * Usage:
+ *   npx kustom-mc login <server-url> <token>
+ *   npx kustom-mc login <token>  (uses server.url from config)
+ */
+export const loginCommand = new Command('login')
+    .description('Authenticate with a Kustom server using a token')
+    .argument('[server-url]', 'Server URL (or use server.url from config)')
+    .argument('[token]', 'Authentication token from /kustom token command')
+    .option('--status', 'Show current login status')
+    .option('--logout', 'Remove stored credentials for a server')
+    .option('--list', 'List all stored server credentials')
+    .action(async (serverUrlArg, tokenArg, options) => {
+    // Handle --list flag
+    if (options?.list) {
+        const servers = listStoredServers();
+        if (servers.length === 0) {
+            console.log(chalk.yellow('No stored credentials.'));
+            return;
+        }
+        console.log(chalk.blue('Stored server credentials:'));
+        for (const server of servers) {
+            const cred = getServerCredential(server);
+            if (cred) {
+                console.log(`  ${chalk.cyan(server)}`);
+                if (cred.playerName) {
+                    console.log(`    Player: ${cred.playerName}`);
+                }
+                console.log(`    Saved: ${cred.savedAt}`);
+            }
+        }
+        return;
+    }
+    // Determine server URL
+    let serverUrl;
+    let token;
+    // If only one argument provided, it might be the token (use config for server)
+    if (serverUrlArg && !tokenArg && !serverUrlArg.includes('://') && !serverUrlArg.includes(':')) {
+        // Looks like a token, not a URL
+        token = serverUrlArg;
+        const config = loadConfig(process.cwd());
+        if (!config.server?.url) {
+            console.error(chalk.red('Error: No server URL provided and none configured in kustom.config.json'));
+            console.log('Usage: npx kustom-mc login <server-url> <token>');
+            console.log('   or: npx kustom-mc login <token>  (with server.url in config)');
+            process.exit(1);
+        }
+        serverUrl = config.server.url;
+    }
+    else if (serverUrlArg) {
+        serverUrl = serverUrlArg;
+        token = tokenArg;
+    }
+    else {
+        // No arguments - use config
+        const config = loadConfig(process.cwd());
+        if (!config.server?.url) {
+            console.error(chalk.red('Error: No server URL provided'));
+            console.log('Usage: npx kustom-mc login <server-url> <token>');
+            process.exit(1);
+        }
+        serverUrl = config.server.url;
+    }
+    serverUrl = normalizeServerUrl(serverUrl);
+    // Handle --logout flag
+    if (options?.logout) {
+        const removed = removeServerCredential(serverUrl);
+        if (removed) {
+            console.log(chalk.green(`Logged out from ${serverUrl}`));
+        }
+        else {
+            console.log(chalk.yellow(`No credentials stored for ${serverUrl}`));
+        }
+        return;
+    }
+    // Handle --status flag
+    if (options?.status) {
+        const cred = getServerCredential(serverUrl);
+        if (!cred) {
+            console.log(chalk.yellow(`Not logged in to ${serverUrl}`));
+            return;
+        }
+        console.log(chalk.blue(`Login status for ${serverUrl}:`));
+        console.log(`  Token: ${cred.token.substring(0, 8)}...`);
+        if (cred.playerName) {
+            console.log(`  Player: ${cred.playerName}`);
+        }
+        console.log(`  Saved: ${cred.savedAt}`);
+        // Validate token is still valid
+        console.log('\nValidating token with server...');
+        try {
+            const result = await validateToken(serverUrl, cred.token);
+            if (result.valid) {
+                console.log(chalk.green('  Token is valid'));
+                if (result.expiresAt) {
+                    console.log(`  Expires: ${result.expiresAt}`);
+                }
+            }
+            else {
+                console.log(chalk.red('  Token is invalid or expired'));
+                console.log(chalk.yellow('  Run: npx kustom-mc login --logout'));
+            }
+        }
+        catch (error) {
+            console.log(chalk.yellow(`  Could not validate: ${error instanceof Error ? error.message : error}`));
+        }
+        return;
+    }
+    // Login with token
+    if (!token) {
+        console.error(chalk.red('Error: Token is required'));
+        console.log('Usage: npx kustom-mc login <server-url> <token>');
+        console.log('\nTo get a token, run /kustom token in-game on the server.');
+        process.exit(1);
+    }
+    console.log(chalk.blue(`Logging in to ${serverUrl}...`));
+    try {
+        const result = await validateToken(serverUrl, token);
+        if (!result.valid) {
+            console.error(chalk.red('Login failed: Invalid or expired token'));
+            if (result.error) {
+                console.error(chalk.red(`  ${result.error}`));
+            }
+            process.exit(1);
+        }
+        // Save credentials
+        saveServerToken(serverUrl, token, result.playerName);
+        console.log(chalk.green('\nLogin successful!'));
+        if (result.playerName) {
+            console.log(`  Player: ${result.playerName}`);
+        }
+        if (result.expiresAt) {
+            console.log(`  Token expires: ${result.expiresAt}`);
+        }
+        console.log(`\nCredentials saved to ~/.kustom/credentials.json`);
+    }
+    catch (error) {
+        console.error(chalk.red(`Login failed: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+});

package/dist/commands/new.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const newCommand: Command;