@simplysm/sd-cli 13.0.76 → 13.0.77

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;
           }