@botharness/core 1.0.1 → 1.0.2

package/dist/index.d.mts

@@ -10832,6 +10832,48 @@ interface MarketplaceClient {
   }>>;
 }
 //#endregion
+//#region packages/core/src/release/notes.d.ts
+interface LocalizedText {
+  en: string;
+  zh: string;
+}
+interface ReleaseNoteSection {
+  name: string;
+  entries: LocalizedText[];
+}
+interface ReleaseNote {
+  version: string;
+  date: string;
+  summary: LocalizedText;
+  sections: ReleaseNoteSection[];
+}
+//#endregion
+//#region packages/core/src/release/service.d.ts
+interface ReleaseInfo {
+  version: string;
+  releases: ReleaseNote[];
+}
+type ReleaseUpdate = {
+  status: 'development';
+  current: string;
+} | {
+  status: 'unavailable';
+  current: string;
+} | {
+  status: 'current';
+  current: string;
+  latest: string;
+} | {
+  status: 'available';
+  current: string;
+  latest: string;
+  releases: ReleaseNote[];
+};
+interface ReleaseService {
+  info(since?: string): ReleaseInfo;
+  update(): Promise<ReleaseUpdate>;
+}
+//#endregion
 //#region packages/core/src/channels/profile-activity.d.ts
 interface GroupProfileActivityDay {
   day: string;
@@ -11363,6 +11405,8 @@ interface BridgeMethods {
   marketplaceReport(payload: unknown): Promise<BridgeResult<{
     received: true;
   }>>;
+  releaseInfo(payload: unknown): BridgeResult<ReleaseInfo>;
+  releaseUpdate(): Promise<BridgeResult<ReleaseUpdate>>;
 }
 interface BridgeMethodsDeps {
   warn?: (message: string) => void;
@@ -11403,6 +11447,7 @@ interface BridgeMethodsDeps {
   };
   createBotId?: () => string;
   marketplace?: MarketplaceClient;
+  release?: ReleaseService;
 }
 export declare function createBridgeMethods(deps: BridgeMethodsDeps): BridgeMethods;
 //#endregion
@@ -11768,6 +11813,8 @@ export declare class BotharnessBridgeService extends TypertRemoteService {
   }>;
   marketplaceTopics(): Promise<MarketplaceTopic[]>;
   marketplaceDetail(id: string): Promise<MarketplaceDetail>;
+  releaseInfo(since?: string): Promise<ReleaseInfo>;
+  releaseUpdate(): Promise<ReleaseUpdate>;
 }
 export declare function registerBridge(ctx: Context, methods: BridgeMethods): BotharnessBridgeService;
 //#endregion

package/dist/index.mjs

@@ -5045,7 +5045,7 @@ const initializer = (inst, issues) => {
 const ZodRealError = /*@__PURE__*/ $constructor("ZodError", initializer, void 0, { Parent: Error });
 //#endregion
 //#region node_modules/.pnpm/zod@4.6.5/node_modules/zod/v4/classic/parse.js
-const parse$1 = /* @__PURE__ */ _parse(ZodRealError);
+const parse$2 = /* @__PURE__ */ _parse(ZodRealError);
 const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
 const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
 const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
@@ -5177,7 +5177,7 @@ const ZodType = /*@__PURE__*/ $constructor("ZodType", (inst, def) => {
 		own(this, "~standard", value);
 	},
 	parse: function _parse(data, params) {
-		return parse$1(this, data, params, { callee: _parse });
+		return parse$2(this, data, params, { callee: _parse });
 	},
 	parseAsync: async function _parseAsync(data, params) {
 		return await parseAsync(this, data, params, { callee: _parseAsync });
@@ -7895,7 +7895,7 @@ function createInboundMessaging(options) {
 			const assertCurrent = () => {
 				if (!valid(grant(value.id)) || grant(value.id).revision !== value.revision || providers.get(value.providerId) !== entry) throw new MessagingError("source-unavailable");
 			};
-			const audit = (record) => database.transaction((db) => {
+			const audit = (record) => transaction((db) => {
 				assertCurrent();
 				const row = db.prepare("SELECT payload_json FROM source_events WHERE source_event_id = ?").get(sourceEventId);
 				const payload = JSON.parse(row.payload_json);
@@ -8009,7 +8009,7 @@ function createInboundMessaging(options) {
 					});
 					result.nextCursor = key;
 				}
-				database.transaction((db) => {
+				transaction((db) => {
 					signal.throwIfAborted();
 					assertCurrent();
 					for (const event of page.events.slice(cursor?.offset ?? 0, offset)) persistSource(db, value, event);
@@ -21754,6 +21754,15 @@ function parseStringArray(source, key) {
 }
 const parseRoles$1 = (source) => parseStringArray(source, "roles");
 const parseWorkspaces = (source) => parseStringArray(source, "workspaces");
+function releaseUnavailable() {
+	return {
+		ok: false,
+		error: {
+			code: "release-unavailable",
+			message: "Release information is unavailable"
+		}
+	};
+}
 function invalidInput(message) {
 	return {
 		ok: false,
@@ -22597,6 +22606,22 @@ function createBridgeMethods(deps) {
 		marketplaceTopics() {
 			return marketplaceCall((client) => client.topics());
 		},
+		releaseInfo(payload) {
+			if (deps.release === void 0) return releaseUnavailable();
+			const since = asObject(payload)["since"];
+			if (since !== void 0 && typeof since !== "string") return invalidInput("invalid since");
+			return {
+				ok: true,
+				value: deps.release.info(since)
+			};
+		},
+		async releaseUpdate() {
+			if (deps.release === void 0) return releaseUnavailable();
+			return {
+				ok: true,
+				value: await deps.release.update()
+			};
+		},
 		marketplaceDetail(payload) {
 			const id = asObject(payload)["id"];
 			if (typeof id !== "string" || id.trim().length === 0) return Promise.resolve(invalidInput("id is required"));
@@ -25054,6 +25079,12 @@ var BotharnessBridgeService = class extends TypertRemoteService {
 	async marketplaceDetail(id) {
 		return unwrapAsync(this.methods.marketplaceDetail({ id }));
 	}
+	async releaseInfo(since) {
+		return unwrap(this.methods.releaseInfo(since === void 0 ? {} : { since }));
+	}
+	async releaseUpdate() {
+		return unwrapAsync(this.methods.releaseUpdate());
+	}
 };
 markRemoteMethods(BotharnessBridgeService.prototype, [
 	"messagingDefaults",
@@ -25178,7 +25209,9 @@ markRemoteMethods(BotharnessBridgeService.prototype, [
 	"marketplaceTopics",
 	"marketplaceDetail",
 	"marketplaceChallenge",
-	"marketplaceReport"
+	"marketplaceReport",
+	"releaseInfo",
+	"releaseUpdate"
 ]);
 function registerBridge(ctx, methods) {
 	return new BotharnessBridgeService(ctx, methods);
@@ -25206,7 +25239,7 @@ function parseChallenge(value) {
 }
 //#endregion
 //#region packages/core/src/marketplace/client.ts
-const REQUEST_TIMEOUT_MS = 15e3;
+const REQUEST_TIMEOUT_MS$1 = 15e3;
 function record$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
 }
@@ -25306,7 +25339,7 @@ function parseReceipt(value) {
 function createMarketplaceClient(options) {
 	const fetchImpl = options.fetchImpl ?? fetch;
 	const baseUrl = options.baseUrl.replace(/\/+$/u, "");
-	const timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS;
+	const timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS$1;
 	const request = async (path, init, parse) => {
 		let response;
 		try {
@@ -25384,6 +25417,349 @@ function createMarketplaceClient(options) {
 	};
 }
 //#endregion
+//#region scripts/release-ledger.mjs
+const RELEASE_HEADING = /^## \[([^\]]+)](?: - (\d{4}-\d{2}-\d{2}))?$/;
+const SECTION_HEADING = /^### (.+)$/;
+const MARKDOWN_LINK$1 = /\[[^\]]*]\(([^)]+)\)/g;
+const RELEASE_PROVENANCE = /^- \*\*(Skill version|Verified against DSH|Upstream revision|Skill 版本|核验的 DSH 版本|上游 revision)(?::|：)\*\*\s+(.+)$/;
+const RELEASE_ARTIFACT_EVIDENCE = /^- \*\*(Release tag|Installable artifact|发布 tag|可安装 artifact)(?::|：)\*\*\s+\[[^\]]+]\((https:\/\/[^)]+)\)$/;
+const PROVENANCE_KEYS = /* @__PURE__ */ new Map([
+	["Skill version", "skillVersion"],
+	["Skill 版本", "skillVersion"],
+	["Verified against DSH", "verifiedAgainst"],
+	["核验的 DSH 版本", "verifiedAgainst"],
+	["Upstream revision", "upstreamSha"],
+	["上游 revision", "upstreamSha"]
+]);
+const EVIDENCE_KEYS = /* @__PURE__ */ new Map([
+	["Release tag", "tagUrl"],
+	["发布 tag", "tagUrl"],
+	["Installable artifact", "installUrl"],
+	["可安装 artifact", "installUrl"]
+]);
+function linksIn(text) {
+	return [...text.matchAll(MARKDOWN_LINK$1)].map((match) => match[1]);
+}
+function provenanceValue(text) {
+	return text.match(/`([^`]+)`/)?.[1] ?? text.trim();
+}
+function parseReleaseLedgerDocument(markdown) {
+	const lines = markdown.replaceAll("\r\n", "\n").split("\n");
+	const releases = [];
+	const unexpectedContent = [];
+	let release;
+	let section;
+	for (const [index, line] of lines.entries()) {
+		const releaseMatch = line.match(RELEASE_HEADING);
+		if (releaseMatch) {
+			release = {
+				identity: releaseMatch[1],
+				date: releaseMatch[2],
+				summary: "",
+				sections: []
+			};
+			releases.push(release);
+			section = void 0;
+			continue;
+		}
+		if (!release) continue;
+		const sectionMatch = line.match(SECTION_HEADING);
+		if (sectionMatch) {
+			section = {
+				name: sectionMatch[1],
+				entries: []
+			};
+			release.sections.push(section);
+			continue;
+		}
+		const provenanceMatch = line.match(RELEASE_PROVENANCE);
+		if (provenanceMatch && !section) {
+			release.provenance ??= {};
+			const key = PROVENANCE_KEYS.get(provenanceMatch[1]);
+			release.provenance[key] = provenanceValue(provenanceMatch[2]);
+			if (key === "upstreamSha") release.provenance.upstreamUrl = linksIn(provenanceMatch[2])[0];
+			continue;
+		}
+		const evidenceMatch = line.match(RELEASE_ARTIFACT_EVIDENCE);
+		if (evidenceMatch && !section) {
+			release.evidence ??= {};
+			release.evidence[EVIDENCE_KEYS.get(evidenceMatch[1])] = evidenceMatch[2];
+			continue;
+		}
+		if (line.startsWith("- ") && section) {
+			const text = line.slice(2);
+			section.entries.push({
+				text,
+				links: linksIn(text)
+			});
+			continue;
+		}
+		if (/^\s{2,}\S/.test(line) && section && section.entries.length > 0) {
+			const entry = section.entries.at(-1);
+			entry.text = `${entry.text} ${line.trim()}`;
+			entry.links = linksIn(entry.text);
+			continue;
+		}
+		if (!release.summary && !section && line.trim()) {
+			release.summary = line.trim();
+			continue;
+		}
+		if (section && line.trim()) unexpectedContent.push({
+			releaseIdentity: release.identity,
+			sectionName: section.name,
+			line: index + 1
+		});
+	}
+	return {
+		releases,
+		unexpectedContent
+	};
+}
+function parseReleaseLedger(markdown) {
+	const { releases } = parseReleaseLedgerDocument(markdown);
+	return { releases };
+}
+//#endregion
+//#region packages/core/src/release/version.ts
+const RELEASE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/u;
+function parse$1(version) {
+	const match = RELEASE_VERSION.exec(version);
+	if (match === null) return void 0;
+	return {
+		core: [
+			Number(match[1]),
+			Number(match[2]),
+			Number(match[3])
+		],
+		prerelease: match[4] === void 0 ? [] : match[4].split(".")
+	};
+}
+function compareIdentifier(left, right) {
+	const leftNumeric = /^\d+$/u.test(left);
+	const rightNumeric = /^\d+$/u.test(right);
+	if (leftNumeric && rightNumeric) return Math.sign(Number(left) - Number(right));
+	if (leftNumeric) return -1;
+	if (rightNumeric) return 1;
+	return left < right ? -1 : left > right ? 1 : 0;
+}
+function isReleaseVersion(version) {
+	const parsed = parse$1(version);
+	return parsed !== void 0 && parsed.core.some((part) => part > 0);
+}
+function compareVersions(left, right) {
+	const a = parse$1(left);
+	const b = parse$1(right);
+	if (a === void 0 || b === void 0) return 0;
+	for (let index = 0; index < 3; index += 1) {
+		const difference = a.core[index] - b.core[index];
+		if (difference !== 0) return Math.sign(difference);
+	}
+	if (a.prerelease.length === 0 || b.prerelease.length === 0) return Math.sign(b.prerelease.length - a.prerelease.length);
+	const length = Math.max(a.prerelease.length, b.prerelease.length);
+	for (let index = 0; index < length; index += 1) {
+		const left = a.prerelease[index];
+		const right = b.prerelease[index];
+		if (left === void 0) return -1;
+		if (right === void 0) return 1;
+		const order = compareIdentifier(left, right);
+		if (order !== 0) return order;
+	}
+	return 0;
+}
+//#endregion
+//#region packages/core/src/release/notes.ts
+const RELEASE_REPOSITORY_URL = "https://github.com/BotHarness/BotHarness";
+const RELEASE_NOTE_SECTION_ORDER = [
+	"Added",
+	"Changed",
+	"Fixed",
+	"Security",
+	"Documentation",
+	"Breaking Changes",
+	"Deprecated",
+	"Removed"
+];
+function sectionRank(name) {
+	const index = RELEASE_NOTE_SECTION_ORDER.indexOf(name);
+	return index === -1 ? RELEASE_NOTE_SECTION_ORDER.length : index;
+}
+const MARKDOWN_LINK = /(\[[^\]]*\]\()([^)\s]+)(\))/gu;
+function absolutizeLedgerLinks(text) {
+	return text.replace(MARKDOWN_LINK, (whole, open, target, close) => {
+		if (/^[a-z][a-z0-9+.-]*:/iu.test(target) || target.startsWith("#")) return whole;
+		const path = target.replace(/^\.?\//u, "");
+		return `${open}${RELEASE_REPOSITORY_URL}/blob/main/${path}${close}`;
+	});
+}
+function pairReleaseLedgers(english, chinese) {
+	const translated = new Map(parseReleaseLedger(chinese).releases.map((release) => [release.identity, release]));
+	const notes = [];
+	for (const release of parseReleaseLedger(english).releases) {
+		if (!isReleaseVersion(release.identity) || release.date === void 0) continue;
+		const zh = translated.get(release.identity);
+		notes.push({
+			version: release.identity,
+			date: release.date,
+			summary: {
+				en: absolutizeLedgerLinks(release.summary),
+				zh: absolutizeLedgerLinks(zh?.summary || release.summary)
+			},
+			sections: release.sections.toSorted((left, right) => sectionRank(left.name) - sectionRank(right.name)).map((section) => {
+				const zhEntries = zh?.sections.find((candidate) => candidate.name === section.name)?.entries;
+				return {
+					name: section.name,
+					entries: section.entries.map((entry, index) => ({
+						en: absolutizeLedgerLinks(entry.text),
+						zh: absolutizeLedgerLinks(zhEntries?.[index]?.text ?? entry.text)
+					}))
+				};
+			})
+		});
+	}
+	return notes.sort((left, right) => compareVersions(right.version, left.version));
+}
+function selectReleaseNotes(notes, range) {
+	return notes.filter((note) => compareVersions(note.version, range.through) <= 0 && (range.after === void 0 || !isReleaseVersion(range.after) || compareVersions(note.version, range.after) > 0));
+}
+//#endregion
+//#region packages/core/src/release/service.ts
+const RELEASE_PACKAGE = "deepseekbot";
+const RELEASE_NOTES_PACKAGE = "@botharness/core";
+const DEFAULT_RELEASE_REGISTRIES = ["https://registry.npmjs.org", "https://registry.npmmirror.com"];
+const DEFAULT_RELEASE_NOTE_SOURCES = [(version) => `https://cdn.jsdelivr.net/npm/${RELEASE_NOTES_PACKAGE}@${version}/`, (version) => `https://registry.npmmirror.com/${RELEASE_NOTES_PACKAGE}/${version}/files/`];
+const CHECK_CACHE_MS = 216e5;
+const FAILURE_CACHE_MS = 3e5;
+const REQUEST_TIMEOUT_MS = 8e3;
+function readFirst(candidates) {
+	for (const candidate of candidates) try {
+		return readFileSync(candidate, "utf8");
+	} catch {
+		continue;
+	}
+}
+function installedRelease(moduleUrl) {
+	const ledger = (name) => readFirst([new URL(`../${name}`, moduleUrl), new URL(`../../../${name}`, moduleUrl)]);
+	return {
+		version: () => {
+			const manifest = readFirst([new URL("../package.json", moduleUrl)]);
+			if (manifest === void 0) return "0.0.0";
+			const version = JSON.parse(manifest).version;
+			return typeof version === "string" ? version : "0.0.0";
+		},
+		ledgers: () => {
+			const english = ledger("CHANGELOG.md");
+			if (english === void 0) return void 0;
+			return {
+				english,
+				chinese: ledger("CHANGELOG.zh.md") ?? english
+			};
+		}
+	};
+}
+function newestTag(tags, current) {
+	if (typeof tags !== "object" || tags === null) return void 0;
+	const source = tags;
+	return [source["latest"], current.includes("-") ? source["next"] : void 0].filter((value) => typeof value === "string" && isReleaseVersion(value)).sort(compareVersions).at(-1);
+}
+function createReleaseService(options) {
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const now = options.now ?? Date.now;
+	const registries = options.registries ?? DEFAULT_RELEASE_REGISTRIES;
+	const noteSources = options.noteSources ?? DEFAULT_RELEASE_NOTE_SOURCES;
+	const timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS;
+	let notes;
+	let cached;
+	let pending;
+	const installedNotes = () => {
+		if (notes !== void 0) return notes;
+		const ledgers = options.ledgers();
+		notes = ledgers === void 0 ? [] : pairReleaseLedgers(ledgers.english, ledgers.chinese);
+		return notes;
+	};
+	const text = async (url) => {
+		try {
+			const response = await fetchImpl(url, { signal: AbortSignal.timeout(timeoutMs) });
+			return response.ok ? await response.text() : void 0;
+		} catch {
+			return;
+		}
+	};
+	const latestVersion = async (current) => {
+		for (const registry of registries) {
+			const body = await text(`${registry.replace(/\/+$/u, "")}/-/package/${RELEASE_PACKAGE}/dist-tags`);
+			if (body === void 0) continue;
+			try {
+				const latest = newestTag(JSON.parse(body), current);
+				if (latest !== void 0) return latest;
+			} catch {
+				continue;
+			}
+		}
+	};
+	const newerNotes = async (current, latest) => {
+		for (const source of noteSources) {
+			const base = source(latest);
+			const english = await text(`${base}CHANGELOG.md`);
+			if (english === void 0) continue;
+			return selectReleaseNotes(pairReleaseLedgers(english, await text(`${base}CHANGELOG.zh.md`) ?? english), {
+				after: current,
+				through: latest
+			});
+		}
+		return [];
+	};
+	const check = async () => {
+		const current = options.version();
+		if (!isReleaseVersion(current)) return {
+			status: "development",
+			current
+		};
+		const latest = await latestVersion(current);
+		if (latest === void 0) return {
+			status: "unavailable",
+			current
+		};
+		if (compareVersions(latest, current) <= 0) return {
+			status: "current",
+			current,
+			latest
+		};
+		return {
+			status: "available",
+			current,
+			latest,
+			releases: await newerNotes(current, latest)
+		};
+	};
+	return {
+		info(since) {
+			const version = options.version();
+			return {
+				version,
+				releases: !isReleaseVersion(version) ? [] : since === void 0 ? installedNotes().filter((note) => compareVersions(note.version, version) === 0) : selectReleaseNotes(installedNotes(), {
+					after: since,
+					through: version
+				})
+			};
+		},
+		update() {
+			if (cached !== void 0) {
+				if (now() - cached.at < (cached.result.status === "unavailable" ? FAILURE_CACHE_MS : CHECK_CACHE_MS)) return Promise.resolve(cached.result);
+			}
+			pending ??= check().then((result) => {
+				cached = {
+					at: now(),
+					result
+				};
+				return result;
+			}).finally(() => {
+				pending = void 0;
+			});
+			return pending;
+		}
+	};
+}
+//#endregion
 //#region packages/core/src/bots/avatar-snapshot.ts
 function deriveAvatarAppearance(value) {
 	if (!isAvatarRecipe(value)) return void 0;
@@ -49675,6 +50051,7 @@ function apply(ctx, config) {
 		toolRules: core.toolRules,
 		assignmentAccess: core.assignmentAccess,
 		marketplace: createMarketplaceClient({ baseUrl: config.marketplaceUrl ?? "https://market.botharness.ai" }),
+		release: createReleaseService(installedRelease(import.meta.url)),
 		developerMode: { set: (enabled) => developerModeTarget.gate?.set(enabled) },
 		computerAccess: { changed: (slug) => {
 			(ctx.get("botharnessComputerTools")?.reconcileBot?.(slug))?.catch((error) => {

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@botharness/core",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "BotHarness core: PersonaBot registry, memory, and state",
   "files": [
     "dist",
     "cordis.patch.yml",
+    "CHANGELOG.md",
+    "CHANGELOG.zh.md",
     "LICENSE"
   ],
   "type": "module",