@simplysm/sd-cli 13.0.75 → 13.0.77

package/src/commands/device.ts

@@ -1,5 +1,5 @@
 import path from "path";
-import { fsExists } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 import { consola } from "consola";
 import type { SdConfig, SdClientPackageConfig } from "../sd-config.types";
 import { loadSdConfig } from "../utils/sd-config";
@@ -43,7 +43,7 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
   // Load sd.config.ts
   let sdConfig: SdConfig;
   try {
-    sdConfig = await loadSdConfig({ cwd, dev: true, opt: options.options });
+    sdConfig = await loadSdConfig({ cwd, dev: true, options: options.options });
     logger.debug("sd.config.ts loaded");
   } catch (err) {
     logger.error(`Failed to load sd.config.ts: ${err instanceof Error ? err.message : err}`);
@@ -114,7 +114,7 @@ export async function runDevice(options: DeviceOptions): Promise<void> {
     logger.debug("development server URL", { serverUrl });
 
     const capPath = path.join(pkgDir, ".capacitor");
-    if (!(await fsExists(capPath))) {
+    if (!(await fsx.exists(capPath))) {
       logger.error(
         `Capacitor project is not initialized. First run 'pnpm watch ${packageName}'.`,
       );

package/src/commands/lint.ts

@@ -1,11 +1,10 @@
 import { ESLint } from "eslint";
 import { createJiti } from "jiti";
 import path from "path";
-import { fsExists, fsGlob, pathFilterByTargets } from "@simplysm/core-node";
+import { fsx, pathx } from "@simplysm/core-node";
 import "@simplysm/core-common";
 import { SdError } from "@simplysm/core-common";
 import { consola } from "consola";
-import stylelint from "stylelint";
 
 //#region Types
 
@@ -27,9 +26,9 @@ export interface LintOptions {
 export interface LintResult {
   /** true if there are no lint errors */
   success: boolean;
-  /** Total error count from ESLint + Stylelint */
+  /** Total error count from ESLint */
   errorCount: number;
-  /** Total warning count from ESLint + Stylelint */
+  /** Total warning count from ESLint */
   warningCount: number;
   /** Formatter output string (content to write to stdout) */
   formattedOutput: string;
@@ -47,16 +46,6 @@ const ESLINT_CONFIG_FILES = [
   "eslint.config.mjs",
 ] as const;
 
-/** Stylelint config file search order */
-const STYLELINT_CONFIG_FILES = [
-  "stylelint.config.ts",
-  "stylelint.config.mts",
-  "stylelint.config.js",
-  "stylelint.config.mjs",
-  ".stylelintrc.json",
-  ".stylelintrc.yml",
-] as const;
-
 /**
  * Type guard to check if an ESLint config object has only ignores property
  */
@@ -78,7 +67,7 @@ export async function loadIgnorePatterns(cwd: string): Promise<string[]> {
   let configPath: string | undefined;
   for (const f of ESLINT_CONFIG_FILES) {
     const p = path.join(cwd, f);
-    if (await fsExists(p)) {
+    if (await fsx.exists(p)) {
       configPath = p;
       break;
     }
@@ -115,16 +104,6 @@ export async function loadIgnorePatterns(cwd: string): Promise<string[]> {
   return configs.filter(isGlobalIgnoresConfig).flatMap((item) => item.ignores);
 }
 
-/**
- * Check if Stylelint config file exists.
- */
-async function hasStylelintConfig(cwd: string): Promise<boolean> {
-  for (const f of STYLELINT_CONFIG_FILES) {
-    if (await fsExists(path.join(cwd, f))) return true;
-  }
-  return false;
-}
-
 //#endregion
 
 //#region Main
@@ -160,13 +139,13 @@ export async function executeLint(options: LintOptions): Promise<LintResult> {
 
   // Collect lint target files
   logger.start("collecting lint target files");
-  let files = await fsGlob("**/*.{ts,tsx,js,jsx}", {
+  let files = await fsx.glob("**/*.{ts,tsx,js,jsx}", {
     cwd,
     ignore: ignorePatterns,
     nodir: true,
     absolute: true,
   });
-  files = pathFilterByTargets(files, targets, cwd);
+  files = pathx.filterByTargets(files, targets, cwd);
   logger.debug("file collection complete", { fileCount: files.length });
   logger.success(`collected lint target files (${files.length} files)`);
 
@@ -192,59 +171,6 @@ export async function executeLint(options: LintOptions): Promise<LintResult> {
     }
   }
 
-  // Stylelint
-  const hasStylelintCfg = await hasStylelintConfig(cwd);
-  let stylelintResult: stylelint.LinterResult | undefined;
-  if (hasStylelintCfg) {
-    logger.start("collecting CSS files");
-    let cssFiles = await fsGlob("**/*.css", {
-      cwd,
-      ignore: ignorePatterns,
-      nodir: true,
-      absolute: true,
-    });
-    cssFiles = pathFilterByTargets(cssFiles, targets, cwd);
-    logger.success(`collected CSS files (${cssFiles.length} files)`);
-
-    if (cssFiles.length > 0) {
-      logger.start(`running Stylelint... (${cssFiles.length} files)`);
-      let configFile: string | undefined;
-      for (const f of STYLELINT_CONFIG_FILES) {
-        const configPath = path.join(cwd, f);
-        if (await fsExists(configPath)) {
-          configFile = configPath;
-          break;
-        }
-      }
-
-      // Support TypeScript config files: load with jiti, pass as config object
-      let stylelintOptions: stylelint.LinterOptions;
-      if (configFile != null && /\.ts$/.test(configFile)) {
-        const jiti = createJiti(import.meta.url);
-        const configModule = await jiti.import<{ default: stylelint.Config }>(configFile);
-        const config = configModule.default;
-        stylelintOptions = {
-          files: cssFiles,
-          config,
-          configBasedir: cwd,
-          fix,
-          cache: true,
-          cacheLocation: path.join(cwd, ".cache", "stylelint.cache"),
-        };
-      } else {
-        stylelintOptions = {
-          files: cssFiles,
-          configFile,
-          fix,
-          cache: true,
-          cacheLocation: path.join(cwd, ".cache", "stylelint.cache"),
-        };
-      }
-      stylelintResult = await stylelint.lint(stylelintOptions);
-      logger.success("Stylelint execution complete");
-    }
-  }
-
   // Return success result if no files or lint was not executed
   if (files.length === 0 || eslintResults == null || eslint == null) {
     logger.info("no files to lint");
@@ -271,43 +197,6 @@ export async function executeLint(options: LintOptions): Promise<LintResult> {
     formattedOutput += resultText;
   }
 
-  // Collect Stylelint results
-  if (stylelintResult != null && stylelintResult.results.length > 0) {
-    const stylelintErrorCount = stylelintResult.results.sum(
-      (r) => r.warnings.filter((w) => w.severity === "error").length,
-    );
-    const stylelintWarningCount = stylelintResult.results.sum(
-      (r) => r.warnings.filter((w) => w.severity === "warning").length,
-    );
-
-    errorCount += stylelintErrorCount;
-    warningCount += stylelintWarningCount;
-
-    if (stylelintErrorCount > 0) {
-      logger.error("Stylelint errors occurred", {
-        errorCount: stylelintErrorCount,
-        warningCount: stylelintWarningCount,
-      });
-    } else if (stylelintWarningCount > 0) {
-      logger.info("Stylelint complete (warnings present)", {
-        errorCount: stylelintErrorCount,
-        warningCount: stylelintWarningCount,
-      });
-    } else {
-      logger.info("Stylelint complete", {
-        errorCount: stylelintErrorCount,
-        warningCount: stylelintWarningCount,
-      });
-    }
-
-    // Stylelint formatter output
-    const stylelintFormatter = await stylelint.formatters.string;
-    const stylelintOutput = stylelintFormatter(stylelintResult.results, stylelintResult);
-    if (stylelintOutput) {
-      formattedOutput += stylelintOutput;
-    }
-  }
-
   return {
     success: errorCount === 0,
     errorCount,

package/src/commands/publish.ts

@@ -2,8 +2,8 @@ import path from "path";
 import semver from "semver";
 import { consola } from "consola";
 import { StorageFactory } from "@simplysm/storage";
-import { fsExists, fsRead, fsReadJson, fsWrite, fsGlob, fsCopy } from "@simplysm/core-node";
-import { env, jsonStringify } from "@simplysm/core-common";
+import { fsx } from "@simplysm/core-node";
+import { env, json } from "@simplysm/core-common";
 import "@simplysm/core-common";
 import type { SdConfig, SdPublishConfig } from "../sd-config.types";
 import { loadSdConfig } from "../utils/sd-config";
@@ -106,7 +106,7 @@ async function ensureSshAuth(
   // Collect SFTP servers without pass (deduplicate user@host)
   const sshTargets = new Map<string, { host: string; port?: number; user: string }>();
   for (const pkg of publishPackages) {
-    if (pkg.config === "npm") continue;
+    if (pkg.config.type === "npm") continue;
     if (pkg.config.type !== "sftp") continue;
     if (pkg.config.pass != null) continue;
     if (pkg.config.user == null) {
@@ -272,7 +272,7 @@ async function upgradeVersion(
 ): Promise<{ version: string; changedFiles: string[] }> {
   const changedFiles: string[] = [];
   const projPkgPath = path.resolve(cwd, "package.json");
-  const projPkg = await fsReadJson<PackageJson>(projPkgPath);
+  const projPkg = await fsx.readJson<PackageJson>(projPkgPath);
 
   const currentVersion = projPkg.version;
   const prereleaseInfo = semver.prerelease(currentVersion);
@@ -289,28 +289,28 @@ async function upgradeVersion(
   }
 
   projPkg.version = newVersion;
-  await fsWrite(projPkgPath, jsonStringify(projPkg, { space: 2 }) + "\n");
+  await fsx.write(projPkgPath, json.stringify(projPkg, { space: 2 }) + "\n");
   changedFiles.push(projPkgPath);
 
   // Set version in each package's package.json
   for (const pkgPath of allPkgPaths) {
     const pkgJsonPath = path.resolve(pkgPath, "package.json");
-    const pkgJson = await fsReadJson<PackageJson>(pkgJsonPath);
+    const pkgJson = await fsx.readJson<PackageJson>(pkgJsonPath);
     pkgJson.version = newVersion;
-    await fsWrite(pkgJsonPath, jsonStringify(pkgJson, { space: 2 }) + "\n");
+    await fsx.write(pkgJsonPath, json.stringify(pkgJson, { space: 2 }) + "\n");
     changedFiles.push(pkgJsonPath);
   }
 
   // Synchronize @simplysm package version in template files
-  const templateFiles = await fsGlob(path.resolve(cwd, "packages/sd-cli/templates/**/*.hbs"));
+  const templateFiles = await fsx.glob(path.resolve(cwd, "packages/sd-cli/templates/**/*.hbs"));
   const versionRegex = /("@simplysm\/[^"]+"\s*:\s*)"~[^"]+"/g;
 
   for (const templatePath of templateFiles) {
-    const content = await fsRead(templatePath);
+    const content = await fsx.read(templatePath);
     const newContent = content.replace(versionRegex, `$1"~${newVersion}"`);
 
     if (content !== newContent) {
-      await fsWrite(templatePath, newContent);
+      await fsx.write(templatePath, newContent);
       changedFiles.push(templatePath);
     }
   }
@@ -336,7 +336,7 @@ async function publishPackage(
 ): Promise<void> {
   const pkgName = path.basename(pkgPath);
 
-  if (publishConfig === "npm") {
+  if (publishConfig.type === "npm") {
     // npm publish
     const prereleaseInfo = semver.prerelease(version);
     const args = ["publish", "--access", "public", "--no-git-checks"];
@@ -362,7 +362,7 @@ async function publishPackage(
       logger.info(`[DRY-RUN] [${pkgName}] copy to local: ${distPath} → ${targetPath}`);
     } else {
       logger.debug(`[${pkgName}] copy to local: ${distPath} → ${targetPath}`);
-      await fsCopy(distPath, targetPath);
+      await fsx.copy(distPath, targetPath);
     }
   } else {
     // Upload to storage
@@ -407,7 +407,7 @@ async function computePublishLevels(
   // Collect workspace dependencies for each package
   const depsMap = new Map<string, Set<string>>();
   for (const pkg of publishPkgs) {
-    const pkgJson = await fsReadJson<PackageJson>(path.resolve(pkg.path, "package.json"));
+    const pkgJson = await fsx.readJson<PackageJson>(path.resolve(pkg.path, "package.json"));
     const allDeps = {
       ...pkgJson.dependencies,
       ...pkgJson.peerDependencies,
@@ -483,7 +483,7 @@ export async function runPublish(options: PublishOptions): Promise<void> {
   // Load sd.config.ts
   let sdConfig: SdConfig;
   try {
-    sdConfig = await loadSdConfig({ cwd, dev: false, opt: options.options });
+    sdConfig = await loadSdConfig({ cwd, dev: false, options: options.options });
     logger.debug("sd.config.ts loaded");
   } catch (err) {
     logger.error(`Failed to load sd.config.ts: ${err instanceof Error ? err.message : err}`);
@@ -493,18 +493,18 @@ export async function runPublish(options: PublishOptions): Promise<void> {
 
   // Load package.json
   const projPkgPath = path.resolve(cwd, "package.json");
-  const projPkg = await fsReadJson<PackageJson>(projPkgPath);
+  const projPkg = await fsx.readJson<PackageJson>(projPkgPath);
 
   // Collect workspace package paths from pnpm-workspace.yaml
   const workspaceYamlPath = path.resolve(cwd, "pnpm-workspace.yaml");
   const workspaceGlobs: string[] = [];
-  if (await fsExists(workspaceYamlPath)) {
-    const yamlContent = await fsRead(workspaceYamlPath);
+  if (await fsx.exists(workspaceYamlPath)) {
+    const yamlContent = await fsx.read(workspaceYamlPath);
     workspaceGlobs.push(...parseWorkspaceGlobs(yamlContent));
   }
 
   const allPkgPaths = (
-    await Promise.all(workspaceGlobs.map((item) => fsGlob(path.resolve(cwd, item))))
+    await Promise.all(workspaceGlobs.map((item) => fsx.glob(path.resolve(cwd, item))))
   )
     .flat()
     .filter((item) => !path.basename(item).includes("."));
@@ -550,12 +550,12 @@ export async function runPublish(options: PublishOptions): Promise<void> {
   );
 
   // Check if Git is available
-  const hasGit = await fsExists(path.resolve(cwd, ".git"));
+  const hasGit = await fsx.exists(path.resolve(cwd, ".git"));
 
   //#region Phase 1: Pre-validation
 
   // Verify npm authentication (if npm publish config exists)
-  if (publishPackages.some((p) => p.config === "npm")) {
+  if (publishPackages.some((p) => p.config.type === "npm")) {
     logger.debug("Verifying npm authentication...");
     try {
       const { stdout: whoami } = await execa("npm", ["whoami"]);

package/src/commands/replace-deps.ts

@@ -16,7 +16,7 @@ export interface ReplaceDepsOptions {
 export async function runReplaceDeps(opts: ReplaceDepsOptions): Promise<void> {
   const cwd = process.cwd();
 
-  const sdConfig = await loadSdConfig({ cwd, dev: false, opt: opts.options });
+  const sdConfig = await loadSdConfig({ cwd, dev: false, options: opts.options });
 
   if (sdConfig.replaceDeps == null) {
     consola.warn("No replaceDeps config found in sd.config.ts.");

package/src/commands/typecheck.ts

@@ -1,8 +1,8 @@
 import ts from "typescript";
 import path from "path";
 import os from "os";
-import { pathPosix, pathFilterByTargets, Worker, type WorkerProxy } from "@simplysm/core-node";
-import { errorMessage } from "@simplysm/core-common";
+import { pathx, Worker, type WorkerProxy } from "@simplysm/core-node";
+import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
 import type { SdConfig } from "../sd-config.types";
 import { parseRootTsconfig, type TypecheckEnv } from "../utils/tsconfig";
@@ -86,7 +86,7 @@ export function extractPackages(
   const packages = new Map<string, PackageInfo>();
 
   for (const fileName of fileNames) {
-    const relativePath = pathPosix(path.relative(cwd, fileName));
+    const relativePath = pathx.posix(path.relative(cwd, fileName));
 
     // packages/{pkg}/...
     const packageMatch = relativePath.match(PATH_PATTERNS.PACKAGE);
@@ -113,7 +113,7 @@ export function extractPackages(
  */
 function hasNonPackageFiles(fileNames: string[], cwd: string): boolean {
   return fileNames.some((f) => {
-    const relativePath = pathPosix(path.relative(cwd, f));
+    const relativePath = pathx.posix(path.relative(cwd, f));
     if (!relativePath.startsWith("packages/")) return true;
     // Also treat files directly under package root (config files) as non-package
     return relativePath.split("/").length === 3;
@@ -202,14 +202,14 @@ export async function executeTypecheck(options: TypecheckOptions): Promise<Typec
   try {
     parsedConfig = parseRootTsconfig(cwd);
   } catch (err) {
-    logger.error(errorMessage(err));
+    logger.error(errNs.message(err));
     return { success: false, errorCount: 1, warningCount: 0, formattedOutput: "" };
   }
 
   // Load sd.config.ts
   let sdConfig: SdConfig;
   try {
-    sdConfig = await loadSdConfig({ cwd, dev: false, opt: options.options });
+    sdConfig = await loadSdConfig({ cwd, dev: false, options: options.options });
     logger.debug("sd.config.ts loaded");
   } catch (err) {
     // Use defaults if sd.config.ts is missing or load fails
@@ -218,7 +218,7 @@ export async function executeTypecheck(options: TypecheckOptions): Promise<Typec
   }
 
   // Filter fileNames if targets specified
-  const fileNames = pathFilterByTargets(parsedConfig.fileNames, targets, cwd);
+  const fileNames = pathx.filterByTargets(parsedConfig.fileNames, targets, cwd);
 
   if (fileNames.length === 0) {
     logger.info("no files to typecheck");
@@ -283,13 +283,13 @@ export async function executeTypecheck(options: TypecheckOptions): Promise<Typec
           }
         } catch (err) {
           logger.error(`Worker error: ${task.displayName}`, {
-            error: errorMessage(err),
+            error: errNs.message(err),
           });
           allResults.push({
             displayName: task.displayName,
             result: {
               success: false,
-              errors: [errorMessage(err)],
+              errors: [errNs.message(err)],
               diagnostics: [],
               errorCount: 1,
               warningCount: 0,

package/src/electron/electron.ts

@@ -2,7 +2,7 @@ import path from "path";
 import os from "os";
 import fs from "fs";
 import module from "module";
-import { fsExists, fsMkdir, fsCopy, fsReaddir, fsReadJson, fsWriteJson } from "@simplysm/core-node";
+import { fsx } from "@simplysm/core-node";
 import { consola } from "consola";
 import type { SdElectronConfig } from "../sd-config.types";
 import { execa } from "execa";
@@ -45,7 +45,7 @@ export class Electron {
   static async create(pkgPath: string, config: SdElectronConfig): Promise<Electron> {
     Electron._validateConfig(config);
 
-    const npmConfig = await fsReadJson<NpmConfig>(path.resolve(pkgPath, "package.json"));
+    const npmConfig = await fsx.readJson<NpmConfig>(path.resolve(pkgPath, "package.json"));
     return new Electron(pkgPath, config, npmConfig);
   }
 
@@ -137,8 +137,8 @@ export class Electron {
     await this._bundleMainProcess(electronRunPath);
 
     // 2. Create package.json
-    await fsMkdir(electronRunPath);
-    await fsWriteJson(
+    await fsx.mkdir(electronRunPath);
+    await fsx.writeJson(
       path.resolve(electronRunPath, "package.json"),
       { name: this._npmConfig.name, version: this._npmConfig.version, main: "electron-main.js" },
       { space: 2 },
@@ -165,7 +165,7 @@ export class Electron {
    * Create .electron/src/package.json
    */
   private async _setupPackageJson(srcPath: string): Promise<void> {
-    await fsMkdir(srcPath);
+    await fsx.mkdir(srcPath);
 
     const reinstallDeps = this._config.reinstallDependencies ?? [];
 
@@ -190,7 +190,7 @@ export class Electron {
       packageJson["scripts"] = { postinstall: this._config.postInstallScript };
     }
 
-    await fsWriteJson(path.resolve(srcPath, "package.json"), packageJson, { space: 2 });
+    await fsx.writeJson(path.resolve(srcPath, "package.json"), packageJson, { space: 2 });
   }
 
   //#endregion
@@ -204,14 +204,14 @@ export class Electron {
     const esbuild = await import("esbuild");
     const entryPoint = path.resolve(this._pkgPath, "src/electron-main.ts");
 
-    if (!(await fsExists(entryPoint))) {
+    if (!(await fsx.exists(entryPoint))) {
       throw new Error(`electron-main.ts file not found: ${entryPoint}`);
     }
 
     const builtinModules = module.builtinModules.flatMap((m) => [m, `node:${m}`]);
     const reinstallDeps = this._config.reinstallDependencies ?? [];
 
-    await fsMkdir(outDir);
+    await fsx.mkdir(outDir);
 
     await esbuild.build({
       entryPoints: [entryPoint],
@@ -232,14 +232,14 @@ export class Electron {
    * Copy web assets (build output → .electron/src/)
    */
   private async _copyWebAssets(outPath: string, srcPath: string): Promise<void> {
-    const items = await fsReaddir(outPath);
+    const items = await fsx.readdir(outPath);
     for (const item of items) {
       // Exclude electron/ subdirectory (prevent self-copying)
       if (item === "electron") continue;
 
       const source = path.resolve(outPath, item);
       const dest = path.resolve(srcPath, item);
-      await fsCopy(source, dest);
+      await fsx.copy(source, dest);
     }
   }
 
@@ -297,7 +297,7 @@ export class Electron {
     }
 
     const configFilePath = path.resolve(this._electronPath, "builder-config.json");
-    await fsWriteJson(configFilePath, builderConfig, { space: 2 });
+    await fsx.writeJson(configFilePath, builderConfig, { space: 2 });
 
     await this._exec(
       "npx",
@@ -312,7 +312,7 @@ export class Electron {
   private async _copyBuildOutput(outPath: string): Promise<void> {
     const distPath = path.resolve(this._electronPath, "dist");
     const electronOutPath = path.resolve(outPath, "electron");
-    await fsMkdir(electronOutPath);
+    await fsx.mkdir(electronOutPath);
 
     const description = this._npmConfig.description ?? this._npmConfig.name;
     const version = this._npmConfig.version;
@@ -322,15 +322,15 @@ export class Electron {
     const builderFileName = `${description} ${isPortable ? "" : "Setup "}${version}.exe`;
     const sourcePath = path.resolve(distPath, builderFileName);
 
-    if (await fsExists(sourcePath)) {
+    if (await fsx.exists(sourcePath)) {
       // Copy latest file
       const latestFileName = `${description}${isPortable ? "-portable" : ""}-latest.exe`;
-      await fsCopy(sourcePath, path.resolve(electronOutPath, latestFileName));
+      await fsx.copy(sourcePath, path.resolve(electronOutPath, latestFileName));
 
       // Copy per-version file to updates/
       const updatesPath = path.resolve(electronOutPath, "updates");
-      await fsMkdir(updatesPath);
-      await fsCopy(sourcePath, path.resolve(updatesPath, `${version}.exe`));
+      await fsx.mkdir(updatesPath);
+      await fsx.copy(sourcePath, path.resolve(updatesPath, `${version}.exe`));
     } else {
       Electron._logger.warn(`build output not found: ${sourcePath}`);
     }

package/src/orchestrators/BuildOrchestrator.ts

@@ -1,7 +1,7 @@
 import path from "path";
 import ts from "typescript";
-import { Worker, type WorkerProxy, fsRm } from "@simplysm/core-node";
-import { errorMessage } from "@simplysm/core-common";
+import { Worker, type WorkerProxy, fsx } from "@simplysm/core-node";
+import { err as errNs } from "@simplysm/core-common";
 import { consola } from "consola";
 import type {
   SdConfig,
@@ -110,7 +110,7 @@ function classifyPackages(
  * Delete dist folders
  */
 async function cleanDistFolders(cwd: string, packageNames: string[]): Promise<void> {
-  await Promise.all(packageNames.map((name) => fsRm(path.join(cwd, "packages", name, "dist"))));
+  await Promise.all(packageNames.map((name) => fsx.rm(path.join(cwd, "packages", name, "dist"))));
 }
 
 //#endregion
@@ -157,7 +157,7 @@ export class BuildOrchestrator {
       this._sdConfig = await loadSdConfig({
         cwd: this._cwd,
         dev: false,
-        opt: this._options.options,
+        options: this._options.options,
       });
       this._logger.debug("sd.config.ts loaded");
     } catch (err) {
@@ -375,7 +375,7 @@ export class BuildOrchestrator {
               target: "client",
               type: "capacitor",
               success: false,
-              errors: [errorMessage(err)],
+              errors: [errNs.message(err)],
             });
             state.hasError = true;
           }
@@ -400,7 +400,7 @@ export class BuildOrchestrator {
               target: "client",
               type: "electron",
               success: false,
-              errors: [errorMessage(err)],
+              errors: [errNs.message(err)],
             });
             state.hasError = true;
           }