@nanhara/hara 0.108.0 → 0.109.0

package/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to `@nanhara/hara`.
 > Versioning (pre-1.0, SemVer-style): the **minor** (middle) number bumps for a **new feature**; the
 > **patch** (last) number bumps for **optimizations/fixes of existing features**.
 
+## 0.109.0 — real multi-line input + Windows shell
+
+- **Pasted multi-line text is now real, editable text in the box** — not a `[Paste]` token, not an
+  auto-submit. The input box renders `\n` as actual line breaks (deterministic wrap now treats a
+  newline as a hard row break), so a pasted paragraph / code / stack trace shows in full, you edit it,
+  and only a real **Enter** sends it. (0.108.1 over-corrected by folding every paste to a token; this
+  is codex's behavior — the composer is a multi-line textarea, a pasted newline is content.) A truly
+  enormous dump (>8000 chars) still folds to a token so it can't wall off the screen.
+- **Windows: the shell no longer hard-fails.** The bash tool hardcoded `/bin/sh`, which doesn't exist
+  on Windows — so every command errored. Now on Windows hara prefers a real **bash** (Git Bash / WSL,
+  which it probes on PATH) so the POSIX commands the model writes keep working, and falls back to
+  `cmd.exe` with a one-time notice pointing at the fix. (Still no auto-`cron install` or sandbox on
+  Windows — those stay Unix-only, as before.)
+
+## 0.108.1 — pasting no longer sends the message
+
+- **A pasted newline is content, not "send".** Pasting multi-line text used to fire the message at
+  the first newline (any 1–2 line paste under 600 chars auto-submitted) — the classic "I pasted and
+  it sent before I could edit" bug. Now ANY paste containing a newline folds to a `[Paste #N +L lines]`
+  token and waits; only a real **Enter** sends it (the token expands to the full text on submit). This
+  is codex's paste-burst rule — Enter inside a paste is a newline, not a submit. A lone newline typed
+  at the prompt still sends, as before.
+- (Slow paste *recognition* over a remote/SSH terminal is chunk-delivery latency — network-bound, not
+  something the client amplifies; local pastes arrive as one chunk and are instant.)
+
 ## 0.108.0 — cron grows up: chat-native scheduling, delivery, a deterministic lane
 
 Distilled from a three-way study of openclaw (the production-grade scheduler running our company),

package/dist/sandbox.js

@@ -5,10 +5,33 @@
 // project, NOT a determined exfiltration. Other platforms run UNSANDBOXED (a one-time warning is
 // emitted from runShell so every entry point — REPL, -p, org, cron — surfaces it). Only the `bash`
 // shell is sandboxed; hara's own file tools are in-process, explicit, and gated by the approval flow.
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { writeFileSync, mkdtempSync } from "node:fs";
 import { tmpdir, platform } from "node:os";
 import { join } from "node:path";
+// Windows shell resolution. hara (and the model) speak POSIX shell — the agent writes `ls`, `grep`,
+// `cat`, pipes, `&&`. So on Windows we PREFER a real bash (Git Bash or WSL, which most Windows devs
+// have) and only fall back to cmd.exe when none is found. Memoized: the PATH probe runs at most once.
+let _winBash;
+function findWindowsBash() {
+    if (_winBash !== undefined)
+        return _winBash;
+    // `where bash` finds Git Bash / WSL bash on PATH; also probe the default Git-for-Windows location.
+    const onPath = spawnSync("where", ["bash"], { encoding: "utf8" });
+    const hit = onPath.status === 0 ? String(onPath.stdout).split(/\r?\n/).find((l) => l.trim()) : "";
+    _winBash = (hit && hit.trim()) || null;
+    return _winBash;
+}
+/** Pure shell-argv resolution — split out so the platform branching is unit-testable without spawning.
+ *  `plat` and `bash` are injected; production passes the real platform() + findWindowsBash(). */
+export function resolveShellArgv(command, plat, bash) {
+    if (plat === "win32") {
+        // A real bash keeps POSIX commands working; cmd.exe is the last resort (most `ls/grep` will fail
+        // there — the model should be told, see maybeWarnWindowsShell).
+        return bash ? { cmd: bash, args: ["-c", command] } : { cmd: "cmd.exe", args: ["/d", "/s", "/c", command] };
+    }
+    return { cmd: "/bin/sh", args: ["-c", command] };
+}
 const sbQuote = (s) => '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
 function seatbeltProfile(cwd, mode) {
     const writable = [
@@ -43,7 +66,20 @@ export function shellCommand(command, cwd, mode) {
         return { cmd: "sandbox-exec", args: ["-f", profileFile, "/bin/bash", "-lc", command] };
     }
     maybeWarnUnsandboxed(mode);
-    return { cmd: "/bin/sh", args: ["-c", command] };
+    const plat = platform();
+    if (plat === "win32")
+        maybeWarnWindowsShell();
+    return resolveShellArgv(command, plat, plat === "win32" ? findWindowsBash() : null);
+}
+/** One-time notice on Windows when no bash is found — the POSIX commands the model writes won't run
+ *  under cmd.exe. Points the user at the fix (install Git for Windows or run under WSL). */
+let warnedWinShell = false;
+function maybeWarnWindowsShell() {
+    if (warnedWinShell || findWindowsBash())
+        return;
+    warnedWinShell = true;
+    process.stderr.write("hara: no bash found on PATH — shell commands run under cmd.exe, where most Unix commands (ls, grep, cat) fail.\n" +
+        "      Install Git for Windows (bundles bash) or run hara inside WSL for full command support.\n");
 }
 /** One-time-per-process notice that --sandbox is a no-op off macOS (covers every entry point). */
 export function maybeWarnUnsandboxed(mode) {

package/dist/tui/InputBox.js

@@ -126,12 +126,13 @@ export function wrapRows(value, cols) {
             pos += p.text.length;
         }
         else {
-            // Break the text run into word chunks (keep trailing space with the word) so wraps land on spaces.
-            const re = /\S+\s*|\s+/g;
+            // Break the text run into: a hard newline (its own atom → forces a row break, so a pasted/typed
+            // `\n` renders as an actual line), a word + trailing NON-newline whitespace, or a run of spaces.
+            const re = /\n|\S+[^\S\n]*|[^\S\n]+/g;
             let m;
-            let base = pos;
+            const base = pos;
             while ((m = re.exec(p.text))) {
-                atoms.push({ text: m[0], start: base + m.index, atomic: false });
+                atoms.push({ text: m[0], start: base + m.index, atomic: false, br: m[0] === "\n" });
             }
             pos += p.text.length;
         }
@@ -147,6 +148,12 @@ export function wrapRows(value, cols) {
     };
     for (const a of atoms) {
         const aEnd = a.start + a.text.length;
+        if (a.br) {
+            // A newline ends the current row: the `\n` sits at the row's end (renderRow strips it from the
+            // displayed text). The next row starts right after it — rows stay contiguous over the value.
+            flush(aEnd);
+            continue;
+        }
         if (a.atomic || a.text.length <= width) {
             // A whole unit (image token OR a word chunk that fits within a full row): if it doesn't fit in
             // the remaining room and the row already has content, wrap to a fresh row FIRST — never split it.
@@ -188,7 +195,9 @@ export function wrapRows(value, cols) {
  *  cursor (inverse cell) when it falls on this row. Splitting happens on precomputed rows so the
  *  whole prompt never reflows as a single <Text> — stable under wrapping and quick to diff. */
 function renderRow(value, row, cursor, showCursor, isLastRow, keyPrefix) {
-    const seg = (token, text, k) => token ? (_jsx(Text, { backgroundColor: "magenta", color: "white", children: text }, k)) : (_jsx(Text, { children: text }, k));
+    // `\n` chars are row SEPARATORS (wrapRows already broke the row on them) — never render them, or ink
+    // would insert a second line break and desync the deterministic layout.
+    const seg = (token, text, k) => token ? (_jsx(Text, { backgroundColor: "magenta", color: "white", children: text.replace(/\n/g, "") }, k)) : (_jsx(Text, { children: text.replace(/\n/g, "") }, k));
     // Segments intersected with this row's [start,end) range.
     const parts = segmentize(value);
     const nodes = [];
@@ -208,7 +217,7 @@ function renderRow(value, row, cursor, showCursor, isLastRow, keyPrefix) {
             const rel = cursor - from;
             if (rel > 0)
                 nodes.push(seg(p.token, slice.slice(0, rel), `${keyPrefix}s${ki++}`));
-            nodes.push(_jsx(Text, { inverse: true, children: slice[rel] }, `${keyPrefix}c${ki++}`));
+            nodes.push(_jsx(Text, { inverse: true, children: slice[rel] === "\n" ? " " : slice[rel] }, `${keyPrefix}c${ki++}`));
             if (rel + 1 < slice.length)
                 nodes.push(seg(p.token, slice.slice(rel + 1), `${keyPrefix}e${ki++}`));
         }
@@ -404,15 +413,24 @@ export function InputBox({ status, cwd, model, route, width, onSubmit, onClipboa
             return;
         }
         if (input && !key.ctrl && !key.meta) {
-            // A LARGE paste (many lines or lots of text in one chunk) folds to a token — never submits,
-            // never floods the box. Small chunks keep the existing paste-to-run newline behavior.
-            if (input.length >= 600 || (input.match(/\n/g)?.length ?? 0) >= 3) {
-                addPaste(input);
+            // A lone newline delivered through `input` (some terminals send Enter this way instead of
+            // setting key.return) = the user pressed Enter → submit.
+            if (/^[\r\n]+$/.test(input)) {
+                submit(value);
+                return;
+            }
+            // A PASTE containing newlines inserts as REAL MULTI-LINE TEXT (normalize CRLF/CR → LF) — the
+            // user sees and can edit it, and a pasted newline is content, NOT "send" (only a real Enter,
+            // above / key.return, submits). Only a truly ENORMOUS dump folds to a `[Paste #N]` token, so a
+            // 500-line paste doesn't turn the box into a wall — normal multi-line pastes stay visible.
+            const hasNL = /[\r\n]/.test(input);
+            if (input.length >= 8000) {
+                addPaste(input.replace(/\r\n?/g, "\n"));
                 return;
             }
-            const nl = input.search(/[\r\n]/); // a chunk carrying a newline (paste / fed input) submits
-            if (nl >= 0) {
-                submit(value.slice(0, cursor) + input.slice(0, nl) + value.slice(cursor));
+            if (hasNL) {
+                const text = input.replace(/\r\n?/g, "\n");
+                set(value.slice(0, cursor) + text + value.slice(cursor), cursor + text.length);
                 return;
             }
             // a dragged-in / pasted image file path attaches instead of inserting literal text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.108.0",
+  "version": "0.109.0",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "dist/index.js"