@simplysm/sd-cli 7.0.249 → 7.0.263

package/src/commons.ts

@@ -4,7 +4,7 @@ export interface INpmConfig {
   description?: string;
   author?: string;
   license?: string;
-  repository: string | {
+  repository?: {
     type: string;
     url: string;
     directory?: string;
@@ -27,6 +27,8 @@ export interface INpmConfig {
 
 export interface ITsconfig {
   compilerOptions?: {
+    module?: string;
+    lib?: string[];
     outDir?: string;
     baseUrl?: string;
     paths?: Record<string, string[]>;
@@ -109,9 +111,11 @@ export interface ISdCliGithubPublishConfig {
 }
 
 export interface ISdCliClientBuilderWebConfig {
+  env?: Record<string, string>;
 }
 
 export interface ISdCliClientBuilderCordovaConfig {
+  env?: Record<string, string>;
   appId: string;
   appName: string;
   plugins?: string[];
@@ -136,4 +140,5 @@ export interface ISdCliClientBuilderElectronConfig {
   appId: string;
   icon?: string;
   installerIcon?: string;
+  env?: Record<string, string>;
 }

package/src/entry-points/SdCliProjectGenerator.ts

@@ -0,0 +1,353 @@
+import { FsUtil, Logger, SdProcess } from "@simplysm/sd-core-node";
+import path from "path";
+import { StringUtil } from "@simplysm/sd-core-common";
+import { fc_project_editor_config } from "./file/project/fc_project_editor_config";
+import { fc_project_eslintrc } from "./file/project/fc_project_eslintrc";
+import { fc_project_gitignore } from "./file/project/fc_project_gitignore";
+import { fc_project_gitattributes } from "./file/project/fc_project_gitattributes";
+import { fc_project_npmconfig } from "./file/project/fc_project_npmconfig";
+import { fc_project_readme } from "./file/project/fc_project_readme";
+import { fc_project_simplysm } from "./file/project/fc_project_simplysm";
+import { fc_project_tsconfig } from "./file/project/fc_project_tsconfig";
+import { fc_package_eslintrc } from "./file/base/fc_package_eslintrc";
+import { fc_package_npmconfig } from "./file/base/fc_package_npmconfig";
+import { fc_package_tsconfig } from "./file/base/fc_package_tsconfig";
+import { fc_package_DbContext } from "./file/db/fc_package_DbContext";
+import { fc_package_DbModel } from "./file/db/fc_package_DbModel";
+import { fc_package_server_main } from "./file/server/fc_package_server_main";
+import { fc_package_appicons } from "./file/client/fc_package_appicons";
+import { fc_package_AppModule } from "./file/client/fc_package_AppModule";
+import { fc_package_AppPage } from "./file/client/fc_package_AppPage";
+import { fileURLToPath } from "url";
+import { fc_package_index } from "./file/client/fc_package_index";
+import { fc_package_client_main } from "./file/client/fc_package_client_main";
+import { fc_package_manifest } from "./file/client/fc_package_manifest";
+import { INpmConfig } from "../commons";
+import { fc_package_polyfills } from "./file/client/fc_package_polyfills";
+import { fc_package_styles } from "./file/client/fc_package_styles";
+
+export class SdCliProjectGenerator {
+  private readonly _logger = Logger.get(["simplysm", "sd-cli", this.constructor.name]);
+
+  public constructor(private readonly _rootPath: string) {
+  }
+
+  public async initAsync(opt: { name?: string; description: string; author: string; gitUrl: string }): Promise<void> {
+    if ((await FsUtil.readdirAsync(this._rootPath)).filter((item) => ![".idea", "package.json", "node_modules", "package-lock.json"].includes(path.basename(item))).length > 0) {
+      throw new Error("빈 디렉토리가 아닙니다. (package-lock.json, package.json, node_modules 외의 파일/폴더가 존재하는 경우, 초기화할 수 없습니다.)");
+    }
+
+    const projName = opt.name ?? path.basename(this._rootPath);
+
+    this._logger.log("'.editorconfig' 파일 생성");
+    await FsUtil.writeFileAsync(path.resolve(this._rootPath, ".editorconfig"), fc_project_editor_config());
+
+    this._logger.log(`[${projName}] '.eslintrc.cjs' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(this._rootPath, ".eslintrc.cjs"), fc_project_eslintrc());
+
+    this._logger.log(`[${projName}]'.gitattributes' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(this._rootPath, ".gitattributes"), fc_project_gitattributes());
+
+    this._logger.log(`[${projName}] '.gitignore' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(this._rootPath, ".gitignore"), fc_project_gitignore());
+
+    this._logger.log(`[${projName}] 'package.json' 파일 생성`);
+    let cliVersion: string | undefined;
+    if (FsUtil.exists(path.resolve(this._rootPath, "package.json"))) {
+      const npmConfig = await FsUtil.readJsonAsync(path.resolve(this._rootPath, "package.json")) as INpmConfig;
+      cliVersion = npmConfig.dependencies?.["@simplysm/sd-cli"];
+    }
+    await FsUtil.writeFileAsync(path.resolve(this._rootPath, "package.json"), fc_project_npmconfig({
+      name: projName,
+      description: opt.description,
+      author: opt.author,
+      gitUrl: opt.gitUrl,
+      cliVersion
+    }));
+
+    this._logger.log(`[${projName}] 'README.md' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(this._rootPath, "README.md"), fc_project_readme({
+      description: opt.description
+    }));
+
+    this._logger.log(`[${projName}] 'simplysm.json' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(this._rootPath, "simplysm.json"), fc_project_simplysm());
+
+    this._logger.log(`[${projName}] 'tsconfig.json' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(this._rootPath, "tsconfig.json"), fc_project_tsconfig());
+
+    this._logger.log(`[${projName}] 'packages' 디렉토리 생성`);
+    await FsUtil.mkdirsAsync(path.resolve(this._rootPath, "packages"));
+
+    this._logger.log(`[${projName}] npm install`);
+    await SdProcess.spawnAsync("npm install", { cwd: this._rootPath }, true);
+  }
+
+  public async addTsLibAsync(opt: { name: string; description: string; useDom: boolean }): Promise<void> {
+    await this._addPackageBaseTemplate({
+      ...opt,
+      isModule: true,
+      isForAngular: false,
+      types: "dist/index.d.ts",
+      main: "dist/index.mjs",
+      dependencies: {}
+    });
+
+    this._logger.log(`[${opt.name}] 'simplysm.json' 파일에 등록`);
+
+    await this._addPackageToSimplysmJson({
+      name: opt.name,
+      type: "library",
+      useAutoIndex: true
+    });
+  }
+
+  public async addDbLibAsync(opt: { name: string }): Promise<void> {
+    const pkgName = "db-" + opt.name;
+    const pkgPath = path.resolve(this._rootPath, "packages", pkgName);
+    const projNpmConfig = await this._getProjNpmConfigAsync();
+    const projName = projNpmConfig.name;
+
+    await this._addPackageBaseTemplate({
+      name: pkgName,
+      description: "DB " + opt.name.toUpperCase(),
+      useDom: false,
+      isModule: false,
+      isForAngular: false,
+      types: "dist/index.d.ts",
+      main: "dist/index.cjs",
+      dependencies: {
+        "@simplysm/sd-core-common": "~7.0.0",
+        "@simplysm/sd-orm-common": "~7.0.0"
+      }
+    });
+
+    this._logger.log(`[${pkgName}] 'src/${StringUtil.toPascalCase(opt.name)}DbContext.ts' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, `src/${StringUtil.toPascalCase(opt.name)}DbContext.ts`), fc_package_DbContext({
+      name: opt.name
+    }));
+
+    this._logger.log(`[${pkgName}] 'src/models' 디렉토리 생성`);
+    await FsUtil.mkdirsAsync(path.resolve(pkgPath, "src/models"));
+
+    this._logger.log(`[${pkgName}] 'simplysm.json' 파일에 등록`);
+    await this._addPackageToSimplysmJson({
+      name: pkgName,
+      type: "library",
+      useAutoIndex: true
+    });
+
+    this._logger.log(`[${projName}] npm install`);
+    await SdProcess.spawnAsync("npm install", { cwd: this._rootPath }, true);
+  }
+
+  public async addDbLibModelAsync(opt: { dbPkgName: string; category: string; name: string; description: string }): Promise<void> {
+    const pkgName = "db-" + opt.dbPkgName;
+    const pkgPath = path.resolve(this._rootPath, "packages", pkgName);
+
+    this._logger.log(`[${pkgName}] 'src/models/${opt.category}/${opt.name}.ts' 파일 생성`);
+
+    await FsUtil.writeFileAsync(
+      path.resolve(pkgPath, `src/models/${opt.category}/${opt.name}.ts`), fc_package_DbModel({
+        name: opt.name,
+        description: opt.description
+      }));
+
+    this._logger.log(`[${pkgName}] DbContext 파일에 등록`);
+    let dbContextContent = await FsUtil.readFileAsync(path.resolve(pkgPath, `src/${StringUtil.toPascalCase(opt.dbPkgName)}DbContext.ts`));
+
+    if (!dbContextContent.includes(`Queryable`)) {
+      this._logger.log(`[${pkgName}] DbContext 파일에 등록: import: Queryable`);
+      dbContextContent = dbContextContent.replace(/ } from "@simplysm\/sd-orm-common";/, `, Queryable } from "@simplysm/sd-orm-common";`);
+    }
+
+    this._logger.log(`[${pkgName}] DbContext 파일에 등록: import: MODEL`);
+    dbContextContent = `import { ${opt.name} } from "./models/${opt.category}/${opt.name}";\n` + dbContextContent;
+
+    if (!dbContextContent.includes(`//-- ${opt.category}\n`)) {
+      this._logger.log(`[${opt.name}] DbContext 파일에 등록: CATEGORY`);
+
+      dbContextContent = dbContextContent.replace(/\n}/, `\n\n  //-- ${opt.category}\n}`);
+    }
+
+    this._logger.log(`[${pkgName}] DbContext 파일에 등록: MODEL`);
+
+    dbContextContent = dbContextContent.replace(new RegExp(`//-- ${opt.category}\n`), `
+  //-- ${opt.category}
+  public readonly ${StringUtil.toCamelCase(opt.name)} = new Queryable(this, ${opt.name});
+`.trim() + "\n");
+
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, `src/${StringUtil.toPascalCase(opt.dbPkgName)}DbContext.ts`), dbContextContent);
+  }
+
+  public async addServerAsync(opt: { name?: string; description?: string }): Promise<void> {
+    const pkgName = "server" + (opt.name === undefined ? "" : `-${opt.name}`);
+    const pkgPath = path.resolve(this._rootPath, "packages", pkgName);
+    const projNpmConfig = await this._getProjNpmConfigAsync();
+    const projName = projNpmConfig.name;
+
+    await this._addPackageBaseTemplate({
+      name: pkgName,
+      description: (opt.description === undefined ? "" : `${opt.description.toUpperCase()} `) + "서버",
+      useDom: false,
+      isModule: false,
+      isForAngular: false,
+      main: "dist/main.js",
+      dependencies: {
+        "@simplysm/sd-core-common": "~7.0.0",
+        "@simplysm/sd-core-node": "~7.0.0",
+        "@simplysm/sd-service-common": "~7.0.0",
+        "@simplysm/sd-service-server": "~7.0.0"
+      }
+    });
+
+    this._logger.log(`[${pkgName}] 'src/main.ts' 파일 등록`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, `src/main.ts`), fc_package_server_main({
+      projPath: this._rootPath,
+      pkgName: pkgName
+    }));
+
+    this._logger.log(`[${pkgName}] 'simplysm.json' 파일에 등록`);
+    await this._addPackageToSimplysmJson({
+      name: pkgName,
+      type: "server",
+      useAutoIndex: false
+    });
+
+    this._logger.log(`[${projName}] npm install`);
+    await SdProcess.spawnAsync("npm install", { cwd: this._rootPath }, true);
+  }
+
+  public async addClientAsync(opt: { name: string; description: string; serverName: string }): Promise<void> {
+    const pkgName = `client-${opt.name}`;
+    const pkgPath = path.resolve(this._rootPath, "packages", pkgName);
+
+    const projNpmConfig = await this._getProjNpmConfigAsync();
+    const projName = projNpmConfig.name;
+
+    await this._addPackageBaseTemplate({
+      name: pkgName,
+      description: `${opt.description} 클라이언트`,
+      useDom: true,
+      isModule: true,
+      isForAngular: true,
+      dependencies: {
+        "@angular/common": "^13.2.0",
+        "@angular/core": "^13.2.0",
+        "@angular/platform-browser": "^13.2.0",
+        "@angular/platform-browser-dynamic": "^13.2.0",
+        "@fortawesome/angular-fontawesome": "^0.10.2",
+        "@fortawesome/fontawesome-svg-core": "^6.1.0",
+        "@fortawesome/free-brands-svg-icons": "^6.1.0",
+        "@fortawesome/pro-duotone-svg-icons": "^6.1.0",
+        "@fortawesome/pro-light-svg-icons": "^6.1.0",
+        "@fortawesome/pro-regular-svg-icons": "^6.1.0",
+        "@fortawesome/pro-solid-svg-icons": "^6.1.0",
+        "@simplysm/sd-angular": "~7.0.0",
+        "@simplysm/sd-core-browser": "~7.0.0",
+        "@simplysm/sd-core-common": "~7.0.0",
+        "rxjs": "^6.6.7",
+        "zone.js": "~0.11.4"
+      }
+    });
+
+    this._logger.log(`[${pkgName}] 'src/app-icons.ts' 파일 등록`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "src/app-icons.ts"), fc_package_appicons());
+
+    this._logger.log(`[${pkgName}] 'src/AppModule.ts' 파일 등록`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "src/AppModule.ts"), fc_package_AppModule());
+
+    this._logger.log(`[${pkgName}] 'src/AppPage.ts' 파일 등록`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "src/AppPage.ts"), fc_package_AppPage());
+
+    this._logger.log(`[${pkgName}] 'src/index.html' 파일 등록`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "src/index.html"), fc_package_index({
+      description: opt.description
+    }));
+
+    this._logger.log(`[${pkgName}] 'src/main.ts' 파일 등록`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "src/main.ts"), fc_package_client_main());
+
+    this._logger.log(`[${pkgName}] 'src/manifest.json' 파일 등록`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "src/manifest.json"), fc_package_manifest({
+      description: projNpmConfig.description,
+      author: projNpmConfig.author,
+      version: projNpmConfig.version
+    }));
+
+    this._logger.log(`[${pkgName}] 'src/polyfills.ts' 파일 등록`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "src/polyfills.ts"), fc_package_polyfills());
+
+    this._logger.log(`[${pkgName}] 'src/styles.scss' 파일 등록`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "src/styles.scss"), fc_package_styles());
+
+    this._logger.log(`[${pkgName}] 'src/assets' 파일 복사`);
+    await FsUtil.copyAsync(
+      path.resolve(path.dirname(fileURLToPath(import.meta.url)), "file/assets"),
+      path.resolve(pkgPath, "src")
+    );
+
+    await this._addPackageToSimplysmJson({
+      name: pkgName,
+      type: "client",
+      useAutoIndex: false,
+      serverName: opt.serverName
+    });
+
+    this._logger.log(`[${projName}] npm install`);
+    await SdProcess.spawnAsync("npm install", { cwd: this._rootPath }, true);
+  }
+
+  private async _addPackageBaseTemplate(opt: { name: string; description: string; useDom: boolean; isModule: boolean; isForAngular: boolean; main?: string; types?: string; dependencies: Record<string, string> }): Promise<void> {
+    const pkgPath = path.resolve(this._rootPath, "packages", opt.name);
+
+    this._logger.log(`[${opt.name}] '.eslintrc.cjs' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, ".eslintrc.cjs"), fc_package_eslintrc({
+      isForAngular: opt.isForAngular
+    }));
+
+    this._logger.log(`[${opt.name}] 'package.json' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "package.json"), fc_package_npmconfig({
+      projPath: this._rootPath,
+      name: opt.name,
+      description: opt.description,
+      isModule: opt.isModule,
+      main: opt.main,
+      types: opt.types,
+      dependencies: opt.dependencies
+    }));
+
+    this._logger.log(`[${opt.name}] 'tsconfig.json' 파일 생성`);
+    await FsUtil.writeFileAsync(path.resolve(pkgPath, "tsconfig.json"), fc_package_tsconfig({
+      isModule: opt.isModule,
+      useDom: opt.useDom
+    }));
+
+    this._logger.log(`[${opt.name}] 'src' 디렉토리 생성`);
+    await FsUtil.mkdirsAsync(path.resolve(pkgPath, "src"));
+  }
+
+  private async _addPackageToSimplysmJson(opt: { name: string; type: string; useAutoIndex: boolean; serverName?: string }): Promise<void> {
+    const config = await FsUtil.readJsonAsync(path.resolve(this._rootPath, "simplysm.json"));
+    config.packages = config.packages ?? {};
+    config.packages[opt.name] = {
+      type: opt.type,
+      ...opt.useAutoIndex ? { autoIndex: {} } : {},
+      ...opt.serverName !== undefined ? { server: opt.serverName } : {}
+    };
+    await FsUtil.writeJsonAsync(path.resolve(this._rootPath, "simplysm.json"), config, { space: 2 });
+  }
+
+  private async _getProjNpmConfigAsync(): Promise<INpmConfig & { description: string; author: string }> {
+    const projNpmConfig = await FsUtil.readJsonAsync(path.resolve(this._rootPath, "package.json")) as INpmConfig;
+
+    if (projNpmConfig.description === undefined) {
+      throw new Error("프로젝트 package.json 파일에 description 이 설정되어있지 않습니다.");
+    }
+    if (projNpmConfig.author === undefined) {
+      throw new Error("프로젝트 package.json 파일에 author 가 설정되어있지 않습니다.");
+    }
+
+    return projNpmConfig as any;
+  }
+}

package/src/entry-points/SdCliWorkspace.ts

@@ -32,7 +32,8 @@ export class SdCliWorkspace {
     }
 
     this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync(config, opt.pkgs);
+    const allPkgs = await this._getPackagesAsync(config);
+    const pkgs = allPkgs.filter((pkg) => opt.pkgs.length === 0 || opt.pkgs.includes(path.basename(pkg.rootPath)));
 
     this._logger.debug("패키지 이벤트 설정...");
     let changeCount = 0;
@@ -102,32 +103,6 @@ export class SdCliWorkspace {
         if (pkg.config.type === "client") {
           await pkg.watchAsync();
 
-          /*const pkgMiddleware: NextHandleFunction = (req, res, next) => {
-            if (req.method === "GET") {
-              const urlObj = url.parse(req.url!, true, false);
-              const urlPathChain = decodeURI(urlObj.pathname!.slice(1)).split("/");
-              if (urlPathChain[0] === pkg.name.split("/").last()!) {
-                let targetFilePath = path.resolve(pkg.rootPath, "dist", ...urlPathChain.slice(1));
-                targetFilePath = FsUtil.exists(targetFilePath) && FsUtil.stat(targetFilePath).isDirectory() ? path.resolve(targetFilePath, "index.html") : targetFilePath;
-
-                if (FsUtil.exists(targetFilePath) && !path.basename(targetFilePath).startsWith(".")) {
-                  const fileStream = FsUtil.createReadStream(targetFilePath);
-                  const targetFileSize = FsUtil.lstat(targetFilePath).size;
-
-                  fileStream.on("open", () => {
-                    res.setHeader("Content-Length", targetFileSize);
-                    res.setHeader("Content-Type", mime.getType(targetFilePath)!);
-                    res.writeHead(200);
-                  });
-                  fileStream.pipe(res);
-                  return;
-                }
-              }
-            }
-
-            next();
-          };*/
-
           if (typeof pkg.config.server === "string") {
             const serverInfo = this._serverInfoMap.getOrCreate(pkg.config.server, { pathProxy: [], clientInfos: [] });
 
@@ -164,20 +139,6 @@ export class SdCliWorkspace {
                 platforms: pkg.config.builder ? Object.keys(pkg.config.builder) : ["web"],
                 cordovaTargets: pkg.config.builder?.cordova?.target ? Object.keys(pkg.config.builder.cordova.target) : ["browser"]
               });
-
-              /*const server = new SdServiceServer({
-                rootPath: process.cwd(),
-                services: [],
-                port: pkg.config.server.port
-              });
-              await server.listenAsync();
-              serverInfo.server = server;
-              serverInfo.server.devMiddlewares = [pkgMiddleware];
-              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"]
-              });*/
             }
           }
         }
@@ -201,6 +162,76 @@ export class SdCliWorkspace {
     }
   }
 
+  public async buildAsync(opt: { confFileRelPath: string; optNames: string[]; pkgs: string[] }): Promise<void> {
+    this._logger.debug("프로젝트 설정 가져오기...");
+    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
+
+    this._logger.debug("패키지 목록 구성...");
+    const allPkgs = await this._getPackagesAsync(config);
+    const pkgs = allPkgs.filter((pkg) => opt.pkgs.length === 0 || opt.pkgs.includes(path.basename(pkg.rootPath)));
+
+    this._logger.debug("프로젝트 및 패키지 버전 설정...");
+    await this._upgradeVersionAsync(allPkgs);
+
+    // 빌드
+    await this._buildPkgsAsync(pkgs);
+  }
+
+  public async publishAsync(opt: { noBuild: boolean; confFileRelPath: string; optNames: string[]; pkgs: string[] }): Promise<void> {
+    this._logger.debug("프로젝트 설정 가져오기...");
+    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
+
+    if (opt.noBuild) {
+      this._logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
+      await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
+    }
+
+    // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
+    if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
+      this._logger.debug("GIT 커밋여부 확인...");
+      const gitStatusResult = await SdProcess.spawnAsync("git status");
+      if (gitStatusResult.includes("Changes") || gitStatusResult.includes("Untracked")) {
+        throw new Error("커밋되지 않은 정보가 있습니다.\n" + gitStatusResult);
+      }
+    }
+
+    this._logger.debug("패키지 목록 구성...");
+    const allPkgs = await this._getPackagesAsync(config);
+    const pkgs = allPkgs.filter((pkg) => opt.pkgs.length === 0 || opt.pkgs.includes(path.basename(pkg.rootPath)));
+
+    this._logger.debug("프로젝트 및 패키지 버전 설정...");
+    await this._upgradeVersionAsync(allPkgs);
+
+    // 빌드
+    if (!opt.noBuild) {
+      // this._logger.debug("노드패키지 업데이트...");
+      // await new SdCliNpm(this._rootPath).updateAsync();
+
+      this._logger.debug("빌드를 시작합니다...");
+      await this._buildPkgsAsync(pkgs);
+    }
+
+    // GIT 사용중일경우, 새 버전 커밋 및 TAG 생성
+    if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
+      this._logger.debug("새 버전 커밋 및 TAG 생성...");
+      await SdProcess.spawnAsync("git add .");
+      await SdProcess.spawnAsync(`git commit -m "v${this._npmConfig.version}"`);
+      await SdProcess.spawnAsync(`git tag -a "v${this._npmConfig.version}" -m "v${this._npmConfig.version}"`);
+
+      this._logger.debug("새 버전 푸쉬...");
+      await SdProcess.spawnAsync("git push");
+      await SdProcess.spawnAsync("git push --tags");
+    }
+
+    this._logger.debug("배포 시작...");
+    await pkgs.parallelAsync(async (pkg) => {
+      this._logger.debug(`[${pkg.name}] 배포를 시작합니다...`);
+      await pkg.publishAsync();
+      this._logger.debug(`[${pkg.name}] 배포가 완료되었습니다.`);
+    });
+    this._logger.info(`모든 배포가 완료되었습니다. (v${this._npmConfig.version})`);
+  }
+
   private async _runServerWorkerAsync(filePathOrOpt: string | { port: number }): Promise<{ worker: cp.ChildProcess; url: string }> {
     const workerPath = fileURLToPath(await import.meta.resolve!("../worker/server-worker"));
     return await new Promise<{ worker: cp.ChildProcess; url: string }>((resolve, reject) => {
@@ -285,17 +316,6 @@ export class SdCliWorkspace {
       serverInfo.url = serverWorkerInfo.url;
       await this._reloadServerWorkerPathProxyAsync(serverInfo);
 
-      /*const serverMainPath = "file:///" + PathUtil.posix(entryFilePath) + "?update=" + Uuid.new().toString().replace(/-/g, "");
-      const serverModule = await import(serverMainPath);
-      serverInfo.server = serverModule.default as SdServiceServer | undefined;
-      if (!serverInfo.server) {
-        this._logger.error(`${entryFilePath}(0, 0): 'SdServiceServer'를 'export'해야 합니다.`);
-        this._isServerRestarting = false;
-        return;
-      }
-      serverInfo.server.devMiddlewares = serverInfo.middlewares;
-      await Wait.until(() => serverInfo.server!.isOpen);*/
-
       this._logger.log(`[${pkg.name}] 서버가 시작되었습니다.`);
     }
     catch (err) {
@@ -305,20 +325,6 @@ export class SdCliWorkspace {
     this._isServerRestarting = false;
   }
 
-  public async buildAsync(opt: { confFileRelPath: string; optNames: string[]; pkgs: string[] }): Promise<void> {
-    this._logger.debug("프로젝트 설정 가져오기...");
-    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
-
-    this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync(config, opt.pkgs);
-
-    this._logger.debug("프로젝트 및 패키지 버전 설정...");
-    await this._upgradeVersionAsync(pkgs);
-
-    // 빌드
-    await this._buildPkgsAsync(pkgs);
-  }
-
   private async _buildPkgsAsync(pkgs: SdCliPackage[]): Promise<void> {
     this._logger.debug("빌드를 시작합니다...");
     const pkgNames = pkgs.map((item) => item.name);
@@ -349,60 +355,6 @@ export class SdCliWorkspace {
     }
   }
 
-  public async publishAsync(opt: { noBuild: boolean; confFileRelPath: string; optNames: string[]; pkgs: string[] }): Promise<void> {
-    this._logger.debug("프로젝트 설정 가져오기...");
-    const config = await SdCliConfigUtil.loadConfigAsync(path.resolve(this._rootPath, opt.confFileRelPath), false, opt.optNames);
-
-    if (opt.noBuild) {
-      this._logger.warn("빌드하지 않고, 배포하는것은 상당히 위험합니다.");
-      await this._waitSecMessageAsync("프로세스를 중지하려면, 'CTRL+C'를 누르세요.", 5);
-    }
-
-    // GIT 사용중일 경우, 커밋되지 않은 수정사항이 있는지 확인
-    if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
-      this._logger.debug("GIT 커밋여부 확인...");
-      const gitStatusResult = await SdProcess.spawnAsync("git status");
-      if (gitStatusResult.includes("Changes") || gitStatusResult.includes("Untracked")) {
-        throw new Error("커밋되지 않은 정보가 있습니다.\n" + gitStatusResult);
-      }
-    }
-
-    this._logger.debug("패키지 목록 구성...");
-    const pkgs = await this._getPackagesAsync(config, opt.pkgs);
-
-    this._logger.debug("프로젝트 및 패키지 버전 설정...");
-    await this._upgradeVersionAsync(pkgs);
-
-    // 빌드
-    if (!opt.noBuild) {
-      // this._logger.debug("노드패키지 업데이트...");
-      // await new SdCliNpm(this._rootPath).updateAsync();
-
-      this._logger.debug("빌드를 시작합니다...");
-      await this._buildPkgsAsync(pkgs);
-    }
-
-    // GIT 사용중일경우, 새 버전 커밋 및 TAG 생성
-    if (FsUtil.exists(path.resolve(process.cwd(), ".git"))) {
-      this._logger.debug("새 버전 커밋 및 TAG 생성...");
-      await SdProcess.spawnAsync("git add .");
-      await SdProcess.spawnAsync(`git commit -m "v${this._npmConfig.version}"`);
-      await SdProcess.spawnAsync(`git tag -a "v${this._npmConfig.version}" -m "v${this._npmConfig.version}"`);
-
-      this._logger.debug("새 버전 푸쉬...");
-      await SdProcess.spawnAsync("git push");
-      await SdProcess.spawnAsync("git push --tags");
-    }
-
-    this._logger.debug("배포 시작...");
-    await pkgs.parallelAsync(async (pkg) => {
-      this._logger.debug(`[${pkg.name}] 배포를 시작합니다...`);
-      await pkg.publishAsync();
-      this._logger.debug(`[${pkg.name}] 배포가 완료되었습니다.`);
-    });
-    this._logger.info(`모든 배포가 완료되었습니다. (v${this._npmConfig.version})`);
-  }
-
   private async _upgradeVersionAsync(pkgs: SdCliPackage[]): Promise<void> {
     // 작업공간 package.json 버전 설정
     const newVersion = semver.inc(this._npmConfig.version, "patch")!;
@@ -445,14 +397,14 @@ export class SdCliWorkspace {
     process.stdout.clearLine(0);
   }
 
-  private async _getPackagesAsync(conf: ISdCliConfig, pkgs: string[]): Promise<SdCliPackage[]> {
+  private async _getPackagesAsync(conf: ISdCliConfig): Promise<SdCliPackage[]> {
     const pkgRootPaths = await this._npmConfig.workspaces?.mapManyAsync(async (item) => await FsUtil.globAsync(item));
     if (!pkgRootPaths) {
       throw new Error("최상위 'package.json'에서 'workspaces'를 찾을 수 없습니다.");
     }
 
     return pkgRootPaths.map((pkgRootPath) => {
-      if (pkgs.length > 0 && !pkgs.includes(path.basename(pkgRootPath))) return undefined;
+      // if (pkgs.length > 0 && !pkgs.includes(path.basename(pkgRootPath))) return undefined;
       const pkgConfig = conf.packages[path.basename(pkgRootPath)];
       if (!pkgConfig) return undefined;
       return new SdCliPackage(this._rootPath, pkgRootPath, pkgConfig);