sandstone-cli 1.2.5 → 2.0.0

package/lib/commands/build.js

@@ -1,30 +1,623 @@
-import path from 'path';
-import { fork } from 'child_process';
-import { getProjectFolders } from '../utils.js';
-export function buildCommand(opts, _folders) {
-    var _a, _b;
-    const folders = (_folders === null || _folders === void 0 ? void 0 : _folders.projectFolder) ? _folders : getProjectFolders(opts.path);
-    console.log('Compiling source...\n');
-    const build = fork(path.join(folders.rootFolder, 'node_modules', 'sandstone-build', 'lib', 'index.js'), process.argv.slice(2), {
-        stdio: 'pipe',
-        env: {
-            NODE_OPTIONS: "--loader ts-node/esm",
-            CLI_OPTIONS: JSON.stringify(opts),
-            PROJECT_FOLDERS: JSON.stringify(folders),
+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');
         }
-    });
-    let esmErrored = false;
-    (_a = build === null || build === void 0 ? void 0 : build.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => process.stdout.write(data));
-    (_b = build === null || build === void 0 ? void 0 : build.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (data) => {
-        if (esmErrored) {
-            process.stderr.write(data);
+    }
+    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 {
-            esmErrored = true;
+            other++;
         }
+    }
+    return { functions, other };
+}
+async function handleSymlink(folder, packName, cache, minecraftPath, targetPath, linkPath) {
+    const allowPath = `[glob]${path.resolve(folder)}${path.sep}**${path.sep}*`;
+    const allowedList = path.join(minecraftPath, 'allowed_symlinks.txt');
+    const comment = `# Sandstone Pack: ${packName}\n`;
+    try {
+        const currentlyAllowed = await fs.readFile(allowedList);
+        if (!currentlyAllowed.includes(allowPath)) {
+            await fs.writeFile(allowedList, `${currentlyAllowed}\n#\n${comment}${allowPath}`);
+        }
+    }
+    catch (e) {
+        await fs.writeFile(allowedList, `${comment}${allowPath}`);
+    }
+    await fs.lstat(linkPath).then(() => {
+        throw new Error(`Tried to add a symlink at "${linkPath}", encountered an existing file.`);
+    }).catch(() => { });
+    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);
+                }
+            }),
     });
-    return new Promise((resolve) => {
-        var _a;
-        (_a = build === null || build === void 0 ? void 0 : build.stdout) === null || _a === void 0 ? void 0 : _a.on('end', () => resolve());
-    });
+    // 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);
+                    }
+                });
+            }
+            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)) {
+                        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)) {
+                        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);
+                    }
+                });
+            }
+            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(),
+            };
+        }
+    }
 }