mb-run 0.0.1-dev-20260504-b6b8a3a

package/dist/cache.js

@@ -0,0 +1,107 @@
+import { readdir, readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { fileExists } from './clean.js';
+import { parsePackageJson } from './helpers.js';
+import { logBackup, logRestore } from './logger.js';
+export const packageJsonMap = new Map();
+export const tsconfigMap = new Map();
+const packageJsonPaths = new Map();
+export async function resolveWorkspacePackageJsonPaths(rootDir) {
+    const rootPkg = await parsePackageJson(rootDir);
+    const workspacesConfig = rootPkg.workspaces;
+    let patterns = [];
+    if (Array.isArray(workspacesConfig)) {
+        patterns = workspacesConfig.filter((p) => typeof p === 'string');
+    }
+    else if (workspacesConfig && typeof workspacesConfig === 'object' && Array.isArray(workspacesConfig.packages)) {
+        patterns = workspacesConfig.packages.filter((p) => typeof p === 'string');
+    }
+    if (patterns.length === 0)
+        return [];
+    const hasGlobChars = (s) => /[*?\[]/.test(s);
+    const results = [];
+    for (const pattern of patterns) {
+        const trimmed = pattern.trim();
+        if (!trimmed)
+            continue;
+        if (!hasGlobChars(trimmed)) {
+            const candidate = path.join(rootDir, trimmed, 'package.json');
+            if (await fileExists(candidate))
+                results.push(candidate);
+            continue;
+        }
+        if (trimmed.endsWith('/*') && trimmed.indexOf('*') === trimmed.length - 1 && !/[?\[]/.test(trimmed)) {
+            const baseAbs = path.join(rootDir, trimmed.slice(0, -2));
+            let entries;
+            try {
+                entries = await readdir(baseAbs, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const candidate = path.join(baseAbs, entry.name, 'package.json');
+                if (await fileExists(candidate))
+                    results.push(candidate);
+            }
+            continue;
+        }
+    }
+    return Array.from(new Set(results));
+}
+export async function backup(rootDir) {
+    logBackup(rootDir);
+    packageJsonMap.clear();
+    tsconfigMap.clear();
+    packageJsonPaths.clear();
+    const rootPkgPath = path.join(rootDir, 'package.json');
+    const rootPkg = await parsePackageJson(rootDir);
+    const rootName = String(rootPkg.name ?? '');
+    packageJsonMap.set(rootName, rootPkg);
+    packageJsonPaths.set(rootName, rootPkgPath);
+    const workspacePkgPaths = await resolveWorkspacePackageJsonPaths(rootDir);
+    const workspaceDirs = [];
+    for (const pkgPath of workspacePkgPaths) {
+        const pkg = JSON.parse(await readFile(pkgPath, 'utf8'));
+        const name = String(pkg.name ?? '');
+        packageJsonMap.set(name, pkg);
+        packageJsonPaths.set(name, pkgPath);
+        workspaceDirs.push(path.dirname(pkgPath));
+    }
+    const dirsToScan = [rootDir, ...workspaceDirs];
+    for (const dir of dirsToScan) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const name = entry.name;
+            if (!name.startsWith('tsconfig') || !name.endsWith('.json'))
+                continue;
+            const absPath = path.join(dir, name);
+            const relKey = path.relative(rootDir, absPath).split(path.sep).join('/');
+            const parsed = JSON.parse(await readFile(absPath, 'utf8'));
+            tsconfigMap.set(relKey, parsed);
+        }
+    }
+}
+export async function restore(rootDir) {
+    logRestore(rootDir);
+    for (const [relKey, content] of tsconfigMap) {
+        const absPath = path.join(rootDir, ...relKey.split('/'));
+        await writeFile(absPath, JSON.stringify(content, null, 2));
+    }
+    for (const [name, content] of packageJsonMap) {
+        const absPath = packageJsonPaths.get(name);
+        if (absPath) {
+            await writeFile(absPath, JSON.stringify(content, null, 2));
+        }
+    }
+}

package/dist/clean.js

@@ -0,0 +1,119 @@
+import { access, readdir, rm } from 'node:fs/promises';
+import path from 'node:path';
+import { logDelete } from './logger.js';
+export async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function removePath(targetPath, opts) {
+    logDelete(targetPath);
+    if (opts.dryRun)
+        return;
+    await rm(targetPath, { recursive: true, force: true });
+}
+export async function emptyDir(dirPath, opts) {
+    if (!(await fileExists(dirPath)))
+        return;
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    await Promise.all(entries.map(async (entry) => {
+        await removePath(path.join(dirPath, entry.name), opts);
+    }));
+}
+async function emptyDirIfExists(dirPath, opts) {
+    let entries;
+    try {
+        entries = await readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    await Promise.all(entries.map(async (entry) => {
+        await removePath(path.join(dirPath, entry.name), opts);
+    }));
+}
+async function removeTsBuildInfo(rootDir, opts) {
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            break;
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (entry.name === 'node_modules')
+                    continue;
+                stack.push(path.join(current, entry.name));
+                continue;
+            }
+            if (entry.isFile() && entry.name.endsWith('.tsbuildinfo')) {
+                await removePath(path.join(current, entry.name), opts);
+            }
+        }
+    }
+}
+async function cleanWorkspaceArtifacts(parentDir, ensureDirs, opts) {
+    let workspaces;
+    try {
+        workspaces = await readdir(parentDir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    await Promise.all(workspaces
+        .filter((d) => d.isDirectory())
+        .map(async (d) => {
+        const wsRoot = path.join(parentDir, d.name);
+        await Promise.all([
+            removePath(path.join(wsRoot, 'build'), opts),
+            removePath(path.join(wsRoot, 'dist'), opts),
+            removePath(path.join(wsRoot, 'dist-jest'), opts),
+            removePath(path.join(wsRoot, 'coverage'), opts),
+            removePath(path.join(wsRoot, 'jest'), opts),
+            removePath(path.join(wsRoot, 'temp'), opts),
+            removePath(path.join(wsRoot, '.cache'), opts),
+            removePath(path.join(wsRoot, 'node_modules'), opts),
+            removePath(path.join(wsRoot, 'package-lock.json'), opts),
+            removePath(path.join(wsRoot, 'npm-shrinkwrap.json'), opts),
+        ]);
+        const empty = ensureDirs ? emptyDir : emptyDirIfExists;
+        await Promise.all([empty(path.join(wsRoot, '.cache'), opts), empty(path.join(wsRoot, 'node_modules'), opts)]);
+    }));
+}
+async function commonClean(emptyRootNodeModules, ensureWorkspaceDirs, opts) {
+    await removeTsBuildInfo(opts.rootDir, opts);
+    await Promise.all([
+        removePath(path.join(opts.rootDir, 'build'), opts),
+        removePath(path.join(opts.rootDir, 'dist'), opts),
+        removePath(path.join(opts.rootDir, 'dist-jest'), opts),
+        removePath(path.join(opts.rootDir, 'coverage'), opts),
+        removePath(path.join(opts.rootDir, 'jest'), opts),
+        removePath(path.join(opts.rootDir, 'temp'), opts),
+        removePath(path.join(opts.rootDir, 'npm-shrinkwrap.json'), opts),
+    ]);
+    await Promise.all([
+        cleanWorkspaceArtifacts(path.join(opts.rootDir, 'packages'), ensureWorkspaceDirs, opts),
+        cleanWorkspaceArtifacts(path.join(opts.rootDir, 'apps'), ensureWorkspaceDirs, opts),
+    ]);
+    const emptyRootCache = ensureWorkspaceDirs ? emptyDir : emptyDirIfExists;
+    await emptyRootCache(path.join(opts.rootDir, '.cache'), opts);
+    if (emptyRootNodeModules) {
+        await emptyDir(path.join(opts.rootDir, 'node_modules'), opts);
+    }
+}
+export async function resetClean(opts) {
+    await commonClean(true, false, opts);
+}
+export async function cleanOnly(opts) {
+    await commonClean(false, false, opts);
+}

package/dist/esbuild.js

@@ -0,0 +1,80 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { build } from 'esbuild';
+import { resolveWorkspacePackageJsonPaths } from './cache.js';
+import { parsePackageJson } from './helpers.js';
+import { logEsbuild } from './logger.js';
+export async function runEsbuild(opts) {
+    if (opts.dryRun)
+        return;
+    const workspacePaths = await resolveWorkspacePackageJsonPaths(opts.rootDir);
+    const allPkgPaths = [path.join(opts.rootDir, 'package.json'), ...workspacePaths];
+    const localNames = new Set();
+    for (const wPkgPath of workspacePaths) {
+        const wRaw = await readFile(wPkgPath, 'utf8');
+        const wPkg = JSON.parse(wRaw);
+        if (wPkg.name)
+            localNames.add(wPkg.name);
+    }
+    const externalSet = new Set();
+    for (const pkgPath of allPkgPaths) {
+        const pRaw = await readFile(pkgPath, 'utf8');
+        const pPkg = JSON.parse(pRaw);
+        for (const dep of [...Object.keys(pPkg.dependencies ?? {}), ...Object.keys(pPkg.optionalDependencies ?? {}), ...Object.keys(pPkg.peerDependencies ?? {})]) {
+            externalSet.add(dep);
+        }
+    }
+    for (const localName of localNames) {
+        externalSet.delete(localName);
+    }
+    const rootPkg = (await parsePackageJson(opts.rootDir));
+    const toTsSrc = (relPath) => relPath
+        .replace(/^\.?\//, '')
+        .replace('dist/', 'src/')
+        .replace(/\.js$/, '.ts');
+    const toOutName = (relPath) => relPath
+        .replace(/^\.?\//, '')
+        .replace(/^dist\//, '')
+        .replace(/\.js$/, '');
+    const exportsMain = typeof rootPkg.exports === 'object' && rootPkg.exports !== null ? rootPkg.exports['.']?.['import'] : undefined;
+    const mainRel = rootPkg.main ??
+        exportsMain ??
+        (() => {
+            throw new Error('No main entry point found in package.json (main or exports["."]["import"] required)');
+        })();
+    const binEntries = Object.entries(rootPkg.bin ?? {});
+    const alias = {};
+    for (const wPkgPath of workspacePaths) {
+        const wRaw = await readFile(wPkgPath, 'utf8');
+        const wPkg = JSON.parse(wRaw);
+        if (!wPkg.name)
+            continue;
+        const wExportsMain = typeof wPkg.exports === 'object' && wPkg.exports !== null ? wPkg.exports['.']?.['import'] : undefined;
+        const wMainRel = wPkg.main ?? wExportsMain;
+        if (!wMainRel)
+            continue;
+        alias[wPkg.name] = path.join(path.dirname(wPkgPath), toTsSrc(wMainRel));
+    }
+    const entryPoints = [
+        { in: path.join(opts.rootDir, toTsSrc(mainRel)), out: toOutName(mainRel) },
+        ...binEntries.map(([, binRelPath]) => ({
+            in: path.join(opts.rootDir, toTsSrc(binRelPath)),
+            out: toOutName(binRelPath),
+        })),
+    ];
+    logEsbuild(entryPoints, opts.rootDir);
+    const esbuildOptions = {
+        entryPoints,
+        bundle: true,
+        format: 'esm',
+        platform: 'node',
+        target: ['esnext'],
+        alias,
+        external: [...externalSet],
+        treeShaking: true,
+        splitting: true,
+        outdir: path.join(opts.rootDir, 'dist'),
+        write: true,
+    };
+    await build(esbuildOptions);
+}

package/dist/help.js

@@ -0,0 +1,44 @@
+import pkg from '../package.json' with { type: 'json' };
+import { brightBlack, brightCyan, brightWhite, brightYellow, cyan, green, log } from './ansi.js';
+export function printUsage() {
+    const title = `${brightCyan('mb-run')} ${brightBlack('version')} ${brightWhite(pkg.version)}`;
+    const usageLine = `${brightYellow('Usage:')} ${green('mb-run')} [--install] [--reset [--production]] [--clean] [--deep-clean] [--build [--production]] [--watch] [--test] [--lint|--lint-fix] [--format|--format-check] [--sort] [--update] [--pack] [--publish] [--dry-run] [--version [dev|edge|git|local|next|alpha|beta]] [--info]`;
+    const msg = `\
+${title}
+
+Runs the same operations as the package.json scripts in the current working directory, but executes the local
+binaries in node_modules/.bin directly (does not call npm scripts).
+
+${usageLine}
+
+${brightYellow('Notes:')}
+- ${cyan('Multiple flags')} are run in this order: ${brightBlack('install → update → deep-clean → reset → clean → build → test → format → lint → sort → watch')}
+- ${green('--install')} runs npm install --no-fund --no-audit
+- ${green('--reset')} empties .cache/ and node_modules/ (keeps directories for devcontainer named volumes), then runs npm install and build
+- ${green('--deep-clean')} empties .cache/ and node_modules/ like --reset but skips the install and build steps
+- ${green('--test')} sets NODE_OPTIONS="--experimental-vm-modules --no-warnings" like the existing scripts
+- ${green('--lint-fix')} runs eslint with --fix
+- ${green('--format-check')} runs prettier with --check
+- ${green('--build')} prefers per-workspace tsconfig.build.json when present
+- ${green('--build --production')} prefers tsconfig.build.production.json, else tsconfig.build.json, else tsconfig.json
+- ${green('--reset --production')} performs a reset and rebuilds using the production tsconfig
+- ${green('--sort')} sorts top-level keys in all package.json files (root and workspaces) using the canonical key order
+- ${green('--update')} installs npm-check-updates (--no-save) then runs ncu -u across all workspaces
+- ${green('--pack')} backs up package.json, cleans, builds for production, strips devDependencies and scripts, empties node_modules, runs npm install --omit=dev, npm shrinkwrap, npm pack, then restores package.json and reinstalls
+- ${green('--publish')} backs up all package.json files (root and workspaces), strips devDependencies and scripts from each, runs npm publish --dry-run for root and every workspace, then restores all package.json files
+- ${green('--dry-run')} logs intended actions without changing files or executing commands
+- ${green('--version')} updates versions for the current package and all configured workspaces
+- ${green('--verbose')} prints each external command before it is executed
+- ${green('--info')} prints system information (platform, hostname, memory, network, Node.js/npm versions)
+`;
+    log(msg);
+}
+export function printVersionUsage() {
+    const msg = [
+        `${brightYellow('Usage:')} ${green('mb-run')} ${green('--version')} [dev|edge|git|local|next|alpha|beta]`,
+        `${cyan('Updates')} package.json + package-lock.json (current package and workspaces) version to:`,
+        `  ${brightBlack('<baseVersion>-<dev|edge|git|local|next|alpha|beta>-<yyyymmdd>-<7charSha>')}`,
+        `Or with no tag, strips the suffix back to ${brightBlack('<baseVersion>')}.`,
+    ].join('\n');
+    log(msg);
+}

package/dist/helpers.js

@@ -0,0 +1,20 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+export async function parsePackageJson(rootDir) {
+    const packageJsonPath = path.join(rootDir, 'package.json');
+    try {
+        const raw = await readFile(packageJsonPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Failed to read or parse ${packageJsonPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+}
+export async function isPlugin(rootDir) {
+    const pkg = (await parsePackageJson(rootDir));
+    return pkg?.scripts?.start === 'matterbridge' || pkg?.scripts?.['dev:link'] === 'npm link --no-fund --no-audit matterbridge';
+}
+export async function isMonorepo(rootDir) {
+    const pkg = await parsePackageJson(rootDir);
+    return pkg?.workspaces !== undefined;
+}

package/dist/info.js

@@ -0,0 +1,93 @@
+import { readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { log } from './ansi.js';
+function formatBytes(bytes) {
+    if (bytes >= 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+    if (bytes >= 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / 1024).toFixed(1)} KB`;
+}
+function formatUptime(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days} day${days !== 1 ? 's' : ''}`);
+    if (hours > 0)
+        parts.push(`${hours} hour${hours !== 1 ? 's' : ''}`);
+    if (minutes > 0)
+        parts.push(`${minutes} minute${minutes !== 1 ? 's' : ''}`);
+    return parts.length > 0 ? `up ${parts.join(', ')}` : 'up less than a minute';
+}
+function getPrimaryIpv4() {
+    for (const iface of Object.values(os.networkInterfaces())) {
+        for (const addr of iface ?? []) {
+            if (addr.family === 'IPv4' && !addr.internal)
+                return addr.address;
+        }
+    }
+    return 'unavailable';
+}
+function getIpv6Addresses() {
+    const addrs = [];
+    for (const iface of Object.values(os.networkInterfaces())) {
+        for (const addr of iface ?? []) {
+            if (addr.family === 'IPv6' && !addr.internal)
+                addrs.push(addr.address);
+        }
+    }
+    return addrs.length > 0 ? addrs.join(' ') : 'none';
+}
+function npmPackageJsonCandidates(nodeBinDir) {
+    return [
+        path.join(nodeBinDir, 'node_modules', 'npm', 'package.json'),
+        path.join(nodeBinDir, '..', 'lib', 'node_modules', 'npm', 'package.json'),
+        '/usr/lib/node_modules/npm/package.json',
+    ];
+}
+function getNpmVersion() {
+    const nodeBinDir = path.dirname(process.execPath);
+    for (const candidate of npmPackageJsonCandidates(nodeBinDir)) {
+        try {
+            const raw = readFileSync(candidate, 'utf8');
+            const parsed = JSON.parse(raw);
+            if (parsed !== null && typeof parsed === 'object' && 'version' in parsed && typeof parsed['version'] === 'string') {
+                return parsed['version'];
+            }
+        }
+        catch {
+        }
+    }
+    const agent = process.env['npm_config_user_agent'];
+    if (agent) {
+        const match = /^npm\/(\S+)/u.exec(agent);
+        if (match?.[1])
+            return match[1];
+    }
+    return 'unavailable';
+}
+export function systemInfo() {
+    const total = os.totalmem();
+    const used = total - os.freemem();
+    let username = 'unavailable';
+    try {
+        username = os.userInfo().username;
+    }
+    catch {
+    }
+    log(`\u{1F4BB}  Platform:     ${os.type()} ${os.arch()}`);
+    log(`\u{1F9E9}  Kernel:       ${os.release()} / ${os.version()}`);
+    log(`\u{1F464}  User:         ${username}`);
+    log(`\u{1F516}  Hostname:     ${os.hostname()}`);
+    log(`\u{23F3}  Uptime:       ${formatUptime(os.uptime())}`);
+    log(`\u{1F4C5}  Date:         ${new Date().toString()}`);
+    log(`\u{1F9E0}  Memory:       ${formatBytes(used)} used / ${formatBytes(total)} total`);
+    log(`\u{1F310}  IPv4:         ${getPrimaryIpv4()}`);
+    log(`\u{1F310}  IPv6:         ${getIpv6Addresses()}`);
+    log(`\u{1F7E2}  Node.js:      ${process.version.replace(/^v/u, '')}`);
+    log(`\u{1F7E3}  Npm:          ${getNpmVersion()}`);
+}

package/dist/logger.js

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import { brightRed, brightYellow, cyan, green, log, magenta, reverse } from './ansi.js';
+export function formatCommandArg(arg) {
+    if (arg === '')
+        return '""';
+    return /[\s"]/u.test(arg) ? JSON.stringify(arg) : arg;
+}
+export class Logger {
+    dryRun;
+    verbose;
+    rootDir;
+    constructor(opts) {
+        this.dryRun = opts.dryRun;
+        this.verbose = opts.verbose;
+        this.rootDir = opts.rootDir;
+    }
+    shouldLogActions() {
+        return this.verbose || this.dryRun;
+    }
+    logPrefix() {
+        return this.dryRun ? `${green('[mb-run]')} ${reverse(magenta('[dry]'))}` : green('[mb-run]');
+    }
+    logCommand = (command, args, cwd = this.rootDir) => {
+        if (!this.shouldLogActions())
+            return;
+        const parts = [command, ...args].map(formatCommandArg).join(' ');
+        log(`${this.logPrefix()} ${cyan(cwd)}> ${green('run')} ${parts}`);
+    };
+    logDelete = (targetPath) => {
+        if (!this.shouldLogActions())
+            return;
+        const resolvedPath = path.resolve(targetPath);
+        log(`${this.logPrefix()} ${cyan(path.dirname(resolvedPath))}> ${brightRed('delete')} ${formatCommandArg(path.basename(resolvedPath))}`);
+    };
+    logWriteFile = (filePath) => {
+        if (!this.shouldLogActions())
+            return;
+        const resolvedPath = path.resolve(filePath);
+        log(`${this.logPrefix()} ${cyan(path.dirname(resolvedPath))}> ${brightYellow('write')} ${formatCommandArg(path.basename(resolvedPath))}`);
+    };
+    logEsbuild = (entryPoints, cwd = this.rootDir) => {
+        if (!this.shouldLogActions())
+            return;
+        const entries = entryPoints.map(({ in: inPath }) => formatCommandArg(inPath)).join(' ');
+        log(`${this.logPrefix()} ${cyan(cwd)}> ${magenta('esbuild')} ${entries}`);
+    };
+    logBackup = (dir) => {
+        if (!this.shouldLogActions())
+            return;
+        log(`${this.logPrefix()} ${cyan(dir)}> ${brightYellow('backup')}`);
+    };
+    logRestore = (dir) => {
+        if (!this.shouldLogActions())
+            return;
+        log(`${this.logPrefix()} ${cyan(dir)}> ${brightYellow('restore')}`);
+    };
+}
+let logger = new Logger({ dryRun: false, verbose: false, rootDir: '' });
+export function initLogger(opts) {
+    logger = new Logger(opts);
+}
+export function logCommand(command, args, cwd) {
+    logger.logCommand(command, args, cwd);
+}
+export function logDelete(targetPath) {
+    logger.logDelete(targetPath);
+}
+export function logWriteFile(filePath) {
+    logger.logWriteFile(filePath);
+}
+export function logEsbuild(entryPoints, cwd) {
+    logger.logEsbuild(entryPoints, cwd);
+}
+export function logBackup(dir) {
+    logger.logBackup(dir);
+}
+export function logRestore(dir) {
+    logger.logRestore(dir);
+}