commit initial 09-12-2025 32

src/App.js

@@ -140,6 +140,9 @@ function App() {
   const [isRunning, setIsRunning] = useState(false);
   const [isFixing, setIsFixing] = useState(false);
   const [isExplaining, setIsExplaining] = useState(false);
+  // near other useState declarations
+const [interactivePromptShown, setInteractivePromptShown] = useState(false);
+
 
   useEffect(() => {
     saveTree(tree);
@@ -271,106 +274,130 @@ function App() {
 
   // Core run with updated input (used by XTerm onData and Send button)
   const runCodeWithUpdatedInput = async (inputLine) => {
-    // append newline like a real console
-    const newAccum = (accumStdin || "") + inputLine + "\n";
-    setAccumStdin(newAccum);
+  if (typeof inputLine !== "string") inputLine = String(inputLine || "");
+  const trimmed = inputLine.replace(/\r$/, ""); // normalize
+  if (trimmed.length === 0 && !accumStdin) {
+    // nothing to send
+    return;
+  }
 
-    const node = getNodeByPath(tree, activePath);
-    if (!node || node.type !== "file") {
-      setOutput((prev) => prev + "\n[Error] No file selected to run.");
-      setAwaitingInput(false);
-      return;
-    }
+  // append newline like a real console
+  const newAccum = (accumStdin || "") + trimmed + "\n";
+  setAccumStdin(newAccum);
+  setInteractivePromptShown(false); // first input arrived -> clear prompt-shown flag
 
-    const selectedLang = LANGUAGE_OPTIONS.find((l) => node.name.endsWith(l.ext))?.id;
-    if (!selectedLang || !RUNNABLE_LANGS.includes(selectedLang)) {
-      setOutput((prev) => prev + `\n[Error] Run not supported for ${node.name}`);
-      setAwaitingInput(false);
-      return;
-    }
+  const node = getNodeByPath(tree, activePath);
+  if (!node || node.type !== "file") {
+    setOutput((prev) => prev + "\n[Error] No file selected to run.");
+    setAwaitingInput(false);
+    return;
+  }
 
-    setIsRunning(true);
-    try {
-      const res = await runCode(node.content, selectedLang, newAccum);
-      const out = res.output ?? "";
-      setOutput(out);
-      setProblems(res.error ? parseProblems(res.output) : []);
-      if (outputLooksForInput(out)) {
-        setAwaitingInput(true);
-        // keep focus
-        focusXtermHelper();
-      } else {
-        setAwaitingInput(false);
-      }
-    } catch (err) {
-      setOutput(String(err));
+  const selectedLang = LANGUAGE_OPTIONS.find((l) => node.name.endsWith(l.ext))?.id;
+  if (!selectedLang || !RUNNABLE_LANGS.includes(selectedLang)) {
+    setOutput((prev) => prev + `\n[Error] Run not supported for ${node.name}`);
+    setAwaitingInput(false);
+    return;
+  }
+
+  setIsRunning(true);
+  try {
+    const res = await runCode(node.content, selectedLang, newAccum);
+    const out = res.output ?? "";
+    setOutput(out);
+    setProblems(res.error ? parseProblems(res.output) : []);
+    if (outputLooksForInput(out)) {
+      // program still waits for more input
+      setAwaitingInput(true);
+      focusXtermHelper();
+    } else {
       setAwaitingInput(false);
-    } finally {
-      setIsRunning(false);
     }
-  };
+  } catch (err) {
+    setOutput(String(err));
+    setAwaitingInput(true);
+  } finally {
+    setIsRunning(false);
+  }
+};
+
 
   // Initial Run: do NOT run if code needs interactive input and there's no accumulated stdin.
-  const handleRun = async () => {
-    const node = getNodeByPath(tree, activePath);
-    if (!node || node.type !== "file") {
-      setOutput("Select a file to run.");
-      return;
-    }
-    const selectedLang = LANGUAGE_OPTIONS.find((l) => node.name.endsWith(l.ext))?.id;
-    if (!selectedLang || !RUNNABLE_LANGS.includes(selectedLang)) {
-      setOutput(`⚠️ Run not supported for this file type.`);
-      return;
-    }
+ const handleRun = async () => {
+  const node = getNodeByPath(tree, activePath);
+  if (!node || node.type !== "file") {
+    setOutput("Select a file to run.");
+    return;
+  }
+  const selectedLang = LANGUAGE_OPTIONS.find((l) => node.name.endsWith(l.ext))?.id;
+  if (!selectedLang || !RUNNABLE_LANGS.includes(selectedLang)) {
+    setOutput(`⚠️ Run not supported for this file type.`);
+    return;
+  }
+
+  const needs = codeNeedsInput(node.content, selectedLang);
+  const haveAccum = !!(accumStdin && accumStdin.length > 0);
+  const haveLegacyStdin = !!(stdin && stdin.length > 0);
+
+  if (needs && !haveAccum && !haveLegacyStdin) {
+    // Show helpful message in terminal and enable awaitingInput so user can type into XTerm.
+    setOutput("[Interactive program detected — type input directly into the terminal]");
+    setAwaitingInput(true);
+    setInteractivePromptShown(true);
+    focusXtermHelper();
+    return; // do not run now (avoids EOFError)
+  }
 
-    const needs = codeNeedsInput(node.content, selectedLang);
-    const haveAccum = !!(accumStdin && accumStdin.length > 0);
-    const haveLegacyStdin = !!(stdin && stdin.length > 0);
+  // Otherwise run immediately with whichever stdin we have (accumStdin or legacy stdin)
+  const stdinToSend = accumStdin || stdin || "";
 
-    if (needs && !haveAccum && !haveLegacyStdin) {
-      // Show instruction and enable typing in XTerm; do not perform a run with empty stdin (avoids EOFError)
-      setOutput("[Interactive program detected — click Start interactive session or type in terminal]");
+  resetTerminal(true); // keep accumStdin
+  setOutput(`[Running with stdin length=${stdinToSend ? stdinToSend.length : 0}]\n`);
+  setIsRunning(true);
+  setProblems([]);
+  try {
+    const res = await runCode(node.content, selectedLang, stdinToSend);
+    const out = res.output ?? "";
+    setOutput(out);
+    setProblems(res.error ? parseProblems(res.output) : []);
+    if (outputLooksForInput(out)) {
       setAwaitingInput(true);
       focusXtermHelper();
-      return;
+    } else {
+      setAwaitingInput(false);
+      setInteractivePromptShown(false);
     }
+  } catch (err) {
+    setOutput(String(err));
+    // Allow user to type into terminal after EOF errors
+    setAwaitingInput(true);
+    setInteractivePromptShown(true);
+    focusXtermHelper();
+  } finally {
+    setIsRunning(false);
+  }
+};
 
-    // Otherwise perform run with existing accumulated or legacy input
-    const stdinToSend = accumStdin || stdin || "";
-    resetTerminal(true);
-    setOutput(`[Running with stdin length=${stdinToSend ? stdinToSend.length : 0}]\n`);
-    setIsRunning(true);
-    setProblems([]);
-    try {
-      const res = await runCode(node.content, selectedLang, stdinToSend);
-      const out = res.output ?? "";
-      setOutput(out);
-      setProblems(res.error ? parseProblems(res.output) : []);
-      if (outputLooksForInput(out)) {
-        setAwaitingInput(true);
-        focusXtermHelper();
-      } else {
-        setAwaitingInput(false);
-      }
-    } catch (err) {
-      setOutput(String(err));
-      // allow interactive continuation after EOF
-      setAwaitingInput(true);
+
+  // Send from the small input box: delegate to runCodeWithUpdatedInput to keep behavior uniform
+ const sendTerminalInput = async () => {
+  const line = (terminalInput || "").replace(/\r$/, "");
+  if (!line) {
+    // If there is no typed small-input but interactivePromptShown is true, just focus terminal
+    if (interactivePromptShown) {
       focusXtermHelper();
-    } finally {
-      setIsRunning(false);
     }
-  };
+    return;
+  }
+
+  // show echo in output
+  setOutput((prev) => (prev ? prev + `\n> ${line}` : `> ${line}`));
+  setTerminalInput("");
+
+  // Use the unified runner that appends input and runs
+  await runCodeWithUpdatedInput(line);
+};
 
-  // Send from the small input box: delegate to runCodeWithUpdatedInput to keep behavior uniform
-  const sendTerminalInput = async () => {
-    if (!terminalInput || terminalInput.length === 0) return;
-    // echo in output for small box then run
-    setOutput((prev) => prev + `\n> ${terminalInput}`);
-    const line = terminalInput;
-    setTerminalInput("");
-    await runCodeWithUpdatedInput(line);
-  };
 
   // handle press Enter for small input
   const onTerminalKeyDown = (e) => {
@@ -554,12 +581,19 @@ function App() {
               <div style={{ fontSize: 12, color: "#ccc", marginBottom: 6 }}>Terminal</div>
 
               <XTerm
-                output={output}
-                onData={(line) => {
-                  // Called when XTerm wrapper detects a full line (ENTER)
-                  runCodeWithUpdatedInput(line);
-                }}
-              />
+  output={output}
+  onData={(line) => {
+    const text = (line || "").replace(/\r$/, "");
+    if (!text) return;
+    // only auto-send when we previously showed a prompt OR are awaiting input
+    if (interactivePromptShown || awaitingInput) {
+      runCodeWithUpdatedInput(text);
+    } else {
+      // not an interactive session — you can still echo into small input if desired
+      setTerminalInput((prev) => (prev ? prev + text : text));
+    }
+  }}
+/>
 
               {/* When interactive program detected and waiting for user input */}
               {awaitingInput && (