watch-tail 0.9.0 → 0.10.1

package/build/server/chunks/chunks/{archive.js-D2jtMmDo.js → archive.js-D7cGVWaq.js}

@@ -1,11 +1,11 @@
 import { r as resolveAwsConfig, c as createStsClient, p as parseRegionParam } from './env2.js-C5BgBJDY.js';
 import { g as getCallerIdentityWith } from './identity.js-NmGXxBz3.js';
-import { d as detectRequestId, a as detectLevelWithSource, e as eventDurationMs, i as isLogLevel, L as LEVEL_RANK } from './log-buffer.js-A9FA-Qv8.js';
+import { d as detectRequestId, a as detectLevelWithSource, e as eventDurationMs, i as isLogLevel, L as LEVEL_RANK } from './log-buffer.js-BjT3sJlh.js';
 import { mkdirSync, statSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { resolve, join, dirname } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
-import { setTimeout } from 'node:timers/promises';
+import { setTimeout as setTimeout$1 } from 'node:timers/promises';
 
 //#region src/lib/server/archive-location.ts
 /** Account/region archive routing. Cached identities are for offline reads only. */
@@ -130,6 +130,13 @@ var ARCHIVE_SCHEMA = [
 	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS level_source VARCHAR`,
 	`ALTER TABLE log_events ADD COLUMN IF NOT EXISTS request_id VARCHAR`,
 	`CREATE TABLE IF NOT EXISTS archive_meta (key VARCHAR PRIMARY KEY, value VARCHAR)`,
+	`CREATE TABLE IF NOT EXISTS archive_coverage (
+		region VARCHAR NOT NULL,
+		log_group VARCHAR NOT NULL,
+		start_ms BIGINT NOT NULL,
+		end_ms BIGINT NOT NULL
+	)`,
+	`CREATE INDEX IF NOT EXISTS archive_coverage_key ON archive_coverage (region, log_group, start_ms)`,
 	`CREATE UNIQUE INDEX IF NOT EXISTS log_events_unique ON log_events (region, log_group, event_key)`,
 	`CREATE INDEX IF NOT EXISTS log_events_time ON log_events (region, log_group, timestamp_ms)`
 ];
@@ -345,6 +352,160 @@ function rowsToGroups(rows) {
 	}
 	return groups;
 }
+/** Drops intervals that are not a usable, ordered range. */
+function isUsableInterval(interval) {
+	return Number.isFinite(interval.start) && Number.isFinite(interval.end) && interval.end >= interval.start;
+}
+/**
+* Merges overlapping or adjacent intervals into the fewest ranges.
+*
+* Adjacency counts (`next.start === current.end + 1`) so two scans that met
+* exactly leave one range rather than two, which keeps the table small. The
+* input is not mutated.
+*/
+function mergeCoverage(intervals) {
+	const sorted = intervals.filter(isUsableInterval).map((interval) => ({
+		start: interval.start,
+		end: interval.end
+	})).toSorted((a, b) => a.start - b.start || a.end - b.end);
+	const merged = [];
+	for (const interval of sorted) {
+		const last = merged.at(-1);
+		if (last !== void 0 && interval.start <= last.end + 1) {
+			if (interval.end > last.end) last.end = interval.end;
+		} else merged.push(interval);
+	}
+	return merged;
+}
+/** The parts of `[start, end]` that `intervals` do cover, clipped to the range. */
+function intersectCoverage(start, end, intervals) {
+	const covered = [];
+	for (const interval of mergeCoverage(intervals)) {
+		const clippedStart = Math.max(start, interval.start);
+		const clippedEnd = Math.min(end, interval.end);
+		if (clippedStart <= clippedEnd) covered.push({
+			start: clippedStart,
+			end: clippedEnd
+		});
+	}
+	return covered;
+}
+/** The parts of `[start, end]` that `intervals` do not cover, in order. */
+function subtractCoverage(start, end, intervals) {
+	const uncovered = [];
+	let cursor = start;
+	for (const interval of mergeCoverage(intervals)) {
+		if (interval.end < cursor) continue;
+		if (interval.start > end) break;
+		if (interval.start > cursor) uncovered.push({
+			start: cursor,
+			end: interval.start - 1
+		});
+		cursor = Math.max(cursor, interval.end + 1);
+		if (cursor > end) return uncovered;
+	}
+	if (cursor <= end) uncovered.push({
+		start: cursor,
+		end
+	});
+	return uncovered;
+}
+/**
+* How long CloudWatch is given to finish ingesting a moment before a read of it
+* counts as complete.
+*
+* Events can be ingested well after their timestamp (agents batch and retry), so
+* a range read at time `t` is only trusted up to `t - COVERAGE_SETTLE_MS`. The
+* rest of the range is left uncovered and is fetched from CloudWatch again next
+* time, which is what keeps a late event from being hidden behind the archive.
+*/
+var COVERAGE_SETTLE_MS = 3e5;
+/**
+* The part of a read range that had settled when it was read, or `null`.
+*
+* `readAt` is when the CloudWatch query started: anything newer than
+* `readAt - settleMs` may still have been arriving.
+*/
+function settleCoverage(interval, readAt, settleMs = COVERAGE_SETTLE_MS) {
+	const settled = {
+		start: interval.start,
+		end: Math.min(interval.end, readAt - settleMs)
+	};
+	return isUsableInterval(settled) ? settled : null;
+}
+/** Reads the coverage intervals of several groups that overlap a window. */
+function buildCoverageQuery(region, logGroups, start, end) {
+	const groups = logGroups.length > 0 ? logGroups : [""];
+	return {
+		sql: `SELECT log_group, start_ms, end_ms FROM archive_coverage WHERE region = ? AND log_group IN (${groups.map(() => "?").join(", ")}) AND end_ms >= ? AND start_ms <= ? ORDER BY log_group, start_ms`,
+		params: [
+			region,
+			...groups,
+			BigInt(Math.round(start)),
+			BigInt(Math.round(end))
+		]
+	};
+}
+/** Maps rows of `start_ms`/`end_ms` onto coverage intervals. */
+function rowsToCoverage(rows) {
+	const intervals = [];
+	for (const row of rows) {
+		const start = toNumber(pick(row, "start_ms"));
+		const end = toNumber(pick(row, "end_ms"));
+		if (start !== null && end !== null) intervals.push({
+			start,
+			end
+		});
+	}
+	return intervals;
+}
+/** Maps {@link buildCoverageQuery} rows onto merged intervals per log group. */
+function rowsToCoverageByGroup(rows) {
+	const byGroup = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const group = pick(row, "log_group");
+		const start = toNumber(pick(row, "start_ms"));
+		const end = toNumber(pick(row, "end_ms"));
+		if (typeof group !== "string" || start === null || end === null) continue;
+		const list = byGroup.get(group);
+		if (list === void 0) byGroup.set(group, [{
+			start,
+			end
+		}]);
+		else list.push({
+			start,
+			end
+		});
+	}
+	for (const [group, intervals] of byGroup) byGroup.set(group, mergeCoverage(intervals));
+	return byGroup;
+}
+/** Every coverage interval of one group, for a merge-on-write. */
+function buildCoverageGroupQuery(region, logGroup) {
+	return {
+		sql: "SELECT start_ms, end_ms FROM archive_coverage WHERE region = ? AND log_group = ? ORDER BY start_ms",
+		params: [region, logGroup]
+	};
+}
+/** Removes every coverage interval of one group, before the merged set is written. */
+function buildCoverageDeleteQuery(region, logGroup) {
+	return {
+		sql: "DELETE FROM archive_coverage WHERE region = ? AND log_group = ?",
+		params: [region, logGroup]
+	};
+}
+/** Builds a multi-row insert of coverage intervals. */
+function buildCoverageInsert(rowCount) {
+	if (!Number.isInteger(rowCount) || rowCount < 1) throw new RangeError(`rowCount must be a positive integer, received ${String(rowCount)}`);
+	const row = "(?, ?, ?, ?)";
+	return `INSERT INTO archive_coverage (region, log_group, start_ms, end_ms) VALUES ${Array.from({ length: rowCount }, () => row).join(", ")}`;
+}
+/** Flattens merged intervals into the parameters {@link buildCoverageInsert} expects. */
+function toCoverageParams(region, logGroup, intervals) {
+	const params = [];
+	for (const interval of intervals) params.push(region, logGroup, BigInt(Math.round(interval.start)), BigInt(Math.round(interval.end)));
+	return params;
+}
 /**
 * Row budget of one request-id backfill pass.
 *
@@ -672,6 +833,17 @@ function resolveArchiveConfig(env, platform = process.platform, home = homedir()
 	};
 }
 /**
+* Idle milliseconds after which the archive file is released, from
+* `WATCH_TAIL_ARCHIVE_IDLE_MS`; `0` (the default) keeps it open.
+*
+* `watch-tail mcp` sets it for its private server, so an agent session does not
+* hold DuckDB's single-process lock for as long as the agent runs.
+*/
+function archiveIdleReleaseMs(env) {
+	const parsed = Number(env.WATCH_TAIL_ARCHIVE_IDLE_MS?.trim() ?? "");
+	return Number.isFinite(parsed) && parsed > 0 ? Math.round(parsed) : 0;
+}
+/**
 * A short, non-throwing description of an unknown failure.
 *
 * A conflicting lock is the one failure a user can act on, and DuckDB's own
@@ -700,9 +872,18 @@ var LogArchive = class LogArchive {
 	/** Database file this archive uses. */
 	path;
 	#connection = null;
+	#instance = null;
+	#driver = null;
 	#available = false;
 	#error = null;
 	#queue = Promise.resolve();
+	/** Idle time before the file is released, or 0 to keep it open. */
+	#idleReleaseMs = 0;
+	#idleTimer;
+	/** Statements queued or running, so the file is only released when none are. */
+	#pending = 0;
+	/** True while the file is closed by the idle release, to be reopened on demand. */
+	#released = false;
 	constructor(path) {
 		this.path = path;
 	}
@@ -718,20 +899,14 @@ var LogArchive = class LogArchive {
 		const archive = new LogArchive(options.path);
 		const load = options.load ?? loadDuckDbDriver;
 		const ensureDir = options.ensureDir ?? ((dir) => mkdirSync(dir, { recursive: true }));
+		const idle = options.idleReleaseMs ?? 0;
+		archive.#idleReleaseMs = Number.isFinite(idle) && idle > 0 ? Math.round(idle) : 0;
 		try {
 			ensureDir(dirname(options.path));
-			const driver = await load();
-			for (let attempt = 1;; attempt += 1) try {
-				const connection = await (await driver.DuckDBInstance.create(options.path)).connect();
-				for (const statement of ARCHIVE_SCHEMA) await connection.run(statement);
-				archive.#connection = connection;
-				archive.#available = true;
-				await archive.#backfillRequestIds();
-				break;
-			} catch (error) {
-				if (attempt >= 3 || !isLockError(error)) throw error;
-				await setTimeout(150);
-			}
+			archive.#driver = await load();
+			await archive.#connect();
+			archive.#available = true;
+			await archive.#backfillRequestIds();
 		} catch (error) {
 			archive.#available = false;
 			archive.#error = describeOpenError(error, options.path);
@@ -758,6 +933,51 @@ var LogArchive = class LogArchive {
 	get error() {
 		return this.#error;
 	}
+	/**
+	* Opens the file and brings it up to the current schema.
+	*
+	* Used by the first open and by a reopen after an idle release. A lock held by
+	* a process that is just exiting is retried briefly; any other failure throws.
+	*/
+	async #connect() {
+		const driver = this.#driver;
+		if (driver === null) throw new Error("the DuckDB driver is not loaded");
+		for (let attempt = 1;; attempt += 1) try {
+			const instance = await driver.DuckDBInstance.create(this.path);
+			const connection = await instance.connect();
+			for (const statement of ARCHIVE_SCHEMA) await connection.run(statement);
+			this.#instance = instance;
+			this.#connection = connection;
+			this.#released = false;
+			return;
+		} catch (error) {
+			if (attempt >= 3 || !isLockError(error)) throw error;
+			await setTimeout$1(150);
+		}
+	}
+	/** Closes the connection and the database, which releases the file lock. */
+	#disconnect() {
+		const connection = this.#connection;
+		const instance = this.#instance;
+		this.#connection = null;
+		this.#instance = null;
+		connection?.closeSync?.();
+		instance?.closeSync?.();
+	}
+	/** Arms the idle release once nothing is queued. */
+	#scheduleRelease() {
+		if (this.#idleReleaseMs === 0 || this.#pending > 0 || this.#connection === null) return;
+		clearTimeout(this.#idleTimer);
+		this.#idleTimer = setTimeout(() => {
+			this.#idleTimer = void 0;
+			this.#enqueue(async () => {
+				if (this.#pending > 0 || this.#connection === null) return;
+				this.#disconnect();
+				this.#released = true;
+			});
+		}, this.#idleReleaseMs);
+		this.#idleTimer.unref?.();
+	}
 	/** Runs one task after every task queued before it. */
 	#enqueue(task) {
 		const next = this.#queue.then(task, task);
@@ -766,13 +986,20 @@ var LogArchive = class LogArchive {
 	}
 	/** Runs a statement, returning the failure instead of throwing. */
 	async #guard(fallback, task) {
-		if (this.#connection === null) return fallback;
+		if (this.#connection === null && !this.#released) return fallback;
+		this.#pending += 1;
+		clearTimeout(this.#idleTimer);
+		this.#idleTimer = void 0;
 		return this.#enqueue(async () => {
 			try {
+				if (this.#connection === null && this.#released) await this.#connect();
 				return await task();
 			} catch (error) {
-				this.#error = error instanceof Error ? error.message : String(error);
+				this.#error = describeOpenError(error, this.path);
 				return fallback;
+			} finally {
+				this.#pending -= 1;
+				this.#scheduleRelease();
 			}
 		});
 	}
@@ -810,11 +1037,12 @@ var LogArchive = class LogArchive {
 		});
 	}
 	/**
-	* Writes one batch of streamed events.
+	* Writes one batch of streamed events, answering how many rows were written.
 	*
 	* Batches are split into chunks of {@link ARCHIVE_INSERT_CHUNK} rows, and
 	* `INSERT OR IGNORE` plus the unique index make a repeated scan idempotent.
-	* Failures never propagate: a full disk must not interrupt a log stream.
+	* Failures never propagate: a full disk must not interrupt a log stream. A
+	* failed write answers `0`, so a caller can tell it from a stored batch.
 	*/
 	async record(region, logGroup, events) {
 		if (events.length === 0) return 0;
@@ -830,18 +1058,28 @@ var LogArchive = class LogArchive {
 			return written;
 		});
 	}
-	/** Reads one page of archived events. */
+	/**
+	* Reads one page of archived events.
+	*
+	* A read that fails answers an empty page with `error` set, so a replay can
+	* report the failure instead of mistaking it for the end of the window.
+	*/
 	async page(request) {
-		const empty = {
-			events: [],
-			last: null
-		};
-		return this.#guard(empty, async () => {
+		const page = await this.#guard(null, async () => {
 			const connection = this.#connection;
-			if (connection === null) return empty;
+			if (connection === null) return {
+				events: [],
+				last: null
+			};
 			const { sql, params } = buildPageQuery(request);
 			return rowsToPage((await connection.runAndReadAll(sql, params)).getRowObjects());
 		});
+		if (page !== null) return page;
+		return {
+			events: [],
+			last: null,
+			...this.#available ? { error: this.#error ?? "the archive could not be read" } : {}
+		};
 	}
 	/**
 	* Bucketed counts for the chart, per group and level.
@@ -874,6 +1112,61 @@ var LogArchive = class LogArchive {
 			return rowsToGroups((await connection.runAndReadAll(sql, params)).getRowObjects());
 		});
 	}
+	/**
+	* The ranges this archive is known to hold, per log group, within a window.
+	*
+	* Coverage is what makes a historic view able to read from the archive
+	* instead of CloudWatch: it says which ranges watch-tail has already queried
+	* and archived, so the request only has to ask AWS for the rest. An
+	* unavailable archive answers an empty map, which sends the caller back to
+	* CloudWatch for everything.
+	*/
+	async coverage(region, logGroups, start, end) {
+		return this.#guard(/* @__PURE__ */ new Map(), async () => {
+			const connection = this.#connection;
+			if (connection === null) return /* @__PURE__ */ new Map();
+			const { sql, params } = buildCoverageQuery(region, logGroups, start, end);
+			return rowsToCoverageByGroup((await connection.runAndReadAll(sql, params)).getRowObjects());
+		});
+	}
+	/**
+	* Records the ranges a scan actually queried, merging them into what is known.
+	*
+	* One statement per group rewrites that group's intervals: the existing rows
+	* are merged with the new ranges in JavaScript (which is where the adjacency
+	* and overlap rules live) and written back as a small set. The archive is
+	* single-writer, so this is serialised with the streams that are writing log
+	* rows, and a failure is reported on `error` without interrupting a view.
+	*/
+	async recordCoverage(region, entries) {
+		if (entries.length === 0) return;
+		await this.#guard(void 0, async () => {
+			const connection = this.#connection;
+			if (connection === null) return;
+			const byGroup = /* @__PURE__ */ new Map();
+			for (const entry of entries) {
+				const list = byGroup.get(entry.logGroup);
+				if (list === void 0) byGroup.set(entry.logGroup, [{
+					start: entry.start,
+					end: entry.end
+				}]);
+				else list.push({
+					start: entry.start,
+					end: entry.end
+				});
+			}
+			for (const [logGroup, intervals] of byGroup) {
+				const query = buildCoverageGroupQuery(region, logGroup);
+				const merged = mergeCoverage([...mergeCoverage(rowsToCoverage((await connection.runAndReadAll(query.sql, query.params)).getRowObjects())), ...intervals]);
+				const removal = buildCoverageDeleteQuery(region, logGroup);
+				await connection.run(removal.sql, removal.params);
+				for (let start = 0; start < merged.length; start += 500) {
+					const chunk = merged.slice(start, start + 500);
+					await connection.run(buildCoverageInsert(chunk.length), toCoverageParams(region, logGroup, chunk));
+				}
+			}
+		});
+	}
 	/** Status for `GET /api/archive`, including the file size on disk. */
 	async status() {
 		const totals = await this.totals();
@@ -891,14 +1184,20 @@ var LogArchive = class LogArchive {
 			totals
 		};
 	}
-	/** Closes the connection. Safe to call twice. */
+	/** Closes the connection and the database file. Safe to call twice. */
 	async close() {
+		clearTimeout(this.#idleTimer);
+		this.#idleTimer = void 0;
 		const connection = this.#connection;
+		const instance = this.#instance;
 		this.#connection = null;
+		this.#instance = null;
 		this.#available = false;
-		if (connection?.closeSync === void 0) return;
+		this.#released = false;
+		if (connection?.closeSync === void 0 && instance?.closeSync === void 0) return;
 		await this.#enqueue(async () => {
-			connection.closeSync?.();
+			connection?.closeSync?.();
+			instance?.closeSync?.();
 		});
 	}
 };
@@ -918,14 +1217,15 @@ async function getArchive(env, selection = {}, load) {
 	path = resolve(path);
 	let archive = sharedArchives.get(path);
 	if (!archive) {
+		const idleReleaseMs = archiveIdleReleaseMs(env);
 		archive = LogArchive.open({
 			path,
-			...{} 
+			...{} ,
+			...idleReleaseMs === 0 ? {} : { idleReleaseMs }
 		});
 		sharedArchives.set(path, archive);
 	}
 	return archive;
 }
 
-export { getArchive as g };
-//# sourceMappingURL=archive.js-D2jtMmDo.js.map
+export { settleCoverage as a, getArchive as g, intersectCoverage as i, mergeCoverage as m, subtractCoverage as s };

package/build/server/chunks/chunks/env.js-l0sNRNKZ.js

@@ -1,2 +1 @@
 
-//# sourceMappingURL=env.js-l0sNRNKZ.js.map

package/build/server/chunks/chunks/env2.js-C5BgBJDY.js

@@ -319,4 +319,3 @@ function readEnv() {
 }
 
 export { REGION_PARAM_HINT as R, apiError as a, readEnv as b, createStsClient as c, createLogsClient as d, resolveEffectiveRegion as e, describeAwsError as f, parseRegionParam as p, resolveAwsConfig as r };
-//# sourceMappingURL=env2.js-C5BgBJDY.js.map

package/build/server/chunks/chunks/{exports.js-ClPPfcHj.js → exports.js-CvFPPbaH.js}

@@ -1,8 +1,3 @@
-//#region node_modules/.pnpm/@sveltejs+kit@2.70.3_@sveltejs+vite-plugin-svelte@7.3.0_svelte@5.57.0_vite@8.2.2_@types_ab6e39593f61aae0ad0b9a1bac6935c7/node_modules/@sveltejs/kit/src/utils/url.js
-/**
-* Matches a URI scheme. See https://www.rfc-editor.org/rfc/rfc3986#section-3.1
-* @type {RegExp}
-*/
 var internal = new URL("sveltekit-internal://");
 /**
 * @param {string} base
@@ -265,4 +260,3 @@ var validate_layout_server_exports = validator(valid_layout_server_exports);
 var validate_page_server_exports = validator(valid_page_server_exports);
 
 export { disable_search as a, validate_layout_exports as b, validate_page_server_exports as c, decode_pathname as d, validate_page_exports as e, find_route as f, hash as h, make_trackable as m, normalize_path as n, resolve as r, validate_layout_server_exports as v };
-//# sourceMappingURL=exports.js-ClPPfcHj.js.map

package/build/server/chunks/chunks/identity.js-NmGXxBz3.js

@@ -19,4 +19,3 @@ async function getCallerIdentityWith(client, options = {}) {
 }
 
 export { getCallerIdentityWith as g };
-//# sourceMappingURL=identity.js-NmGXxBz3.js.map