@crustjs/crust 0.0.6 → 0.0.7

package/README.md

@@ -1,44 +1,18 @@
 # @crustjs/crust
 
-The all-in-one package for the [Crust](https://crustjs.com) CLI framework.
+CLI tooling for the [Crust](https://crustjs.com) framework — build and distribute standalone executables.
 
-Re-exports everything from `@crustjs/core` and `@crustjs/plugins`, plus provides CLI tooling for building Crust-powered CLIs.
+> For the framework API (`defineCommand`, `runMain`, plugins, etc.), install [`@crustjs/core`](https://www.npmjs.com/package/@crustjs/core) and [`@crustjs/plugins`](https://www.npmjs.com/package/@crustjs/plugins).
 
 ## Install
 
 ```sh
-bun add @crustjs/crust
+bun add -d @crustjs/crust
 ```
 
-## Framework API
-
-The `@crustjs/crust` package gives you the full framework API in a single import:
-
-```ts
-import {
-  defineCommand,
-  runMain,
-  helpPlugin,
-  versionPlugin,
-} from "@crustjs/crust";
-
-const main = defineCommand({
-  meta: { name: "my-cli", description: "My CLI tool" },
-  run() {
-    console.log("Hello!");
-  },
-});
-
-runMain(main, {
-  plugins: [versionPlugin("1.0.0"), helpPlugin()],
-});
-```
-
-> For granular control, you can install `@crustjs/core` and `@crustjs/plugins` separately.
-
 ## CLI Commands
 
-When installed, the `crust` binary provides tooling for your project:
+The `crust` binary provides build tooling for your Crust-powered CLI:
 
 | Command       | Description                                      |
 | ------------- | ------------------------------------------------ |
@@ -48,10 +22,10 @@ When installed, the `crust` binary provides tooling for your project:
 
 Compiles your CLI entry file to standalone Bun executables using `bun build --compile`.
 
-**By default, builds for all 5 supported platforms** and generates a JS resolver script that detects the host platform at runtime and runs the correct binary. This makes it easy to distribute your CLI as a single npm package that works everywhere.
+**By default, builds for all 5 supported platforms** and generates a shell resolver script that detects the host platform at runtime and runs the correct binary. This makes it easy to distribute your CLI as a single npm package that works everywhere — no runtime (Node.js or Bun) required.
 
 ```sh
-crust build                          # All platforms + JS resolver (default)
+crust build                          # All platforms + shell resolver (default)
 crust build --entry src/main.ts      # Custom entry point
 crust build --name my-tool           # Set base binary name
 crust build --no-minify              # Disable minification
@@ -72,7 +46,7 @@ crust build --target linux-x64 --outfile ./my-cli       # Custom output (single
 | `linux-x64`    | `bun-linux-x64-baseline`   | Linux x86_64        |
 | `linux-arm64`  | `bun-linux-arm64`          | Linux ARM64         |
 | `darwin-x64`   | `bun-darwin-x64`           | macOS Intel         |
-| `darwin-arm64` | `bun-darwin-arm64`         | macOS Apple Silicon |
+| `darwin-arm64`  | `bun-darwin-arm64`         | macOS Apple Silicon |
 | `windows-x64`  | `bun-windows-x64-baseline` | Windows x86_64      |
 
 #### Flags
@@ -84,6 +58,7 @@ crust build --target linux-x64 --outfile ./my-cli       # Custom output (single
 | `--name`    | `-n`  | `"string"`  | package.json `name` | Base binary name                             |
 | `--minify`  | —     | `"boolean"` | `true`              | Minify the output                            |
 | `--target`  | `-t`  | `"string"`  | _(all platforms)_   | Target platform(s); repeatable               |
+| `--resolver` | `-r` | `"string"`  | `cli`               | Resolver script filename (multi-target only, no extension) |
 
 #### Output
 
@@ -91,7 +66,8 @@ crust build --target linux-x64 --outfile ./my-cli       # Custom output (single
 
 ```
 dist/
-  my-cli.js                         # JS resolver (entry point for npm bin)
+  cli                               # Shell resolver (entry point for npm bin)
+  cli.cmd                           # Windows batch resolver
   my-cli-bun-linux-x64-baseline     # Linux x64 binary
   my-cli-bun-linux-arm64            # Linux ARM64 binary
   my-cli-bun-darwin-x64             # macOS Intel binary
@@ -108,19 +84,19 @@ dist/
 
 #### Distributing via npm
 
-After building for all platforms, configure your `package.json` to use the JS resolver as the bin entry:
+After building for all platforms, configure your `package.json` to use the shell resolver as the bin entry:
 
 ```json
 {
   "name": "my-cli",
   "bin": {
-    "my-cli": "dist/my-cli.js"
+    "my-cli": "dist/cli"
   },
   "files": ["dist"]
 }
 ```
 
-The resolver uses `#!/usr/bin/env node` for maximum compatibility when installed globally via npm (works even when Bun is not installed on the end user's machine).
+The resolver is a `#!/bin/sh` script (with a companion `.cmd` for Windows) that requires no runtime — it detects the platform and directly executes the correct prebuilt binary.
 
 ## Documentation
 

package/dist/cli.js

@@ -11,8 +11,8 @@ import {
 // package.json
 var package_default = {
   name: "@crustjs/crust",
-  version: "0.0.6",
-  description: "A TypeScript-first, Bun-native CLI framework with composable modules.",
+  version: "0.0.7",
+  description: "CLI tooling for the Crust framework \u2014 build and distribute standalone executables.",
   type: "module",
   license: "MIT",
   author: "chenxin-yan",
@@ -27,22 +27,15 @@ var package_default = {
   },
   keywords: [
     "cli",
-    "command",
-    "framework",
-    "parser",
+    "build",
+    "compile",
+    "standalone",
     "bun",
-    "typescript",
-    "plugin"
+    "typescript"
   ],
   files: [
     "dist"
   ],
-  exports: {
-    ".": {
-      import: "./dist/index.js",
-      types: "./dist/index.d.ts"
-    }
-  },
   publishConfig: {
     access: "public"
   },
@@ -86,13 +79,6 @@ var TARGET_ALIASES = {
   "darwin-arm64": "bun-darwin-arm64",
   "windows-x64": "bun-windows-x64-baseline"
 };
-var TARGET_PLATFORM_MAP = {
-  "bun-linux-x64-baseline": "linux-x64",
-  "bun-linux-arm64": "linux-arm64",
-  "bun-darwin-x64": "darwin-x64",
-  "bun-darwin-arm64": "darwin-arm64",
-  "bun-windows-x64-baseline": "win32-x64"
-};
 function resolveTarget(input) {
   if (SUPPORTED_TARGETS.includes(input)) {
     return input;
@@ -135,83 +121,92 @@ function resolveTargetOutfile(baseName, target, cwd) {
   const ext = isWindows ? ".exe" : "";
   return resolve(cwd, "dist", `${baseName}-${target}${ext}`);
 }
+var TARGET_UNAME_MAP = {
+  "bun-linux-x64-baseline": "Linux-x86_64",
+  "bun-linux-arm64": "Linux-aarch64",
+  "bun-darwin-x64": "Darwin-x86_64",
+  "bun-darwin-arm64": "Darwin-arm64",
+  "bun-windows-x64-baseline": "Windows-x64"
+};
 function getBinaryFilename(baseName, target) {
   const isWindows = target.startsWith("bun-windows");
   const ext = isWindows ? ".exe" : "";
   return `${baseName}-${target}${ext}`;
 }
 function generateResolver(baseName, targets) {
-  const entries = [];
+  const caseEntries = [];
   for (const target of targets) {
-    const platformKey = TARGET_PLATFORM_MAP[target];
+    if (target.startsWith("bun-windows"))
+      continue;
+    const unameKey = TARGET_UNAME_MAP[target];
     const filename = getBinaryFilename(baseName, target);
-    entries.push(`	"${platformKey}": "${filename}"`);
+    caseEntries.push(`	${unameKey}) bin="${filename}" ;;`);
   }
-  const mapBody = entries.join(`,
+  const caseBody = caseEntries.join(`
 `);
-  return `#!/usr/bin/env node
-"use strict";
+  return `#!/bin/sh
+# Auto-generated by crust build \u2014 do not edit
+set -e
 
-const { execFileSync } = require("node:child_process");
-const { chmodSync, statSync } = require("node:fs");
-const path = require("node:path");
+dir="$(cd "$(dirname "$0")" && pwd)"
+platform="$(uname -s)-$(uname -m)"
 
-const PLATFORM_ARCH = \`\${process.platform}-\${process.arch}\`;
+case "$platform" in
+${caseBody}
+	*)
+		echo "[${baseName}] Unsupported platform: $platform" >&2
+		echo "[${baseName}] Please open an issue with your OS/CPU details." >&2
+		exit 1
+		;;
+esac
 
-const TARGET_MAP = {
-${mapBody}
-};
-
-const binaryName = TARGET_MAP[PLATFORM_ARCH];
+bin_path="$dir/$bin"
 
-if (!binaryName) {
-	console.error(
-		\`[${baseName}] Unsupported platform: \${PLATFORM_ARCH}. \` +
-			"Please open an issue with your OS/CPU details."
-	);
-	process.exit(1);
-}
+if [ ! -f "$bin_path" ]; then
+	echo "[${baseName}] Prebuilt binary not found: $bin_path" >&2
+	echo "[${baseName}] Expected binary for $platform: $bin" >&2
+	echo "[${baseName}] Try reinstalling the package." >&2
+	exit 1
+fi
 
-const binPath = path.join(__dirname, binaryName);
+# Ensure the binary is executable
+if [ ! -x "$bin_path" ]; then
+	chmod +x "$bin_path" 2>/dev/null || true
+fi
 
-try {
-	statSync(binPath);
-} catch {
-	console.error(\`[${baseName}] Prebuilt binary not found: \${binPath}\`);
-	console.error(\`[${baseName}] Expected binary for \${PLATFORM_ARCH}: \${binaryName}\`);
-	console.error(\`[${baseName}] Try reinstalling the package.\`);
-	process.exit(1);
-}
-
-// Ensure binary is executable on Unix
-if (process.platform !== "win32") {
-	try {
-		const stats = statSync(binPath);
-		if ((stats.mode & 0o111) === 0) {
-			chmodSync(binPath, stats.mode | 0o111);
-		}
-	} catch {
-		try {
-			chmodSync(binPath, 0o755);
-		} catch {
-			// If chmod fails, continue and let execFileSync report the error
-		}
-	}
-}
-
-try {
-	execFileSync(binPath, process.argv.slice(2), { stdio: "inherit" });
-} catch (error) {
-	if (error && typeof error === "object" && "status" in error && typeof error.status === "number") {
-		process.exit(error.status);
-	}
-	process.exit(1);
+exec "$bin_path" "$@"
+`;
 }
+function generateCmdResolver(baseName, targets) {
+  const windowsTargets = targets.filter((t) => t.startsWith("bun-windows"));
+  if (windowsTargets.length === 0) {
+    return `@echo off\r
+echo [${baseName}] No Windows binary was built for this package. >&2\r
+exit /b 1\r
+`;
+  }
+  const filename = getBinaryFilename(baseName, windowsTargets[0]);
+  return `@echo off\r
+rem Auto-generated by crust build -- do not edit\r
+setlocal\r
+set "dir=%~dp0"\r
+set "bin=${filename}"\r
+set "bin_path=%dir%%bin%"\r
+\r
+if not exist "%bin_path%" (\r
+	echo [${baseName}] Prebuilt binary not found: %bin_path% >&2\r
+	echo [${baseName}] Try reinstalling the package. >&2\r
+	exit /b 1\r
+)\r
+\r
+"%bin_path%" %*\r
 `;
 }
 function writeResolver(resolverPath, baseName, targets) {
-  const content = generateResolver(baseName, targets);
-  writeFileSync(resolverPath, content, { mode: 493 });
+  const shellContent = generateResolver(baseName, targets);
+  writeFileSync(resolverPath, shellContent, { mode: 493 });
+  const cmdContent = generateCmdResolver(baseName, targets);
+  writeFileSync(`${resolverPath}.cmd`, cmdContent);
 }
 function buildBunArgs(entryPath, outfilePath, minify, target) {
   const args = [
@@ -274,6 +269,12 @@ var buildCommand = defineCommand({
       multiple: true,
       description: "Target platform(s) to compile for (e.g. linux-x64, darwin-arm64). Omit to build all.",
       alias: "t"
+    },
+    resolver: {
+      type: "string",
+      description: "Filename for the resolver script (multi-target builds, no extension)",
+      default: "cli",
+      alias: "r"
     }
   },
   async run({ flags }) {
@@ -305,7 +306,7 @@ var buildCommand = defineCommand({
         await execBuild(args, cwd, targetOutfile);
         results.push(targetOutfile);
       }
-      const resolverPath = resolve(cwd, "dist", `${baseName}.js`);
+      const resolverPath = resolve(cwd, "dist", flags.resolver);
       writeResolver(resolverPath, baseName, targets);
       console.log(`
 Built ${results.length} target(s) successfully:`);
@@ -313,7 +314,7 @@ Built ${results.length} target(s) successfully:`);
         console.log(`  ${r}`);
       }
       console.log(`
-Resolver: ${resolverPath}`);
+Resolver: ${resolverPath} (+ ${resolverPath}.cmd)`);
     }
   }
 });

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@crustjs/crust",
-	"version": "0.0.6",
-	"description": "A TypeScript-first, Bun-native CLI framework with composable modules.",
+	"version": "0.0.7",
+	"description": "CLI tooling for the Crust framework — build and distribute standalone executables.",
 	"type": "module",
 	"license": "MIT",
 	"author": "chenxin-yan",
@@ -16,22 +16,15 @@
 	},
 	"keywords": [
 		"cli",
-		"command",
-		"framework",
-		"parser",
+		"build",
+		"compile",
+		"standalone",
 		"bun",
-		"typescript",
-		"plugin"
+		"typescript"
 	],
 	"files": [
 		"dist"
 	],
-	"exports": {
-		".": {
-			"import": "./dist/index.js",
-			"types": "./dist/index.d.ts"
-		}
-	},
 	"publishConfig": {
 		"access": "public"
 	},

package/dist/cli.d.ts

@@ -1,12 +0,0 @@
-import { Command } from "@crustjs/core";
-/**
-* The root `crust` CLI command.
-*
-* Built entirely with `@crustjs/core`.
-* When invoked without a subcommand, displays help listing available commands.
-*
-* Subcommands:
-* - `crust build` - Compile your CLI to a standalone Bun executable
-*/
-declare const crustCommand: Command;
-export { crustCommand };

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from "@crustjs/core";
-export * from "@crustjs/plugins";

package/dist/index.js

@@ -1,4 +0,0 @@
-// @bun
-// src/index.ts
-export * from "@crustjs/core";
-export * from "@crustjs/plugins";