@dylanpiercey/work 0.2.70 → 0.2.72

package/dist/{_CSFzm8Kj.js → _D7kw4Cra.js}

@@ -1,4 +1,4 @@
-import { $ as paneJobs, $n as turnSince, B as killSession, Bn as onFinished, D as agentCaller, En as agentPhase, Hn as onTurnEnd, Kn as setExpecting, M as createSession, Mr as agentChoices, Qn as turnSettling, R as getSession, Rr as getSetting, Sn as cleanSummary, Tn as activityOf, Un as onTurnFailed, Vn as onPhaseChange, W as listPanesWithin, Wn as sessionWatched, X as notifySessionsChanged, Xn as summaryOf, Z as onSessionDispose, Zn as turnPhase, _i as get, _n as steerKeys, at as restartSession, gi as db, hi as all, it as reopenable, j as closedSession, jn as lastTypedAt, kn as hookReportedAt, li as httpError, mn as quotesPastes, nt as renameSession, ot as retireSession, pn as interruptKeys, rr as agentLabel, rt as reopenSession, st as sendToSession, tr as agentFamily, z as interruptSession, zr as isKnownAgent } from "./_DK0sGNuL.js";
+import { An as cleanSummary, B as interruptSession, Br as agentChoices, Ci as all, D as agentCaller, G as listPanesWithin, Jn as onFinished, Kr as getSetting, Ln as hookReportedAt, M as closedTeam, N as createSession, Nn as activityOf, Pn as agentPhase, Q as onSessionDispose, Qn as sessionWatched, Sn as quotesPastes, Ti as get, Tn as steerKeys, V as killSession, Xn as onTurnEnd, Yn as onPhaseChange, Z as notifySessionsChanged, Zn as onTurnFailed, _i as httpError, ar as turnPhase, at as reopenSession, ct as restartPlan, dr as agentLabel, dt as sendToSession, er as setExpecting, et as paneJobs, ir as summaryOf, it as renameSession, j as closedSession, lr as agentFamily, lt as restartSession, mt as setSwitch, or as turnSettling, ot as reopenable, qr as isKnownAgent, rt as pendingSwitches, sr as turnSince, ut as retireSession, wi as db, xn as interruptKeys, z as getSession, zn as lastTypedAt } from "./_Ckb53sPe.js";
 //#region src/server/messages.ts
 var team = {
 	memberGroup: () => null,
@@ -398,17 +398,20 @@ async function pump() {
 	try {
 		for (let i = 0; i < 5; i++) {
 			again = false;
+			const switches = pendingSwitches();
 			const queued = all("SELECT DISTINCT to_session AS id FROM session_messages WHERE delivered_at IS NULL").map((r) => r.id).filter((id) => deliverable(id).length);
-			if (!queued.length) break;
+			if (!queued.length && !switches.length) break;
 			const panes = await listPanesWithin(2e3);
 			if (!panes) break;
 			const running = new Set(panes.map((p) => p.id));
-			for (const id of queued) if (running.has(id)) await deliver(id);
+			if (switches.length) await switchWhenIdle(switches, running);
+			const moving = new Set(pendingSwitches().map((p) => p.id));
+			for (const id of queued) if (running.has(id) && !moving.has(id)) await deliver(id);
 			if (!again) break;
 		}
 	} finally {
 		pumping = false;
-		const waiting = all("SELECT DISTINCT to_session AS id FROM session_messages WHERE delivered_at IS NULL").some((r) => deliverable(r.id).length);
+		const waiting = pendingSwitches().length > 0 || all("SELECT DISTINCT to_session AS id FROM session_messages WHERE delivered_at IS NULL").some((r) => deliverable(r.id).length);
 		if (!retry && waiting) {
 			retry = setTimeout(() => {
 				retry = null;
@@ -509,6 +512,42 @@ async function sendMessage(to, text, opts = {}) {
 		promoted: queued.length
 	};
 }
+/** What a restart of `id` would end now: its turn, a question to the
+* user, the jobs in its pane. */
+async function busyFor(id) {
+	const phase = turnPhase(id);
+	const jobs = await paneJobs(id);
+	return [phase === "waiting" ? "it waits on the user" : (phase || turnSettling(id)) && "its turn is under way", jobs.length && `its pane still runs ${jobs.join("; ")}`].filter((w) => !!w);
+}
+/** Moves each session waiting to (`switch_to`) once a restart ends nothing:
+* its turn's end settled, no question, no job in its pane, nobody typing
+* in it, nothing being typed in. One whose pane is gone is idle already.
+* What is queued for it waits for the move (`pump`), so the new CLI takes
+* it rather than the old one starting a turn the move would end. */
+async function switchWhenIdle(switches, running) {
+	for (const { id, switch_to } of switches) {
+		if (delivering.has(id)) continue;
+		if (running.has(id)) {
+			if (turnPhase(id) || turnSettling(id)) continue;
+			if (Date.now() - lastTypedAt(id) < TYPING_QUIET_MS) continue;
+			if ((await paneJobs(id)).length) continue;
+		}
+		delivering.add(id);
+		try {
+			dropHold(id);
+			steered.delete(id);
+			await restartSession(id, switch_to);
+			failedTold.delete(id);
+			startedAt.set(id, Date.now());
+			console.log(`[work] ${id} moved to ${switch_to}`);
+		} catch (err) {
+			setSwitch(id, null);
+			console.warn(`[work] ${id} could not move to ${switch_to}: ${err.message}`);
+		} finally {
+			delivering.delete(id);
+		}
+	}
+}
 /** Start `id` again on its own conversation (`work session reopen`, a
 * message to one closed for being done): one closed, its row back
 * (`reopenSession`), under `by` when the session that started it is gone;
@@ -519,11 +558,20 @@ async function sendMessage(to, text, opts = {}) {
 * send meanwhile queues behind this rather than starting the CLI afresh. */
 async function reopen(id, opts = {}) {
 	if (delivering.has(id)) throw httpError(409, `${id} is being started or typed into: try again`);
-	if (getSession(id) && !opts.now) {
-		const phase = turnPhase(id);
-		const jobs = await paneJobs(id);
-		const busy = [phase === "waiting" ? "it waits on the user" : (phase || turnSettling(id)) && "its turn is under way", jobs.length && `its pane still runs ${jobs.join("; ")}`].filter(Boolean);
-		if (busy.length) throw httpError(409, `${id} is busy: ${busy.join(", and ")}. Restarting its CLI would end that: reopen it once it is idle, or pass --now to restart it anyway`);
+	if (getSession(id)) {
+		const { next } = restartPlan(id, opts.agent);
+		const self = !!opts.by && opts.by === id;
+		const busy = self ? [] : await busyFor(id);
+		if (self || busy.length && !opts.now) {
+			setSwitch(id, next);
+			kick();
+			return {
+				session: getSession(id),
+				restarted: false,
+				scheduled: next,
+				waits: self ? ["this turn's end"] : busy
+			};
+		}
 	}
 	if (delivering.has(id)) throw httpError(409, `${id} is being started or typed into: try again`);
 	delivering.add(id);
@@ -541,13 +589,54 @@ async function reopen(id, opts = {}) {
 		startedAt.set(id, Date.now());
 		return {
 			session,
-			restarted: !!live
+			restarted: !!live,
+			scheduled: null,
+			waits: []
 		};
 	} finally {
 		delivering.delete(id);
 		kick();
 	}
 }
+/** A closed lead started again with the sessions closed with it (`work
+* session reopen --team`, `closedTeam`), each on its own conversation and
+* under its own parent again, as `agent` too where that is another
+* instance of the member's own CLI (a team moved from one account to
+* another). One that cannot be is skipped, saying why, and those under it
+* come back under the nearest above them that did. No session cap: it
+* brings back what ran, not more. */
+async function reopenTeam(id, opts = {}) {
+	if (getSession(id)) throw httpError(409, `${id} is running: --team reopens a closed lead with the sessions closed with it, and a running one has its team`);
+	if (!closedSession(id)) throw httpError(404, `no session ${id}`);
+	const team = closedTeam(id);
+	const lead = await reopen(id, opts);
+	const reopened = [];
+	const skipped = [];
+	const back = /* @__PURE__ */ new Map([[id, id]]);
+	for (const m of team) {
+		const under = back.get(m.parent_id) ?? id;
+		const sameCli = !!opts.agent && agentFamily(opts.agent) === agentFamily(m.agent);
+		try {
+			await reopen(m.id, {
+				agent: sameCli ? opts.agent : void 0,
+				by: under
+			});
+			reopened.push(m.id);
+			back.set(m.id, m.id);
+		} catch (err) {
+			skipped.push({
+				id: m.id,
+				why: err instanceof Error ? err.message : String(err)
+			});
+			back.set(m.id, under);
+		}
+	}
+	return {
+		...lead,
+		reopened,
+		skipped
+	};
+}
 /** `asker` no longer wants what `to` owes it (`work session forget`): its
 * messages in `to`'s turn stop wanting a reply, so that turn's end answers
 * nobody, and its messages still queued go in wanting none. A reply `to`
@@ -1447,4 +1536,4 @@ function startTeam() {
 	kickPool();
 }
 //#endregion
-export { takeReplies as C, startMessages as S, messageLog as _, createGroup as a, sendMessage as b, kickPool as c, retryMember as d, skipMember as f, holdReply as g, teamsOf as h, closeFinished as i, memberWorkspace as l, teamOf as m, closeBlockers as n, forget as o, startTeam as p, closeDone as r, keepSession as s, clearGroup as t, retire as u, messageStates as v, withdraw as w, sessionGone as x, reopen as y };
+export { startMessages as C, sessionGone as S, withdraw as T, messageLog as _, createGroup as a, reopenTeam as b, kickPool as c, retryMember as d, skipMember as f, holdReply as g, teamsOf as h, closeFinished as i, memberWorkspace as l, teamOf as m, closeBlockers as n, forget as o, startTeam as p, closeDone as r, keepSession as s, clearGroup as t, retire as u, messageStates as v, takeReplies as w, sendMessage as x, reopen as y };