@ghostlytools/cli 1.3.0 → 1.3.2

package/dist/assets/{host-Cmd205Dc.js → host-C7hA-Za7.js}

@@ -1,13 +1,12 @@
-import { jt as fromBase64Url } from "./groupFiles-DBbjOLuD.js";
-import { Ba as callRtcConfig, Gr as checkPushEndpoint, Ha as extractParamsFromSdp, Ia as CALL_SIGNAL_MAX_AGE_MS, La as RTC_CONFIG, Ra as answersOffer, Ua as parseCallSignal, Us as setLinkTraceSink, Va as callSignalHeardAt, Wa as signalHasVideo, hi as isPublicAddress, za as buildSdpFromSignal } from "./src-DhfGgAUu.js";
-import { a as fedimintSdkOn, r as irohRelayProblem } from "./irohWeb--YyEA-hX.js";
-import { r as asCliError, t as CliError } from "./errors-my6VJR_0.js";
-import { a as findChat } from "./apiKit-CajiDxdK.js";
-import { _ as flushCardUpdates, c as paymentJson, d as nodeLocalFetch, f as chatJson, g as resumeHolds, h as groupMessageJson, l as reportAppFrames, m as groupJson, p as chatMessageJson, r as callApi, u as servedApps } from "./api-CrxVxtY1.js";
-import { n as RESTORED_MARK, r as acquireLock } from "./profiles-B6F4oa9K.js";
+import { $o as parseCallSignal, Jo as answersOffer, Ko as CALL_SIGNAL_MAX_AGE_MS, Qo as extractParamsFromSdp, Xo as callRtcConfig, Yo as buildSdpFromSignal, Zo as callSignalHeardAt, ai as checkPushEndpoint, el as setLinkTraceSink, es as signalHasVideo, ki as isPublicAddress, qo as RTC_CONFIG, yl as fromBase64Url } from "./src-yMUQvdyL.js";
+import { a as fedimintSdkOn, r as irohRelayProblem } from "./irohWeb-BJPk9bMn.js";
+import { r as asCliError, t as CliError } from "./errors-DO5z6h_l.js";
+import { a as findChat } from "./apiKit-DYkVEs6r.js";
+import { _ as flushCardUpdates, c as paymentJson, d as nodeLocalFetch, f as chatJson, g as resumeHolds, h as groupMessageJson, l as reportAppFrames, m as groupJson, p as chatMessageJson, r as callApi, u as servedApps } from "./api-aup3Amud.js";
+import { n as RESTORED_MARK, r as acquireLock } from "./profiles-BHc9pEYg.js";
 import { r as privateFolder, t as ownFolder } from "./privateFolder-Bk9C9oFv.js";
 import { createRequire } from "node:module";
-import { appendFileSync, chmodSync, closeSync, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { appendFileSync, chmodSync, closeSync, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { createHash, randomBytes } from "node:crypto";
@@ -910,8 +909,14 @@ var CallManager = class {
 	calls = /* @__PURE__ */ new Map();
 	/** Per chat: the timestamp of the last signal handled. */
 	lastSignal = /* @__PURE__ */ new Map();
+	/** Per chat: the timestamp of the last signal sent (`stamp`). */
+	lastSent = /* @__PURE__ */ new Map();
 	/** Per chat: the timer that clears the hang-up signal. */
 	clearing = /* @__PURE__ */ new Map();
+	/** Per chat: when this side's last call there ended before it was answered (`CALL_PACE_MS`). */
+	unansweredAt = /* @__PURE__ */ new Map();
+	/** The early answers being made, those of ended calls too (MAX_EARLY_ANSWERS). */
+	makings = /* @__PURE__ */ new Set();
 	auto;
 	configPath;
 	stopping = false;
@@ -924,6 +929,15 @@ var CallManager = class {
 	get now() {
 		return (this.host.now ?? Date.now)();
 	}
+	/**
+	* A new signal's timestamp in a chat: now, or 1 ms after the last one sent there. The contact drops a signal no
+	* newer than the last it heard, so a redial or a hang-up in the same millisecond as the signal before it would be lost.
+	*/
+	stamp(chat) {
+		const ts = Math.max(this.now, (this.lastSent.get(chat) ?? 0) + 1);
+		this.lastSent.set(chat, ts);
+		return ts;
+	}
 	/** A signal the contact's app sent in a chat (the engine's `call-signal`). */
 	onSignal(chat, json) {
 		if (this.stopping) return;
@@ -1035,7 +1049,7 @@ var CallManager = class {
 		try {
 			const stack = await this.stack();
 			if (!await this.connect(call, (media) => CallMedia.offer(stack, media))) return;
-			call.offerTs = this.now;
+			call.offerTs = this.stamp(call.chat);
 			call.offering = true;
 			await this.send(call.chat, {
 				t: "o",
@@ -1059,7 +1073,7 @@ var CallManager = class {
 			if (!await this.connect(call, (media) => CallMedia.answer(stack, offer, media))) return;
 			await this.send(call.chat, {
 				t: "a",
-				ts: this.now,
+				ts: this.stamp(call.chat),
 				o: offer.ts,
 				...call.media.local,
 				v: 0
@@ -1075,11 +1089,15 @@ var CallManager = class {
 	*/
 	prepare(call) {
 		if (this.host.answers === false || call.ended || call.state !== "ringing") return;
+		this.stopEarly(call);
 		call.earlyTimer = setTimeout(() => this.prepare(call), this.host.earlyAnswerMs ?? 3e4);
 		call.earlyTimer.unref?.();
 		if (call.making) return;
+		const held = [...this.calls.values()].filter((c) => c !== call && c.early).length;
+		if (this.makings.size + held >= 4 || [...this.makings].some((m) => m.chat === call.chat)) return;
 		const offer = call.offer;
 		const making = {
+			chat: call.chat,
 			done: this.stack().then((stack) => EarlyAnswer.open(stack, offer, {
 				iceServers: this.host.engine.getState().settings?.iceServers ?? [],
 				log: (line) => process.stderr.write(`ghostly: call ${call.id}: ${line}\n`)
@@ -1091,15 +1109,19 @@ var CallManager = class {
 			claimed: false
 		};
 		call.making = making;
+		this.makings.add(making);
 		making.done.then((early) => {
+			this.makings.delete(making);
 			if (call.making === making) call.making = null;
-			if (making.claimed || !early) return;
-			if (call.ended || call.state !== "ringing") {
-				early.close();
-				return;
+			if (!making.claimed && early) {
+				if (call.ended || call.state !== "ringing") early.close();
+				else {
+					call.early?.close();
+					call.early = early;
+				}
 			}
-			call.early?.close();
-			call.early = early;
+			const next = this.byChat(making.chat);
+			if (next && next !== call && next.direction === "in" && !next.making && !next.early) this.prepare(next);
 		});
 	}
 	/** The answered call's early answer: the one made, if still good, or the one being made; none from then on. */
@@ -1122,6 +1144,7 @@ var CallManager = class {
 	async start(chat, options) {
 		const link = this.callable(chat);
 		if (this.byChat(link.id)) throw new CliError("busy", "A call is already on in this chat");
+		this.paced(link.id);
 		const rate = rateOf(options.rate, this.auto.rate);
 		const stack = await this.stack();
 		if (this.byChat(link.id)) throw new CliError("busy", "A call is already on in this chat");
@@ -1130,7 +1153,7 @@ var CallManager = class {
 			await this.attach(call, (media) => CallMedia.offer(stack, media));
 			if (call.reason === "crossed") throw new CliError("busy", "The contact called at the same time: their call rings here");
 			if (call.ended) throw new CliError("unavailable", "The call ended before it was placed");
-			call.offerTs = this.now;
+			call.offerTs = this.stamp(link.id);
 			call.offering = true;
 			await this.send(link.id, {
 				t: "o",
@@ -1168,7 +1191,7 @@ var CallManager = class {
 			if (call.ended) throw new CliError("unavailable", "The call ended before it was answered");
 			await this.send(call.chat, {
 				t: "a",
-				ts: this.now,
+				ts: this.stamp(call.chat),
 				o: call.offer.ts,
 				...call.media.local,
 				v: 0
@@ -1388,6 +1411,7 @@ var CallManager = class {
 		this.disarm(call);
 		if (call.watcher) clearInterval(call.watcher);
 		this.calls.delete(call.id);
+		if (call.direction === "out" && call.connectedAt === null && call.state === "ringing" && (reason === "hangup" || reason === "unanswered")) this.unansweredAt.set(call.chat, this.now);
 		if (report) process.stderr.write(`ghostly: call ${call.id}: ended (${reason})${call.media ? `, ice ${call.media.ice.state}` : ""}\n`);
 		call.media?.close();
 		this.stopEarly(call);
@@ -1397,7 +1421,7 @@ var CallManager = class {
 		if (tell) {
 			await this.send(call.chat, {
 				t: "h",
-				ts: this.now
+				ts: this.stamp(call.chat)
 			}).catch(() => {});
 			if (!this.stopping) {
 				const timer = setTimeout(() => {
@@ -1416,6 +1440,17 @@ var CallManager = class {
 			...call.connectedAt !== null ? { duration: this.now - call.connectedAt } : {}
 		});
 	}
+	/** Refuses a call placed too soon after this side's last unanswered one in the chat (`CALL_PACE_MS`). */
+	paced(chat) {
+		const pace = this.host.callPaceMs ?? 2e3, last = this.unansweredAt.get(chat);
+		if (!pace || last === void 0) return;
+		const left = last + pace - this.now;
+		if (left <= 0) {
+			this.unansweredAt.delete(chat);
+			return;
+		}
+		throw new CliError("busy", `Your last call in this chat ended unanswered a moment ago: call again in ${Math.ceil(left / 100) / 10} s`, { retryAfterMs: left });
+	}
 	arm(call, ms, reason, tell) {
 		this.disarm(call);
 		call.timer = setTimeout(() => void this.end(call, reason, tell), ms);
@@ -1537,6 +1572,8 @@ function readAuto(path) {
 		return off;
 	}
 }
+/** A journal past this is trimmed, and only this much of its end is ever read. */
+var JOURNAL_MAX_BYTES = 33554432;
 var SEEN_DB = "ghostly-cli";
 var SEEN = "seen";
 /**
@@ -1562,6 +1599,7 @@ var EventHub = class {
 	seenDb;
 	seq = 0;
 	journalLines = 0;
+	journalBytes = 0;
 	listeners = /* @__PURE__ */ new Set();
 	stateListeners = /* @__PURE__ */ new Set();
 	callListeners = /* @__PURE__ */ new Set();
@@ -1598,13 +1636,24 @@ var EventHub = class {
 	}
 	/** Loads the journal's last seq and the seen set; call before `sink` is attached. */
 	async open() {
-		if (existsSync(this.journalPath)) {
-			const lines = readFileSync(this.journalPath, "utf8").split("\n").filter(Boolean);
-			this.journalLines = lines.length;
-			for (let i = lines.length - 1; i >= 0; i--) try {
-				this.seq = JSON.parse(lines[i]).seq;
-				break;
+		try {
+			if (existsSync(this.journalPath)) {
+				const { lines, size } = journalTail(this.journalPath);
+				this.journalLines = lines.length;
+				this.journalBytes = size;
+				for (let i = lines.length - 1; i >= 0; i--) try {
+					this.seq = JSON.parse(lines[i]).seq;
+					break;
+				} catch {}
+				if (size > 33554432 || lines.length > 2e4) this.trimJournal();
+			}
+		} catch (error) {
+			process.stderr.write(`ghostly: the event journal could not be read, a new one begins: ${error instanceof Error ? error.message : String(error)}\n`);
+			try {
+				renameSync(this.journalPath, this.journalPath + ".unreadable");
 			} catch {}
+			this.journalLines = 0;
+			this.journalBytes = 0;
 		}
 		this.db = await new Promise((resolve, reject) => {
 			const request = indexedDB.open(this.seenDb, 1);
@@ -1729,13 +1778,10 @@ var EventHub = class {
 	replay(since) {
 		if (!existsSync(this.journalPath) || since >= this.seq) return [];
 		const out = [];
-		for (const line of readFileSync(this.journalPath, "utf8").split("\n")) {
-			if (!line) continue;
-			try {
-				const event = JSON.parse(line);
-				if (event.seq > since) out.push(event);
-			} catch {}
-		}
+		for (const line of journalTail(this.journalPath).lines) try {
+			const event = JSON.parse(line);
+			if (event.seq > since) out.push(event);
+		} catch {}
 		if (out.length && out[0].seq > since + 1) out.unshift({
 			seq: since,
 			id: `events.gap:${since}:${out[0].seq}`,
@@ -1758,18 +1804,29 @@ var EventHub = class {
 			at: this.now(),
 			...fields
 		};
-		appendFileSync(this.journalPath, JSON.stringify(event) + "\n", { mode: 384 });
-		if (++this.journalLines > 2e4) this.trimJournal();
+		try {
+			const line = JSON.stringify(event) + "\n";
+			appendFileSync(this.journalPath, line, { mode: 384 });
+			this.journalBytes += Buffer.byteLength(line);
+			if (++this.journalLines > 2e4 || this.journalBytes > 33554432) this.trimJournal();
+		} catch (error) {
+			process.stderr.write(`ghostly: event journal error: ${error instanceof Error ? error.message : String(error)}\n`);
+		}
 		for (const listener of this.listeners) try {
 			listener(event);
 		} catch {}
 		return event;
 	}
+	/** Keeps the last `JOURNAL_KEEP` events, and of them no more than `JOURNAL_KEEP_BYTES`. */
 	trimJournal() {
-		const lines = readFileSync(this.journalPath, "utf8").split("\n").filter(Boolean).slice(-1e4);
-		writeFileSync(this.journalPath + ".tmp", lines.join("\n") + "\n", { mode: 384 });
+		const lines = journalTail(this.journalPath).lines.slice(-1e4);
+		let start = lines.length, bytes = 0;
+		while (start > 0 && bytes + Buffer.byteLength(lines[start - 1]) + 1 <= 16777216) bytes += Buffer.byteLength(lines[--start]) + 1;
+		const kept = lines.slice(start);
+		writeFileSync(this.journalPath + ".tmp", kept.length ? kept.join("\n") + "\n" : "", { mode: 384 });
 		renameSync(this.journalPath + ".tmp", this.journalPath);
-		this.journalLines = lines.length;
+		this.journalLines = kept.length;
+		this.journalBytes = bytes;
 	}
 	handle(message) {
 		switch (message.kind) {
@@ -2327,6 +2384,32 @@ function groupShape(group) {
 		pin: group.pin ?? null
 	};
 }
+/**
+* The journal's whole lines within its last `JOURNAL_MAX_BYTES`, and its size: never the whole file as one string, so
+* a journal grown past what a string can hold (or a trim's bound) is still read, and in bounded time.
+*/
+function journalTail(path) {
+	const fd = openSync(path, "r");
+	try {
+		const size = fstatSync(fd).size;
+		const from = Math.max(0, size - JOURNAL_MAX_BYTES - 1);
+		const buffer = Buffer.alloc(size - from);
+		let read = 0;
+		while (read < buffer.length) {
+			const n = readSync(fd, buffer, read, buffer.length - read, from + read);
+			if (!n) break;
+			read += n;
+		}
+		const lines = buffer.toString("utf8", 0, read).split("\n");
+		if (from > 0) lines.shift();
+		return {
+			lines: lines.filter(Boolean),
+			size
+		};
+	} finally {
+		closeSync(fd);
+	}
+}
 //#endregion
 //#region src/runtime/fedimint.ts
 /**
@@ -4358,14 +4441,14 @@ async function startRuntime(paths, options = {}) {
 	(await import("./ghostly_iroh_web-Dvzh3Y6E.js")).initSync({ module: irohWasmBytes() });
 	const [{ registerFileBytes }, { NodeFileBytes }] = await Promise.all([import("./fileBytes-CgbibpbV.js"), import("./fileBytes-CfSXjTFa.js")]);
 	registerFileBytes("native", async () => new NodeFileBytes(paths.files), true);
-	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./server-CBCEYKMN.js"), import("./endpoint-Dn7H8qE1.js")]);
+	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./server-CJNEKxzE.js"), import("./endpoint-BOTFMpfS.js")]);
 	const network = hyperdhtNetwork();
 	const dht = mainlineNetwork();
-	const mainline = dht.off ? null : new (await (import("./mainline-D5D5C-jT.js"))).Mainline({
+	const mainline = dht.off ? null : new (await (import("./mainline-CxbxpoU4.js"))).Mainline({
 		bootstrap: dht.bootstrap,
 		host: dht.host
 	});
-	const transport = mainline || pinned ? new (await (import("./mainline-D5D5C-jT.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
+	const transport = mainline || pinned ? new (await (import("./mainline-CxbxpoU4.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
 	const apps = servedApps(paths.dir).length > 0;
 	const server = new EngineServer({
 		...transport ? { transport } : {},
@@ -4611,6 +4694,16 @@ function connection(ctx, socket) {
 		if (request.method === "events.subscribe") {
 			const params = request.params ?? {};
 			const since = typeof params.since === "number" ? params.since : ctx.hub.lastSeq;
+			let replay;
+			try {
+				replay = ctx.hub.replay(since);
+			} catch (error) {
+				write({
+					id,
+					error: asCliError(error).toJSON()
+				});
+				return;
+			}
 			const queued = [];
 			let replaying = true;
 			unsubscribes.push(ctx.hub.onEvent((event) => {
@@ -4625,7 +4718,7 @@ function connection(ctx, socket) {
 				}
 			});
 			let last = since;
-			for (const event of ctx.hub.replay(since)) {
+			for (const event of replay) {
 				write({ event });
 				last = event.seq;
 			}
@@ -4645,4 +4738,4 @@ function connection(ctx, socket) {
 //#endregion
 export { BASELINE_NEWEST, MAX_LINE, keepServing, openHost, serve };
 
-//# sourceMappingURL=host-Cmd205Dc.js.map
+//# sourceMappingURL=host-C7hA-Za7.js.map