@dylanpiercey/work 0.0.145 → 0.0.146

package/dist/_CCA0c-I0.js

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

package/dist/{_RdvbSrnZ.js → _OZ9nLhXp.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
@@ -705,6 +705,96 @@ 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) {
@@ -6599,7 +6689,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("./_CCA0c-I0.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -8172,13 +8262,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 +8309,45 @@ 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 and the activity scraper all ask within the same tick,
+* and a field costs tmux nothing while a spawn costs ~10 ms on macOS. No
+* reuse window — a kill-session followed by a state read must see the
+* pane gone — only concurrent callers share the spawn. 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 listPanes = shared(listPanesNow, 0);
+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 +8385,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 +8639,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 { getSetting as $, setAgentPhase as A, pushPublicKey as B, blankRow as C, run$1 as Ct, agentLabel as D, agentFromCommand as E, iconSvg as F, subscriberJoins as G, publish as H, manifest as I, withLock as J, shared as K, normalizeAccent as L, setSessionViewers as M, ACCENT_RE as N, agentMeta as O, getInstance as P, enabledAgents as Q, setInstance as R, reportsWorking as S, git as St, agentFamily as T, config as Tt, subscribe as U, saveSubscription as V, subscriberCount as W, allPrefs as X, agentChoices as Y, disabledAgents as Z, sessionStates as _, db as _t, ensureTmuxServer as a, doctor as at, AGENTS as b, TMUX_SOCKET as bt, killWorkspaceSessions as c, miseVersions as ct, markTmuxStarted as d, DEFAULT_GITHUB_HOST as dt, preferredAgent as et, newSessionArgs as f, TOOLS as ft, sendToSession as g, all as gt, renameSession as h, toolById as ht, disposeSessions as i, discoverAgents as it, setScrapedPhase as j, clearAgentPhase as k, listPanes as l, setupPath as lt, panePids as m, agentLabel$1 as mt, clearTmuxStarted as n, setPref as nt, getSession as o, ghKnownHosts as ot, notifySessionsChanged as p, agentById as pt, swr as q, createSession as r, setSetting as rt, killSession as s, miseInstalls as st, cleanEnv as t, setDisabledAgents as tt, listSessions as u, which as ut, tmuxName as v, get as vt, agentBadge as w, tmux as wt, readHookPayload as x, gh as xt, tmuxWasStarted as y, workspacePath as yt, deleteSubscription as z };