@uipath/solution-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/{packager-tool-7znqtw3f.js → packager-tool-9vvdgbay.js}

@@ -3,10 +3,10 @@ import {
   assertNoContributionErrors,
   collectProjectContributions,
   contributionErrorMessages
-} from "./packager-tool-znakt6yw.js";
+} from "./packager-tool-vh4ng74p.js";
 import {
   ensurePackagerTools
-} from "./packager-tool-k4mskzww.js";
+} from "./packager-tool-5dzjsw5q.js";
 import {
   Tokens,
   createResourceBuilderServices,
@@ -17,12 +17,14 @@ import {
   models_BindingsResourceType,
   readUipxProjects,
   syncAndLog
-} from "./packager-tool-bkwnetqn.js";
+} from "./packager-tool-83rzavkx.js";
 import {
   catchError,
-  getFileSystem,
   logger
-} from "./packager-tool-0f0wt9vh.js";
+} from "./packager-tool-5fjp60dk.js";
+import {
+  getFileSystem
+} from "./packager-tool-zf3929se.js";
 
 // src/services/emit-runtime-dependencies.ts
 import { createHash } from "node:crypto";
@@ -241,4 +243,4 @@ async function prepareSolutionResources(solutionDir, fs, options) {
 
 export { projectSubTypesFrom, prepareSolutionResources };
 
-//# debugId=66D4CB702D8B08F964756E2164756E21
+//# debugId=16FA8B6372D1A69964756E2164756E21

package/dist/packager-tool-bqre28m1.js

@@ -0,0 +1,43 @@
+import {
+  resolveSessionIdentity
+} from "./packager-tool-gb35b4qs.js";
+
+// src/services/feed-session.ts
+function classifyFeedSession(session) {
+  const type = (session.identity ?? resolveSessionIdentity(session.accessToken))?.type;
+  if (type === "User") {
+    return "user";
+  }
+  return type === "Application" ? "application" : "unknown";
+}
+function feedSessionRefusal(verdict, action, alternative) {
+  if (verdict === "application") {
+    return {
+      message: `${action} needs a user session; this session is an external app.`,
+      instructions: `The server does not apply X-UIPATH-FolderKey to client-credentials requests, so the request would run against the tenant feed instead. Run it with a user session ('uip login'), or ${alternative}.`
+    };
+  }
+  return {
+    message: `${action} needs a user session, and this session's kind could not be read from its token.`,
+    instructions: `The server applies X-UIPATH-FolderKey to user-token requests only, and a session that cannot be shown to be a user's is not allowed to act on a feed — guessing wrong would run the request against the tenant feed. Refresh the session with 'uip login' (an interactive login is recorded as a user session), or ${alternative}.`
+  };
+}
+function feedReadRefusalForApplication(session, action) {
+  if (classifyFeedSession(session) !== "application") {
+    return;
+  }
+  return feedSessionRefusal("application", action, "drop the feed flag to read the tenant feed");
+}
+
+class FeedReadRefusedError extends Error {
+  refusal;
+  constructor(refusal) {
+    super(refusal.message);
+    this.refusal = refusal;
+    this.name = "FeedReadRefusedError";
+  }
+}
+
+export { classifyFeedSession, feedSessionRefusal, feedReadRefusalForApplication, FeedReadRefusedError };
+
+//# debugId=46593028C6477B8B64756E2164756E21

package/dist/packager-tool-f5gq77m5.js

@@ -0,0 +1,28 @@
+import {
+  getAuthContext
+} from "./packager-tool-gb35b4qs.js";
+
+// ../solution-sdk/src/solution-auth.ts
+async function getSolutionAuthContext(options) {
+  const ctx = await getAuthContext({
+    tenant: options.tenant,
+    ensureTokenValidityMinutes: options.loginValidity ?? 10,
+    envFilePath: options.envFilePath,
+    requireOrganizationId: true,
+    requireTenantName: true
+  });
+  const organizationId = ctx.organizationId;
+  const tenantName = ctx.tenantName;
+  const basePath = `${ctx.baseUrl}/${organizationId}/${tenantName}/automationsolutions_`;
+  return {
+    accessToken: ctx.accessToken,
+    basePath,
+    organizationId,
+    tenantName,
+    identity: ctx.identity
+  };
+}
+
+export { getSolutionAuthContext };
+
+//# debugId=7C83D4398979D25864756E2164756E21

package/dist/{packager-tool-nzghfa48.js → packager-tool-fv7xyzg2.js}

@@ -1,3 +1,8 @@
+import {
+  unzipSync,
+  zipSync
+} from "./packager-tool-dfrk01gn.js";
+
 // ../packager/packager-core/src/services/tools-factory-repository.ts
 class ToolsFactoryRepository {
   projectFactoryMap = new Map;
@@ -44,6 +49,283 @@ if (!_global[REGISTRY_KEY]) {
   _global[REGISTRY_KEY] = new ToolsFactoryRepository;
 }
 var toolsFactoryRepository = _global[REGISTRY_KEY];
+
+// ../packager/packager-core/src/filesystem/path.ts
+class Path {
+  static normalize(path) {
+    return path.replace(/\\/g, "/").replace(/\/+/g, "/");
+  }
+  static join(...segments) {
+    return Path.normalize(segments.filter((s) => s.length > 0).join("/"));
+  }
+  static dirname(path) {
+    const normalized = Path.normalize(path).replace(/\/$/, "");
+    if (normalized === "")
+      return ".";
+    const lastSlash = normalized.lastIndexOf("/");
+    if (lastSlash === -1)
+      return ".";
+    if (lastSlash === 0)
+      return "/";
+    return normalized.substring(0, lastSlash);
+  }
+  static basename(path) {
+    const normalized = Path.normalize(path).replace(/\/$/, "");
+    if (normalized === "")
+      return "";
+    const lastSlash = normalized.lastIndexOf("/");
+    return lastSlash >= 0 ? normalized.substring(lastSlash + 1) : normalized;
+  }
+  static extname(path) {
+    const base = Path.basename(path);
+    const lastDot = base.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === 0 || lastDot === base.length - 1) {
+      return "";
+    }
+    return base.substring(lastDot);
+  }
+  static async walkDirectory(fs, rootPath, currentRelativePath = "") {
+    const entries = [];
+    const absolutePath = currentRelativePath ? Path.join(rootPath, currentRelativePath) : rootPath;
+    const items = await fs.readdir(absolutePath);
+    for (const item of items) {
+      const itemRelativePath = currentRelativePath ? Path.join(currentRelativePath, item) : item;
+      const itemAbsolutePath = Path.join(rootPath, itemRelativePath);
+      const stat = await fs.stat(itemAbsolutePath);
+      if (stat?.isDirectory()) {
+        const subEntries = await Path.walkDirectory(fs, rootPath, itemRelativePath);
+        entries.push(...subEntries);
+      } else if (stat?.isFile()) {
+        entries.push({
+          relativePath: Path.normalize(itemRelativePath),
+          absolutePath: Path.normalize(itemAbsolutePath)
+        });
+      }
+    }
+    return entries;
+  }
+}
+
+// ../packager/packager-core/src/models/nuget-constants.ts
+var NugetConstants = {
+  OutputFolderName: "bundle",
+  ContentFolderName: "content",
+  OperateFileName: "operate.json",
+  EntryPointsFileName: "entry-points.json",
+  PackageDescriptorFileName: "package-descriptor.json",
+  BindingsV2FileName: "bindings_v2.json",
+  BindingsFileId: "bindings.json"
+};
+
+// ../packager/packager-core/src/services/project-id.ts
+var OPERATE_FILE = "operate.json";
+var PROJECT_FILE = "project.json";
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+async function readJsonObject(fs, filePath) {
+  let content;
+  try {
+    content = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  if (content === null) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed === null || typeof parsed !== "object") {
+      return;
+    }
+    return parsed;
+  } catch {
+    return;
+  }
+}
+async function writeJsonObject(fs, filePath, data) {
+  await fs.writeFile(filePath, `${JSON.stringify(data, null, 2)}
+`);
+}
+async function ensureProjectId(projectPath, fs) {
+  const operatePath = Path.join(projectPath, OPERATE_FILE);
+  const operateExists = await fs.exists(operatePath);
+  if (operateExists) {
+    const operate = await readJsonObject(fs, operatePath);
+    if (operate && isNonEmptyString(operate.projectId)) {
+      return operate.projectId;
+    }
+    if (operate) {
+      const id = crypto.randomUUID();
+      await writeJsonObject(fs, operatePath, {
+        ...operate,
+        projectId: id
+      });
+      return id;
+    }
+    return crypto.randomUUID();
+  }
+  const projectFilePath = Path.join(projectPath, PROJECT_FILE);
+  const projectFileExists = await fs.exists(projectFilePath);
+  if (projectFileExists) {
+    const projectFile = await readJsonObject(fs, projectFilePath);
+    if (projectFile && isNonEmptyString(projectFile.projectId)) {
+      return projectFile.projectId;
+    }
+    if (projectFile) {
+      const id = crypto.randomUUID();
+      await writeJsonObject(fs, projectFilePath, {
+        ...projectFile,
+        projectId: id
+      });
+      return id;
+    }
+    return crypto.randomUUID();
+  }
+  return crypto.randomUUID();
+}
+async function ensureProjectIdInOperateFile(operateFilePath, fallbackProjectId, fs) {
+  if (!await fs.exists(operateFilePath)) {
+    return;
+  }
+  const parsed = await readJsonObject(fs, operateFilePath);
+  if (!parsed) {
+    return;
+  }
+  if (isNonEmptyString(parsed.projectId)) {
+    return;
+  }
+  await writeJsonObject(fs, operateFilePath, {
+    ...parsed,
+    projectId: fallbackProjectId
+  });
+}
+async function writeOrBackfillOperateProjectId(operateFilePath, projectId, fs, createIfMissing) {
+  if (await fs.exists(operateFilePath)) {
+    await ensureProjectIdInOperateFile(operateFilePath, projectId, fs);
+    return;
+  }
+  await createIfMissing();
+}
+// ../packager/packager-core/src/services/nuget-packager.ts
+function escapeXml(str) {
+  if (str === null || str === undefined) {
+    return "";
+  }
+  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function optionalElement(name, value) {
+  if (value === undefined || value === "")
+    return "";
+  return `    <${name}>${escapeXml(value)}</${name}>
+`;
+}
+function generateDependenciesXml(dependencies) {
+  if (!dependencies || dependencies.length === 0)
+    return "";
+  const deps = dependencies.map((d) => `      <dependency id="${escapeXml(d.id)}" version="${escapeXml(d.version)}" />`).join(`
+`);
+  return `    <dependencies>
+${deps}
+    </dependencies>
+`;
+}
+function generateRepositoryXml(packageInfo) {
+  if (!packageInfo.repositoryType || !packageInfo.repositoryUrl)
+    return "";
+  let repoXml = `    <repository type="${escapeXml(packageInfo.repositoryType)}" url="${escapeXml(packageInfo.repositoryUrl)}"`;
+  if (packageInfo.repositoryBranch) {
+    repoXml += ` branch="${escapeXml(packageInfo.repositoryBranch)}"`;
+  }
+  if (packageInfo.repositoryCommit) {
+    repoXml += ` commit="${escapeXml(packageInfo.repositoryCommit)}"`;
+  }
+  repoXml += ` />
+`;
+  return repoXml;
+}
+function generateNuspecXml(packageInfo) {
+  const author = packageInfo.author?.trim() || "UiPath";
+  const description = packageInfo.description?.trim() || "Created by UiPath";
+  const title = packageInfo.title?.trim() || packageInfo.id;
+  const requireLicenseAcceptance = packageInfo.requireLicenseAcceptance === true ? "true" : "false";
+  const releaseNotes = packageInfo.releaseNotes ?? "";
+  const xml = `\uFEFF<?xml version="1.0" encoding="utf-8"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata>
+    <id>${escapeXml(packageInfo.id)}</id>
+    <version>${escapeXml(packageInfo.version)}</version>
+    <title>${escapeXml(title)}</title>
+    <authors>${escapeXml(author)}</authors>
+    <requireLicenseAcceptance>${requireLicenseAcceptance}</requireLicenseAcceptance>
+    <description>${escapeXml(description)}</description>
+    <releaseNotes>${escapeXml(releaseNotes)}</releaseNotes>
+${optionalElement("tags", packageInfo.tags)}${optionalElement("iconUrl", packageInfo.iconUrl)}${optionalElement("projectUrl", packageInfo.projectUrl)}${optionalElement("licenseUrl", packageInfo.licenseUrl)}${optionalElement("copyright", packageInfo.copyright)}${generateRepositoryXml(packageInfo)}${generateDependenciesXml(packageInfo.dependencies)}  </metadata>
+</package>
+`;
+  return xml;
+}
+function generatePsmdcpXml(packageInfo) {
+  const author = packageInfo.author?.trim() || "UiPath";
+  const description = packageInfo.description?.trim() || "Created by UiPath";
+  return `<?xml version="1.0" encoding="utf-8"?>
+<coreProperties xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.openxmlformats.org/package/2006/metadata/core-properties">
+  <dc:creator>${escapeXml(author)}</dc:creator>
+  <dc:description>${escapeXml(description)}</dc:description>
+  <dc:identifier>${escapeXml(packageInfo.id)}</dc:identifier>
+  <version>${escapeXml(packageInfo.version)}</version>
+  <keywords></keywords>
+  <lastModifiedBy>NuGet.Packaging, Version=6.12.1.1, Culture=neutral, PublicKeyToken=31bf3856ad364e35;.NET 5.0</lastModifiedBy>
+</coreProperties>`;
+}
+
+class NugetPackager {
+  fileSystem;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async packAsync(rootPath, packageInfo, outputPath) {
+    const normalizedOutputPath = Path.normalize(outputPath);
+    const nuspecXml = generateNuspecXml(packageInfo);
+    const nuspecFileName = `${packageInfo.id}.nuspec`;
+    const fileEntries = await Path.walkDirectory(this.fileSystem, rootPath);
+    const zipContents = {};
+    const encoder = new TextEncoder;
+    const psmdcpId = Array.from({ length: 4 }, () => Math.floor(Math.random() * 4294967296).toString(16).padStart(8, "0")).join("");
+    const psmdcpFileName = `${psmdcpId}.psmdcp`;
+    const psmdcpPath = `package/services/metadata/core-properties/${psmdcpFileName}`;
+    const contentTypesXml = `<?xml version="1.0" encoding="utf-8"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" />
+  <Default Extension="psmdcp" ContentType="application/vnd.openxmlformats-package.core-properties+xml" />
+  <Default Extension="uiproj" ContentType="application/octet" />
+  <Default Extension="json" ContentType="application/octet" />
+  <Default Extension="nuspec" ContentType="application/octet" />
+</Types>`;
+    zipContents["[Content_Types].xml"] = encoder.encode(contentTypesXml);
+    const manifestRelId = `R${Date.now().toString(16).toUpperCase()}`;
+    const corePropsRelId = `R${(Date.now() + 1).toString(16).toUpperCase()}`;
+    const relsXml = `<?xml version="1.0" encoding="utf-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Type="http://schemas.microsoft.com/packaging/2010/07/manifest" Target="/${nuspecFileName}" Id="${manifestRelId}" />
+  <Relationship Type="http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties" Target="/${psmdcpPath}" Id="${corePropsRelId}" />
+</Relationships>`;
+    zipContents["_rels/.rels"] = encoder.encode(relsXml);
+    zipContents[psmdcpPath] = encoder.encode(generatePsmdcpXml(packageInfo));
+    zipContents[nuspecFileName] = encoder.encode(nuspecXml);
+    for (const entry of fileEntries) {
+      const content = await this.fileSystem.readFile(entry.absolutePath);
+      if (content !== null) {
+        zipContents[entry.relativePath] = content;
+      }
+    }
+    const zippedData = zipSync(zipContents);
+    await this.fileSystem.writeFile(normalizedOutputPath, zippedData);
+    return {
+      outputPath: normalizedOutputPath
+    };
+  }
+}
 // ../packager/packager-core/src/models/tool-result.ts
 class ToolResult {
   errorCode;
@@ -67,6 +349,180 @@ class ToolResult {
     return new ToolResult(errorCode, message, [], instructions);
   }
 }
+
+// ../packager/packager-core/src/services/project-tool.ts
+class ProjectTool {
+  fileSystem;
+  logger;
+  static ProjectFileName = "project.uiproj";
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is a noop");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is a noop");
+    return ToolResult.success();
+  }
+  async buildAsync(_options, _cancellationToken) {
+    this.logger.info("Build operation is a noop");
+    return ToolResult.success();
+  }
+  async packAsync(_options, _cancellationToken) {
+    this.logger.info("Pack operation is a noop");
+    return ToolResult.success();
+  }
+  async cleanupAsync(_options, _cancellationToken) {
+    this.logger.info("Cleanup operation is a noop");
+    return ToolResult.success();
+  }
+  async getUiProjectAsync(projectPath) {
+    const filePath = Path.join(projectPath, ProjectTool.ProjectFileName);
+    if (!await this.fileSystem.exists(filePath)) {
+      return;
+    }
+    const raw = await this.fileSystem.readFile(filePath);
+    if (!raw) {
+      return;
+    }
+    const json = typeof raw === "string" ? raw : new TextDecoder("utf-8").decode(raw);
+    return JSON.parse(json);
+  }
+  async dispose() {}
+}
+// ../packager/packager-core/src/services/solution-tool.ts
+class SolutionTool {
+  fileSystem;
+  logger;
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is a noop");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is a noop");
+    return ToolResult.success();
+  }
+  async buildAsync(_options, _cancellationToken) {
+    this.logger.info("Build operation is a noop");
+    return ToolResult.success();
+  }
+  async packAsync(_options, _cancellationToken) {
+    this.logger.info("Pack operation is a noop");
+    return ToolResult.success();
+  }
+  dispose() {}
+}
+// ../packager/packager-core/src/filesystem/temporary-storage-service.ts
+class TemporaryStorageService {
+  fileSystem;
+  _tempFolderPath = null;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async getTempFolderPath() {
+    if (!this._tempFolderPath) {
+      const systemTempDir = await this.fileSystem.getTempDir();
+      const uniqueFolderName = this.generateUniqueFolderName();
+      this._tempFolderPath = Path.join(systemTempDir, uniqueFolderName);
+      await this.fileSystem.mkdir(this._tempFolderPath);
+    }
+    return this._tempFolderPath;
+  }
+  generateUniqueFolderName() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 10);
+    return `tool-temp-${timestamp}-${random}`;
+  }
+  async getTempSubfolderPathAsync(subfolder) {
+    const tempFolderPath = await this.getTempFolderPath();
+    const inputPath = Path.join(tempFolderPath, subfolder);
+    await this.fileSystem.mkdir(inputPath);
+    return inputPath;
+  }
+  async cleanup() {
+    try {
+      if (!this._tempFolderPath) {
+        return;
+      }
+      try {
+        const stats = await this.fileSystem.stat(this._tempFolderPath);
+        if (!stats) {
+          return;
+        }
+      } catch {
+        return;
+      }
+      const _pathToCleanup = this._tempFolderPath;
+      await this.fileSystem.rm(this._tempFolderPath);
+      this._tempFolderPath = null;
+    } catch {}
+  }
+}
+// ../packager/packager-core/src/filesystem/zip-service.ts
+class ZipService {
+  fileSystem;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async extractAsync(zipData, targetPath) {
+    const normalizedTarget = targetPath.replace(/\/$/, "");
+    const files = unzipSync(zipData);
+    const dirsToCreate = new Set([normalizedTarget]);
+    const filesToWrite = [];
+    const extractedPaths = [];
+    for (const [relativePath, data] of Object.entries(files)) {
+      if (relativePath.endsWith("/") || data.length === 0) {
+        const dirPath = `${normalizedTarget}/${relativePath.replace(/\/$/, "")}`;
+        if (!dirPath.startsWith(`${normalizedTarget}/`)) {
+          throw new Error(`Zip-slip detected: entry "${relativePath}" escapes extraction directory`);
+        }
+        dirsToCreate.add(dirPath);
+        continue;
+      }
+      const fullPath = `${normalizedTarget}/${relativePath}`;
+      if (!fullPath.startsWith(`${normalizedTarget}/`)) {
+        throw new Error(`Zip-slip detected: entry "${relativePath}" escapes extraction directory`);
+      }
+      const parentDir = fullPath.split("/").slice(0, -1).join("/");
+      if (parentDir) {
+        dirsToCreate.add(parentDir);
+      }
+      filesToWrite.push({ path: fullPath, data });
+      extractedPaths.push(fullPath);
+    }
+    await Promise.all(Array.from(dirsToCreate, (dir) => this.fileSystem.mkdir(dir)));
+    await Promise.all(filesToWrite.map(({ path, data }) => this.fileSystem.writeFile(path, data)));
+    return extractedPaths;
+  }
+  async compressAsync(sourcePath) {
+    const normalizedSource = sourcePath.replace(/\/$/, "");
+    const entries = await Path.walkDirectory(this.fileSystem, normalizedSource);
+    const fileContents = await Promise.all(entries.map(async (entry) => ({
+      relativePath: entry.relativePath,
+      data: await this.fileSystem.readFile(entry.absolutePath)
+    })));
+    const zippable = {};
+    for (const { relativePath, data } of fileContents) {
+      if (data) {
+        zippable[relativePath] = data;
+      }
+    }
+    const zipData = zipSync(zippable, {
+      level: 6
+    });
+    return zipData;
+  }
+  compressEntries(entries) {
+    return zipSync(entries, { level: 6 });
+  }
+}
 // ../packager/packager-core/src/i18n/types.ts
 function isPluralForm(value) {
   return typeof value === "object" && value !== null && "other" in value;
@@ -890,6 +1346,98 @@ I18nManager.registerTranslations("zh-cn", zh_CN);
 I18nManager.registerTranslations("zh-tw", zh_TW);
 I18nManager.registerTranslations("zu", zu);
 I18nManager.setLocale("en");
-export { ToolResult, toolsFactoryRepository };
+// ../packager/packager-core/src/models/ignored-rules.ts
+function normalizeIgnoredRules(ignoredRules) {
+  const rules = (ignoredRules ?? []).flatMap((rule) => rule.split(",")).map((rule) => rule.trim()).filter((rule) => rule.length > 0);
+  return [...new Set(rules)];
+}
+// ../packager/packager-core/src/models/log-message.ts
+class LogMessage {
+  message;
+  logLevel;
+  source;
+  sourceTarget;
+  progress;
+  code;
+  filePath;
+  line;
+  id;
+  timestamp;
+  constructor(message, logLevel, options, timestamp) {
+    this.message = message;
+    this.logLevel = LogMessage.toLogLevel(logLevel);
+    this.source = options?.source;
+    this.sourceTarget = options?.sourceTarget;
+    this.progress = options?.progress;
+    this.code = options?.code;
+    this.filePath = options?.filePath;
+    this.line = options?.line;
+    this.id = options?.id;
+    this.timestamp = LogMessage.resolveTimestamp(timestamp);
+  }
+  static resolveTimestamp(timestamp) {
+    if (timestamp instanceof Date) {
+      return timestamp;
+    }
+    if (timestamp === undefined || timestamp === null) {
+      return new Date;
+    }
+    const parsed = new Date(timestamp);
+    if (Number.isNaN(parsed.getTime())) {
+      console.error(`[LogMessage] invalid timestamp "${timestamp}", defaulting to now`);
+      return new Date;
+    }
+    return parsed;
+  }
+  static toLogLevel(level) {
+    switch (level) {
+      case "Verbose":
+      case "Trace":
+      case "Debug":
+        return "Debug" /* Debug */;
+      case "Warn":
+      case "Warning":
+        return "Warning" /* Warn */;
+      case "Error":
+      case "Critical":
+        return "Error" /* Error */;
+      default:
+        return "Information" /* Info */;
+    }
+  }
+  toFormattedString() {
+    const parts = [];
+    parts.push(`[${this.timestamp.toISOString()}]`);
+    parts.push(`[${String(this.logLevel).toUpperCase()}]`);
+    if (this.source) {
+      parts.push(`[${this.source}]`);
+    }
+    if (this.sourceTarget) {
+      parts.push(`[${this.sourceTarget}]`);
+    }
+    const locationParts = [];
+    if (this.filePath) {
+      locationParts.push(this.filePath);
+    }
+    if (this.line) {
+      locationParts.push(`Line:${this.line}`);
+    }
+    if (this.id) {
+      locationParts.push(`Id:${this.id}`);
+    }
+    if (locationParts.length > 0) {
+      parts.push(`(${locationParts.join("")})`);
+    }
+    if (this.code) {
+      parts.push(`[${this.code}]`);
+    }
+    if (this.progress || this.progress === 0) {
+      parts.push(`${this.progress}%`);
+    }
+    parts.push(this.message);
+    return parts.join(" ");
+  }
+}
+export { Path, TemporaryStorageService, ZipService, I18nManager, translate, normalizeIgnoredRules, LogMessage, NugetConstants, ToolResult, ensureProjectId, writeOrBackfillOperateProjectId, NugetPackager, ProjectTool, SolutionTool, toolsFactoryRepository };
 
-//# debugId=C6B394D3F76A061364756E2164756E21
+//# debugId=7E433C7A73ED1B5664756E2164756E21