@norman-else/dsh-claude 0.1.20 → 0.1.22

package/lib/index.mjs

@@ -15,6 +15,9 @@ import { fileURLToPath } from "node:url";
 //#region src/sidecar.ts
 const SIDECAR_SCHEMA_VERSION = 1;
 const MAX_ACTIVITIES = 1e4;
+/** Trailing window that coalesces per-token transcript persistence into one
+*  atomic disk write; live subscribers are notified synchronously regardless. */
+const TEXT_FLUSH_MS = 150;
 function emptyProjection() {
 	return {
 		schemaVersion: SIDECAR_SCHEMA_VERSION,
@@ -117,13 +120,126 @@ var ClaudeSidecarRepository = class {
 	root;
 	legacyRoot;
 	#pending = /* @__PURE__ */ new Map();
+	/** Latest durable projection per session; disk is read once and written through. */
+	#latest = /* @__PURE__ */ new Map();
+	#listeners = /* @__PURE__ */ new Map();
+	/** Streaming transcript segments not yet persisted, keyed by activity key. */
+	#live = /* @__PURE__ */ new Map();
+	/** Monotonic revision boost so merged reads advance while text stays in memory. */
+	#boost = /* @__PURE__ */ new Map();
+	#flushTimers = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this.root = options.root ?? dshHomePath("plugins", "dsh-claude", "sessions");
 		this.legacyRoot = options.legacyRoot ?? (options.root === void 0 ? dshHomePath("plugins", "dsh-claude-code", "sessions") : void 0);
 	}
 	async read(sessionId) {
 		await this.#pending.get(sessionId)?.catch(() => void 0);
-		return this.#readNow(sessionId);
+		return this.#merged(sessionId, await this.#base(sessionId));
+	}
+	/** Observe accepted changes for one session; returns the unsubscriber. */
+	subscribe(sessionId, listener) {
+		let set = this.#listeners.get(sessionId);
+		if (set === void 0) {
+			set = /* @__PURE__ */ new Set();
+			this.#listeners.set(sessionId, set);
+		}
+		set.add(listener);
+		return () => {
+			set.delete(listener);
+			if (set.size === 0) this.#listeners.delete(sessionId);
+		};
+	}
+	/** Record streaming assistant prose without touching the disk on the hot
+	*  path: subscribers are notified synchronously (as an append when the
+	*  redacted text grows in place) and persistence is coalesced. */
+	appendTranscriptText(sessionId, value) {
+		const normalized = normalizeActivity({
+			kind: "text",
+			phase: "updated",
+			...value
+		});
+		const key = activityKey(normalized);
+		let overlay = this.#live.get(sessionId);
+		if (overlay === void 0) {
+			overlay = /* @__PURE__ */ new Map();
+			this.#live.set(sessionId, overlay);
+		}
+		const previous = overlay.get(key);
+		overlay.set(key, normalized);
+		this.#boost.set(sessionId, (this.#boost.get(sessionId) ?? 0) + 1);
+		const text = normalized.text ?? "";
+		const base = {
+			turn: normalized.turn,
+			step: normalized.step,
+			ordinal: normalized.ordinal
+		};
+		this.#notify(sessionId, previous?.text !== void 0 && text.startsWith(previous.text) ? {
+			kind: "text",
+			...base,
+			append: text.slice(previous.text.length)
+		} : {
+			kind: "text",
+			...base,
+			text
+		});
+		this.#scheduleTextFlush(sessionId);
+	}
+	/** Persist any pending streaming transcript now (segment close, turn end). */
+	flushTranscriptText(sessionId) {
+		const timer = this.#flushTimers.get(sessionId);
+		if (timer !== void 0) {
+			clearTimeout(timer);
+			this.#flushTimers.delete(sessionId);
+		}
+		return this.#flushLive(sessionId);
+	}
+	#notify(sessionId, delta) {
+		const set = this.#listeners.get(sessionId);
+		if (set === void 0) return;
+		for (const listener of [...set]) try {
+			listener(delta);
+		} catch {}
+	}
+	#merged(sessionId, base) {
+		const overlay = this.#live.get(sessionId);
+		const boost = this.#boost.get(sessionId) ?? 0;
+		if ((overlay === void 0 || overlay.size === 0) && boost === 0) return base;
+		return {
+			...base,
+			revision: base.revision + boost,
+			...overlay === void 0 || overlay.size === 0 ? {} : { activities: mergeActivities(base.activities, [...overlay.values()]) }
+		};
+	}
+	async #base(sessionId) {
+		const cached = this.#latest.get(sessionId);
+		if (cached !== void 0) return cached;
+		const loaded = await this.#readNow(sessionId);
+		this.#latest.set(sessionId, loaded);
+		return loaded;
+	}
+	#scheduleTextFlush(sessionId) {
+		if (this.#flushTimers.has(sessionId)) return;
+		const timer = setTimeout(() => {
+			this.#flushTimers.delete(sessionId);
+			this.#flushLive(sessionId);
+		}, TEXT_FLUSH_MS);
+		timer.unref?.();
+		this.#flushTimers.set(sessionId, timer);
+	}
+	async #flushLive(sessionId) {
+		const overlay = this.#live.get(sessionId);
+		if (overlay === void 0 || overlay.size === 0) return;
+		const entries = [...overlay.entries()];
+		try {
+			await this.#update(sessionId, (current) => ({
+				...current,
+				activities: mergeActivities(current.activities, entries.map(([, value]) => value))
+			}));
+		} catch {
+			return;
+		}
+		for (const [key, value] of entries) if (overlay.get(key) === value) overlay.delete(key);
+		if (overlay.size === 0) this.#live.delete(sessionId);
 	}
 	writeBinding(sessionId, value) {
 		const normalized = normalizeBinding(value);
@@ -137,21 +253,30 @@ var ClaudeSidecarRepository = class {
 		return this.#update(sessionId, (current) => ({
 			...current,
 			activities: mergeActivities(current.activities, [normalized])
-		}));
+		}), false, {
+			kind: "activity",
+			activity: normalized
+		});
 	}
 	writeContextUsage(sessionId, value) {
 		const normalized = normalizeContextUsage(value);
 		return this.#update(sessionId, (current) => ({
 			...current,
 			contextUsage: normalized
-		}));
+		}), false, {
+			kind: "contextUsage",
+			value: normalized
+		});
 	}
 	writeTasks(sessionId, value) {
 		const normalized = normalizeTasksEvent(value);
 		return this.#update(sessionId, (current) => ({
 			...current,
 			tasks: normalized
-		}));
+		}), false, {
+			kind: "tasks",
+			value: normalized
+		});
 	}
 	importLegacy(sessionId, events) {
 		const importedActivities = events.filter((event) => event.type === CLAUDE_ACTIVITY_EVENT).map((event) => activity(event.data)).filter((item) => item !== void 0);
@@ -164,15 +289,15 @@ var ClaudeSidecarRepository = class {
 			...current.binding !== void 0 || importedBinding === void 0 ? {} : { binding: normalizeBinding(importedBinding) },
 			...current.contextUsage !== void 0 || importedUsage === void 0 ? {} : { contextUsage: normalizeContextUsage(importedUsage) },
 			...current.tasks !== void 0 || importedTasks === void 0 ? {} : { tasks: normalizeTasksEvent(importedTasks.tasks) }
-		}), true);
+		}), true, { kind: "sync" });
 	}
 	#path(sessionId, root = this.root) {
 		if (sessionId.length === 0 || sessionId.length > 1024) throw new Error("dsh-claude: invalid session id");
 		return join(root, `${Buffer.from(sessionId).toString("base64url")}.json`);
 	}
-	#update(sessionId, change, skipUnchanged = false) {
+	#update(sessionId, change, skipUnchanged = false, delta) {
 		const operation = (this.#pending.get(sessionId) ?? Promise.resolve()).catch(() => void 0).then(async () => {
-			const current = await this.#readNow(sessionId);
+			const current = await this.#base(sessionId);
 			const changed = parseClaudeSidecar({
 				...change(current),
 				schemaVersion: SIDECAR_SCHEMA_VERSION,
@@ -184,6 +309,8 @@ var ClaudeSidecarRepository = class {
 				revision: current.revision + 1
 			};
 			await this.#writeNow(sessionId, next);
+			this.#latest.set(sessionId, next);
+			if (delta !== void 0) this.#notify(sessionId, delta);
 			return next;
 		});
 		this.#pending.set(sessionId, operation);
@@ -594,7 +721,9 @@ function normalizeAssistant(message) {
 	return normalized;
 }
 function normalizeUser(message) {
+	if (message.isReplay === true) return [];
 	const content = record$4(message.message)?.content;
+	if (typeof content === "string") return [];
 	if (!Array.isArray(content)) return [{
 		kind: "protocol-error",
 		title: "Malformed Claude user message",
@@ -1647,6 +1776,7 @@ var ClaudeSupervisor = class {
 		if (entry.active !== active) return;
 		if (active.aborted) {
 			await this.#upsertTranscriptText(active);
+			await this.#flushTranscript(active);
 			await this.#appendSafely(active, {
 				kind: "status",
 				phase: "failed",
@@ -1689,6 +1819,7 @@ var ClaudeSupervisor = class {
 				});
 			}
 			await this.#upsertTranscriptText(active);
+			await this.#flushTranscript(active);
 			const message = result.errors?.join("\n") ?? (result.terminalReason !== void 0 ? `Claude Code failed the turn (${result.terminalReason})` : "Claude Code failed the turn");
 			await this.#appendSafely(active, {
 				kind: "error",
@@ -1724,6 +1855,7 @@ var ClaudeSupervisor = class {
 				phase: "completed",
 				title: "Claude Code turn completed"
 			});
+			await this.#flushTranscript(active);
 			active.output.push({
 				type: "complete",
 				text: active.text
@@ -1741,9 +1873,7 @@ var ClaudeSupervisor = class {
 		const ordinal = active.transcriptTextOrdinal ?? active.cursor.nextOrdinal++;
 		active.transcriptTextOrdinal = ordinal;
 		try {
-			await this.#sidecar.appendActivity(active.agent.id, {
-				kind: "text",
-				phase: "updated",
+			this.#sidecar.appendTranscriptText(active.agent.id, {
 				text: active.transcriptText,
 				turn: active.cursor.turn,
 				step: active.cursor.step,
@@ -1751,7 +1881,11 @@ var ClaudeSupervisor = class {
 			});
 		} catch {}
 	}
+	async #flushTranscript(active) {
+		await this.#sidecar.flushTranscriptText(active.agent.id).catch(() => void 0);
+	}
 	#closeTranscriptTextSegment(active) {
+		this.#flushTranscript(active);
 		active.transcriptText = "";
 		active.transcriptTextOrdinal = void 0;
 	}
@@ -1807,6 +1941,7 @@ var ClaudeSupervisor = class {
 		const stderr = entry.process?.stderrTail();
 		if (active !== void 0) {
 			await this.#upsertTranscriptText(active);
+			await this.#flushTranscript(active);
 			if (active.signal !== void 0 && active.abortListener !== void 0) active.signal.removeEventListener("abort", active.abortListener);
 			const unknown = active.sawActivity;
 			entry.state = unknown ? "outcome-unknown" : "disconnected";
@@ -2376,47 +2511,173 @@ function registerClaudeDoctorRoutes(ctx, runtime, supervisor, config, resolution
 //#endregion
 //#region src/projection-routes.ts
 const MAX_SESSION_ID_CHARS$2 = 1024;
-function sessionIdFromUrl$1(rawUrl) {
+/** Slow-moving metadata refresh and stream heartbeat cadence; deliberately off
+*  the transcript hot path so git/gh latency never delays visible text. */
+const META_REFRESH_MS = 5e3;
+function targetFromUrl(rawUrl) {
 	try {
 		const pathname = new URL(rawUrl ?? "/", "http://localhost").pathname;
 		const prefix = `${CLAUDE_PROJECTION_PATH}/`;
 		if (!pathname.startsWith(prefix)) return void 0;
-		const encoded = pathname.slice(prefix.length);
+		let encoded = pathname.slice(prefix.length);
+		const stream = encoded.endsWith("/stream");
+		if (stream) encoded = encoded.slice(0, -7);
 		if (encoded.length === 0 || encoded.includes("/")) return void 0;
 		const sessionId = decodeURIComponent(encoded);
 		if (sessionId.length === 0 || sessionId.length > MAX_SESSION_ID_CHARS$2) return void 0;
-		return sessionId;
+		return {
+			sessionId,
+			stream
+		};
 	} catch {
 		return;
 	}
 }
-/** Register the browser-readable, credential-free sidecar projection endpoint. */
+function envelope(projection, meta) {
+	return {
+		schemaVersion: projection.schemaVersion,
+		revision: projection.revision,
+		owned: meta.owned,
+		commands: meta.commands,
+		activities: projection.activities,
+		...projection.contextUsage === void 0 ? {} : { contextUsage: projection.contextUsage },
+		...projection.tasks === void 0 ? {} : { tasks: projection.tasks },
+		...meta.repository === void 0 ? {} : { repository: meta.repository },
+		reviewComments: meta.reviewComments
+	};
+}
+/** Register the browser-readable, credential-free sidecar projection endpoint.
+*  `GET <path>/:sessionId` returns one snapshot; `GET <path>/:sessionId/stream`
+*  returns an NDJSON stream: a full snapshot line followed by incremental
+*  transcript/activity deltas and periodic metadata/heartbeat lines. */
 function registerClaudeProjectionRoute(ctx, sidecar, ownsSession, commandsForSession = () => [], repositoryForSession = async () => void 0, reviewCommentsForSession = () => []) {
+	const info = (message) => {
+		ctx.logger?.info?.(message);
+	};
+	const assembleMeta = async (sessionId) => {
+		const owned = ownsSession(sessionId);
+		const repository = owned ? await repositoryForSession(sessionId) : void 0;
+		return {
+			owned,
+			commands: commandsForSession(sessionId),
+			...repository === void 0 ? {} : { repository },
+			reviewComments: owned ? reviewCommentsForSession(sessionId) : []
+		};
+	};
+	const streamProjection = async (res, sessionId) => {
+		info(`dsh-claude: projection stream opened for ${sessionId.slice(0, 64)}`);
+		let textDeltas = 0;
+		let textBytes = 0;
+		let textSince = Date.now();
+		let meta = await assembleMeta(sessionId);
+		res.writeHead(200, {
+			"content-type": "application/x-ndjson; charset=utf-8",
+			"cache-control": "no-store",
+			"x-content-type-options": "nosniff"
+		});
+		res.flushHeaders?.();
+		let closed = false;
+		const writeLine = (value) => {
+			if (closed) return;
+			try {
+				res.write(`${JSON.stringify(value)}\n`);
+			} catch {
+				closed = true;
+			}
+		};
+		const writeSnapshot = async () => {
+			const projection = await sidecar.read(sessionId);
+			writeLine({
+				type: "snapshot",
+				...envelope(projection, meta)
+			});
+		};
+		await writeSnapshot();
+		const unsubscribe = sidecar.subscribe(sessionId, (delta) => {
+			switch (delta.kind) {
+				case "text":
+					textDeltas += 1;
+					textBytes += (delta.append ?? delta.text ?? "").length;
+					if (textDeltas % 25 === 0) {
+						const elapsed = Date.now() - textSince;
+						info(`dsh-claude: stream ${sessionId.slice(0, 24)} 25 text deltas ${textBytes}B in ${elapsed}ms`);
+						textBytes = 0;
+						textSince = Date.now();
+					}
+					writeLine({
+						type: "text",
+						turn: delta.turn,
+						step: delta.step,
+						ordinal: delta.ordinal,
+						...delta.append === void 0 ? {} : { append: delta.append },
+						...delta.text === void 0 ? {} : { text: delta.text }
+					});
+					return;
+				case "activity":
+					writeLine({
+						type: "activity",
+						activity: delta.activity
+					});
+					return;
+				case "contextUsage":
+					writeLine({
+						type: "contextUsage",
+						value: delta.value
+					});
+					return;
+				case "tasks":
+					writeLine({
+						type: "tasks",
+						value: delta.value
+					});
+					return;
+				case "sync": writeSnapshot().catch(() => void 0);
+			}
+		});
+		const timer = setInterval(() => {
+			(async () => {
+				const next = await assembleMeta(sessionId);
+				if (closed) return;
+				if (JSON.stringify(next) === JSON.stringify(meta)) {
+					writeLine({ type: "ping" });
+					return;
+				}
+				meta = next;
+				writeLine({
+					type: "meta",
+					owned: meta.owned,
+					commands: meta.commands,
+					...meta.repository === void 0 ? {} : { repository: meta.repository },
+					reviewComments: meta.reviewComments
+				});
+			})().catch(() => void 0);
+		}, META_REFRESH_MS);
+		timer.unref?.();
+		await new Promise((resolve) => {
+			res.on("close", () => {
+				closed = true;
+				clearInterval(timer);
+				unsubscribe();
+				info(`dsh-claude: projection stream closed for ${sessionId.slice(0, 64)} after ${textDeltas} text deltas`);
+				resolve();
+			});
+		});
+	};
 	ctx.effect(() => ctx.webServer.register({
 		kind: "prefix",
 		path: CLAUDE_PROJECTION_PATH,
 		handler: async (req, res) => {
 			if (req.method !== "GET") return json(res, 405, { error: "method not allowed" });
 			if (!trustedRequest(req)) return json(res, 403, { error: "forbidden" });
-			const sessionId = sessionIdFromUrl$1(req.url);
-			if (sessionId === void 0) return json(res, 400, { error: "invalid session id" });
+			const target = targetFromUrl(req.url);
+			if (target === void 0) return json(res, 400, { error: "invalid session id" });
 			try {
-				const projection = await sidecar.read(sessionId);
-				const owned = ownsSession(sessionId);
-				const repository = owned ? await repositoryForSession(sessionId) : void 0;
-				return json(res, 200, {
-					schemaVersion: projection.schemaVersion,
-					revision: projection.revision,
-					owned,
-					commands: commandsForSession(sessionId),
-					activities: projection.activities,
-					...projection.contextUsage === void 0 ? {} : { contextUsage: projection.contextUsage },
-					...projection.tasks === void 0 ? {} : { tasks: projection.tasks },
-					...repository === void 0 ? {} : { repository },
-					reviewComments: owned ? reviewCommentsForSession(sessionId) : []
-				});
+				if (target.stream) return await streamProjection(res, target.sessionId);
+				info(`dsh-claude: projection poll for ${target.sessionId.slice(0, 64)}`);
+				return json(res, 200, envelope(await sidecar.read(target.sessionId), await assembleMeta(target.sessionId)));
 			} catch {
-				return json(res, 500, { error: "projection unavailable" });
+				if (!res.headersSent) return json(res, 500, { error: "projection unavailable" });
+				res.end();
 			}
 		}
 	}), "dsh-claude: sidecar projection route");
@@ -3318,6 +3579,30 @@ var RepositoryActionService = class {
 				pushed: true
 			};
 		}
+		if (request.action === "merge-pr") {
+			const method = request.mergeMethod;
+			if (method !== "merge" && method !== "squash" && method !== "rebase") throw new RepositoryActionError("invalid-request", "The merge method is invalid.");
+			let gh;
+			try {
+				gh = await this.#gh();
+			} catch (error) {
+				throw new RepositoryActionError("gh-unavailable", error instanceof Error ? error.message : "GitHub CLI is unavailable.");
+			}
+			const merged = await this.#run(gh, [
+				"pr",
+				"merge",
+				`--${method}`
+			], before.root, REMOTE_TIMEOUT_MS);
+			if (merged.exitCode !== 0 || merged.lossy) {
+				const reason = merged.stderr.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0).at(-1);
+				throw new RepositoryActionError("merge-failed", reason === void 0 || reason.length === 0 ? "The pull request could not be merged." : reason);
+			}
+			this.#invalidate(before.root);
+			return {
+				commit: before.head,
+				pushed: true
+			};
+		}
 		const message = safeText(request.message, MAX_MESSAGE_CHARS, "Commit message");
 		if (before.files.length === 0 && request.action !== "create-pr") throw new RepositoryActionError("nothing-to-commit", "There are no changes to commit.");
 		const git = await this.#git();
@@ -3655,7 +3940,8 @@ const ACTIONS = /* @__PURE__ */ new Set([
 	"commit",
 	"commit-push",
 	"push",
-	"create-pr"
+	"create-pr",
+	"merge-pr"
 ]);
 function record$1(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -3695,13 +3981,16 @@ function actionRequest(input) {
 	return {
 		action,
 		fingerprint: string(input, "fingerprint"),
-		message: action === "push" ? optionalString(input, "message") ?? "" : string(input, "message"),
+		message: action === "push" || action === "merge-pr" ? optionalString(input, "message") ?? "" : string(input, "message"),
 		includeUnstaged: input.includeUnstaged,
 		...optionalString(input, "prTitle") === void 0 ? {} : { prTitle: optionalString(input, "prTitle") },
 		...optionalString(input, "prBody") === void 0 ? {} : { prBody: optionalString(input, "prBody") },
 		...optionalString(input, "baseBranch") === void 0 ? {} : { baseBranch: optionalString(input, "baseBranch") },
 		...input.draft === void 0 ? {} : typeof input.draft === "boolean" ? { draft: input.draft } : (() => {
 			throw new RepositoryActionError("invalid-request", "The draft field must be a boolean.");
+		})(),
+		...input.mergeMethod === void 0 ? {} : input.mergeMethod === "merge" || input.mergeMethod === "squash" || input.mergeMethod === "rebase" ? { mergeMethod: input.mergeMethod } : (() => {
+			throw new RepositoryActionError("invalid-request", "The mergeMethod field is invalid.");
 		})()
 	};
 }