elm-pages 3.0.27 → 3.0.28

package/generator/review/elm.json

@@ -12,7 +12,7 @@
             "elm/json": "1.1.3",
             "elm/regex": "1.0.0",
             "jfmengels/elm-review": "2.15.1",
-            "mdgriffith/elm-codegen": "5.2.0",
+            "mdgriffith/elm-codegen": "6.0.1",
             "stil4m/elm-syntax": "7.3.8",
             "the-sett/elm-syntax-dsl": "6.0.3"
         },

package/generator/src/compatibility-key.js

@@ -1,3 +1,3 @@
-export const compatibilityKey = 22;
+export const compatibilityKey = 23;
 
-export const packageVersion = "3.0.27";
+export const packageVersion = "3.0.28";

package/generator/src/render.js

@@ -536,6 +536,8 @@ async function runInternalJob(
         return [requestHash, await runWhich(requestToPerform)];
       case "elm-pages-internal://question":
         return [requestHash, await runQuestion(requestToPerform)];
+      case "elm-pages-internal://readKey":
+        return [requestHash, await runReadKey(requestToPerform)];
       case "elm-pages-internal://shell":
         return [requestHash, await runShell(requestToPerform)];
       case "elm-pages-internal://stream":
@@ -638,6 +640,10 @@ async function runQuestion(req) {
   return jsonResponse(req, await question(req.body.args[0]));
 }
 
+async function runReadKey(req) {
+  return jsonResponse(req, await readKey());
+}
+
 function runStream(req, portsFile) {
   return new Promise(async (resolve) => {
     const context = getContext(req);
@@ -667,19 +673,21 @@ function runStream(req, portsFile) {
         index += 1;
       }
       if (kind === "json") {
-        resolve(
-          jsonResponse(req, {
-            body: await consumers.json(lastStream),
-            metadata: await tryCallingFunction(metadataResponse),
-          })
-        );
+        try {
+          const body = await consumers.json(lastStream);
+          const metadata = await tryCallingFunction(metadataResponse);
+          resolve(jsonResponse(req, { body, metadata }));
+        } catch (error) {
+          resolve(jsonResponse(req, { error: error.toString() }));
+        }
       } else if (kind === "text") {
-        resolve(
-          jsonResponse(req, {
-            body: await consumers.text(lastStream),
-            metadata: await tryCallingFunction(metadataResponse),
-          })
-        );
+        try {
+          const body = await consumers.text(lastStream);
+          const metadata = await tryCallingFunction(metadataResponse);
+          resolve(jsonResponse(req, { body, metadata }));
+        } catch (error) {
+          resolve(jsonResponse(req, { error: error.toString() }));
+        }
       } else if (kind === "none") {
         if (!lastStream) {
           // ensure all error handling gets a chance to fire before resolving successfully
@@ -687,22 +695,21 @@ function runStream(req, portsFile) {
           resolve(jsonResponse(req, { body: null }));
         } else {
           let resolvedMeta = await tryCallingFunction(metadataResponse);
-          lastStream.once("finish", async () => {
+          // Writable streams emit "finish", Readable streams emit "end"
+          // Duplex streams emit both - use a flag to prevent double-resolve
+          let resolved = false;
+          const onComplete = () => {
+            if (resolved) return;
+            resolved = true;
             resolve(
               jsonResponse(req, {
                 body: null,
                 metadata: resolvedMeta,
               })
             );
-          });
-          lastStream.once("end", async () => {
-            resolve(
-              jsonResponse(req, {
-                body: null,
-                metadata: resolvedMeta,
-              })
-            );
-          });
+          };
+          lastStream.once("finish", onComplete);
+          lastStream.once("end", onComplete);
         }
       } else if (kind === "command") {
         // already handled in parts.forEach
@@ -745,19 +752,36 @@ function runStream(req, portsFile) {
             env,
           });
           if (validateStream.isDuplexStream(newLocal.stream)) {
+            newLocal.stream.once("error", (error) => {
+              newLocal.stream.destroy();
+              resolve({ error: `Custom duplex stream '${part.portName}' error: ${error.message}` });
+            });
             pipeIfPossible(lastStream, newLocal.stream);
+            if (!lastStream) {
+              endStreamIfNoInput(newLocal.stream);
+            }
             return newLocal;
           } else {
             throw `Expected '${part.portName}' to be a duplex stream!`;
           }
         } else if (part.name === "customRead") {
+          const newLocal = await portsFile[part.portName](part.input, {
+            cwd,
+            quiet,
+            env,
+          });
+          // customRead can return either a stream directly or { stream, metadata }
+          const stream = newLocal.stream || newLocal;
+          if (!validateStream.isReadableStream(stream)) {
+            throw `Expected '${part.portName}' to return a readable stream!`;
+          }
+          stream.once("error", (error) => {
+            stream.destroy();
+            resolve({ error: `Custom read stream '${part.portName}' error: ${error.message}` });
+          });
           return {
-            metadata: null,
-            stream: await portsFile[part.portName](part.input, {
-              cwd,
-              quiet,
-              env,
-            }),
+            metadata: newLocal.metadata || null,
+            stream: stream,
           };
         } else if (part.name === "customWrite") {
           const newLocal = await portsFile[part.portName](part.input, {
@@ -766,25 +790,42 @@ function runStream(req, portsFile) {
             env,
           });
           if (!validateStream.isWritableStream(newLocal.stream)) {
-            console.error("Expected a writable stream!");
-            resolve({ error: "Expected a writable stream!" });
-          } else {
-            pipeIfPossible(lastStream, newLocal.stream);
+            throw `Expected '${part.portName}' to return a writable stream!`;
+          }
+          newLocal.stream.once("error", (error) => {
+            newLocal.stream.destroy();
+            resolve({ error: `Custom write stream '${part.portName}' error: ${error.message}` });
+          });
+          pipeIfPossible(lastStream, newLocal.stream);
+          if (!lastStream) {
+            endStreamIfNoInput(newLocal.stream);
           }
           return newLocal;
         } else if (part.name === "gzip") {
           const gzip = zlib.createGzip();
+          gzip.once("error", (error) => {
+            gzip.destroy();
+            resolve({ error: `gzip error: ${error.message}` });
+          });
           if (!lastStream) {
-            gzip.end();
+            endStreamIfNoInput(gzip);
           }
           return {
             metadata: null,
             stream: pipeIfPossible(lastStream, gzip),
           };
         } else if (part.name === "unzip") {
+          const unzip = zlib.createUnzip();
+          unzip.once("error", (error) => {
+            unzip.destroy();
+            resolve({ error: `unzip error: ${error.message}` });
+          });
+          if (!lastStream) {
+            endStreamIfNoInput(unzip);
+          }
           return {
             metadata: null,
-            stream: pipeIfPossible(lastStream, zlib.createUnzip()),
+            stream: pipeIfPossible(lastStream, unzip),
           };
         } else if (part.name === "fileWrite") {
           const destinationPath = path.resolve(part.path);
@@ -801,9 +842,13 @@ function runStream(req, portsFile) {
             newLocal.removeAllListeners();
             resolve({ error: error.toString() });
           });
+          pipeIfPossible(lastStream, newLocal);
+          if (!lastStream) {
+            endStreamIfNoInput(newLocal);
+          }
           return {
             metadata: null,
-            stream: pipeIfPossible(lastStream, newLocal),
+            stream: newLocal,
           };
         } else if (part.name === "httpWrite") {
           const makeFetchHappen = makeFetchHappenOriginal.defaults({
@@ -865,6 +910,9 @@ function runStream(req, portsFile) {
           });
 
           pipeIfPossible(lastStream, newProcess.stdin);
+          if (!lastStream) {
+            endStreamIfNoInput(newProcess.stdin);
+          }
           let newStream;
           if (output === "MergeWithStdout") {
             newStream = mergeStreams([newProcess.stdout, newProcess.stderr]);
@@ -874,28 +922,40 @@ function runStream(req, portsFile) {
             newStream = newProcess.stdout;
           }
 
+          // For the last process, we need to track metadata resolution
+          // so we can resolve it even if the process errors
+          let resolveMeta = null;
+          const metadataPromise = isLastProcess
+            ? new Promise((resolve) => {
+                resolveMeta = resolve;
+              })
+            : null;
+
           newProcess.once("error", (error) => {
             newStream && newStream.end();
             newProcess.removeAllListeners();
+            // Resolve metadata Promise to prevent hanging awaits
+            if (resolveMeta) {
+              resolveMeta({ exitCode: null, error: error.toString() });
+            }
             resolve({ error: error.toString() });
           });
+
           if (isLastProcess) {
+            newProcess.once("exit", (code) => {
+              if (code !== 0 && !allowNon0Status) {
+                newStream && newStream.end();
+                resolve({
+                  error: `Command ${command} exited with code ${code}`,
+                });
+              }
+              resolveMeta({
+                exitCode: code,
+              });
+            });
             return {
               stream: newStream,
-              metadata: new Promise((resoveMeta) => {
-                newProcess.once("exit", (code) => {
-                  if (code !== 0 && !allowNon0Status) {
-                    newStream && newStream.end();
-                    resolve({
-                      error: `Command ${command} exited with code ${code}`,
-                    });
-                  }
-
-                  resoveMeta({
-                    exitCode: code,
-                  });
-                });
-              }),
+              metadata: metadataPromise,
             };
           } else {
             return { metadata: null, stream: newStream };
@@ -930,6 +990,45 @@ function pipeIfPossible(input, destination) {
   }
 }
 
+/**
+ * Safely signals EOF to a writable stream when no input will be piped to it.
+ *
+ * This is necessary because when a writable stream (like a child process's stdin)
+ * is created but nothing is piped to it, the receiving end has no way to know
+ * that no data is coming. It will wait indefinitely for the pipe to close.
+ *
+ * GUI applications like ksdiff/meld are particularly affected - they wait for
+ * stdin to close before proceeding, causing hangs if we don't explicitly end it.
+ *
+ * @param {import('stream').Writable | null | undefined} stream - The writable stream to end
+ */
+function endStreamIfNoInput(stream) {
+  if (!stream) {
+    return;
+  }
+
+  // Check if stream is still in a state where .end() is valid
+  // - writable: false if the stream has been destroyed or ended
+  // - writableEnded: true if .end() has already been called
+  // - destroyed: true if .destroy() has been called
+  if (!stream.writable || stream.writableEnded || stream.destroyed) {
+    return;
+  }
+
+  // Add a one-time error handler to prevent unhandled error crashes
+  // This can happen if the child process exits before we call .end()
+  stream.once("error", (err) => {
+    // EPIPE: "broken pipe" - the other end closed before we finished
+    // This is expected if the child process exits quickly
+    if (err.code !== "EPIPE") {
+      // Log unexpected errors but don't crash - this is cleanup code
+      console.error("Stream end error:", err.message);
+    }
+  });
+
+  stream.end();
+}
+
 function stdout() {
   return new Writable({
     write(chunk, encoding, callback) {
@@ -1077,7 +1176,7 @@ export function pipeShells(
       if (previousProcess === null) {
         currentProcess = spawnCallback(command, args, {
           stdio: ["inherit", "pipe", "inherit"],
-          timeout: timeout ? undefined : timeout,
+          timeout: timeout,
           cwd: cwd,
           env: env,
         });
@@ -1087,14 +1186,14 @@ export function pipeShells(
             stdio: quiet
               ? ["pipe", "ignore", "ignore"]
               : ["pipe", "inherit", "inherit"],
-            timeout: timeout ? undefined : timeout,
+            timeout: timeout,
             cwd: cwd,
             env: env,
           });
         } else {
           currentProcess = spawnCallback(command, args, {
             stdio: ["pipe", "pipe", "pipe"],
-            timeout: timeout ? undefined : timeout,
+            timeout: timeout,
             cwd: cwd,
             env: env,
           });
@@ -1153,6 +1252,48 @@ export async function question({ prompt }) {
   });
 }
 
+/**
+ * Read a single keypress from stdin without requiring Enter.
+ * Uses raw mode to capture individual keypresses.
+ * Falls back to line-buffered input when not in a TTY (e.g., piped input).
+ */
+export async function readKey() {
+  const stdin = process.stdin;
+
+  if (!stdin.isTTY) {
+    // Fall back to reading a line when not in a TTY (piped input, CI, etc.)
+    // Takes the first character of the input line
+    const rl = readline.createInterface({ input: stdin });
+    return new Promise((resolve) => {
+      rl.once("line", (line) => {
+        rl.close();
+        resolve(line.charAt(0) || "\n");
+      });
+    });
+  }
+
+  // TTY mode - single keypress without Enter
+  return new Promise((resolve) => {
+    const wasRaw = stdin.isRaw;
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+
+    stdin.once("data", (key) => {
+      stdin.setRawMode(wasRaw);
+      stdin.pause();
+
+      // Handle Ctrl+C to exit gracefully
+      if (key === "\u0003") {
+        process.exit();
+      }
+
+      resolve(key);
+    });
+  });
+}
+
 async function runWriteFileJob(req) {
   const { cwd } = getContext(req);
   const data = req.body.args[0];
@@ -1223,7 +1364,7 @@ async function runGlobNew(req, patternsToWatch) {
         }
         return {
           fullPath: fullPath.path,
-          captures: mm.capture(pattern, fullPath.path),
+          captures: mm.capture(pattern, fullPath.path) || [],
           fileStats: {
             size: stats.size,
             atime: Math.round(stats.atime.getTime()),

package/generator/template/elm.json

@@ -31,7 +31,7 @@
             "elm-community/result-extra": "2.4.0",
             "jluckyiv/elm-utc-date-strings": "1.0.0",
             "justinmimbs/date": "4.1.0",
-            "mdgriffith/elm-codegen": "5.2.0",
+            "mdgriffith/elm-codegen": "6.0.1",
             "miniBill/elm-codec": "2.2.0",
             "noahzgordon/elm-color-extra": "1.0.2",
             "robinheghan/fnv1a": "1.0.0",

package/generator/template/script/elm.json

@@ -13,7 +13,7 @@
             "elm/core": "1.0.5",
             "elm/html": "1.0.0",
             "elm/json": "1.1.3",
-            "mdgriffith/elm-codegen": "5.2.0"
+            "mdgriffith/elm-codegen": "6.0.1"
         },
         "indirect": {
             "Chadtech/elm-bool-extra": "2.4.2",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elm-pages",
   "type": "module",
-  "version": "3.0.27",
+  "version": "3.0.28",
   "homepage": "https://elm-pages.com",
   "moduleResolution": "node",
   "description": "Hybrid Elm framework with full-stack and static routes.",

package/src/BackendTask/Stream.elm

@@ -884,44 +884,59 @@ readJson decoder ((Stream ( _, metadataDecoder ) _) as stream) =
         , body = BackendTask.Http.jsonBody (pipelineEncoder stream "json")
         , expect =
             BackendTask.Http.expectJson
-                (Decode.field "metadata" metadataDecoder
-                    |> Decode.andThen
-                        (\result1 ->
-                            let
-                                bodyResult : Decoder (Result Decode.Error value)
-                                bodyResult =
-                                    Decode.field "body" Decode.value
-                                        |> Decode.map
-                                            (\bodyValue ->
-                                                Decode.decodeValue decoder bodyValue
-                                            )
-                            in
-                            bodyResult
-                                |> Decode.map
-                                    (\result ->
-                                        case result1 of
-                                            Ok metadata ->
-                                                case result of
-                                                    Ok body ->
-                                                        Ok
-                                                            { metadata = metadata
-                                                            , body = body
-                                                            }
-
-                                                    Err decoderError ->
-                                                        FatalError.recoverable
-                                                            { title = "Failed to decode body"
-                                                            , body = "Failed to decode body"
-                                                            }
-                                                            (StreamError (Decode.errorToString decoderError))
-                                                            |> Err
-
-                                            Err error ->
-                                                error
-                                                    |> mapRecoverable (Result.toMaybe result)
-                                                    |> Err
+                (Decode.oneOf
+                    [ Decode.field "error" Decode.string
+                        |> Decode.andThen
+                            (\error ->
+                                Decode.succeed
+                                    (Err
+                                        (FatalError.recoverable
+                                            { title = "Stream Error"
+                                            , body = error
+                                            }
+                                            (StreamError error)
+                                        )
                                     )
-                        )
+                            )
+                    , Decode.field "metadata" metadataDecoder
+                        |> Decode.andThen
+                            (\result1 ->
+                                let
+                                    bodyResult : Decoder (Result Decode.Error value)
+                                    bodyResult =
+                                        Decode.field "body" Decode.value
+                                            |> Decode.map
+                                                (\bodyValue ->
+                                                    Decode.decodeValue decoder bodyValue
+                                                )
+                                in
+                                bodyResult
+                                    |> Decode.map
+                                        (\result ->
+                                            case result1 of
+                                                Ok metadata ->
+                                                    case result of
+                                                        Ok body ->
+                                                            Ok
+                                                                { metadata = metadata
+                                                                , body = body
+                                                                }
+
+                                                        Err decoderError ->
+                                                            FatalError.recoverable
+                                                                { title = "Failed to decode body"
+                                                                , body = "Failed to decode body"
+                                                                }
+                                                                (StreamError (Decode.errorToString decoderError))
+                                                                |> Err
+
+                                                Err error ->
+                                                    error
+                                                        |> mapRecoverable (Result.toMaybe result)
+                                                        |> Err
+                                        )
+                            )
+                    ]
                 )
         }
         |> BackendTask.andThen BackendTask.fromResult

package/src/Pages/Internal/Platform/CompatibilityKey.elm

@@ -3,4 +3,4 @@ module Pages.Internal.Platform.CompatibilityKey exposing (currentCompatibilityKe
 
 currentCompatibilityKey : Int
 currentCompatibilityKey =
-    22
+    23

package/src/Pages/Script.elm

@@ -3,7 +3,7 @@ module Pages.Script exposing
     , withCliOptions, withoutCliOptions
     , writeFile
     , command, exec
-    , log, sleep, doThen, which, expectWhich, question
+    , log, sleep, doThen, which, expectWhich, question, readKey, readKeyWithDefault
     , Error(..)
     )
 
@@ -31,7 +31,7 @@ Read more about using the `elm-pages` CLI to run (or bundle) scripts, plus a bri
 
 ## Utilities
 
-@docs log, sleep, doThen, which, expectWhich, question
+@docs log, sleep, doThen, which, expectWhich, question, readKey, readKeyWithDefault
 
 
 ## Errors
@@ -313,6 +313,77 @@ question prompt =
         }
 
 
+{-| Read a single keypress from stdin without requiring Enter.
+
+This is useful for interactive prompts where you want immediate response
+to a single key, like confirmation dialogs (y/n) or menu navigation.
+
+    module ConfirmDemo exposing (run)
+
+    import BackendTask
+
+    run : Script
+    run =
+        Script.withoutCliOptions
+            (Script.log "Approve this change? [y/n] "
+                |> BackendTask.andThen (\_ -> Script.readKey)
+                |> BackendTask.andThen
+                    (\key ->
+                        if key == "y" then
+                            Script.log "Approved!"
+
+                        else
+                            Script.log "Rejected."
+                    )
+            )
+
+Note: Returns the raw key character. Control characters like Ctrl+C will
+terminate the process.
+
+When not running in an interactive terminal (e.g., piped input or CI),
+falls back to line-buffered input and returns the first character of the line.
+This allows scripts to work both interactively and with piped input like
+`echo "y" | elm-pages run MyScript.elm`.
+
+-}
+readKey : BackendTask error String
+readKey =
+    BackendTask.Internal.Request.request
+        { body = BackendTask.Http.emptyBody
+        , expect = BackendTask.Http.expectJson Decode.string
+        , name = "readKey"
+        }
+
+
+{-| Like [`readKey`](#readKey), but returns a default value when Enter is pressed.
+
+    Script.log "Continue? [Y/n] "
+        |> BackendTask.andThen (\_ -> Script.readKeyWithDefault "y")
+        |> BackendTask.andThen
+            (\key ->
+                if String.toLower key == "y" then
+                    continue
+
+                else
+                    abort
+            )
+
+Useful for prompts where pressing Enter should accept a default option.
+
+-}
+readKeyWithDefault : String -> BackendTask error String
+readKeyWithDefault default =
+    readKey
+        |> BackendTask.map
+            (\key ->
+                if key == "\u{000D}" || key == "\n" then
+                    default
+
+                else
+                    key
+            )
+
+
 {-| Like [`command`](#command), but prints stderr and stdout to the console as the command runs instead of capturing them.
 
     module MyScript exposing (run)