sandstone-cli 2.0.8 → 2.1.0

package/lib/ui/logger.js

@@ -1,189 +0,0 @@
-import fs from 'fs-extra';
-import path from 'path';
-import { stripVTControlCharacters, format } from 'util';
-let logPath = null;
-let liveLogCallback = null;
-let liveLogBuffer = [];
-let liveLogReady = false;
-let silent = false;
-// Track initialization and pending writes
-let initPromise = null;
-let writer = null;
-const pendingWrites = [];
-export function initLogger(rootFolder) {
-    logPath = path.join(rootFolder, '.sandstone', 'watch.log');
-    // Start logWorkerInit detached
-    initPromise = logWorkerInit();
-    // Return async function that awaits logWorkerFinish
-    return () => logWorkerFinish();
-}
-/**
- * Initialize the logger without file writing.
- * Use this for `sand build` where we want logging but no persistent log file.
- */
-export function initLoggerNoFile() {
-    logPath = null;
-    liveLogReady = true;
-    // Set a default callback that prints to console
-    liveLogCallback = (level, args) => {
-        console.log(...(level ? [`[${level}]`] : []), ...args);
-    };
-}
-/**
- * Set whether the logger should suppress live output.
- */
-export function setSilent(value) {
-    silent = value;
-}
-export function setLiveLogCallback(callback) {
-    liveLogCallback = callback;
-}
-export function drainLiveLogBuffer() {
-    liveLogReady = true;
-    if (liveLogCallback && liveLogBuffer.length > 0) {
-        for (const { level, args } of liveLogBuffer) {
-            liveLogCallback(level, args);
-        }
-        liveLogBuffer = [];
-    }
-}
-async function logWorkerInit() {
-    await fs.ensureDir(path.dirname(logPath));
-    await fs.writeFile(logPath, `=== Watch started at ${new Date().toISOString()} ===\n`);
-    writer = fs.createWriteStream(logPath, { flags: 'a' });
-    // Wait for the stream to be ready before allowing writes
-    await new Promise((resolve, reject) => {
-        writer.once('open', () => resolve());
-        writer.once('error', reject);
-    });
-}
-async function logWorkerMain(level, ...args) {
-    // Await logWorkerInit finishing if it isn't finished
-    if (initPromise) {
-        await initPromise;
-    }
-    // Skip empty log calls
-    if (args.length === 0) {
-        return;
-    }
-    // Skip logs that are just empty strings
-    if (args.length === 1 && typeof args[0] === 'string' && stripVTControlCharacters(args[0]).trim() === '') {
-        return;
-    }
-    // Collect all chunks first
-    const chunks = [];
-    // Timestamp and level prefix
-    chunks.push(`[${new Date().toISOString()}]${level !== false ? ` [${level}]` : ''} `);
-    // Process each argument
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (typeof arg === 'string') {
-            chunks.push(stripVTControlCharacters(arg));
-        }
-        else if (Buffer.isBuffer(arg) || arg instanceof Uint8Array) {
-            chunks.push(arg);
-        }
-        else if (arg instanceof ArrayBuffer) {
-            chunks.push(new Uint8Array(arg));
-        }
-        else if (arg instanceof Blob) {
-            chunks.push(new Uint8Array(await arg.arrayBuffer()));
-        }
-        else {
-            // Use util.format for objects, numbers, etc.
-            chunks.push(format('%O', arg));
-        }
-        // Add space between args (but not after last)
-        if (i < args.length - 1) {
-            chunks.push(' ');
-        }
-    }
-    chunks.push('\n');
-    // Concatenate all chunks into a single buffer for atomic write
-    const buffers = chunks.map(chunk => typeof chunk === 'string' ? Buffer.from(chunk) : Buffer.from(chunk));
-    await writeChunk(Buffer.concat(buffers));
-}
-function writeChunk(chunk) {
-    return new Promise((resolve, reject) => {
-        if (!writer) {
-            reject(new Error('Writer not initialized'));
-            return;
-        }
-        writer.write(chunk, (err) => {
-            if (err)
-                reject(err);
-            else
-                resolve();
-        });
-    });
-}
-async function logWorkerFinish() {
-    // Make sure to await logWorkerInit being finished
-    if (initPromise) {
-        await initPromise;
-    }
-    // Make sure to await all pending logWorkerMain calls
-    await Promise.all(pendingWrites);
-    // Close the writer
-    if (writer) {
-        await new Promise((resolve, reject) => {
-            writer.close((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-        });
-        writer = null;
-    }
-}
-function writeLog(level, ...args) {
-    if (!silent) {
-        if (liveLogReady) {
-            liveLogCallback?.(level, args);
-        }
-        else {
-            liveLogBuffer.push({ level, args });
-        }
-    }
-    if (logPath) {
-        // Call logWorkerMain detached and track the promise
-        const writePromise = logWorkerMain(level, ...args);
-        pendingWrites.push(writePromise);
-        // Clean up completed promises to avoid memory leak
-        writePromise
-            .catch((err) => {
-            // Log to stderr so we can see file write errors
-            process.stderr.write(`[logger] Write error: ${err}\n`);
-        })
-            .finally(() => {
-            const idx = pendingWrites.indexOf(writePromise);
-            if (idx !== -1)
-                pendingWrites.splice(idx, 1);
-        });
-    }
-}
-export function log(...args) {
-    writeLog(false, ...args);
-}
-export function logInfo(...args) {
-    writeLog('INFO', ...args);
-}
-export function logWarn(...args) {
-    writeLog('WARN', ...args);
-}
-export function logDebug(...args) {
-    writeLog('DEBUG', ...args);
-}
-export function logTrace(...args) {
-    writeLog('TRACE', ...args);
-}
-export function logError(error) {
-    if (typeof error === 'string') {
-        writeLog('ERROR', error);
-    }
-    else {
-        const err = error;
-        writeLog('ERROR', err?.message || String(error), ...(err?.stack ? ['\n', err.stack] : []));
-    }
-}

package/lib/ui/types.d.ts

@@ -1,26 +0,0 @@
-import type { SandstoneConfig, SandstonePack } from "sandstone";
-export type WatchStatus = 'watching' | 'building' | 'restarting' | 'error' | 'pending';
-export type ChangeCategory = 'src' | 'resources' | 'config' | 'dependencies' | 'other';
-export interface TrackedChange {
-    path: string;
-    category: ChangeCategory;
-}
-export interface ResourceCounts {
-    functions: number;
-    other: number;
-}
-export interface BuildResult {
-    success: boolean;
-    error?: string;
-    resourceCounts: ResourceCounts;
-    timestamp: number;
-    sandstoneConfig?: SandstoneConfig;
-    sandstonePack?: SandstonePack;
-    resetSandstonePack?: () => void;
-}
-export interface WatchUIAPI {
-    setStatus: (status: WatchStatus, reason?: string) => void;
-    setChangedFiles: (files: TrackedChange[]) => void;
-    setBuildResult: (result: BuildResult) => void;
-    setLiveLog: (level: string | false, args: unknown[]) => void;
-}

package/lib/ui/types.js

@@ -1 +0,0 @@
-export {};

package/lib/utils.d.ts

@@ -1,34 +0,0 @@
-/** Normalize a path to use forward slashes */
-export declare const normalizePath: (p: string) => string;
-export declare function hasYarn(): boolean;
-export declare function hasPnpm(): boolean;
-export declare function hasBun(): boolean;
-export declare const capitalize: (s: string) => string;
-/**
- * Check if symlinks can be used on this system.
- * Returns true on non-Windows platforms.
- * On Windows, tests if symlinking actually works (requires admin or developer mode).
- */
-export declare function canUseSymlinks(): Promise<boolean>;
-/**
- * Get the .minecraft path
- */
-export declare function getMinecraftPath(): string;
-export declare function getWorldsList(clientPath?: string): string[];
-type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
-type LastOf<T> = UnionToIntersection<T extends any ? () => T : never> extends () => (infer R) ? R : never;
-type Push<T extends any[], V> = [...T, V];
-type UnionToTuple<T, L = LastOf<T>, N = [T] extends [never] ? true : false> = true extends N ? [] : Push<UnionToTuple<Exclude<T, L>>, L>;
-type PowerSet<T, Keys extends any[] = UnionToTuple<keyof T>> = Keys extends [infer Head, ...infer Rest] ? PowerSet<T, Rest> | (Head extends keyof T ? {
-    [K in Head]: NonNullable<T[K]>;
-} & PowerSet<T, Rest> : never) : Record<string, never>;
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-/**
- * Helper to add key-value pairs to an object if the values are not undefined.
- *
- * @returns An object with the key-value pairs if the values are not undefined, otherwise an empty object.
- */
-export declare function add<O extends Record<string, any>>(obj: O): Prettify<PowerSet<O>>;
-export {};

package/lib/utils.js

@@ -1,105 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { execSync } from 'child_process';
-/** Normalize a path to use forward slashes */
-export const normalizePath = (p) => p.replaceAll('\\', '/');
-export function hasYarn() {
-    try {
-        execSync('yarn --version');
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-export function hasPnpm() {
-    try {
-        execSync('pnpm --version');
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-export function hasBun() {
-    try {
-        execSync('bun --version');
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}
-export const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
-/**
- * Check if symlinks can be used on this system.
- * Returns true on non-Windows platforms.
- * On Windows, tests if symlinking actually works (requires admin or developer mode).
- */
-export async function canUseSymlinks() {
-    if (os.platform() !== 'win32') {
-        return true;
-    }
-    const testDir = path.join(os.tmpdir(), `symlink-test-${Date.now()}`);
-    const targetPath = path.join(testDir, 'target');
-    const linkPath = path.join(testDir, 'link');
-    try {
-        await fs.promises.mkdir(testDir);
-        await fs.promises.mkdir(targetPath);
-        await fs.promises.writeFile(path.join(targetPath, 'test.txt'), 'symlink-test');
-        await fs.promises.symlink(targetPath, linkPath, 'dir');
-        // Verify the symlink actually works by reading through it
-        const content = await fs.promises.readFile(path.join(linkPath, 'test.txt'), 'utf-8');
-        return content === 'symlink-test';
-    }
-    catch {
-        return false;
-    }
-    finally {
-        await fs.promises.rm(testDir, { recursive: true, force: true }).catch(() => { });
-    }
-}
-/**
- * Get the .minecraft path
- */
-export function getMinecraftPath() {
-    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();
-    if (!fs.existsSync(mcPath)) {
-        throw new Error('Unable to locate the .minecraft folder. Please specify it manually.');
-    }
-    return mcPath;
-}
-export function getWorldsList(clientPath) {
-    const mcPath = clientPath || getMinecraftPath();
-    const savesPath = path.join(mcPath, 'saves');
-    return fs.readdirSync(savesPath, { withFileTypes: true }).filter((f) => f.isDirectory).map((f) => f.name);
-}
-/**
- * Helper to add key-value pairs to an object if the values are not undefined.
- *
- * @returns An object with the key-value pairs if the values are not undefined, otherwise an empty object.
- */
-export function add(obj) {
-    const filtered = {};
-    for (const key of Object.keys(obj)) {
-        const value = obj[key];
-        if (value !== undefined) {
-            // @ts-ignore
-            filtered[key] = value;
-        }
-    }
-    // @ts-ignore
-    return filtered;
-}