@spzhongwin/skill-logger-plugin 1.0.18 → 1.0.19

package/src/free-skill-writer.ts

@@ -0,0 +1,591 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  FreeSkillWorkspaceError,
+  resolveFreeSkillWorkspace,
+  type FreeSkillWorkspace,
+  type FreeSkillWorkspaceContext,
+} from "./free-skill-workspace.ts";
+
+const FREE_SKILL_DIRECTORY_NAME = ".xg-platform";
+const SKILL_FILE_NAME = "SKILL.md";
+
+export type FreeSkillWriteErrorCode =
+  | "INVALID_SKILL_NAME"
+  | "INVALID_CONTENT"
+  | "INVALID_FRONTMATTER"
+  | "MISSING_NAME"
+  | "MISSING_DESCRIPTION"
+  | "EMPTY_BODY"
+  | "INVALID_METADATA"
+  | "TARGET_ESCAPE"
+  | "TARGET_SYMLINK"
+  | "TARGET_NOT_DIRECTORY"
+  | "TARGET_UNAVAILABLE"
+  | "SKILL_EXISTS"
+  | "ATOMIC_WRITE_FAILED"
+  | FreeSkillWorkspaceError["code"];
+
+export class FreeSkillWriterError extends Error {
+  public readonly code: FreeSkillWriteErrorCode;
+
+  constructor(code: FreeSkillWriteErrorCode, message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.code = code;
+    this.name = "FreeSkillWriterError";
+  }
+}
+
+type FrontmatterScalar = {
+  kind: "scalar";
+  value: string;
+};
+
+type FrontmatterOther = {
+  kind: "other";
+};
+
+type FrontmatterValue = FrontmatterScalar | FrontmatterOther;
+
+type ParsedSkillContent = {
+  name: string;
+  description: string;
+  body: string;
+};
+
+type StringRecord = Record<string, unknown>;
+
+/** 只声明写入核心使用的最小 fs 接口，便于测试原子 rename 失败。 */
+export type FreeSkillWriterFileSystem = {
+  lstat: typeof fs.lstat;
+  realpath: typeof fs.realpath;
+  stat: typeof fs.stat;
+  mkdir: typeof fs.mkdir;
+  writeFile: typeof fs.writeFile;
+  rename: typeof fs.rename;
+  rm: typeof fs.rm;
+};
+
+export type FreeSkillWriteInput = {
+  /** Skill 的一级目录名；`name` 是兼容别名。 */
+  skillName?: unknown;
+  name?: unknown;
+  /** 完整 SKILL.md 内容。 */
+  content?: unknown;
+  skillContent?: unknown;
+  /** 可选 JSON 元数据，会落盘为 `.meta.json`。 */
+  metadata?: unknown;
+  /** 必须是 resolveFreeSkillWorkspace 的返回值。 */
+  workspace?: FreeSkillWorkspace;
+  /** 运行时注入的 workspace context；不会读取 target/path 字段。 */
+  context?: FreeSkillWorkspaceContext | unknown;
+};
+
+export type FreeSkillWriteSuccess = {
+  success: true;
+  skillName: string;
+  directoryPath: string;
+  skillFilePath: string;
+  metadataFilePath?: string;
+};
+
+export type FreeSkillWriteFailure = {
+  success: false;
+  code: FreeSkillWriteErrorCode;
+  message: string;
+};
+
+export type FreeSkillWriteResult = FreeSkillWriteSuccess | FreeSkillWriteFailure;
+
+type WorkspaceInput = FreeSkillWorkspace | FreeSkillWorkspaceContext | unknown;
+
+const defaultFileSystem: FreeSkillWriterFileSystem = {
+  lstat: fs.lstat,
+  realpath: fs.realpath,
+  stat: fs.stat,
+  mkdir: fs.mkdir,
+  writeFile: fs.writeFile,
+  rename: fs.rename,
+  rm: fs.rm,
+};
+
+function isRecord(value: unknown): value is StringRecord {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isWithin(parent: string, candidate: string): boolean {
+  const relative = path.relative(parent, candidate);
+  return relative === ""
+    || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+
+function asErrnoCode(error: unknown): string | undefined {
+  return typeof error === "object" && error !== null && "code" in error
+    ? String((error as { code?: unknown }).code)
+    : undefined;
+}
+
+function asMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function fail(code: FreeSkillWriteErrorCode, message: string): never {
+  throw new FreeSkillWriterError(code, message);
+}
+
+function stripYamlComment(value: string): string {
+  let quote: "'" | '"' | undefined;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote === '"' && character === "\\") {
+      index += 1;
+      continue;
+    }
+    if ((character === "'" || character === '"') && (!quote || quote === character)) {
+      if (quote === "'" && character === "'" && value[index + 1] === "'") {
+        index += 1;
+        continue;
+      }
+      quote = quote ? undefined : character;
+      continue;
+    }
+    if (!quote && character === "#" && (index === 0 || /\s/.test(value[index - 1]))) {
+      return value.slice(0, index).trimEnd();
+    }
+  }
+  return value.trim();
+}
+
+function parseQuotedScalar(rawValue: string): string | undefined {
+  if (rawValue.startsWith('"')) {
+    if (!rawValue.endsWith('"')) return undefined;
+    try {
+      const parsed: unknown = JSON.parse(rawValue);
+      return typeof parsed === "string" ? parsed : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
+  if (rawValue.startsWith("'")) {
+    if (!rawValue.endsWith("'")) return undefined;
+    const inner = rawValue.slice(1, -1);
+    let value = "";
+    for (let index = 0; index < inner.length; index += 1) {
+      if (inner[index] === "'" && inner[index + 1] === "'") {
+        value += "'";
+        index += 1;
+      } else if (inner[index] === "'") {
+        return undefined;
+      } else {
+        value += inner[index];
+      }
+    }
+    return value;
+  }
+
+  return undefined;
+}
+
+function hasBalancedCollection(value: string): boolean {
+  const opening = value[0];
+  const closing = opening === "[" ? "]" : "}";
+  if ((opening !== "[" && opening !== "{") || !value.endsWith(closing)) return false;
+
+  let depth = 0;
+  let quote: "'" | '"' | undefined;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote === '"' && character === "\\") {
+      index += 1;
+      continue;
+    }
+    if ((character === "'" || character === '"') && (!quote || quote === character)) {
+      if (quote === "'" && character === "'" && value[index + 1] === "'") {
+        index += 1;
+        continue;
+      }
+      quote = quote ? undefined : character;
+      continue;
+    }
+    if (quote) continue;
+    if (character === opening) depth += 1;
+    if (character === closing) depth -= 1;
+    if (depth < 0) return false;
+  }
+  return depth === 0 && !quote;
+}
+
+function parseInlineValue(rawValue: string): FrontmatterValue {
+  const value = stripYamlComment(rawValue);
+  if (value.startsWith('"') || value.startsWith("'")) {
+    const parsed = parseQuotedScalar(value);
+    if (parsed === undefined) fail("INVALID_FRONTMATTER", "SKILL.md frontmatter 中存在未闭合或无效字符串");
+    return { kind: "scalar", value: parsed };
+  }
+  if (value.startsWith("[") || value.startsWith("{")) {
+    if (!hasBalancedCollection(value)) {
+      fail("INVALID_FRONTMATTER", "SKILL.md frontmatter 中存在未闭合集合值");
+    }
+    return { kind: "other" };
+  }
+  return { kind: "scalar", value };
+}
+
+function parseBlockValue(
+  lines: string[],
+  startIndex: number,
+  header: string,
+): { value: string; nextIndex: number } {
+  const headerMatch = /^([|>])(?:[+-]|[1-9])?$/.exec(header);
+  if (!headerMatch) fail("INVALID_FRONTMATTER", "SKILL.md frontmatter 中存在无效块标量");
+
+  const blockLines: string[] = [];
+  let index = startIndex;
+  let contentIndent: number | undefined;
+  while (index < lines.length) {
+    const line = lines[index];
+    if (line.trim() !== "" && !/^\s+/.test(line)) break;
+    if (line.trim() === "") {
+      blockLines.push("");
+      index += 1;
+      continue;
+    }
+    const indent = line.match(/^\s*/)?.[0].length ?? 0;
+    contentIndent ??= indent;
+    if (indent < contentIndent) break;
+    blockLines.push(line.slice(contentIndent));
+    index += 1;
+  }
+
+  if (headerMatch[1] === ">") {
+    const folded: string[] = [];
+    for (const line of blockLines) {
+      if (line === "") {
+        folded.push("\n");
+      } else if (folded.length > 0 && folded[folded.length - 1] !== "\n") {
+        folded.push(" ", line);
+      } else {
+        folded.push(line);
+      }
+    }
+    return { value: folded.join(""), nextIndex: index };
+  }
+
+  return { value: blockLines.join("\n"), nextIndex: index };
+}
+
+function parseFrontmatter(content: string): ParsedSkillContent {
+  const normalized = content.replace(/^\uFEFF/, "");
+  const lines = normalized.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") {
+    fail("INVALID_FRONTMATTER", "SKILL.md 必须以 YAML frontmatter 开始");
+  }
+
+  const fields = new Map<string, FrontmatterValue>();
+  let closingIndex = -1;
+  let index = 1;
+  while (index < lines.length) {
+    const line = lines[index];
+    const trimmed = line.trim();
+    if (trimmed === "---" || trimmed === "...") {
+      closingIndex = index;
+      break;
+    }
+    if (trimmed === "" || trimmed.startsWith("#")) {
+      index += 1;
+      continue;
+    }
+    if (/^\s/.test(line) || line.includes("\t")) {
+      fail("INVALID_FRONTMATTER", "SKILL.md frontmatter 中存在无效缩进");
+    }
+
+    const match = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*?)\s*$/.exec(line);
+    if (!match) fail("INVALID_FRONTMATTER", "SKILL.md frontmatter 中存在无效字段");
+    const [, key, rawValue] = match;
+    if (fields.has(key)) fail("INVALID_FRONTMATTER", `SKILL.md frontmatter 字段重复: ${key}`);
+
+    const value = stripYamlComment(rawValue);
+    if (value === "|" || value === ">" || /^[|>][+-]$/.test(value)) {
+      const block = parseBlockValue(lines, index + 1, value);
+      fields.set(key, { kind: "scalar", value: block.value });
+      index = block.nextIndex;
+      continue;
+    }
+    fields.set(key, parseInlineValue(rawValue));
+    index += 1;
+  }
+
+  if (closingIndex < 0) fail("INVALID_FRONTMATTER", "SKILL.md frontmatter 缺少结束标记");
+
+  const name = fields.get("name");
+  if (!name || name.kind !== "scalar" || !name.value.trim()) {
+    fail("MISSING_NAME", "SKILL.md frontmatter 必须包含非空 name");
+  }
+  const description = fields.get("description");
+  if (!description || description.kind !== "scalar" || !description.value.trim()) {
+    fail("MISSING_DESCRIPTION", "SKILL.md frontmatter 必须包含非空 description");
+  }
+
+  const body = lines.slice(closingIndex + 1).join("\n");
+  if (!body.trim()) fail("EMPTY_BODY", "SKILL.md 正文不能为空");
+  return { name: name.value.trim(), description: description.value.trim(), body };
+}
+
+/** 校验并提取 SKILL.md 的最小必要字段。 */
+export function validateFreeSkillContent(content: unknown): ParsedSkillContent {
+  if (typeof content !== "string") fail("INVALID_CONTENT", "SKILL.md 内容必须是字符串");
+  return parseFrontmatter(content);
+}
+
+function validateSkillName(value: unknown): string {
+  if (typeof value !== "string" || value.length === 0 || value !== value.trim()) {
+    fail("INVALID_SKILL_NAME", "Skill 名称必须是非空的单级目录名");
+  }
+  if (
+    value === "."
+    || value === ".."
+    || value.startsWith(".")
+    || value.endsWith(".")
+    || value.endsWith(" ")
+    || path.basename(value) !== value
+    || path.win32.basename(value) !== value
+    || path.isAbsolute(value)
+    || /[\\/\0<>:"|?*\u0000-\u001f\u007f]/u.test(value)
+  ) {
+    fail("INVALID_SKILL_NAME", `非法的 Skill 名称: ${value}`);
+  }
+  return value;
+}
+
+function serializeMetadata(value: unknown): string | undefined {
+  if (value === undefined) return undefined;
+  if (!isRecord(value)) fail("INVALID_METADATA", ".meta.json metadata 必须是 JSON 对象");
+  try {
+    const serialized = JSON.stringify(value, null, 2);
+    if (serialized === undefined) fail("INVALID_METADATA", ".meta.json metadata 无法序列化");
+    return `${serialized}\n`;
+  } catch (error) {
+    fail("INVALID_METADATA", `.meta.json metadata 无法序列化: ${asMessage(error)}`);
+  }
+}
+
+function isResolvedWorkspace(value: unknown): value is FreeSkillWorkspace {
+  if (!isRecord(value)) return false;
+  return typeof value.workspacePath === "string"
+    && typeof value.directoryPath === "string"
+    && value.workspaceRelativePath === FREE_SKILL_DIRECTORY_NAME;
+}
+
+async function ensurePlatformDirectory(
+  workspace: FreeSkillWorkspace,
+  io: FreeSkillWriterFileSystem,
+): Promise<{ workspacePath: string; directoryPath: string }> {
+  if (!path.isAbsolute(workspace.workspacePath) || !path.isAbsolute(workspace.directoryPath)) {
+    fail("TARGET_ESCAPE", "Skill workspace 路径必须是解析器返回的绝对路径");
+  }
+
+  let workspacePath: string;
+  try {
+    workspacePath = await io.realpath(path.resolve(workspace.workspacePath));
+    const workspaceStat = await io.stat(workspacePath);
+    if (!workspaceStat.isDirectory()) fail("WORKSPACE_NOT_DIRECTORY", "Agent workspace 不是目录");
+  } catch (error) {
+    if (error instanceof FreeSkillWriterError) throw error;
+    fail("WORKSPACE_MISSING", `Agent workspace 不存在或不可访问: ${asMessage(error)}`);
+  }
+
+  const directoryPath = path.resolve(workspacePath, FREE_SKILL_DIRECTORY_NAME);
+  if (!isWithin(workspacePath, directoryPath) || path.resolve(workspace.directoryPath) !== directoryPath) {
+    fail("TARGET_ESCAPE", "自由 Skill 目标目录必须是 workspace/.xg-platform");
+  }
+
+  let entry;
+  try {
+    entry = await io.lstat(directoryPath);
+  } catch (error) {
+    if (asErrnoCode(error) !== "ENOENT") {
+      fail("TARGET_UNAVAILABLE", `无法检查自由 Skill 目标目录: ${asMessage(error)}`);
+    }
+    try {
+      await io.mkdir(directoryPath, { recursive: false });
+      entry = await io.lstat(directoryPath);
+    } catch (mkdirError) {
+      if (asErrnoCode(mkdirError) !== "EEXIST") {
+        fail("ATOMIC_WRITE_FAILED", `创建自由 Skill 目标目录失败: ${asMessage(mkdirError)}`);
+      }
+      try {
+        entry = await io.lstat(directoryPath);
+      } catch (statError) {
+        fail("TARGET_UNAVAILABLE", `无法检查自由 Skill 目标目录: ${asMessage(statError)}`);
+      }
+    }
+  }
+
+  if (entry.isSymbolicLink()) fail("TARGET_SYMLINK", "拒绝写入符号链接目标目录");
+  if (!entry.isDirectory()) fail("TARGET_NOT_DIRECTORY", "自由 Skill 目标不是目录");
+
+  let realDirectory: string;
+  try {
+    realDirectory = await io.realpath(directoryPath);
+  } catch (error) {
+    fail("TARGET_UNAVAILABLE", `无法解析自由 Skill 目标目录: ${asMessage(error)}`);
+  }
+  if (realDirectory !== directoryPath || !isWithin(workspacePath, realDirectory)) {
+    fail("TARGET_ESCAPE", "自由 Skill 目标目录越出 Agent workspace");
+  }
+  return { workspacePath, directoryPath };
+}
+
+async function resolveWriterWorkspace(
+  input: FreeSkillWriteInput,
+  suppliedWorkspace: WorkspaceInput | undefined,
+  io: FreeSkillWriterFileSystem,
+): Promise<{ workspacePath: string; directoryPath: string }> {
+  let workspace: FreeSkillWorkspace;
+  const candidate = suppliedWorkspace ?? input.workspace;
+  if (isResolvedWorkspace(candidate)) {
+    workspace = candidate;
+  } else {
+    const context = input.context ?? candidate ?? input;
+    try {
+      workspace = await resolveFreeSkillWorkspace(context);
+    } catch (error) {
+      if (error instanceof FreeSkillWorkspaceError) throw error;
+      fail("WORKSPACE_MISSING", `无法解析 Agent workspace: ${asMessage(error)}`);
+    }
+  }
+  return ensurePlatformDirectory(workspace, io);
+}
+
+function makeTemporaryPath(directoryPath: string, skillName: string, suffix: string): string {
+  return path.join(
+    directoryPath,
+    `.${skillName}.${suffix}-${process.pid}-${Date.now()}-${crypto.randomUUID()}`,
+  );
+}
+
+async function removePath(io: FreeSkillWriterFileSystem, target: string): Promise<void> {
+  await io.rm(target, { recursive: true, force: true }).catch(() => undefined);
+}
+
+async function targetAlreadyExists(
+  targetPath: string,
+  io: FreeSkillWriterFileSystem,
+): Promise<"symlink" | "exists" | "missing"> {
+  try {
+    const entry = await io.lstat(targetPath);
+    return entry.isSymbolicLink() ? "symlink" : "exists";
+  } catch (error) {
+    if (asErrnoCode(error) === "ENOENT") return "missing";
+    fail("TARGET_UNAVAILABLE", `无法检查 Skill 目标目录: ${asMessage(error)}`);
+  }
+}
+
+/**
+ * 创建自由 Skill。目标根目录始终来自 resolveFreeSkillWorkspace 的结果，
+ * 不读取 input 中任何 target/path 字段。
+ */
+export async function writeFreeSkill(
+  input: FreeSkillWriteInput,
+  workspace?: WorkspaceInput,
+  dependencies?: { fileSystem?: Partial<FreeSkillWriterFileSystem> },
+): Promise<FreeSkillWriteResult> {
+  const io: FreeSkillWriterFileSystem = {
+    ...defaultFileSystem,
+    ...dependencies?.fileSystem,
+  };
+
+  try {
+    if (!isRecord(input)) fail("INVALID_CONTENT", "Skill 写入请求必须是对象");
+    const skillName = validateSkillName(input.skillName ?? input.name);
+    const content = input.content ?? input.skillContent;
+    validateFreeSkillContent(content);
+    const metadata = serializeMetadata(input.metadata);
+    const { directoryPath: platformDirectoryPath } = await resolveWriterWorkspace(input, workspace, io);
+    const targetDirectoryPath = path.resolve(platformDirectoryPath, skillName);
+    if (!isWithin(platformDirectoryPath, targetDirectoryPath)) {
+      fail("TARGET_ESCAPE", "Skill 目标目录越出 workspace/.xg-platform");
+    }
+
+    const existing = await targetAlreadyExists(targetDirectoryPath, io);
+    if (existing === "symlink") fail("TARGET_SYMLINK", "拒绝写入符号链接 Skill 目录");
+    if (existing === "exists") fail("SKILL_EXISTS", `Skill 已存在: ${skillName}`);
+
+    let createdTargetDirectory = false;
+    let skillTempPath: string | undefined;
+    let metadataTempPath: string | undefined;
+    const skillFilePath = path.join(targetDirectoryPath, SKILL_FILE_NAME);
+    const metadataFilePath = metadata ? path.join(targetDirectoryPath, ".meta.json") : undefined;
+    try {
+      try {
+        await io.mkdir(targetDirectoryPath, { recursive: false });
+        createdTargetDirectory = true;
+      } catch (error) {
+        if (asErrnoCode(error) === "EEXIST") {
+          const raced = await targetAlreadyExists(targetDirectoryPath, io);
+          if (raced === "symlink") fail("TARGET_SYMLINK", "拒绝写入符号链接 Skill 目录");
+          fail("SKILL_EXISTS", `Skill 已存在: ${skillName}`);
+        }
+        fail("ATOMIC_WRITE_FAILED", `创建 Skill 目录失败: ${asMessage(error)}`);
+      }
+
+      skillTempPath = makeTemporaryPath(targetDirectoryPath, skillName, "skill-md-tmp");
+      await io.writeFile(skillTempPath, content as string, {
+        encoding: "utf8",
+        flag: "wx",
+        mode: 0o600,
+      });
+      await io.rename(skillTempPath, skillFilePath);
+      skillTempPath = undefined;
+
+      if (metadata && metadataFilePath) {
+        metadataTempPath = makeTemporaryPath(targetDirectoryPath, skillName, "metadata-tmp");
+        await io.writeFile(metadataTempPath, metadata, {
+          encoding: "utf8",
+          flag: "wx",
+          mode: 0o600,
+        });
+        await io.rename(metadataTempPath, metadataFilePath);
+        metadataTempPath = undefined;
+      }
+    } catch (error) {
+        if (error instanceof FreeSkillWriterError && error.code === "SKILL_EXISTS") throw error;
+      await Promise.all([
+        skillTempPath ? removePath(io, skillTempPath) : Promise.resolve(),
+        metadataTempPath ? removePath(io, metadataTempPath) : Promise.resolve(),
+      ]);
+      if (createdTargetDirectory) await removePath(io, targetDirectoryPath);
+      if (error instanceof FreeSkillWriterError) throw error;
+      fail("ATOMIC_WRITE_FAILED", `自由 Skill 原子写入失败: ${asMessage(error)}`);
+    }
+
+    return {
+      success: true,
+      skillName,
+      directoryPath: targetDirectoryPath,
+      skillFilePath,
+      ...(metadataFilePath ? { metadataFilePath } : {}),
+    };
+  } catch (error) {
+    if (error instanceof FreeSkillWriterError) {
+      return { success: false, code: error.code, message: error.message };
+    }
+    if (error instanceof FreeSkillWorkspaceError) {
+      return { success: false, code: error.code, message: error.message };
+    }
+    return { success: false, code: "ATOMIC_WRITE_FAILED", message: `自由 Skill 写入失败: ${asMessage(error)}` };
+  }
+}
+
+/** 需要异常控制流时使用的包装入口；错误 code 与 writeFreeSkill 保持一致。 */
+export async function writeFreeSkillOrThrow(
+  input: FreeSkillWriteInput,
+  workspace?: WorkspaceInput,
+  dependencies?: { fileSystem?: Partial<FreeSkillWriterFileSystem> },
+): Promise<FreeSkillWriteSuccess> {
+  const result = await writeFreeSkill(input, workspace, dependencies);
+  if (!result.success) throw new FreeSkillWriterError(result.code, result.message);
+  return result;
+}

package/src/index.ts

@@ -27,6 +27,7 @@ import { GatewayWsClient } from "./ws-client.ts";
 let wsClient: GatewayWsClient | undefined;
 
 import { Hooks, isSkillMdReadPath } from "./hooks.ts";
+import { createFreeSkillToolFactory, FREE_SKILL_TOOL_NAME } from "./free-skill-tool.ts";
 
 // 供单测复用（保留历史测试）。
 export { isSkillMdReadPath };
@@ -38,6 +39,7 @@ type PluginApi = {
     hookName: string,
     handler: (event: Record<string, unknown>, ctx: Record<string, unknown>) => any
   ) => void;
+  registerTool?: (tool: unknown, opts?: { name?: string; names?: string[]; optional?: boolean }) => void;
 };
 
 /** 本地扫描对账周期：发现新增 agent/skill（纯本地 I/O），固定 3 分钟。 */
@@ -63,6 +65,9 @@ const definition = {
   description:
     "追踪 openclaw skill 内功能点（脚本/命令/工具/HTTP）使用与报错，落本地并批量上报",
   register(api: PluginApi) {
+    if (typeof api.registerTool === "function") {
+      api.registerTool(createFreeSkillToolFactory, { name: FREE_SKILL_TOOL_NAME });
+    }
     let pkgVersion = "unknown";
     try {
       const dir = path.dirname(fileURLToPath(import.meta.url));