kustom-mc 0.1.0

package/dist/commands/new.js

@@ -0,0 +1,132 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import Handlebars from 'handlebars';
+const templates = {
+    script: `import { defineScript } from 'kustom-mc';
+
+export default defineScript({
+  props: {
+    // Define your props here
+  },
+  
+  run({ executor, props, process }) {
+    const player = executor.asPlayer();
+    if (!player) {
+      console.error("This script requires a player executor");
+      return;
+    }
+    
+    // Your script logic here
+    player.sendMessage("Hello from {{name}}!");
+  }
+});
+`,
+    block: `import { defineScript } from 'kustom-mc';
+
+export default defineScript({
+  run({ shaper }) {
+    shaper.create("{{name}}")
+      .withModel("kustom:block/{{name}}")
+      .fullBlockCollision()
+      .onClick((event) => {
+        const player = event.player;
+        player.sendMessage("You clicked {{name}}!");
+      })
+      .register();
+  }
+});
+`,
+    item: `import { defineScript } from 'kustom-mc';
+
+export default defineScript({
+  run({ items, definition }) {
+    items.create("{{name}}")
+      .withModel(definition.model("kustom:item/{{name}}"))
+      .on("rightClick", (event) => {
+        const player = event.player;
+        player.sendMessage("You used {{name}}!");
+      })
+      .register();
+  }
+});
+`,
+    gui: `import { defineScript, Screen, Props } from 'kustom-mc';
+
+export default defineScript({
+  props: {
+    title: Props.String("{{name}}"),
+  },
+  
+  run({ executor, props, process }) {
+    const player = executor.asPlayer();
+    if (!player) {
+      console.error("This script requires a player executor");
+      return;
+    }
+    
+    const screen = new Screen(54, {
+      autoCover: true,
+    });
+    
+    screen.appendText(props.title, 9, 20, true);
+    
+    screen.addButton(8, "close", "Close", () => {
+      screen.close();
+      process.exit(null);
+    });
+    
+    screen.open(player);
+  }
+});
+`
+};
+export const newCommand = new Command('new')
+    .description('Generate a new script from template')
+    .argument('<type>', 'Type of script (script, block, item, gui)')
+    .argument('<name>', 'Name of the script')
+    .option('-f, --force', 'Overwrite existing file')
+    .action(async (type, name, options) => {
+    const validTypes = Object.keys(templates);
+    if (!validTypes.includes(type)) {
+        console.error(`Invalid type: ${type}`);
+        console.error(`Valid types: ${validTypes.join(', ')}`);
+        process.exit(1);
+    }
+    // Determine output directory and file
+    const dirMap = {
+        script: 'scripts',
+        block: 'blocks',
+        item: 'items',
+        gui: 'scripts'
+    };
+    const dir = dirMap[type];
+    const fileName = `${name}.ts`;
+    const filePath = path.join(process.cwd(), dir, fileName);
+    // Check if file exists
+    if (fs.existsSync(filePath) && !options.force) {
+        console.error(`File already exists: ${dir}/${fileName}`);
+        console.error('Use --force to overwrite.');
+        process.exit(1);
+    }
+    // Ensure directory exists
+    const fullDir = path.dirname(filePath);
+    if (!fs.existsSync(fullDir)) {
+        fs.mkdirSync(fullDir, { recursive: true });
+    }
+    // Generate from template
+    const template = Handlebars.compile(templates[type]);
+    const content = template({ name });
+    fs.writeFileSync(filePath, content);
+    console.log(`Created: ${dir}/${fileName}`);
+    // Suggest next steps
+    if (type === 'gui') {
+        console.log(`\nDon't forget to create the GUI texture: gui/${name}.png`);
+    }
+    else if (type === 'block') {
+        console.log(`\nDon't forget to create the block model: models/block/${name}.json`);
+    }
+    else if (type === 'item') {
+        console.log(`\nDon't forget to create the item model: models/item/${name}.json`);
+    }
+});

package/dist/commands/prepare.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+/**
+ * Run the prepare command - scan project and generate types.
+ */
+export declare function prepare(projectDir: string, options?: {
+    verbose?: boolean;
+    skipServer?: boolean;
+}): Promise<void>;
+export declare const prepareCommand: Command;

package/dist/commands/prepare.js

@@ -0,0 +1,267 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+import chalk from 'chalk';
+import { loadConfig } from '../config.js';
+import { getServerToken, normalizeServerUrl } from '../credentials.js';
+/**
+ * Scan the sounds/ folder and return an array of sound event names.
+ *
+ * sounds/ding.ogg → "ding"
+ * sounds/effects/boom.ogg → "effects.boom"
+ * sounds/music/theme.ogg → "music.theme"
+ */
+async function scanSounds(projectDir) {
+    const soundsDir = path.join(projectDir, 'sounds');
+    if (!fs.existsSync(soundsDir)) {
+        return [];
+    }
+    const oggFiles = await glob('**/*.ogg', {
+        cwd: soundsDir,
+        nodir: true
+    });
+    return oggFiles.map(file => {
+        // Remove .ogg extension and convert slashes to dots
+        const withoutExt = file.replace(/\.ogg$/i, '');
+        return withoutExt.replace(/[\\/]/g, '.');
+    });
+}
+/**
+ * Generate TypeScript declaration content for sounds.
+ * This is the single source of truth for sound types.
+ */
+function generateSoundTypes(sounds) {
+    const soundType = sounds.length > 0
+        ? sounds.map(s => `"${s}"`).join(' | ')
+        : 'string'; // fallback to string when no sounds
+    return `// Auto-generated by kustom-mc prepare
+// Do not edit manually - changes will be overwritten
+
+export type KustomSounds = ${soundType};
+`;
+}
+/**
+ * Generate the main index.d.ts that declares globals using the generated types.
+ */
+function generateIndexTypes(sounds) {
+    const soundType = sounds.length > 0
+        ? sounds.map(s => `"${s}"`).join(' | ')
+        : 'string';
+    return `// Auto-generated by kustom-mc prepare
+// Do not edit manually - changes will be overwritten
+
+import type { PlaySoundOptions, Sound } from 'kustom-mc';
+
+/** Available custom sounds in this project */
+export type KustomSounds = ${soundType};
+
+declare global {
+  /**
+   * Play a sound to one or more targets.
+   * 
+   * @param sound - Custom sound name or "minecraft:..." for vanilla sounds
+   * @param target - Player, location, entity, or "*" for all players
+   * @param options - Volume, pitch, category options
+   */
+  function playSound(
+    sound: KustomSounds | \`minecraft:\${string}\`,
+    target: unknown,
+    options?: PlaySoundOptions
+  ): Sound;
+}
+`;
+}
+/**
+ * Parse a dependency string into pack ID and version range.
+ * Format: "pack-id@version-range" (e.g., "core-pack@^1.0.0")
+ */
+function parseDependency(dep) {
+    const match = dep.match(/^([a-z0-9-]+)@(.+)$/);
+    if (!match)
+        return null;
+    return { packId: match[1], versionRange: match[2] };
+}
+/**
+ * Fetch type definitions for a pack from the server.
+ */
+async function fetchPackTypes(serverUrl, packId) {
+    const url = `${normalizeServerUrl(serverUrl)}/packs/${encodeURIComponent(packId)}/types`;
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                'Accept': 'text/plain'
+            }
+        });
+        if (response.status === 404) {
+            return null; // Pack not found
+        }
+        if (!response.ok) {
+            throw new Error(`Server returned ${response.status}`);
+        }
+        return await response.text();
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch types for ${packId}: ${error instanceof Error ? error.message : error}`);
+    }
+}
+/**
+ * Fetch types for all dependencies from the server.
+ */
+async function fetchDependencyTypes(serverUrl, dependencies, typesDir, verbose) {
+    const fetched = [];
+    const failed = [];
+    for (const dep of dependencies) {
+        const parsed = parseDependency(dep);
+        if (!parsed) {
+            if (verbose) {
+                console.log(chalk.yellow(`  Skipping invalid dependency: ${dep}`));
+            }
+            failed.push(dep);
+            continue;
+        }
+        const { packId } = parsed;
+        if (verbose) {
+            console.log(`  Fetching types for ${packId}...`);
+        }
+        try {
+            const types = await fetchPackTypes(serverUrl, packId);
+            if (types === null) {
+                if (verbose) {
+                    console.log(chalk.yellow(`    Pack not found on server: ${packId}`));
+                }
+                failed.push(packId);
+                continue;
+            }
+            // Write types to .kustom/types/{packId}.d.ts
+            const typesPath = path.join(typesDir, `${packId}.d.ts`);
+            fs.writeFileSync(typesPath, types);
+            fetched.push(packId);
+            if (verbose) {
+                console.log(chalk.green(`    Saved: ${packId}.d.ts`));
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                console.log(chalk.red(`    Error: ${error instanceof Error ? error.message : error}`));
+            }
+            failed.push(packId);
+        }
+    }
+    return { fetched, failed };
+}
+/**
+ * Generate an index.d.ts that re-exports all dependency types.
+ */
+function generateDependencyIndex(packIds) {
+    if (packIds.length === 0) {
+        return `// Auto-generated by kustom-mc prepare
+// No dependencies configured
+export {};
+`;
+    }
+    const exports = packIds.map(id => `export * as ${id.replace(/-/g, '_')} from './${id}.js';`);
+    return `// Auto-generated by kustom-mc prepare
+// Re-exports types from all dependencies
+
+${exports.join('\n')}
+`;
+}
+/**
+ * Run the prepare command - scan project and generate types.
+ */
+export async function prepare(projectDir, options) {
+    const config = loadConfig(projectDir);
+    const verbose = options?.verbose ?? false;
+    // === Local Types (dist/types/) ===
+    const distTypesDir = path.join(projectDir, 'dist', 'types');
+    // Ensure dist/types directory exists
+    if (!fs.existsSync(distTypesDir)) {
+        fs.mkdirSync(distTypesDir, { recursive: true });
+    }
+    // Scan sounds
+    const sounds = await scanSounds(projectDir);
+    // Generate and write sounds types
+    const soundTypesContent = generateSoundTypes(sounds);
+    const soundTypesPath = path.join(distTypesDir, 'sounds.d.ts');
+    fs.writeFileSync(soundTypesPath, soundTypesContent);
+    // Generate main index.d.ts with global declarations
+    const indexTypesContent = generateIndexTypes(sounds);
+    const indexTypesPath = path.join(distTypesDir, 'index.d.ts');
+    fs.writeFileSync(indexTypesPath, indexTypesContent);
+    if (sounds.length > 0) {
+        console.log(`Generated types for ${sounds.length} sound(s)`);
+    }
+    // === Dependency Types (.kustom/types/) ===
+    if (options?.skipServer) {
+        if (verbose) {
+            console.log(chalk.gray('Skipping server dependency fetch (--skip-server)'));
+        }
+        return;
+    }
+    const dependencies = config.dependencies || [];
+    if (dependencies.length === 0) {
+        if (verbose) {
+            console.log(chalk.gray('No dependencies configured'));
+        }
+        return;
+    }
+    // Check for server URL
+    const serverUrl = config.server?.url;
+    if (!serverUrl) {
+        console.log(chalk.yellow('Warning: Dependencies configured but no server.url in config'));
+        console.log(chalk.yellow('  Skipping dependency type fetching'));
+        return;
+    }
+    // Check if logged in (optional, types endpoint may not require auth)
+    const token = getServerToken(serverUrl);
+    if (!token && verbose) {
+        console.log(chalk.gray('Not logged in - some types may not be available'));
+    }
+    // Create .kustom/types directory
+    const kustomTypesDir = path.join(projectDir, '.kustom', 'types');
+    if (!fs.existsSync(kustomTypesDir)) {
+        fs.mkdirSync(kustomTypesDir, { recursive: true });
+    }
+    console.log(`\nFetching dependency types from ${serverUrl}...`);
+    const { fetched, failed } = await fetchDependencyTypes(serverUrl, dependencies, kustomTypesDir, verbose);
+    // Generate index for dependencies
+    if (fetched.length > 0) {
+        const depIndexContent = generateDependencyIndex(fetched);
+        const depIndexPath = path.join(kustomTypesDir, 'index.d.ts');
+        fs.writeFileSync(depIndexPath, depIndexContent);
+    }
+    // Summary
+    if (fetched.length > 0) {
+        console.log(chalk.green(`Fetched types for ${fetched.length} dependency(ies)`));
+    }
+    if (failed.length > 0) {
+        console.log(chalk.yellow(`Failed to fetch ${failed.length} dependency(ies): ${failed.join(', ')}`));
+    }
+    // Add .kustom to .gitignore if not already there
+    const gitignorePath = path.join(projectDir, '.gitignore');
+    if (fs.existsSync(gitignorePath)) {
+        const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
+        if (!gitignore.includes('.kustom/')) {
+            fs.appendFileSync(gitignorePath, '\n# Kustom SDK cache\n.kustom/\n');
+            if (verbose) {
+                console.log(chalk.gray('Added .kustom/ to .gitignore'));
+            }
+        }
+    }
+}
+export const prepareCommand = new Command('prepare')
+    .description('Generate TypeScript definitions from project structure and fetch dependency types')
+    .option('-v, --verbose', 'Show detailed output')
+    .option('--skip-server', 'Skip fetching types from server')
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    console.log('Preparing project types...');
+    await prepare(projectDir, options);
+    console.log('\nTypes generated in dist/types/');
+    const config = loadConfig(projectDir);
+    if (config.dependencies && config.dependencies.length > 0) {
+        console.log('Dependency types in .kustom/types/');
+    }
+});

package/dist/commands/push.d.ts

@@ -0,0 +1,9 @@
+import { Command } from 'commander';
+/**
+ * Push command - bundle and upload pack to server.
+ *
+ * Usage:
+ *   npx kustom-mc push              # Push to configured server
+ *   npx kustom-mc push --server <url>  # Push to specific server
+ */
+export declare const pushCommand: Command;

package/dist/commands/push.js

@@ -0,0 +1,205 @@
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { glob } from 'glob';
+import archiver from 'archiver';
+import { loadConfig, generateManifest, validateManifest } from '../config.js';
+import { getServerToken, normalizeServerUrl, getServerCredential } from '../credentials.js';
+/**
+ * Create a zip bundle in memory and return as Buffer.
+ */
+async function createBundle(projectDir) {
+    const config = loadConfig(projectDir);
+    // Validate manifest
+    const errors = validateManifest(config);
+    if (errors.length > 0) {
+        throw new Error(`Manifest validation failed:\n  ${errors.join('\n  ')}`);
+    }
+    const packId = config.manifest?.id || 'kustompack';
+    const version = config.manifest?.version || '1.0.0';
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        const archive = archiver('zip', { zlib: { level: 9 } });
+        archive.on('data', (chunk) => chunks.push(chunk));
+        archive.on('end', () => resolve({
+            buffer: Buffer.concat(chunks),
+            packId,
+            version
+        }));
+        archive.on('error', reject);
+        // Generate and add manifest
+        const manifestContent = generateManifest(config);
+        archive.append(manifestContent, { name: 'kustompack.json' });
+        // Add files based on bundle config
+        const includePatterns = config.bundle?.include || [
+            '**/*.js',
+            'textures/**/*',
+            'gui/**/*',
+            'models/**/*',
+            'sounds/**/*'
+        ];
+        const addFiles = async () => {
+            const addedFiles = new Set();
+            for (const pattern of includePatterns) {
+                const files = await glob(pattern, {
+                    cwd: projectDir,
+                    nodir: true,
+                    ignore: ['node_modules/**', 'dist/**', '*.ts', 'kustompack.json']
+                });
+                for (const file of files) {
+                    if (addedFiles.has(file))
+                        continue;
+                    const filePath = path.resolve(projectDir, file);
+                    if (fs.existsSync(filePath)) {
+                        archive.file(filePath, { name: file });
+                        addedFiles.add(file);
+                    }
+                }
+            }
+            archive.finalize();
+        };
+        addFiles().catch(reject);
+    });
+}
+/**
+ * Upload a pack to the server.
+ *
+ * Currently sends raw zip bytes for simplicity and performance.
+ *
+ * TODO: If a web UI is added later, consider supporting multipart/form-data
+ * uploads on the server side (Option 2). This would require:
+ * - Adding multipart parsing to PackRegistryServer.java (Apache Commons FileUpload or manual)
+ * - Keeping raw zip support for CLI (faster)
+ * - Adding multipart support for browser uploads
+ */
+async function uploadPack(serverUrl, token, buffer, packId) {
+    const url = `${normalizeServerUrl(serverUrl)}/packs/upload`;
+    // Send raw zip bytes (faster than multipart, server already supports this)
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/zip',
+            'X-Pack-Id': packId // Optional hint for server
+        },
+        body: buffer
+    });
+    if (response.status === 401) {
+        throw new Error('Authentication failed. Token may be invalid or expired. Run: npx kustom-mc login');
+    }
+    if (response.status === 403) {
+        throw new Error('Permission denied. You may not have upload permissions.');
+    }
+    const result = await response.json();
+    if (!response.ok) {
+        throw new Error(result.error || result.message || `Server returned ${response.status}`);
+    }
+    return result;
+}
+/**
+ * Push command - bundle and upload pack to server.
+ *
+ * Usage:
+ *   npx kustom-mc push              # Push to configured server
+ *   npx kustom-mc push --server <url>  # Push to specific server
+ */
+export const pushCommand = new Command('push')
+    .description('Bundle and upload pack to the connected server')
+    .option('-s, --server <url>', 'Server URL (overrides config)')
+    .option('--dry-run', 'Create bundle but do not upload')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const config = loadConfig(projectDir);
+    // Determine server URL
+    let serverUrl;
+    if (options?.server) {
+        serverUrl = options.server;
+    }
+    else {
+        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 authentication
+    const token = getServerToken(serverUrl);
+    if (!token && !options?.dryRun) {
+        console.error(chalk.red('Error: Not logged in to server'));
+        console.log(`Run: npx kustom-mc login ${serverUrl} <token>`);
+        console.log('Get a token by running /kustom token in-game.');
+        process.exit(1);
+    }
+    const cred = getServerCredential(serverUrl);
+    console.log(chalk.blue('Preparing pack for upload...'));
+    console.log(`  Server: ${serverUrl}`);
+    if (cred?.playerName) {
+        console.log(`  As: ${cred.playerName}`);
+    }
+    console.log();
+    try {
+        // Create bundle
+        console.log('Creating bundle...');
+        const { buffer, packId, version } = await createBundle(projectDir);
+        const sizeKB = (buffer.length / 1024).toFixed(2);
+        console.log(chalk.green(`  Pack: ${packId} v${version}`));
+        console.log(chalk.green(`  Size: ${sizeKB} KB`));
+        if (options?.dryRun) {
+            console.log(chalk.yellow('\n--dry-run: Bundle created but not uploaded.'));
+            // Optionally save the bundle locally
+            const outputPath = path.join(projectDir, 'dist', `${packId}.zip`);
+            const outputDir = path.dirname(outputPath);
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            fs.writeFileSync(outputPath, buffer);
+            console.log(`  Saved to: ${outputPath}`);
+            return;
+        }
+        // Confirmation
+        if (!options?.yes) {
+            console.log(chalk.yellow(`\nThis will upload ${packId} v${version} to ${serverUrl}`));
+            console.log(chalk.yellow('If a pack with this ID exists, it will be replaced.'));
+            // Simple confirmation using readline
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout
+            });
+            const answer = await new Promise((resolve) => {
+                rl.question('Continue? [y/N] ', resolve);
+            });
+            rl.close();
+            if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+                console.log('Cancelled.');
+                process.exit(0);
+            }
+        }
+        // Upload
+        console.log('\nUploading...');
+        const result = await uploadPack(serverUrl, token, buffer, packId);
+        if (result.success) {
+            console.log(chalk.green('\nUpload successful!'));
+            if (result.message) {
+                console.log(`  ${result.message}`);
+            }
+            console.log(`\nPack ${packId} v${version} is now available on the server.`);
+            console.log(chalk.gray('Run /kustom pack reload to apply changes in-game.'));
+        }
+        else {
+            console.error(chalk.red('\nUpload failed'));
+            if (result.error) {
+                console.error(chalk.red(`  ${result.error}`));
+            }
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`\nFailed: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+});

package/dist/commands/validate.d.ts

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