@dylanpiercey/work 0.0.145 → 0.0.147

package/dist/_Bv4lCw13.js

@@ -0,0 +1,2 @@
+import { m as notifySessionsChanged } from "./_DGEhqy7E.js";
+export { notifySessionsChanged };

package/dist/{_RdvbSrnZ.js → _DGEhqy7E.js}

@@ -72,7 +72,7 @@ var tmux = (args, env) => run$1("tmux", [
 	"-L",
 	TMUX_SOCKET,
 	...args
-], void 0, utf8Locale(env ?? process.env));
+], os.homedir(), utf8Locale(env ?? process.env));
 /** launchd starts the service with no locale at all, and under a non-UTF-8
 * locale tmux replaces characters it deems unprintable in format output —
 * including the \t separators sessionStates and the scraper split on, which
@@ -426,6 +426,20 @@ function setupPath(base = process.env.PATH || "") {
 	const seen = /* @__PURE__ */ new Set();
 	return [...base.split(path.delimiter), ...extra].filter((p) => p && !seen.has(p) && seen.add(p)).join(path.delimiter);
 }
+/** setupPath() split once per PATH value: `which` runs for every tool on
+* every probe and rebuilt the list each time. */
+var dirsFor = {
+	base: void 0,
+	dirs: []
+};
+function setupDirs() {
+	const base = process.env.PATH || "";
+	if (dirsFor.base !== base) dirsFor = {
+		base,
+		dirs: setupPath(base).split(path.delimiter)
+	};
+	return dirsFor.dirs;
+}
 /** `~/…` for anything under the home directory — every path here is for
 * display (Settings rows, `work doctor`), never re-used to exec. */
 function tilde(p) {
@@ -434,7 +448,7 @@ function tilde(p) {
 }
 /** Absolute path of `bin` on setupPath(), or null. */
 function which(bin) {
-	for (const dir of setupPath().split(path.delimiter)) {
+	for (const dir of setupDirs()) {
 		const full = path.join(dir, bin);
 		try {
 			if (fs.statSync(full).isFile()) return full;
@@ -500,14 +514,29 @@ function ghKnownHosts() {
 	}
 	return [...text.matchAll(/^([A-Za-z0-9.-]+):\s*$/gm)].map((m) => m[1]);
 }
+/** Agent scan memo. Every app page render, skills scan and session
+* create asks; the answer only moves when something is installed, and
+* the doctor probe (which every install runs) refreshes it. */
+var AGENTS_MEMO_MS = 3e4;
+var agentsMemo = null;
 /**
 * Every agent CLI instance on PATH, per family: the plain binary and any
 * numeric-suffixed siblings (`claude1`, `cursor-agent2`). Sync — a PATH
 * scan is cheap and the boot handler needs it without awaiting. First hit
-* on PATH wins per name, like the shell.
+* on PATH wins per name, like the shell. `fresh` rescans regardless of
+* the memo.
 */
-function discoverAgents() {
-	const dirs = setupPath().split(path.delimiter);
+function discoverAgents(fresh = false) {
+	if (!fresh && agentsMemo && Date.now() - agentsMemo.at < AGENTS_MEMO_MS) return agentsMemo.value;
+	const value = scanAgents();
+	agentsMemo = {
+		at: Date.now(),
+		value
+	};
+	return value;
+}
+function scanAgents() {
+	const dirs = setupDirs();
 	const seenDirs = /* @__PURE__ */ new Set();
 	const seen = /* @__PURE__ */ new Map();
 	for (const dir of dirs) {
@@ -614,7 +643,7 @@ async function doctor(opts = {}) {
 			mise: t.mise
 		};
 	});
-	const agents = discoverAgents();
+	const agents = discoverAgents(true);
 	const missing = [];
 	for (const t of tools) if (t.required && !t.installed) missing.push(t.id);
 	if (!github.some((h) => h.authed)) missing.push("github-auth");
@@ -705,12 +734,108 @@ function preferredAgent(enabled = enabledAgents()) {
 	return enabled[0] || "shell";
 }
 //#endregion
+//#region src/server/cache.ts
+/** Keyed stale-while-revalidate cache: a cached value is served immediately
+* (revalidating in the background when older than `ttlMs`); loads are deduped
+* per key, and `refresh` bypasses both the cache and any in-flight load. */
+function swr(ttlMs, load, seed) {
+	const cache = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	function start(key, refresh) {
+		const startedAt = Date.now();
+		const promise = load(key, refresh).then((value) => {
+			const existing = cache.get(key);
+			if (!existing || existing.at <= startedAt) cache.set(key, {
+				at: Date.now(),
+				value
+			});
+			return value;
+		}).finally(() => {
+			if (inflight.get(key)?.promise === promise) inflight.delete(key);
+		});
+		inflight.set(key, {
+			promise,
+			refresh
+		});
+		return promise;
+	}
+	const read = (key, refresh = false) => {
+		if (refresh) {
+			const current = inflight.get(key);
+			return current?.refresh ? current.promise : start(key, true);
+		}
+		let cached = cache.get(key);
+		if (!cached && seed) {
+			cached = seed(key);
+			if (cached) cache.set(key, cached);
+		}
+		if (cached) {
+			if (Date.now() - cached.at >= ttlMs && !inflight.has(key)) start(key, false).catch(() => {});
+			return Promise.resolve(cached.value);
+		}
+		return inflight.get(key)?.promise ?? start(key, false);
+	};
+	/** Inject an externally fetched value (e.g. from a batched load). */
+	read.set = (key, value) => {
+		cache.set(key, {
+			at: Date.now(),
+			value
+		});
+	};
+	/** Current cached value, if any — used when a batch update must merge
+	* with a richer per-key load rather than replace it. */
+	read.get = (key) => cache.get(key)?.value;
+	return read;
+}
+/** Serialize async work per key: calls for one key run in submission order,
+* each starting only after the previous settled. The stored tail is the
+* all-settled form, so a rejection neither blocks the next caller nor leaves
+* the entry behind — the map holds only keys with work still in flight. */
+var locks = /* @__PURE__ */ new Map();
+function withLock(key, fn) {
+	const run = (locks.get(key) ?? Promise.resolve()).then(fn);
+	const tail = run.then(() => {}, () => {});
+	locks.set(key, tail);
+	tail.then(() => {
+		if (locks.get(key) === tail) locks.delete(key);
+	});
+	return run;
+}
+/** One load at a time, and a short reuse window: callers join the in-flight
+* load, and a result younger than `ttlMs` is served without one. For an
+* expensive process sweep (lsof, ps, list-panes) whose answer does not
+* change within the window — `ttlMs` of 0 still collapses concurrent
+* callers onto a single spawn. */
+function shared(fn, ttlMs) {
+	let inflight = null;
+	let last = null;
+	return () => {
+		if (last && Date.now() - last.at < ttlMs) return Promise.resolve(last.value);
+		if (!inflight) inflight = fn().then((value) => {
+			last = {
+				at: Date.now(),
+				value
+			};
+			return value;
+		}).finally(() => {
+			inflight = null;
+		});
+		return inflight;
+	};
+}
+//#endregion
 //#region src/server/events.ts
 var listeners = /* @__PURE__ */ new Set();
 function publish(type, data) {
+	publishJson(type, data === void 0 ? void 0 : JSON.stringify(data), data);
+}
+/** Publish with the payload already serialized (a producer that had to
+* stringify it anyway, e.g. for change detection, hands the string in). */
+function publishJson(type, dataJson, data) {
 	const event = {
 		type,
-		data
+		data,
+		frame: dataJson === void 0 ? JSON.stringify({ type }) : `{"type":${JSON.stringify(type)},"data":${dataJson}}`
 	};
 	for (const listener of [...listeners]) try {
 		listener(event);
@@ -6599,7 +6724,7 @@ function publishChange(sessionId) {
 	const row = get("SELECT workspace_id FROM sessions WHERE id = ?", sessionId);
 	if (row?.workspace_id) {
 		const workspaceId = row.workspace_id;
-		import("./_BF-bl9wz.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_Bv4lCw13.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -8126,6 +8251,7 @@ async function disposeSession(id) {
 		"-t",
 		tmuxName(id)
 	]).catch(() => {});
+	forgetPanes();
 	clearTmuxStarted(id);
 	clearAgentPhase(id);
 	db.prepare("DELETE FROM sessions WHERE id = ?").run(id);
@@ -8144,9 +8270,18 @@ function tmuxWasStarted(id) {
 function clearTmuxStarted(id) {
 	tmuxStarted.delete(id);
 }
-/** SSE payload: session rows + live tmux/hook state so clients don't refetch. */
+/** SSE payload: session rows + live tmux/hook state so clients don't refetch.
+* Coalesced per workspace: a turn boundary lands as a burst of phase
+* transitions (hook, then scrape), and each one cost a list-panes spawn
+* and a broadcast for a list that came out the same. */
+var EMIT_DEBOUNCE_MS = 50;
+var pendingEmits = /* @__PURE__ */ new Map();
 function notifySessionsChanged(workspaceId) {
-	emitSessionsChanged(workspaceId);
+	clearTimeout(pendingEmits.get(workspaceId));
+	pendingEmits.set(workspaceId, setTimeout(() => {
+		pendingEmits.delete(workspaceId);
+		emitSessionsChanged(workspaceId);
+	}, EMIT_DEBOUNCE_MS));
 }
 async function emitSessionsChanged(workspaceId) {
 	try {
@@ -8172,13 +8307,13 @@ async function sendToSession(id, text, size) {
 	const wsPath = workspacePath(session.workspace_id);
 	if (!wsPath) throw new Error("unknown workspace");
 	const name = tmuxName(id);
-	await ensureTmuxServer();
 	const env = cleanEnv();
 	if (!await tmux([
 		"has-session",
 		"-t",
 		name
 	], env).then(() => true, () => false)) {
+		await ensureTmuxServer();
 		if (promptAsArgv(session.agent)) {
 			await tmux(newSessionArgs(session, wsPath, "-d", text, size), env);
 			markTmuxStarted(id);
@@ -8219,33 +8354,52 @@ async function sendToSession(id, text, size) {
 * started, so a shell someone ran `claude` inside still reads as "shell". */
 async function sessionStates() {
 	const result = {};
-	const out = await tmux([
-		"list-panes",
-		"-a",
-		"-F",
-		"#{session_name}	#{pane_current_command}"
-	]).catch(() => "");
-	for (const line of out.split("\n")) {
-		const [name, command] = line.split("	");
-		if (!name?.startsWith("wk-")) continue;
-		const id = name.slice(3);
-		result[id] = {
-			alive: true,
-			phase: agentPhase(id),
-			command: command || ""
-		};
-	}
+	for (const { id, command } of await listPanes() || []) if (id) result[id] = {
+		alive: true,
+		phase: agentPhase(id),
+		command
+	};
 	return result;
 }
 /** Root pids of every tmux pane (the agent/shell each session runs). */
 async function panePids() {
+	return new Set((await listPanes() || []).map((p) => p.pid));
+}
+/** Every tmux pane, one `list-panes` for everyone who wants one: session
+* state, pane pids, the activity scraper and every phase transition ask
+* within a short span, and a field costs tmux nothing while a spawn costs
+* ~10 ms on macOS. The reuse window sits well under the scraper's 2 s
+* cadence; the one reader that must not see a stale answer — a
+* kill-session followed by a state read — drops the window with
+* `forgetPanes`. Null when tmux did not answer (server down, transient
+* failure): callers that clear state on "no panes" must not clear it on
+* "no answer". */
+var PANES_REUSE_MS = 400;
+var panesShared = shared(listPanesNow, PANES_REUSE_MS);
+var listPanes = () => panesShared();
+function forgetPanes() {
+	panesShared = shared(listPanesNow, PANES_REUSE_MS);
+}
+async function listPanesNow() {
 	const out = await tmux([
 		"list-panes",
 		"-a",
 		"-F",
-		"#{pane_pid}"
-	]).catch(() => "");
-	return new Set(out.split("\n").filter(Boolean).map(Number));
+		"#{session_name}	#{pane_current_command}	#{pane_pid}	#{window_activity}"
+	]).catch(() => null);
+	if (out === null) return null;
+	const panes = [];
+	for (const line of out.split("\n")) {
+		if (!line) continue;
+		const [name, command, pid, stamp] = line.split("	");
+		panes.push({
+			id: name?.startsWith("wk-") ? name.slice(3) : void 0,
+			command: command || "",
+			pid: Number(pid),
+			activityAt: Number(stamp) * 1e3
+		});
+	}
+	return panes;
 }
 /** Cleared once per process — boot already runs this, and a server we
 * create below never has PORT set, so re-running on every attach only
@@ -8283,7 +8437,7 @@ async function ensureTmuxServer() {
 		"work-keeper",
 		"sleep",
 		"infinity"
-	]).catch(() => {});
+	], os.homedir()).catch(() => {});
 }
 /** Full tmux command (options + new-session) for creating/attaching a
 * session's tmux; `mode` is "-d" (create detached) or "-A" (attach-or-create). */
@@ -8537,4 +8691,4 @@ function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
 //#endregion
-export { setSetting as $, setScrapedPhase as A, saveSubscription as B, agentBadge as C, agentMeta as D, agentLabel as E, manifest as F, agentChoices as G, subscribe as H, normalizeAccent as I, enabledAgents as J, allPrefs as K, setInstance as L, ACCENT_RE as M, getInstance as N, clearAgentPhase as O, iconSvg as P, setPref as Q, deleteSubscription as R, blankRow as S, agentFromCommand as T, subscriberCount as U, publish as V, subscriberJoins as W, preferredAgent as X, getSetting as Y, setDisabledAgents as Z, tmuxName as _, gh as _t, ensureTmuxServer as a, setupPath as at, readHookPayload as b, tmux as bt, killWorkspaceSessions as c, TOOLS as ct, newSessionArgs as d, toolById as dt, discoverAgents as et, notifySessionsChanged as f, all as ft, sessionStates as g, TMUX_SOCKET as gt, sendToSession as h, workspacePath as ht, disposeSessions as i, miseVersions as it, setSessionViewers as j, setAgentPhase as k, listSessions as l, agentById as lt, renameSession as m, get as mt, clearTmuxStarted as n, ghKnownHosts as nt, getSession as o, which as ot, panePids as p, db as pt, disabledAgents as q, createSession as r, miseInstalls as rt, killSession as s, DEFAULT_GITHUB_HOST as st, cleanEnv as t, doctor as tt, markTmuxStarted as u, agentLabel$1 as ut, tmuxWasStarted as v, git as vt, agentFamily as w, reportsWorking as x, config as xt, AGENTS as y, run$1 as yt, pushPublicKey as z };
+export { disabledAgents as $, clearAgentPhase as A, deleteSubscription as B, reportsWorking as C, gh as Ct, agentFromCommand as D, config as Dt, agentFamily as E, tmux as Et, getInstance as F, subscribe as G, saveSubscription as H, iconSvg as I, shared as J, subscriberCount as K, manifest as L, setScrapedPhase as M, setSessionViewers as N, agentLabel as O, ACCENT_RE as P, allPrefs as Q, normalizeAccent as R, readHookPayload as S, TMUX_SOCKET as St, agentBadge as T, run$1 as Tt, publish as U, pushPublicKey as V, publishJson as W, withLock as X, swr as Y, agentChoices as Z, sendToSession as _, toolById as _t, ensureTmuxServer as a, setSetting as at, tmuxWasStarted as b, get as bt, killSession as c, ghKnownHosts as ct, listSessions as d, setupPath as dt, enabledAgents as et, markTmuxStarted as f, which as ft, renameSession as g, agentLabel$1 as gt, panePids as h, agentById as ht, disposeSessions as i, setPref as it, setAgentPhase as j, agentMeta as k, killWorkspaceSessions as l, miseInstalls as lt, notifySessionsChanged as m, TOOLS as mt, clearTmuxStarted as n, preferredAgent as nt, forgetPanes as o, discoverAgents as ot, newSessionArgs as p, DEFAULT_GITHUB_HOST as pt, subscriberJoins as q, createSession as r, setDisabledAgents as rt, getSession as s, doctor as st, cleanEnv as t, getSetting as tt, listPanes as u, miseVersions as ut, sessionStates as v, all as vt, blankRow as w, git as wt, AGENTS as x, workspacePath as xt, tmuxName as y, db as yt, setInstance as z };