@serviceme/devtools-core 2.0.5 → 2.0.7

package/dist/toolbox-BV7vLGXZ.js

@@ -1,614 +0,0 @@
-const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.js");
-const require_userHome = require("./userHome-CLlsXCvW.js");
-let node_fs_promises = require("node:fs/promises");
-node_fs_promises = require_rolldown_runtime.__toESM(node_fs_promises);
-let node_path = require("node:path");
-node_path = require_rolldown_runtime.__toESM(node_path);
-let node_timers_promises = require("node:timers/promises");
-//#region src/toolbox/sort.ts
-/**
-* Parsed timestamp from `lastUsedAt`. Returns 0 when the field is
-* missing or unparseable (so the entry falls below entries with a
-* real timestamp).
-*/
-function lastUsedTimestamp(tool) {
-	if (!tool.lastUsedAt) return 0;
-	const ms = Date.parse(tool.lastUsedAt);
-	return Number.isFinite(ms) ? ms : 0;
-}
-/**
-* Sort by "recently used" — entries with newer `lastUsedAt` float to
-* the top, entries with no `lastUsedAt` sort to the bottom (preserving
-* their relative `order` index when both are absent).
-*
-* Ties (same `lastUsedAt` or both missing) are broken by `order`, then
-* by `id` for determinism.
-*/
-function sortByRecentFirst(tools) {
-	return [...tools].sort((a, b) => {
-		const tsA = lastUsedTimestamp(a);
-		const tsB = lastUsedTimestamp(b);
-		if (tsA !== tsB) return tsB - tsA;
-		const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
-		const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
-		if (orderA !== orderB) return orderA - orderB;
-		return a.id.localeCompare(b.id);
-	});
-}
-/**
-* Sort by user-defined `order` field. Entries without `order` are
-* appended in their input order (stable sort via `id` tiebreaker).
-*/
-function sortByUserOrder(tools) {
-	return [...tools].sort((a, b) => {
-		const orderA = a.order ?? Number.MAX_SAFE_INTEGER;
-		const orderB = b.order ?? Number.MAX_SAFE_INTEGER;
-		if (orderA !== orderB) return orderA - orderB;
-		return a.id.localeCompare(b.id);
-	});
-}
-/**
-* Merge built-in defaults with user-stored tools. Defaults keep
-* `isDefault: true` and their `order`; user tools are appended with
-* their stored metadata. Output is sorted by user order.
-*/
-function mergeWithDefaults(defaults, userTools) {
-	const defaultIds = new Set(defaults.map((d) => d.id));
-	const uniqueUserTools = userTools.filter((t) => !defaultIds.has(t.id));
-	return sortByUserOrder([...defaults, ...uniqueUserTools]);
-}
-/**
-* Re-number `order` for a list of tool ids. Used by
-* `toolbox.update` when the user drags-and-drops entries in the UI.
-*/
-function reindexOrder(tools, newOrderIds) {
-	const orderMap = /* @__PURE__ */ new Map();
-	for (const [index, id] of newOrderIds.entries()) orderMap.set(id, index);
-	for (const tool of tools) {
-		const next = orderMap.get(tool.id);
-		if (next !== void 0) tool.order = next;
-	}
-	return tools;
-}
-/**
-* Stamp `lastUsedAt` on the targeted tool (clones the array). Returns
-* a new array; the input is left untouched.
-*/
-function touchLastUsedAt(tools, id, when = /* @__PURE__ */ new Date()) {
-	return tools.map((tool) => tool.id === id ? {
-		...tool,
-		lastUsedAt: when.toISOString()
-	} : tool);
-}
-//#endregion
-//#region src/toolbox/types.ts
-/** Schema version of the on-disk toolbox JSON files. Bumped on breaking changes. */
-const TOOLBOX_JSON_SCHEMA_VERSION = 1;
-/** Built-in tools rendered when the JSON file is missing or empty. */
-const BUILTIN_DEFAULT_TOOLS = [
-	{
-		id: "builtin-docs",
-		name: "SERVICEME Docs",
-		description: "Official documentation portal",
-		icon: "book",
-		url: "https://docs.medalsoft.com/serviceme"
-	},
-	{
-		id: "builtin-issues",
-		name: "Issue Tracker",
-		description: "Report bugs and feature requests",
-		icon: "bug",
-		url: "https://github.com/medalsoftchina/ms-devtools-vscode/issues"
-	},
-	{
-		id: "builtin-changelog",
-		name: "Changelog",
-		description: "Release notes for every published version",
-		icon: "history",
-		url: "https://github.com/medalsoftchina/ms-devtools-vscode/releases"
-	}
-];
-//#endregion
-//#region src/toolbox/ToolboxStore.ts
-/**
-* ToolboxStore — JSON persistence for the toolbox entries.
-*
-* Two scopes:
-*   - `user`      → `~/.serviceme/toolbox.json`
-*   - `workspace` → `<cwd>/.github/.serviceme-toolbox.json`
-*
-* Both files share the `PersistedToolbox` shape and the same atomic
-* write pattern (tmp + rename + fsync) as `IdentityStore`. Concurrent
-* writers are serialized via a mkdir-based file lock (Phase 6+ may
-* upgrade to `proper-lockfile`).
-*
-* Refs:
-* - 4.功能规划.md §2.3 — `ToolboxStore.ts JSON 持久化(user + workspace scope)`
-* - `3.功能拆分.md` §3 — toolbox wire shape
-*/
-const FILE_MODE = 384;
-const LOCK_DIR_MODE = 448;
-const DEFAULT_LOCK_TIMEOUT_MS = 5e3;
-const DEFAULT_LOCK_RETRY_MS = 25;
-const LOCK_STALE_GRACE_MS = 200;
-const TMP_SUFFIX = ".tmp";
-const WORKSPACE_TOOLBOX_RELATIVE_PATH = node_path.join(".github", ".serviceme-toolbox.json");
-const LEGACY_WORKSPACE_TOOLBOX_FILENAME = ".ms-devtools-toolbox.json";
-/**
-* One-time migration: the workspace-scope toolbox file used to be named
-* `.ms-devtools-toolbox.json`. If the new `.serviceme-toolbox.json` doesn't
-* exist yet but the legacy file does (in the same directory), rename it
-* forward so existing toolbox entries aren't silently lost.
-*/
-async function migrateLegacyWorkspaceToolboxFile(filePath) {
-	if (!filePath) return;
-	const legacyPath = node_path.join(node_path.dirname(filePath), LEGACY_WORKSPACE_TOOLBOX_FILENAME);
-	if (legacyPath === filePath) return;
-	try {
-		await node_fs_promises.access(filePath);
-		return;
-	} catch {}
-	try {
-		await node_fs_promises.rename(legacyPath, filePath);
-	} catch {}
-}
-var FsToolboxFileBackend = class {
-	constructor() {
-		this.maxBackupCount = 5;
-	}
-	async exists(filePath) {
-		try {
-			await node_fs_promises.access(filePath);
-			return true;
-		} catch {
-			return false;
-		}
-	}
-	async read(filePath) {
-		let buf;
-		try {
-			buf = await node_fs_promises.readFile(filePath, "utf8");
-		} catch (err) {
-			if (isNodeError(err) && err.code === "ENOENT") return null;
-			throw err;
-		}
-		try {
-			return coercePersistedToolbox(JSON.parse(buf));
-		} catch {
-			await this.backupCorruptedFile(filePath);
-			return null;
-		}
-	}
-	async backupCorruptedFile(filePath) {
-		try {
-			const backupPath = `${filePath}.corrupted.${Date.now()}.bak`;
-			await node_fs_promises.copyFile(filePath, backupPath);
-			await this.purgeExcessBackups(filePath);
-		} catch {}
-	}
-	async purgeExcessBackups(filePath) {
-		const dir = node_path.dirname(filePath);
-		const base = node_path.basename(filePath);
-		let entries;
-		try {
-			entries = await node_fs_promises.readdir(dir);
-		} catch {
-			return;
-		}
-		const backups = entries.filter((n) => n.startsWith(base) && n.endsWith(".bak")).map((n) => ({
-			name: n,
-			filePath: node_path.join(dir, n)
-		})).sort((a, b) => {
-			return a.name.localeCompare(b.name);
-		});
-		const excess = backups.length - this.maxBackupCount;
-		if (excess <= 0) return;
-		await Promise.all(backups.slice(0, excess).map((b) => node_fs_promises.rm(b.filePath).catch(() => void 0)));
-	}
-	async write(filePath, payload) {
-		await node_fs_promises.mkdir(node_path.dirname(filePath), { recursive: true });
-		const tmpPath = `${filePath}${TMP_SUFFIX}`;
-		const bytes = Buffer.from(JSON.stringify(payload, null, "	"), "utf8");
-		await node_fs_promises.rm(tmpPath, { force: true });
-		const handle = await node_fs_promises.open(tmpPath, "w", FILE_MODE);
-		try {
-			await handle.writeFile(bytes);
-			await handle.sync();
-		} finally {
-			await handle.close();
-		}
-		await node_fs_promises.rename(tmpPath, filePath);
-		await node_fs_promises.chmod(filePath, FILE_MODE).catch(() => void 0);
-	}
-};
-function coercePersistedToolbox(parsed) {
-	if (typeof parsed !== "object" || parsed === null) throw new Error("toolbox.json: top-level must be an object");
-	const obj = parsed;
-	const version = obj.version;
-	if (version !== 1) throw new Error(`toolbox.json: unsupported schema version ${String(version)}`);
-	if (!Array.isArray(obj.tools)) throw new Error("toolbox.json: 'tools' must be an array");
-	return {
-		version,
-		tools: obj.tools
-	};
-}
-function isNodeError(value) {
-	return value instanceof Error && typeof value.code === "string";
-}
-function isProcessAlive(pid) {
-	try {
-		process.kill(pid, 0);
-		return true;
-	} catch {
-		return false;
-	}
-}
-var ToolboxFileLock = class {
-	constructor(filePath, timeoutMs, retryMs) {
-		this.acquired = false;
-		this.dirPath = `${filePath}.lock`;
-		this.pidFilePath = node_path.join(this.dirPath, "pid");
-		this.timeoutMs = timeoutMs;
-		this.retryMs = retryMs;
-	}
-	async acquire() {
-		const start = Date.now();
-		while (true) try {
-			await node_fs_promises.mkdir(this.dirPath, { mode: LOCK_DIR_MODE });
-			await node_fs_promises.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
-			this.acquired = true;
-			return;
-		} catch (err) {
-			if (!isNodeError(err) || err.code !== "EEXIST") throw err;
-			if (await this.isStaleLock()) {
-				await node_fs_promises.rm(this.dirPath, {
-					recursive: true,
-					force: true
-				});
-				continue;
-			}
-			if (Date.now() - start >= this.timeoutMs) throw new Error(`ToolboxStore lock acquisition timed out for ${this.dirPath}`);
-			await (0, node_timers_promises.setTimeout)(this.retryMs);
-		}
-	}
-	async isStaleLock() {
-		let pidStr;
-		try {
-			pidStr = await node_fs_promises.readFile(this.pidFilePath, "utf8");
-		} catch {
-			try {
-				const stat = await node_fs_promises.stat(this.dirPath);
-				return Date.now() - stat.mtimeMs > LOCK_STALE_GRACE_MS;
-			} catch {
-				return false;
-			}
-		}
-		const pid = Number.parseInt(pidStr.trim(), 10);
-		if (!Number.isFinite(pid) || pid <= 0) return true;
-		return !isProcessAlive(pid);
-	}
-	async release() {
-		if (!this.acquired) return;
-		this.acquired = false;
-		await node_fs_promises.rm(this.dirPath, {
-			recursive: true,
-			force: true
-		});
-	}
-};
-function defaultWorkspacePath() {
-	if (process.env.SERVICEME_NO_WORKSPACE_TOOLBOX === "1") return null;
-	return node_path.join(process.cwd(), WORKSPACE_TOOLBOX_RELATIVE_PATH);
-}
-var ToolboxStore = class {
-	constructor(opts = {}) {
-		this.userFilePath = opts.userFilePath ?? require_userHome.getToolboxJsonPath();
-		this.resolveWorkspacePath = opts.resolveWorkspacePath ?? defaultWorkspacePath;
-		this.defaults = opts.defaultTools ?? BUILTIN_DEFAULT_TOOLS;
-		this.hooks = opts.hooks ?? {};
-		this.backend = opts.backend ?? new FsToolboxFileBackend();
-		this.lockTimeoutMs = opts.lockTimeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS;
-		this.lockRetryMs = opts.lockRetryMs ?? DEFAULT_LOCK_RETRY_MS;
-	}
-	/** Read a scope; returns the resolved toolbox (with defaults merged when empty). */
-	async read(scope) {
-		const filePath = this.filePathFor(scope);
-		if (scope === "workspace") await migrateLegacyWorkspaceToolboxFile(filePath);
-		const storedTools = (filePath ? await this.backend.read(filePath) : null)?.tools ?? [];
-		const merged = mergeWithDefaults(this.defaults.map((seed, index) => toDefaultTool(seed, index)), storedTools);
-		storedTools.filter((t) => !this.defaults.some((d) => d.id === t.id));
-		return {
-			scope,
-			tools: merged
-		};
-	}
-	/**
-	* Atomic write under a file lock. Replaces the entire `tools` array
-	* with the provided snapshot.
-	*/
-	async write(scope, tools) {
-		const filePath = this.filePathFor(scope);
-		if (!filePath) throw new Error(`Cannot write toolbox scope '${scope}': file path is unavailable`);
-		if (scope === "workspace") await migrateLegacyWorkspaceToolboxFile(filePath);
-		const payload = {
-			version: 1,
-			tools: sortByUserOrder([...tools])
-		};
-		await this.hooks.beforeWrite?.(scope, payload);
-		const lock = new ToolboxFileLock(filePath, this.lockTimeoutMs, this.lockRetryMs);
-		await lock.acquire();
-		try {
-			await this.backend.write(filePath, payload);
-		} finally {
-			await lock.release();
-		}
-		await this.hooks.afterWrite?.(scope, payload);
-	}
-	/**
-	* Read-modify-write under the file lock. The mutator receives the
-	* current user-only list (defaults not included) and returns the
-	* replacement list. Throwing inside the mutator aborts the write.
-	*/
-	async mutate(scope, mutator) {
-		const filePath = this.filePathFor(scope);
-		if (!filePath) throw new Error(`Cannot mutate toolbox scope '${scope}': file path is unavailable`);
-		if (scope === "workspace") await migrateLegacyWorkspaceToolboxFile(filePath);
-		const lock = new ToolboxFileLock(filePath, this.lockTimeoutMs, this.lockRetryMs);
-		await lock.acquire();
-		try {
-			const storedTools = (await this.backend.read(filePath))?.tools ?? [];
-			const defaultIds = new Set(this.defaults.map((d) => d.id));
-			const next = await mutator(storedTools.filter((t) => !defaultIds.has(t.id)));
-			const payload = {
-				version: 1,
-				tools: sortByUserOrder([...next])
-			};
-			await this.hooks.beforeWrite?.(scope, payload);
-			await this.backend.write(filePath, payload);
-			await this.hooks.afterWrite?.(scope, payload);
-			return next;
-		} finally {
-			await lock.release();
-		}
-	}
-	/** Wipe a scope entirely (used by `toolbox.remove --all` extensions). */
-	async clear(scope) {
-		const filePath = this.filePathFor(scope);
-		if (!filePath) return;
-		await node_fs_promises.rm(filePath, { force: true });
-	}
-	/** Test seam — resolve the user-scope file path. */
-	getUserFilePath() {
-		return this.userFilePath;
-	}
-	/** Test seam — resolve the workspace-scope file path (or null when disabled). */
-	getWorkspaceFilePath() {
-		return this.resolveWorkspacePath();
-	}
-	filePathFor(scope) {
-		return scope === "user" ? this.userFilePath : this.resolveWorkspacePath();
-	}
-};
-function toDefaultTool(seed, order) {
-	return {
-		id: seed.id,
-		name: seed.name,
-		description: seed.description,
-		icon: seed.icon,
-		url: seed.url,
-		isDefault: true,
-		order,
-		scope: "user"
-	};
-}
-//#endregion
-//#region src/toolbox/ToolboxCore.ts
-/** Sentinel — caller tried to remove a built-in (immutable) tool. */
-var DefaultToolImmutableError = class extends Error {
-	constructor(toolId) {
-		super(`Cannot remove default toolbox entry: ${toolId}`);
-		this.toolId = toolId;
-		this.name = "DefaultToolImmutableError";
-	}
-};
-var ToolboxCore = class {
-	constructor(opts = {}) {
-		this.store = opts.store ?? new ToolboxStore();
-		this.defaults = opts.defaultTools ?? BUILTIN_DEFAULT_TOOLS;
-		this.listSort = opts.listSort ?? sortByUserOrder;
-	}
-	/** List all tools in a scope. Built-in defaults are merged in. */
-	async list(scope = "user") {
-		const resolved = await this.store.read(scope);
-		return {
-			scope,
-			tools: this.listSort(resolved.tools)
-		};
-	}
-	/**
-	* Append a new tool to the requested scope. Default tools are
-	* rejected (they are seeds, not user entries).
-	*/
-	async add(tool, scope = "user") {
-		if (this.isDefaultId(tool.id)) throw new DefaultToolImmutableError(tool.id);
-		return {
-			scope,
-			tools: await this.store.mutate(scope, async (current) => {
-				const filtered = current.filter((t) => t.id !== tool.id);
-				return [...filtered, {
-					...tool,
-					scope,
-					isDefault: false,
-					order: tool.order ?? filtered.length
-				}];
-			})
-		};
-	}
-	/**
-	* Remove a tool by id. Returns `success: false` when the id is a
-	* built-in default (idempotent, never throws on missing entries).
-	*/
-	async remove(id, scope = "user") {
-		if (this.isDefaultId(id)) throw new DefaultToolImmutableError(id);
-		return {
-			scope,
-			toolId: id,
-			success: !(await this.store.mutate(scope, async (current) => current.filter((t) => t.id !== id))).some((t) => t.id === id)
-		};
-	}
-	/**
-	* Patch a tool by id. Default tools can only have their `order`
-	* updated; other patches are silently ignored for default entries
-	* (callers can compare before/after to detect the ignore).
-	*/
-	async update(id, patch, scope = "user") {
-		const isDefault = this.isDefaultId(id);
-		return {
-			scope,
-			tools: await this.store.mutate(scope, async (current) => {
-				if (isDefault) return current;
-				return current.map((tool) => tool.id === id ? {
-					...tool,
-					...patch,
-					scope,
-					isDefault: false
-				} : tool);
-			})
-		};
-	}
-	/**
-	* Stamp `lastUsedAt` on the targeted tool. This is the "recently
-	* used" hook the Extension's webview uses when a user clicks a
-	* toolbox entry.
-	*/
-	async recordUsage(id, scope = "user", when = /* @__PURE__ */ new Date()) {
-		if (this.isDefaultId(id)) {
-			const seed = this.defaults.find((d) => d.id === id);
-			if (!seed) return null;
-			return {
-				...seed,
-				scope,
-				isDefault: true,
-				order: 0,
-				lastUsedAt: when.toISOString()
-			};
-		}
-		let updated = null;
-		await this.store.mutate(scope, async (current) => {
-			const next = touchLastUsedAt(current, id, when);
-			updated = next.find((t) => t.id === id) ?? null;
-			return next;
-		});
-		return updated;
-	}
-	/**
-	* Combined view: user + workspace scopes merged, sorted by recent
-	* usage. Workspace tools overlay user tools (workspace entries win
-	* on `id` collision).
-	*/
-	async listMerged() {
-		const [user, workspace] = await Promise.all([this.store.read("user"), this.store.read("workspace")]);
-		const seen = /* @__PURE__ */ new Set();
-		const merged = [];
-		for (const tool of workspace.tools) {
-			seen.add(tool.id);
-			merged.push({
-				...tool,
-				scope: "workspace"
-			});
-		}
-		for (const tool of user.tools) {
-			if (seen.has(tool.id)) continue;
-			merged.push({
-				...tool,
-				scope: "user"
-			});
-		}
-		return {
-			scope: "user",
-			tools: sortByRecentFirst(merged)
-		};
-	}
-	/** Expose the underlying store (CLI / Bridge use it for path-level access). */
-	getStore() {
-		return this.store;
-	}
-	isDefaultId(id) {
-		return this.defaults.some((d) => d.id === id);
-	}
-};
-//#endregion
-Object.defineProperty(exports, "BUILTIN_DEFAULT_TOOLS", {
-	enumerable: true,
-	get: function() {
-		return BUILTIN_DEFAULT_TOOLS;
-	}
-});
-Object.defineProperty(exports, "DefaultToolImmutableError", {
-	enumerable: true,
-	get: function() {
-		return DefaultToolImmutableError;
-	}
-});
-Object.defineProperty(exports, "FsToolboxFileBackend", {
-	enumerable: true,
-	get: function() {
-		return FsToolboxFileBackend;
-	}
-});
-Object.defineProperty(exports, "TOOLBOX_JSON_SCHEMA_VERSION", {
-	enumerable: true,
-	get: function() {
-		return TOOLBOX_JSON_SCHEMA_VERSION;
-	}
-});
-Object.defineProperty(exports, "ToolboxCore", {
-	enumerable: true,
-	get: function() {
-		return ToolboxCore;
-	}
-});
-Object.defineProperty(exports, "ToolboxStore", {
-	enumerable: true,
-	get: function() {
-		return ToolboxStore;
-	}
-});
-Object.defineProperty(exports, "WORKSPACE_TOOLBOX_RELATIVE_PATH", {
-	enumerable: true,
-	get: function() {
-		return WORKSPACE_TOOLBOX_RELATIVE_PATH;
-	}
-});
-Object.defineProperty(exports, "mergeWithDefaults", {
-	enumerable: true,
-	get: function() {
-		return mergeWithDefaults;
-	}
-});
-Object.defineProperty(exports, "reindexOrder", {
-	enumerable: true,
-	get: function() {
-		return reindexOrder;
-	}
-});
-Object.defineProperty(exports, "sortByRecentFirst", {
-	enumerable: true,
-	get: function() {
-		return sortByRecentFirst;
-	}
-});
-Object.defineProperty(exports, "sortByUserOrder", {
-	enumerable: true,
-	get: function() {
-		return sortByUserOrder;
-	}
-});
-Object.defineProperty(exports, "touchLastUsedAt", {
-	enumerable: true,
-	get: function() {
-		return touchLastUsedAt;
-	}
-});
-
-//# sourceMappingURL=toolbox-BV7vLGXZ.js.map