@dylanpiercey/work 0.0.120 → 0.0.122

package/dist/_Bjh5JEm7.js

@@ -0,0 +1,2 @@
+import { n as pokeStatusWatch } from "./_CfwTkTbL.js";
+export { pokeStatusWatch };

package/dist/_CfwTkTbL.js

@@ -0,0 +1,352 @@
+import { U as subscriberCount, V as publish, W as subscriberJoins, dt as all, ft as db, g as sessionStates, l as listSessions } from "./_Cr71Xd0d.js";
+import { A as portsByWorkspace, J as hostToken, K as forgetToken, M as headOid, Q as ownsBranch, R as repoParent, V as DEFAULT_HOST, Y as joinRepo, Z as splitRepo, h as listWorkspaces, o as pushFailureFor, q as graphqlUrl, z as swr } from "./_DJyHc1w-.js";
+import path from "node:path";
+//#region src/server/github-api.ts
+/** Run a GraphQL query against one host.
+*
+* Partial failures come back as a populated `errors` alongside usable `data`
+* — one repo deleted, renamed, or outside this token's scope. Callers want
+* the repos that did resolve, so `data` wins whenever it is present; this
+* matches how the `gh` path treated a non-zero exit with usable stdout. */
+async function graphql(query, host = DEFAULT_HOST) {
+	const res = await fetch(graphqlUrl(host), {
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${await hostToken(host)}`,
+			"content-type": "application/json",
+			accept: "application/vnd.github+json",
+			"user-agent": "work"
+		},
+		body: JSON.stringify({ query })
+	});
+	if (!res.ok && res.status !== 200) {
+		if (res.status === 401 || res.status === 403) forgetToken(host);
+		throw new Error(`github graphql ${res.status}`);
+	}
+	const body = await res.json();
+	if (!body?.data) throw new Error(body?.errors?.[0]?.message || "graphql response without data");
+	return body.data;
+}
+//#endregion
+//#region src/server/prs.ts
+var TTL_MS$1 = 12e4;
+/** PRs whose head is the workspace branch or one of its `-topic` lanes.
+* `exclude` lists other workspaces' branches — slugs are user-chosen, so
+* another workspace's branch can extend this prefix and its PRs must not
+* be attributed here. */
+function prsForBranchPrefix(prs, prefix, exclude = []) {
+	return prs.filter((pr) => ownsBranch(pr.headRefName, prefix) && !exclude.some((x) => ownsBranch(pr.headRefName, x)));
+}
+/** `[host/]owner/name#branch` — the host prefix travels with the name. */
+var branchKey = (fullName, branch) => `${fullName}#${branch}`;
+/** One workspace's PRs in one repo — its branch and every `-topic` lane, in
+* every state. Asking for the workspace's own branches is what keeps this
+* proportional to the workspace rather than to the repo: the alternative,
+* a recency window over all of a repo's PRs, fetched roughly twice what it
+* kept here and still aged a quiet workspace out on a busy repo.
+* Key: `fullName#branch`. */
+var branchPrs = swr(TTL_MS$1, async (key, refresh) => {
+	const sep = key.indexOf("#");
+	const fullName = key.slice(0, sep);
+	const { host, name } = splitRepo(fullName);
+	const upstream = await repoParent(fullName);
+	return (await searchPrs(host, upstream ? [name, splitRepo(upstream).name] : [name], [key.slice(sep + 1)], refresh)).filter((n) => ownsNode(n, fullName, upstream));
+});
+/** A workspace repo's PRs, minus any belonging to a workspace whose branch
+* extends this one's. `since` is an imported workspace's arrival: a
+* restored or joined workspace keeps its branch name, so the branch's whole
+* history on GitHub matches — finished PRs from before it arrived here are
+* its previous life's, not chips to dismiss again. Open PRs always show;
+* hiding live work would be the worse mistake. */
+async function workspacePrs(fullName, branch, foreign, refresh = false, since) {
+	return prsForBranchPrefix(await branchPrs(branchKey(fullName, branch), refresh).catch(() => []), branch, foreign).filter((pr) => !since || pr.state === "OPEN" || !pr.updatedAt || pr.updatedAt >= since);
+}
+/** Refresh many repos' PRs with one GraphQL request (vs one `gh pr list`
+* process per repo) — called from the status watcher for active
+* workspaces so open/merge/close flips surface in ~watch-tick time
+* instead of waiting out the per-repo TTL. Throttled internally. */
+var BATCH_MIN_MS = 15e3;
+/** After a detected local push, poll fast for a bit — the PR appears
+* and merges/closes in the minutes right after. */
+var HOT_MIN_MS = 3e3;
+var HOT_WINDOW_MS = 18e4;
+var lastBatch = 0;
+var hotUntil = 0;
+function notePushActivity() {
+	hotUntil = Date.now() + HOT_WINDOW_MS;
+}
+/** Inside the post-push window where PR state is actively flipping. */
+function inHotWindow() {
+	return Date.now() < hotUntil;
+}
+/** `headRefOid` is the PR's own head commit, which is what the UI compares
+* against. Reaching through `headRef` gets the branch's *current* tip
+* instead — a different commit entirely once a workspace branch is reused,
+* and `headRef { oid }` is not even a field, so GitHub answers 200 with an
+* `errors` array and no `data`. */
+var GQL_PR_FIELDS = "number title url headRefName baseRefName isDraft state headRefOid updatedAt";
+/** Does this search hit belong to `fullName`'s workspace repo? Directly when
+* the PR lives in that repo *with its head branch there too*; via the fork
+* case when it lives in `upstream` with its head on the fork. The head check
+* on both arms keeps one PR from being claimed twice when a workspace holds
+* a fork and its upstream, and keeps a same-named branch pushed by someone
+* else's fork from being claimed at all. A null headRepository (head repo
+* deleted) stays with the PR's own repo. */
+function ownsNode(n, fullName, upstream) {
+	const head = n.headRepository?.nameWithOwner;
+	return n.repository.nameWithOwner === fullName && (!head || head === fullName) || !!upstream && n.repository.nameWithOwner === upstream && head === fullName;
+}
+/** Dedup key: PR numbers restart per repo, and a fork target's list spans
+* the fork and its upstream. */
+var nodeKey = (p) => `${p.repository.nameWithOwner}#${p.number}`;
+/** Search's `head:` matches a branch *and* its `-topic` lanes, so one term
+* covers a whole workspace, and repeated terms are OR'd within a qualifier
+* while different qualifiers are AND'd — `repo:a repo:b head:x head:y`
+* reads as (a|b) and (x|y). That is what lets every workspace share one
+* request instead of needing an alias per repo and per branch. */
+function searchTerms(repos, branches) {
+	return [...repos.map((r) => `repo:${r}`), ...branches.map((b) => `head:${b}`)].join(" ");
+}
+/** Finished PRs are asked for by recency, open ones are not: a merged PR
+* only has to outlive its dismissal, while an open PR must stay visible
+* however long it has sat idle — which is exactly what a recency window
+* over the whole repo got wrong. */
+var CLOSED_FIRST = 60;
+var OPEN_FIRST = 100;
+/** Search pages at 100. Open PRs are the page that can genuinely overflow
+* (every workspace's, in one request), so it is followed — bounded, because
+* an unbounded follow is a way to hang the status tick on a bad query. */
+var MAX_OPEN_PAGES = 4;
+var searchField = (alias, query, first, after) => `${alias}: search(query: ${JSON.stringify(query)}, type: ISSUE, first: ${first}${after ? `, after: ${JSON.stringify(after)}` : ""}) { pageInfo { hasNextPage endCursor } nodes { ... on PullRequest { ${GQL_PR_FIELDS} repository { nameWithOwner } headRepository { nameWithOwner } } } }`;
+/** Every PR on the given branches (and their lanes) across the given repos
+* of one host (`repos` are bare `owner/name`). `refresh` is accepted for the
+* swr signature; freshness here is GitHub's, not ours. Nodes come back with
+* the host folded into `repository.nameWithOwner` so callers compare full
+* names. */
+async function searchPrs(host, repos, branches, _refresh) {
+	const terms = searchTerms(repos, branches);
+	const out = [];
+	let cursor;
+	for (let page = 0; page < MAX_OPEN_PAGES; page++) {
+		const data = await graphql("query {" + searchField("open", `is:pr is:open ${terms}`, OPEN_FIRST, cursor) + (page === 0 ? " " + searchField("done", `is:pr is:closed sort:updated-desc ${terms}`, CLOSED_FIRST) : "") + "}", host);
+		const open = data.open;
+		const done = data.done;
+		for (const node of [...open?.nodes ?? [], ...done?.nodes ?? []]) if (node?.number) out.push({
+			...node,
+			repository: { nameWithOwner: joinRepo(host, node.repository.nameWithOwner) },
+			headRepository: node.headRepository ? { nameWithOwner: joinRepo(host, node.headRepository.nameWithOwner) } : null
+		});
+		if (!open?.pageInfo.hasNextPage || !open.pageInfo.endCursor) break;
+		cursor = open.pageInfo.endCursor;
+	}
+	return out;
+}
+async function refreshPrsBatch(targets, force = false) {
+	const wanted = [...new Map(targets.filter((t) => t.fullName.includes("/") && t.branch).map((t) => [branchKey(t.fullName, t.branch), t])).values()];
+	const minMs = force ? 2e3 : Date.now() < hotUntil ? HOT_MIN_MS : BATCH_MIN_MS;
+	if (!wanted.length || Date.now() - lastBatch < minMs) return false;
+	const prevBatch = lastBatch;
+	lastBatch = Date.now();
+	try {
+		const upstreams = new Map(await Promise.all(wanted.map(async (t) => [t.fullName, await repoParent(t.fullName)])));
+		const byHost = /* @__PURE__ */ new Map();
+		for (const t of wanted) {
+			const { host, name } = splitRepo(t.fullName);
+			const names = (byHost.get(host) || /* @__PURE__ */ new Set()).add(name);
+			const upstream = upstreams.get(t.fullName);
+			if (upstream) names.add(splitRepo(upstream).name);
+			byHost.set(host, names);
+		}
+		const branches = [...new Set(wanted.map((t) => t.branch))];
+		const results = await Promise.all([...byHost].map(([host, names]) => searchPrs(host, [...names], branches).catch((err) => {
+			if (byHost.size === 1) throw err;
+			return null;
+		})));
+		const nodes = results.flatMap((r) => r ?? []);
+		const failedHosts = new Set([...byHost.keys()].filter((_, i) => results[i] === null));
+		for (const target of wanted) {
+			if (failedHosts.has(splitRepo(target.fullName).host)) continue;
+			const foreign = branches.filter((b) => b !== target.branch);
+			const key = branchKey(target.fullName, target.branch);
+			const incoming = prsForBranchPrefix(nodes.filter((n) => ownsNode(n, target.fullName, upstreams.get(target.fullName) ?? null)), target.branch, foreign);
+			const open = incoming.filter((p) => p.state === "OPEN");
+			const openKeys = new Set(open.map(nodeKey));
+			const done = /* @__PURE__ */ new Map();
+			for (const p of branchPrs.get(key) ?? []) if (p.state !== "OPEN" && !openKeys.has(nodeKey(p))) done.set(nodeKey(p), p);
+			for (const p of incoming) if (p.state !== "OPEN" && !openKeys.has(nodeKey(p))) done.set(nodeKey(p), p);
+			branchPrs.set(key, [...open, ...done.values()]);
+		}
+		return true;
+	} catch (err) {
+		lastBatch = prevBatch;
+		throw err;
+	}
+}
+/** Confirm a finished (merged/closed) PR so it leaves the manage list. */
+function dismissPr(workspaceId, fullName, number) {
+	db.prepare("INSERT OR IGNORE INTO dismissed_prs (workspace_id, full_name, number) VALUES (?, ?, ?)").run(workspaceId, fullName, number);
+}
+/** Drop dismissed PRs from a repo's list — unless one reopened. Keyed by
+* each PR's own repo + number: a fork target's list spans the fork and its
+* upstream (same numbers restart per repo), so a workspace-repo-wide key
+* would let dismissing upstream #N hide the fork's own #N too. Rows written
+* before PRs carried their repo are keyed by the workspace repo alone and
+* still match via that fallback. */
+function withoutDismissed(workspaceId, fullName, list) {
+	const dismissed = new Set(all("SELECT full_name, number FROM dismissed_prs WHERE workspace_id = ?", workspaceId).map((row) => `${row.full_name}#${row.number}`));
+	return list.filter((pr) => pr.state === "OPEN" || !dismissed.has(`${pr.repository?.nameWithOwner ?? fullName}#${pr.number}`));
+}
+//#endregion
+//#region src/server/status.ts
+var TTL_MS = 2e3;
+var snapshot = null;
+var inflight = null;
+var snapshotGen = 0;
+/** Drop the cached snapshot AND detach any in-flight compute — callers
+* after an invalidation get a computation that starts from fresh state. */
+function invalidateSnapshot() {
+	snapshot = null;
+	snapshotGen++;
+	inflight = null;
+}
+function statusForAll() {
+	if (snapshot && Date.now() - snapshot.at < TTL_MS) return Promise.resolve(snapshot.value);
+	if (!inflight) {
+		const gen = snapshotGen;
+		const run = computeStatus().then((value) => {
+			if (gen === snapshotGen) snapshot = {
+				at: Date.now(),
+				value
+			};
+			return value;
+		}).finally(() => {
+			if (inflight === run) inflight = null;
+		});
+		inflight = run;
+	}
+	return inflight;
+}
+/** Push-based freshness: while any events-bus client is connected,
+* recompute the (shared, deduped) snapshot on a slow tick and publish it
+* only when it actually changed — ports appearing, PR open/merge/close flips reach
+* every client in ~15s instead of waiting out a slow poll, and idle
+* systems push nothing at all. */
+var WATCH_MS = 1e4;
+/** Right after a local push, PR+check state flips within seconds — tick
+* fast so the badge lands while it still feels immediate. */
+var WATCH_HOT_MS = 4e3;
+var watching = false;
+/** Last published state per workspace, so a tick can publish the ones that
+* actually moved. Comparing the whole snapshot instead meant one agent's
+* commit — or any session, port or PR flip in a workspace nobody is
+* looking at — pushed every workspace to every client, which each then
+* re-rendered and re-fingerprinted to conclude nothing of theirs had
+* changed. That amplification grows with the number of workspaces. */
+var lastPushed = /* @__PURE__ */ new Map();
+var lastJoins = -1;
+async function watchTick() {
+	if (!subscriberCount()) return;
+	try {
+		if (await refreshPrsBatch(activeRepoTargets()).catch(() => false)) invalidateSnapshot();
+		const value = await statusForAll();
+		const joins = subscriberJoins();
+		const everything = joins !== lastJoins;
+		lastJoins = joins;
+		const changed = {};
+		for (const [id, ws] of Object.entries(value)) {
+			const json = JSON.stringify(ws);
+			if (everything || lastPushed.get(id) !== json) changed[id] = ws;
+			lastPushed.set(id, json);
+		}
+		for (const id of lastPushed.keys()) if (!(id in value)) lastPushed.delete(id);
+		if (Object.keys(changed).length) publish("status.changed", changed);
+	} catch {}
+}
+var watchTimer;
+function scheduleTick(ms) {
+	clearTimeout(watchTimer);
+	watchTimer = setTimeout(tick, ms);
+	watchTimer.unref?.();
+}
+async function tick() {
+	await watchTick();
+	scheduleTick(inHotWindow() ? WATCH_HOT_MS : WATCH_MS);
+}
+/** Recompute and push right now (e.g. a local push was detected) instead
+* of waiting out the watch tick — and drop the loop into its fast cadence
+* (the push opened the hot window, but the pending timeout was scheduled
+* for the slow one). */
+function pokeStatusWatch() {
+	invalidateSnapshot();
+	watchTick().then(() => {
+		if (watching) scheduleTick(inHotWindow() ? WATCH_HOT_MS : WATCH_MS);
+	});
+}
+function startStatusWatch() {
+	if (watching) return;
+	watching = true;
+	scheduleTick(WATCH_MS);
+}
+/** Every active workspace's repos, paired with the branch that workspace
+* works on — the batch refreshes both the recency window and the exact-head
+* lookup for each, in one request. */
+function activeRepoTargets() {
+	return listWorkspaces().filter((ws) => ws.status === "active").flatMap((ws) => ws.repos.map((r) => ({
+		fullName: r.full_name,
+		branch: ws.branch
+	})));
+}
+/** Status with PRs refetched first (throttled): a client returning to the
+* foreground wants current PR state — merges/closes happen on GitHub and
+* send no local signal, so without this they wait out the slow poll. */
+async function statusForAllFresh() {
+	if (await refreshPrsBatch(activeRepoTargets(), true).catch(() => false)) invalidateSnapshot();
+	return statusForAll();
+}
+/** RSS here is the Node + Marko baseline (~80 MB empty, ~115 MB loaded),
+* not a leak and not worth chasing — young-gen flags do not move it. */
+async function computeStatus() {
+	const everyWorkspace = listWorkspaces();
+	const workspaces = everyWorkspace.filter((ws) => ws.status === "active");
+	const paths = new Map(workspaces.map((ws) => [ws.id, ws.path]));
+	const [ports, states] = await Promise.all([portsByWorkspace(paths), sessionStates()]);
+	const entries = await Promise.all(workspaces.map(async (ws) => {
+		const foreign = everyWorkspace.filter((w) => w.id !== ws.id).map((w) => w.branch);
+		const statuses = await Promise.all(ws.repos.map((repo) => repoStatus(ws, repo, foreign)));
+		return [ws.id, {
+			ports: ports.get(ws.id) || [],
+			repos: statuses,
+			...sessionCounts(ws.id, states)
+		}];
+	}));
+	return Object.fromEntries(entries);
+}
+async function repoStatus(ws, repo, foreign) {
+	const dir = path.join(ws.path, repo.worktree);
+	const [repoPrs, localHead] = await Promise.all([workspacePrs(repo.full_name, ws.branch, foreign, false, ws.imported_at).then((list) => withoutDismissed(ws.id, repo.full_name, list)), headOid(dir).then((h) => h.oid)]);
+	const unpushed = pushFailureFor(repo.full_name, ws.branch, foreign);
+	return {
+		full_name: repo.full_name,
+		worktree: repo.worktree,
+		...localHead && { localHead },
+		...unpushed && { unpushed },
+		prs: repoPrs
+	};
+}
+function sessionCounts(workspaceId, states) {
+	const sessions = listSessions(workspaceId).map((s) => ({
+		id: s.id,
+		agent: s.agent,
+		title: s.title,
+		state: states[s.id] || { alive: false }
+	}));
+	const live = sessions.map((s) => s.state).filter((state) => !!state.alive);
+	return {
+		sessions,
+		agents: live.length,
+		working: live.filter((state) => state.phase === "working").length,
+		waiting: live.filter((state) => state.phase === "waiting").length
+	};
+}
+//#endregion
+export { statusForAllFresh as a, refreshPrsBatch as c, statusForAll as i, workspacePrs as l, pokeStatusWatch as n, dismissPr as o, startStatusWatch as r, notePushActivity as s, activeRepoTargets as t };

package/dist/{_DE2RUdbF.js → _Cr71Xd0d.js}

@@ -9,7 +9,8 @@ import { promisify } from "node:util";
 import { DatabaseSync } from "node:sqlite";
 import { createHash } from "node:crypto";
 //#region src/server/config.ts
-var home$1 = os.homedir();
+var rawHome = os.homedir();
+var home$1 = rawHome && rawHome !== "undefined" && rawHome !== "null" ? rawHome : "";
 var config = {
 	/** Root directory containing all workspaces. */
 	workRoot: process.env.WORK_ROOT || path.join(home$1, "work"),
@@ -81,6 +82,7 @@ function utf8Locale(env) {
 }
 //#endregion
 //#region src/server/db.ts
+if (!path.isAbsolute(config.dataDir)) throw new Error(`data dir must be absolute, got "${config.dataDir}" — check WORK_DATA_DIR and $HOME`);
 var db = new DatabaseSync(path.join(config.dataDir, "work.db"));
 db.exec("PRAGMA busy_timeout = 5000");
 function all(sql, ...params) {
@@ -165,6 +167,9 @@ function ensureColumn(table, column, decl) {
 }
 ensureColumn("review_comments", "head", "TEXT");
 ensureColumn("review_comments", "snippet", "TEXT");
+ensureColumn("workspaces", "materialized", "INTEGER NOT NULL DEFAULT 1");
+ensureColumn("workspaces", "origin_branch", "TEXT");
+ensureColumn("workspaces", "imported_at", "TEXT");
 //#endregion
 //#region lib/setup/agents.json
 var agents_default = [
@@ -6551,7 +6556,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("./_BIDn_RW1.js").then((m) => m.notifySessionsChanged(workspaceId));
+		import("./_B1lVb01g.js").then((m) => m.notifySessionsChanged(workspaceId));
 		return;
 	}
 	publish("sessions.changed");
@@ -8213,4 +8218,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 _, run$1 as _t, ensureTmuxServer as a, which as at, readHookPayload as b, killWorkspaceSessions as c, agentById as ct, newSessionArgs as d, db as dt, discoverAgents as et, notifySessionsChanged as f, get as ft, sessionStates as g, git as gt, sendToSession as h, gh as ht, disposeSessions as i, setupPath as it, setSessionViewers as j, setAgentPhase as k, listSessions as l, toolById as lt, renameSession as m, TMUX_SOCKET as mt, clearTmuxStarted as n, ghKnownHosts as nt, getSession as o, DEFAULT_GITHUB_HOST as ot, panePids as p, workspacePath as pt, disabledAgents as q, createSession as r, miseVersions as rt, killSession as s, TOOLS as st, cleanEnv as t, doctor as tt, markTmuxStarted as u, all as ut, tmuxWasStarted as v, tmux as vt, agentFamily as w, reportsWorking as x, AGENTS as y, config as yt, pushPublicKey as z };
+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 _, git as _t, ensureTmuxServer as a, which as at, readHookPayload as b, config as bt, killWorkspaceSessions as c, agentById as ct, newSessionArgs as d, all as dt, discoverAgents as et, notifySessionsChanged as f, db as ft, sessionStates as g, gh as gt, sendToSession as h, TMUX_SOCKET as ht, disposeSessions as i, setupPath as it, setSessionViewers as j, setAgentPhase as k, listSessions as l, agentLabel$1 as lt, renameSession as m, workspacePath as mt, clearTmuxStarted as n, ghKnownHosts as nt, getSession as o, DEFAULT_GITHUB_HOST as ot, panePids as p, get as pt, disabledAgents as q, createSession as r, miseVersions as rt, killSession as s, TOOLS as st, cleanEnv as t, doctor as tt, markTmuxStarted as u, toolById as ut, tmuxWasStarted as v, run$1 as vt, agentFamily as w, reportsWorking as x, AGENTS as y, tmux as yt, pushPublicKey as z };