@simplysm/sd-cli 7.0.100 → 7.0.151

package/src/build-tool/SdCliGithubApi.ts

@@ -0,0 +1,111 @@
+import https from "https";
+import { SdProcess } from "@simplysm/sd-core-node";
+import mime from "mime";
+
+export class SdCliGithubApi {
+  public constructor(private readonly _apiKey: string,
+                     private readonly _repoOwner: string,
+                     private readonly _repoName: string) {
+  }
+
+  public async uploadAsync(version: string, files: { name: string; buffer: Buffer }[]): Promise<void> {
+    const releaseId = await this._createReleaseTagAsync(version);
+
+    for (const file of files) {
+      await this._uploadFileAsync(releaseId, file.name, file.buffer);
+    }
+  }
+
+  private async _uploadFileAsync(releaseId: number, fileName: string, buffer: Buffer): Promise<void> {
+    const contentLength = buffer.length;
+
+    await new Promise<void>((resolve, reject) => {
+      const req = https.request(
+        `https://uploads.github.com/repos/${this._repoOwner}/${this._repoName}/releases/${releaseId}/assets?name=${fileName}&label=${fileName}`,
+        {
+          method: "POST",
+          headers: {
+            "Authorization": `token ${this._apiKey}`,
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "@simplysm/sd-cli:publish",
+            "Content-Length": contentLength,
+            "Content-Type": mime.getType(fileName)!
+          }
+        },
+        (res) => {
+          let dataBuffer = Buffer.from([]);
+          res.on("data", data => {
+            dataBuffer = Buffer.concat([dataBuffer, data]);
+          });
+
+          res.on("end", () => {
+            if (res.statusCode !== 201) {
+              const errObj = JSON.parse(dataBuffer.toString());
+              throw new Error(errObj.message + "(" + errObj.documentation_url + ")");
+            }
+            else {
+              resolve();
+            }
+          });
+        }
+      );
+
+      req.on("error", (error) => {
+        reject(error);
+      });
+      req.write(buffer);
+      req.end();
+    });
+  }
+
+  private async _createReleaseTagAsync(ver: string): Promise<number> {
+    const currentBranch = (await SdProcess.spawnAsync("git branch --show-current")).trim();
+
+    return await new Promise<number>((resolve, reject) => {
+      const req = https.request(
+        `https://api.github.com/repos/${this._repoOwner}/${this._repoName}/releases`,
+        {
+          method: "POST",
+          headers: {
+            "Authorization": `token ${this._apiKey}`,
+            "Accept": "application/vnd.github.v3+json",
+            "User-Agent": "@simplysm/sd-cli:publish"
+          }
+        },
+        (res) => {
+          let dataBuffer = Buffer.from([]);
+          res.on("data", data => {
+            dataBuffer = Buffer.concat([dataBuffer, data]);
+          });
+
+          res.on("end", () => {
+            if (res.statusCode !== 201) {
+              const errObj = JSON.parse(dataBuffer.toString());
+              throw new Error(errObj.message + "(" + errObj.documentation_url + ")");
+            }
+            else {
+              // console.log(JSON.parse(dataBuffer.toString()));
+              const resData = JSON.parse(dataBuffer.toString());
+              resolve(resData.id);
+            }
+          });
+        }
+      );
+
+      req.on("error", (error) => {
+        reject(error);
+      });
+
+      req.write(JSON.stringify({
+        tag_name: `v${ver}`,
+        target_commitish: currentBranch,
+        name: `v${ver}`,
+        body: `v${ver}`,
+        draft: false,
+        prerelease: false
+      }));
+
+      req.end();
+    });
+  }
+}

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
@@ -35,7 +34,6 @@ import { SdCliNgModuleGenerator } from "../ng-tools/SdCliNgModuleGenerator";
 import { SdCliCordova } from "../build-tool/SdCliCordova";
 import { SdCliNpmConfigUtil } from "../utils/SdCliNpmConfigUtil";
 import electronBuilder from "electron-builder";
-import { NeverEntryError } from "@simplysm/sd-core-common";
 import LintResult = ESLint.LintResult;
 
 export class SdCliClientBuilder extends EventEmitter {
@@ -85,8 +83,8 @@ export class SdCliClientBuilder extends EventEmitter {
     } : undefined);
 
     // CORDOVA
-    if (this._config.builders?.cordova) {
-      this._cordova = new SdCliCordova(this._rootPath, this._config.builders.cordova);
+    if (this._config.builder?.cordova) {
+      this._cordova = new SdCliCordova(this._rootPath, this._config.builder.cordova);
     }
   }
 
@@ -111,7 +109,7 @@ export class SdCliClientBuilder extends EventEmitter {
     }
 
     // 빌드 준비
-    const webpackConfigs = (Object.keys(this._config.builders ?? { web: {} }) as ("web" | "cordova" | "electron")[])
+    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) => {
@@ -193,7 +191,7 @@ export class SdCliClientBuilder extends EventEmitter {
 
     // 빌드
     this._logger.debug("Webpack 빌드 수행...");
-    const builderTypes = (Object.keys(this._config.builders ?? { web: {} }) as ("web" | "cordova" | "electron")[]);
+    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) => {
@@ -218,8 +216,8 @@ export class SdCliClientBuilder extends EventEmitter {
       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, path.resolve(this._parsedTsconfig.options.outDir!, "web"))) as any,
-        `/${packageKey}/web/`,
+        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")))
       );
     }
@@ -234,14 +232,23 @@ export class SdCliClientBuilder extends EventEmitter {
     }
 
     // ELECTRON
-    if (this._config.builders?.electron) {
+    if (this._config.builder?.electron) {
       const npmConfig = this._getNpmConfig(this._rootPath)!;
 
-      if (npmConfig.dependencies?.["electron"] == null) {
-        throw new NeverEntryError();
+      const electronVersion = npmConfig.dependencies?.["electron"];
+      if (electronVersion === undefined) {
+        throw new Error("ELECTRON 빌드 패키지의 'dependencies'에는 'electron'이 반드시 포함되어야 합니다.");
       }
 
-      await FsUtil.writeJsonAsync(path.resolve(this._rootPath, `.electron/src/package.json`), {
+      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,
@@ -249,24 +256,34 @@ export class SdCliClientBuilder extends EventEmitter {
         author: npmConfig.author,
         license: npmConfig.license,
         devDependencies: {
-          "electron": npmConfig.dependencies["electron"].replace("^", "")
+          "electron": electronVersion.replace("^", "")
+        },
+        dependencies: {
+          "dotenv": dotenvVersion
         }
       });
 
-      await FsUtil.writeFileAsync(path.resolve(this._rootPath, `.electron/src/.env`), `NODE_ENV=production`);
+      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"));
 
-      await FsUtil.copyAsync(path.resolve(this._rootPath, `src/electron.prod.js`), path.resolve(this._rootPath, ".electron/src/electron.js"));
+      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.builders.electron.appId,
+          appId: this._config.builder.electron.appId,
           productName: npmConfig.description,
-          asar: true,
           nsis: {},
           directories: {
-            app: path.resolve(this._rootPath, ".electron/src"),
-            output: path.resolve(this._rootPath, ".electron/dist")
+            app: electronSrcPath,
+            output: electronDistPath
           }
         }
       });
@@ -300,20 +317,21 @@ export class SdCliClientBuilder extends EventEmitter {
     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 = (builderType === "web" || watch) ? `/${pkgKey}/${builderType}/` : ``;
+    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 = (builderType === "cordova" && !watch)
-      ? path.resolve(this._cordova!.cordovaPath, "www")
-      : (builderType === "electron" && !watch)
-        ? path.resolve(this._rootPath, ".electron/src")
-        : `${this._parsedTsconfig.options.outDir}/${builderType}`;
+    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();
 
@@ -376,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")
@@ -490,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,
@@ -564,7 +583,9 @@ export class SdCliClientBuilder extends EventEmitter {
         ]
       },
       plugins: [
-        new NodePolyfillPlugin(),
+        new NodePolyfillPlugin({
+          excludeAliases: builderType === "electron" ? ["process"] : []
+        }),
         new NamedChunksPlugin(),
         new DedupeModuleResolvePlugin(),
         new webpack.ProgressPlugin({
@@ -578,9 +599,6 @@ export class SdCliClientBuilder extends EventEmitter {
             }
           }
         }),
-        new CommonJsUsageWarnPlugin({
-          allowedDependencies: ["@fortawesome"]
-        }),
         ...watch ? [] : [
           new LicenseWebpackPlugin({
             stats: { warnings: false, errors: false },
@@ -612,18 +630,18 @@ export class SdCliClientBuilder extends EventEmitter {
               {
                 context: this._cordova!.cordovaPath,
                 to: `cordova-${platform}/plugins`,
-                from: `platforms/${platform}/www/plugins`,
+                from: `platforms/${platform}/platform_www/plugins`,
                 noErrorOnMissing: true
               },
               {
                 context: this._cordova!.cordovaPath,
                 to: `cordova-${platform}/cordova.js`,
-                from: `platforms/${platform}/www/cordova.js`
+                from: `platforms/${platform}/platform_www/cordova.js`
               },
               {
                 context: this._cordova!.cordovaPath,
                 to: `cordova-${platform}/cordova_plugins.js`,
-                from: `platforms/${platform}/www/cordova_plugins.js`,
+                from: `platforms/${platform}/platform_www/cordova_plugins.js`,
                 noErrorOnMissing: true
               },
               {
@@ -685,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/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/commons.ts

@@ -4,6 +4,11 @@ export interface INpmConfig {
   description?: string;
   author?: string;
   license?: string;
+  repository: string | {
+    type: string;
+    url: string;
+    directory?: string;
+  };
   type?: "module";
   workspaces?: string[];
   main?: string;
@@ -66,7 +71,7 @@ export interface ISdCliServerPackageConfig {
 
 export interface ISdCliClientPackageConfig {
   type: "client";
-  builders?: {
+  builder?: {
     web?: ISdCliClientBuilderWebConfig;
     cordova?: ISdCliClientBuilderCordovaConfig;
     electron?: ISdCliClientBuilderElectronConfig;
@@ -77,7 +82,7 @@ export interface ISdCliClientPackageConfig {
   publish?: TSdCliPublishConfig;
 }
 
-export type TSdCliPublishConfig = ISdCliFtpPublishConfig | ISdCliLocalDirectoryPublishConfig;
+export type TSdCliPublishConfig = ISdCliFtpPublishConfig | ISdCliLocalDirectoryPublishConfig | ISdCliGithubPublishConfig;
 
 export interface ISdCliFtpPublishConfig {
   type: "ftp" | "ftps" | "sftp";
@@ -93,17 +98,22 @@ export interface ISdCliLocalDirectoryPublishConfig {
   path: string;
 }
 
+export interface ISdCliGithubPublishConfig {
+  type: "github";
+  apiKey: string;
+  files: { from: string; to: string }[];
+}
+
 export interface ISdCliClientBuilderWebConfig {
 }
 
 export interface ISdCliClientBuilderCordovaConfig {
-  type: "cordova";
   appId: string;
   appName: string;
   plugins?: string[];
   icon?: string;
   debug?: boolean;
-  targets?: {
+  target?: {
     browser?: {};
     android?: {
       bundle?: boolean;
@@ -120,9 +130,5 @@ export interface ISdCliClientBuilderCordovaConfig {
 
 export interface ISdCliClientBuilderElectronConfig {
   appId: string;
-}
-
-export type TSdCliClientBuilderConfig =
-  ISdCliClientBuilderWebConfig
-  | ISdCliClientBuilderCordovaConfig
-  | ISdCliClientBuilderElectronConfig;
+  icon?: string;
+}

package/src/entry-points/SdCliWorkspace.ts

@@ -83,7 +83,11 @@ export class SdCliWorkspace {
           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()! });
+            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: [] });
@@ -96,7 +100,11 @@ export class SdCliWorkspace {
               await server.listenAsync();
               serverInfo.server = server;
               serverInfo.server.devMiddlewares = middlewares;
-              serverInfo.clientInfos.push({ pkgKey: pkg.name.split("/").last()! });
+              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"]
+              });
             }
           }
         }
@@ -250,6 +258,9 @@ export class SdCliWorkspace {
       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 --tags");
     }
 
     this._logger.debug("배포 시작...");
@@ -361,11 +372,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")}`);
     }
   }
 }
@@ -373,5 +401,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,6 +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";

package/src/packages/SdCliPackage.ts

@@ -11,6 +11,7 @@ import { SdCliClientBuilder } from "../builder/SdCliClientBuilder";
 import { NextHandleFunction } from "connect";
 import { SdStorage } from "@simplysm/sd-storage";
 import ts from "typescript";
+import { SdCliGithubApi } from "../build-tool/SdCliGithubApi";
 
 export class SdCliPackage extends EventEmitter {
   private readonly _npmConfig: INpmConfig;
@@ -96,7 +97,23 @@ export class SdCliPackage extends EventEmitter {
         }
       }
       else {
-        if (this.config.publish.type === "ftp" || this.config.publish.type === "ftps" || this.config.publish.type === "sftp") {
+        if (this.config.publish.type === "github") {
+          const repoUrl = typeof this._npmConfig.repository === "string" ? this._npmConfig.repository : this._npmConfig.repository.url;
+          const repoOwner = repoUrl.split("/").slice(-2)[0];
+          const repoName = repoUrl.split("/").slice(-2)[1].replace(/\..*/g, "");
+
+          const github = new SdCliGithubApi(
+            this.config.publish.apiKey,
+            repoOwner,
+            repoName
+          );
+
+          await github.uploadAsync(this._npmConfig.version, this.config.publish.files.map((item) => ({
+            buffer: FsUtil.readFileBuffer(path.resolve(this.rootPath, "dist", item.from)),
+            name: item.to
+          })));
+        }
+        else if (this.config.publish.type === "ftp" || this.config.publish.type === "ftps" || this.config.publish.type === "sftp") {
           const tsconfigPath = path.resolve(this.rootPath, "tsconfig-build.json");
           const tsconfig = FsUtil.readJson(tsconfigPath);
           const parsedTsconfig = ts.parseJsonConfigFileContent(tsconfig, ts.sys, this.rootPath, tsconfig.angularCompilerOptions);