kustom-mc 0.1.0

package/dist/credentials.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Server credentials stored in ~/.kustom/credentials.json
+ */
+export interface ServerCredential {
+    token: string;
+    playerName?: string;
+    savedAt: string;
+}
+/**
+ * Credentials file structure
+ */
+export interface Credentials {
+    servers: {
+        [serverUrl: string]: ServerCredential;
+    };
+}
+/**
+ * Get the path to the credentials file.
+ * ~/.kustom/credentials.json on Unix
+ * %USERPROFILE%\.kustom\credentials.json on Windows
+ */
+export declare function getCredentialsPath(): string;
+/**
+ * Get the path to the .kustom directory in user's home.
+ */
+export declare function getKustomHomeDir(): string;
+/**
+ * Ensure the .kustom directory exists.
+ */
+export declare function ensureKustomDir(): void;
+/**
+ * Load credentials from file.
+ * Returns empty credentials if file doesn't exist.
+ */
+export declare function loadCredentials(): Credentials;
+/**
+ * Save credentials to file.
+ */
+export declare function saveCredentials(creds: Credentials): void;
+/**
+ * Get the token for a server URL.
+ * Returns null if no token is stored.
+ */
+export declare function getServerToken(serverUrl: string): string | null;
+/**
+ * Get the full credentials for a server URL.
+ */
+export declare function getServerCredential(serverUrl: string): ServerCredential | null;
+/**
+ * Save a token for a server URL.
+ */
+export declare function saveServerToken(serverUrl: string, token: string, playerName?: string): void;
+/**
+ * Remove credentials for a server URL.
+ */
+export declare function removeServerCredential(serverUrl: string): boolean;
+/**
+ * List all stored server URLs.
+ */
+export declare function listStoredServers(): string[];
+/**
+ * Normalize a server URL for consistent storage.
+ * Removes trailing slashes, ensures protocol.
+ */
+export declare function normalizeServerUrl(url: string): string;

package/dist/credentials.js

@@ -0,0 +1,136 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+/**
+ * Get the path to the credentials file.
+ * ~/.kustom/credentials.json on Unix
+ * %USERPROFILE%\.kustom\credentials.json on Windows
+ */
+export function getCredentialsPath() {
+    const homeDir = os.homedir();
+    return path.join(homeDir, '.kustom', 'credentials.json');
+}
+/**
+ * Get the path to the .kustom directory in user's home.
+ */
+export function getKustomHomeDir() {
+    return path.join(os.homedir(), '.kustom');
+}
+/**
+ * Ensure the .kustom directory exists.
+ */
+export function ensureKustomDir() {
+    const dir = getKustomHomeDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+/**
+ * Load credentials from file.
+ * Returns empty credentials if file doesn't exist.
+ */
+export function loadCredentials() {
+    const credPath = getCredentialsPath();
+    if (!fs.existsSync(credPath)) {
+        return { servers: {} };
+    }
+    try {
+        const content = fs.readFileSync(credPath, 'utf-8');
+        const creds = JSON.parse(content);
+        // Ensure servers object exists
+        if (!creds.servers) {
+            creds.servers = {};
+        }
+        return creds;
+    }
+    catch (error) {
+        console.warn(`Warning: Could not parse credentials file: ${error}`);
+        return { servers: {} };
+    }
+}
+/**
+ * Save credentials to file.
+ */
+export function saveCredentials(creds) {
+    ensureKustomDir();
+    const credPath = getCredentialsPath();
+    const content = JSON.stringify(creds, null, 2);
+    fs.writeFileSync(credPath, content, 'utf-8');
+    // Set restrictive permissions on Unix systems
+    if (process.platform !== 'win32') {
+        try {
+            fs.chmodSync(credPath, 0o600);
+        }
+        catch {
+            // Ignore permission errors
+        }
+    }
+}
+/**
+ * Get the token for a server URL.
+ * Returns null if no token is stored.
+ */
+export function getServerToken(serverUrl) {
+    const creds = loadCredentials();
+    const normalizedUrl = normalizeServerUrl(serverUrl);
+    const serverCred = creds.servers[normalizedUrl];
+    if (!serverCred) {
+        return null;
+    }
+    return serverCred.token;
+}
+/**
+ * Get the full credentials for a server URL.
+ */
+export function getServerCredential(serverUrl) {
+    const creds = loadCredentials();
+    const normalizedUrl = normalizeServerUrl(serverUrl);
+    return creds.servers[normalizedUrl] || null;
+}
+/**
+ * Save a token for a server URL.
+ */
+export function saveServerToken(serverUrl, token, playerName) {
+    const creds = loadCredentials();
+    const normalizedUrl = normalizeServerUrl(serverUrl);
+    creds.servers[normalizedUrl] = {
+        token,
+        playerName,
+        savedAt: new Date().toISOString()
+    };
+    saveCredentials(creds);
+}
+/**
+ * Remove credentials for a server URL.
+ */
+export function removeServerCredential(serverUrl) {
+    const creds = loadCredentials();
+    const normalizedUrl = normalizeServerUrl(serverUrl);
+    if (creds.servers[normalizedUrl]) {
+        delete creds.servers[normalizedUrl];
+        saveCredentials(creds);
+        return true;
+    }
+    return false;
+}
+/**
+ * List all stored server URLs.
+ */
+export function listStoredServers() {
+    const creds = loadCredentials();
+    return Object.keys(creds.servers);
+}
+/**
+ * Normalize a server URL for consistent storage.
+ * Removes trailing slashes, ensures protocol.
+ */
+export function normalizeServerUrl(url) {
+    let normalized = url.trim();
+    // Add http:// if no protocol
+    if (!normalized.startsWith('http://') && !normalized.startsWith('https://')) {
+        normalized = 'http://' + normalized;
+    }
+    // Remove trailing slash
+    normalized = normalized.replace(/\/+$/, '');
+    return normalized;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { initCommand } from './commands/init.js';
+import { buildCommand } from './commands/build.js';
+import { bundleCommand } from './commands/bundle.js';
+import { validateCommand } from './commands/validate.js';
+import { newCommand } from './commands/new.js';
+import { prepareCommand } from './commands/prepare.js';
+import { loginCommand } from './commands/login.js';
+import { listCommand } from './commands/list.js';
+import { pushCommand } from './commands/push.js';
+const program = new Command();
+program
+    .name('kustom')
+    .description('CLI for kustompack development with TypeScript support')
+    .version('0.1.0');
+// Build commands
+program.addCommand(initCommand);
+program.addCommand(buildCommand);
+program.addCommand(bundleCommand);
+program.addCommand(validateCommand);
+program.addCommand(newCommand);
+program.addCommand(prepareCommand);
+// Registry commands
+program.addCommand(loginCommand);
+program.addCommand(listCommand);
+program.addCommand(pushCommand);
+program.parse();

package/dist/runtime.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Runtime exports for kustom-mc.
+ * These are used at compile time for type checking and at runtime (after build)
+ * for structure.
+ *
+ * Note: The define* functions are no-op passthroughs - they exist only for
+ * type safety during development. At build time, they are transformed to
+ * plain objects with __type property injected.
+ */
+import './types/globals.js';
+import type { ScriptConfig, ExportedScript, PropSchema, EventSchema, EmptyEventSchema, BlockConfig, BlockDefinition, ItemConfig, ItemDefinition, ScreenConstructor, ContainerConstructor, ElementFactory, ScriptableLocationFactory, PropsAPI, CellStateUtils } from './types/index.js';
+/**
+ * Screen constructor - create new screens for GUIs.
+ * Actual value is injected by Java at runtime.
+ * Build system strips imports, resolving to Java-injected global.
+ */
+export declare const Screen: ScreenConstructor;
+/**
+ * Container constructor - create child containers within screens.
+ * Actual value is injected by Java at runtime.
+ */
+export declare const Container: ContainerConstructor;
+/**
+ * Element factory - create GUI elements (buttons, items, slots, covers).
+ * Actual value is injected by Java at runtime.
+ */
+export declare const Element: ElementFactory;
+/**
+ * Props factory - create property type definitions for scripts.
+ * Actual value is injected by Java at runtime.
+ */
+export declare const Props: PropsAPI;
+/**
+ * CellState utility - slot state management constants and helpers.
+ * Actual value is injected by Java at runtime.
+ */
+export declare const CellState: CellStateUtils;
+/**
+ * ScriptableLocation factory - create location objects.
+ * Actual value is injected by Java at runtime.
+ */
+export declare const ScriptableLocation: ScriptableLocationFactory;
+/**
+ * Define a kustom script with type safety.
+ *
+ * This is a type-only helper that returns its input unchanged.
+ * The Java ProcessManager extracts the `run` function and calls it
+ * with the ScriptContext.
+ *
+ * @example
+ * import { defineScript, Props } from 'kustom-mc';
+ *
+ * export default defineScript({
+ *   props: {
+ *     player: Props.String(),
+ *     message: Props.String("Hello!"),
+ *   },
+ *   events: {
+ *     onSuccess: Props.Boolean(),
+ *     onError: Props.String(),
+ *   },
+ *   run({ process, props }) {
+ *     const player = process.getPlayer(props.player);
+ *     player.sendMessage(props.message);
+ *     process.emit("onSuccess", true);  // Typed!
+ *   }
+ * });
+ */
+export declare function defineScript<P extends PropSchema = Record<string, never>, E extends EventSchema = EmptyEventSchema>(config: ScriptConfig<P, E>): ExportedScript<P, E>;
+/**
+ * Define a custom block with type safety.
+ *
+ * Blocks are registered with the ShaperRegistry and can have collision,
+ * auto-place items, and event handlers.
+ *
+ * @example
+ * import { defineBlock } from 'kustom-mc';
+ *
+ * export default defineBlock({
+ *   id: "tower",
+ *   model: "kustom:block/tower",
+ *   collision: "full",
+ *   autoPlace: true,
+ *
+ *   onClick(event) {
+ *     event.player.sendMessage("You clicked the tower!");
+ *   },
+ *
+ *   onBreak(event) {
+ *     event.player.sendMessage("Tower destroyed!");
+ *   }
+ * });
+ */
+export declare function defineBlock(config: BlockConfig): BlockDefinition;
+/**
+ * Define a custom item with type safety.
+ *
+ * Items are registered with the CustomItemRegistry and can have
+ * custom models, display names, and event handlers.
+ *
+ * @example
+ * import { defineItem } from 'kustom-mc';
+ *
+ * export default defineItem({
+ *   id: "magic_wand",
+ *   material: "STICK",
+ *   model: "kustom:item/magic_wand",
+ *   displayName: "<gold>Magic Wand",
+ *
+ *   onRightClick(event) {
+ *     event.player.sendMessage("Zap!");
+ *   }
+ * });
+ */
+export declare function defineItem(config: ItemConfig): ItemDefinition;
+export type { ScriptConfig, ScriptDefinition, ExportedScript, ScriptContext, PropSchema, PropAPI, InferProps, PropsAPI, EventSchema, EmptyEventSchema, InferEventPayload, ScriptModule, ScriptProcess, TypedScriptProcess, InferScriptModule, McModuleAPI, TypedMcModuleAPI, ProcessExecutorAPI, CameraAPI, SessionAPI, ChatGUIAPI, CommandManager, BetterModelEntityAPI, ShaperAPI, ItemAPI, DefinitionBuilder, ScriptablePlayer, BlockConfig, BlockDefinition, BlockClickEvent, BlockBreakEvent, BlockPlaceEvent, ItemConfig, ItemDefinition, ScreenConstructor, ContainerConstructor, ElementFactory, ScriptableLocationFactory, CellStateUtils, } from './types/index.js';

package/dist/runtime.js

@@ -0,0 +1,96 @@
+/**
+ * Runtime exports for kustom-mc.
+ * These are used at compile time for type checking and at runtime (after build)
+ * for structure.
+ *
+ * Note: The define* functions are no-op passthroughs - they exist only for
+ * type safety during development. At build time, they are transformed to
+ * plain objects with __type property injected.
+ */
+// Import globals for side effects - makes console, setTimeout, etc. available
+import './types/globals.js';
+/**
+ * Define a kustom script with type safety.
+ *
+ * This is a type-only helper that returns its input unchanged.
+ * The Java ProcessManager extracts the `run` function and calls it
+ * with the ScriptContext.
+ *
+ * @example
+ * import { defineScript, Props } from 'kustom-mc';
+ *
+ * export default defineScript({
+ *   props: {
+ *     player: Props.String(),
+ *     message: Props.String("Hello!"),
+ *   },
+ *   events: {
+ *     onSuccess: Props.Boolean(),
+ *     onError: Props.String(),
+ *   },
+ *   run({ process, props }) {
+ *     const player = process.getPlayer(props.player);
+ *     player.sendMessage(props.message);
+ *     process.emit("onSuccess", true);  // Typed!
+ *   }
+ * });
+ */
+export function defineScript(config) {
+    // Simply return the config - the Java side will handle execution
+    // The return type is ExportedScript which combines:
+    // - Definition metadata (props, events, __type) for the Java runtime
+    // - ScriptModule interface with .run(props) method for TypeScript imports
+    return config;
+}
+/**
+ * Define a custom block with type safety.
+ *
+ * Blocks are registered with the ShaperRegistry and can have collision,
+ * auto-place items, and event handlers.
+ *
+ * @example
+ * import { defineBlock } from 'kustom-mc';
+ *
+ * export default defineBlock({
+ *   id: "tower",
+ *   model: "kustom:block/tower",
+ *   collision: "full",
+ *   autoPlace: true,
+ *
+ *   onClick(event) {
+ *     event.player.sendMessage("You clicked the tower!");
+ *   },
+ *
+ *   onBreak(event) {
+ *     event.player.sendMessage("Tower destroyed!");
+ *   }
+ * });
+ */
+export function defineBlock(config) {
+    // Simply return the config - the Java side will handle registration
+    return config;
+}
+/**
+ * Define a custom item with type safety.
+ *
+ * Items are registered with the CustomItemRegistry and can have
+ * custom models, display names, and event handlers.
+ *
+ * @example
+ * import { defineItem } from 'kustom-mc';
+ *
+ * export default defineItem({
+ *   id: "magic_wand",
+ *   material: "STICK",
+ *   model: "kustom:item/magic_wand",
+ *   displayName: "<gold>Magic Wand",
+ *
+ *   onRightClick(event) {
+ *     event.player.sendMessage("Zap!");
+ *   }
+ * });
+ */
+export function defineItem(config) {
+    // Simply return the config - the Java side will handle registration
+    return config;
+}

package/dist/types/globals.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Global type declarations for the Rhino JavaScript runtime.
+ * These types are available in all kustom scripts without needing to import them.
+ *
+ * Note: This file provides minimal declarations that don't conflict with @types/node or DOM libs.
+ *
+ * The playSound() function is declared in dist/types/index.d.ts generated by `kustom prepare`,
+ * which provides project-specific sound autocomplete.
+ */
+declare global {
+    interface Console {
+        /** Log a message to the server console */
+        log(...data: unknown[]): void;
+        /** Log a warning message */
+        warn(...data: unknown[]): void;
+        /** Log an error message */
+        error(...data: unknown[]): void;
+        /** Log an info message */
+        info(...data: unknown[]): void;
+        /** Log a debug message */
+        debug(...data: unknown[]): void;
+    }
+    var console: Console;
+    /**
+     * Schedule a function to run after a delay.
+     * @param handler Function to call
+     * @param timeout Delay in milliseconds
+     * @returns Timer ID that can be passed to clearTimeout
+     */
+    function setTimeout(handler: () => void, timeout?: number): number;
+    /**
+     * Cancel a timeout previously scheduled with setTimeout.
+     * @param id Timer ID returned by setTimeout
+     */
+    function clearTimeout(id: number | undefined): void;
+    /**
+     * Schedule a function to run repeatedly at a fixed interval.
+     * @param handler Function to call
+     * @param timeout Interval in milliseconds
+     * @returns Timer ID that can be passed to clearInterval
+     */
+    function setInterval(handler: () => void, timeout?: number): number;
+    /**
+     * Cancel an interval previously scheduled with setInterval.
+     * @param id Timer ID returned by setInterval
+     */
+    function clearInterval(id: number | undefined): void;
+    /**
+     * Returns a Promise that resolves after the specified delay.
+     * Use with async/await for readable delays in scripts.
+     *
+     * @param ms Delay in milliseconds
+     * @returns Promise that resolves after the delay
+     *
+     * @example
+     * ```typescript
+     * async function run() {
+     *   console.log("Starting...");
+     *   await delay(1000); // Wait 1 second
+     *   console.log("Done!");
+     * }
+     * ```
+     */
+    function delay(ms: number): Promise<void>;
+    /**
+     * Stop all sounds.
+     *
+     * @param target Optional - if provided, stops all sounds for that player.
+     *               If omitted, stops all sounds started by this script.
+     *
+     * @example
+     * // Stop all sounds from this script
+     * stopAllSounds();
+     *
+     * // Stop all sounds for a specific player
+     * stopAllSounds(player);
+     */
+    function stopAllSounds(target?: unknown): void;
+}
+export {};

package/dist/types/globals.js

@@ -0,0 +1,10 @@
+/**
+ * Global type declarations for the Rhino JavaScript runtime.
+ * These types are available in all kustom scripts without needing to import them.
+ *
+ * Note: This file provides minimal declarations that don't conflict with @types/node or DOM libs.
+ *
+ * The playSound() function is declared in dist/types/index.d.ts generated by `kustom prepare`,
+ * which provides project-specific sound autocomplete.
+ */
+export {};