sandstone-cli 2.0.8 → 2.1.0

package/lib/commands/build.js

@@ -1,664 +0,0 @@
-import path from 'node:path';
-import os from 'node:os';
-import crypto from 'node:crypto';
-import { pathToFileURL } from 'node:url';
-import fs from 'fs-extra';
-import chalk from 'chalk';
-import AdmZip from 'adm-zip';
-import { log, logInfo, logWarn, logError as logErrorFn, logDebug, logTrace, initLoggerNoFile, setSilent } from '../ui/logger.js';
-import { canUseSymlinks } from '../utils.js';
-import { split } from 'obliterator';
-// Console capture for watch mode - wraps console to redirect output to our log file
-const originalConsole = globalThis.console;
-let consoleWrapped = false;
-export function enableConsoleCapture() {
-    if (consoleWrapped)
-        return;
-    consoleWrapped = true;
-    globalThis.console.log = (...args) => log(...args);
-    globalThis.console.info = (...args) => logInfo(...args);
-    globalThis.console.warn = (...args) => logWarn(...args);
-    globalThis.console.error = (...args) => logErrorFn(args.join(' '));
-    globalThis.console.debug = (...args) => logDebug(...args);
-    globalThis.console.trace = (...args) => {
-        const traceObj = { stack: '' };
-        Error.captureStackTrace(traceObj, globalThis.console.trace);
-        const cleanedStack = traceObj.stack
-            .replace(/^Error\n/, '') // Remove "Error" header line
-            .replace(/\?hot-hook=\d+/g, '')
-            .replace(/file:\/\/\/?/g, '');
-        logTrace(...args, '\n' + cleanedStack);
-    };
-}
-export function disableConsoleCapture() {
-    if (!consoleWrapped)
-        return;
-    consoleWrapped = false;
-    // Restore original methods
-    const methodsToRestore = ['log', 'info', 'warn', 'error', 'debug', 'trace'];
-    for (const method of methodsToRestore) {
-        ;
-        globalThis.console[method] = originalConsole[method].bind(originalConsole);
-    }
-}
-function hash(stringToHash) {
-    return crypto.createHash('md5').update(stringToHash).digest('hex');
-}
-let cache;
-let symlinksAvailable;
-async function getClientPath() {
-    function getMCPath() {
-        switch (os.platform()) {
-            case 'win32':
-                return path.join(os.homedir(), 'AppData/Roaming/.minecraft');
-            case 'darwin':
-                return path.join(os.homedir(), 'Library/Application Support/minecraft');
-            case 'linux':
-            default:
-                return path.join(os.homedir(), '.minecraft');
-        }
-    }
-    const mcPath = getMCPath();
-    try {
-        await fs.stat(mcPath);
-    }
-    catch {
-        log('Unable to locate the .minecraft folder. Will not be able to export to client.');
-        return undefined;
-    }
-    return mcPath;
-}
-async function getClientWorldPath(worldName, minecraftPath) {
-    const mcPath = minecraftPath ?? (await getClientPath());
-    const savesPath = path.join(mcPath, 'saves');
-    const worldPath = path.join(savesPath, worldName);
-    if (!fs.existsSync(worldPath)) {
-        const existingWorlds = (await fs.readdir(savesPath, { withFileTypes: true }))
-            .filter((f) => f.isDirectory())
-            .map((f) => f.name);
-        throw new Error(`Unable to locate the "${worldPath}" folder. World ${worldName} does not exist. List of existing worlds: ${JSON.stringify(existingWorlds, null, 2)}`);
-    }
-    return worldPath;
-}
-// Boilerplate resources to exclude from counts
-const BOILERPLATE_NAMESPACES = new Set(['load', '__sandstone__']);
-const BOILERPLATE_FUNCTIONS = new Set(['__init__']);
-const BOILERPLATE_TAG = { namespace: 'minecraft', name: 'load' };
-function isBoilerplateResource(resource) {
-    const ns = resource.namespace || '';
-    const pathParts = resource.path || [];
-    const name = pathParts[pathParts.length - 1] || '';
-    // Exclude load namespace and __sandstone__ namespace
-    if (BOILERPLATE_NAMESPACES.has(ns))
-        return true;
-    // Exclude __init__ functions
-    if (BOILERPLATE_FUNCTIONS.has(name))
-        return true;
-    if (ns === BOILERPLATE_TAG.namespace && name === BOILERPLATE_TAG.name)
-        return true;
-    return false;
-}
-function countResources(sandstonePack) {
-    let functions = 0;
-    let other = 0;
-    for (const node of sandstonePack.core.resourceNodes) {
-        const resource = node.resource;
-        // Skip boilerplate resources
-        if (isBoilerplateResource(resource))
-            continue;
-        // Check if it's a function (MCFunctionClass)
-        if (resource.constructor?.name === '_RawMCFunctionClass') {
-            functions++;
-        }
-        else {
-            other++;
-        }
-    }
-    return { functions, other };
-}
-function splitPath(split) {
-    let parts = [];
-    let current = split;
-    while (current !== 'C:') {
-        let dirname = path.dirname(current);
-        if (dirname.endsWith('\\')) {
-            dirname = dirname.slice(0, -1);
-        }
-        parts.unshift(current.replace(`${dirname}${path.sep}`, ''));
-        current = dirname;
-    }
-    parts.unshift('C:');
-    return parts;
-}
-async function handleSymlink(folder, packName, cache, minecraftPath, targetPath, linkPath) {
-    let rawPath = path.resolve(path.join(folder));
-    let sep = path.sep;
-    if (os.platform() === 'win32') {
-        sep = `${path.sep}${path.sep}`;
-        rawPath = splitPath(rawPath).join(sep);
-    }
-    const allowPath = `[glob]${rawPath}${sep}**${sep}*`;
-    const allowedList = path.join(minecraftPath, 'allowed_symlinks.txt');
-    const comment = `# Sandstone Pack: ${packName}\n`;
-    try {
-        const currentlyAllowed = await fs.readFile(allowedList, 'utf-8');
-        if (!currentlyAllowed.includes(allowPath)) {
-            log('[handleSymlink] Adding workspace to allowed_symlinks.txt at minecraft path. If the game is running please restart it.');
-            await fs.writeFile(allowedList, `${currentlyAllowed}\n#\n${comment}${allowPath}`);
-        }
-        else {
-            log('[handleSymlink] Workspace is already in allowed_symlinks.txt at minecraft path, skipping...');
-        }
-    }
-    catch (e) {
-        log('[handleSymlink] Creating allowed_symlinks.txt at minecraft path. If the game is running please restart it.');
-        await fs.writeFile(allowedList, `${comment}${allowPath}`);
-    }
-    let skip = false;
-    let errored = false;
-    try {
-        const stats = await fs.lstat(linkPath);
-        if (stats.isSymbolicLink() && await fs.readlink(linkPath) === path.resolve(targetPath)) {
-            log('[handleSymlink] Symlink already created, skipping...');
-            skip = true;
-        }
-        else {
-            errored = true;
-        }
-    }
-    catch { }
-    if (errored) {
-        throw new Error(`Tried to add a symlink at "${linkPath}",\n encountered an existing FS entry.`);
-    }
-    if (!skip) {
-        log(`[handleSymlink] Creating symlink for ${targetPath.replace(`${path.dirname(targetPath)}${path.sep}`, '')}`);
-        await fs.symlink(path.resolve(targetPath), linkPath);
-    }
-    cache.symlinks ??= [];
-    cache.symlinks.push(linkPath);
-}
-export async function loadBuildContext(cliOptions, folder) {
-    // Load sandstone.config.ts
-    const configPath = path.join(folder, 'sandstone.config.ts');
-    const configUrl = pathToFileURL(configPath).toString();
-    const sandstoneConfig = (await import(configUrl)).default;
-    // Build the context for sandstone
-    const namespace = cliOptions.namespace || sandstoneConfig.namespace;
-    const conflictStrategies = {};
-    if (sandstoneConfig.onConflict) {
-        for (const [resource, strategy] of Object.entries(sandstoneConfig.onConflict)) {
-            conflictStrategies[resource] = strategy;
-        }
-    }
-    // Import sandstone from the project's node_modules, not the CLI's
-    // This ensures we use the same module instance as the user code
-    const sandstoneUrl = pathToFileURL(path.join(folder, 'node_modules', 'sandstone', 'dist', 'index.js'));
-    /* @ts-ignore */
-    const { createSandstonePack, resetSandstonePack } = (await import(sandstoneUrl));
-    const context = {
-        workingDir: folder,
-        namespace,
-        packUid: sandstoneConfig.packUid,
-        packOptions: sandstoneConfig.packs,
-        conflictStrategies,
-        loadVersion: sandstoneConfig.loadVersion,
-    };
-    // Create the pack with context
-    const sandstonePack = createSandstonePack(context);
-    return { sandstoneConfig, sandstonePack, resetSandstonePack };
-}
-async function _buildProject(cliOptions, folder, silent = false, existingContext, watching = false) {
-    // Read project package.json to get entrypoint
-    const packageJsonPath = path.join(folder, 'package.json');
-    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
-    // Get the entrypoint from the "module" field
-    const entrypoint = packageJson.module;
-    if (!entrypoint) {
-        throw new Error('No "module" field found in package.json. Please specify the entrypoint for your pack code.');
-    }
-    const entrypointPath = path.join(folder, entrypoint);
-    // Load or use existing context
-    const { sandstoneConfig, sandstonePack, resetSandstonePack } = existingContext ??
-        await loadBuildContext(cliOptions, folder);
-    // Reset pack state before each build
-    resetSandstonePack();
-    const { scripts, resources } = sandstoneConfig;
-    const saveOptions = sandstoneConfig.saveOptions || {};
-    const outputFolder = path.join(folder, '.sandstone', 'output');
-    // Resolve options
-    const worldName = cliOptions.world || saveOptions.world;
-    const root = cliOptions.root !== undefined ? cliOptions.root : saveOptions.root;
-    // Only use explicitly configured client path for now
-    // We'll auto-detect after save() if there are client-side packs that need exporting
-    let clientPath = !cliOptions.production
-        ? cliOptions.clientPath || saveOptions.clientPath
-        : undefined;
-    if (worldName && !cliOptions.production) {
-        // Need client path for world export
-        clientPath ??= await getClientPath();
-        if (clientPath) {
-            await getClientWorldPath(worldName, clientPath);
-        }
-    }
-    else if (root && !cliOptions.production) {
-        // Need client path for root export
-        clientPath ??= await getClientPath();
-    }
-    const serverPath = !cliOptions.production
-        ? cliOptions.serverPath || saveOptions.serverPath
-        : undefined;
-    const packName = cliOptions.name ?? sandstoneConfig.name;
-    if (worldName && root) {
-        throw new Error("Expected only 'world' or 'root'. Got both.");
-    }
-    // Run beforeAll script
-    await scripts?.beforeAll?.();
-    // Import user code (this executes their pack definitions)
-    if (!silent) {
-        log('Compiling source...');
-    }
-    try {
-        if (await fs.pathExists(entrypointPath)) {
-            const isBun = Object.hasOwn(globalThis, 'Bun');
-            const entrypointUrl = pathToFileURL(entrypointPath).toString();
-            if (watching && !isBun) {
-                // Hot-hook for Node.js - only this should be hot reloaded
-                // Bun doesn't support hot-hook, we clear require.cache instead in watch.ts
-                await import(entrypointUrl, { with: { hot: 'true' } });
-            }
-            else {
-                await import(entrypointUrl);
-            }
-        }
-    }
-    catch (e) {
-        const errorMsg = `While loading "${entrypointPath}":\n${cliOptions.fullTrace ? e : (e.message || e)}`;
-        if (!silent) {
-            console.error(chalk.bgRed.white('BuildError') + chalk.gray(':'), errorMsg);
-        }
-        log('BuildError:', errorMsg);
-        throw e; // Re-throw for buildCommand to handle
-    }
-    // Add dependencies if specified
-    if (cliOptions.dependencies) {
-        for (const dependency of cliOptions.dependencies) {
-            sandstonePack.core.depend(...dependency);
-        }
-    }
-    // Setup cache
-    const newCache = { files: {}, archives: [] };
-    const cacheFile = path.join(folder, '.sandstone', 'cache.json');
-    // Track which pack types have changed files
-    const changedPackTypes = new Set();
-    // Track directories containing new files
-    const newDirs = new Set();
-    if (cache === undefined) {
-        try {
-            const fileRead = await fs.readFile(cacheFile, 'utf8');
-            if (fileRead) {
-                const parsed = JSON.parse(fileRead);
-                // Handle legacy cache format (plain Record<string, string>)
-                if (parsed.files) {
-                    cache = parsed;
-                }
-                else {
-                    cache = { files: parsed };
-                }
-            }
-        }
-        catch {
-            cache = { files: {} };
-        }
-    }
-    // Check symlink availability (use cached value if available)
-    if (symlinksAvailable === undefined) {
-        if (cache.canUseSymlinks !== undefined) {
-            symlinksAvailable = cache.canUseSymlinks;
-        }
-        else {
-            symlinksAvailable = await canUseSymlinks();
-        }
-    }
-    newCache.canUseSymlinks = symlinksAvailable;
-    // Run beforeSave script
-    await scripts?.beforeSave?.();
-    // File exclusion setup
-    const excludeOption = resources?.exclude;
-    const fileExclusions = excludeOption
-        ? {
-            generated: ('generated' in excludeOption ? excludeOption.generated : excludeOption),
-            existing: ('existing' in excludeOption ? excludeOption.existing : excludeOption),
-        }
-        : false;
-    const fileHandlers = resources?.handle || false;
-    // Save the pack
-    const packTypes = await sandstonePack.save({
-        dry: cliOptions.dry ?? false,
-        verbose: cliOptions.verbose ?? false,
-        fileHandler: saveOptions.customFileHandler ??
-            (async (relativePath, content) => {
-                let pathPass = true;
-                if (fileExclusions && fileExclusions.generated) {
-                    for (const exclude of fileExclusions.generated) {
-                        if (!Array.isArray(exclude)) {
-                            pathPass = !exclude.test(relativePath);
-                        }
-                    }
-                }
-                if (fileHandlers) {
-                    for (const handler of fileHandlers) {
-                        if (handler.path.test(relativePath)) {
-                            content = await handler.callback(content);
-                        }
-                    }
-                }
-                if (pathPass) {
-                    const hashValue = hash(content + relativePath);
-                    newCache.files[relativePath] = hashValue;
-                    // Track parent directories
-                    for (let dir = path.dirname(relativePath); dir && dir !== '.'; dir = path.dirname(dir)) {
-                        newDirs.add(dir);
-                    }
-                    if (cache.files[relativePath] === hashValue) {
-                        return;
-                    }
-                    // Track that this pack type has changed
-                    const packTypeDir = relativePath.split(/[/\\]/)[0];
-                    changedPackTypes.add(packTypeDir);
-                    const realPath = path.join(outputFolder, relativePath);
-                    await fs.ensureDir(path.dirname(realPath));
-                    return await fs.writeFile(realPath, content);
-                }
-            }),
-    });
-    // Handle resources folder
-    async function handleResources(packType) {
-        const working = path.join(folder, 'resources', packType);
-        if (!(await fs.pathExists(working))) {
-            return;
-        }
-        const walk = async (dir) => {
-            const files = [];
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    files.push(...(await walk(fullPath)));
-                }
-                else {
-                    files.push(fullPath);
-                }
-            }
-            return files;
-        };
-        for (const file of await walk(working)) {
-            const relativePath = path.join(packType, file.substring(working.length + 1));
-            let pathPass = true;
-            if (fileExclusions && fileExclusions.existing) {
-                for (const exclude of fileExclusions.existing) {
-                    pathPass = Array.isArray(exclude) ? !exclude[0].test(relativePath) : !exclude.test(relativePath);
-                }
-            }
-            if (!pathPass)
-                continue;
-            try {
-                let content = await fs.readFile(file);
-                if (fileHandlers) {
-                    for (const handler of fileHandlers) {
-                        if (handler.path.test(relativePath)) {
-                            content = (await handler.callback(content));
-                        }
-                    }
-                }
-                const hashValue = hash(content + relativePath);
-                newCache.files[relativePath] = hashValue;
-                for (let dir = path.dirname(relativePath); dir && dir !== '.'; dir = path.dirname(dir)) {
-                    if (newDirs.has(dir)) {
-                        break;
-                    }
-                    else {
-                        newDirs.add(dir);
-                    }
-                }
-                if (cache.files[relativePath] !== hashValue) {
-                    // Track that this pack type has changed
-                    changedPackTypes.add(packType);
-                    const realPath = path.join(outputFolder, relativePath);
-                    await fs.ensureDir(path.dirname(realPath));
-                    await fs.writeFile(realPath, content);
-                }
-            }
-            catch { }
-        }
-    }
-    // Archive output if needed
-    async function archiveOutput(packType) {
-        const input = path.join(outputFolder, packType.type);
-        const files = await fs.readdir(input).catch(() => []);
-        if (files.length === 0)
-            return false;
-        const archiveName = `${packName}_${packType.type}.zip`;
-        newCache.archives.push(archiveName);
-        const archive = new AdmZip();
-        await archive.addLocalFolderPromise(input, {});
-        await fs.ensureDir(path.join(outputFolder, 'archives'));
-        await archive.writeZipPromise(path.join(outputFolder, 'archives', archiveName), { overwrite: true });
-        return true;
-    }
-    // Export to client/server
-    if (!cliOptions.production) {
-        // Check if there are any client-side packs that need exporting
-        // If so and clientPath not set, try to find it now (after dependencies resolved)
-        const packTypesArray = [...packTypes];
-        const hasClientPacks = packTypesArray.some(([, pt]) => pt.networkSides === 'client');
-        if (hasClientPacks && !clientPath && (root || worldName)) {
-            clientPath = await getClientPath();
-        }
-        // When no world/root specified, only export client-side packs (resource packs + dependencies)
-        const resourcePackOnlyExport = !worldName && !root;
-        for (const [, packType] of packTypesArray) {
-            const outputPath = path.join(outputFolder, packType.type);
-            await fs.ensureDir(outputPath);
-            if (packType.handleOutput) {
-                await packType.handleOutput('output', (async (relativePath, encoding = 'utf8') => await fs.readFile(path.join(outputPath, relativePath), encoding)), async (relativePath, contents) => {
-                    if (contents === undefined) {
-                        await fs.unlink(path.join(outputPath, relativePath));
-                    }
-                    else {
-                        await fs.writeFile(path.join(outputPath, relativePath), contents.replaceAll('"min_version"', '"min_format"').replace('"max_version"', '"max_format"'));
-                    }
-                });
-            }
-            await handleResources(packType.type);
-            // Skip archive and export if no files in this pack type changed
-            if (!changedPackTypes.has(packType.type)) {
-                continue;
-            }
-            let archivedOutput = false;
-            if (packType.archiveOutput && saveOptions.exportZips) {
-                archivedOutput = await archiveOutput(packType);
-            }
-            // Handle client export
-            // Skip non-client packs (datapacks) when in resource pack only mode (no world/root specified)
-            if (clientPath && !(resourcePackOnlyExport && packType.networkSides !== 'client')) {
-                let fullClientPath;
-                // Only export the resource pack to `$worldName$/resources.zip` if exportZips is on
-                if (worldName && (packType.type !== 'resourcepack' || saveOptions.exportZips)) {
-                    fullClientPath = path.join(clientPath, packType.clientPath)
-                        .replace('$packName$', packName)
-                        .replace('$worldName$', worldName);
-                }
-                else {
-                    fullClientPath = path.join(clientPath, packType.rootPath).replace('$packName$', packName);
-                }
-                if (packType.archiveOutput && archivedOutput && saveOptions.exportZips) {
-                    const archivePath = path.join(outputFolder, 'archives', `${packName}_${packType.type}.zip`);
-                    await fs.copyFile(archivePath, `${fullClientPath}.zip`);
-                }
-                else if (symlinksAvailable) {
-                    if (cache.symlinks === undefined || !cache.symlinks.includes(fullClientPath)) {
-                        await handleSymlink(folder, packName, newCache, clientPath, outputPath, fullClientPath);
-                    }
-                }
-                else {
-                    await fs.remove(fullClientPath);
-                    await fs.copy(outputPath, fullClientPath);
-                }
-            }
-            // Handle server export (skip client-only packs like resource packs)
-            if (serverPath && packType.networkSides === 'server') {
-                const fullServerPath = path.join(serverPath, packType.serverPath).replace('$packName$', packName);
-                if (packType.archiveOutput && archivedOutput && saveOptions.exportZips) {
-                    const archivePath = path.join(outputFolder, 'archives', `${packName}_${packType.type}.zip`);
-                    await fs.copyFile(archivePath, `${fullServerPath}.zip`);
-                }
-                else if (symlinksAvailable) {
-                    if (cache.symlinks === undefined || !cache.symlinks.includes(fullServerPath)) {
-                        await handleSymlink(folder, packName, newCache, serverPath, outputPath, fullServerPath);
-                    }
-                }
-                else {
-                    await fs.remove(fullServerPath);
-                    await fs.copy(outputPath, fullServerPath);
-                }
-            }
-        }
-    }
-    else {
-        // Production mode
-        for await (const [, packType] of packTypes) {
-            const outputPath = path.join(outputFolder, packType.type);
-            if (packType.handleOutput) {
-                await packType.handleOutput('output', (async (relativePath, encoding = 'utf8') => await fs.readFile(path.join(outputPath, relativePath), encoding)), async (relativePath, contents) => {
-                    if (contents === undefined) {
-                        await fs.unlink(path.join(outputPath, relativePath));
-                    }
-                    else {
-                        await fs.writeFile(path.join(outputPath, relativePath), contents.replaceAll('"min_version"', '"min_format"').replace('"max_version"', '"max_format"'));
-                    }
-                });
-            }
-            await handleResources(packType.type);
-        }
-    }
-    // Clean up old files, directories, and symlinks not in new cache
-    if (cliOptions.dry !== true) {
-        for (const file of Object.keys(cache.files)) {
-            if (!(file in newCache.files)) {
-                await fs.rm(path.join(outputFolder, file));
-                let dir = undefined;
-                for (const segment of split(new RegExp(RegExp.escape(path.sep)), path.dirname(file))) {
-                    dir = dir === undefined ? segment : path.join(dir, segment);
-                    if (!newDirs.has(dir)) {
-                        await fs.rm(path.join(outputFolder, dir), { force: true, recursive: true });
-                        break;
-                    }
-                }
-            }
-        }
-        // Clean up old archives
-        if (cache.archives) {
-            const archivesDir = path.join(outputFolder, 'archives');
-            if (newCache.archives === undefined || newCache.archives.length === 0) {
-                await fs.rm(archivesDir, { force: true, recursive: true });
-            }
-            for (const archive of cache.archives) {
-                if (!newCache.archives.includes(archive)) {
-                    await fs.rm(path.join(archivesDir, archive));
-                }
-            }
-        }
-        if (cache.symlinks) {
-            const newSymlinks = new Set(newCache.symlinks);
-            for (const symlink of cache.symlinks) {
-                if (!newSymlinks.has(symlink)) {
-                    await fs.rm(symlink);
-                }
-            }
-        }
-        // Update cache
-        cache = newCache;
-        await fs.ensureDir(path.dirname(cacheFile));
-        await fs.writeFile(cacheFile, JSON.stringify(cache));
-    }
-    // Run afterAll script
-    await scripts?.afterAll?.();
-    // Count resources (excluding boilerplate)
-    const resourceCounts = countResources(sandstonePack);
-    const exports = [clientPath && 'client', serverPath && 'server'].filter(Boolean).join(' & ') || false;
-    const countMsg = `${resourceCounts.functions} functions, ${resourceCounts.other} other resources`;
-    if (!silent) {
-        log(`Pack(s) compiled! (${countMsg})${exports ? ` Exported to ${exports}.` : ''}`);
-    }
-    return { resourceCounts, sandstoneConfig, sandstonePack, resetSandstonePack };
-}
-export async function _buildCommand(opts, _folder, existingContext, watching = false) {
-    const folder = _folder ?? opts.path;
-    try {
-        const result = await _buildProject(opts, folder, true, existingContext, watching);
-        return {
-            success: true,
-            resourceCounts: result?.resourceCounts ?? { functions: 0, other: 0 },
-            timestamp: Date.now(),
-            sandstoneConfig: result?.sandstoneConfig,
-            sandstonePack: result?.sandstonePack,
-            resetSandstonePack: result?.resetSandstonePack,
-        };
-    }
-    catch (err) {
-        const errorMessage = err.message || String(err);
-        // Always include stack trace for better debugging - format paths for terminal clickability
-        const stack = err.stack || '';
-        // Clean up stack trace: remove ?hot-hook query params and convert file:// URLs to paths
-        const cleanedStack = stack
-            .replace(/\?hot-hook=\d+/g, '') // Remove hot-hook cache busting params
-            .replace(/file:\/\/\//g, '') // Convert file:/// URLs to paths (Windows)
-            .replace(/file:\/\//g, ''); // Convert file:// URLs to paths (Unix)
-        const formattedError = cleanedStack ? `${errorMessage}\n${cleanedStack}` : errorMessage;
-        log('Build failed:', errorMessage);
-        return {
-            success: false,
-            error: formattedError,
-            resourceCounts: { functions: 0, other: 0 },
-            timestamp: Date.now(),
-        };
-    }
-}
-export async function buildCommand(opts, _folder, silent = false) {
-    // Commander passes Command object as second arg, so check for string explicitly
-    const folder = (typeof _folder === 'string') ? _folder : opts.path;
-    // Initialize logger without file for build mode
-    initLoggerNoFile();
-    setSilent(silent);
-    try {
-        const result = await _buildProject(opts, folder, silent);
-        if (silent) {
-            return {
-                success: true,
-                resourceCounts: result?.resourceCounts ?? { functions: 0, other: 0 },
-                timestamp: Date.now(),
-                sandstoneConfig: result?.sandstoneConfig,
-                sandstonePack: result?.sandstonePack,
-                resetSandstonePack: result?.resetSandstonePack,
-            };
-        }
-    }
-    catch (err) {
-        const errorMessage = err.message || String(err);
-        if (!silent) {
-            console.error(chalk.red('Build failed:'), errorMessage);
-            if (opts.fullTrace) {
-                console.error(err);
-            }
-        }
-        log('Build failed:', errorMessage);
-        if (silent) {
-            return {
-                success: false,
-                error: opts.fullTrace ? String(err) : errorMessage,
-                resourceCounts: { functions: 0, other: 0 },
-                timestamp: Date.now(),
-            };
-        }
-    }
-}

package/lib/commands/create.d.ts

@@ -1,8 +0,0 @@
-type CreateOptions = {
-    root: boolean;
-    world?: string;
-    clientPath?: string;
-    serverPath?: string;
-};
-export declare function createCommand(_project: string, opts: CreateOptions): Promise<void>;
-export {};