bun-workspaces 1.0.0-alpha.4 → 1.0.0-alpha.7

package/README.md

@@ -79,6 +79,10 @@ bw script-info my-script --json
 # in their `scripts` field
 bw run my-script
 
+# By default, a prefix is added to the script output with the workspace name
+# This can be disabled with the --noPrefix option
+bw run my-script --noPrefix
+
 # Run a script for a specific workspace by its package.json name or alias from the config
 bw run my-script my-workspace
 

package/bin/cli.js

@@ -1,4 +1,3 @@
 #!/usr/bin/env bun
 import { createCli } from "bun-workspaces";
-
 createCli().run();

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "bun-workspaces",
-  "version": "1.0.0-alpha.4",
-  "main": "src/index.ts",
-  "homepage": "https://github.com/ScottMorse/bun-workspaces#readme",
+  "version": "1.0.0-alpha.7",
+  "main": "src/index.mjs",
+  "types": "src/index.d.ts",
+  "homepage": "https://github.com/ScottMorse/bun-workspaces",
   "bin": {
     "bun-workspaces": "bin/cli.js"
   },
@@ -12,28 +13,8 @@
       "libraryConsumer": "^1.1.x"
     }
   },
-  "scripts": {
-    "cli": "bun run bin/cli.js",
-    "cli:dev": "_BW_RUNTIME_MODE=development bun run bin/cli.js",
-    "type-check": "tsc --noEmit",
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "format-check": "prettier --check ."
-  },
-  "devDependencies": {
-    "@types/bun": "^1.3.0",
-    "@typescript-eslint/eslint-plugin": "^8.46.0",
-    "@typescript-eslint/parser": "^8.46.0",
-    "eslint": "^9.37.0",
-    "eslint-plugin-import": "^2.32.0",
-    "prettier": "^3.6.2",
-    "typescript-eslint": "^8.46.0"
-  },
   "dependencies": {
     "commander": "^12.1.0",
     "glob": "^11.0.3"
-  },
-  "peerDependencies": {
-    "typescript": "^5.9.3"
   }
-}
+}

package/src/cli/cli.d.ts

@@ -0,0 +1,13 @@
+import { type Command } from "commander";
+export interface RunCliOptions {
+    argv?: string | string[];
+}
+export interface CliProgram {
+    run: (options?: RunCliOptions) => Promise<void>;
+}
+export interface CreateCliProgramOptions {
+    handleError?: (error: Error) => void;
+    postInit?: (program: Command) => unknown;
+    defaultCwd?: string;
+}
+export declare const createCliProgram: ({ handleError, postInit, defaultCwd, }?: CreateCliProgramOptions) => CliProgram;

package/src/cli/cli.mjs

@@ -0,0 +1,43 @@
+import { createCommand } from "commander";
+import package_0 from "../../package.json";
+import { getRequiredBunVersion, validateCurrentBunVersion } from "../internal/bunVersion.mjs";
+import { logger } from "../internal/logger.mjs";
+import { initializeWithGlobalOptions } from "./globalOptions.mjs";
+import { defineProjectCommands } from "./projectCommands.mjs";
+const createCliProgram = ({ handleError, postInit, defaultCwd = process.cwd() } = {})=>{
+    const run = async ({ argv = process.argv } = {})=>{
+        const errorListener = handleError ?? ((error)=>{
+            logger.error(error);
+            logger.error("Unhandled rejection");
+            process.exit(1);
+        });
+        process.on("unhandledRejection", errorListener);
+        try {
+            const program = createCommand("bunx bun-workspaces").description("CLI for utilities for Bun workspaces").version(package_0.version).configureOutput({
+                writeOut: (s)=>logger.info(s),
+                writeErr: (s)=>s.startsWith("Usage") ? logger.info(s) : logger.error(s)
+            });
+            postInit?.(program);
+            if (!validateCurrentBunVersion()) {
+                logger.error(`Bun version mismatch. Required: ${getRequiredBunVersion()}, Found: ${Bun.version}`);
+                process.exit(1);
+            }
+            const args = "string" == typeof argv ? argv.split(" ") : argv;
+            const { project } = initializeWithGlobalOptions(program, args, defaultCwd);
+            if (!project) return;
+            defineProjectCommands({
+                program,
+                project
+            });
+            await program.parseAsync(args);
+        } catch (error) {
+            errorListener(error);
+        } finally{
+            process.off("unhandledRejection", errorListener);
+        }
+    };
+    return {
+        run
+    };
+};
+export { createCliProgram };

package/src/cli/globalOptions.d.ts

@@ -0,0 +1,11 @@
+import { type Command } from "commander";
+import { type LogLevelSetting } from "../internal/logger";
+export interface CliGlobalOptions {
+    logLevel: LogLevelSetting;
+    cwd: string;
+    configFile?: string;
+}
+export type CliGlobalOptionName = keyof CliGlobalOptions;
+export declare const initializeWithGlobalOptions: (program: Command, args: string[], defaultCwd: string) => {
+    project: import("..").Project;
+};

package/src/cli/globalOptions.mjs

@@ -0,0 +1,65 @@
+import path from "path";
+import { Option } from "commander";
+import { loadConfigFile } from "../config/index.mjs";
+import { LOG_LEVELS, logger } from "../internal/logger.mjs";
+import { createProject } from "../project/index.mjs";
+const getWorkingDirectory = (program, args, defaultCwd)=>{
+    program.addOption(new Option("-d --cwd <path>", "Working directory").default(defaultCwd));
+    program.parseOptions(args);
+    return program.opts().cwd;
+};
+const getConfig = (program, args)=>{
+    program.addOption(new Option("-c --configFile <path>", "Config file"));
+    program.parseOptions(args);
+    return program.opts().configFile;
+};
+const defineGlobalOptions = (program, args, defaultCwd)=>{
+    const cwd = getWorkingDirectory(program, args, defaultCwd);
+    const configFilePath = getConfig(program, args);
+    const config = loadConfigFile(configFilePath, cwd);
+    const globalOptions = {
+        logLevel: {
+            shortName: "l",
+            description: "Log levels",
+            defaultValue: config?.cli?.logLevel ?? logger.printLevel,
+            values: [
+                ...LOG_LEVELS,
+                "silent"
+            ],
+            param: "level"
+        }
+    };
+    Object.entries(globalOptions).forEach(([name, { shortName, description, param, values, defaultValue }])=>{
+        const option = new Option(`-${shortName} --${name}${param ? ` <${param}>` : ""}`, description).default(defaultValue);
+        program.addOption(values?.length ? option.choices(values) : option);
+    });
+    return {
+        cwd,
+        config
+    };
+};
+const applyGlobalOptions = (options, config)=>{
+    logger.printLevel = options.logLevel;
+    logger.debug("Log level: " + options.logLevel);
+    const project = createProject({
+        rootDir: options.cwd,
+        workspaceAliases: config?.project?.workspaceAliases ?? {}
+    });
+    logger.debug(`Project: ${JSON.stringify(project.name)} (${project.workspaces.length} workspace${1 === project.workspaces.length ? "" : "s"})`);
+    logger.debug("Project root: " + path.resolve(project.rootDir));
+    return {
+        project
+    };
+};
+const initializeWithGlobalOptions = (program, args, defaultCwd)=>{
+    program.allowUnknownOption(true);
+    const { cwd, config } = defineGlobalOptions(program, args, defaultCwd);
+    program.parseOptions(args);
+    program.allowUnknownOption(false);
+    const options = program.opts();
+    return applyGlobalOptions({
+        ...options,
+        cwd
+    }, config);
+};
+export { initializeWithGlobalOptions };

package/src/cli/index.mjs

@@ -0,0 +1,2 @@
+import { createCliProgram } from "./cli.mjs";
+export { createCliProgram as createCli };

package/src/cli/projectCommands.d.ts

@@ -0,0 +1,8 @@
+import { type Command } from "commander";
+import type { Project } from "../project";
+export interface ProjectCommandsContext {
+    project: Project;
+    program: Command;
+}
+export declare const commandOutputLogger: import("../internal/logger").Logger;
+export declare const defineProjectCommands: (context: ProjectCommandsContext) => void;

package/src/cli/projectCommands.mjs

@@ -0,0 +1,179 @@
+import { BunWorkspacesError } from "../internal/error.mjs";
+import { createLogger, logger } from "../internal/logger.mjs";
+const createWorkspaceInfoLines = (workspace)=>[
+        `Workspace: ${workspace.name}`,
+        ` - Aliases: ${workspace.aliases.join(", ")}`,
+        ` - Path: ${workspace.path}`,
+        ` - Glob Match: ${workspace.matchPattern}`,
+        ` - Scripts: ${Object.keys(workspace.packageJson.scripts).sort().join(", ")}`
+    ];
+const createScriptInfoLines = (script, workspaces)=>[
+        `Script: ${script}`,
+        ...workspaces.map((workspace)=>` - ${workspace.name}`)
+    ];
+const createJsonLines = (data, options)=>JSON.stringify(data, null, options.pretty ? 2 : void 0).split("\n");
+const commandOutputLogger = createLogger("");
+commandOutputLogger.printLevel = "info";
+const listWorkspaces = ({ program, project })=>{
+    program.command("list-workspaces [pattern]").aliases([
+        "ls",
+        "list"
+    ]).description("List all workspaces").option("--name-only", "Only show workspace names").option("--json", "Output as JSON").option("--pretty", "Pretty print JSON").action((pattern, options)=>{
+        logger.debug(`Command: List workspaces (options: ${JSON.stringify(options)})`);
+        const lines = [];
+        const workspaces = pattern ? project.findWorkspacesByPattern(pattern) : project.workspaces;
+        if (options.json) lines.push(...createJsonLines(options.nameOnly ? workspaces.map(({ name })=>name) : workspaces, options));
+        else workspaces.forEach((workspace)=>{
+            if (options.nameOnly) lines.push(workspace.name);
+            else lines.push(...createWorkspaceInfoLines(workspace));
+        });
+        if (!lines.length) logger.info("No workspaces found");
+        if (lines.length) commandOutputLogger.info(lines.join("\n"));
+    });
+};
+const listScripts = ({ program, project })=>{
+    program.command("list-scripts").description("List all scripts available with their workspaces").option("--name-only", "Only show script names").option("--json", "Output as JSON").option("--pretty", "Pretty print JSON").action((options)=>{
+        logger.debug(`Command: List scripts (options: ${JSON.stringify(options)})`);
+        const scripts = project.listScriptsWithWorkspaces();
+        const lines = [];
+        if (options.json) lines.push(...createJsonLines(options.nameOnly ? Object.keys(scripts) : Object.values(scripts).map(({ workspaces, ...rest })=>({
+                ...rest,
+                workspaces: workspaces.map(({ name })=>name)
+            })), options));
+        else {
+            Object.values(scripts).sort(({ name: nameA }, { name: nameB })=>nameA.localeCompare(nameB)).forEach(({ name, workspaces })=>{
+                if (options.nameOnly) lines.push(name);
+                else lines.push(...createScriptInfoLines(name, workspaces));
+            });
+            if (!lines.length) logger.info("No scripts found");
+        }
+        if (lines.length) commandOutputLogger.info(lines.join("\n"));
+    });
+};
+const workspaceInfo = ({ program, project })=>{
+    program.command("workspace-info <workspace>").aliases([
+        "info"
+    ]).description("Show information about a workspace").option("--json", "Output as JSON").option("--pretty", "Pretty print JSON").action((workspaceName, options)=>{
+        logger.debug(`Command: Workspace info for ${workspaceName} (options: ${JSON.stringify(options)})`);
+        const workspace = project.findWorkspaceByNameOrAlias(workspaceName);
+        if (!workspace) return void logger.error(`Workspace not found: (options: ${JSON.stringify(workspaceName)})`);
+        commandOutputLogger.info((options.json ? createJsonLines(workspace, options) : createWorkspaceInfoLines(workspace)).join("\n"));
+    });
+};
+const scriptInfo = ({ program, project })=>{
+    program.command("script-info <script>").description("Show information about a script").option("--workspaces-only", "Only show script's workspace names").option("--json", "Output as JSON").option("--pretty", "Pretty print JSON").action((script, options)=>{
+        logger.debug(`Command: Script info for ${script} (options: ${JSON.stringify(options)})`);
+        const scripts = project.listScriptsWithWorkspaces();
+        const scriptMetadata = scripts[script];
+        if (!scriptMetadata) return void logger.error(`Script not found: ${JSON.stringify(script)} (available: ${Object.keys(scripts).join(", ")})`);
+        commandOutputLogger.info((options.json ? createJsonLines(options.workspacesOnly ? scriptMetadata.workspaces.map(({ name })=>name) : {
+            name: scriptMetadata.name,
+            workspaces: scriptMetadata.workspaces.map(({ name })=>name)
+        }, options) : options.workspacesOnly ? scriptMetadata.workspaces.map(({ name })=>name) : createScriptInfoLines(script, scriptMetadata.workspaces)).join("\n"));
+    });
+};
+const runScript = ({ program, project })=>{
+    program.command("run <script> [workspaces...]").description("Run a script in all workspaces").option("--parallel", "Run the scripts in parallel").option("--args <args>", "Args to append to the script command", "").option("--noPrefix", "Do not prefix the workspace name to the script output", "").action(async (script, _workspaces, options)=>{
+        logger.debug(`Command: Run script ${JSON.stringify(script)} for ${_workspaces.length ? "workspaces " + _workspaces.join(", ") : "all workspaces"} (parallel: ${!!options.parallel}, method: ${JSON.stringify(options.method)}, args: ${JSON.stringify(options.args)})`);
+        const workspaces = _workspaces.length ? _workspaces.flatMap((workspacePattern)=>{
+            if (workspacePattern.includes("*")) return project.findWorkspacesByPattern(workspacePattern).filter(({ packageJson: { scripts } })=>scripts?.[script]).map(({ name })=>name);
+            return [
+                workspacePattern
+            ];
+        }) : project.listWorkspacesWithScript(script).map(({ name })=>name);
+        if (!workspaces.length) program.error(`No ${_workspaces.length ? "matching " : ""}workspaces found for script ${JSON.stringify(script)}`);
+        let scriptCommands;
+        try {
+            scriptCommands = workspaces.map((workspaceName)=>project.createScriptCommand({
+                    scriptName: script,
+                    workspaceName,
+                    method: "cd",
+                    args: options.args.replace(/<workspace>/g, workspaceName)
+                }));
+        } catch (error) {
+            program.error(error.message);
+            throw error;
+        }
+        const runCommand = async ({ command, scriptName, workspace })=>{
+            const commandLogger = createLogger(`${workspace.name}:${scriptName}`);
+            const splitCommand = command.command.split(/\s+/g);
+            commandLogger.debug(`Running script ${scriptName} in workspace ${workspace.name} (cwd: ${command.cwd}): ${splitCommand.join(" ")}`);
+            const isSilent = "silent" === logger.printLevel;
+            const proc = Bun.spawn(command.command.split(/\s+/g), {
+                cwd: command.cwd,
+                env: {
+                    ...process.env,
+                    FORCE_COLOR: "1"
+                },
+                stdout: isSilent ? "ignore" : "pipe",
+                stderr: isSilent ? "ignore" : "pipe"
+            });
+            const linePrefix = options.noPrefix ? "" : `[${workspace.name}:${scriptName}] `;
+            if (proc.stdout) for await (const chunk of proc.stdout)commandLogger.logOutput(chunk, "info", process.stdout, linePrefix);
+            if (proc.stderr) for await (const chunk of proc.stderr)commandLogger.logOutput(chunk, "error", process.stderr, linePrefix);
+            await proc.exited;
+            return {
+                scriptName,
+                workspace,
+                command,
+                success: 0 === proc.exitCode,
+                error: 0 === proc.exitCode ? null : new BunWorkspacesError(`Script exited with code ${proc.exitCode}`)
+            };
+        };
+        const results = [];
+        if (options.parallel) {
+            let i = 0;
+            for await (const result of (await Promise.allSettled(scriptCommands.map(runCommand)))){
+                if ("rejected" === result.status) results.push({
+                    success: false,
+                    workspaceName: workspaces[i],
+                    error: result.reason
+                });
+                else results.push({
+                    success: result.value.success,
+                    workspaceName: workspaces[i],
+                    error: result.value.error
+                });
+                i++;
+            }
+        } else {
+            let i = 0;
+            for (const command of scriptCommands){
+                try {
+                    const result = await runCommand(command);
+                    results.push({
+                        success: result.success,
+                        workspaceName: workspaces[i],
+                        error: result.error
+                    });
+                } catch (error) {
+                    results.push({
+                        success: false,
+                        workspaceName: workspaces[i],
+                        error: error
+                    });
+                }
+                i++;
+            }
+        }
+        let failCount = 0;
+        results.forEach(({ success, workspaceName })=>{
+            if (!success) failCount++;
+            logger.info(`${success ? "✅" : "❌"} ${workspaceName}: ${script}`);
+        });
+        const s = 1 === results.length ? "" : "s";
+        if (failCount) {
+            const message = `${failCount} of ${results.length} script${s} failed`;
+            logger.error(message);
+            process.exit(1);
+        } else logger.info(`${results.length} script${s} ran successfully`);
+    });
+};
+const defineProjectCommands = (context)=>{
+    listWorkspaces(context);
+    listScripts(context);
+    workspaceInfo(context);
+    scriptInfo(context);
+    runScript(context);
+};
+export { commandOutputLogger, defineProjectCommands };

package/src/config/bunWorkspacesConfig.d.ts

@@ -0,0 +1,13 @@
+import { type LogLevelSetting } from "../internal/logger";
+export interface CliConfig {
+    logLevel?: LogLevelSetting;
+}
+export interface ProjectConfig {
+    /** A map of aliases to a workspace name */
+    workspaceAliases?: Record<string, string>;
+}
+export interface BunWorkspacesConfig {
+    cli?: CliConfig;
+    project?: ProjectConfig;
+}
+export declare const validateBunWorkspacesConfig: (config: BunWorkspacesConfig) => void;

package/src/config/bunWorkspacesConfig.mjs

@@ -0,0 +1,18 @@
+import { validateLogLevel } from "../internal/logger.mjs";
+const validateCliConfig = (cliConfig)=>{
+    if ("object" != typeof cliConfig || Array.isArray(cliConfig)) throw new Error('Config file: "cli" must be an object');
+    if (cliConfig?.logLevel) validateLogLevel(cliConfig.logLevel);
+};
+const validateProjectConfig = (projectConfig)=>{
+    if ("object" != typeof projectConfig || Array.isArray(projectConfig)) throw new Error('Config file: "project" must be an object');
+    if (projectConfig?.workspaceAliases) {
+        if ("object" != typeof projectConfig.workspaceAliases || Array.isArray(projectConfig.workspaceAliases)) throw new Error("Config file: project.workspaceAliases must be an object");
+        for (const alias of Object.values(projectConfig.workspaceAliases))if ("string" != typeof alias) throw new Error("Config file: project.workspaceAliases must be an object with string keys and values");
+    }
+};
+const validateBunWorkspacesConfig = (config)=>{
+    if ("object" != typeof config || Array.isArray(config)) throw new Error("Config file: must be an object");
+    if (void 0 !== config.cli) validateCliConfig(config.cli);
+    if (void 0 !== config.project) validateProjectConfig(config.project);
+};
+export { validateBunWorkspacesConfig };

package/src/config/configFile.d.ts

@@ -0,0 +1,3 @@
+import { type BunWorkspacesConfig } from "./bunWorkspacesConfig";
+export declare const DEFAULT_CONFIG_FILE_PATH = "bw.json";
+export declare const loadConfigFile: (filePath?: string | undefined, rootDir?: string) => BunWorkspacesConfig | null;

package/src/config/configFile.mjs

@@ -0,0 +1,21 @@
+import fs from "fs";
+import path from "path";
+import { validateBunWorkspacesConfig } from "./bunWorkspacesConfig.mjs";
+const DEFAULT_CONFIG_FILE_PATH = "bw.json";
+const loadConfigFile = (filePath, rootDir = ".")=>{
+    if (!filePath) {
+        const defaultFilePath = path.resolve(rootDir, DEFAULT_CONFIG_FILE_PATH);
+        if (!fs.existsSync(defaultFilePath)) return null;
+        filePath = defaultFilePath;
+    }
+    filePath = path.resolve(rootDir, filePath);
+    const configFile = fs.readFileSync(filePath, "utf8");
+    try {
+        const json = JSON.parse(configFile);
+        validateBunWorkspacesConfig(json);
+        return json;
+    } catch (error) {
+        throw new Error(`Config file: "${filePath}" is not a valid JSON file: ${error}`);
+    }
+};
+export { DEFAULT_CONFIG_FILE_PATH, loadConfigFile };

package/src/config/index.d.ts

@@ -0,0 +1,2 @@
+export { validateBunWorkspacesConfig, type BunWorkspacesConfig, type CliConfig, type ProjectConfig, } from "./bunWorkspacesConfig";
+export { loadConfigFile, DEFAULT_CONFIG_FILE_PATH } from "./configFile";

package/src/config/index.mjs

@@ -0,0 +1,3 @@
+import { validateBunWorkspacesConfig } from "./bunWorkspacesConfig.mjs";
+import { DEFAULT_CONFIG_FILE_PATH, loadConfigFile } from "./configFile.mjs";
+export { DEFAULT_CONFIG_FILE_PATH, loadConfigFile, validateBunWorkspacesConfig };

package/src/index.mjs

@@ -0,0 +1,3 @@
+export * from "./workspaces/index.mjs";
+export * from "./project/index.mjs";
+export * from "./cli/index.mjs";

package/src/internal/bunVersion.d.ts

@@ -0,0 +1,14 @@
+export declare const LIBRARY_CONSUMER_BUN_VERSION: string;
+export declare const BUILD_BUN_VERSION: string;
+export declare const getRequiredBunVersion: (build?: boolean | undefined) => string;
+/**
+ * Validates that the provided version satisfies the required Bun version
+ * specified in the root `package.json`.
+ */
+export declare const validateBunVersion: (version: string, build?: boolean | undefined) => boolean;
+/**
+ *
+ * Validates that the Bun version of the current script satisfies the
+ * required Bun version specified in the root `package.json`.
+ */
+export declare const validateCurrentBunVersion: (build?: boolean | undefined) => boolean;

package/src/internal/bunVersion.mjs

@@ -0,0 +1,8 @@
+import package_0 from "../../package.json";
+const LIBRARY_CONSUMER_BUN_VERSION = package_0.custom.bunVersion.libraryConsumer;
+const BUILD_BUN_VERSION = package_0.custom.bunVersion.build;
+const getRequiredBunVersion = (build)=>build ? BUILD_BUN_VERSION : LIBRARY_CONSUMER_BUN_VERSION;
+const _Bun = "undefined" == typeof Bun ? null : Bun;
+const validateBunVersion = (version, build)=>_Bun ? _Bun.semver.satisfies(version, getRequiredBunVersion(build)) : false;
+const validateCurrentBunVersion = (build)=>validateBunVersion(_Bun?.version ?? "(Error: not Bun runtime)", build);
+export { BUILD_BUN_VERSION, LIBRARY_CONSUMER_BUN_VERSION, getRequiredBunVersion, validateBunVersion, validateCurrentBunVersion };

package/src/internal/env.d.ts

@@ -0,0 +1,5 @@
+export type RuntimeMode = "development" | "production" | "test";
+export declare const RUNTIME_MODE: RuntimeMode;
+export declare const IS_TEST: boolean;
+export declare const IS_PRODUCTION: boolean;
+export declare const IS_DEVELOPMENT: boolean;

package/src/internal/env.mjs

@@ -0,0 +1,12 @@
+const RUNTIME_MODE_VALUES = [
+    "development",
+    "production",
+    "test"
+];
+const _RUNTIME_MODE = process.env._BW_RUNTIME_MODE || (process.env.NODE_ENV?.match(/test(ing)?/) ? "test" : "development" === process.env.NODE_ENV ? "development" : "production");
+const RUNTIME_MODE = RUNTIME_MODE_VALUES.includes(_RUNTIME_MODE) ? _RUNTIME_MODE : "production";
+if (RUNTIME_MODE !== _RUNTIME_MODE) console.error(`Env var RUNTIME_MODE has an invalid value: "${_RUNTIME_MODE}". Defaulting to "${RUNTIME_MODE}". Accepted values: ${RUNTIME_MODE_VALUES.join(", ")}.`);
+const IS_TEST = "test" === RUNTIME_MODE;
+const IS_PRODUCTION = "production" === RUNTIME_MODE;
+const IS_DEVELOPMENT = "development" === RUNTIME_MODE;
+export { IS_DEVELOPMENT, IS_PRODUCTION, IS_TEST, RUNTIME_MODE };

package/src/internal/error.d.ts

@@ -0,0 +1,7 @@
+export declare class BunWorkspacesError extends Error {
+    name: string;
+}
+export type DefinedErrors<ErrorName extends string> = {
+    [name in ErrorName]: typeof BunWorkspacesError;
+};
+export declare const defineErrors: <ErrorName extends string>(...errors: ErrorName[]) => DefinedErrors<ErrorName>;

package/src/internal/error.mjs

@@ -0,0 +1,26 @@
+class BunWorkspacesError extends Error {
+    name = "BunWorkspacesError";
+}
+const defineErrors = (...errors)=>errors.reduce((acc, error)=>{
+        acc[error] = class extends BunWorkspacesError {
+            constructor(message){
+                super(message);
+                this.name = error;
+            }
+            name = error;
+        };
+        Object.defineProperty(acc[error].prototype.constructor, "name", {
+            value: error
+        });
+        Object.defineProperty(acc[error].constructor, "name", {
+            value: error
+        });
+        Object.defineProperty(acc[error].prototype, "name", {
+            value: error
+        });
+        Object.defineProperty(acc[error], "name", {
+            value: error
+        });
+        return acc;
+    }, {});
+export { BunWorkspacesError, defineErrors };

package/src/internal/logger.d.ts

@@ -0,0 +1,21 @@
+export declare const LOG_LEVELS: readonly ["debug", "info", "warn", "error"];
+export type LogLevel = (typeof LOG_LEVELS)[number];
+export type LogLevelSetting = LogLevel | "silent";
+export declare const validateLogLevel: (level: LogLevelSetting) => void;
+export type LogMetadata = Record<string, any>;
+export interface Log<Message extends string | Error = string, Metadata extends LogMetadata = LogMetadata> {
+    message: Message;
+    level: LogLevel;
+    metadata: Metadata;
+    time: Date;
+}
+export type Logger = {
+    name: string;
+    log<Message extends string | Error = string, Metadata extends LogMetadata = LogMetadata>(message: Message, level: LogLevel, metadata?: Metadata): Log<Message, Metadata>;
+    logOutput(chunk: Uint8Array, level: LogLevel, stream: NodeJS.WriteStream, prefix: string): Log<string, Record<string, unknown>>;
+    printLevel: LogLevelSetting;
+} & {
+    [Level in LogLevel]: <Message extends string | Error = string, Metadata extends LogMetadata = LogMetadata>(message: Message, metadata?: Metadata) => Log<Message, Metadata>;
+};
+export declare const createLogger: (name: string) => Logger;
+export declare const logger: Logger;

package/src/internal/logger.mjs

@@ -0,0 +1,85 @@
+import { IS_PRODUCTION, IS_TEST } from "./env.mjs";
+const LOG_LEVELS = [
+    "debug",
+    "info",
+    "warn",
+    "error"
+];
+const getLevelNumber = (level)=>LOG_LEVELS.indexOf(level);
+const validateLogLevel = (level)=>{
+    if ("silent" === level) return;
+    if (!LOG_LEVELS.includes(level)) throw new Error(`Invalid log level: "${level}". Accepted values: ${LOG_LEVELS.join(", ")}`);
+};
+const createLogger = (name)=>new _Logger(name);
+class _Logger {
+    name;
+    constructor(name){
+        this.name = name;
+    }
+    log(message, level, metadata) {
+        const log = {
+            message,
+            level,
+            metadata: metadata ?? {},
+            time: new Date()
+        };
+        if (this.shouldPrint(level)) {
+            const formattedMessage = this.formatLogMessage(message, level);
+            if (message instanceof Error) message.message = formattedMessage;
+            console[level](message instanceof Error ? message : formattedMessage, ...metadata ? [
+                {
+                    metadata
+                }
+            ] : []);
+        }
+        return log;
+    }
+    logOutput(chunk, level, stream, prefix) {
+        const message = new TextDecoder().decode(chunk).trim();
+        const log = {
+            message,
+            level,
+            metadata: {
+                stream,
+                isLogOutput: true
+            },
+            time: new Date()
+        };
+        if (!this.shouldPrint(level)) return log;
+        const linePrefix = `${prefix}\x1b[0m`;
+        const lines = message.split(/\r?\n/);
+        lines.forEach((line)=>{
+            if (line) stream.write(linePrefix + line + "\n");
+        });
+        return log;
+    }
+    debug(message, metadata) {
+        return this.log(message, "debug", metadata);
+    }
+    info(message, metadata) {
+        return this.log(message, "info", metadata);
+    }
+    warn(message, metadata) {
+        return this.log(message, "warn", metadata);
+    }
+    error(message, metadata) {
+        return this.log(message, "error", metadata);
+    }
+    get printLevel() {
+        return this._printLevel;
+    }
+    set printLevel(level) {
+        this._printLevel = level;
+    }
+    formatLogMessage(message, level) {
+        const content = message instanceof Error ? message.message : message;
+        return "debug" === level || "warn" === level ? `[${this.name} ${level.toUpperCase()}]: ${content}` : content;
+    }
+    _printLevel = IS_PRODUCTION ? "info" : IS_TEST ? "silent" : "debug";
+    shouldPrint(level) {
+        if ("silent" === this.printLevel) return false;
+        return getLevelNumber(level) >= getLevelNumber(this.printLevel);
+    }
+}
+const logger = createLogger("bun-workspaces");
+export { LOG_LEVELS, createLogger, logger, validateLogLevel };