@gjsify/cli 0.0.4 → 0.1.1

package/README.md

@@ -0,0 +1,30 @@
+# @gjsify/cli
+
+CLI tool for building and running GJS applications. Bundles TypeScript/JavaScript using esbuild with automatic Node.js to GJS module aliasing.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Installation
+
+```bash
+npm install @gjsify/cli
+# or
+yarn add @gjsify/cli
+```
+
+## Usage
+
+```bash
+# Build a GJS application
+npx @gjsify/cli build src/index.ts
+
+# Run a built GJS application (sets up LD_LIBRARY_PATH, GI_TYPELIB_PATH, etc.)
+npx @gjsify/cli run dist/index.js
+
+# Show environment info for a bundle
+npx @gjsify/cli info dist/index.js
+```
+
+## License
+
+MIT

package/lib/actions/build.d.ts

@@ -9,86 +9,87 @@ export declare class BuildAction {
     buildLibrary(): Promise<BuildResult<BuildOptions>[]>;
     /** Application mode */
     buildApp(app?: App): Promise<BuildResult<{
-        format: "cjs" | "esm";
+        format: "esm" | "cjs";
         plugins: import("esbuild").Plugin[];
-        bundle?: boolean | undefined;
-        splitting?: boolean | undefined;
-        preserveSymlinks?: boolean | undefined;
-        outfile?: string | undefined;
-        metafile?: boolean | undefined;
-        outdir?: string | undefined;
-        outbase?: string | undefined;
-        external?: string[] | undefined;
-        packages?: "external" | undefined;
-        alias?: Record<string, string> | undefined;
+        bundle?: boolean;
+        splitting?: boolean;
+        preserveSymlinks?: boolean;
+        outfile?: string;
+        metafile?: boolean;
+        outdir?: string;
+        outbase?: string;
+        external?: string[];
+        packages?: "bundle" | "external";
+        alias?: Record<string, string>;
         loader?: {
             [ext: string]: import("esbuild").Loader;
-        } | undefined;
-        resolveExtensions?: string[] | undefined;
-        mainFields?: string[] | undefined;
-        conditions?: string[] | undefined;
-        write?: boolean | undefined;
-        allowOverwrite?: boolean | undefined;
-        tsconfig?: string | undefined;
+        };
+        resolveExtensions?: string[];
+        mainFields?: string[];
+        conditions?: string[];
+        write?: boolean;
+        allowOverwrite?: boolean;
+        tsconfig?: string;
         outExtension?: {
             [ext: string]: string;
-        } | undefined;
-        publicPath?: string | undefined;
-        entryNames?: string | undefined;
-        chunkNames?: string | undefined;
-        assetNames?: string | undefined;
-        inject?: string[] | undefined;
+        };
+        publicPath?: string;
+        entryNames?: string;
+        chunkNames?: string;
+        assetNames?: string;
+        inject?: string[];
         banner?: {
             [type: string]: string;
-        } | undefined;
+        };
         footer?: {
             [type: string]: string;
-        } | undefined;
-        entryPoints?: string[] | Record<string, string> | {
+        };
+        entryPoints?: (string | {
             in: string;
             out: string;
-        }[] | undefined;
-        stdin?: import("esbuild").StdinOptions | undefined;
-        absWorkingDir?: string | undefined;
-        nodePaths?: string[] | undefined;
-        sourcemap?: boolean | "inline" | "both" | "external" | "linked" | undefined;
-        legalComments?: "inline" | "none" | "external" | "linked" | "eof" | undefined;
-        sourceRoot?: string | undefined;
-        sourcesContent?: boolean | undefined;
-        globalName?: string | undefined;
-        target?: string | string[] | undefined;
-        supported?: Record<string, boolean> | undefined;
-        platform?: import("esbuild").Platform | undefined;
-        mangleProps?: RegExp | undefined;
-        reserveProps?: RegExp | undefined;
-        mangleQuoted?: boolean | undefined;
-        mangleCache?: Record<string, string | false> | undefined;
-        drop?: import("esbuild").Drop[] | undefined;
-        dropLabels?: string[] | undefined;
-        minify?: boolean | undefined;
-        minifyWhitespace?: boolean | undefined;
-        minifyIdentifiers?: boolean | undefined;
-        minifySyntax?: boolean | undefined;
-        lineLimit?: number | undefined;
-        charset?: import("esbuild").Charset | undefined;
-        treeShaking?: boolean | undefined;
-        ignoreAnnotations?: boolean | undefined;
-        jsx?: "transform" | "preserve" | "automatic" | undefined;
-        jsxFactory?: string | undefined;
-        jsxFragment?: string | undefined;
-        jsxImportSource?: string | undefined;
-        jsxDev?: boolean | undefined;
-        jsxSideEffects?: boolean | undefined;
+        })[] | Record<string, string>;
+        stdin?: import("esbuild").StdinOptions;
+        absWorkingDir?: string;
+        nodePaths?: string[];
+        sourcemap?: boolean | "linked" | "inline" | "external" | "both";
+        legalComments?: "none" | "inline" | "eof" | "linked" | "external";
+        sourceRoot?: string;
+        sourcesContent?: boolean;
+        globalName?: string;
+        target?: string | string[];
+        supported?: Record<string, boolean>;
+        platform?: import("esbuild").Platform;
+        mangleProps?: RegExp;
+        reserveProps?: RegExp;
+        mangleQuoted?: boolean;
+        mangleCache?: Record<string, string | false>;
+        drop?: import("esbuild").Drop[];
+        dropLabels?: string[];
+        minify?: boolean;
+        minifyWhitespace?: boolean;
+        minifyIdentifiers?: boolean;
+        minifySyntax?: boolean;
+        lineLimit?: number;
+        charset?: import("esbuild").Charset;
+        treeShaking?: boolean;
+        ignoreAnnotations?: boolean;
+        jsx?: "transform" | "preserve" | "automatic";
+        jsxFactory?: string;
+        jsxFragment?: string;
+        jsxImportSource?: string;
+        jsxDev?: boolean;
+        jsxSideEffects?: boolean;
         define?: {
             [key: string]: string;
-        } | undefined;
-        pure?: string[] | undefined;
-        keepNames?: boolean | undefined;
-        color?: boolean | undefined;
-        logLevel?: import("esbuild").LogLevel | undefined;
-        logLimit?: number | undefined;
-        logOverride?: Record<string, import("esbuild").LogLevel> | undefined;
-        tsconfigRaw?: string | import("esbuild").TsconfigRaw | undefined;
+        };
+        pure?: string[];
+        keepNames?: boolean;
+        absPaths?: import("esbuild").AbsPaths[];
+        color?: boolean;
+        logLevel?: import("esbuild").LogLevel;
+        logLimit?: number;
+        logOverride?: Record<string, import("esbuild").LogLevel>;
+        tsconfigRaw?: string | import("esbuild").TsconfigRaw;
     }>[]>;
     start(buildType?: {
         library?: boolean;

package/lib/actions/build.js

@@ -50,7 +50,7 @@ export class BuildAction {
             const outfilePath = esbuild?.outfile || library?.module || library?.main;
             const outExt = outfilePath ? extname(outfilePath) : '.js';
             const outdir = esbuild?.outdir || (outfilePath ? dirname(outfilePath) : undefined);
-            const format = esbuild?.format || outdir?.includes('/cjs') || outExt === '.cjs' ? 'cjs' : 'esm';
+            const format = esbuild?.format ?? (outdir?.includes('/cjs') || outExt === '.cjs' ? 'cjs' : 'esm');
             results.push(await build({
                 ...this.getEsBuildDefaults(),
                 ...esbuild,
@@ -66,17 +66,18 @@ export class BuildAction {
     /** Application mode */
     async buildApp(app = 'gjs') {
         const { verbose, esbuild, typescript, exclude, library: pgk } = this.configData;
-        const format = esbuild?.format || esbuild?.outfile?.endsWith('.cjs') ? 'cjs' : 'esm';
+        const format = esbuild?.format ?? (esbuild?.outfile?.endsWith('.cjs') ? 'cjs' : 'esm');
         // Set default outfile if no outdir is set 
         if (esbuild && !esbuild?.outfile && !esbuild?.outdir && (pgk?.main || pgk?.module)) {
             esbuild.outfile = esbuild?.format === 'cjs' ? pgk.main || pgk.module : pgk.module || pgk.main;
         }
+        const { consoleShim } = this.configData;
         const result = await build({
             ...this.getEsBuildDefaults(),
             ...esbuild,
             format,
             plugins: [
-                gjsifyPlugin({ debug: verbose, app, format, exclude, reflection: typescript?.reflection }),
+                gjsifyPlugin({ debug: verbose, app, format, exclude, reflection: typescript?.reflection, consoleShim }),
             ]
         });
         // See https://esbuild.github.io/api/#metafile

package/lib/commands/build.js

@@ -30,9 +30,9 @@ export const buildCommand = {
             default: false
         })
             .option('app', {
-            description: "Use this if you want to build a application, the application platforms node and deno are usually only used for tests",
+            description: "Use this if you want to build an application, the platform node is usually only used for tests",
             type: 'string',
-            choices: ['gjs', 'node', 'deno', 'browser'],
+            choices: ['gjs', 'node', 'browser'],
             normalize: true,
             default: 'gjs'
         })
@@ -79,6 +79,12 @@ export const buildCommand = {
             choices: ['silent', 'error', 'warning', 'info', 'debug', 'verbose'],
             normalize: true,
             default: 'warning'
+        })
+            .option('console-shim', {
+            description: "Inject a console shim into GJS builds for clean output without the GLib prefix and with working ANSI colors. Use --no-console-shim to disable. Only applies to GJS app builds.",
+            type: 'boolean',
+            normalize: true,
+            default: true
         });
     },
     handler: async (args) => {

package/lib/commands/index.d.ts

@@ -1 +1,3 @@
 export * from './build.js';
+export * from './run.js';
+export * from './info.js';

package/lib/commands/index.js

@@ -1 +1,3 @@
 export * from './build.js';
+export * from './run.js';
+export * from './info.js';

package/lib/commands/info.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from '../types/index.js';
+interface InfoOptions {
+    export: boolean;
+    file?: string;
+}
+export declare const infoCommand: Command<any, InfoOptions>;
+export {};

package/lib/commands/info.js

@@ -0,0 +1,59 @@
+import { resolve } from 'node:path';
+import { detectNativePackages, buildNativeEnv } from '../utils/detect-native-packages.js';
+export const infoCommand = {
+    command: 'info [file]',
+    description: 'Show native gjsify packages detected in node_modules and the env vars needed to run a GJS bundle directly with gjs.',
+    builder: (yargs) => {
+        return yargs
+            .positional('file', {
+            description: 'Optional: the GJS bundle path to include in the example command (e.g. dist/gjs.js)',
+            type: 'string',
+            normalize: true,
+        })
+            .option('export', {
+            description: 'Output only shell export statements suitable for eval (eval $(gjsify info --export))',
+            type: 'boolean',
+            default: false,
+        });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const file = args.file ? resolve(args.file) : null;
+        const nativePackages = detectNativePackages(cwd);
+        const { LD_LIBRARY_PATH, GI_TYPELIB_PATH } = buildNativeEnv(nativePackages);
+        if (args.export) {
+            // Machine-readable output for eval
+            console.log(`export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}"`);
+            console.log(`export GI_TYPELIB_PATH="${GI_TYPELIB_PATH}"`);
+            return;
+        }
+        // Human-readable output
+        if (nativePackages.length === 0) {
+            console.log('No native gjsify packages detected in node_modules.');
+            console.log('Native packages declare "gjsify": { "prebuilds": "<dir>" } in their package.json.');
+            return;
+        }
+        console.log('Native packages detected:');
+        for (const pkg of nativePackages) {
+            console.log(`  ${pkg.name}  →  ${pkg.prebuildsDir}`);
+        }
+        console.log('');
+        console.log('To run your app directly with gjs, set:');
+        console.log(`  export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}"`);
+        console.log(`  export GI_TYPELIB_PATH="${GI_TYPELIB_PATH}"`);
+        if (file) {
+            console.log(`  gjs -m ${file}`);
+        }
+        else {
+            console.log('  gjs -m <your-bundle.js>');
+        }
+        console.log('');
+        console.log('Or use gjsify run to handle this automatically:');
+        if (file) {
+            console.log(`  gjsify run ${args.file}`);
+        }
+        else {
+            console.log('  gjsify run <your-bundle.js>');
+        }
+    },
+};

package/lib/commands/run.d.ts

@@ -0,0 +1,7 @@
+import type { Command } from '../types/index.js';
+interface RunOptions {
+    file: string;
+    args: string[];
+}
+export declare const runCommand: Command<any, RunOptions>;
+export {};

package/lib/commands/run.js

@@ -0,0 +1,49 @@
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import { detectNativePackages, buildNativeEnv } from '../utils/detect-native-packages.js';
+export const runCommand = {
+    command: 'run <file> [args..]',
+    description: 'Run a GJS bundle, automatically setting LD_LIBRARY_PATH and GI_TYPELIB_PATH for any installed native gjsify packages (e.g. @gjsify/webgl).',
+    builder: (yargs) => {
+        return yargs
+            .positional('file', {
+            description: 'The GJS bundle to run (e.g. dist/gjs.js)',
+            type: 'string',
+            normalize: true,
+            demandOption: true,
+        })
+            .positional('args', {
+            description: 'Extra arguments passed through to gjs',
+            type: 'string',
+            array: true,
+            default: [],
+        });
+    },
+    handler: async (args) => {
+        const file = resolve(args.file);
+        const extraArgs = args.args ?? [];
+        const cwd = process.cwd();
+        const nativePackages = detectNativePackages(cwd);
+        const nativeEnv = buildNativeEnv(nativePackages);
+        const env = {
+            ...process.env,
+            ...nativeEnv,
+        };
+        const gjsArgs = ['-m', file, ...extraArgs];
+        const child = spawn('gjs', gjsArgs, { env, stdio: 'inherit' });
+        await new Promise((resolvePromise, reject) => {
+            child.on('close', (code) => {
+                if (code !== 0) {
+                    reject(new Error(`gjs exited with code ${code}`));
+                }
+                else {
+                    resolvePromise();
+                }
+            });
+            child.on('error', reject);
+        }).catch((err) => {
+            console.error(err.message);
+            process.exit(1);
+        });
+    },
+};

package/lib/config.d.ts

@@ -1,4 +1,4 @@
-import { Options as LoadOptions } from 'cosmiconfig';
+import { type Options as LoadOptions } from 'cosmiconfig';
 import type { CliBuildOptions, ConfigData } from './types/index.js';
 import type { ArgumentsCamelCase } from 'yargs';
 export declare class Config {

package/lib/config.js

@@ -2,8 +2,29 @@ import { APP_NAME } from './constants.js';
 import { cosmiconfig } from 'cosmiconfig';
 import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
 import { getTsconfig } from 'get-tsconfig';
-import lodash from "lodash";
-const { merge } = lodash;
+/** Deep merge objects (replaces lodash.merge) */
+function merge(target, ...sources) {
+    for (const source of sources) {
+        if (!source)
+            continue;
+        for (const key of Object.keys(source)) {
+            const targetVal = target[key];
+            const sourceVal = source[key];
+            if (sourceVal !== undefined) {
+                if (isPlainObject(targetVal) && isPlainObject(sourceVal)) {
+                    merge(targetVal, sourceVal);
+                }
+                else {
+                    target[key] = sourceVal;
+                }
+            }
+        }
+    }
+    return target;
+}
+function isPlainObject(val) {
+    return typeof val === 'object' && val !== null && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
+}
 export class Config {
     loadOptions = {};
     constructor(loadOptions = {}) {
@@ -46,9 +67,11 @@ export class Config {
         // TODO replace with `cliArgs.logLevel`
         configData.verbose = cliArgs.verbose || false;
         configData.exclude = cliArgs.exclude || [];
-        merge(configData.library, pkg, configData.library);
-        merge(configData.typescript, tsConfig, configData.typescript);
-        merge(configData.esbuild, {
+        if (cliArgs.consoleShim !== undefined)
+            configData.consoleShim = cliArgs.consoleShim;
+        merge(configData.library ??= {}, pkg, configData.library);
+        merge(configData.typescript ??= {}, tsConfig, configData.typescript);
+        merge(configData.esbuild ??= {}, {
             format: cliArgs.format,
             minify: cliArgs.minify,
             entryPoints: cliArgs.entryPoints,

package/lib/index.js

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
-import { buildCommand as build } from './commands/index.js';
+import { buildCommand as build, runCommand as run, infoCommand as info } from './commands/index.js';
 import { APP_NAME } from './constants.js';
 void yargs(hideBin(process.argv))
     .scriptName(APP_NAME)
     .strict()
     // .usage(Config.usage)
     .command(build.command, build.description, build.builder, build.handler)
+    .command(run.command, run.description, run.builder, run.handler)
+    .command(info.command, info.description, info.builder, info.handler)
     .demandCommand(1)
     .help().argv;

package/lib/types/cli-build-options.d.ts

@@ -17,7 +17,7 @@ export interface CliBuildOptions {
      * @see https://esbuild.github.io/api/#format
      */
     format?: 'iife' | 'esm' | 'cjs';
-    /** Use this if you want to build a application or test, the platforms node and deno are usually only used internally to build the tests for Gjsify */
+    /** Use this if you want to build an application or test, the platform node is usually only used internally to build the tests for Gjsify */
     app?: App;
     /** Use this if you want to build a library for Gjsify */
     library?: boolean;
@@ -42,4 +42,9 @@ export interface CliBuildOptions {
     logLevel: 'silent' | 'error' | 'warning' | 'info' | 'debug' | 'verbose';
     /** An array of glob patterns to exclude matches and aliases */
     exclude?: string[];
+    /**
+     * Inject a console shim into GJS builds for clean output (no GLib prefix, ANSI colors work).
+     * Use --no-console-shim to disable. Only applies to GJS app builds. Default: true.
+     */
+    consoleShim?: boolean;
 }

package/lib/types/config-data.d.ts

@@ -8,4 +8,9 @@ export interface ConfigData {
     typescript?: ConfigDataTypescript;
     /** An array of glob patterns to exclude matches and aliases */
     exclude?: string[];
+    /**
+     * Inject a console shim into GJS builds for clean output (no GLib prefix, ANSI colors work).
+     * Only applies to GJS app builds. Default: true.
+     */
+    consoleShim?: boolean;
 }

package/lib/utils/detect-native-packages.d.ts

@@ -0,0 +1,22 @@
+export interface NativePackage {
+    /** npm package name, e.g. "@gjsify/webgl" */
+    name: string;
+    /** Absolute path to the arch-specific prebuilds dir, e.g. "/…/@gjsify/webgl/prebuilds/linux-x86_64" */
+    prebuildsDir: string;
+}
+/**
+ * Walk up the directory tree from `startDir` looking for a node_modules directory.
+ * Returns all native packages found in the first node_modules encountered.
+ *
+ * Note: This intentionally stops at the first node_modules to match how Node.js
+ * resolves packages from the perspective of the calling project.
+ */
+export declare function detectNativePackages(startDir: string): NativePackage[];
+/**
+ * Build the LD_LIBRARY_PATH and GI_TYPELIB_PATH env var values for the detected native packages.
+ * Prepends the new paths to any existing values from the environment.
+ */
+export declare function buildNativeEnv(packages: NativePackage[]): {
+    LD_LIBRARY_PATH: string;
+    GI_TYPELIB_PATH: string;
+};

package/lib/utils/detect-native-packages.js

@@ -0,0 +1,119 @@
+// Utility to find npm packages with gjsify native prebuilds.
+// Packages declare: "gjsify": { "prebuilds": "<dir>" } in their package.json.
+// The CLI uses this to auto-set LD_LIBRARY_PATH / GI_TYPELIB_PATH before running gjs.
+import { readdirSync, existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+/** Map Node.js process.arch values to the convention used in prebuilds/ directories. */
+function nodeArchToLinuxArch(arch) {
+    const map = {
+        x64: 'x86_64',
+        arm64: 'aarch64',
+        arm: 'armv7',
+        ia32: 'i686',
+    };
+    return map[arch] ?? arch;
+}
+/** Read a package.json file and return its parsed content, or null on error. */
+function readPackageJson(pkgJsonPath) {
+    try {
+        return JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Scan all packages in a node_modules directory for gjsify native prebuilds.
+ * Handles scoped packages (@scope/name) as well as flat packages.
+ */
+function scanNodeModules(nodeModulesDir, arch) {
+    const results = [];
+    if (!existsSync(nodeModulesDir))
+        return results;
+    let entries;
+    try {
+        entries = readdirSync(nodeModulesDir);
+    }
+    catch {
+        return results;
+    }
+    for (const entry of entries) {
+        if (entry.startsWith('.'))
+            continue;
+        if (entry.startsWith('@')) {
+            // Scoped packages — one more level deep
+            const scopeDir = join(nodeModulesDir, entry);
+            let scopeEntries;
+            try {
+                scopeEntries = readdirSync(scopeDir);
+            }
+            catch {
+                continue;
+            }
+            for (const scopedPkg of scopeEntries) {
+                const pkgDir = join(scopeDir, scopedPkg);
+                const native = checkPackage(pkgDir, `${entry}/${scopedPkg}`, arch);
+                if (native)
+                    results.push(native);
+            }
+        }
+        else {
+            const pkgDir = join(nodeModulesDir, entry);
+            const native = checkPackage(pkgDir, entry, arch);
+            if (native)
+                results.push(native);
+        }
+    }
+    return results;
+}
+/** Check a single package directory for gjsify prebuilds metadata. */
+function checkPackage(pkgDir, name, arch) {
+    const pkgJson = readPackageJson(join(pkgDir, 'package.json'));
+    if (!pkgJson)
+        return null;
+    const gjsifyMeta = pkgJson['gjsify'];
+    if (!gjsifyMeta || typeof gjsifyMeta !== 'object')
+        return null;
+    const prebuildsField = gjsifyMeta['prebuilds'];
+    if (typeof prebuildsField !== 'string')
+        return null;
+    const prebuildsDir = join(pkgDir, prebuildsField, `linux-${arch}`);
+    if (!existsSync(prebuildsDir))
+        return null;
+    return { name, prebuildsDir };
+}
+/**
+ * Walk up the directory tree from `startDir` looking for a node_modules directory.
+ * Returns all native packages found in the first node_modules encountered.
+ *
+ * Note: This intentionally stops at the first node_modules to match how Node.js
+ * resolves packages from the perspective of the calling project.
+ */
+export function detectNativePackages(startDir) {
+    const arch = nodeArchToLinuxArch(process.arch);
+    let dir = resolve(startDir);
+    // Walk up to filesystem root
+    while (true) {
+        const nodeModulesDir = join(dir, 'node_modules');
+        if (existsSync(nodeModulesDir)) {
+            return scanNodeModules(nodeModulesDir, arch);
+        }
+        const parent = resolve(dir, '..');
+        if (parent === dir)
+            break; // reached filesystem root
+        dir = parent;
+    }
+    return [];
+}
+/**
+ * Build the LD_LIBRARY_PATH and GI_TYPELIB_PATH env var values for the detected native packages.
+ * Prepends the new paths to any existing values from the environment.
+ */
+export function buildNativeEnv(packages) {
+    const dirs = packages.map(p => p.prebuildsDir);
+    const existing_ld = process.env['LD_LIBRARY_PATH'] ?? '';
+    const existing_gi = process.env['GI_TYPELIB_PATH'] ?? '';
+    const LD_LIBRARY_PATH = [...dirs, ...(existing_ld ? [existing_ld] : [])].join(':');
+    const GI_TYPELIB_PATH = [...dirs, ...(existing_gi ? [existing_gi] : [])].join(':');
+    return { LD_LIBRARY_PATH, GI_TYPELIB_PATH };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/cli",
-  "version": "0.0.4",
+  "version": "0.1.1",
   "description": "CLI for Gjsify",
   "type": "module",
   "main": "lib/index.js",
@@ -10,10 +10,10 @@
     "gjsify": "./lib/index.js"
   },
   "scripts": {
-    "clear": "rm -rf lib tsconfig.tsbuildinfo tsconfig.types.tsbuildinfo || exit 0",
-    "print:name": "echo '@gjsify/cli'",
+    "clear": "rm -rf lib tsconfig.tsbuildinfo || exit 0",
+    "check": "tsc --noEmit",
     "start": "node lib/index.js",
-    "build": "yarn print:name && tsc && yarn chmod",
+    "build": "tsc && yarn chmod",
     "chmod": "chmod +x ./lib/index.js"
   },
   "keywords": [
@@ -23,17 +23,15 @@
     "cli"
   ],
   "dependencies": {
-    "@gjsify/esbuild-plugin-deepkit": "^0.0.4",
-    "@gjsify/esbuild-plugin-gjsify": "^0.0.4",
-    "cosmiconfig": "^9.0.0",
-    "esbuild": "^0.19.10",
-    "get-tsconfig": "^4.7.2",
-    "lodash": "^4.17.21",
-    "pkg-types": "^1.0.3",
-    "yargs": "^17.7.2"
+    "@gjsify/esbuild-plugin-gjsify": "^0.1.1",
+    "cosmiconfig": "^9.0.1",
+    "esbuild": "^0.27.4",
+    "get-tsconfig": "^4.13.7",
+    "pkg-types": "^2.3.0",
+    "yargs": "^18.0.0"
   },
   "devDependencies": {
-    "@types/yargs": "^17.0.32",
-    "typescript": "^5.3.3"
+    "@types/yargs": "^17.0.35",
+    "typescript": "^6.0.2"
   }
 }

package/src/actions/build.ts

@@ -60,7 +60,7 @@ export class BuildAction {
             const outfilePath = esbuild?.outfile || library?.module || library?.main;
             const outExt = outfilePath ? extname(outfilePath) : '.js';
             const outdir = esbuild?.outdir || (outfilePath ? dirname(outfilePath) : undefined);
-            const format = esbuild?.format || outdir?.includes('/cjs') || outExt === '.cjs' ? 'cjs' : 'esm';
+            const format: 'esm' | 'cjs' = (esbuild?.format as 'esm' | 'cjs') ?? (outdir?.includes('/cjs') || outExt === '.cjs' ? 'cjs' : 'esm');
             results.push(await build({
                 ...this.getEsBuildDefaults(),
                 ...esbuild,
@@ -79,19 +79,20 @@ export class BuildAction {
 
         const { verbose, esbuild, typescript, exclude, library: pgk } = this.configData;
 
-        const format: 'cjs' | 'esm' = esbuild?.format || esbuild?.outfile?.endsWith('.cjs') ? 'cjs' : 'esm';
+        const format: 'esm' | 'cjs' = (esbuild?.format as 'esm' | 'cjs') ?? (esbuild?.outfile?.endsWith('.cjs') ? 'cjs' : 'esm');
 
         // Set default outfile if no outdir is set 
         if(esbuild && !esbuild?.outfile && !esbuild?.outdir && (pgk?.main || pgk?.module)) {
             esbuild.outfile = esbuild?.format === 'cjs' ? pgk.main || pgk.module : pgk.module || pgk.main;
         }
 
+        const { consoleShim } = this.configData;
         const result = await build({
             ...this.getEsBuildDefaults(),
             ...esbuild,
             format,
             plugins: [
-                gjsifyPlugin({debug: verbose, app, format, exclude, reflection: typescript?.reflection}),
+                gjsifyPlugin({debug: verbose, app, format, exclude, reflection: typescript?.reflection, consoleShim}),
             ]
         });
 

package/src/commands/build.ts

@@ -32,9 +32,9 @@ export const buildCommand: Command<any, CliBuildOptions> = {
                 default: false
             })
             .option('app', {
-                description: "Use this if you want to build a application, the application platforms node and deno are usually only used for tests",
+                description: "Use this if you want to build an application, the platform node is usually only used for tests",
                 type: 'string',
-                choices: ['gjs', 'node', 'deno', 'browser'],
+                choices: ['gjs', 'node', 'browser'],
                 normalize: true,
                 default: 'gjs'
             })
@@ -82,6 +82,12 @@ export const buildCommand: Command<any, CliBuildOptions> = {
                 normalize: true,
                 default: 'warning'
             })
+            .option('console-shim', {
+                description: "Inject a console shim into GJS builds for clean output without the GLib prefix and with working ANSI colors. Use --no-console-shim to disable. Only applies to GJS app builds.",
+                type: 'boolean',
+                normalize: true,
+                default: true
+            })
     },
     handler: async (args) => {
         const config = new Config();

package/src/commands/index.ts

@@ -1 +1,3 @@
-export * from './build.js';
+export * from './build.js';
+export * from './run.js';
+export * from './info.js';

package/src/commands/info.ts

@@ -0,0 +1,70 @@
+import { resolve } from 'node:path';
+import type { Command } from '../types/index.js';
+import { detectNativePackages, buildNativeEnv } from '../utils/detect-native-packages.js';
+
+interface InfoOptions {
+    export: boolean;
+    file?: string;
+}
+
+export const infoCommand: Command<any, InfoOptions> = {
+    command: 'info [file]',
+    description: 'Show native gjsify packages detected in node_modules and the env vars needed to run a GJS bundle directly with gjs.',
+    builder: (yargs) => {
+        return yargs
+            .positional('file', {
+                description: 'Optional: the GJS bundle path to include in the example command (e.g. dist/gjs.js)',
+                type: 'string',
+                normalize: true,
+            })
+            .option('export', {
+                description: 'Output only shell export statements suitable for eval (eval $(gjsify info --export))',
+                type: 'boolean',
+                default: false,
+            });
+    },
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const file = args.file ? resolve(args.file as string) : null;
+        const nativePackages = detectNativePackages(cwd);
+        const { LD_LIBRARY_PATH, GI_TYPELIB_PATH } = buildNativeEnv(nativePackages);
+
+        if (args.export) {
+            // Machine-readable output for eval
+            console.log(`export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}"`);
+            console.log(`export GI_TYPELIB_PATH="${GI_TYPELIB_PATH}"`);
+            return;
+        }
+
+        // Human-readable output
+        if (nativePackages.length === 0) {
+            console.log('No native gjsify packages detected in node_modules.');
+            console.log('Native packages declare "gjsify": { "prebuilds": "<dir>" } in their package.json.');
+            return;
+        }
+
+        console.log('Native packages detected:');
+        for (const pkg of nativePackages) {
+            console.log(`  ${pkg.name}  →  ${pkg.prebuildsDir}`);
+        }
+
+        console.log('');
+        console.log('To run your app directly with gjs, set:');
+        console.log(`  export LD_LIBRARY_PATH="${LD_LIBRARY_PATH}"`);
+        console.log(`  export GI_TYPELIB_PATH="${GI_TYPELIB_PATH}"`);
+
+        if (file) {
+            console.log(`  gjs -m ${file}`);
+        } else {
+            console.log('  gjs -m <your-bundle.js>');
+        }
+
+        console.log('');
+        console.log('Or use gjsify run to handle this automatically:');
+        if (file) {
+            console.log(`  gjsify run ${args.file}`);
+        } else {
+            console.log('  gjsify run <your-bundle.js>');
+        }
+    },
+};

package/src/commands/run.ts

@@ -0,0 +1,59 @@
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import type { Command } from '../types/index.js';
+import { detectNativePackages, buildNativeEnv } from '../utils/detect-native-packages.js';
+
+interface RunOptions {
+    file: string;
+    args: string[];
+}
+
+export const runCommand: Command<any, RunOptions> = {
+    command: 'run <file> [args..]',
+    description: 'Run a GJS bundle, automatically setting LD_LIBRARY_PATH and GI_TYPELIB_PATH for any installed native gjsify packages (e.g. @gjsify/webgl).',
+    builder: (yargs) => {
+        return yargs
+            .positional('file', {
+                description: 'The GJS bundle to run (e.g. dist/gjs.js)',
+                type: 'string',
+                normalize: true,
+                demandOption: true,
+            })
+            .positional('args', {
+                description: 'Extra arguments passed through to gjs',
+                type: 'string',
+                array: true,
+                default: [],
+            });
+    },
+    handler: async (args) => {
+        const file = resolve(args.file as string);
+        const extraArgs = (args.args as string[]) ?? [];
+        const cwd = process.cwd();
+
+        const nativePackages = detectNativePackages(cwd);
+        const nativeEnv = buildNativeEnv(nativePackages);
+
+        const env = {
+            ...process.env,
+            ...nativeEnv,
+        };
+
+        const gjsArgs = ['-m', file, ...extraArgs];
+        const child = spawn('gjs', gjsArgs, { env, stdio: 'inherit' });
+
+        await new Promise<void>((resolvePromise, reject) => {
+            child.on('close', (code) => {
+                if (code !== 0) {
+                    reject(new Error(`gjs exited with code ${code}`));
+                } else {
+                    resolvePromise();
+                }
+            });
+            child.on('error', reject);
+        }).catch((err) => {
+            console.error(err.message);
+            process.exit(1);
+        });
+    },
+};

package/src/config.ts

@@ -1,9 +1,30 @@
 import { APP_NAME } from  './constants.js';
-import { cosmiconfig, Options as LoadOptions } from 'cosmiconfig';
+import { cosmiconfig, type Options as LoadOptions } from 'cosmiconfig';
 import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
 import { getTsconfig } from 'get-tsconfig';
-import lodash from "lodash";
-const { merge } = lodash;
+
+/** Deep merge objects (replaces lodash.merge) */
+function merge<T extends Record<string, any>>(target: T, ...sources: Record<string, any>[]): T {
+    for (const source of sources) {
+        if (!source) continue;
+        for (const key of Object.keys(source)) {
+            const targetVal = (target as any)[key];
+            const sourceVal = source[key];
+            if (sourceVal !== undefined) {
+                if (isPlainObject(targetVal) && isPlainObject(sourceVal)) {
+                    merge(targetVal, sourceVal);
+                } else {
+                    (target as any)[key] = sourceVal;
+                }
+            }
+        }
+    }
+    return target;
+}
+
+function isPlainObject(val: unknown): val is Record<string, any> {
+    return typeof val === 'object' && val !== null && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
+}
 
 import type { CliBuildOptions, ConfigData, CosmiconfigResult, ConfigDataTypescript, ConfigDataLibrary} from './types/index.js';
 import type { ArgumentsCamelCase } from 'yargs';
@@ -60,10 +81,11 @@ export class Config {
         // TODO replace with `cliArgs.logLevel`
         configData.verbose = cliArgs.verbose || false;
         configData.exclude = cliArgs.exclude || [];
+        if (cliArgs.consoleShim !== undefined) configData.consoleShim = cliArgs.consoleShim;
 
-        merge(configData.library, pkg, configData.library);
-        merge(configData.typescript, tsConfig, configData.typescript);
-        merge(configData.esbuild, {
+        merge(configData.library ??= {}, pkg, configData.library);
+        merge(configData.typescript ??= {}, tsConfig, configData.typescript);
+        merge(configData.esbuild ??= {}, {
             format: cliArgs.format,
             minify: cliArgs.minify,
             entryPoints: cliArgs.entryPoints,

package/src/index.ts

@@ -2,7 +2,7 @@
 import yargs from 'yargs'
 import { hideBin } from 'yargs/helpers'
 
-import { buildCommand as build } from './commands/index.js'
+import { buildCommand as build, runCommand as run, infoCommand as info } from './commands/index.js'
 import { APP_NAME } from './constants.js'
 
 void yargs(hideBin(process.argv))
@@ -10,5 +10,7 @@ void yargs(hideBin(process.argv))
     .strict()
     // .usage(Config.usage)
     .command(build.command, build.description, build.builder, build.handler)
+    .command(run.command, run.description, run.builder, run.handler)
+    .command(info.command, info.description, info.builder, info.handler)
     .demandCommand(1)
     .help().argv

package/src/types/cli-build-options.ts

@@ -18,7 +18,7 @@ export interface CliBuildOptions {
    * @see https://esbuild.github.io/api/#format
    */
   format?: 'iife' | 'esm' | 'cjs';
-  /** Use this if you want to build a application or test, the platforms node and deno are usually only used internally to build the tests for Gjsify */
+  /** Use this if you want to build an application or test, the platform node is usually only used internally to build the tests for Gjsify */
   app?: App;
   /** Use this if you want to build a library for Gjsify */
   library?: boolean;
@@ -43,4 +43,9 @@ export interface CliBuildOptions {
   logLevel: 'silent' | 'error' | 'warning' | 'info' | 'debug' | 'verbose';
   /** An array of glob patterns to exclude matches and aliases */
   exclude?: string[];
+  /**
+   * Inject a console shim into GJS builds for clean output (no GLib prefix, ANSI colors work).
+   * Use --no-console-shim to disable. Only applies to GJS app builds. Default: true.
+   */
+  consoleShim?: boolean;
 }

package/src/types/config-data.ts

@@ -9,4 +9,9 @@ export interface ConfigData {
     typescript?: ConfigDataTypescript;
     /** An array of glob patterns to exclude matches and aliases */
     exclude?: string[];
+    /**
+     * Inject a console shim into GJS builds for clean output (no GLib prefix, ANSI colors work).
+     * Only applies to GJS app builds. Default: true.
+     */
+    consoleShim?: boolean;
 }

package/src/utils/detect-native-packages.ts

@@ -0,0 +1,133 @@
+// Utility to find npm packages with gjsify native prebuilds.
+// Packages declare: "gjsify": { "prebuilds": "<dir>" } in their package.json.
+// The CLI uses this to auto-set LD_LIBRARY_PATH / GI_TYPELIB_PATH before running gjs.
+
+import { readdirSync, existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+export interface NativePackage {
+    /** npm package name, e.g. "@gjsify/webgl" */
+    name: string;
+    /** Absolute path to the arch-specific prebuilds dir, e.g. "/…/@gjsify/webgl/prebuilds/linux-x86_64" */
+    prebuildsDir: string;
+}
+
+/** Map Node.js process.arch values to the convention used in prebuilds/ directories. */
+function nodeArchToLinuxArch(arch: string): string {
+    const map: Record<string, string> = {
+        x64: 'x86_64',
+        arm64: 'aarch64',
+        arm: 'armv7',
+        ia32: 'i686',
+    };
+    return map[arch] ?? arch;
+}
+
+/** Read a package.json file and return its parsed content, or null on error. */
+function readPackageJson(pkgJsonPath: string): Record<string, unknown> | null {
+    try {
+        return JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Scan all packages in a node_modules directory for gjsify native prebuilds.
+ * Handles scoped packages (@scope/name) as well as flat packages.
+ */
+function scanNodeModules(nodeModulesDir: string, arch: string): NativePackage[] {
+    const results: NativePackage[] = [];
+    if (!existsSync(nodeModulesDir)) return results;
+
+    let entries: string[];
+    try {
+        entries = readdirSync(nodeModulesDir);
+    } catch {
+        return results;
+    }
+
+    for (const entry of entries) {
+        if (entry.startsWith('.')) continue;
+
+        if (entry.startsWith('@')) {
+            // Scoped packages — one more level deep
+            const scopeDir = join(nodeModulesDir, entry);
+            let scopeEntries: string[];
+            try {
+                scopeEntries = readdirSync(scopeDir);
+            } catch {
+                continue;
+            }
+            for (const scopedPkg of scopeEntries) {
+                const pkgDir = join(scopeDir, scopedPkg);
+                const native = checkPackage(pkgDir, `${entry}/${scopedPkg}`, arch);
+                if (native) results.push(native);
+            }
+        } else {
+            const pkgDir = join(nodeModulesDir, entry);
+            const native = checkPackage(pkgDir, entry, arch);
+            if (native) results.push(native);
+        }
+    }
+
+    return results;
+}
+
+/** Check a single package directory for gjsify prebuilds metadata. */
+function checkPackage(pkgDir: string, name: string, arch: string): NativePackage | null {
+    const pkgJson = readPackageJson(join(pkgDir, 'package.json'));
+    if (!pkgJson) return null;
+
+    const gjsifyMeta = pkgJson['gjsify'];
+    if (!gjsifyMeta || typeof gjsifyMeta !== 'object') return null;
+
+    const prebuildsField = (gjsifyMeta as Record<string, unknown>)['prebuilds'];
+    if (typeof prebuildsField !== 'string') return null;
+
+    const prebuildsDir = join(pkgDir, prebuildsField, `linux-${arch}`);
+    if (!existsSync(prebuildsDir)) return null;
+
+    return { name, prebuildsDir };
+}
+
+/**
+ * Walk up the directory tree from `startDir` looking for a node_modules directory.
+ * Returns all native packages found in the first node_modules encountered.
+ *
+ * Note: This intentionally stops at the first node_modules to match how Node.js
+ * resolves packages from the perspective of the calling project.
+ */
+export function detectNativePackages(startDir: string): NativePackage[] {
+    const arch = nodeArchToLinuxArch(process.arch);
+    let dir = resolve(startDir);
+
+    // Walk up to filesystem root
+    while (true) {
+        const nodeModulesDir = join(dir, 'node_modules');
+        if (existsSync(nodeModulesDir)) {
+            return scanNodeModules(nodeModulesDir, arch);
+        }
+        const parent = resolve(dir, '..');
+        if (parent === dir) break; // reached filesystem root
+        dir = parent;
+    }
+
+    return [];
+}
+
+/**
+ * Build the LD_LIBRARY_PATH and GI_TYPELIB_PATH env var values for the detected native packages.
+ * Prepends the new paths to any existing values from the environment.
+ */
+export function buildNativeEnv(packages: NativePackage[]): { LD_LIBRARY_PATH: string; GI_TYPELIB_PATH: string } {
+    const dirs = packages.map(p => p.prebuildsDir);
+
+    const existing_ld = process.env['LD_LIBRARY_PATH'] ?? '';
+    const existing_gi = process.env['GI_TYPELIB_PATH'] ?? '';
+
+    const LD_LIBRARY_PATH = [...dirs, ...(existing_ld ? [existing_ld] : [])].join(':');
+    const GI_TYPELIB_PATH = [...dirs, ...(existing_gi ? [existing_gi] : [])].join(':');
+
+    return { LD_LIBRARY_PATH, GI_TYPELIB_PATH };
+}

package/tsconfig.json

@@ -1,13 +1,16 @@
 {
     "compilerOptions": {
+      "rootDir": "src",
       "outDir": "lib",
       "declarationDir": "lib",
       "declaration": true,
       "target": "ESNext",
-      "moduleResolution":"Node",
-      "allowSyntheticDefaultImports": true,
-      "strict": true
+      "module": "NodeNext",
+      "moduleResolution": "NodeNext",
+      "types": ["node"],
+      "esModuleInterop": true,
+      "strict": true,
+      "skipLibCheck": true
     },
-    "include": ["src/lodash.d.ts"],
     "files": ["src/index.ts"]
-}
+}

package/src/lodash.d.ts

@@ -1,46 +0,0 @@
-declare module 'lodash' {
-    /**
-     * Recursively merges own and inherited enumerable properties of source
-     * objects into the destination object, skipping source properties that resolve
-     * to `undefined`. Array and plain object properties are merged recursively.
-     * Other objects and value types are overridden by assignment. Source objects
-     * are applied from left to right. Subsequent sources overwrite property
-     * assignments of previous sources.
-     *
-     * **Note:** This method mutates `object`.
-     *
-     * @category Object
-     * @param object The destination object.
-     * @param [sources] The source objects.
-     * @returns Returns `object`.
-     * @example
-     *
-     * var users = {
-     *   'data': [{ 'user': 'barney' }, { 'user': 'fred' }]
-     * };
-     *
-     * var ages = {
-     *   'data': [{ 'age': 36 }, { 'age': 40 }]
-     * };
-     *
-     * _.merge(users, ages);
-     * // => { 'data': [{ 'user': 'barney', 'age': 36 }, { 'user': 'fred', 'age': 40 }] }
-     */
-    function merge<TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
-    /**
-     * @see _.merge
-     */
-    function merge<TObject, TSource1, TSource2>(object: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
-    /**
-     * @see _.merge
-     */
-    function merge<TObject, TSource1, TSource2, TSource3>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3): TObject & TSource1 & TSource2 & TSource3;
-    /**
-     * @see _.merge
-     */
-    function merge<TObject, TSource1, TSource2, TSource3, TSource4>(object: TObject, source1: TSource1, source2: TSource2, source3: TSource3, source4: TSource4): TObject & TSource1 & TSource2 & TSource3 & TSource4;
-    /**
-     * @see _.merge
-     */
-    function merge(object: any, ...otherArgs: any[]): any;
-}