@simplysm/sd-cli 12.16.27 → 13.0.0-beta.12

package/dist/entry/SdCliCordova.js

@@ -1,394 +0,0 @@
-import * as path from "path";
-import { FsUtils, PathUtils, SdLogger, SdProcess } from "@simplysm/sd-core-node";
-import { SdZip, XmlConvert } from "@simplysm/sd-core-common";
-export class SdCliCordova {
-    constructor(_opt) {
-        this._opt = _opt;
-        // 상수 정의
-        this._CORDOVA_DIR_NAME = ".cordova";
-        this._PLATFORMS_DIR_NAME = "platforms";
-        this._WWW_DIR_NAME = "www";
-        this._PLUGINS_DIR_NAME = "plugins";
-        this._PLUGINS_FETCH_FILE = "fetch.json";
-        this._ANDROID_SDK_VERSION = "35"; //cordova-android@14
-        this._KEYSTORE_FILE_NAME = "android.keystore";
-        this._CONFIG_XML_FILE_NAME = "config.xml";
-        this._CONFIG_XML_BACKUP_FILE_NAME = "config.xml.bak";
-        this._BUILD_JSON_FILE_NAME = "build.json";
-        this._ANDROID_SIGNING_PROP_PATH = "platforms/android/release-signing.properties";
-        this._ICON_DIR_PATH = "res/icons";
-        this._SPLASH_SCREEN_DIR_PATH = "res/screen/android";
-        this._SPLASH_SCREEN_XML_FILE = "splashscreen.xml";
-        this._platforms = Object.keys(this._opt.config.platform ?? { browser: {} });
-        this._npmConfig = FsUtils.readJson(path.resolve(this._opt.pkgPath, "package.json"));
-    }
-    static { this._logger = SdLogger.get(["simplysm", "sd-cli", "SdCliCordova"]); }
-    static async _execAsync(cmd, args, cwd) {
-        this._logger.debug(`실행 명령: ${cmd + " " + args.join(" ")}`);
-        const msg = await SdProcess.spawnAsync(cmd, args, { cwd });
-        this._logger.debug(`실행 결과: ${msg}`);
-    }
-    async initializeAsync() {
-        const cordovaPath = path.resolve(this._opt.pkgPath, this._CORDOVA_DIR_NAME);
-        // 1. Cordova 프로젝트 초기화
-        await this._initializeCordovaProjectAsync(cordovaPath);
-        // 2. 플랫폼 관리
-        await this._managePlatformsAsync(cordovaPath);
-        // 3. 플러그인 관리
-        await this._managePluginsAsync(cordovaPath);
-        // 4. 안드로이드 서명 설정
-        this._setupAndroidSign(cordovaPath);
-        // 5. 빌드 설정 파일 생성
-        this._createBuildConfig(cordovaPath);
-        // 6. 아이콘 및 스플래시 스크린 설정
-        this._setupIconAndSplashScreen(cordovaPath);
-        // 7. XML 설정 구성
-        this._configureXml(cordovaPath);
-        // 8. 각 플랫폼 www 준비
-        await SdCliCordova._execAsync("npx", ["cordova", "prepare"], cordovaPath);
-    }
-    // 1. Cordova 프로젝트 초기화
-    async _initializeCordovaProjectAsync(cordovaPath) {
-        if (FsUtils.exists(cordovaPath)) {
-            SdCliCordova._logger.log("이미 생성되어있는 '.cordova'를 사용합니다.");
-        }
-        else {
-            // await SdCliCordova.#execAsync("npx", ["cordova", "telemetry", "on"], this._opt.pkgPath);
-            // 프로젝트 생성
-            await SdCliCordova._execAsync("npx", ["cordova", "create", cordovaPath, this._opt.config.appId, this._opt.config.appName], process.cwd());
-        }
-        // platforms 폴더 혹시 없으면 생성
-        FsUtils.mkdirs(path.resolve(cordovaPath, this._PLATFORMS_DIR_NAME));
-        // www 폴더 혹시 없으면 생성
-        FsUtils.mkdirs(path.resolve(cordovaPath, this._WWW_DIR_NAME));
-    }
-    // 2. 플랫폼 관리
-    async _managePlatformsAsync(cordovaPath) {
-        const alreadyPlatforms = FsUtils.readdir(path.resolve(cordovaPath, this._PLATFORMS_DIR_NAME));
-        // 미설치 빌드 플랫폼 신규 생성
-        for (const platform of this._platforms) {
-            if (alreadyPlatforms.includes(platform))
-                continue;
-            await SdCliCordova._execAsync("npx", ["cordova", "platform", "add", platform], cordovaPath);
-        }
-    }
-    // 3. 플러그인 관리
-    async _managePluginsAsync(cordovaPath) {
-        const pluginsFetchPath = path.resolve(cordovaPath, this._PLUGINS_DIR_NAME, this._PLUGINS_FETCH_FILE);
-        const pluginsFetch = FsUtils.exists(pluginsFetchPath) ? FsUtils.readJson(pluginsFetchPath) : {};
-        const alreadyPlugins = Object.keys(pluginsFetch).map((key) => ({
-            name: key,
-            id: pluginsFetch[key].source.id,
-            dependencies: pluginsFetch[key].dependencies,
-        }));
-        const usePlugins = (this._opt.config.plugins ?? []).distinct();
-        // 사용하지 않는 플러그인 제거 및 새 플러그인 설치 - 의존성 때문에 순차 처리
-        await this._removeUnusedPluginsAsync(cordovaPath, alreadyPlugins, usePlugins);
-        await this._installNewPluginsAsync(cordovaPath, alreadyPlugins, usePlugins);
-    }
-    async _removeUnusedPluginsAsync(cordovaPath, alreadyPlugins, usePlugins) {
-        for (const alreadyPlugin of alreadyPlugins) {
-            if (!usePlugins.includes(alreadyPlugin.id) && !usePlugins.includes(alreadyPlugin.name)) {
-                try {
-                    await SdCliCordova._execAsync("npx", ["cordova", "plugin", "remove", alreadyPlugin.name], cordovaPath);
-                }
-                catch (err) {
-                    // 의존성으로 인한 skip 메시지는 무시 (로그 생략)
-                    const msg = err instanceof Error ? err.message : String(err);
-                    if (!msg.includes("is required by") || !msg.includes("skipping uninstallation")) {
-                        throw err;
-                    }
-                }
-            }
-        }
-    }
-    async _installNewPluginsAsync(cordovaPath, alreadyPlugins, usePlugins) {
-        // 병렬로 플러그인을 설치하면 충돌이 발생할 수 있으므로 순차 처리
-        for (const usePlugin of usePlugins) {
-            const isPluginAlreadyInstalled = alreadyPlugins.some((plugin) => usePlugin === plugin.id || usePlugin === plugin.name);
-            if (!isPluginAlreadyInstalled) {
-                await SdCliCordova._execAsync("npx", ["cordova", "plugin", "add", usePlugin], cordovaPath);
-            }
-        }
-    }
-    // 4. 안드로이드 서명 설정
-    _setupAndroidSign(cordovaPath) {
-        const keystorePath = path.resolve(cordovaPath, this._KEYSTORE_FILE_NAME);
-        const signingPropsPath = path.resolve(cordovaPath, this._ANDROID_SIGNING_PROP_PATH);
-        if (this._opt.config.platform?.android?.sign) {
-            FsUtils.copy(path.resolve(this._opt.pkgPath, this._opt.config.platform.android.sign.keystore), keystorePath);
-        }
-        else {
-            FsUtils.remove(keystorePath);
-            // SIGN을 안쓸경우 아래 파일이 생성되어 있으면 오류남
-            FsUtils.remove(signingPropsPath);
-        }
-    }
-    // 5. 빌드 설정 파일 생성
-    _createBuildConfig(cordovaPath) {
-        const buildJsonPath = path.resolve(cordovaPath, this._BUILD_JSON_FILE_NAME);
-        const keystorePath = path.resolve(cordovaPath, this._KEYSTORE_FILE_NAME);
-        const androidConfig = this._opt.config.platform?.android
-            ? {
-                android: {
-                    release: {
-                        packageType: this._opt.config.platform.android.bundle ? "bundle" : "apk",
-                        ...(this._opt.config.platform.android.sign
-                            ? {
-                                keystore: keystorePath,
-                                storePassword: this._opt.config.platform.android.sign.storePassword,
-                                alias: this._opt.config.platform.android.sign.alias,
-                                password: this._opt.config.platform.android.sign.password,
-                                keystoreType: this._opt.config.platform.android.sign.keystoreType,
-                            }
-                            : {}),
-                    },
-                },
-            }
-            : {};
-        FsUtils.writeJson(buildJsonPath, androidConfig);
-    }
-    // 6. 아이콘 및 스플래시 스크린 설정
-    _setupIconAndSplashScreen(cordovaPath) {
-        const iconDirPath = path.resolve(cordovaPath, this._ICON_DIR_PATH);
-        const splashScreenPath = path.resolve(cordovaPath, this._SPLASH_SCREEN_DIR_PATH);
-        const splashScreenXmlPath = path.resolve(splashScreenPath, this._SPLASH_SCREEN_XML_FILE);
-        // ICON 파일 복사
-        if (this._opt.config.icon != null) {
-            FsUtils.mkdirs(iconDirPath);
-            FsUtils.copy(path.resolve(this._opt.pkgPath, this._opt.config.icon), path.resolve(iconDirPath, path.basename(this._opt.config.icon)));
-        }
-        else {
-            FsUtils.remove(iconDirPath);
-        }
-        // SplashScreen 파일 생성
-        if (this._opt.config.platform?.android && this._opt.config.icon != null) {
-            FsUtils.mkdirs(splashScreenPath);
-            FsUtils.writeFile(splashScreenXmlPath, `
-<?xml version="1.0" encoding="utf-8"?>
-<layer-list xmlns:android="http://schemas.android.com/apk/res/android">
-  <item
-    android:width="48dp"
-    android:height="48dp"
-    android:drawable="@mipmap/ic_launcher"
-    android:gravity="center" />
-</layer-list>`.trim());
-        }
-    }
-    // 7. XML 설정 구성
-    _configureXml(cordovaPath) {
-        // CONFIG: 초기값 백업
-        const configFilePath = path.resolve(cordovaPath, this._CONFIG_XML_FILE_NAME);
-        const configBackFilePath = path.resolve(cordovaPath, this._CONFIG_XML_BACKUP_FILE_NAME);
-        if (!FsUtils.exists(configBackFilePath)) {
-            FsUtils.copy(configFilePath, configBackFilePath);
-        }
-        // CONFIG: 초기값 읽기
-        const configFileContent = FsUtils.readFile(configBackFilePath);
-        const configXml = XmlConvert.parse(configFileContent);
-        // CONFIG: 기본 설정
-        this._configureBasicXmlSettings(configXml);
-        // CONFIG: 안드로이드 설정
-        if (this._opt.config.platform?.android) {
-            this._configureAndroidXmlSettings(configXml);
-        }
-        // CONFIG: 파일 새로 쓰기
-        const configResultContent = XmlConvert.stringify(configXml, {
-            format: true,
-        });
-        FsUtils.writeFile(configFilePath, configResultContent);
-    }
-    _configureBasicXmlSettings(configXml) {
-        // 버전 설정
-        configXml.widget.$.version = this._npmConfig.version;
-        // ICON 설정
-        if (this._opt.config.icon != null) {
-            configXml.widget.icon = [
-                {
-                    $: {
-                        src: `${this._ICON_DIR_PATH}/${path.basename(this._opt.config.icon)}`,
-                    },
-                },
-            ];
-        }
-        // 접근허용 세팅
-        configXml.widget.content = [{ $: { src: "http://localhost/index.html" } }];
-        configXml.widget.access = [{ $: { origin: "*" } }];
-        configXml.widget["allow-navigation"] = [{ $: { href: "*" } }];
-        configXml.widget["allow-intent"] = [{ $: { href: "*" } }];
-        configXml.widget.preference = [{ $: { name: "MixedContentMode", value: "1" } }];
-    }
-    _configureAndroidXmlSettings(configXml) {
-        configXml.widget.$["xmlns:android"] = "http://schemas.android.com/apk/res/android";
-        configXml.widget.$["xmlns:tools"] = "http://schemas.android.com/tools";
-        configXml.widget.platform = configXml.widget.platform ?? [];
-        const androidPlatform = {
-            "$": {
-                name: "android",
-            },
-            "preference": [
-                {
-                    $: {
-                        name: "AndroidWindowSplashScreenAnimatedIcon",
-                        value: `${this._SPLASH_SCREEN_DIR_PATH}/${this._SPLASH_SCREEN_XML_FILE}`,
-                    },
-                },
-            ],
-            "edit-config": [
-                {
-                    $: {
-                        file: "app/src/main/AndroidManifest.xml",
-                        mode: "merge",
-                        target: "/manifest",
-                    },
-                    manifest: [
-                        {
-                            $: {
-                                "xmlns:tools": "http://schemas.android.com/tools",
-                            },
-                        },
-                    ],
-                },
-                {
-                    $: {
-                        file: "app/src/main/AndroidManifest.xml",
-                        mode: "merge",
-                        target: "/manifest/application",
-                    },
-                    application: [
-                        {
-                            $: {
-                                "android:usesCleartextTraffic": "true",
-                                ...(this._opt.config.platform.android.config
-                                    ? Object.keys(this._opt.config.platform.android.config).toObject((key) => "android:" + key, (key) => this._opt.config.platform.android.config[key])
-                                    : {}),
-                            },
-                        },
-                    ],
-                },
-            ],
-        };
-        // SDK 버전 설정
-        if (this._opt.config.platform.android.sdkVersion != null) {
-            androidPlatform.preference.push(...[
-                {
-                    $: {
-                        name: "android-maxSdkVersion",
-                        value: `${this._opt.config.platform.android.sdkVersion}`,
-                    },
-                },
-                {
-                    $: {
-                        name: "android-minSdkVersion",
-                        value: `${this._opt.config.platform.android.sdkVersion}`,
-                    },
-                },
-                {
-                    $: {
-                        name: "android-targetSdkVersion",
-                        value: `${this._opt.config.platform.android.sdkVersion}`,
-                    },
-                },
-                {
-                    $: {
-                        name: "android-compileSdkVersion",
-                        value: this._ANDROID_SDK_VERSION,
-                    },
-                },
-            ]);
-        }
-        // 권한 설정
-        if (this._opt.config.platform.android.permissions) {
-            androidPlatform["config-file"] = androidPlatform["config-file"] ?? [];
-            androidPlatform["config-file"].push({
-                "$": {
-                    target: "AndroidManifest.xml",
-                    parent: "/*",
-                },
-                "uses-permission": this._opt.config.platform.android.permissions.map((perm) => ({
-                    $: {
-                        "android:name": `android.permission.${perm.name}`,
-                        ...(perm.maxSdkVersion != null
-                            ? {
-                                "android:maxSdkVersion": `${perm.maxSdkVersion}`,
-                            }
-                            : {}),
-                        ...(perm.ignore != null
-                            ? {
-                                "tools:ignore": `${perm.ignore}`,
-                            }
-                            : {}),
-                    },
-                })),
-            });
-        }
-        configXml.widget.platform.push(androidPlatform);
-    }
-    async buildAsync(outPath) {
-        const cordovaPath = path.resolve(this._opt.pkgPath, this._CORDOVA_DIR_NAME);
-        // 빌드 실행 - 병렬 처리로 개선
-        const buildType = this._opt.config.debug ? "debug" : "release";
-        // 모든 플랫폼 동시에 빌드
-        await Promise.all(this._platforms.map((platform) => SdCliCordova._execAsync("npx", ["cordova", "build", platform, `--${buildType}`], cordovaPath)));
-        // 결과물 복사 및 ZIP 파일 생성 - 병렬 처리
-        await Promise.all(Object.keys(this._opt.config.platform ?? {}).map(async (platform) => {
-            await this._processBuildOutputAsync(cordovaPath, outPath, platform, buildType);
-        }));
-    }
-    async _processBuildOutputAsync(cordovaPath, outPath, platform, buildType) {
-        const targetOutPath = path.resolve(outPath, platform);
-        // 결과물 복사: ANDROID
-        if (platform === "android") {
-            this._copyAndroidBuildOutput(cordovaPath, targetOutPath, buildType);
-        }
-        // 자동업데이트를 위한 파일 생성
-        await this._createUpdateZipAsync(cordovaPath, outPath, platform);
-    }
-    _copyAndroidBuildOutput(cordovaPath, targetOutPath, buildType) {
-        const apkFileName = this._opt.config.platform.android.sign
-            ? `app-${buildType}.apk`
-            : `app-${buildType}-unsigned.apk`;
-        const latestDistApkFileName = path.basename(`${this._opt.config.appName}${this._opt.config.platform.android.sign ? "" : "-unsigned"}-latest.apk`);
-        FsUtils.mkdirs(targetOutPath);
-        FsUtils.copy(path.resolve(cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName), path.resolve(targetOutPath, latestDistApkFileName));
-        // 업데이트파일
-        FsUtils.copy(path.resolve(cordovaPath, "platforms/android/app/build/outputs/apk", buildType, apkFileName), path.resolve(targetOutPath, "updates", `${this._npmConfig.version}.apk`));
-    }
-    /** @deprecated */
-    async _createUpdateZipAsync(cordovaPath, outPath, platform) {
-        const zip = new SdZip();
-        const wwwPath = path.resolve(cordovaPath, this._WWW_DIR_NAME);
-        const platformWwwPath = path.resolve(cordovaPath, this._PLATFORMS_DIR_NAME, platform, "platform_www");
-        this._addFilesToZip(zip, wwwPath);
-        this._addFilesToZip(zip, platformWwwPath);
-        // ZIP 파일 생성
-        const updateDirPath = path.resolve(outPath, platform, "updates");
-        FsUtils.mkdirs(updateDirPath);
-        FsUtils.writeFile(path.resolve(updateDirPath, this._npmConfig.version + ".zip"), await zip.compressAsync());
-    }
-    _addFilesToZip(zip, dirPath) {
-        const files = FsUtils.glob(path.resolve(dirPath, "**/*"), { nodir: true });
-        for (const file of files) {
-            const relFilePath = path.relative(dirPath, file);
-            const fileBuffer = FsUtils.readFileBuffer(file);
-            zip.write(relFilePath, fileBuffer);
-        }
-    }
-    static async runWebviewOnDeviceAsync(opt) {
-        const projNpmConf = FsUtils.readJson(path.resolve(process.cwd(), "package.json"));
-        const allPkgPaths = projNpmConf.workspaces.mapMany((item) => FsUtils.glob(PathUtils.posix(process.cwd(), item)));
-        const cordovaPath = path.resolve(allPkgPaths.single((item) => item.endsWith(opt.package)), ".cordova");
-        if (opt.url !== undefined) {
-            FsUtils.remove(path.resolve(cordovaPath, "www"));
-            FsUtils.mkdirs(path.resolve(cordovaPath, "www"));
-            FsUtils.writeFile(path.resolve(cordovaPath, "www/index.html"), `
-'${opt.url}'로 이동중...
-<script>
-  setTimeout(function () {
-    window.location.href = "${opt.url.replace(/\/$/, "")}/${opt.package}/cordova/";
-  }, 3000);
-</script>`.trim());
-        }
-        await this._execAsync("npx", ["cordova", "run", opt.platform, "--device"], cordovaPath);
-    }
-}

package/dist/entry/SdCliElectron.d.ts

@@ -1,22 +0,0 @@
-import { ISdClientBuilderElectronConfig } from "../types/config/ISdProjectConfig";
-export declare class SdCliElectron {
-    private static readonly _logger;
-    static runAsync(opt: {
-        package: string;
-        config: string;
-        options?: string[];
-    }): Promise<void>;
-    static buildForDevAsync(opt: {
-        package: string;
-        config: string;
-        options?: string[];
-    }): Promise<void>;
-    static buildAsync(opt: {
-        pkgPath: string;
-        electronConfig: ISdClientBuilderElectronConfig;
-    }): Promise<void>;
-    private static _loadDevConfig;
-    private static _prepareAsync;
-    private static _buildAsync;
-    private static _canCreateSymlink;
-}

package/dist/entry/SdCliElectron.js

@@ -1,128 +0,0 @@
-import { FsUtils, SdLogger, SdProcess } from "@simplysm/sd-core-node";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { loadProjConfAsync } from "../utils/loadProjConfAsync";
-export class SdCliElectron {
-    static { this._logger = SdLogger.get(["simplysm", "sd-cli", "SdCliElectron"]); }
-    static async runAsync(opt) {
-        this._logger.log("설정 가져오기...");
-        const { pkgPath, electronPath, electronConfig } = await this._loadDevConfig(opt);
-        this._logger.log("준비...");
-        await this._prepareAsync({ pkgPath, electronPath, electronConfig });
-        this._logger.log("실행...");
-        await SdProcess.spawnAsync("npx", ["electron", "."], { cwd: electronPath, showMessage: true });
-    }
-    static async buildForDevAsync(opt) {
-        this._logger.log("설정 가져오기...");
-        const { pkgPath, electronPath, electronConfig } = await this._loadDevConfig(opt);
-        this._logger.log("준비...");
-        const { npmConfig } = await this._prepareAsync({ pkgPath, electronPath, electronConfig });
-        this._logger.log("빌드...");
-        const electronDistPath = path.resolve(pkgPath, ".electron/dist");
-        await this._buildAsync({ pkgPath, electronPath, electronDistPath, npmConfig, electronConfig });
-    }
-    static async buildAsync(opt) {
-        this._logger.log("준비...");
-        const electronPath = path.resolve(opt.pkgPath, ".electron/src");
-        const { npmConfig } = await this._prepareAsync({ ...opt, electronPath });
-        this._logger.log("빌드...");
-        const electronDistPath = path.resolve(opt.pkgPath, ".electron/dist");
-        await this._buildAsync({
-            pkgPath: opt.pkgPath,
-            electronPath,
-            electronDistPath,
-            npmConfig,
-            electronConfig: opt.electronConfig,
-        });
-    }
-    static async _loadDevConfig(opt) {
-        const projConf = await loadProjConfAsync(process.cwd(), true, opt);
-        const pkgConf = projConf.packages[opt.package];
-        if (pkgConf?.type !== "client" || pkgConf.builder?.electron === undefined) {
-            throw new Error();
-        }
-        const pkgPath = path.resolve(process.cwd(), `packages/${opt.package}`);
-        const electronPath = path.resolve(pkgPath, "dist/electron");
-        return {
-            pkgPath,
-            electronPath,
-            electronConfig: pkgConf.builder.electron,
-        };
-    }
-    static async _prepareAsync(opt) {
-        const npmConfig = FsUtils.readJson(path.resolve(opt.pkgPath, `package.json`));
-        const reinstallPkgNames = opt.electronConfig.reinstallDependencies ?? [];
-        FsUtils.writeJson(path.resolve(opt.electronPath, `package.json`), {
-            name: npmConfig.name.replace(/^@/, "").replace(/\//, "-"),
-            version: npmConfig.version,
-            description: npmConfig.description,
-            main: "electron-main.js",
-            ...(opt.electronConfig.postInstallScript !== undefined
-                ? {
-                    scripts: {
-                        postinstall: opt.electronConfig.postInstallScript,
-                    },
-                }
-                : {}),
-            dependencies: reinstallPkgNames.toObject((item) => item, (item) => npmConfig.dependencies[item]),
-        });
-        await SdProcess.spawnAsync("npm", ["install"], { cwd: opt.electronPath, showMessage: true });
-        await SdProcess.spawnAsync("npx", ["electron-rebuild"], {
-            cwd: opt.electronPath,
-            showMessage: true,
-        });
-        return { npmConfig };
-    }
-    static async _buildAsync(opt) {
-        if (!this._canCreateSymlink()) {
-            throw new Error("'Electron 빌드'를 위해서는 'Symlink 생성' 권한이 필요합니다. 윈도우의 개발자모드를 활성화하세요.");
-        }
-        const electronConfig = {
-            appId: opt.electronConfig.appId,
-            productName: opt.npmConfig.description,
-            asar: false,
-            win: {
-                target: opt.electronConfig.portable ? "portable" : "nsis",
-            },
-            nsis: opt.electronConfig.nsisOptions ?? {},
-            directories: {
-                app: opt.electronPath,
-                output: opt.electronDistPath,
-            },
-            ...(opt.electronConfig.installerIcon !== undefined
-                ? {
-                    icon: path.resolve(opt.pkgPath, opt.electronConfig.installerIcon),
-                }
-                : {}),
-            removePackageScripts: false,
-            npmRebuild: false,
-            forceCodeSigning: false,
-        };
-        const configFilePath = path.resolve(opt.pkgPath, ".electron/builder-config.json");
-        FsUtils.writeJson(configFilePath, electronConfig);
-        await SdProcess.spawnAsync("npx", ["electron-builder", "--win", "--config", configFilePath]);
-        FsUtils.copy(path.resolve(opt.electronDistPath, `${opt.npmConfig.description} ${opt.electronConfig.portable ? "" : "Setup "}${opt.npmConfig.version}.exe`), path.resolve(opt.pkgPath, `dist/electron/${opt.npmConfig.description}${opt.electronConfig.portable ? "-portable" : ""}-latest.exe`));
-        FsUtils.copy(path.resolve(opt.electronDistPath, `${opt.npmConfig.description} ${opt.electronConfig.portable ? "" : "Setup "}${opt.npmConfig.version}.exe`), path.resolve(opt.pkgPath, `dist/electron/updates/${opt.npmConfig.version}.exe`));
-    }
-    static _canCreateSymlink() {
-        const tmpDir = os.tmpdir();
-        const testTarget = path.join(tmpDir, "symlink-test-target.txt");
-        const testLink = path.join(tmpDir, "symlink-test-link.txt");
-        try {
-            // 대상 파일 생성
-            fs.writeFileSync(testTarget, "test");
-            // symlink 시도
-            fs.symlinkSync(testTarget, testLink, "file");
-            // symlink 성공 여부 확인
-            const isSymlink = fs.lstatSync(testLink).isSymbolicLink();
-            // 정리
-            fs.unlinkSync(testLink);
-            fs.unlinkSync(testTarget);
-            return isSymlink;
-        }
-        catch {
-            return false;
-        }
-    }
-}

package/dist/entry/SdCliLocalUpdate.d.ts

@@ -1,11 +0,0 @@
-export declare class SdCliLocalUpdate {
-    static runAsync(opt: {
-        config: string;
-        options?: string[];
-    }): Promise<void>;
-    static watchAsync(opt: {
-        config: string;
-        options?: string[];
-    }): Promise<void>;
-    private static _getUpdatePathInfos;
-}

package/dist/entry/SdCliLocalUpdate.js

@@ -1,83 +0,0 @@
-import { FsUtils, PathUtils, SdFsWatcher, SdLogger } from "@simplysm/sd-core-node";
-import path from "path";
-import { loadProjConfAsync } from "../utils/loadProjConfAsync";
-export class SdCliLocalUpdate {
-    static async runAsync(opt) {
-        const logger = SdLogger.get(["simplysm", "sd-cli", "SdCliLocalUpdate", "runAsync"]);
-        logger.debug("프로젝트 설정 가져오기...");
-        const projConf = await loadProjConfAsync(process.cwd(), true, opt);
-        if (!projConf.localUpdates)
-            return;
-        const updatePathInfos = this._getUpdatePathInfos(projConf.localUpdates);
-        logger.debug("로컬 업데이트 구성");
-        logger.log("로컬 라이브러리 업데이트 시작...");
-        await updatePathInfos.parallelAsync(async (updatePathInfo) => {
-            if (!FsUtils.exists(updatePathInfo.source)) {
-                logger.warn(`소스경로를 찾을 수 없어 무시됩니다(${updatePathInfo.source})`);
-                return;
-            }
-            // 소스경로에서 대상경로로 파일 복사
-            await FsUtils.copyAsync(updatePathInfo.source, updatePathInfo.target, (src) => {
-                return !src.includes("node_modules") && !src.endsWith("package.json");
-            });
-        });
-        logger.info("로컬 라이브러리 업데이트 완료");
-    }
-    static async watchAsync(opt) {
-        const logger = SdLogger.get(["simplysm", "sd-cli", "SdCliLocalUpdate", "watchAsync"]);
-        logger.debug("프로젝트 설정 가져오기...");
-        const projConf = await loadProjConfAsync(process.cwd(), true, opt);
-        if (!projConf.localUpdates)
-            return;
-        const updatePathInfos = this._getUpdatePathInfos(projConf.localUpdates);
-        logger.debug("로컬 업데이트 구성");
-        const watcher = await SdFsWatcher.watchAsync(updatePathInfos.map((item) => item.source));
-        watcher.onChange({ delay: 300 }, async (changedInfos) => {
-            const changedFileInfos = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event));
-            if (changedFileInfos.length === 0)
-                return;
-            logger.log("로컬 라이브러리 변경감지...");
-            await changedFileInfos.parallelAsync(async (changedFileInfo) => {
-                await updatePathInfos.parallelAsync(async (updatePathInfo) => {
-                    if (!PathUtils.isChildPath(changedFileInfo.path, updatePathInfo.source))
-                        return;
-                    const sourceRelPath = path.relative(updatePathInfo.source, changedFileInfo.path);
-                    const targetFilePath = path.resolve(updatePathInfo.target, sourceRelPath);
-                    if (changedFileInfo.event === "unlink") {
-                        logger.debug(`변경파일감지(삭제): ${targetFilePath}`);
-                        await FsUtils.removeAsync(targetFilePath);
-                    }
-                    else {
-                        logger.debug(`변경파일감지(복사): ${changedFileInfo.path} => ${targetFilePath}`);
-                        await FsUtils.copyAsync(changedFileInfo.path, targetFilePath);
-                    }
-                });
-            });
-            logger.info("로컬 라이브러리 복사 완료");
-        });
-    }
-    static _getUpdatePathInfos(record) {
-        const result = [];
-        for (const pkgGlobPath of Object.keys(record)) {
-            // "node_modules'에서 로컬업데이트 설정에 맞는 패키지를 "glob"하여 대상 패키지경로 목록 가져오기
-            const targetPaths = [
-                ...FsUtils.glob(path.resolve(process.cwd(), "node_modules", pkgGlobPath)),
-                ...FsUtils.glob(path.resolve(process.cwd(), "packages", "*", "node_modules", pkgGlobPath)),
-            ];
-            result.push(...targetPaths
-                .map((targetPath) => {
-                // 대상의 명칭 추출
-                const regexpText = pkgGlobPath.replace(/[\\/.*]/g, (item) => item === "/" ? "[\\\\\\/]" : item === "." ? "\\." : item === "*" ? "(.*)" : item);
-                const targetNameMatch = new RegExp(regexpText).exec(targetPath);
-                if (!targetNameMatch || typeof targetNameMatch[1] === "undefined")
-                    return undefined;
-                const targetName = targetNameMatch[1];
-                // 가져올 소스 경로 추출
-                const sourcePath = path.resolve(record[pkgGlobPath].replace(/\*/g, targetName));
-                return { source: sourcePath, target: targetPath };
-            })
-                .filterExists());
-        }
-        return result;
-    }
-}

package/dist/entry/SdCliPostInstall.d.ts

@@ -1,3 +0,0 @@
-export declare class SdCliPostInstall {
-    static run(): void;
-}