gflows 1.1.0 → 1.1.1

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.1.1] - 2026-07-25
+
+### Fixed
+
+- Hub returns after dispatch: re-arm stdin after “Press enter to return to hub” (no pause/unref), and trap `process.exit` from commands so the hub loop is not killed
+
 ## [1.1.0] - 2026-07-25
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gflows",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "author": "Ali AlNaghmoush (https://github.com/alialnaghmoush)",
   "repository": {
     "type": "git",

package/src/soft-exit.ts

@@ -0,0 +1,36 @@
+/**
+ * Soft process.exit for hub-embedded command dispatch.
+ * Commands that call process.exit would otherwise kill the hub loop.
+ * @module soft-exit
+ */
+
+/**
+ * Thrown instead of terminating the process when soft-exit mode is active.
+ */
+export class SoftExitError extends Error {
+  /**
+   * @param code - Exit code the command requested.
+   */
+  constructor(readonly code: number) {
+    super(`process.exit(${code})`);
+    this.name = "SoftExitError";
+  }
+}
+
+/**
+ * Runs `fn` while intercepting `process.exit` as {@link SoftExitError}.
+ * Restores the real `process.exit` afterward.
+ */
+export async function runWithSoftExit<T>(fn: () => Promise<T>): Promise<T> {
+  const realExit = process.exit;
+  const softExit = ((code?: number) => {
+    throw new SoftExitError(code ?? 0);
+  }) as typeof process.exit;
+
+  process.exit = softExit;
+  try {
+    return await fn();
+  } finally {
+    process.exit = realExit;
+  }
+}

package/src/tui/hub.ts

@@ -7,6 +7,7 @@ import { render } from "ink";
 import React from "react";
 import { dispatch } from "../dispatch.js";
 import { PromptCancelledError } from "../prompts.js";
+import { runWithSoftExit, SoftExitError } from "../soft-exit.js";
 import { type HubSessionResult, HubShell } from "./HubShell.js";
 import { prepareStdinAfterInk } from "./stdin.js";
 
@@ -25,17 +26,22 @@ export async function runTuiHub(cwd: string): Promise<boolean> {
   if (!canUseTui()) return false;
 
   for (;;) {
+    // Ink needs a live, referenced stdin after waitEnter / Clack / prior unmount.
+    prepareStdinAfterInk();
     const result = await runHubSession(cwd);
     if (result.kind === "quit") break;
 
     if (result.kind === "run") {
-      // Ink unrefs stdin on unmount — re-arm before Clack / git prompts.
       prepareStdinAfterInk();
       console.log("");
       try {
-        await dispatch(cwd, result.argv);
+        // Many commands call process.exit on validation/success paths — trap them
+        // so the hub can show “press enter” and remount instead of dying.
+        await runWithSoftExit(() => dispatch(cwd, result.argv));
       } catch (err) {
-        if (!(err instanceof PromptCancelledError)) {
+        if (err instanceof SoftExitError) {
+          // Command already printed its output / error; continue to waitEnter.
+        } else if (!(err instanceof PromptCancelledError)) {
           console.error("gflows:", err instanceof Error ? err.message : String(err));
         }
       }
@@ -78,15 +84,18 @@ function runHubSession(cwd: string): Promise<HubSessionResult> {
 
 /**
  * Raw stdin “press enter” (no Clack / no Ink).
- * Ink unrefs stdin on unmount — we must ref it again or the process exits
- * before the user can return to the hub.
+ * Leaves stdin armed for the next Ink remount (does not pause/unref).
  */
 function waitEnterRaw(label: string): Promise<void> {
   return new Promise((resolve) => {
     const stdin = process.stdin;
     process.stdout.write(`${label}\n`);
     if (typeof stdin.setRawMode === "function") {
-      stdin.setRawMode(true);
+      try {
+        stdin.setRawMode(true);
+      } catch {
+        // ignore
+      }
     }
     stdin.resume();
     stdin.ref();
@@ -99,20 +108,17 @@ function waitEnterRaw(label: string): Promise<void> {
       }
     }
 
-    const cleanup = () => {
+    const finish = () => {
       stdin.off("data", onData);
-      if (typeof stdin.setRawMode === "function") {
-        stdin.setRawMode(false);
-      }
-      stdin.pause();
-      stdin.unref();
+      // Critical: leave stdin ready for Ink remount (old code paused+unref'd → hub died).
+      prepareStdinAfterInk();
+      resolve();
     };
 
     const onData = (chunk: string | Buffer) => {
       const s = typeof chunk === "string" ? chunk : chunk.toString("utf8");
       if (s.includes("\r") || s.includes("\n") || s.includes("\x03")) {
-        cleanup();
-        resolve();
+        finish();
       }
     };
     stdin.on("data", onData);