@simplysm/sd-cli 7.0.80 → 7.0.145

package/src/builder/SdCliClientBuilder.ts

@@ -7,7 +7,6 @@ import ts from "typescript";
 import { SdCliBuildResultUtil } from "../utils/SdCliBuildResultUtil";
 import { NamedChunksPlugin } from "@angular-devkit/build-angular/src/webpack/plugins/named-chunks-plugin";
 import {
-  CommonJsUsageWarnPlugin,
   DedupeModuleResolvePlugin,
   JavaScriptOptimizerPlugin,
   SuppressExtractedTextChunksWebpackPlugin
@@ -31,10 +30,10 @@ import { TransferSizePlugin } from "@angular-devkit/build-angular/src/webpack/pl
 import { CssOptimizerPlugin } from "@angular-devkit/build-angular/src/webpack/plugins/css-optimizer-plugin";
 import browserslist from "browserslist";
 import { augmentAppWithServiceWorker } from "@angular-devkit/build-angular/src/utils/service-worker";
-import { StringUtil } from "@simplysm/sd-core-common";
 import { SdCliNgModuleGenerator } from "../ng-tools/SdCliNgModuleGenerator";
 import { SdCliCordova } from "../build-tool/SdCliCordova";
 import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
+import electronBuilder from "electron-builder";
 import LintResult = ESLint.LintResult;
 
 export class SdCliClientBuilder extends EventEmitter {
@@ -84,8 +83,8 @@ export class SdCliClientBuilder extends EventEmitter {
     } : undefined);
 
     // CORDOVA
-    if (this._config.cordova) {
-      this._cordova = new SdCliCordova(this._rootPath, this._config.cordova);
+    if (this._config.builder?.cordova) {
+      this._cordova = new SdCliCordova(this._rootPath, this._config.builder.cordova);
     }
   }
 
@@ -97,6 +96,7 @@ export class SdCliClientBuilder extends EventEmitter {
 
   public async watchAsync(): Promise<NextHandleFunction[]> {
     // DIST 비우기
+    await FsUtil.removeAsync(path.resolve(this._rootPath, ".electron"));
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
     // NgModule 생성
@@ -109,10 +109,11 @@ export class SdCliClientBuilder extends EventEmitter {
     }
 
     // 빌드 준비
-    const webpackConfig = this._getWebpackConfig(true);
-    const compiler = webpack(webpackConfig);
+    const webpackConfigs = (Object.keys(this._config.builder ?? { web: {} }) as ("web" | "cordova" | "electron")[])
+      .map((builderType) => this._getWebpackConfig(true, builderType));
+    const multiCompiler = webpack(webpackConfigs);
     return await new Promise<NextHandleFunction[]>((resolve, reject) => {
-      compiler.hooks.invalid.tap(this.constructor.name, (fileName) => {
+      multiCompiler.hooks.invalid.tap(this.constructor.name, (fileName) => {
         if (fileName != null) {
           this._logger.debug("파일변경 감지", fileName);
           // NgModule 캐시 삭제
@@ -120,7 +121,7 @@ export class SdCliClientBuilder extends EventEmitter {
         }
       });
 
-      compiler.hooks.watchRun.tapAsync(this.constructor.name, async (args, callback) => {
+      multiCompiler.hooks.watchRun.tapAsync(this.constructor.name, async (args, callback) => {
         this.emit("change");
 
         // NgModule 생성
@@ -131,54 +132,58 @@ export class SdCliClientBuilder extends EventEmitter {
         this._logger.debug("Webpack 빌드 수행...");
       });
 
-      compiler.hooks.failed.tap(this.constructor.name, (err) => {
-        this.emit("complete", [{
-          filePath: undefined,
-          line: undefined,
-          char: undefined,
-          code: undefined,
-          severity: "error",
-          message: err.stack
-        }]);
-        reject(err);
-        return;
-      });
+      for (const compiler of multiCompiler.compilers) {
+        compiler.hooks.failed.tap(this.constructor.name, (err) => {
+          this.emit("complete", [{
+            filePath: undefined,
+            line: undefined,
+            char: undefined,
+            code: undefined,
+            severity: "error",
+            message: err.stack
+          }]);
+          reject(err);
+          return;
+        });
+      }
 
-      compiler.hooks.done.tap(this.constructor.name, async (stats) => {
+      multiCompiler.hooks.done.tap(this.constructor.name, async (multiStats) => {
         // 결과 반환
-        const results = SdCliBuildResultUtil.convertFromWebpackStats(stats);
+        const results = multiStats.stats.mapMany((stats) => SdCliBuildResultUtil.convertFromWebpackStats(stats));
 
         // .config.json 파일 쓰기
         const npmConfig = this._getNpmConfig(this._rootPath)!;
         const packageKey = npmConfig.name.split("/").last()!;
 
-        const configDistPath = !StringUtil.isNullOrEmpty(this._config.server)
+        const configDistPath = typeof this._config.server === "string"
           ? path.resolve(this._workspaceRootPath, "packages", this._config.server, "dist/www", packageKey, ".config.json")
           : path.resolve(this._parsedTsconfig.options.outDir!, ".config.json");
         await FsUtil.writeFileAsync(configDistPath, JSON.stringify(this._config.configs ?? {}, undefined, 2));
 
         // 마무리
         this._logger.debug("Webpack 빌드 완료");
-        resolve([devMiddleware, hotMiddleware]);
+        resolve(middlewares);
 
         this.emit("complete", results);
       });
 
-      const devMiddleware = wdm(compiler, {
-        publicPath: webpackConfig.output!.publicPath as string,
-        index: "index.html",
-        stats: false
-      });
-
-      const hotMiddleware = whm(compiler, {
-        path: `${webpackConfig.output!.publicPath as string}__webpack_hmr`,
-        log: false
-      });
+      const middlewares = multiCompiler.compilers.mapMany((compiler) => [
+        wdm(compiler, {
+          publicPath: compiler.options.output.publicPath,
+          index: "index.html",
+          stats: false
+        }),
+        whm(compiler, {
+          path: `${compiler.options.output.publicPath}__webpack_hmr`,
+          log: false
+        })
+      ]);
     });
   }
 
   public async buildAsync(): Promise<ISdCliPackageBuildResult[]> {
     // DIST 비우기
+    await FsUtil.removeAsync(path.resolve(this._rootPath, ".electron"));
     await FsUtil.removeAsync(this._parsedTsconfig.options.outDir!);
 
     // NgModule 생성
@@ -186,17 +191,18 @@ export class SdCliClientBuilder extends EventEmitter {
 
     // 빌드
     this._logger.debug("Webpack 빌드 수행...");
-    const webpackConfig = this._getWebpackConfig(false);
-    const compiler = webpack(webpackConfig);
+    const builderTypes = (Object.keys(this._config.builder ?? { web: {} }) as ("web" | "cordova" | "electron")[]);
+    const webpackConfigs = builderTypes.map((builderType) => this._getWebpackConfig(false, builderType));
+    const multipleCompiler = webpack(webpackConfigs);
     const buildResults = await new Promise<ISdCliPackageBuildResult[]>((resolve, reject) => {
-      compiler.run((err, stats) => {
-        if (err != null || stats == null) {
+      multipleCompiler.run((err, multiStats) => {
+        if (err != null || multiStats == null) {
           reject(err);
           return;
         }
 
         // 결과 반환
-        const results = SdCliBuildResultUtil.convertFromWebpackStats(stats);
+        const results = multiStats.stats.mapMany((stats) => SdCliBuildResultUtil.convertFromWebpackStats(stats));
         resolve(results);
       });
     });
@@ -206,11 +212,11 @@ export class SdCliClientBuilder extends EventEmitter {
     await FsUtil.writeFileAsync(targetPath, JSON.stringify(this._config.configs ?? {}, undefined, 2));
 
     // service-worker 처리
-    if (FsUtil.exists(path.resolve(this._rootPath, "ngsw-config.json"))) {
+    if (builderTypes.includes("web") && FsUtil.exists(path.resolve(this._rootPath, "ngsw-config.json"))) {
       const packageKey = this._getNpmConfig(this._rootPath)!.name.split("/").last()!;
       await augmentAppWithServiceWorker(
         PathUtil.posix(path.relative(this._workspaceRootPath, this._rootPath)) as any,
-        PathUtil.posix(path.relative(this._workspaceRootPath, this._parsedTsconfig.options.outDir!)) as any,
+        PathUtil.posix(path.relative(this._workspaceRootPath, path.resolve(this._parsedTsconfig.options.outDir!))) as any,
         `/${packageKey}/`,
         PathUtil.posix(path.relative(this._workspaceRootPath, path.resolve(this._rootPath, "ngsw-config.json")))
       );
@@ -222,7 +228,74 @@ export class SdCliClientBuilder extends EventEmitter {
       await this._cordova.initializeAsync();
 
       this._logger.debug("CORDOVA 빌드...");
-      await this._cordova.buildAsync(this._parsedTsconfig.options.outDir!);
+      await this._cordova.buildAsync(path.resolve(this._parsedTsconfig.options.outDir!, "cordova"));
+    }
+
+    // ELECTRON
+    if (this._config.builder?.electron) {
+      const npmConfig = this._getNpmConfig(this._rootPath)!;
+
+      const electronVersion = npmConfig.dependencies?.["electron"];
+      if (electronVersion === undefined) {
+        throw new Error("ELECTRON 빌드 패키지의 'dependencies'에는 'electron'이 반드시 포함되어야 합니다.");
+      }
+
+      const dotenvVersion = npmConfig.dependencies?.["dotenv"];
+      if (dotenvVersion === undefined) {
+        throw new Error("ELECTRON 빌드 패키지의 'dependencies'에는 'dotenv'가 반드시 포함되어야 합니다.");
+      }
+
+      const electronSrcPath = path.resolve(this._rootPath, `.electron/src`);
+      const electronDistPath = path.resolve(this._rootPath, `.electron/dist`);
+
+      await FsUtil.writeJsonAsync(path.resolve(electronSrcPath, `package.json`), {
+        name: npmConfig.name,
+        version: npmConfig.version,
+        description: npmConfig.description,
+        main: "electron.js",
+        author: npmConfig.author,
+        license: npmConfig.license,
+        devDependencies: {
+          "electron": electronVersion.replace("^", "")
+        },
+        dependencies: {
+          "dotenv": dotenvVersion
+        }
+      });
+
+      await FsUtil.writeFileAsync(path.resolve(electronSrcPath, `.env`), [
+        "NODE_ENV=production",
+        `SD_VERSION=${npmConfig.version}`,
+        (this._config.builder.electron.icon !== undefined) ? `SD_ELECTRON_ICON=${this._config.builder.electron.icon}` : `SD_ELECTRON_ICON=favicon.ico`,
+        ...(this._config.env !== undefined) ? Object.keys(this._config.env).map((key) => `${key}=${this._config.env![key]}`) : []
+      ].filterExists().join("\n"));
+
+      let electronTsFileContent = await FsUtil.readFileAsync(path.resolve(this._rootPath, `src/electron.ts`));
+      electronTsFileContent = "require(\"dotenv\").config({ path: `${__dirname}\\\\.env` });\n" + electronTsFileContent;
+      const result = ts.transpileModule(electronTsFileContent, { compilerOptions: { module: ts.ModuleKind.CommonJS } });
+      await FsUtil.writeFileAsync(path.resolve(electronSrcPath, "electron.js"), result.outputText);
+
+      await electronBuilder.build({
+        targets: electronBuilder.Platform.WINDOWS.createTarget(),
+        config: {
+          appId: this._config.builder.electron.appId,
+          productName: npmConfig.description,
+          nsis: {},
+          directories: {
+            app: electronSrcPath,
+            output: electronDistPath
+          }
+        }
+      });
+
+      await FsUtil.copyAsync(
+        path.resolve(this._rootPath, `.electron/dist/${npmConfig.description} Setup ${npmConfig.version}.exe`),
+        path.resolve(this._parsedTsconfig.options.outDir!, `electron/${npmConfig.description}-v${npmConfig.version}.exe`)
+      );
+      await FsUtil.copyAsync(
+        path.resolve(this._rootPath, `.electron/dist/${npmConfig.description} Setup ${npmConfig.version}.exe`),
+        path.resolve(this._parsedTsconfig.options.outDir!, `electron/${npmConfig.description}-latest.exe`)
+      );
     }
 
     // 마무리
@@ -237,23 +310,28 @@ export class SdCliClientBuilder extends EventEmitter {
     ].map((p) => path.dirname(p));
   }
 
-  private _getWebpackConfig(watch: boolean): webpack.Configuration {
+  private _getWebpackConfig(watch: boolean, builderType: "web" | "cordova" | "electron"): webpack.Configuration {
     const workspaceNpmConfig = this._getNpmConfig(this._workspaceRootPath)!;
     const workspaceName = workspaceNpmConfig.name;
 
     const internalModuleCachePaths = watch ? this._getInternalModuleCachePaths(workspaceName) : undefined;
 
     const npmConfig = this._getNpmConfig(this._rootPath)!;
-    const pkgVersion = npmConfig.version;
-    const ngVersion = this._getNpmConfig(FsUtil.findAllParentChildDirPaths("node_modules/@angular/core", this._rootPath, this._workspaceRootPath)[0])!.version;
+    // const pkgVersion = npmConfig.version;
+    // const ngVersion = this._getNpmConfig(FsUtil.findAllParentChildDirPaths("node_modules/@angular/core", this._rootPath, this._workspaceRootPath)[0])!.version;
+
+    const workspacePkgLockContent = FsUtil.readFile(path.resolve(this._workspaceRootPath, "package-lock.json"));
 
     const pkgKey = npmConfig.name.split("/").last()!;
-    const publicPath = (this._cordova && !watch) ? `` : `/${pkgKey}/`;
+    const publicPath = builderType === "web" ? `/${pkgKey}/` : watch ? `/${pkgKey}/${builderType}/` : ``;
 
     const cacheBasePath = path.resolve(this._rootPath, ".cache");
-    const cachePath = path.resolve(cacheBasePath, pkgVersion);
+    // const cachePath = path.resolve(cacheBasePath, pkgVersion);
 
-    const distPath = (this._cordova && !watch) ? path.resolve(this._cordova.cordovaPath, "www") : this._parsedTsconfig.options.outDir;
+    const distPath = (builderType === "cordova" && !watch) ? path.resolve(this._cordova!.cordovaPath, "www")
+      : (builderType === "electron" && !watch) ? path.resolve(this._rootPath, ".electron/src")
+        : builderType === "web" ? this._parsedTsconfig.options.outDir
+          : `${this._parsedTsconfig.options.outDir}/${builderType}`;
 
     const sassImplementation = new SassWorkerImplementation();
 
@@ -265,7 +343,7 @@ export class SdCliClientBuilder extends EventEmitter {
     return {
       mode: watch ? "development" : "production",
       devtool: false,
-      target: ["web", "es2015"],
+      target: builderType === "electron" ? ["electron-renderer", "es2015"] : ["web", "es2015"],
       profile: false,
       resolve: {
         roots: [this._rootPath],
@@ -273,7 +351,7 @@ export class SdCliClientBuilder extends EventEmitter {
         symlinks: true,
         modules: [this._workspaceRootPath, "node_modules"],
         mainFields: ["es2015", "browser", "module", "main"],
-        conditionNames: ["es2015", "..."]
+        conditionNames: ["es2015", "..."],
       },
       resolveLoader: {
         symlinks: true
@@ -316,14 +394,15 @@ export class SdCliClientBuilder extends EventEmitter {
       cache: {
         type: "filesystem",
         profile: watch ? undefined : false,
-        cacheDirectory: path.resolve(cachePath, "angular-webpack"),
+        cacheDirectory: path.resolve(cacheBasePath, "angular-webpack"),
         maxMemoryGenerations: 1,
         name: createHash("sha1")
-          .update(pkgVersion)
-          .update(ngVersion)
+          .update(workspacePkgLockContent)
+          // .update(pkgVersion)
+          // .update(ngVersion)
           .update(JSON.stringify(this._parsedTsconfig.options))
-          .update(this._workspaceRootPath)
-          .update(this._rootPath)
+          // .update(this._workspaceRootPath)
+          // .update(this._rootPath)
           .update(JSON.stringify(this._config))
           .update(watch.toString())
           .digest("hex")
@@ -430,7 +509,7 @@ export class SdCliClientBuilder extends EventEmitter {
               {
                 loader: "@angular-devkit/build-angular/src/babel/webpack-loader",
                 options: {
-                  cacheDirectory: path.resolve(cachePath, "babel-webpack"),
+                  cacheDirectory: path.resolve(cacheBasePath, "babel-webpack"),
                   scriptTarget: ts.ScriptTarget.ES2017,
                   aot: true,
                   optimize: !watch,
@@ -504,7 +583,9 @@ export class SdCliClientBuilder extends EventEmitter {
         ]
       },
       plugins: [
-        new NodePolyfillPlugin(),
+        new NodePolyfillPlugin({
+          excludeAliases: builderType === "electron" ? ["process"] : []
+        }),
         new NamedChunksPlugin(),
         new DedupeModuleResolvePlugin(),
         new webpack.ProgressPlugin({
@@ -518,7 +599,6 @@ export class SdCliClientBuilder extends EventEmitter {
             }
           }
         }),
-        new CommonJsUsageWarnPlugin(),
         ...watch ? [] : [
           new LicenseWebpackPlugin({
             stats: { warnings: false, errors: false },
@@ -529,7 +609,7 @@ export class SdCliClientBuilder extends EventEmitter {
         ],
         new CopyWebpackPlugin({
           patterns: [
-            ...["favicon.ico", "assets/", "manifest.webmanifest"].map((item) => ({
+            ...["favicon.ico", "assets/", "manifest.json"].map((item) => ({
               context: this._rootPath,
               to: item,
               from: `src/${item}`,
@@ -546,11 +626,31 @@ export class SdCliClientBuilder extends EventEmitter {
               },
               priority: 0
             })),
-            ...this._cordova ? this._cordova.platforms.map((platform) => ({
-              context: this._cordova!.cordovaPath,
-              to: `cordova-${platform}`,
-              from: `platforms/${platform}/platform_www`
-            })) : []
+            ...builderType === "cordova" && watch ? this._cordova!.platforms.mapMany((platform) => [
+              {
+                context: this._cordova!.cordovaPath,
+                to: `cordova-${platform}/plugins`,
+                from: `platforms/${platform}/platform_www/plugins`,
+                noErrorOnMissing: true
+              },
+              {
+                context: this._cordova!.cordovaPath,
+                to: `cordova-${platform}/cordova.js`,
+                from: `platforms/${platform}/platform_www/cordova.js`
+              },
+              {
+                context: this._cordova!.cordovaPath,
+                to: `cordova-${platform}/cordova_plugins.js`,
+                from: `platforms/${platform}/platform_www/cordova_plugins.js`,
+                noErrorOnMissing: true
+              },
+              {
+                context: this._cordova!.cordovaPath,
+                to: `cordova-${platform}/config.xml`,
+                from: `platforms/${platform}/www/config.xml`,
+                noErrorOnMissing: true
+              }
+            ]) : []
           ]
         }),
         ...watch ? [
@@ -603,7 +703,7 @@ export class SdCliClientBuilder extends EventEmitter {
           cache: {
             enabled: true,
             basePath: cacheBasePath,
-            path: cachePath
+            path: path.resolve(cacheBasePath, "index-webpack")
           },
           postTransform: undefined,
           optimization: {

package/src/builder/SdCliJsLibBuilder.ts

@@ -25,15 +25,15 @@ export class SdCliJsLibBuilder extends EventEmitter {
 
     const relatedPaths = await this.getRelatedPathsAsync();
     const watcher = SdFsWatcher.watch(relatedPaths);
-    watcher.onChange({}, async (changeInfos) => {
-      const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+    watcher.onChange({}, async (changedInfos) => {
+      const changeFilePaths = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
       if (changeFilePaths.length === 0) return;
 
       this._logger.debug("파일 변경 감지");
       this.emit("change");
       const watchBuildResults: ISdCliPackageBuildResult[] = [];
 
-      const lintFilePaths = changeInfos.filter((item) => ["add", "change"].includes(item.event)).map((item) => item.path);
+      const lintFilePaths = changedInfos.filter((item) => ["add", "change"].includes(item.event)).map((item) => item.path);
       if (lintFilePaths.length > 0) {
         watchBuildResults.push(...await this._linter.lintAsync(lintFilePaths));
       }

package/src/builder/SdCliServerBuilder.ts

@@ -187,11 +187,12 @@ export class SdCliServerBuilder extends EventEmitter {
 
     const npmConfig = this._getNpmConfig(this._rootPath)!;
     const pkgKey = npmConfig.name.split("/").last()!;
-    const pkgVersion = npmConfig.version;
+    // const pkgVersion = npmConfig.version;
 
-    const cacheBasePath = path.resolve(this._rootPath, ".cache");
-    const cachePath = path.resolve(cacheBasePath, pkgVersion);
+    const workspacePkgLockContent = FsUtil.readFile(path.resolve(this._workspaceRootPath, "package-lock.json"));
 
+    const cacheBasePath = path.resolve(this._rootPath, ".cache");
+    // const cachePath = path.resolve(cacheBasePath, pkgVersion);
 
     let prevProgressMessage = "";
     return {
@@ -241,13 +242,11 @@ export class SdCliServerBuilder extends EventEmitter {
       cache: {
         type: "filesystem",
         profile: watch ? undefined : false,
-        cacheDirectory: path.resolve(cachePath, "server-webpack"),
+        cacheDirectory: path.resolve(cacheBasePath, "server-webpack"),
         maxMemoryGenerations: 1,
         name: createHash("sha1")
-          .update(pkgVersion)
+          .update(workspacePkgLockContent)
           .update(JSON.stringify(this._parsedTsconfig.options))
-          .update(this._workspaceRootPath)
-          .update(this._rootPath)
           .update(JSON.stringify(this._config))
           .update(watch.toString())
           .digest("hex")

package/src/builder/SdCliTsLibBuilder.ts

@@ -115,8 +115,8 @@ export class SdCliTsLibBuilder extends EventEmitter {
     this._logger.debug("변경감지 구성...");
     const relatedPaths = await this.getAllRelatedPathsAsync();
     const watcher = SdFsWatcher.watch(relatedPaths);
-    watcher.onChange({}, async (changeInfos) => {
-      const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+    watcher.onChange({}, async (changedInfos) => {
+      const changeFilePaths = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
       if (changeFilePaths.length === 0) return;
 
       this._logger.debug("파일 변경 감지", changeFilePaths);
@@ -153,7 +153,7 @@ export class SdCliTsLibBuilder extends EventEmitter {
       this._logger.debug("린트...");
       const lintFilePaths = [
         ...watchBuildPack.affectedSourceFiles.map((item) => item.fileName),
-        ...changeInfos.filter((item) => ["add", "change"].includes(item.event)).map((item) => item.path)
+        ...changedInfos.filter((item) => ["add", "change"].includes(item.event)).map((item) => item.path)
       ];
       if (lintFilePaths.length > 0) {
         watchBuildResults.push(...await this._linter.lintAsync(lintFilePaths, watchBuildPack.program));

package/src/commons.ts

@@ -1,6 +1,14 @@
 export interface INpmConfig {
   name: string;
   version: string;
+  description?: string;
+  author?: string;
+  license?: string;
+  repository: string | {
+    type: string;
+    url: string;
+    directory?: string;
+  };
   type?: "module";
   workspaces?: string[];
   main?: string;
@@ -63,14 +71,18 @@ export interface ISdCliServerPackageConfig {
 
 export interface ISdCliClientPackageConfig {
   type: "client";
-  cordova?: ISdCliClientPackageCordovaConfig;
-  server: string;
+  builder?: {
+    web?: ISdCliClientBuilderWebConfig;
+    cordova?: ISdCliClientBuilderCordovaConfig;
+    electron?: ISdCliClientBuilderElectronConfig;
+  };
+  server: string | { port: number };
   env?: Record<string, string>;
   configs?: Record<string, any>;
   publish?: TSdCliPublishConfig;
 }
 
-export type TSdCliPublishConfig = ISdCliFtpPublishConfig | ISdCliLocalDirectoryPublishConfig;
+export type TSdCliPublishConfig = ISdCliFtpPublishConfig | ISdCliLocalDirectoryPublishConfig | ISdCliGithubPublishConfig;
 
 export interface ISdCliFtpPublishConfig {
   type: "ftp" | "ftps" | "sftp";
@@ -86,17 +98,26 @@ export interface ISdCliLocalDirectoryPublishConfig {
   path: string;
 }
 
-export interface ISdCliClientPackageCordovaConfig {
-  platforms: TSdCliCordovaPlatform[];
+export interface ISdCliGithubPublishConfig {
+  type: "github";
+  apiKey: string;
+  files: { from: string; to: string }[];
+}
+
+export interface ISdCliClientBuilderWebConfig {
+}
+
+export interface ISdCliClientBuilderCordovaConfig {
   appId: string;
   appName: string;
   plugins?: string[];
   icon?: string;
-  buildOption?: {
-    debug?: boolean;
-    bundle?: boolean;
-    sign?: {
-      android?: {
+  debug?: boolean;
+  target?: {
+    browser?: {};
+    android?: {
+      bundle?: boolean;
+      sign?: {
         keystore: string;
         storePassword: string;
         alias: string;
@@ -107,4 +128,7 @@ export interface ISdCliClientPackageCordovaConfig {
   };
 }
 
-export type TSdCliCordovaPlatform = "browser" | "ios" | "android" | "electron";
+export interface ISdCliClientBuilderElectronConfig {
+  appId: string;
+  icon?: string;
+}

package/src/entry-points/SdCliLocalUpdate.ts

@@ -42,8 +42,8 @@ export class SdCliLocalUpdate {
     const watchPaths = (await updatePathInfos.mapManyAsync(async (item) => await this._getWatchPathsAsync(item.source))).distinct();
 
     const watcher = SdFsWatcher.watch(watchPaths);
-    watcher.onChange({ delay: 1000 }, async (changeInfos) => {
-      const changeFilePaths = changeInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
+    watcher.onChange({ delay: 1000 }, async (changedInfos) => {
+      const changeFilePaths = changedInfos.filter((item) => ["add", "change", "unlink"].includes(item.event)).map((item) => item.path);
       if (changeFilePaths.length === 0) return;
 
       this._logger.log("로컬 라이브러리 변경감지...");

package/src/entry-points/SdCliWorkspace.ts

@@ -80,9 +80,33 @@ export class SdCliWorkspace {
         if (pkg.config.type === "client") {
           const middlewares = (await pkg.watchAsync()) as NextHandleFunction[];
 
-          const serverInfo = this._serverInfoMap.getOrCreate(pkg.config.server, { middlewares: [], clientInfos: [] });
-          serverInfo.middlewares.push(...middlewares);
-          serverInfo.clientInfos.push({ pkgKey: pkg.name.split("/").last()! });
+          if (typeof pkg.config.server === "string") {
+            const serverInfo = this._serverInfoMap.getOrCreate(pkg.config.server, { middlewares: [], clientInfos: [] });
+            serverInfo.middlewares.push(...middlewares);
+            serverInfo.clientInfos.push({
+              pkgKey: pkg.name.split("/").last()!,
+              platforms: pkg.config.builder ? Object.keys(pkg.config.builder) : ["web"],
+              cordovaTargets: pkg.config.builder?.cordova?.target ? Object.keys(pkg.config.builder.cordova.target) : ["browser"]
+            });
+          }
+          else { // DEV SERVER
+            const serverInfo = this._serverInfoMap.getOrCreate("_", { middlewares: [], clientInfos: [] });
+            if (serverInfo.server === undefined) {
+              const server = new SdServiceServer({
+                rootPath: process.cwd(),
+                services: [],
+                port: pkg.config.server.port
+              });
+              await server.listenAsync();
+              serverInfo.server = server;
+              serverInfo.server.devMiddlewares = middlewares;
+              serverInfo.clientInfos.push({
+                pkgKey: pkg.name.split("/").last()!,
+                platforms: pkg.config.builder ? Object.keys(pkg.config.builder) : ["web"],
+                cordovaTargets: pkg.config.builder?.cordova?.target ? Object.keys(pkg.config.builder.cordova.target) : ["browser"]
+              });
+            }
+          }
         }
         else {
           await pkg.watchAsync();
@@ -345,11 +369,28 @@ export class SdCliWorkspace {
       const portStr = serverInfo.server.options.port.toString();
 
       for (const clientInfo of serverInfo.clientInfos) {
-        clientHrefs.push(`${protocolStr}://localhost:${portStr}/${clientInfo.pkgKey}/`);
+        for (const platform of clientInfo.platforms) {
+          if (platform === "web") {
+            clientHrefs.push(`${protocolStr}://localhost:${portStr}/${clientInfo.pkgKey}/`);
+          }
+          else if (platform === "electron") {
+            clientHrefs.push(`sd-cli run-electron ${clientInfo.pkgKey} http://localhost:${portStr}`);
+          }
+          else if (platform === "cordova") {
+            for (const target of clientInfo.cordovaTargets) {
+              if (target === "browser") {
+                clientHrefs.push(`${protocolStr}://localhost:${portStr}/${clientInfo.pkgKey}/${platform}/`);
+              }
+              else {
+                clientHrefs.push(`sd-cli run-cordova ${clientInfo.pkgKey} http://[IP]:${portStr}`);
+              }
+            }
+          }
+        }
       }
     }
     if (clientHrefs.length > 0) {
-      this._logger.log(`오픈된 클라이언트: ${clientHrefs.join(", ")}`);
+      this._logger.log(`오픈된 클라이언트:\n${clientHrefs.join("\n")}`);
     }
   }
 }
@@ -357,5 +398,5 @@ export class SdCliWorkspace {
 interface IServerInfo {
   server?: SdServiceServer;
   middlewares: NextHandleFunction[];
-  clientInfos: { pkgKey: string }[];
+  clientInfos: { pkgKey: string; platforms: string[]; cordovaTargets: string[] }[];
 }

package/src/index.ts

@@ -1,5 +1,7 @@
 export * from "./build-tool/SdCliCacheCompilerHost";
 export * from "./build-tool/SdCliCordova";
+export * from "./build-tool/SdCliElectron";
+export * from "./build-tool/SdCliGithubApi";
 export * from "./build-tool/SdCliIndexFileGenerator";
 export * from "./build-tool/SdCliNgCacheCompilerHost";
 export * from "./build-tool/SdCliPackageLinter";