@dylanpiercey/work 0.0.119 → 0.0.121

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/{_BOIUqihs.js → _CivNK9fo.js}

@@ -1594,6 +1594,9 @@ function _attr_details_or_dialog_open(scopeId, nodeAccessor, open, openChange, s
 	let normalizedOpen = isNotVoid(open);
 	return openChange && writeControlledScope(4, scopeId, nodeAccessor, normalizedOpen || void 0, openChange, serializeType), normalizedOpen ? " open" : "";
 }
+function _attr_nonce() {
+	return getChunk().boundary.state.nonceAttr;
+}
 function _attr(name, value) {
 	return isVoid(value) ? "" : nonVoidAttr(name, value);
 }
@@ -1975,7 +1978,7 @@ var toastTitle = {
 };
 //#endregion
 //#region src/tags/icons/icon-base.marko
-var icon_base_default = _template("M", (input) => {
+var icon_base_default = _template("N", (input) => {
 	const $scope0_reason = _scope_reason();
 	const $scope0_id = _scope_id();
 	const size = input.size ?? 15;
@@ -1984,7 +1987,7 @@ var icon_base_default = _template("M", (input) => {
 });
 //#endregion
 //#region src/tags/icons/icon-xmark.marko
-var icon_xmark_default = _template("lb", (input) => {
+var icon_xmark_default = _template("nb", (input) => {
 	const $scope0_reason = _scope_reason(), $sg__input_size__OR__input_class = _serialize_guard($scope0_reason, 0);
 	const $scope0_id = _scope_id();
 	_set_serialize_reason({
@@ -2001,7 +2004,7 @@ var icon_xmark_default = _template("lb", (input) => {
 });
 //#endregion
 //#region src/tags/toast.marko
-var toast_default = _template("C", (input) => {
+var toast_default = _template("D", (input) => {
 	const $scope0_reason = _scope_reason(), $sg__input_title = _serialize_guard($scope0_reason, 7), $sg__input_title__OR__input_content__OR__input_action__OR__input_onDismiss = _serialize_guard($scope0_reason, 5), $sg__input_content = _serialize_guard($scope0_reason, 8), $sg__input_action = _serialize_guard($scope0_reason, 9), $sg__input_action__OR__input_onDismiss = _serialize_guard($scope0_reason, 3), $sg__input_onDismiss = _serialize_guard($scope0_reason, 11), $si__input_content = _serialize_if($scope0_reason, 8), $si__input_action__OR__input_onDismiss = _serialize_if($scope0_reason, 3), $si__input_action_content = _serialize_if($scope0_reason, 10);
 	const $scope0_id = _scope_id();
 	const $input_action_content__closures = /* @__PURE__ */ new Set();
@@ -2058,7 +2061,7 @@ var toast_default = _template("C", (input) => {
 					_html(`<button${_attr_class([iconBtnRow, "_bm"])} type=button title=Dismiss aria-label=Dismiss>`);
 					icon_xmark_default({ size: 14 });
 					_html(`</button>${_el_resume($scope5_id, "a")}`);
-					_script($scope5_id, "C0");
+					_script($scope5_id, "D0");
 					writeScope($scope5_id, { _: _scope_with_id($scope3_id) });
 					return 0;
 				}
@@ -2069,8 +2072,8 @@ var toast_default = _template("C", (input) => {
 		}
 	}, $scope0_id, "e", $sg__input_action__OR__input_onDismiss, $sg__input_action__OR__input_onDismiss, $sg__input_title__OR__input_content__OR__input_action__OR__input_onDismiss, 0, 1);
 	_html(`</div>${_el_resume($scope0_id, "a")}`);
-	_script($scope0_id, "C1");
-	_script($scope0_id, "C2");
+	_script($scope0_id, "D1");
+	_script($scope0_id, "D2");
 	writeScope($scope0_id, {
 		j: _serialize_if($scope0_reason, 7) && title,
 		k: _serialize_if($scope0_reason, 0) && inputClass,
@@ -2128,8 +2131,7 @@ function diffTreeOpen() {
 }
 function diffScope() {
 	const v = get("diff-scope");
-	if (v === "working" || v === "dirty") return v;
-	return get("diff-uncommitted") === "1" ? "working" : "committed";
+	return v === "working" || v === "dirty" ? v : "committed";
 }
 function setDiffScope(scope) {
 	set("diff-scope", scope);
@@ -2176,7 +2178,7 @@ var row = "_bB _bt";
 var iconBtn = "_Z _j";
 //#endregion
 //#region src/tags/icons/icon-refresh.marko
-var icon_refresh_default = _template("db", (input) => {
+var icon_refresh_default = _template("fb", (input) => {
 	const $scope0_reason = _scope_reason(), $sg__input_size__OR__input_class = _serialize_guard($scope0_reason, 0);
 	const $scope0_id = _scope_id();
 	_set_serialize_reason({
@@ -2193,7 +2195,7 @@ var icon_refresh_default = _template("db", (input) => {
 });
 //#endregion
 //#region src/tags/icons/icon-back.marko
-var icon_back_default = _template("L", (input) => {
+var icon_back_default = _template("M", (input) => {
 	const $scope0_reason = _scope_reason(), $sg__input_size__OR__input_class = _serialize_guard($scope0_reason, 0);
 	const $scope0_id = _scope_id();
 	_set_serialize_reason({
@@ -2210,7 +2212,7 @@ var icon_back_default = _template("L", (input) => {
 });
 //#endregion
 //#region src/tags/icons/icon-chevron-right.marko
-var icon_chevron_right_default = _template("R", (input) => {
+var icon_chevron_right_default = _template("S", (input) => {
 	const $scope0_reason = _scope_reason(), $sg__input_size__OR__input_class = _serialize_guard($scope0_reason, 0);
 	const $scope0_id = _scope_id();
 	_set_serialize_reason({
@@ -2227,7 +2229,7 @@ var icon_chevron_right_default = _template("R", (input) => {
 });
 //#endregion
 //#region src/tags/icons/icon-arrow-up.marko
-var icon_arrow_up_default = _template("K", (input) => {
+var icon_arrow_up_default = _template("L", (input) => {
 	const $scope0_reason = _scope_reason(), $sg__input_size__OR__input_class = _serialize_guard($scope0_reason, 0);
 	const $scope0_id = _scope_id();
 	_set_serialize_reason({
@@ -2244,7 +2246,7 @@ var icon_arrow_up_default = _template("K", (input) => {
 });
 //#endregion
 //#region src/tags/icons/icon-search.marko
-var icon_search_default = _template("eb", (input) => {
+var icon_search_default = _template("gb", (input) => {
 	const $scope0_reason = _scope_reason(), $sg__input_size__OR__input_class = _serialize_guard($scope0_reason, 0);
 	const $scope0_id = _scope_id();
 	_set_serialize_reason({
@@ -2303,7 +2305,7 @@ function fuzzy(query, text) {
 }
 //#endregion
 //#region src/tags/icons/icon-sidebar.marko
-var icon_sidebar_default = _template("hb", (input) => {
+var icon_sidebar_default = _template("jb", (input) => {
 	const $scope0_reason = _scope_reason(), $sg__input_size__OR__input_class = _serialize_guard($scope0_reason, 0);
 	const $scope0_id = _scope_id();
 	_set_serialize_reason({
@@ -2318,11 +2320,11 @@ var icon_sidebar_default = _template("hb", (input) => {
 	});
 	_serialize_if($scope0_reason, 0) && writeScope($scope0_id, { a: _existing_scope($childScope) });
 });
-var findInput = "_gc _l";
-var findIconBtn = "_gf _j";
+var findInput = "_f9 _l";
+var findIconBtn = "_gb _j";
 //#endregion
 //#region src/tags/icons/icon-arrow-down.marko
-var icon_arrow_down_default = _template("H", (input) => {
+var icon_arrow_down_default = _template("I", (input) => {
 	const $scope0_reason = _scope_reason(), $sg__input_size__OR__input_class = _serialize_guard($scope0_reason, 0);
 	const $scope0_id = _scope_id();
 	_set_serialize_reason({
@@ -2338,4 +2340,4 @@ var icon_arrow_down_default = _template("H", (input) => {
 	_serialize_if($scope0_reason, 0) && writeScope($scope0_id, { a: _existing_scope($childScope) });
 });
 //#endregion
-export { _attrs_partial as $, parseRepoUrl as A, _var as At, metaTrunc as B, setWorkspaceTab as C, _serialize_guard as Ct, toast_default as D, _template as Dt, workspaceTab as E, _subscribe as Et, btnSm as F, _attr_class as G, tone as H, iconBtnLg as I, _attr_option_value as J, _attr_details_or_dialog_open as K, iconBtnRow as L, repoWebUrl as M, forOf as Mt, setPrimaryHost as N, withPageAssets as Nt, icon_xmark_default as O, _to_text as Ot, btnLg as P, writeScope as Pt, _attrs as Q, iconBtnXs as R, setTheme as S, _sep as St, theme as T, _set_serialize_reason as Tt, $global as U, phase as V, _attr as W, _attr_select_value as X, _attr_or as Y, _attr_style as Z, diffScope as _, _resume_branch as _t, fuzzy as a, _el_resume as at, setDiffPos as b, _scope_with_id as bt, icon_arrow_up_default as c, _flush_head as ct, icon_refresh_default as d, _hoist_read_error as dt, _content as et, iconBtn as f, _html as ft, diffPos as g, _resume as gt, diffFilter as h, _peek_scope_id as ht, icon_sidebar_default as i, _el_read_error as it, repoLabel as j, attrTag as jt, icon_base_default as k, _trailers as kt, icon_chevron_right_default as l, _for_of as lt, sectionCount as m, _if as mt, findIconBtn as n, _dynamic_tag as nt, rankRepos as o, _escape as ot, row as p, _id as pt, _attr_input_value as q, findInput as r, _el as rt, icon_search_default as s, _existing_scope as st, icon_arrow_down_default as t, _content_resume as tt, icon_back_default as u, _hoist as ut, diffTreeOpen as v, _scope_id as vt, sideNavOpen as w, _serialize_if as wt, setDiffScope as x, _script as xt, ignoredSsoOrgs as y, _scope_reason as yt, inputLg as z };
+export { _attr_style as $, parseRepoUrl as A, _subscribe as At, metaTrunc as B, setWorkspaceTab as C, _scope_reason as Ct, toast_default as D, _serialize_guard as Dt, workspaceTab as E, _sep as Et, btnSm as F, attrTag as Ft, _attr_class as G, tone as H, iconBtnLg as I, forOf as It, _attr_input_value as J, _attr_details_or_dialog_open as K, iconBtnRow as L, withPageAssets as Lt, repoWebUrl as M, _to_text as Mt, setPrimaryHost as N, _trailers as Nt, icon_xmark_default as O, _serialize_if as Ot, btnLg as P, _var as Pt, _attr_select_value as Q, iconBtnXs as R, writeScope as Rt, setTheme as S, _scope_id as St, theme as T, _script as Tt, $global as U, phase as V, _attr as W, _attr_option_value as X, _attr_nonce as Y, _attr_or as Z, diffScope as _, _id as _t, fuzzy as a, _dynamic_tag as at, setDiffPos as b, _resume as bt, icon_arrow_up_default as c, _el_resume as ct, icon_refresh_default as d, _existing_scope as dt, _attr_textarea_value as et, iconBtn as f, _flush_head as ft, diffPos as g, _html as gt, diffFilter as h, _hoist_read_error as ht, icon_sidebar_default as i, _content_resume as it, repoLabel as j, _template as jt, icon_base_default as k, _set_serialize_reason as kt, icon_chevron_right_default as l, _escape as lt, sectionCount as m, _hoist as mt, findIconBtn as n, _attrs_partial as nt, rankRepos as o, _el as ot, row as p, _for_of as pt, _attr_input_checked as q, findInput as r, _content as rt, icon_search_default as s, _el_read_error as st, icon_arrow_down_default as t, _attrs as tt, icon_back_default as u, _escape_script as ut, diffTreeOpen as v, _if as vt, sideNavOpen as w, _scope_with_id as wt, setDiffScope as x, _resume_branch as xt, ignoredSsoOrgs as y, _peek_scope_id as yt, inputLg as z };

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 };