agent-repl 0.1.3 → 0.1.6

package/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to `agent-repl` are documented here.
 
 ## [Unreleased]
 
+## [0.1.6] — 2026-10-19
+
+### Fixed
+- `agent-repl attach`, and starting a runtime in a terminal, pass `-u` to tmux. In a terminal without a UTF-8 locale (`LANG` unset, as in Muxy), non-ASCII output such as λ or é showed as underscores.
+
+## [0.1.5] — 2026-10-19
+
+### Changed
+- Generated from pi-repl 0.8.6.
+
+### Fixed
+- The 0.1.3 done-marker footer no longer waits without limit for its Node helper. In Julia and R, a Node startup hook (`NODE_OPTIONS`) that kept Node running held the cell's completion indefinitely. In Clojure, an interrupt while the footer waited left the tmux query running.
+
+## [0.1.4] — 2026-10-19
+
+### Changed
+- Generated from pi-repl 0.8.5.
+
+### Fixed
+- Julia no longer leaves copies of a wrapped submission line in the output, as it did in panes narrower than the `include(...)` line, such as a detached session's default 80 columns.
+
 ## [0.1.3] — 2026-10-19
 
 ### Changed

package/dist/attach.js

@@ -0,0 +1,7 @@
+/** The tmux arguments that show a session in this terminal. */
+export function attachArgs(sessionName, insideTmux) {
+    // Inside tmux, switch this client to the session instead of nesting tmux.
+    // Otherwise -u: without a UTF-8 locale (LANG is unset in some terminals),
+    // a new client draws non-ASCII output such as λ or é as underscores.
+    return insideTmux ? ["switch-client", "-t", sessionName] : ["-u", "attach", "-t", sessionName];
+}

package/dist/cli.js

@@ -6,6 +6,7 @@
 import { spawnSync } from "node:child_process";
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import { attachArgs } from "./attach.js";
 import { hostContext, loadPiRepl } from "./host.js";
 import { runMcpServer } from "./mcp.js";
 import { forAgentRepl } from "./text.js";
@@ -55,9 +56,7 @@ export function attachTarget(messages) {
     return names.length === 1 ? names[0] : undefined;
 }
 function attachTerminal(sessionName) {
-    // Inside tmux, switch this client to the session instead of nesting tmux.
-    const args = process.env.TMUX ? ["switch-client", "-t", sessionName] : ["attach", "-t", sessionName];
-    return spawnSync("tmux", args, { stdio: "inherit" }).status ?? 1;
+    return spawnSync("tmux", attachArgs(sessionName, Boolean(process.env.TMUX)), { stdio: "inherit" }).status ?? 1;
 }
 async function attach(runtime, cwd) {
     const interactive = process.stdin.isTTY && process.stdout.isTTY;

package/dist/pi-repl.js

@@ -1,4 +1,4 @@
-// GENERATED by scripts/sync-from-pi-repl.mjs from pi-repl 0.8.4 (6d9234a). Do not edit by hand:
+// GENERATED by scripts/sync-from-pi-repl.mjs from pi-repl 0.8.6 (7dd015b). Do not edit by hand:
 // change pi-repl and re-sync. Identical to pi-repl's index.ts except that its Pi
 // imports come from ./pi-compat/index.js.
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateTail, } from "./pi-compat/index.js";
@@ -890,7 +890,9 @@ function buildClojureDisplayStatements(display, indent = "") {
 // Prints the pane's cursor column, or exits non-zero; tmux gets 500 ms. A
 // wrapper runs it with Node and ends a line before its footer unless it
 // prints 0. Only the wrapper reads its output, so it never reaches the pane.
-const CURSOR_COLUMN_QUERY = 'try { process.stdout.write(require("node:child_process").execFileSync("tmux", ["-N", "display-message", "-p", "-t", process.env.TMUX_PANE, "#{cursor_x}"], { encoding: "utf8", timeout: 500, killSignal: "SIGKILL", maxBuffer: 128, stdio: ["ignore", "pipe", "ignore"] }).trim()); } catch { process.exitCode = 1; }';
+// process.exit ends Node even if a startup hook in NODE_OPTIONS would keep it
+// running, and each wrapper also limits the whole helper to 5 s.
+const CURSOR_COLUMN_QUERY = 'let code = 1; try { require("node:fs").writeSync(1, require("node:child_process").execFileSync("tmux", ["-N", "display-message", "-p", "-t", process.env.TMUX_PANE, "#{cursor_x}"], { encoding: "utf8", timeout: 500, killSignal: "SIGKILL", maxBuffer: 128, stdio: ["ignore", "pipe", "ignore"] }).trim()); code = 0; } catch {} process.exit(code);';
 function buildPythonFooter(display) {
     if (!display.enabled)
         return [];
@@ -954,12 +956,32 @@ function buildJuliaFooter(display) {
     const query = `Cmd([${juliaStringLiteral(process.execPath)}, "-e", ${juliaStringLiteral(CURSOR_COLUMN_QUERY)}])`;
     return [
         '    local __pi_repl_column = ""',
-        // read throws if the query fails; catch also takes an interrupt here.
+        "    local __pi_repl_query = nothing",
+        // The wait, not the read, is bounded: a child the helper started could
+        // keep the pipe open after the helper exits. An interrupt does not end
+        // the wait, since killing Node early would leave its tmux child
+        // running. After 5 s a helper still running is killed, and the pipe
+        // is closed so that the reader ends too.
         "    try",
         "        flush(stdout)",
         "        flush(stderr)",
-        `        __pi_repl_column = strip(read(pipeline(${query}, stdin=devnull, stderr=devnull), String))`,
+        `        __pi_repl_query = open(pipeline(${query}, stdin=devnull, stderr=devnull), "r")`,
+        "        local __pi_repl_reader = @async read(__pi_repl_query, String)",
+        "        local __pi_repl_deadline = time_ns() + 5_000_000_000",
+        "        local __pi_repl_finished = false",
+        "        while !__pi_repl_finished && time_ns() < __pi_repl_deadline",
+        "            try",
+        "                __pi_repl_finished = timedwait(() -> istaskdone(__pi_repl_reader) && process_exited(__pi_repl_query), max(0.01, (signed(__pi_repl_deadline) - signed(time_ns())) / 1e9); pollint=0.01) === :ok",
+        "            catch",
+        "            end",
+        "        end",
+        "        __pi_repl_finished && success(__pi_repl_query) && (__pi_repl_column = strip(fetch(__pi_repl_reader)))",
         "    catch",
+        "    finally",
+        "        if !isnothing(__pi_repl_query)",
+        "            process_exited(__pi_repl_query) || kill(__pi_repl_query, Base.SIGKILL)",
+        "            try close(__pi_repl_query.out) catch end",
+        "        end",
         "    end",
         '    __pi_repl_column == "0" || Base.println()',
         ...display.suffixLines.map((line) => `    Base.println(${juliaStringLiteral(line)})`),
@@ -987,9 +1009,10 @@ function buildRFooter(display) {
         return [];
     return [
         "    try({ flush(stdout()); flush(stderr()) }, silent = TRUE)",
-        // system2 quotes the command but not its arguments. A failed query
-        // sets a status; an error or Ctrl-C here gives NULL, not a lost done file.
-        `    .__pi_repl_column <- tryCatch(suppressWarnings(system2(${JSON.stringify(process.execPath)}, c("-e", ${JSON.stringify(shellQuote(CURSOR_COLUMN_QUERY))}), stdout = TRUE, stderr = FALSE)), error = function(e) NULL, interrupt = function(e) NULL)`,
+        // system2 quotes the command but not its arguments, and kills it after
+        // 5 s. A failed query sets a status; an error or Ctrl-C here gives
+        // NULL, not a lost done file.
+        `    .__pi_repl_column <- tryCatch(suppressWarnings(system2(${JSON.stringify(process.execPath)}, c("-e", ${JSON.stringify(shellQuote(CURSOR_COLUMN_QUERY))}), stdout = TRUE, stderr = FALSE, timeout = 5)), error = function(e) NULL, interrupt = function(e) NULL)`,
         '    if (!is.null(attr(.__pi_repl_column, "status")) || !identical(trimws(paste(.__pi_repl_column, collapse = "")), "0")) base::cat("\\n")',
         ...display.suffixLines.map((line) => `    base::cat(${JSON.stringify(`${line}\n`)})`),
     ];
@@ -1126,16 +1149,27 @@ function buildClojureFooter(display) {
     return [
         "      (try (.flush *out*) (.flush *err*) (catch Throwable _))",
         // An interrupt left pending by the code would end the wait at once, so
-        // it is cleared for the query and restored afterwards, as is one that
-        // arrives during the wait. The query is killed on every path.
+        // it is cleared for the query and restored afterwards. One that arrives
+        // during the wait is noted and the wait goes on: killing Node early
+        // would leave its tmux child running. The query is killed after 5 s.
         "      (let [pi-repl-interrupted (volatile! (Thread/interrupted))",
         `            pi-repl-query (try (.start (.redirectError ${builder} java.lang.ProcessBuilder$Redirect/DISCARD)) (catch Throwable _ nil))`,
+        "            pi-repl-deadline (+ (System/nanoTime) 5000000000)",
         "            pi-repl-column (when pi-repl-query",
         "                             (try",
         "                               (.close (.getOutputStream pi-repl-query))",
-        "                               (when (and (.waitFor pi-repl-query 5 java.util.concurrent.TimeUnit/SECONDS) (zero? (.exitValue pi-repl-query)))",
-        "                                 (.trim ^String (slurp (.getInputStream pi-repl-query))))",
-        "                               (catch InterruptedException _ (vreset! pi-repl-interrupted true) nil)",
+        "                               (when (and (loop []",
+        "                                            (let [left (- pi-repl-deadline (System/nanoTime))",
+        "                                                  exited (when (pos? left)",
+        "                                                           (try (.waitFor pi-repl-query left java.util.concurrent.TimeUnit/NANOSECONDS)",
+        "                                                             (catch InterruptedException _ (vreset! pi-repl-interrupted true) :interrupted)))]",
+        "                                              (if (= exited :interrupted) (recur) exited)))",
+        "                                          (zero? (.exitValue pi-repl-query)))",
+        // Only what is waiting: a child of Node could hold the pipe open.
+        "                                 (let [in (.getInputStream pi-repl-query)",
+        "                                       bytes (byte-array (min 32 (.available in)))",
+        "                                       n (.read in bytes)]",
+        '                                   (.trim (String. bytes 0 (int (max 0 n)) "UTF-8"))))',
         "                               (catch Throwable _ nil)",
         "                               (finally (.destroyForcibly pi-repl-query))))]",
         "        (when @pi-repl-interrupted (.interrupt (Thread/currentThread)))",
@@ -1362,7 +1396,7 @@ function prepareReplControlFiles(runtime, code, details) {
         throw error;
     }
 }
-async function pasteTextToTmuxPane(pi, sessionTarget, cwd, text, onPasted) {
+async function pasteTextToTmuxPane(pi, sessionTarget, cwd, text, onPasted, bracketed = false) {
     const bufferName = `pi-repl-${randomUUID()}`;
     const target = await getPaneTarget(pi, sessionTarget, cwd);
     const controlPaths = createPrivateReplControlFiles({ ...REPL_CONTROL_OPTIONS, extension: "txt", buildSource: () => text });
@@ -1374,7 +1408,10 @@ async function pasteTextToTmuxPane(pi, sessionTarget, cwd, text, onPasted) {
             const reason = loadResult.stderr.trim() || loadResult.stdout.trim() || `exit code ${loadResult.code}`;
             throw new Error(`Failed to load tmux buffer: ${reason}`);
         }
-        const pasteResult = await execTmux(pi, ["paste-buffer", "-d", "-b", bufferName, "-t", target], cwd, 5_000);
+        // -p brackets the paste only if the REPL asked for bracketed pastes.
+        // Julia then draws a line that wraps in the pane once, not once per
+        // character, which left copies of its first row in the output.
+        const pasteResult = await execTmux(pi, ["paste-buffer", ...(bracketed ? ["-p"] : []), "-d", "-b", bufferName, "-t", target], cwd, 5_000);
         if (pasteResult.code !== 0) {
             const reason = pasteResult.stderr.trim() || pasteResult.stdout.trim() || `exit code ${pasteResult.code}`;
             throw new Error(`Failed to paste tmux buffer: ${reason}`);
@@ -1674,7 +1711,7 @@ async function runReplCode(pi, params, ctx, signal, options = {}) {
         await pasteTextToTmuxPane(pi, paneTarget, ctx.cwd, prepared.submissionText, () => {
             submissionStarted = true;
             options.onSubmissionStarted?.(submissionState);
-        });
+        }, runtime === "julia");
         await waitForReplDoneFile(pi, sessionName, sessionTarget, paneTarget, ctx.cwd, prepared.controlPaths.doneFile, timeoutMs, signal, { beforeCapture, prepared, state: submissionState });
         submissionState.completionObserved = true;
         const afterCapture = await capturePaneOutput(pi, paneTarget, ctx.cwd);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "agent-repl",
-	"version": "0.1.3",
+	"version": "0.1.6",
 	"description": "pi-repl's shared tmux REPLs (Python, Julia, R and more) for Claude Code, Codex, OpenCode and other agents, over MCP and a CLI.",
 	"keywords": [
 		"repl",