@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/shared-state-board-DV-dpHFJ.mjs

@@ -0,0 +1,586 @@
+import { a as argString, i as argObject, r as argNumber, s as argStringRequired, t as argBool } from "./parse-args-BlRjqlkL.mjs";
+import "./definitions-B3QdlrHv.mjs";
+import { randomUUID } from "node:crypto";
+//#region src/utils/escapeForRegex.ts
+/**
+* Utility: escape a user-provided string for safe use in a RegExp constructor.
+* All regex metacharacters are escaped except `*`, which is preserved for
+* wildcard matching (converted to `.*` by callers).
+*/
+function escapeRegexStr(s) {
+	return s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/server/domains/shared-state-board/handlers/shared.ts
+/**
+* Shared types and state store for shared-state-board sub-handlers.
+*/
+function matchesKeyPattern(key, keyPattern) {
+	if (!keyPattern) return true;
+	return new RegExp(`^${keyPattern.split("*").map((segment) => escapeRegexStr(segment)).join(".*")}$`).test(key);
+}
+var StateBoardStore = class {
+	state = /* @__PURE__ */ new Map();
+	history = /* @__PURE__ */ new Map();
+	watches = /* @__PURE__ */ new Map();
+	maxHistoryPerKey = 100;
+	mutationSeq = 0;
+	lastPersistedSeq = 0;
+	persistNotifier;
+	setPersistNotifier(notify) {
+		this.persistNotifier = notify;
+	}
+	markDirty() {
+		this.mutationSeq++;
+		this.persistNotifier?.();
+	}
+	recordChange(fullKey, record) {
+		this.markDirty();
+		let history = this.history.get(fullKey);
+		if (!history) {
+			history = [];
+			this.history.set(fullKey, history);
+		}
+		history.push(record);
+		if (history.length > this.maxHistoryPerKey) history.splice(0, history.length - this.maxHistoryPerKey);
+	}
+	deleteEntry(fullKey) {
+		const entry = this.state.get(fullKey);
+		if (!entry) return;
+		this.state.delete(fullKey);
+		this.recordChange(fullKey, {
+			id: randomUUID().slice(0, 8),
+			key: entry.key,
+			namespace: entry.namespace,
+			action: "delete",
+			oldValue: entry.value,
+			timestamp: Date.now()
+		});
+	}
+	isExpired(entry) {
+		return !!(entry.expiresAt && Date.now() > entry.expiresAt);
+	}
+	cleanupExpired() {
+		const now = Date.now();
+		let cleaned = 0;
+		for (const [fullKey, entry] of this.state.entries()) if (entry.expiresAt && now > entry.expiresAt) {
+			this.state.delete(fullKey);
+			this.recordChange(fullKey, {
+				id: randomUUID().slice(0, 8),
+				key: entry.key,
+				namespace: entry.namespace,
+				action: "expire",
+				oldValue: entry.value,
+				timestamp: now
+			});
+			cleaned++;
+		}
+		return cleaned;
+	}
+	getSnapshotSeq() {
+		return this.mutationSeq;
+	}
+	getLastPersistedSeq() {
+		return this.lastPersistedSeq;
+	}
+	markPersisted() {
+		this.lastPersistedSeq = this.mutationSeq;
+	}
+	isPersistDirty() {
+		return this.mutationSeq !== this.lastPersistedSeq;
+	}
+	exportSnapshot() {
+		return {
+			schemaVersion: 1,
+			savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			entries: [...this.state.entries()],
+			history: [...this.history.entries()]
+		};
+	}
+	restoreSnapshot(data) {
+		if (!data || typeof data !== "object") return;
+		const snapshot = data;
+		if (snapshot.schemaVersion !== 1) return;
+		const now = Date.now();
+		this.state.clear();
+		this.history.clear();
+		if (snapshot.entries) for (const [key, entry] of snapshot.entries) {
+			if (entry.expiresAt && now > entry.expiresAt) continue;
+			this.state.set(key, entry);
+		}
+		if (snapshot.history) for (const [key, records] of snapshot.history) this.history.set(key, records);
+		this.mutationSeq = this.state.size;
+		this.lastPersistedSeq = this.mutationSeq;
+	}
+};
+//#endregion
+//#region src/server/domains/shared-state-board/handlers/store-handlers.ts
+/**
+* Store sub-handler — set, get, delete, list, clear, stats.
+*/
+var StoreHandlers = class {
+	store;
+	constructor(store) {
+		this.store = store;
+	}
+	async handleSet(args) {
+		const key = argStringRequired(args, "key");
+		if (!key) throw new Error("key must be a non-empty string");
+		const value = args.value;
+		const namespace = argString(args, "namespace", "default");
+		const ttlSeconds = argNumber(args, "ttlSeconds");
+		const fullKey = `${namespace}:${key}`;
+		const now = Date.now();
+		const existing = this.store.state.get(fullKey);
+		const oldVersion = existing?.version ?? 0;
+		const oldValue = existing?.value;
+		const entry = {
+			key,
+			value,
+			namespace,
+			createdAt: existing?.createdAt ?? now,
+			updatedAt: now,
+			ttlSeconds,
+			expiresAt: ttlSeconds ? now + ttlSeconds * 1e3 : void 0,
+			version: oldVersion + 1
+		};
+		this.store.state.set(fullKey, entry);
+		this.store.recordChange(fullKey, {
+			id: randomUUID().slice(0, 8),
+			key,
+			namespace,
+			action: "set",
+			oldValue,
+			newValue: value,
+			timestamp: now
+		});
+		return {
+			success: true,
+			key,
+			namespace,
+			version: entry.version,
+			expiresAt: entry.expiresAt ? new Date(entry.expiresAt).toISOString() : void 0
+		};
+	}
+	async handleGet(args) {
+		const key = argStringRequired(args, "key");
+		if (!key) throw new Error("key must be a non-empty string");
+		const namespace = argString(args, "namespace", "default");
+		const fullKey = `${namespace}:${key}`;
+		const entry = this.store.state.get(fullKey);
+		if (!entry) return {
+			found: false,
+			key,
+			namespace
+		};
+		if (this.store.isExpired(entry)) {
+			this.store.deleteEntry(fullKey);
+			return {
+				found: false,
+				key,
+				namespace,
+				expired: true
+			};
+		}
+		return {
+			found: true,
+			key,
+			namespace,
+			value: entry.value,
+			version: entry.version,
+			createdAt: new Date(entry.createdAt).toISOString(),
+			updatedAt: new Date(entry.updatedAt).toISOString(),
+			ttlSeconds: entry.ttlSeconds,
+			expiresAt: entry.expiresAt ? new Date(entry.expiresAt).toISOString() : void 0
+		};
+	}
+	async handleDelete(args) {
+		const key = argStringRequired(args, "key");
+		if (!key) throw new Error("key must be a non-empty string");
+		const namespace = argString(args, "namespace", "default");
+		const fullKey = `${namespace}:${key}`;
+		if (!this.store.state.get(fullKey)) return {
+			deleted: false,
+			key,
+			namespace,
+			reason: "not_found"
+		};
+		this.store.deleteEntry(fullKey);
+		return {
+			deleted: true,
+			key,
+			namespace
+		};
+	}
+	async handleList(args) {
+		const namespace = argString(args, "namespace");
+		const includeValues = argBool(args, "includeValues", false);
+		const entries = [];
+		const toDelete = [];
+		for (const entry of this.store.state.values()) {
+			if (namespace && entry.namespace !== namespace) continue;
+			if (this.store.isExpired(entry)) {
+				toDelete.push(`${entry.namespace}:${entry.key}`);
+				continue;
+			}
+			entries.push({
+				key: entry.key,
+				namespace: entry.namespace,
+				version: entry.version,
+				updatedAt: new Date(entry.updatedAt).toISOString(),
+				...includeValues ? { value: entry.value } : {}
+			});
+		}
+		for (const fullKey of toDelete) this.store.deleteEntry(fullKey);
+		entries.sort((a, b) => {
+			if (a.namespace !== b.namespace) return a.namespace.localeCompare(b.namespace);
+			return a.key.localeCompare(b.key);
+		});
+		return {
+			entries,
+			total: entries.length,
+			namespaces: [...new Set(entries.map((e) => e.namespace))]
+		};
+	}
+	async handleClear(args) {
+		const namespace = argString(args, "namespace");
+		const keyPattern = argString(args, "keyPattern");
+		const toDelete = [];
+		for (const [fullKey, entry] of this.store.state.entries()) {
+			if (namespace && entry.namespace !== namespace) continue;
+			if (!matchesKeyPattern(entry.key, keyPattern)) continue;
+			toDelete.push(fullKey);
+		}
+		for (const fullKey of toDelete) this.store.deleteEntry(fullKey);
+		return {
+			cleared: toDelete.length,
+			namespace: namespace ?? "all",
+			pattern: keyPattern
+		};
+	}
+	async handleStats() {
+		const now = Date.now();
+		const entriesByNamespace = {};
+		let expiredCount = 0;
+		for (const [, entry] of this.store.state.entries()) {
+			if (entry.expiresAt && now > entry.expiresAt) {
+				expiredCount++;
+				continue;
+			}
+			entriesByNamespace[entry.namespace] = (entriesByNamespace[entry.namespace] ?? 0) + 1;
+		}
+		let historySize = 0;
+		for (const records of this.store.history.values()) historySize += records.length;
+		return {
+			totalEntries: Object.values(entriesByNamespace).reduce((a, b) => a + b, 0),
+			entriesByNamespace,
+			expiredEntries: expiredCount,
+			totalWatches: this.store.watches.size,
+			historySize
+		};
+	}
+};
+//#endregion
+//#region src/server/domains/shared-state-board/handlers/watch-handlers.ts
+/**
+* Watch sub-handler — watch, unwatch, poll.
+*/
+var WatchHandlers = class {
+	store;
+	constructor(store) {
+		this.store = store;
+	}
+	async handleWatch(args) {
+		const key = argStringRequired(args, "key");
+		if (!key) throw new Error("key must be a non-empty string");
+		const namespace = argString(args, "namespace", "default");
+		const pollIntervalMs = argNumber(args, "pollIntervalMs", 1e3);
+		const watchId = `watch_${randomUUID().slice(0, 8)}`;
+		const isPattern = key.includes("*");
+		const watch = {
+			id: watchId,
+			key,
+			namespace,
+			pattern: isPattern,
+			pollIntervalMs,
+			lastChecked: Date.now(),
+			lastVersion: {},
+			createdAt: Date.now()
+		};
+		const prefix = `${namespace}:`;
+		for (const [fullKey, entry] of this.store.state.entries()) if (fullKey.startsWith(prefix)) {
+			if (isPattern) {
+				if (matchesKeyPattern(entry.key, key)) watch.lastVersion[entry.key] = entry.version;
+			} else if (entry.key === key) watch.lastVersion[entry.key] = entry.version;
+		}
+		this.store.watches.set(watchId, watch);
+		return {
+			watchId,
+			key,
+			namespace,
+			pattern: isPattern,
+			pollIntervalMs,
+			initialKeys: Object.keys(watch.lastVersion)
+		};
+	}
+	async handleUnwatch(args) {
+		const watchId = argStringRequired(args, "watchId");
+		const watch = this.store.watches.get(watchId);
+		if (!watch) return {
+			removed: false,
+			watchId,
+			reason: "not_found"
+		};
+		this.store.watches.delete(watchId);
+		return {
+			removed: true,
+			watchId,
+			wasWatching: watch.key
+		};
+	}
+	async handlePoll(args) {
+		const watchId = argStringRequired(args, "watchId");
+		const watch = this.store.watches.get(watchId);
+		if (!watch) throw new Error(`Watch "${watchId}" not found`);
+		const now = Date.now();
+		const changes = [];
+		const prefix = `${watch.namespace}:`;
+		if (watch.pattern) {
+			for (const [fullKey, entry] of this.store.state.entries()) if (fullKey.startsWith(prefix) && matchesKeyPattern(entry.key, watch.key)) {
+				const lastVer = watch.lastVersion[entry.key];
+				if (lastVer === void 0) changes.push({
+					key: entry.key,
+					namespace: entry.namespace,
+					action: "created"
+				});
+				else if (entry.version > lastVer) changes.push({
+					key: entry.key,
+					namespace: entry.namespace,
+					action: "changed"
+				});
+				watch.lastVersion[entry.key] = entry.version;
+			}
+			for (const watchedKey of Object.keys(watch.lastVersion)) if (!this.store.state.has(`${watch.namespace}:${watchedKey}`) && matchesKeyPattern(watchedKey, watch.key)) {
+				changes.push({
+					key: watchedKey,
+					namespace: watch.namespace,
+					action: "deleted"
+				});
+				delete watch.lastVersion[watchedKey];
+			}
+		} else {
+			const fullKey = `${watch.namespace}:${watch.key}`;
+			const entry = this.store.state.get(fullKey);
+			const lastVer = watch.lastVersion[watch.key];
+			if (!entry && lastVer !== void 0) {
+				changes.push({
+					key: watch.key,
+					namespace: watch.namespace,
+					action: "deleted"
+				});
+				delete watch.lastVersion[watch.key];
+			} else if (entry) {
+				if (lastVer === void 0) changes.push({
+					key: entry.key,
+					namespace: entry.namespace,
+					action: "created"
+				});
+				else if (entry.version > lastVer) changes.push({
+					key: entry.key,
+					namespace: entry.namespace,
+					action: "changed"
+				});
+				watch.lastVersion[watch.key] = entry.version;
+			}
+		}
+		watch.lastChecked = now;
+		return {
+			watchId,
+			changes,
+			hasChanges: changes.length > 0,
+			checkedAt: new Date(now).toISOString()
+		};
+	}
+};
+//#endregion
+//#region src/server/domains/shared-state-board/handlers/io-handlers.ts
+/**
+* IO sub-handler — history, export, import.
+*/
+var IOHandlers = class {
+	store;
+	constructor(store) {
+		this.store = store;
+	}
+	async handleHistory(args) {
+		const key = argStringRequired(args, "key");
+		const namespace = argString(args, "namespace", "default");
+		const limit = argNumber(args, "limit", 50);
+		const fullKey = `${namespace}:${key}`;
+		const records = this.store.history.get(fullKey) ?? [];
+		const limited = [...records].toSorted((a, b) => b.timestamp - a.timestamp).slice(0, limit);
+		return {
+			key,
+			namespace,
+			history: limited.map((r) => ({
+				...r,
+				timestamp: new Date(r.timestamp).toISOString()
+			})),
+			total: records.length,
+			returned: limited.length
+		};
+	}
+	async handleExport(args) {
+		const namespace = argString(args, "namespace");
+		const keyPattern = argString(args, "keyPattern");
+		const now = Date.now();
+		const data = {};
+		for (const [_fullKey, entry] of this.store.state.entries()) {
+			if (namespace && entry.namespace !== namespace) continue;
+			if (!matchesKeyPattern(entry.key, keyPattern)) continue;
+			if (entry.expiresAt && now > entry.expiresAt) continue;
+			data[entry.key] = entry.value;
+		}
+		return {
+			data,
+			count: Object.keys(data).length,
+			namespace: namespace ?? "all",
+			exportedAt: new Date(now).toISOString()
+		};
+	}
+	async handleImport(args) {
+		const data = argObject(args, "data");
+		const namespace = argString(args, "namespace", "default");
+		const overwrite = argBool(args, "overwrite", false);
+		if (!data) throw new Error("data must be an object");
+		const imported = [];
+		const skipped = [];
+		const overwritten = [];
+		for (const [key, value] of Object.entries(data)) {
+			const fullKey = `${namespace}:${key}`;
+			const existing = this.store.state.get(fullKey);
+			if (existing && !overwrite) {
+				skipped.push(key);
+				continue;
+			}
+			if (existing && overwrite) overwritten.push(key);
+			const now = Date.now();
+			const entry = {
+				key,
+				value,
+				namespace,
+				createdAt: existing?.createdAt ?? now,
+				updatedAt: now,
+				version: (existing?.version ?? 0) + 1
+			};
+			this.store.state.set(fullKey, entry);
+			this.store.recordChange(fullKey, {
+				id: randomUUID().slice(0, 8),
+				key,
+				namespace,
+				action: "set",
+				oldValue: existing?.value,
+				newValue: value,
+				timestamp: now,
+				source: "import"
+			});
+			imported.push(key);
+		}
+		return {
+			imported: imported.length,
+			skipped: skipped.length,
+			overwritten: overwritten.length,
+			total: Object.keys(data).length,
+			keys: imported
+		};
+	}
+};
+//#endregion
+//#region src/server/domains/shared-state-board/handlers.impl.core.ts
+var SharedStateBoardHandlers = class {
+	store;
+	storeHandlers;
+	watchHandlers;
+	ioHandlers;
+	constructor() {
+		this.store = new StateBoardStore();
+		this.storeHandlers = new StoreHandlers(this.store);
+		this.watchHandlers = new WatchHandlers(this.store);
+		this.ioHandlers = new IOHandlers(this.store);
+	}
+	setPersistNotifier(notify) {
+		this.store.setPersistNotifier(notify);
+	}
+	handleSet(args) {
+		return this.storeHandlers.handleSet(args);
+	}
+	handleGet(args) {
+		return this.storeHandlers.handleGet(args);
+	}
+	handleDelete(args) {
+		return this.storeHandlers.handleDelete(args);
+	}
+	handleList(args) {
+		return this.storeHandlers.handleList(args);
+	}
+	handleWatchDispatch(args) {
+		const action = String(args["action"] ?? "");
+		if (action === "stop") return this.watchHandlers.handleUnwatch(args);
+		if (action === "poll") return this.watchHandlers.handlePoll(args);
+		return this.watchHandlers.handleWatch(args);
+	}
+	handleIODispatch(args) {
+		if (String(args["action"] ?? "") === "import") return this.ioHandlers.handleImport(args);
+		return this.ioHandlers.handleExport(args);
+	}
+	handleWatch(args) {
+		return this.watchHandlers.handleWatch(args);
+	}
+	handleUnwatch(args) {
+		return this.watchHandlers.handleUnwatch(args);
+	}
+	handlePoll(args) {
+		return this.watchHandlers.handlePoll(args);
+	}
+	handleHistory(args) {
+		return this.ioHandlers.handleHistory(args);
+	}
+	handleExport(args) {
+		return this.ioHandlers.handleExport(args);
+	}
+	handleImport(args) {
+		return this.ioHandlers.handleImport(args);
+	}
+	handleClear(args) {
+		return this.storeHandlers.handleClear(args);
+	}
+	handleDispatch(args) {
+		const action = String(args["action"] ?? "");
+		switch (action) {
+			case "set": return this.storeHandlers.handleSet(args);
+			case "get": return this.storeHandlers.handleGet(args);
+			case "delete": return this.storeHandlers.handleDelete(args);
+			case "list": return this.storeHandlers.handleList(args);
+			case "history": return this.ioHandlers.handleHistory(args);
+			case "clear": return this.storeHandlers.handleClear(args);
+			default: return Promise.resolve({
+				content: [{
+					type: "text",
+					text: `Invalid action: "${action}". Expected one of: set, get, delete, list, history, clear`
+				}],
+				isError: true
+			});
+		}
+	}
+	handleStats() {
+		return this.storeHandlers.handleStats();
+	}
+	cleanupExpired() {
+		return this.store.cleanupExpired();
+	}
+	getStore() {
+		return this.store;
+	}
+};
+//#endregion
+export { SharedStateBoardHandlers };