import {Options} from "electron-packager"; import * as packager from "electron-packager" const pkg = require('../package.json'); const dev_dependencies = Object.keys(pkg.devDependencies); import * as fs from "fs-extra"; import * as path_helper from "path"; import {parse_version} from "../modules/shared/version"; import * as util from "util"; import * as child_process from "child_process"; import * as os from "os"; import * as asar from "asar"; import * as querystring from "querystring"; import request = require("request"); import * as deployer from "./deploy"; let options: Options = {} as any; let version = parse_version(pkg.version); version.timestamp = Date.now(); options.dir = '.'; options.name = "TeaClient"; options.appVersion = pkg.version; options.appCopyright = "© 2018-2019 Markus Hadenfeldt All Rights Reserved"; options.out = "build/"; if(!pkg.dependencies['electron']) { console.error("Missing electron version"); process.exit(1); } options["version-string"] = { 'CompanyName': 'TeaSpeak', 'LegalCopyright': '© 2018-2020 Markus Hadenfeldt All Rights Reserved', 'FileDescription' : 'TeaSpeak-Client', 'OriginalFilename' : 'TeaClient.exe', 'FileVersion' : pkg.version, 'ProductVersion' : pkg.version, 'ProductName' : 'TeaSpeak-Client', 'InternalName' : 'TeaClient.exe' }; options.electronVersion = pkg.dependencies['electron']; options.protocols = [{name: "TeaSpeak - Connect", schemes: ["teaserver"]}]; options.overwrite = true; options.derefSymlinks = true; options.buildVersion = version.toString(true); options.asar = { unpackDir: "teaclient-unpacked" }; interface ProjectEntry { type: ProjectEntryType; } interface ProjectFile extends ProjectEntry { path: string; name: string | RegExp; //target_name?: string | ((file: string) => string); } interface ProjectDirectory extends ProjectEntry { path: string | RegExp; children?: boolean; files?: RegExp; } enum ProjectEntryType { FILE, DIRECTORY } const project_files: ProjectEntry[] = []; { /* general required files*/ project_files.push({ type: ProjectEntryType.FILE, path: "/", name: "package.json" } as ProjectFile); project_files.push({ type: ProjectEntryType.FILE, path: "/", name: "main.js" } as ProjectFile); project_files.push({ type: ProjectEntryType.DIRECTORY, path: "/node_modules", children: true, files: /\.(js|css|html|node|json)$/ } as ProjectDirectory); project_files.push({ type: ProjectEntryType.DIRECTORY, path: "/node_modules/electron", children: true, files: /.*/ } as ProjectDirectory); } /* TeaClient modules */ project_files.push({ type: ProjectEntryType.DIRECTORY, path: "/modules", children: true, files: /.*\.(js|css|html|png|svg)$/ } as ProjectDirectory); /* resource files */ project_files.push({ type: ProjectEntryType.DIRECTORY, path: "/resources" } as ProjectDirectory); if (process.argv[2] == "linux") { options.arch = "x64"; options.platform = "linux"; options.icon = "resources/logo.svg"; } else if (process.argv[2] == "win32") { options.arch = "x64"; options.platform = "win32"; options.icon = "resources/logo.ico"; } else { console.error("Invalid system"); process.exit(1); } const path_validator = (path: string) => { path = path.replace(/\\/g,"/"); const IGNORE = true; const APPEND = false; const ppath = path_helper.parse(path); const is_directory = ppath.ext == '' && fs.statSync(path_helper.join('.', ppath.dir, ppath.name)).isDirectory(); const directory = (is_directory ? path_helper.join(ppath.dir, ppath.name) : ppath.dir).replace(/\\/g,"/"); //console.log("Is directory %o => %s", is_directory, directory); //console.dir(ppath); for(const entry of project_files) { if(entry.type == ProjectEntryType.DIRECTORY) { const dir_entry = entry; if(typeof(dir_entry.path) === 'string') { //ppath.dir == dir_entry.path //console.log("'" + dir_entry.path + "' | '" + directory + "'"); if(dir_entry.path.startsWith(directory)) { if(is_directory) return APPEND; } if(directory == dir_entry.path) { //console.log("Math: " + ppath.base + " to " + dir_entry.files); if(dir_entry.files) return ppath.base.match(dir_entry.files) ? APPEND : IGNORE; return APPEND; } if(directory.startsWith(dir_entry.path)) { if(dir_entry.children) { if(is_directory) return APPEND; const sub_path = directory.substr(dir_entry.path.length); //console.log("Sub path: " + sub_path + ". Test: " + (path_helper.join(sub_path, ppath.base) + " against " + dir_entry.files); if(dir_entry.files) return path_helper.join(sub_path, ppath.base).match(dir_entry.files) ? APPEND : IGNORE; return APPEND; } //TODO test for regex } } else { //TODO } } else if(entry.type == ProjectEntryType.FILE) { const file_entry = entry; if(file_entry.path.startsWith(directory) && is_directory) return APPEND; if(directory == file_entry.path) { if(typeof(file_entry.name) === 'string' && ppath.base == file_entry.name) return APPEND; else if (ppath.base.match(file_entry.name)) return APPEND; } } } return true; }; options.ignore = path => { if(path.length == 0) return false; //Dont ignore root paths const ignore_path = path_validator(path); if(!ignore_path) { console.log(" + " + path); } return ignore_path; }; async function copy_striped(source: string, target: string, symbol_directory: string) { const exec = (command, options) => new Promise<{ stdout: Buffer | string, stderr: Buffer | string}>((resolve, reject) => child_process.exec(command, options, (error, out, err) => error ? reject(error) : resolve({stdout: out, stderr: err}))); if(process.argv[2] == "win32") { await fs.copy(source, target); return; } if(process.argv[2] != "linux") throw "invalid target type"; await fs.copy(source, target); { const symbols_command = await exec("dump_syms " + target, { maxBuffer: 1024 * 1024 * 512 }); if(symbols_command.stderr.length != 0) { console.error("Failed to create sys dump: %o", symbols_command.stderr.toString()); throw "symbol create failed"; } const symbols = symbols_command.stdout.toString(); const header = symbols.substr(0, symbols.indexOf('\n')); const binary_name = path_helper.basename(target); const dump_id = header.split(" ")[3]; if(binary_name != header.split(" ")[4]) throw "binary name missmatch"; const dump_dir = path_helper.join(symbol_directory, binary_name, dump_id); const dump_file = path_helper.join(dump_dir, binary_name + ".sym"); if(!(await fs.pathExists(dump_dir))) await fs.mkdirp(dump_dir); await fs.ensureDir(dump_dir); console.log("Writing file to %s", dump_file); await fs.writeFile(dump_file, symbols); console.log("Created dump file for binary %s (%s).", binary_name, dump_id); } { console.log("Striping file"); //TODO: Keep node module names! const strip_command = await exec("strip -s " + target, { maxBuffer: 1024 * 1024 * 512 }); if(strip_command.stderr.length != 0) { console.error("Failed to strip binary: %o", strip_command.stderr.toString()); throw "strip failed"; } const nm_command = await exec("nm " + target, { maxBuffer: 1024 * 1024 * 512 }); console.log("File stripped. Symbols left: \n%s", nm_command.stderr.toString().trim() || nm_command.stdout.toString().trim()); } } async function create_native_addons(target_directory: string, symbol_directory: string) { let node_source = "native/build/" + os.platform() + "_" + os.arch() + "/"; console.log("Native addon path: %s", node_source); await fs.ensureDir(target_directory); for(const file of await fs.readdir(node_source)) { if(!file.endsWith(".node")) { console.warn("Discovered non node file within node file out dir"); continue; } await copy_striped(path_helper.join(node_source, file), path_helper.join(target_directory, file), symbol_directory); } } interface UIVersion { channel: string; version: string; git_hash: string; timestamp: number; required_client?: string; filename?: string; } async function create_default_ui_pack(target_directory: string) { const remote_url = "http://clientapi.teaspeak.dev/"; const channel = "release"; const file = path_helper.join(target_directory, "default_ui.tar.gz"); console.log("Creating default UI pack. Downloading from %s (channel: %s)", remote_url, channel); await fs.ensureDir(target_directory); let ui_info: UIVersion; await new Promise((resolve, reject) => { request.get(remote_url + "api.php?" + querystring.stringify({ type: "ui-download", channel: channel, version: "latest" }), { timeout: 5000 }).on('response', function(response) { if(response.statusCode != 200) reject("Failed to download UI files (Status code " + response.statusCode + ")"); ui_info = { channel: channel, version: response.headers["x-ui-version"] as string, git_hash: response.headers["x-ui-git-ref"] as string, required_client: response.headers["x-ui-required_client"] as string, timestamp: parseInt(response.headers["x-ui-timestamp"] as string), filename: path_helper.basename(file) } }).on('error', error => { reject("Failed to download UI files: " + error); }).pipe(fs.createWriteStream(file)).on('finish', resolve); }); if(!ui_info) throw "failed to generate ui info!"; await fs.writeJson(path_helper.join(target_directory, "default_ui_info.json"), ui_info); console.log("UI-Pack downloaded!"); } let path; new Promise((resolve, reject) => packager(options, (err, appPaths) => err ? reject(err) : resolve(appPaths))).then(async app_paths => { console.log("Copying changelog file!"); /* We dont have promisify in our build system */ await fs.copy(path_helper.join(options.dir, "github", "ChangeLog.txt"), path_helper.join(app_paths[0], "ChangeLog.txt")); return app_paths; }).then(async app_paths => { await create_native_addons(path_helper.join(app_paths[0], "resources", "natives"), "build/symbols"); return app_paths; }).then(async app_paths => { await create_default_ui_pack(path_helper.join(app_paths[0], "resources", "ui")); return app_paths; }).then(async appPaths => { ///native/build/linux_amd64 path = appPaths[0]; if(process.argv[2] == "linux") { await copy_striped(options.dir + "/native/build/exe/update-installer", path + "/update-installer", "build/symbols"); } else if (process.argv[2] == "win32") { await copy_striped(options.dir + "/native/build/exe/update-installer.exe", path + "/update-installer.exe", "build/symbols"); } await fs.writeJson(path + "/app_version.json", { version: version.toString(true), timestamp: version.timestamp }); return appPaths; }).then(async app_path => { console.log("Fixing versions file"); let version = await fs.readFile(path_helper.join(app_path[0], "version"), 'UTF-8'); if(!version.startsWith("v")) version = "v" + version; await fs.writeFile(path_helper.join(app_path[0], "version"), version); return app_path; }).then(async () => { if(process.argv[2] == "win32") { console.log("Installing local PDB files"); const symbol_binary_path = "native/build/" + os.platform() + "_" + os.arch() + "/"; const symbol_pdb_path = "native/build/symbols/"; const symbol_server_path = path_helper.join(__dirname, "..", "native", "build", "symbol-server"); const files = []; for(const file of await fs.readdir(symbol_binary_path)) { console.error(file); if(!file.endsWith(".node")) continue; let file_name = path_helper.basename(file); if(file_name.endsWith(".node")) file_name = file_name.substr(0, file_name.length - 5); const binary_path = path_helper.join(symbol_binary_path, file); const pdb_path = path_helper.join(symbol_pdb_path, file_name + ".pdb"); if(!fs.existsSync(pdb_path)) { console.warn("Missing PDB file for binary %s", file); continue; } files.push({ binary: binary_path, pdb: pdb_path }); } console.log("Gathered %d files", files.length); await deployer.deploy_win_dbg_files(files, version, symbol_server_path); console.log("PDB files deployed"); } }).then(() => { console.log("Package created"); process.exit(0); }).catch(error => { console.error(error); console.error("Failed to create package!"); process.exit(1); }); export {}