@gjsify/cli 0.3.4 → 0.3.6

package/src/utils/parse-spec.ts

@@ -0,0 +1,48 @@
+// Parse a `gjsify dlx` package spec — distinguishes local paths from npm specs.
+
+import { existsSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+
+export type ParsedSpec =
+    | { kind: 'local'; path: string }
+    | { kind: 'registry'; name: string; version?: string; spec: string };
+
+const NPM_NAME_RE = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+
+/**
+ * Parse a CLI input into either a local-path or an npm-registry spec.
+ *
+ * Local: starts with `./`, `../`, `/`, or is an existing directory path.
+ * Registry: `<name>` | `<name>@<version>` | `@scope/<name>` | `@scope/<name>@<version>`
+ *
+ * The full spec string is preserved on the registry case so it can be passed
+ * verbatim to `npm install` (which already understands dist-tags, ranges,
+ * git URIs, tarball URLs, etc. — we don't re-parse those).
+ */
+export function parseSpec(input: string): ParsedSpec {
+    if (!input) throw new Error('dlx: empty package spec');
+
+    if (input.startsWith('./') || input.startsWith('../') || isAbsolute(input)) {
+        return { kind: 'local', path: resolve(input) };
+    }
+
+    if (existsSync(input)) {
+        return { kind: 'local', path: resolve(input) };
+    }
+
+    // Registry spec: split off the version after the LAST `@` that isn't the
+    // leading scope separator.
+    let name = input;
+    let version: string | undefined;
+    const lastAt = input.lastIndexOf('@');
+    if (lastAt > 0) {
+        name = input.slice(0, lastAt);
+        version = input.slice(lastAt + 1);
+    }
+
+    if (!NPM_NAME_RE.test(name)) {
+        throw new Error(`dlx: invalid package name "${name}"`);
+    }
+
+    return { kind: 'registry', name, version, spec: input };
+}

package/src/utils/resolve-gjs-entry.ts

@@ -0,0 +1,96 @@
+// Resolve the GJS entry point of an installed package.
+//
+// Per the `gjsify` field convention (see CLI reference):
+//
+//   {
+//     "gjsify": {
+//       "main": "dist/gjs.js",
+//       "bin":  { "name-a": "dist/a.js", "name-b": "dist/b.js" }
+//     }
+//   }
+//
+// Resolution order:
+//   1. user-supplied bin name + `gjsify.bin[name]`     → that path
+//   2. single-entry `gjsify.bin`                       → the only path
+//   3. `gjsify.main`                                   → that path
+//   4. fallback: `package.json#main`                   → that path (advisory warning)
+//   5. otherwise: hard-fail with a fix hint
+
+import { readFileSync } from 'node:fs';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+
+interface ResolvedEntry {
+    bundlePath: string;
+    binName: string | null;
+    fromFallback: boolean;
+}
+
+interface PackageJson {
+    name?: string;
+    main?: string;
+    gjsify?: {
+        main?: string;
+        bin?: Record<string, string>;
+        prebuilds?: string;
+    };
+}
+
+export function resolveGjsEntry(
+    pkgDir: string,
+    binName: string | null,
+): ResolvedEntry {
+    const pkgJsonPath = join(pkgDir, 'package.json');
+    if (!existsSync(pkgJsonPath)) {
+        throw new Error(`dlx: no package.json found at ${pkgDir}`);
+    }
+    const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8')) as PackageJson;
+
+    const gjsifyBin = pkg.gjsify?.bin;
+    const gjsifyMain = pkg.gjsify?.main;
+    const fallbackMain = pkg.main;
+
+    let entry: string | undefined;
+    let resolvedBin: string | null = null;
+    let fromFallback = false;
+
+    if (binName !== null) {
+        if (!gjsifyBin || !gjsifyBin[binName]) {
+            const known = gjsifyBin ? Object.keys(gjsifyBin).join(', ') : '(none)';
+            throw new Error(
+                `dlx: package "${pkg.name ?? pkgDir}" has no GJS bin named "${binName}" — known: ${known}`,
+            );
+        }
+        entry = gjsifyBin[binName];
+        resolvedBin = binName;
+    } else if (gjsifyBin && Object.keys(gjsifyBin).length === 1) {
+        const onlyBin = Object.keys(gjsifyBin)[0];
+        entry = gjsifyBin[onlyBin];
+        resolvedBin = onlyBin;
+    } else if (gjsifyMain) {
+        entry = gjsifyMain;
+    } else if (fallbackMain) {
+        entry = fallbackMain;
+        fromFallback = true;
+    }
+
+    if (gjsifyBin && Object.keys(gjsifyBin).length > 1 && binName === null) {
+        const names = Object.keys(gjsifyBin).join(', ');
+        throw new Error(
+            `dlx: package "${pkg.name ?? pkgDir}" defines multiple GJS bins — pass one of: ${names}`,
+        );
+    }
+
+    if (!entry) {
+        throw new Error(
+            `dlx: package "${pkg.name ?? pkgDir}" has no GJS entry — set \`gjsify.main\` (or \`gjsify.bin\`) in its package.json`,
+        );
+    }
+
+    const bundlePath = resolve(pkgDir, entry);
+    if (!existsSync(bundlePath)) {
+        throw new Error(`dlx: GJS entry not found: ${bundlePath}`);
+    }
+
+    return { bundlePath, binName: resolvedBin, fromFallback };
+}