@serviceme/devtools-core 2.0.0 → 2.0.2

package/dist/toolbox.js

@@ -1,584 +1,14 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/toolbox/index.ts
-var toolbox_exports = {};
-__export(toolbox_exports, {
-  BUILTIN_DEFAULT_TOOLS: () => BUILTIN_DEFAULT_TOOLS,
-  DefaultToolImmutableError: () => DefaultToolImmutableError,
-  FsToolboxFileBackend: () => FsToolboxFileBackend,
-  TOOLBOX_JSON_SCHEMA_VERSION: () => TOOLBOX_JSON_SCHEMA_VERSION,
-  ToolboxCore: () => ToolboxCore,
-  ToolboxStore: () => ToolboxStore,
-  WORKSPACE_TOOLBOX_RELATIVE_PATH: () => WORKSPACE_TOOLBOX_RELATIVE_PATH,
-  mergeWithDefaults: () => mergeWithDefaults,
-  reindexOrder: () => reindexOrder,
-  sortByRecentFirst: () => sortByRecentFirst,
-  sortByUserOrder: () => sortByUserOrder,
-  touchLastUsedAt: () => touchLastUsedAt
-});
-module.exports = __toCommonJS(toolbox_exports);
-
-// src/toolbox/sort.ts
-function lastUsedTimestamp(tool) {
-  if (!tool.lastUsedAt) return 0;
-  const ms = Date.parse(tool.lastUsedAt);
-  return Number.isFinite(ms) ? ms : 0;
-}
-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);
-  });
-}
-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);
-  });
-}
-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]);
-}
-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;
-}
-function touchLastUsedAt(tools, id, when = /* @__PURE__ */ new Date()) {
-  return tools.map((tool) => tool.id === id ? { ...tool, lastUsedAt: when.toISOString() } : tool);
-}
-
-// src/toolbox/ToolboxStore.ts
-var fsp = __toESM(require("fs/promises"));
-var path2 = __toESM(require("path"));
-var import_promises = require("timers/promises");
-
-// src/paths/userHome.ts
-var os = __toESM(require("os"));
-var path = __toESM(require("path"));
-var SERVICEME_DIR_NAME = ".serviceme";
-var SERVICEME_HOME_ENV = "SERVICEME_HOME";
-var activeOverrides = {};
-function resolveHomeDir() {
-  const injected = activeOverrides.homeDir;
-  if (injected !== void 0) {
-    return injected;
-  }
-  return os.homedir();
-}
-function resolveServicemeHomeEnv() {
-  const injected = activeOverrides.servicemeHomeEnv;
-  if (injected !== void 0) {
-    return injected.length > 0 ? injected : void 0;
-  }
-  const envValue = process.env[SERVICEME_HOME_ENV];
-  return envValue && envValue.length > 0 ? envValue : void 0;
-}
-function getServicemeHome() {
-  const override = resolveServicemeHomeEnv();
-  if (override !== void 0) {
-    return path.resolve(override);
-  }
-  return path.join(resolveHomeDir(), SERVICEME_DIR_NAME);
-}
-var TOOLBOX_JSON_FILENAME = "toolbox.json";
-function getToolboxJsonPath() {
-  return path.join(getServicemeHome(), TOOLBOX_JSON_FILENAME);
-}
-
-// src/toolbox/types.ts
-var TOOLBOX_JSON_SCHEMA_VERSION = 1;
-var 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"
-  }
-];
-
-// src/toolbox/ToolboxStore.ts
-var FILE_MODE = 384;
-var LOCK_DIR_MODE = 448;
-var DEFAULT_LOCK_TIMEOUT_MS = 5e3;
-var DEFAULT_LOCK_RETRY_MS = 25;
-var LOCK_STALE_GRACE_MS = 200;
-var TMP_SUFFIX = ".tmp";
-var WORKSPACE_TOOLBOX_RELATIVE_PATH = path2.join(".github", ".serviceme-toolbox.json");
-var LEGACY_WORKSPACE_TOOLBOX_FILENAME = ".ms-devtools-toolbox.json";
-async function migrateLegacyWorkspaceToolboxFile(filePath) {
-  if (!filePath) return;
-  const legacyPath = path2.join(path2.dirname(filePath), LEGACY_WORKSPACE_TOOLBOX_FILENAME);
-  if (legacyPath === filePath) return;
-  try {
-    await fsp.access(filePath);
-    return;
-  } catch {
-  }
-  try {
-    await fsp.rename(legacyPath, filePath);
-  } catch {
-  }
-}
-var FsToolboxFileBackend = class {
-  constructor() {
-    this.maxBackupCount = 5;
-  }
-  async exists(filePath) {
-    try {
-      await fsp.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async read(filePath) {
-    let buf;
-    try {
-      buf = await fsp.readFile(filePath, "utf8");
-    } catch (err) {
-      if (isNodeError(err) && err.code === "ENOENT") return null;
-      throw err;
-    }
-    try {
-      const parsed = JSON.parse(buf);
-      return coercePersistedToolbox(parsed);
-    } catch {
-      await this.backupCorruptedFile(filePath);
-      return null;
-    }
-  }
-  async backupCorruptedFile(filePath) {
-    try {
-      const backupPath = `${filePath}.corrupted.${Date.now()}.bak`;
-      await fsp.copyFile(filePath, backupPath);
-      await this.purgeExcessBackups(filePath);
-    } catch {
-    }
-  }
-  async purgeExcessBackups(filePath) {
-    const dir = path2.dirname(filePath);
-    const base = path2.basename(filePath);
-    let entries;
-    try {
-      entries = await fsp.readdir(dir);
-    } catch {
-      return;
-    }
-    const backups = entries.filter((n) => n.startsWith(base) && n.endsWith(".bak")).map((n) => ({ name: n, filePath: path2.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) => fsp.rm(b.filePath).catch(() => void 0))
-    );
-  }
-  async write(filePath, payload) {
-    await fsp.mkdir(path2.dirname(filePath), { recursive: true });
-    const tmpPath = `${filePath}${TMP_SUFFIX}`;
-    const bytes = Buffer.from(JSON.stringify(payload, null, "	"), "utf8");
-    await fsp.rm(tmpPath, { force: true });
-    const handle = await fsp.open(tmpPath, "w", FILE_MODE);
-    try {
-      await handle.writeFile(bytes);
-      await handle.sync();
-    } finally {
-      await handle.close();
-    }
-    await fsp.rename(tmpPath, filePath);
-    await fsp.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 !== TOOLBOX_JSON_SCHEMA_VERSION) {
-    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 = path2.join(this.dirPath, "pid");
-    this.timeoutMs = timeoutMs;
-    this.retryMs = retryMs;
-  }
-  async acquire() {
-    const start = Date.now();
-    while (true) {
-      try {
-        await fsp.mkdir(this.dirPath, { mode: LOCK_DIR_MODE });
-        await fsp.writeFile(this.pidFilePath, String(process.pid), "utf8").catch(() => void 0);
-        this.acquired = true;
-        return;
-      } catch (err) {
-        if (!isNodeError(err) || err.code !== "EEXIST") throw err;
-        const stale = await this.isStaleLock();
-        if (stale) {
-          await fsp.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, import_promises.setTimeout)(this.retryMs);
-      }
-    }
-  }
-  async isStaleLock() {
-    let pidStr;
-    try {
-      pidStr = await fsp.readFile(this.pidFilePath, "utf8");
-    } catch {
-      try {
-        const stat2 = await fsp.stat(this.dirPath);
-        return Date.now() - stat2.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 fsp.rm(this.dirPath, { recursive: true, force: true });
-  }
-};
-function defaultWorkspacePath() {
-  if (process.env.SERVICEME_NO_WORKSPACE_TOOLBOX === "1") return null;
-  return path2.join(process.cwd(), WORKSPACE_TOOLBOX_RELATIVE_PATH);
-}
-var ToolboxStore = class {
-  constructor(opts = {}) {
-    this.userFilePath = opts.userFilePath ?? 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 stored = filePath ? await this.backend.read(filePath) : null;
-    const storedTools = stored?.tools ?? [];
-    const defaults = this.defaults.map((seed, index) => toDefaultTool(seed, index));
-    const merged = mergeWithDefaults(defaults, storedTools);
-    const userOnly = storedTools.filter((t) => !this.defaults.some((d) => d.id === t.id));
-    void userOnly;
-    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: TOOLBOX_JSON_SCHEMA_VERSION,
-      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 stored = await this.backend.read(filePath);
-      const storedTools = stored?.tools ?? [];
-      const defaultIds = new Set(this.defaults.map((d) => d.id));
-      const userTools = storedTools.filter((t) => !defaultIds.has(t.id));
-      const next = await mutator(userTools);
-      const payload = {
-        version: TOOLBOX_JSON_SCHEMA_VERSION,
-        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 fsp.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"
-  };
-}
-
-// src/toolbox/ToolboxCore.ts
-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);
-    }
-    const next = 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
-        }
-      ];
-    });
-    return { scope, tools: next };
-  }
-  /**
-   * 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);
-    }
-    const removed = await this.store.mutate(
-      scope,
-      async (current) => current.filter((t) => t.id !== id)
-    );
-    return { scope, toolId: id, success: !removed.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);
-    const next = await this.store.mutate(scope, async (current) => {
-      if (isDefault) {
-        return current;
-      }
-      return current.map(
-        (tool) => tool.id === id ? { ...tool, ...patch, scope, isDefault: false } : tool
-      );
-    });
-    return { scope, tools: next };
-  }
-  /**
-   * 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);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BUILTIN_DEFAULT_TOOLS,
-  DefaultToolImmutableError,
-  FsToolboxFileBackend,
-  TOOLBOX_JSON_SCHEMA_VERSION,
-  ToolboxCore,
-  ToolboxStore,
-  WORKSPACE_TOOLBOX_RELATIVE_PATH,
-  mergeWithDefaults,
-  reindexOrder,
-  sortByRecentFirst,
-  sortByUserOrder,
-  touchLastUsedAt
-});
-//# sourceMappingURL=toolbox.js.map
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_toolbox = require("./toolbox-CxnOr-FY.js");
+exports.BUILTIN_DEFAULT_TOOLS = require_toolbox.BUILTIN_DEFAULT_TOOLS;
+exports.DefaultToolImmutableError = require_toolbox.DefaultToolImmutableError;
+exports.FsToolboxFileBackend = require_toolbox.FsToolboxFileBackend;
+exports.TOOLBOX_JSON_SCHEMA_VERSION = require_toolbox.TOOLBOX_JSON_SCHEMA_VERSION;
+exports.ToolboxCore = require_toolbox.ToolboxCore;
+exports.ToolboxStore = require_toolbox.ToolboxStore;
+exports.WORKSPACE_TOOLBOX_RELATIVE_PATH = require_toolbox.WORKSPACE_TOOLBOX_RELATIVE_PATH;
+exports.mergeWithDefaults = require_toolbox.mergeWithDefaults;
+exports.reindexOrder = require_toolbox.reindexOrder;
+exports.sortByRecentFirst = require_toolbox.sortByRecentFirst;
+exports.sortByUserOrder = require_toolbox.sortByUserOrder;
+exports.touchLastUsedAt = require_toolbox.touchLastUsedAt;