@alphacoder-v0/pi-loops 0.22.3 → 0.22.5

package/src/web.mjs

@@ -210,6 +210,8 @@ const STDERR_KEEP = 8000;
 /** What actually leaves this process: the tail, which is the part that says why pi stopped. */
 const STDERR_SEND = 4000;
 let stderrTail = "";
+/** Characters the keep cut has already thrown away, so the send cut can count everything dropped. */
+let stderrDropped = 0;
 /**
  * The shapes a credential takes in a line of output.
  *
@@ -258,14 +260,25 @@ function maskSecrets(text) {
 }
 
 function recentStderr() {
-	// Redact the whole kept tail, then cut. The other order cut first, so a key that straddled the
-	// 4000-character boundary lost the `sk-` its pattern starts at — nothing matched, and the second
-	// half of it went out to every attached browser.
-	return maskSecrets(stderrTail.trim()).slice(-STDERR_SEND);
+	// Redact the whole kept tail, then cut by characters. `slice` counted UTF-16 code units, so the
+	// served tail could begin on the low half of an astral character — a replacement glyph where the
+	// error should start — and the page's own cap at 4000 could never fire: it was always handed 4000
+	// code units or fewer, and code points are never more numerous than code units, so nothing ever
+	// told the person anything was dropped. The count has to be put here rather than in the page,
+	// because `capped` keeps the first n characters and a tail keeps the last.
+	const kept = Array.from(maskSecrets(stderrTail.trim()));
+	if (!stderrDropped && kept.length <= STDERR_SEND) return kept.join("");
+	const room = STDERR_SEND - 40; // the marker line below is shorter than this
+	const shown = kept.slice(-room);
+	return `… (${stderrDropped + kept.length - shown.length} chars dropped)\n${shown.join("")}`;
 }
 pi.stderr.on("data", (d) => {
 	process.stderr.write(d);
-	stderrTail = (stderrTail + d.toString("utf8")).slice(-STDERR_KEEP);
+	// Characters, not code units: a cut on the code-unit half of an astral character leaves a lone
+	// surrogate in the tail, which `textContent` draws as a replacement glyph.
+	const all = Array.from(stderrTail + d.toString("utf8"));
+	stderrDropped += Math.max(0, all.length - STDERR_KEEP);
+	stderrTail = all.slice(-STDERR_KEEP).join("");
 });
 
 let nextId = 1;
@@ -464,9 +477,9 @@ function formatSchedule(s) {
  * Missing file, older pi-loops, no leader yet: no next run shown, which is what was shown before.
  */
 function nextRuns() {
-	// This machine's file. Leadership is per host, and so is the clock a cron expression is matched
-	// against, so on a shared `$HOME` each machine keeps its own answers rather than overwriting the
-	// other's with times computed in a different timezone.
+	// The scheduler's one file. If two machines shared a `$HOME` they would both run every job and
+	// overwrite one another's answers here; that is unsupported rather than handled
+	// (docs/design.md §19).
 	const doc = readJson(path.join(LOOPS_DIR, "next-runs.json"), { next: {} });
 	return doc?.next && typeof doc.next === "object" ? doc.next : {};
 }
@@ -502,10 +515,13 @@ function automation(cwd) {
 		runCount: j.runCount ?? 0,
 		lastError: maskSecrets(j.lastError),
 		running: !!j.running,
-		// The open body of a card shows these two, which the terminal's `/cron` line has and the
-		// panel did not; they leave the store as they were written, no reshaping.
+		// The open body of a card shows these, which the terminal's `/cron` line has and the panel
+		// did not; they leave the store as they were written, no reshaping.
 		cwd: j.cwd,
 		lastFiredAt: j.lastFiredAt,
+		// Due ticks a run was too slow to take. The `lastError` a skip writes is cleared by the next
+		// run; this count is not, so it is the last evidence a loop is losing cadence.
+		skippedOverlap: j.skippedOverlap ?? 0,
 		// Set only when it is not this machine's: the panel says so, and nothing else has to guess.
 		// What to type to fix it. The terminal's version of this line says `/cron set <n>`, where n
 		// is the position in a numbered list — which this panel does not have, so telling someone to
@@ -822,11 +838,15 @@ function listSessionsHere(limit = 40) {
 /** The header, a name if one was set early, and the first thing a person said. */
 function readHead(file) {
 	let text;
+	let readBytes = 0;
 	try {
 		const fd = fs.openSync(file, "r");
 		try {
 			const buf = Buffer.alloc(SESSION_HEAD);
-			text = buf.toString("utf8", 0, fs.readSync(fd, buf, 0, SESSION_HEAD, 0));
+			// `SESSION_HEAD` is a byte window, so the decision to cut is the byte count read, not the
+			// decoded string's length: a multi-byte character makes those differ.
+			readBytes = fs.readSync(fd, buf, 0, SESSION_HEAD, 0);
+			text = buf.toString("utf8", 0, readBytes);
 		} finally {
 			fs.closeSync(fd);
 		}
@@ -841,7 +861,7 @@ function readHead(file) {
 		return undefined;
 	}
 	if (header?.type !== "session" || typeof header.id !== "string") return undefined;
-	const cut = text.length >= SESSION_HEAD;
+	const cut = readBytes >= SESSION_HEAD;
 	let name;
 	let first;
 	let messages = 0;
@@ -2024,15 +2044,29 @@ function previewRoot(file) {
 	return undefined;
 }
 
-/** The path the filesystem actually means: symlinks followed as far as anything exists. */
+/**
+ * The path the filesystem actually means: every symlink above it resolved, whether or not the path
+ * itself exists. The deepest ancestor that does exist is resolved and the rest re-attached.
+ *
+ * One level up was not enough. A job whose cwd is a removed worktree or a checkout that moved is two
+ * or more levels below the deepest thing that exists, and a parent-only fallback returned the
+ * unresolved path — so `sameProject` said "another project" about a directory plainly inside this
+ * one, and the panel dropped a job `/cron` still lists with `[orphan: cwd missing]`. This is the
+ * walk `src/paths.ts` does as `realpathish`, copied because the front end is one file with no
+ * imports on purpose.
+ */
 function realOf(file) {
-	try {
-		return fs.realpathSync(file);
-	} catch {
+	if (!file) return "";
+	let at = path.resolve(file);
+	const tail = [];
+	for (;;) {
 		try {
-			return path.join(fs.realpathSync(path.dirname(file)), path.basename(file));
+			return path.join(fs.realpathSync(at), ...tail);
 		} catch {
-			return path.resolve(file);
+			const parent = path.dirname(at);
+			if (parent === at) return path.resolve(file); // reached the root and nothing resolved
+			tail.unshift(path.basename(at));
+			at = parent;
 		}
 	}
 }
@@ -3038,10 +3072,15 @@ function copyBtn(getText) {
  * they reported the drop three different ways, one of them not at all: a result that stopped at 8000
  * characters looked like a result that ended there. A cap that hides its own existence is a lie
  * about the output.
+ *
+ * Counted and cut in characters, which is what the message says and what capChars in src/protocol.ts
+ * and previewText in src/session-head.ts have always counted. String.length is code units, so an
+ * emoji is two of them: the count came out larger than what was shown, and a cut between the two
+ * halves of one left half a character, which a browser draws as a replacement glyph.
  */
 function capped(text, n) {
-  const s = String(text ?? "");
-  return s.length > n ? s.slice(0, n) + "\n… (" + s.length + " chars)" : s;
+  const chars = Array.from(String(text ?? ""));
+  return chars.length > n ? chars.slice(0, n).join("") + "\n… (" + chars.length + " chars)" : chars.join("");
 }
 
 /** Replace a row's plain text with its rendered Markdown, keeping the source for the copy button. */
@@ -3505,7 +3544,7 @@ function renderSidebar(s) {
         '<div class="body">' +
         '<pre class="full">' + prompt + "</pre>" +
         '<button class="copy" data-copy="' + safeText(j.id) + '">copy</button>' +
-        '<div class="m">id ' + safeText(j.id) + " · cwd " + safeText(j.cwd) + (j.lastFiredAt ? " · last fired " + safeText(j.lastFiredAt) : "") + "</div>" +
+        '<div class="m">id ' + safeText(j.id) + " · cwd " + safeText(j.cwd) + (j.lastFiredAt ? " · last fired " + safeText(j.lastFiredAt) : "") + (j.skippedOverlap ? " · skipped overlaps " + num(j.skippedOverlap) : "") + "</div>" +
         // A job belonging to a hostname this machine no longer has: it is listed, because it exists,
         // and it says why nothing is happening rather than leaving you to find out from the silence.
         (j.lastError ? '<div class="m" style="color:#c66">' + safeText(j.lastError) + "</div>" : "") +
@@ -3745,7 +3784,7 @@ function renderRuntime(rt) {
     // An MCP server's name, its state and its last error are all that server's own words.
     html += "<div>" + dot(m.state) + safeText(m.name) + " <span class=\"m\">" + safeText(m.state) + " · " + countOf((m.tools || []).length, "tools", m.tools) +
       (m.injects ? " · injects" : "") + (m.queued ? " · " + num(m.queued) + " queued" : "") + "</span></div>" +
-      (m.lastError ? '<div class="m" style="color:#c66">  ' + safeText(str(m.lastError).slice(0, 120)) + "</div>" : "");
+      (m.lastError ? '<div class="m" style="color:#c66">  ' + safeText(str(m.lastError)) + "</div>" : "");
   }
   if (rt.mcpConfigError) html += '<div class="m" style="color:#c66">mcp.toml: ' + safeText(rt.mcpConfigError) + "</div>";
   const h = rt.hooks || {};