laohuang 0.8.4 → 0.8.5

package/README.md

@@ -4,7 +4,25 @@ A minimal coding-agent CLI for local software work.
 
 ## Install
 
-Requires Node.js >=22.19.0.
+Recommended standalone install (bundled Node.js; Bash required):
+
+```bash
+curl -fsSL https://github.com/hxr223/laoHuangCode/releases/latest/download/install.sh | sh
+```
+
+On Windows, install Git for Windows first, then run in PowerShell:
+
+```powershell
+irm https://github.com/hxr223/laoHuangCode/releases/latest/download/install.ps1 | iex
+```
+
+The installer verifies the download and startup, then configures the user PATH.
+Open a new terminal or apply the PATH command printed by the installer.
+Standalone packages target macOS, glibc Linux and Windows on x64 and ARM64.
+See [installation details](https://github.com/hxr223/laoHuangCode/blob/main/INSTALLING.md).
+
+Alternatively, install with npm (Node.js >=22.19.0 and Bash required; npm's
+global executable directory must already be on PATH):
 
 ```bash
 npm install -g laohuang
@@ -38,7 +56,11 @@ If no models are available, the CLI points to `/login`.
 directly, and `/apikey` remains a compatibility alias. Switching models affects
 only the current session, not the default profile.
 
-`laohuang update` updates the running npm installation to the latest stable
+For standalone installations, `laohuang update` reruns the bundled installer
+against the latest GitHub release, verifies it before switching the launcher,
+and retains the previous version. Restart laohuang after updating.
+
+For npm installations, `laohuang update` updates the running installation to the latest stable
 release and verifies its installed version. Restart the CLI after updating.
 It supports global npm installations and direct project or workspace npm
 dependencies; local updates change the owning manifest and lockfile while

package/dist/bin.js

@@ -12916,6 +12916,7 @@ var InteractiveTerminalLoop = class {
       input?.on("end", onEnd);
       this.#wakeupEnabled = true;
       try {
+        input?.resume?.();
         if (!this.#exitRequested) {
           await new Promise((resolve8) => {
             this.#exitResolve = resolve8;
@@ -18393,8 +18394,110 @@ function createMcpCommand(runtime, presenter) {
   };
 }
 
+// src/stdin-prompts.ts
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
+var StdinPrompts = class {
+  #input;
+  #active = false;
+  #skipLf = false;
+  constructor(input) {
+    this.#input = input;
+  }
+  async prompt(message, output, secret = false) {
+    const input = this.#input;
+    if (this.#active || input.listenerCount("data") > 0 || input.listenerCount("readable") > 0) {
+      throw new Error("stdin is already in use by another input reader");
+    }
+    if (input.errored) throw input.errored;
+    if (input.readableEnded || input.destroyed) throw new PromptEofError();
+    this.#active = true;
+    const raw = Boolean(secret && input.isTTY && input.setRawMode);
+    return new Promise((resolve8, reject) => {
+      const decoder = new StringDecoder2("utf8");
+      let answer = "";
+      let settled = false;
+      let restoreRawMode;
+      const finish = (error) => {
+        if (settled) return;
+        settled = true;
+        input.pause();
+        input.removeListener("data", onData);
+        input.removeListener("end", onEnd);
+        input.removeListener("close", onClose);
+        input.removeListener("error", onError);
+        process.removeListener("SIGINT", onInterrupt);
+        try {
+          restoreRawMode?.();
+        } catch (restoreError) {
+          error = error === void 0 ? restoreError : new AggregateError([error, restoreError], "Input and terminal restoration failed");
+        }
+        this.#active = false;
+        try {
+          if (restoreRawMode) output.write("\n");
+        } catch (outputError) {
+          error ??= outputError;
+        }
+        if (error !== void 0) reject(error);
+        else resolve8(answer);
+      };
+      const onData = (data) => {
+        try {
+          const bytes = typeof data === "string" ? Buffer.from(data) : data;
+          for (let index = 0; index < bytes.length; index++) {
+            const value = bytes[index];
+            if (this.#skipLf) {
+              this.#skipLf = false;
+              if (value === 10) continue;
+            }
+            if (raw && (value === 3 || value === 4)) {
+              finish(value === 3 ? new PromptCancelledError() : new PromptEofError());
+              return;
+            }
+            if (value === 10 || value === 13) {
+              answer += decoder.end();
+              if (value === 13) {
+                if (bytes[index + 1] === 10) index++;
+                else this.#skipLf = index + 1 === bytes.length;
+              }
+              input.pause();
+              if (index + 1 < bytes.length) input.unshift(bytes.subarray(index + 1));
+              finish();
+              return;
+            }
+            if (raw && (value === 127 || value === 8)) {
+              answer = [...answer].slice(0, -1).join("");
+            } else {
+              answer += decoder.write(bytes.subarray(index, index + 1));
+            }
+          }
+        } catch (error) {
+          finish(error);
+        }
+      };
+      const onEnd = () => {
+        answer += decoder.end();
+        finish(!raw && answer ? void 0 : new PromptEofError());
+      };
+      const onClose = () => finish(new PromptEofError());
+      const onError = (error) => finish(error);
+      const onInterrupt = () => finish(new PromptCancelledError());
+      try {
+        if (raw) restoreRawMode = enterTerminalRawMode(input);
+        if (message) output.write(message);
+        if (input.isTTY) process.on("SIGINT", onInterrupt);
+        input.on("data", onData);
+        input.on("end", onEnd);
+        input.on("close", onClose);
+        input.on("error", onError);
+        input.resume();
+      } catch (error) {
+        finish(error);
+      }
+    });
+  }
+};
+
 // src/repl.ts
-import { readSync as readSync2 } from "node:fs";
 function errorMessage11(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -18404,86 +18507,14 @@ function isEofError(error) {
 function isInterruptedError(error) {
   return error instanceof PromptCancelledError || error instanceof Error && (error.name === "PromptCancelledError" || error.name === "KeyboardInterrupt");
 }
-var stdinBuffer = { pending: "", eof: false };
-function readLineFromStdin() {
-  const chunk = Buffer.alloc(4096);
-  for (; ; ) {
-    const newline = stdinBuffer.pending.indexOf("\n");
-    if (newline !== -1) {
-      const line2 = stdinBuffer.pending.slice(0, newline);
-      stdinBuffer.pending = stdinBuffer.pending.slice(newline + 1);
-      return line2.endsWith("\r") ? line2.slice(0, -1) : line2;
-    }
-    if (stdinBuffer.eof) {
-      const rest = stdinBuffer.pending;
-      stdinBuffer.pending = "";
-      if (rest) {
-        return rest;
-      }
-      throw new PromptEofError();
-    }
-    let bytesRead = 0;
-    try {
-      bytesRead = readSync2(0, chunk, 0, chunk.length, null);
-    } catch (error) {
-      if (error.code === "EAGAIN") {
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
-        continue;
-      }
-      throw error;
-    }
-    if (bytesRead === 0) {
-      stdinBuffer.eof = true;
-      continue;
-    }
-    stdinBuffer.pending += chunk.toString("utf8", 0, bytesRead);
-  }
-}
+var stdinPrompts;
 function defaultInputFn(prompt) {
-  if (prompt) {
-    process.stdout.write(prompt);
-  }
-  return readLineFromStdin();
+  stdinPrompts ??= new StdinPrompts(process.stdin);
+  return stdinPrompts.prompt(prompt, process.stdout);
 }
 function defaultSecretInputFn(prompt) {
-  if (prompt) {
-    process.stderr.write(prompt);
-  }
-  if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== "function") {
-    return readLineFromStdin();
-  }
-  const byte = Buffer.alloc(1);
-  let answer = "";
-  const restoreRawMode = enterTerminalRawMode(process.stdin);
-  try {
-    for (; ; ) {
-      const bytesRead = readSync2(0, byte, 0, 1, null);
-      if (bytesRead === 0) {
-        throw new PromptEofError();
-      }
-      const value = byte[0];
-      if (value === 3) {
-        process.stderr.write("\n");
-        throw new PromptCancelledError();
-      }
-      if (value === 4) {
-        process.stderr.write("\n");
-        throw new PromptEofError();
-      }
-      if (value === 10 || value === 13) {
-        break;
-      }
-      if (value === 127 || value === 8) {
-        answer = [...answer].slice(0, -1).join("");
-        continue;
-      }
-      answer += byte.toString("utf8", 0, 1);
-    }
-  } finally {
-    restoreRawMode();
-  }
-  process.stderr.write("\n");
-  return answer;
+  stdinPrompts ??= new StdinPrompts(process.stdin);
+  return stdinPrompts.prompt(prompt, process.stderr, true);
 }
 function supportsTerminalUI(options = {}) {
   if (options.inputFn !== void 0 || options.outputFn !== void 0) {