@gjsify/cli 0.7.5 → 0.9.0

package/lib/utils/prompt.js

@@ -1,81 +1,118 @@
-// Minimal interactive prompts for `gjsify login` — a visible line prompt and a
-// hidden (no-echo) password prompt. Cross-runtime: `process.stdin.setRawMode`
-// is provided by Node and by `@gjsify/process` (terminal-native) under GJS.
+// Interactive prompts for `gjsify login` / `gjsify trust`.
 //
-// Non-TTY stdin (piped input, CI) is supported: both helpers read a single line
-// without raw-mode masking, so `printf 'user\npass\n' | gjsify login` works for
-// automation.
-const CTRL_C = String.fromCharCode(3); // ETX (Ctrl-C)
-const DEL = String.fromCharCode(127); // DEL (Backspace on most terminals)
-const BACKSPACE = String.fromCharCode(8); // BS
-/** Print a question and read one line from stdin (visible). */
-export async function promptLine(question) {
-    process.stdout.write(question);
-    return readLine();
+// On a TTY every prompt runs inside a single RAW-mode session (`runRawSession`)
+// that reads key-by-key with manual echo and a guaranteed cooked-mode restore
+// (try/finally). This deliberately does NOT rely on the terminal's cooked
+// line-discipline nor on the shared `process.stdin` resume/pause cycle:
+//   - The old visible prompt read a cooked line via `process.stdin` 'data'
+//     events. With the line discipline in an unexpected state (e.g. ICRNL off
+//     after a prior raw prompt) Enter arrived as a bare `\r` that never
+//     terminated the cooked line — the prompt hung showing `name^M`. The
+//     resume/pause churn on the shared stdin singleton between two sequential
+//     prompts also intermittently dropped the line or resolved it empty.
+//   - Reading raw + handling `\r`/`\n` ourselves removes both failure modes.
+//
+// Raw mode (via @gjsify/process → terminal-native) now also clears ISIG, so
+// Ctrl-C is delivered as a `\x03` keystroke we handle (restore + exit) instead
+// of a SIGINT that would kill the process leaving the terminal in raw mode.
+//
+// Non-TTY stdin (piped input, CI) keeps a plain line read so
+// `printf 'user\npass\n' | gjsify login` still works.
+const CTRL_C = '\x03'; // ETX (Ctrl-C)
+const DEL = '\x7f'; // DEL (Backspace on most terminals)
+const BACKSPACE = '\x08'; // BS
+function isTtyStdin() {
+    const stdin = process.stdin;
+    return Boolean(stdin.isTTY) && typeof stdin.setRawMode === 'function';
 }
 /**
- * Print a question and read one line WITHOUT echoing it (passwords). Uses raw
- * mode + manual key handling on a TTY; falls back to a plain line read when
- * stdin is not a TTY (piped). Ctrl-C aborts the process.
+ * Pure key handler for the raw-mode line editor — the single source of truth
+ * for how a keystroke updates the buffer + echo. Kept pure (no I/O) so it is
+ * unit-testable: this is what makes Enter (`\r` OR `\n`) reliably submit, masks
+ * passwords, and treats Ctrl-C as an interrupt rather than text.
  */
-export async function promptHidden(question) {
-    process.stdout.write(question);
-    const stdin = process.stdin;
-    if (!stdin.isTTY || typeof stdin.setRawMode !== 'function') {
-        // Non-interactive: read a line as-is (no masking possible/needed).
-        return readLine();
+export function applyKey(buf, ch, mask) {
+    if (ch === '\r' || ch === '\n') {
+        return { buf, echo: '\n', done: true, interrupt: false };
     }
-    return new Promise((resolve) => {
-        let buf = '';
-        stdin.setRawMode(true);
-        stdin.resume();
-        // setEncoding makes 'data' emit decoded STRINGS — including under GJS,
-        // where @gjsify/process honours it via StringDecoder (was a no-op stub;
-        // bytes broke `ch === '\r'` so Enter never submitted). So we can iterate
-        // characters directly here; do NOT reintroduce a byte-normalising shim.
-        stdin.setEncoding('utf-8');
-        const onData = (chunk) => {
-            for (const ch of chunk) {
-                if (ch === '\r' || ch === '\n') {
-                    cleanup();
-                    process.stdout.write('\n');
-                    resolve(buf);
-                    return;
-                }
-                else if (ch === CTRL_C) {
-                    cleanup();
-                    process.stdout.write('\n');
-                    process.exit(130);
-                }
-                else if (ch === DEL || ch === BACKSPACE) {
-                    if (buf.length > 0) {
-                        buf = buf.slice(0, -1);
-                        process.stdout.write('\b \b');
-                    }
-                }
-                else if (ch >= ' ') {
-                    buf += ch;
-                    process.stdout.write('*');
-                }
-            }
-        };
-        const cleanup = () => {
+    if (ch === CTRL_C) {
+        return { buf, echo: '\n', done: false, interrupt: true };
+    }
+    if (ch === DEL || ch === BACKSPACE) {
+        if (buf.length > 0) {
+            return { buf: buf.slice(0, -1), echo: '\b \b', done: false, interrupt: false };
+        }
+        return { buf, echo: '', done: false, interrupt: false };
+    }
+    if (ch >= ' ') {
+        return { buf: buf + ch, echo: mask ? '*' : ch, done: false, interrupt: false };
+    }
+    // Other control characters (arrows, tabs, escapes) are ignored.
+    return { buf, echo: '', done: false, interrupt: false };
+}
+/**
+ * Open ONE raw-mode stdin session, run `fn` (which may read several lines via
+ * the supplied reader), and always restore cooked mode afterwards. Keeping a
+ * single session for the whole credential exchange avoids per-prompt
+ * resume/pause races on the shared stdin singleton.
+ */
+async function runRawSession(fn) {
+    const stdin = process.stdin;
+    const out = process.stdout;
+    let pending = null;
+    const cleanup = () => {
+        stdin.removeListener('data', onData);
+        try {
             stdin.setRawMode(false);
-            stdin.removeListener('data', onData);
+        }
+        catch {
+            /* not a TTY any more */
+        }
+        if (typeof stdin.pause === 'function')
             stdin.pause();
-        };
-        stdin.on('data', onData);
+    };
+    const onData = (chunk) => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
+        for (const ch of text) {
+            if (!pending)
+                continue; // ignore type-ahead between prompts
+            const r = applyKey(pending.buf, ch, pending.mask);
+            pending.buf = r.buf;
+            if (r.echo)
+                out.write(r.echo);
+            if (r.interrupt) {
+                cleanup();
+                process.exit(130);
+            }
+            if (r.done) {
+                const { resolve } = pending;
+                pending = null;
+                resolve(r.buf);
+            }
+        }
+    };
+    stdin.setRawMode(true);
+    if (typeof stdin.resume === 'function')
+        stdin.resume();
+    stdin.setEncoding('utf-8');
+    stdin.on('data', onData);
+    const read = (question, mask) => new Promise((resolve) => {
+        out.write(question);
+        pending = { mask, buf: '', resolve };
     });
+    try {
+        return await fn(read);
+    }
+    finally {
+        cleanup();
+    }
 }
-/** Read a single line from stdin (shared by both prompts on non-TTY). */
+/** Read a single line from non-TTY stdin (piped). Accepts CR, LF, or CRLF. */
 function readLine() {
     return new Promise((resolve) => {
         let buf = '';
         const onData = (chunk) => {
             buf += typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
-            // Accept CR, LF, or CRLF as the line terminator. A bare CR (`\r`)
-            // is what some terminals / the GJS terminal-native stdin deliver on
-            // Enter — keying only on `\n` made the prompt hang forever there.
             const m = buf.search(/[\r\n]/);
             if (m >= 0) {
                 cleanup();
@@ -97,3 +134,42 @@ function readLine() {
         process.stdin.once('end', onEnd);
     });
 }
+/** Print a question and read one visible line. */
+export async function promptLine(question) {
+    if (!isTtyStdin()) {
+        process.stdout.write(question);
+        return readLine();
+    }
+    return runRawSession((read) => read(question, false));
+}
+/** Print a question and read one line WITHOUT echoing it (passwords). */
+export async function promptHidden(question) {
+    if (!isTtyStdin()) {
+        process.stdout.write(question);
+        return readLine();
+    }
+    return runRawSession((read) => read(question, true));
+}
+/**
+ * Read npm credentials. On a TTY both the visible username and the masked
+ * password are read in ONE raw session (no cooked-line dependency, no
+ * inter-prompt resume/pause race). `providedUsername` (from `--username`) skips
+ * the username prompt.
+ */
+export async function promptCredentials(providedUsername) {
+    if (!isTtyStdin()) {
+        let username = providedUsername;
+        if (!username) {
+            process.stdout.write('Username: ');
+            username = await readLine();
+        }
+        process.stdout.write('Password: ');
+        const password = await readLine();
+        return { username, password };
+    }
+    return runRawSession(async (read) => {
+        const username = providedUsername ?? (await read('Username: ', false));
+        const password = await read('Password: ', true);
+        return { username, password };
+    });
+}

package/lib/utils/resolve-plugin-by-name.d.ts

@@ -7,6 +7,26 @@ export interface PluginByName {
     /** Options forwarded to the plugin factory. */
     options?: unknown;
 }
+/**
+ * Strategy for turning a resolved plugin file path into its module namespace.
+ *
+ * On Node this is a plain dynamic `import()`. Under GJS it cannot be — GJS's
+ * native ESM loader does not follow npm `package.json#exports` subpath maps
+ * for bare specifiers, so importing a plugin whose source does
+ * `import … from '@scope/pkg/internal-subpath'` throws
+ * `Module not found: @scope/pkg/internal-subpath` even when the file is on
+ * disk. The CLI injects a GJS strategy that first bundles the plugin to a
+ * single self-contained ESM file (Rolldown resolves the exports map at
+ * bundle time), then imports that. See `BuildAction.loadPluginViaGjsBundle`.
+ */
+export type LoadPluginModule = (resolvedPath: string, pluginName: string) => Promise<Record<string, unknown>>;
+export interface ResolveUserPluginsOptions {
+    /**
+     * Override how a resolved plugin path is turned into its module
+     * namespace. Defaults to a direct dynamic `import()` (correct on Node).
+     */
+    loadModule?: LoadPluginModule;
+}
 /** Type-guard: a `PluginByName` shape rather than a Rolldown plugin object. */
 export declare function isPluginByName(value: unknown): value is PluginByName;
 /**
@@ -18,4 +38,4 @@ export declare function isPluginByName(value: unknown): value is PluginByName;
  * Throws when a name fails to resolve, when the chosen export is not a
  * function, or when the factory returns nothing.
  */
-export declare function resolveUserPlugins(plugins: ReadonlyArray<RolldownPluginOption | PluginByName>, projectDir: string): Promise<RolldownPluginOption[]>;
+export declare function resolveUserPlugins(plugins: ReadonlyArray<RolldownPluginOption | PluginByName>, projectDir: string, options?: ResolveUserPluginsOptions): Promise<RolldownPluginOption[]>;

package/lib/utils/resolve-plugin-by-name.js

@@ -15,6 +15,8 @@
 import { createRequire } from 'node:module';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
+/** Default loader: a plain dynamic import of the resolved file URL (Node path). */
+const defaultLoadModule = async (resolvedPath) => (await import(pathToFileURL(resolvedPath).href));
 /** Type-guard: a `PluginByName` shape rather than a Rolldown plugin object. */
 export function isPluginByName(value) {
     return (typeof value === 'object' &&
@@ -39,7 +41,8 @@ export function isPluginByName(value) {
  * Throws when a name fails to resolve, when the chosen export is not a
  * function, or when the factory returns nothing.
  */
-export async function resolveUserPlugins(plugins, projectDir) {
+export async function resolveUserPlugins(plugins, projectDir, options = {}) {
+    const loadModule = options.loadModule ?? defaultLoadModule;
     const requireFromProject = createRequire(join(projectDir, 'package.json'));
     const out = [];
     for (const entry of plugins) {
@@ -56,7 +59,7 @@ export async function resolveUserPlugins(plugins, projectDir) {
                 `Add it to your project's dependencies, or pass a Plugin object directly. ` +
                 `(${err.message})`);
         }
-        const mod = await import(pathToFileURL(resolvedPath).href);
+        const mod = await loadModule(resolvedPath, entry.name);
         const exportName = entry.export ?? 'default';
         const factory = mod[exportName];
         if (typeof factory !== 'function') {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.7.5",
+    "version": "0.9.0",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -120,19 +120,19 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/buffer": "^0.7.5",
-        "@gjsify/create-app": "^0.7.5",
-        "@gjsify/node-globals": "^0.7.5",
-        "@gjsify/node-polyfills": "^0.7.5",
-        "@gjsify/npm-registry": "^0.7.5",
-        "@gjsify/resolve-npm": "^0.7.5",
-        "@gjsify/rolldown-plugin-gjsify": "^0.7.5",
-        "@gjsify/rolldown-plugin-pnp": "^0.7.5",
-        "@gjsify/semver": "^0.7.5",
-        "@gjsify/tar": "^0.7.5",
-        "@gjsify/tsc": "^0.7.5",
-        "@gjsify/web-polyfills": "^0.7.5",
-        "@gjsify/workspace": "^0.7.5",
+        "@gjsify/buffer": "^0.9.0",
+        "@gjsify/create-app": "^0.9.0",
+        "@gjsify/node-globals": "^0.9.0",
+        "@gjsify/node-polyfills": "^0.9.0",
+        "@gjsify/npm-registry": "^0.9.0",
+        "@gjsify/resolve-npm": "^0.9.0",
+        "@gjsify/rolldown-plugin-gjsify": "^0.9.0",
+        "@gjsify/rolldown-plugin-pnp": "^0.9.0",
+        "@gjsify/semver": "^0.9.0",
+        "@gjsify/tar": "^0.9.0",
+        "@gjsify/tsc": "^0.9.0",
+        "@gjsify/web-polyfills": "^0.9.0",
+        "@gjsify/workspace": "^0.9.0",
         "cosmiconfig": "^9.0.2",
         "get-tsconfig": "^4.14.0",
         "pkg-types": "^2.3.1",
@@ -140,13 +140,13 @@
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.7.5",
+        "@gjsify/unit": "^0.9.0",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.7.5",
-        "@gjsify/rolldown-native": "^0.7.5"
+        "@gjsify/oxfmt-native": "^0.9.0",
+        "@gjsify/rolldown-native": "^0.9.0"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {