@dylanpiercey/work 0.2.68 → 0.2.70

package/dist/{_KNWFiRfu.js → _DK0sGNuL.js}

@@ -2,11 +2,11 @@ import { i as __require, o as __toESM, t as __commonJSMin } from "./_BMI-E3GI.js
 import { r as require_inherits, t as require_src$1 } from "./_xlrdOUsL.js";
 import { t as require_safe_buffer } from "./_BmSjjJ2E.js";
 import { createRequire } from "node:module";
+import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { execFile, execFileSync, spawn, spawnSync } from "node:child_process";
 import fs$1 from "node:fs/promises";
 import os from "node:os";
 import { promisify } from "node:util";
@@ -184,6 +184,14 @@ try {
 * detaches every client on its socket, which on the live one cut every
 * open terminal. */
 var TMUX_SOCKET = process.env.WORK_TMUX_SOCKET || "work";
+/** Any socket but the machine's `work` is a scratch server's (smoke, a
+* repro), and its tmux server is that server's alone: it is stopped as the
+* server stops (entry.ts) and its systemd unit ends within a day however
+* the server went (`ensureTmuxServer`), where the live one outlives every
+* restart. Left to themselves, scratch runs kept a tmux server and its unit
+* each for weeks. `WORK_TMUX_KEEP=1` keeps one, for a test of what a
+* restart keeps. */
+var SCRATCH_TMUX = TMUX_SOCKET !== "work" && process.env.WORK_TMUX_KEEP !== "1";
 var execFileAsync = promisify(execFile);
 async function run$2(cmd, args, cwd, env, opts = {}) {
 	const child = execFileAsync(cmd, args, {
@@ -9659,7 +9667,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("./_xm4j4quQ.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_wbrwjNyW.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -12577,11 +12585,11 @@ async function pruneWorkspaceSnaps(ws) {
 	const live = new Set([...reviewPoints(ws.id).values()].map((p) => p.snap));
 	for (const repo of ws.repos) await pruneSnaps(path.join(ws.path, repo.worktree), ws.id, live).catch(() => {});
 }
-var started = false;
+var started$1 = false;
 /** A minute after boot and hourly after, every active workspace's sweep. */
 function startSnapSweep() {
-	if (started) return;
-	started = true;
+	if (started$1) return;
+	started$1 = true;
 	const sweep = () => {
 		for (const { id } of all("SELECT id FROM workspaces WHERE status = 'active'")) {
 			const ws = getWorkspace(id);
@@ -16722,7 +16730,7 @@ function serverAt(key, def, root, checkout, cmd, forWarm) {
 	return srv;
 }
 /** When a server last mattered: asked, or warmed for a page. */
-var touched = (s) => Math.max(s.lastUsed, s.lastWarm);
+var touched$1 = (s) => Math.max(s.lastUsed, s.lastWarm);
 /** Stop the least recently touched idle servers until one more fits, and
 * say whether it does. A question makes room from any server not
 * mid-question (a burst can overshoot); a warm only from ones unused for a
@@ -16730,7 +16738,7 @@ var touched = (s) => Math.max(s.lastUsed, s.lastWarm);
 function makeRoom(forWarm = false) {
 	const live = [...servers.values()].filter((s) => !s.stopping);
 	const now = Date.now();
-	const idle = live.filter((s) => !s.busy && (!forWarm || now - touched(s) > RECENT_MS)).sort((a, b) => touched(a) - touched(b));
+	const idle = live.filter((s) => !s.busy && (!forWarm || now - touched$1(s) > RECENT_MS)).sort((a, b) => touched$1(a) - touched$1(b));
 	let n = live.length;
 	for (; n >= MAX_RUNNING && idle.length; n--) stop(idle.shift());
 	return n < MAX_RUNNING;
@@ -16923,7 +16931,7 @@ setInterval(() => {
 	if (!lspEnabled()) {
 		for (const s of servers.values()) if (!s.busy) stop(s);
 	}
-	for (const s of servers.values()) if (!s.busy && now - touched(s) > (s.lastUsed ? IDLE_MS : WARM_IDLE_MS)) stop(s);
+	for (const s of servers.values()) if (!s.busy && now - touched$1(s) > (s.lastUsed ? IDLE_MS : WARM_IDLE_MS)) stop(s);
 }, 6e4).unref();
 function exclusive(srv, fn) {
 	const run = srv.queue.then(fn, fn);
@@ -17469,6 +17477,60 @@ async function workPids(argv) {
 	for (let at = process.pid; at && at > 1 && !pids.has(at) && pids.size < 32; at = argv ? argv.get(at)?.ppid : await procPpid(at)) pids.add(at);
 	return pids;
 }
+/** How long what a closed session started has to exit on its SIGTERM. */
+var SESSION_END_GRACE_MS = 5e3;
+/** Every process a session started, wherever it went since. tmux gives a
+* session's panes `WORK_SESSION_ID` and whatever they start inherits it, a
+* job detached with nohup or setsid included: once its parent is gone no
+* process tree leads back to one, and such jobs outlived their sessions
+* by days. Read from each process's environment where /proc has it; on
+* macOS, whose `ps` would mix the environment into the command line, the
+* trees under the session's panes instead (`panes`, read before the
+* session went). Never the server or what runs it. */
+async function sessionProcs(sessionId, panes) {
+	let pids;
+	if (darwin) {
+		const table = await processArgsNow();
+		const children = /* @__PURE__ */ new Map();
+		for (const [pid, row] of table) children.set(row.ppid, [...children.get(row.ppid) ?? [], pid]);
+		const seen = /* @__PURE__ */ new Set();
+		const queue = panes.filter((p) => table.has(p));
+		while (queue.length) {
+			const pid = queue.pop();
+			if (seen.has(pid)) continue;
+			seen.add(pid);
+			queue.push(...children.get(pid) ?? []);
+		}
+		pids = [...seen];
+	} else {
+		const mark = `WORK_SESSION_ID=${sessionId}\0`;
+		const names = await fs$1.readdir("/proc").catch(() => []);
+		pids = (await Promise.all(names.filter((n) => /^\d+$/.test(n)).map(async (n) => {
+			const env = await fs$1.readFile(`/proc/${n}/environ`, "latin1").catch(() => "");
+			return env.startsWith(mark) || env.includes(`\0${mark}`) ? Number(n) : 0;
+		}))).filter(Boolean);
+	}
+	const own = await workPids();
+	return pids.filter((p) => !own.has(p));
+}
+/** Ends everything a closing session started (`sessionProcs`): SIGTERM
+* now, and SIGKILL to what is still there `SESSION_END_GRACE_MS` later.
+* On Linux the second pass looks again by the environment, so a pid
+* reused meanwhile is never hit. */
+async function endSessionProcs(sessionId, panes) {
+	const first = await sessionProcs(sessionId, panes);
+	if (!first.length) return;
+	for (const pid of first) try {
+		process.kill(pid, "SIGTERM");
+	} catch {}
+	setTimeout(() => {
+		(darwin ? Promise.resolve(first) : sessionProcs(sessionId, [])).then((left) => {
+			for (const pid of left) try {
+				process.kill(pid, "SIGKILL");
+			} catch {}
+		}).catch(() => {});
+	}, SESSION_END_GRACE_MS).unref?.();
+}
 /** SIGTERM every process running inside the workspace (dev servers etc.). */
 async function killWorkspaceProcs(wsPath) {
 	for (const proc of await workspaceProcs(wsPath)) try {
@@ -17931,11 +17993,13 @@ function onSessionDispose(fn) {
 }
 async function disposeSession(id) {
 	for (const fn of disposeListeners) fn(id);
+	const panes = (await listPanes() ?? []).filter((p) => p.id === id).map((p) => p.pid);
 	await tmux([
 		"kill-session",
 		"-t",
 		tmuxName(id)
 	]).catch(() => {});
+	endSessionProcs(id, panes).catch(() => {});
 	forgetPanes();
 	clearTmuxStarted(id);
 	clearAgentPhase(id);
@@ -18005,7 +18069,7 @@ function notifySessionsChanged(workspaceId) {
 async function emitSessionsChanged(workspaceId) {
 	try {
 		const states = await sessionStates();
-		const { teamsOf } = await import("./_tFH4KiOy.js");
+		const { teamsOf } = await import("./_B25P__C4.js");
 		publish("sessions.changed", {
 			workspaceId,
 			sessions: listSessions(workspaceId).map((s) => ({
@@ -18299,8 +18363,9 @@ async function ensureTmuxServer() {
 		"sleep",
 		"infinity"
 	], os.homedir());
+	const backstop = SCRATCH_TMUX ? ["--property=RuntimeMaxSec=1d"] : [];
 	const files = openFileLimit();
-	await start(files ? [`--property=LimitNOFILE=${files}`] : []).catch(() => files ? start([]) : Promise.reject()).catch(() => {});
+	await start([...files ? [`--property=LimitNOFILE=${files}`] : [], ...backstop]).catch(() => files ? start(backstop) : Promise.reject()).catch(() => {});
 }
 /** This server's open-file limit, for tmux's server: it holds a socket and
 * a tty for every client attached and a pty for every pane, and a systemd
@@ -18589,9 +18654,10 @@ function sessionEnvArgs(session, cwd) {
 }
 /** A session's scratch (`TMPDIR`): its workspace's own `.tmp/`, on disk
 * and gone with the workspace (and out of backups), where `/tmp` is a
-* small tmpfs every workspace shares and nothing empties: agents' repro
-* servers and installs there ran it out of inodes. Made here, since a
-* `TMPDIR` that does not exist fails `mktemp` outright. */
+* small tmpfs every workspace shares: agents' repro servers and installs
+* there ran it out of inodes. It empties as `/tmp` does (tmp-sweep.ts).
+* Made here, since a `TMPDIR` that does not exist fails `mktemp`
+* outright. */
 function sessionTmp(cwd) {
 	const dir = path.join(cwd, ".tmp");
 	fs.mkdirSync(dir, { recursive: true });
@@ -18685,6 +18751,258 @@ function ensureAllPushHooks() {
 	}
 }
 //#endregion
+//#region src/server/tmp-sweep.ts
+/**
+* A workspace's `.tmp/` is its sessions' `TMPDIR` (sessions.ts
+* `sessionTmp`), and agents fill it the way they would fill `/tmp`: clones,
+* installs, repro servers, logs. Nothing else ever emptied it, so it grew
+* to tens of gigabytes a workspace. It is emptied the way the machine
+* empties its own `/tmp`: what has gone untouched for as long as `/tmp`
+* keeps an entry goes, by the rules `systemd-tmpfiles --clean` applies, on
+* its schedule.
+*/
+var DAY = 864e5;
+/** systemd's own age for `/tmp` (its shipped `tmp.conf`), and the age where
+* nothing on the machine names one. */
+var SYSTEMD_TMP_AGE = 10 * DAY;
+/** macOS's `daily_clean_tmps_days` as shipped. */
+var MAC_TMP_DAYS = 3;
+/** As `systemd-tmpfiles-clean.timer`: 15 minutes after start, then daily. */
+var FIRST_SWEEP_MS = 9e5;
+var SWEEP_EVERY_MS = DAY;
+/** Where systemd-tmpfiles reads its config, first to last: a file in an
+* earlier directory hides one of the same name in a later one. */
+var TMPFILES_DIRS = [
+	"/etc/tmpfiles.d",
+	"/run/tmpfiles.d",
+	"/usr/local/lib/tmpfiles.d",
+	"/usr/lib/tmpfiles.d"
+];
+/** macOS periodic(8)'s config, each assignment overriding the one before. */
+var PERIODIC_CONFS = [
+	"/etc/defaults/periodic.conf",
+	"/etc/periodic.conf",
+	"/etc/periodic.conf.local"
+];
+var UNIT_MS = {
+	us: .001,
+	usec: .001,
+	ms: 1,
+	msec: 1,
+	s: 1e3,
+	sec: 1e3,
+	second: 1e3,
+	seconds: 1e3,
+	m: 6e4,
+	min: 6e4,
+	minute: 6e4,
+	minutes: 6e4,
+	h: 36e5,
+	hr: 36e5,
+	hour: 36e5,
+	hours: 36e5,
+	d: DAY,
+	day: DAY,
+	days: DAY,
+	w: 7 * DAY,
+	week: 7 * DAY,
+	weeks: 7 * DAY,
+	M: 30.44 * DAY,
+	month: 30.44 * DAY,
+	months: 30.44 * DAY,
+	y: 365.25 * DAY,
+	year: 365.25 * DAY,
+	years: 365.25 * DAY
+};
+/** A tmpfiles.d age (`10d`, `1w 2d`, `~12h`, `ac:30d`) in ms: null for
+* `-` or none, which means never cleaned. */
+function parseAge(text) {
+	if (!text || text === "-") return null;
+	const span = text.replace(/^~/, "").replace(/^[aAbBcCmM]+:/, "");
+	let ms = 0;
+	let matched = "";
+	for (const m of span.matchAll(/\s*(\d+(?:\.\d+)?)\s*([a-zA-Zµ]*)/g)) {
+		const unit = m[2] === "" ? "s" : m[2] === "µs" ? "us" : m[2];
+		if (!(unit in UNIT_MS)) return null;
+		ms += Number(m[1]) * UNIT_MS[unit];
+		matched += m[0];
+	}
+	return matched.trim() === span.trim() && matched ? ms : null;
+}
+/** `/tmp`'s age in this machine's tmpfiles.d config: undefined when no
+* line names `/tmp`. Of every file, the lexicographically first one with a
+* line for a path is the one applied, as systemd-tmpfiles does. */
+function tmpfilesAge(root) {
+	const files = /* @__PURE__ */ new Map();
+	for (const dir of TMPFILES_DIRS) {
+		let names;
+		try {
+			names = fs.readdirSync(path.join(root, dir));
+		} catch {
+			continue;
+		}
+		for (const name of names) if (name.endsWith(".conf") && !files.has(name)) files.set(name, path.join(root, dir, name));
+	}
+	for (const name of [...files.keys()].sort()) {
+		let text;
+		try {
+			text = fs.readFileSync(files.get(name), "utf8");
+		} catch {
+			continue;
+		}
+		for (const raw of text.split("\n")) {
+			const line = raw.trim();
+			if (!line || line.startsWith("#")) continue;
+			const [type, where, , , , age] = line.split(/\s+/);
+			if (where === "/tmp" && /^[dDeqQv]/.test(type)) return parseAge(age);
+		}
+	}
+}
+/** macOS cleans `/tmp` from periodic(8)'s daily run: what has gone
+* `daily_clean_tmps_days` untouched, while `daily_clean_tmps_enable`. */
+function periodicAge(root) {
+	const vars = {};
+	for (const file of PERIODIC_CONFS) {
+		let text;
+		try {
+			text = fs.readFileSync(path.join(root, file), "utf8");
+		} catch {
+			continue;
+		}
+		for (const m of text.matchAll(/^\s*(daily_clean_tmps_(?:enable|days))\s*=\s*["']?([^"'\s#]*)/gm)) vars[m[1]] = m[2];
+	}
+	if ((vars.daily_clean_tmps_enable ?? "YES").toUpperCase() !== "YES") return null;
+	const days = Number(vars.daily_clean_tmps_days);
+	return (Number.isFinite(days) && days >= 0 ? days : MAC_TMP_DAYS) * DAY;
+}
+/** How long this machine's `/tmp` keeps an entry nobody touches, in ms:
+* null when it never ages one out. `WORK_TMP_AGE` (a tmpfiles.d age, or
+* `off`) overrides it. `root` and `platform` are for a test. */
+function tmpAge(opts = {}) {
+	const env = opts.env ?? process.env.WORK_TMP_AGE;
+	if (env) return /^(off|never|-)$/i.test(env) ? null : parseAge(env);
+	const root = opts.root ?? "/";
+	if ((opts.platform ?? process.platform) === "darwin") return periodicAge(root);
+	const age = tmpfilesAge(root);
+	return age === void 0 ? SYSTEMD_TMP_AGE : age;
+}
+/** When an entry was last touched, by the times systemd-tmpfiles weighs
+* by default (`abcmABM`): a file's access, birth, change and modification;
+* a directory's without its change time, which cleaning it moves. */
+function touched(st, dir) {
+	return Math.max(st.atimeMs, st.mtimeMs, st.birthtimeMs || 0, dir ? 0 : st.ctimeMs);
+}
+/** Empties `dir` of what has gone `ageMs` untouched: each file past it,
+* then each directory past it once it is empty. `dir` itself stays, a
+* symlink is never followed (a `.tmp` that is one is left alone), and
+* another filesystem mounted inside is never entered. */
+async function sweepTmp(dir, ageMs, now = Date.now()) {
+	const out = {
+		removed: 0,
+		bytes: 0
+	};
+	let top;
+	try {
+		top = await fs$1.lstat(dir);
+	} catch {
+		return out;
+	}
+	if (!top.isDirectory()) return out;
+	await clean(dir, top, now - ageMs, out);
+	return out;
+}
+/** Cleans one directory, `st` its times from before it was read; true when
+* nothing is left in it. */
+async function clean(dir, st, cutoff, out) {
+	let handle;
+	try {
+		handle = await fs$1.opendir(dir);
+	} catch {
+		return false;
+	}
+	let left = 0;
+	try {
+		for await (const entry of handle) {
+			const p = path.join(dir, entry.name);
+			let s;
+			try {
+				s = await fs$1.lstat(p);
+			} catch {
+				continue;
+			}
+			if (s.dev !== st.dev) {
+				left++;
+				continue;
+			}
+			if (s.isDirectory()) {
+				if (await clean(p, s, cutoff, out) && touched(s, true) < cutoff) try {
+					await fs$1.rmdir(p);
+					out.removed++;
+					continue;
+				} catch {}
+				left++;
+				continue;
+			}
+			if (touched(s, false) < cutoff) try {
+				await fs$1.unlink(p);
+				out.removed++;
+				out.bytes += s.size;
+				continue;
+			} catch {}
+			left++;
+		}
+	} catch {
+		left++;
+	}
+	await fs$1.utimes(dir, st.atime, st.mtime).catch(() => {});
+	return left === 0;
+}
+/** An age as the sweep's log and the workspace AGENTS.md say it. */
+function ageText(ms) {
+	for (const [unit, per] of [
+		["day", DAY],
+		["hour", 36e5],
+		["minute", 6e4]
+	]) if (ms >= per) {
+		const n = Math.round(ms / per);
+		return `${n} ${unit}${n === 1 ? "" : "s"}`;
+	}
+	const n = Math.round(ms / 1e3);
+	return `${n} second${n === 1 ? "" : "s"}`;
+}
+function size(bytes) {
+	return bytes >= 1 << 30 ? `${(bytes / (1 << 30)).toFixed(1)} GiB` : `${Math.round(bytes / (1 << 20))} MiB`;
+}
+var started = false;
+/** Sweeps each `.tmp/` that `dirs` names, on systemd-tmpfiles-clean's
+* schedule, at the age `/tmp` has when each sweep starts (a machine whose
+* `/tmp` keeps everything keeps these too). `WORK_TMP_SWEEP_DELAY`
+* (seconds) moves the first sweep, for a test. */
+function startTmpSweep(dirs) {
+	if (started) return;
+	started = true;
+	let running = false;
+	const sweep = async () => {
+		if (running) return;
+		running = true;
+		try {
+			const age = tmpAge();
+			if (age === null) return;
+			for (const dir of dirs()) {
+				const r = await sweepTmp(dir, age).catch(() => null);
+				if (r?.removed) console.log(`[work] tmp: removed ${r.removed} entr${r.removed === 1 ? "y" : "ies"} (${size(r.bytes)}) untouched for ${ageText(age)} from ${dir}`);
+			}
+		} finally {
+			running = false;
+		}
+	};
+	const delay = Number(process.env.WORK_TMP_SWEEP_DELAY);
+	setTimeout(() => {
+		sweep();
+		setInterval(() => void sweep(), SWEEP_EVERY_MS).unref?.();
+	}, Number.isFinite(delay) && delay >= 0 ? delay * 1e3 : FIRST_SWEEP_MS).unref?.();
+}
+//#endregion
 //#region src/server/workspaces.ts
 /** Newest first, and never reordered by use: a row that moves as you
 * click or type is worse than a stale order. The nav groups rows by PR
@@ -19653,6 +19971,8 @@ function syncAgentsMd() {
 }
 function agentsMd(wsId, branch, repos, origin) {
 	const first = repos[0]?.worktree ?? "<repo>";
+	const tmpKept = tmpAge();
+	const tmpLine = tmpKept === null ? "" : `\n  It empties as the machine's \`/tmp\` does: whatever goes ${ageText(tmpKept)}\n  untouched there is deleted.`;
 	const repoLines = repos.map((r) => `  - \`${r.worktree}/\`: ${r.full_name}${r.default_branch === r.base_branch ? "" : ` (base: \`${r.base_branch}\`${r.default_branch ? `, default: \`${r.default_branch}\`` : ""})`}`).join("\n");
 	const featureBase = !origin && repos.some((r) => r.default_branch && r.default_branch !== r.base_branch);
 	const backportLine = featureBase ? ` (a backport: from \`origin/<default>\`)` : "";
@@ -19685,7 +20005,10 @@ ${repoLines}
   \`work topic list\` shows the open ones. \`<group>.<topic>\` folds topics
   into one review chip. Keep a few open per repo unless asked for a batch; a
   finding you won't fix gets a topic of its own. Work on files another open
-  branch changes goes on that branch or waits for it to merge.
+  branch changes goes on that branch or waits for it to merge. One you
+  abandon goes with \`work topic drop <topic>\` (never \`git branch -D\` or
+  \`git worktree remove\`): it says what it discards, wants \`--yes\` for
+  work no base has, and keeps the tip 30 days.
 - **One branch, one PR:** follow-ups to a change are more commits on its
   branch, PR open or not. Stack only when the user asks, or when a change of
   several hundred lines splits into parts each worth merging alone (never a
@@ -19707,7 +20030,8 @@ ${repoLines}
   follow-up and the same link shows it.
 - **PRs:** only when the user asks; the description is a few sentences on
   what changed and why, no verification logs or file lists.${independentPr}
-- **After a merge** (its PR's, or yours into the branch it stacks on):
+- **After a merge** (its PR's, yours into the branch it stacks on, or its
+  changes landing by other commits: squashed into another PR, cherry-picked):
   \`work topic done <topic> --rebase\` removes the merged topic's worktree
   (its branch stays; the app prunes it) and rebases the other open topics,
   each onto its own base (\`origin/<base>\`${featureBase ? ", a backport's `origin/<default>`" : ""}, or the branch it
@@ -19719,7 +20043,7 @@ ${repoLines}
   \`[login-after](/w/${wsId}/files?file=.share/<path>)\`, never a bare file
   name, which nothing opens (\`work open <path>\` offers it in the app too).
   \`.tmp/\` (your \`TMPDIR\`) is scratch the app does not list: a link to a
-  file there opens, but what they should keep seeing belongs in \`.share/\`.
+  file there opens, but what they should keep seeing belongs in \`.share/\`.${tmpLine}
   Their pastes land in \`.share/pasted/\`.
 - **Tell the user** only what the app does not already: it notifies them when
   your turn ends or you are waiting on them. For news in the middle of a turn
@@ -19774,4 +20098,4 @@ ${repoLines}
 `;
 }
 //#endregion
-export { panePids as $, agentBadge as $n, agentById as $r, startSnapSweep as $t, closedSession as A, lastTypedAt as An, WORKSPACE_PREFS as Ar, removeServer as At, killWorkspaceSessions as B, onPhaseChange as Bn, setDisabledAgents as Br, refreshGithub as Bt, workspaceBranches as C, config as Ci, realInside as Cn, ensureGitCredentials as Cr, addCustomServer as Ct, beginCreation as D, hookPhase as Dn, removeHost as Dr, installKey as Dt, agentCaller as E, clearAgentPhase as En, normalizeHost as Er, forgetProbes as Et, ensureTmuxServer as F, noteTurnFailed as Fn, disabledAgents as Fr, authGithub as Ft, markTmuxStarted as G, setExpecting as Gn, ghKnownHosts as Gr, patchIn as Gt, listPanes as H, onTurnFailed as Hn, setSetting as Hr, runStreaming as Ht, forgetPanes as I, noteTyped as In, enabledAgents as Ir, installAgent as It, noteConversation as J, settleQuietWorking as Jn, which as Jr, reviewWaiting as Jt, moveSession as K, setScrapedPhase as Kn, miseInstalls as Kr, readBlobAt as Kt, getSession as L, noteUserAnswered as Ln, getSetting as Lr, installMise as Lt, creationOf as M, noteBackground as Mn, allPrefs as Mr, serverList as Mt, descendantsOf as N, noteInterrupt as Nn, changePref as Nr, sharing as Nt, cleanEnv as O, hookReportedAt as On, unreachableRepos as Or, installServer as Ot, disposeSessions as P, notePermissionMode as Pn, deleteSetting as Pr, whileInstalling as Pt, paneJobs as Q, turnSince as Qn, TOOLS as Qr, setPoints as Qt, interruptSession as R, notifyEventOn as Rn, isKnownAgent as Rr, installTool as Rt, withProgressOp as S, tmux as Si, inside as Sn, configuredHosts as Sr, stopServers as St, hookToken as T, withLock as Ti, agentPhase as Tn, isValidHost as Tr, forgetCustomServer as Tt, listPanesWithin as U, sessionWatched as Un, discoverAgents as Ur, updateTool as Ut, launchDir as V, onTurnEnd as Vn, setPref as Vr, removeTool as Vt, listSessions as W, setAgentPhase as Wn, doctor as Wr, fileChanges as Wt, onSessionDispose as X, turnPhase as Xn, firewallProbe as Xr, workspaceDiff as Xt, notifySessionsChanged as Y, summaryOf as Yn, bornOut as Yr, withinBudget as Yt, ownWorkspaceOnly as Z, turnSettling as Zn, PROJECT_TOOLS as Zr, workspaceSections as Zt, retryMaterialize as _, workspacePath as _i, blankRow as _n, repoBranches as _r, lspQueryOf as _t, ensureUntrackedCache as a, FRAME_ANCESTORS as ai, hotBatchMinMs as an, getInstance as ar, retireSession as at, sweepTrash as b, TMUX_SOCKET as bi, writeCache as bn, DEFAULT_HOST as br, runningServers as bt, insertPendingWorkspace as c, httpError as ci, withoutDismissed as cn, normalizeAccent as cr, sessionStates as ct, progress as d, publishJson as di, AGENTS as dn, pushPublicKey as dr, killWorkspaceProc as dt, agentLabel$1 as ei, diffStamp as en, agentFamily as er, pasteToSession as et, progressSince as f, subscribe as fi, interruptKeys as fn, saveSubscription as fr, portsByWorkspace as ft, resumePendingWorkspaces as g, get as gi, steerKeys as gn, pendingSsoOrgs as gr, lspQuery as gt, removeRepo as h, db as hi, reportsWorking as hn, headOid as hr, lspDiagnostics as ht, deleteWorkspace as i, applyPrefChange as ii, dismissPr as in, ACCENT_RE as ir, restartSession as it, createSession as j, noteActivity$1 as jn, agentChoices as jr, serverById as jt, clearTmuxStarted as k, interruptedSinceReport as kn, PREF_MAX as kr, lspEnabled as kt, listWorkspaces as l, readBody as li, workspacePrs as ln, setInstance as lr, tmuxName as lt, queueMaterialize as m, all as mi, readHookPayload as mn, validSubscription as mr, killServers as mt, barePath as n, parseAgentId as ni, markBranch as nn, agentLabel as nr, reopenSession as nt, gcBares as o, FRAME_HEADERS as oi, notePushActivity as on, iconSvg as or, sendToSession as ot, pruneLaneBranch as p, subscriberCount as pi, quotesPastes as pn, sendPush as pr, workspaceProcs as pt, newSessionArgs as q, setSessionViewers as qn, miseVersions as qr, readFileAt as qt, createWorkspace as r, toolById as ri, sectionFor as rn, agentMeta as rr, reopenable as rt, getWorkspace as s, checked as si, refreshPrsBatch as sn, manifest as sr, sessionInfo as st, addRepo as t, catalogPin as ti, commentFolder as tn, agentFromCommand as tr, renameSession as tt, otherWorkspaceBranches as u, publish as ui, noteActivity as un, deleteSubscription as ur, tmuxWasStarted as ut, revParse as v, ownsBranchOf as vi, credentialStamp as vn, repoCatalog as vr, lspUses as vt, ensureAllPushHooks as w, swr as wi, activityOf as wn, forgetToken as wr, allServers as wt, syncAgentsMd as x, git as xi, cleanSummary as xn, addHost as xr, stopAllServers as xt, setWorkspaceStatus as y, ensureAllCacheConfig as yi, readCache as yn, repoDefaultBranch as yr, lspWarm as yt, killSession as z, onFinished as zn, preferredAgent as zr, logoutGithub as zt };
+export { paneJobs as $, turnSince as $n, TOOLS as $r, setPoints as $t, clearTmuxStarted as A, interruptedSinceReport as An, PREF_MAX as Ar, lspEnabled as At, killSession as B, onFinished as Bn, preferredAgent as Br, logoutGithub as Bt, workspaceBranches as C, git as Ci, inside as Cn, configuredHosts as Cr, stopServers as Ct, agentCaller as D, withLock as Di, clearAgentPhase as Dn, normalizeHost as Dr, forgetProbes as Dt, hookToken as E, swr as Ei, agentPhase as En, isValidHost as Er, forgetCustomServer as Et, disposeSessions as F, notePermissionMode as Fn, deleteSetting as Fr, whileInstalling as Ft, listSessions as G, setAgentPhase as Gn, doctor as Gr, fileChanges as Gt, launchDir as H, onTurnEnd as Hn, setPref as Hr, removeTool as Ht, ensureTmuxServer as I, noteTurnFailed as In, disabledAgents as Ir, authGithub as It, newSessionArgs as J, setSessionViewers as Jn, miseVersions as Jr, readFileAt as Jt, markTmuxStarted as K, setExpecting as Kn, ghKnownHosts as Kr, patchIn as Kt, forgetPanes as L, noteTyped as Ln, enabledAgents as Lr, installAgent as Lt, createSession as M, noteActivity$1 as Mn, agentChoices as Mr, serverById as Mt, creationOf as N, noteBackground as Nn, allPrefs as Nr, serverList as Nt, beginCreation as O, hookPhase as On, removeHost as Or, installKey as Ot, descendantsOf as P, noteInterrupt as Pn, changePref as Pr, sharing as Pt, ownWorkspaceOnly as Q, turnSettling as Qn, PROJECT_TOOLS as Qr, workspaceSections as Qt, getSession as R, noteUserAnswered as Rn, getSetting as Rr, installMise as Rt, withProgressOp as S, TMUX_SOCKET as Si, cleanSummary as Sn, addHost as Sr, stopAllServers as St, ensureAllPushHooks as T, config as Ti, activityOf as Tn, forgetToken as Tr, allServers as Tt, listPanes as U, onTurnFailed as Un, setSetting as Ur, runStreaming as Ut, killWorkspaceSessions as V, onPhaseChange as Vn, setDisabledAgents as Vr, refreshGithub as Vt, listPanesWithin as W, sessionWatched as Wn, discoverAgents as Wr, updateTool as Wt, notifySessionsChanged as X, summaryOf as Xn, bornOut as Xr, withinBudget as Xt, noteConversation as Y, settleQuietWorking as Yn, which as Yr, reviewWaiting as Yt, onSessionDispose as Z, turnPhase as Zn, firewallProbe as Zr, workspaceDiff as Zt, retryMaterialize as _, get as _i, steerKeys as _n, pendingSsoOrgs as _r, lspQuery as _t, ensureUntrackedCache as a, applyPrefChange as ai, dismissPr as an, ACCENT_RE as ar, restartSession as at, sweepTrash as b, ensureAllCacheConfig as bi, readCache as bn, repoDefaultBranch as br, lspWarm as bt, insertPendingWorkspace as c, checked as ci, refreshPrsBatch as cn, manifest as cr, sessionInfo as ct, progress as d, publish as di, noteActivity as dn, deleteSubscription as dr, tmuxWasStarted as dt, agentById as ei, startSnapSweep as en, agentBadge as er, panePids as et, progressSince as f, publishJson as fi, AGENTS as fn, pushPublicKey as fr, killWorkspaceProc as ft, resumePendingWorkspaces as g, db as gi, reportsWorking as gn, headOid as gr, lspDiagnostics as gt, removeRepo as h, all as hi, readHookPayload as hn, validSubscription as hr, killServers as ht, deleteWorkspace as i, toolById as ii, sectionFor as in, agentMeta as ir, reopenable as it, closedSession as j, lastTypedAt as jn, WORKSPACE_PREFS as jr, removeServer as jt, cleanEnv as k, hookReportedAt as kn, unreachableRepos as kr, installServer as kt, listWorkspaces as l, httpError as li, withoutDismissed as ln, normalizeAccent as lr, sessionStates as lt, queueMaterialize as m, subscriberCount as mi, quotesPastes as mn, sendPush as mr, workspaceProcs as mt, barePath as n, catalogPin as ni, commentFolder as nn, agentFromCommand as nr, renameSession as nt, gcBares as o, FRAME_ANCESTORS as oi, hotBatchMinMs as on, getInstance as or, retireSession as ot, pruneLaneBranch as p, subscribe as pi, interruptKeys as pn, saveSubscription as pr, portsByWorkspace as pt, moveSession as q, setScrapedPhase as qn, miseInstalls as qr, readBlobAt as qt, createWorkspace as r, parseAgentId as ri, markBranch as rn, agentLabel as rr, reopenSession as rt, getWorkspace as s, FRAME_HEADERS as si, notePushActivity as sn, iconSvg as sr, sendToSession as st, addRepo as t, agentLabel$1 as ti, diffStamp as tn, agentFamily as tr, pasteToSession as tt, otherWorkspaceBranches as u, readBody as ui, workspacePrs as un, setInstance as ur, tmuxName as ut, revParse as v, workspacePath as vi, blankRow as vn, repoBranches as vr, lspQueryOf as vt, startTmpSweep as w, tmux as wi, realInside as wn, ensureGitCredentials as wr, addCustomServer as wt, syncAgentsMd as x, SCRATCH_TMUX as xi, writeCache as xn, DEFAULT_HOST as xr, runningServers as xt, setWorkspaceStatus as y, ownsBranchOf as yi, credentialStamp as yn, repoCatalog as yr, lspUses as yt, interruptSession as z, notifyEventOn as zn, isKnownAgent as zr, installTool as zt };

package/dist/_wbrwjNyW.js

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