claude-mux 0.30.13 → 0.30.15

package/src/server/message-queue.ts

@@ -12,7 +12,7 @@
 
 import { execFileSync, execSync } from 'child_process';
 import { randomUUID } from 'crypto';
-import { existsSync, readFileSync } from 'fs';
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync } from 'fs';
 import { join } from 'path';
 import { getAllSessions } from '../db/index.js';
 import { CLAUDE_MUX_DIR } from '../utils/paths.js';
@@ -21,6 +21,7 @@ import { isPidAlive } from '../utils/pid.js';
 import { capturePaneContentAsync, readPaneHold, readPromptBox } from '../tmux/pane.js';
 import { composePromptWithAttachments } from './attachments.js';
 import { recordDictation } from './dictation-marks.js';
+import { resolveTranscriptPath } from '../transcript/tailer.js';
 import type { DeliveryInfo, QueuedMessageInfo } from '../types/ws-messages.js';
 
 // ============================================================================
@@ -114,26 +115,91 @@ function pressEnter(target: string): void {
 	}
 }
 
-/** How long Claude Code gets to take a pasted line before the box is read. */
-const SUBMIT_SETTLE_MS = 600;
+/** How often the box is read while waiting for Claude Code to take a line. */
+const SUBMIT_POLL_MS = 250;
+/** How long the text may sit in the box before one more Enter is sent. */
+const SUBMIT_RETRY_MS = 1500;
+/** How long Claude Code gets in all before the line counts as not taken. */
+const SUBMIT_GIVE_UP_MS = 5000;
+/** How much of the transcript's tail is searched for the line being logged. */
+const TRANSCRIPT_TAIL_BYTES = 512 * 1024;
+
+/** Claude Code's stand-in for a long paste in its box: "[Pasted text #1 +12 lines]". */
+const PASTE_PLACEHOLDER = /^\[Pasted text #\d+/;
+
+/**
+ * Whether the session in `target` logged `text` as a prompt or a queued
+ * message at or after `since`: the transcript's word that Claude Code took
+ * it, which holds even while the pane has not yet redrawn its box.
+ */
+function loggedSince(target: string, text: string, since: number): boolean {
+	const session = getAllSessions().find((s) => s.tmux_target === target || s.id === target);
+	const path = session ? resolveTranscriptPath(session, session.id) : null;
+	if (!path) return false;
+	const want = text.replace(/\s+/g, '');
+	try {
+		const size = statSync(path).size;
+		const fd = openSync(path, 'r');
+		try {
+			const length = Math.min(size, TRANSCRIPT_TAIL_BYTES);
+			const buf = Buffer.alloc(length);
+			readSync(fd, buf, 0, length, size - length);
+			const lines = buf.toString('utf8').split('\n').reverse();
+			for (const line of lines) {
+				if (!line.includes('"queue-operation"') && !line.includes('"type":"user"')) continue;
+				let record: { timestamp?: string; content?: unknown; message?: { content?: unknown } };
+				try {
+					record = JSON.parse(line);
+				} catch {
+					continue;
+				}
+				const at = record.timestamp ? Date.parse(record.timestamp) : NaN;
+				if (!(at >= since)) continue;
+				const content = record.content ?? record.message?.content;
+				const logged = typeof content === 'string' ? content : JSON.stringify(content ?? '');
+				if (logged.replace(/\s+/g, '').includes(want)) return true;
+			}
+		} finally {
+			closeSync(fd);
+		}
+	} catch {
+		/* no transcript to read: the box decides */
+	}
+	return false;
+}
 
 /**
  * Whether Claude Code took the line just sent. A message it accepted has left
  * the box: either the turn started, or, while busy, it went to Claude Code's
- * own queue and the box shows the hint for that. Text still sitting there
- * typed means the Enter was lost, which happens when the paste and the key
- * land inside the same input burst; one more Enter is sent, and the box read
- * again. Resolves false when the text is still there after that.
+ * own queue. A busy pane in a long session can take seconds to redraw, so the
+ * box is read until then, and two other signs count as taken meanwhile: the
+ * box holding something else, and the transcript logging the line (a prompt,
+ * or a queue entry). Text still sitting there after a while means the Enter
+ * was lost, which happens when the paste and the key land inside the same
+ * input burst; one more Enter is sent. Resolves false when the text is still
+ * there, unlogged, at the end.
  */
-export async function confirmSubmitted(target: string): Promise<boolean> {
-	for (let attempt = 0; attempt < 2; attempt++) {
-		await new Promise((r) => setTimeout(r, SUBMIT_SETTLE_MS));
+export async function confirmSubmitted(target: string, text?: string): Promise<boolean> {
+	const since = Date.now() - 2000;
+	const started = Date.now();
+	let retried = false;
+	for (;;) {
+		await new Promise((r) => setTimeout(r, SUBMIT_POLL_MS));
 		const raw = await capturePaneContentAsync(target, true);
 		const box = raw === null ? null : readPromptBox(raw);
 		if (!box || box.kind !== 'typed' || !box.text.trim()) return true;
-		if (attempt === 0) execFileSync('tmux', ['send-keys', '-t', target, 'Enter'], { stdio: 'ignore' });
+		if (text !== undefined) {
+			const typed = box.text.trim();
+			if (!PASTE_PLACEHOLDER.test(typed) && !sameTyped(typed, text)) return true;
+			if (loggedSince(target, text, since)) return true;
+		}
+		const waited = Date.now() - started;
+		if (!retried && waited >= SUBMIT_RETRY_MS) {
+			pressEnter(target);
+			retried = true;
+		}
+		if (waited >= SUBMIT_GIVE_UP_MS) return false;
 	}
-	return false;
 }
 
 /** How a message handed to the pane fared (`submitToPane`). */
@@ -163,7 +229,7 @@ export async function submitToPane(target: string, text: string): Promise<Submit
 	} else {
 		sendTextToPane(target, text);
 	}
-	return (await confirmSubmitted(target)) ? 'taken' : 'in-box';
+	return (await confirmSubmitted(target, text)) ? 'taken' : 'in-box';
 }
 
 /**

package/src/transcript/parser.ts

@@ -177,6 +177,21 @@ function parseLocalOutput(content: string): string | null {
   return chunks.join("\n");
 }
 
+/** The wrapper Claude Code logs around a long paste: `<pasted_content id="c2b8">` … `</pasted_content id="c2b8">`. */
+const PASTED_OPEN = /<pasted_content id="[^"]*">\n?/g;
+const PASTED_CLOSE = /\n?<\/pasted_content id="[^"]*">\n?/g;
+
+/**
+ * A prompt as it was pasted. Claude Code logs a long paste inside a
+ * `<pasted_content>` wrapper (with a blank line before it when nothing was
+ * typed ahead of it); the person sent the text, not the tags, and the
+ * dictation and queued-message matching compare against the text.
+ */
+export function unwrapPasted(text: string): string {
+  if (!text.includes("<pasted_content id=")) return text;
+  return text.replace(PASTED_OPEN, "").replace(PASTED_CLOSE, "\n").trim();
+}
+
 function parseAskQuestions(input: Record<string, unknown>): AskQuestion[] {
   const raw = input.questions;
   if (!Array.isArray(raw)) return [];
@@ -503,7 +518,8 @@ export class TranscriptBuilder {
     if (!attachment || attachment.type !== "queued_command") return [];
     // Only human-typed prompts; system notifications also arrive queued.
     if (asRecord(attachment.origin)?.kind !== "human") return [];
-    const prompt = readString(attachment.prompt);
+    const raw = readString(attachment.prompt);
+    const prompt = raw === null ? null : unwrapPasted(raw);
     if (!prompt || prompt.trim().length === 0) return [];
     const uuid = readString(record.uuid) ?? `queued-${this.entries.length}`;
     const ts = parseTimestamp(record.timestamp ?? attachment.timestamp);
@@ -582,7 +598,7 @@ export class TranscriptBuilder {
     if (!message) return [];
     const uuid = readString(record.uuid) ?? `user-${this.entries.length}`;
     const ts = parseTimestamp(record.timestamp);
-    const content = message.content;
+    const content = typeof message.content === "string" ? unwrapPasted(message.content) : message.content;
 
     // Cross-session (A2A) messages arrive as meta user lines with
     // origin.kind "peer"; origin.body is the clean text (message.content is
@@ -724,7 +740,8 @@ export class TranscriptBuilder {
           }),
         );
       } else if (rec.type === "text") {
-        const text = readString(rec.text);
+        const raw = readString(rec.text);
+        const text = raw === null ? null : unwrapPasted(raw);
         if (text && text.trim().length > 0) promptTexts.push(text);
       }
     }

package/src/transcript/past-sessions.ts

@@ -18,7 +18,7 @@
 import { open, readdir, readFile, stat } from "node:fs/promises";
 import { basename, join } from "node:path";
 import { type PastSession } from "../past-session.js";
-import { parseSlashCommand } from "./parser.js";
+import { parseSlashCommand, unwrapPasted } from "./parser.js";
 import { projectsRoot } from "./tailer.js";
 
 
@@ -76,6 +76,8 @@ export function promptText(entry: Entry): string | null {
     if (!block || message.content.some((b) => b?.type === "tool_result")) return null;
     text = block.text;
   }
+  // A long paste is logged inside Claude Code's <pasted_content> wrapper.
+  if (text) text = unwrapPasted(text);
   if (!text?.trim()) return null;
   const command = parseSlashCommand(text);
   if (command) return clip(command.args ? `${command.name} ${command.args}` : command.name);

package/src/utils/version.ts

@@ -2,4 +2,4 @@
  * Central version constant for claude-watch.
  * Keep in sync with package.json version.
  */
-export const VERSION = "0.30.13";
+export const VERSION = "0.30.15";

package/tests/fleet-places.test.ts

@@ -30,6 +30,26 @@ describe("projectRoots", () => {
     expect(projectRoots(["/p/app"], ["/p/app", ""])).toEqual(["/p/app", NO_FOLDER]);
     expect(projectRoots([], [null])).toEqual([NO_FOLDER]);
   });
+
+  it("keeps a session's repo its own project under a remembered folder that is no repo", () => {
+    // distilo: a session opened in ~/Projects made it the one remembered root.
+    const P = "/home/leo/Projects";
+    const roots = projectRoots(
+      [P],
+      [P, `${P}/quita`, `${P}/distilo/runner`],
+      [null, `${P}/quita`, `${P}/distilo`],
+      () => false
+    );
+    expect(roots).toEqual([P, `${P}/quita`, `${P}/distilo`]);
+    expect(rootOf(`${P}/distilo/runner`, roots)).toBe(`${P}/distilo`);
+    expect(rootOf(P, roots)).toBe(P);
+  });
+
+  it("leaves a worktree under the repo it belongs to", () => {
+    const app = "/home/leo/Projects/app";
+    const tree = `${app}/.claude/worktrees/agent-1`;
+    expect(projectRoots([app], [app, tree], [app, tree], (root) => root === app)).toEqual([app]);
+  });
 });
 
 describe("rootOf", () => {

package/tests/server/dictation-marks.test.ts

@@ -43,6 +43,22 @@ describe("dictation marks", () => {
     expect(isDictated("s1", "fix the login bug now", Date.now())).toBe(false);
   });
 
+  it("matches dictations Claude Code ran together as one prompt", () => {
+    // Two things said during a turn are queued by Claude Code and logged as
+    // one prompt, joined by a line break.
+    recordDictation("s1", "Também me responde aí, ele voltou pro topo?");
+    recordDictation("s1", "Outra limitação que eu acho é a do scroll.");
+    const joined = "Também me responde aí, ele voltou pro topo?\nOutra limitação que eu acho é a do scroll.";
+    expect(isDictated("s1", joined, Date.now())).toBe(true);
+  });
+
+  it("does not match a prompt only partly made of dictations", () => {
+    recordDictation("s1", "fix the login bug");
+    recordDictation("s1", "and the logout one");
+    expect(isDictated("s1", "fix the login bug\nplus something typed", Date.now())).toBe(false);
+    expect(isDictated("s1", "fix the login bugand the logout one", Date.now())).toBe(false);
+  });
+
   it("does not match outside the time window", () => {
     recordDictation("s1", "fix the login bug");
     expect(isDictated("s1", "fix the login bug", Date.now() + 16 * 60_000)).toBe(false);

package/tests/server/steer.test.ts

@@ -42,7 +42,7 @@ const CHORD = ['send-keys', '-t', TARGET, 'C-x', 'C-s'];
  * than run-all: the queue's drain loop is an interval and would never end.
  */
 async function settle<T>(promise: Promise<T>): Promise<T> {
-	await vi.advanceTimersByTimeAsync(2000);
+	await vi.advanceTimersByTimeAsync(6000);
 	return promise;
 }
 
@@ -104,6 +104,19 @@ describe('steer', () => {
 		expect(callIndex(['send-keys', '-t', TARGET, 'Enter'])).toBeGreaterThan(-1);
 	});
 
+	it('waits out a slow redraw rather than calling the text stuck', async () => {
+		// Pasted into an empty box; the box still shows the text for four reads, then clears.
+		boxReads = [null, 'look at this', 'look at this', 'look at this', 'look at this', null];
+		expect(await settle(steerIntoPane(TARGET, 'look at this', true))).toBe('taken');
+		// Taken before the retry was due: no second Enter.
+		expect(tmuxCalls.filter((c) => c.join(' ') === `send-keys -t ${TARGET} Enter`)).toHaveLength(1);
+	});
+
+	it('counts the line taken once the box holds something else', async () => {
+		boxReads = [null, 'a new draft'];
+		expect(await settle(steerIntoPane(TARGET, 'look at this', true))).toBe('taken');
+	});
+
 	it('leaves the pane alone when something else is typed in its box', async () => {
 		boxText = 'a draft of my own';
 		expect(await settle(steerIntoPane(TARGET, 'look at this', true, { mode: 'now' }))).toBe('occupied');

package/tests/transcript/parser.test.ts

@@ -79,6 +79,40 @@ describe("TranscriptBuilder", () => {
     ]);
   });
 
+  it("reads a long paste without Claude Code's pasted_content wrapper, and matches its dictation", () => {
+    // Logged as in a real session (Claude Code 2.1.30x): a blank line, the
+    // wrapper, the paste, the closing tag carrying the same id.
+    const said = "Enquanto eu penso no que você acabou de falar, uma ideia.\nSeis. Deixa quieto.";
+    const builder = new TranscriptBuilder(false, (text) => text === said);
+    builder.feed(
+      line({
+        type: "user",
+        uuid: "u1",
+        timestamp: TS,
+        message: { role: "user", content: `\n\n<pasted_content id="c2b8">\n${said}\n</pasted_content id="c2b8">\n` },
+        origin: { kind: "human" },
+      }),
+    );
+    expect(builder.entries).toEqual([{ kind: "user", id: "u1", ts: Date.parse(TS), text: said, dictated: true }]);
+  });
+
+  it("keeps the words typed ahead of a pasted block", () => {
+    const builder = new TranscriptBuilder();
+    builder.feed(
+      line({
+        type: "user",
+        uuid: "u1",
+        timestamp: TS,
+        message: {
+          role: "user",
+          content: [{ type: "text", text: 'look at this\n\n<pasted_content id="a1">\nline one\nline two\n</pasted_content id="a1">\n' }],
+        },
+        origin: { kind: "human" },
+      }),
+    );
+    expect(builder.entries[0]).toMatchObject({ kind: "user", text: "look at this\n\nline one\nline two" });
+  });
+
   it("unwraps a slash command into its name and arguments", () => {
     const builder = new TranscriptBuilder();
     builder.feed(

package/tests/transcript/past-sessions.test.ts

@@ -46,6 +46,11 @@ function write(dir: string, id: string, entries: unknown[], mtime?: Date): strin
 }
 
 describe("promptText", () => {
+  it("reads a long paste out of Claude Code's pasted_content wrapper", () => {
+    const logged = '\n\n<pasted_content id="c2b8">\nlong dictated text\n</pasted_content id="c2b8">\n';
+    expect(promptText(user(logged))).toBe("long dictated text");
+  });
+
   it("reads typed text, and a slash command as typed", () => {
     expect(promptText(user("fix the build"))).toBe("fix the build");
     expect(promptText(user([{ type: "text", text: "from a block" }]))).toBe("from a block");

package/web/.svelte-kit/adapter-bun/.vite/manifest.json

@@ -417,7 +417,8 @@
       "_paths.js",
       "_pid.js",
       "_pane.js",
-      "_attachments.js"
+      "_attachments.js",
+      "_tailer.js"
     ]
   },
   "_page-origin.js": {

package/web/.svelte-kit/adapter-bun/chunks/git.js

@@ -40,6 +40,12 @@ ${text}` : text);
   if (chunks.length === 0 && !LOCAL_OUTPUT_TAG.test(trimmed)) return null;
   return chunks.join("\n");
 }
+const PASTED_OPEN = /<pasted_content id="[^"]*">\n?/g;
+const PASTED_CLOSE = /\n?<\/pasted_content id="[^"]*">\n?/g;
+function unwrapPasted(text) {
+  if (!text.includes("<pasted_content id=")) return text;
+  return text.replace(PASTED_OPEN, "").replace(PASTED_CLOSE, "\n").trim();
+}
 function parseAskQuestions(input) {
   const raw = input.questions;
   if (!Array.isArray(raw)) return [];
@@ -305,7 +311,8 @@ class TranscriptBuilder {
     const attachment = asRecord(record.attachment);
     if (!attachment || attachment.type !== "queued_command") return [];
     if (asRecord(attachment.origin)?.kind !== "human") return [];
-    const prompt = readString(attachment.prompt);
+    const raw = readString(attachment.prompt);
+    const prompt = raw === null ? null : unwrapPasted(raw);
     if (!prompt || prompt.trim().length === 0) return [];
     const uuid = readString(record.uuid) ?? `queued-${this.entries.length}`;
     const ts = parseTimestamp(record.timestamp ?? attachment.timestamp);
@@ -378,7 +385,7 @@ class TranscriptBuilder {
     if (!message) return [];
     const uuid = readString(record.uuid) ?? `user-${this.entries.length}`;
     const ts = parseTimestamp(record.timestamp);
-    const content = message.content;
+    const content = typeof message.content === "string" ? unwrapPasted(message.content) : message.content;
     const origin = asRecord(record.origin);
     if (origin?.kind === "peer") {
       const body = readString(origin.body) ?? (typeof content === "string" ? content : null);
@@ -493,7 +500,8 @@ class TranscriptBuilder {
           })
         );
       } else if (rec.type === "text") {
-        const text = readString(rec.text);
+        const raw = readString(rec.text);
+        const text = raw === null ? null : unwrapPasted(raw);
         if (text && text.trim().length > 0) promptTexts.push(text);
       }
     }
@@ -1176,6 +1184,7 @@ export {
   parseUnifiedDiff as l,
   parseSlashCommand as p,
   repoRoot as r,
-  sessionWatcher as s
+  sessionWatcher as s,
+  unwrapPasted as u
 };
 //# sourceMappingURL=git.js.map