react-native-update-cli 2.7.1 → 2.7.2

package/cli.json

@@ -254,6 +254,7 @@
           "default": false
         },
         "hermes": {
+          "hasValue": true,
           "default": false
         },
         "name": {

package/lib/esm/api..mjs

@@ -0,0 +1,183 @@
+import fs from "fs";
+import path from "path";
+import util from "util";
+import filesizeParser from "filesize-parser";
+import FormData from "form-data";
+import fetch from "node-fetch";
+import ProgressBar from "progress";
+import tcpp from "tcp-ping";
+import { getBaseUrl } from "./utils/http-helper";
+import packageJson from "../package.json";
+import { credentialFile, pricingPageUrl, IS_CRESC } from "./utils/constants";
+import { t } from "./utils/i18n";
+const tcpPing = util.promisify(tcpp.ping);
+let session;
+let savedSession;
+let apiToken;
+const userAgent = `react-native-update-cli/${packageJson.version}`;
+export const getSession = ()=>session;
+export const getApiToken = ()=>apiToken;
+export const setApiToken = (token)=>{
+    apiToken = token;
+};
+const loadApiTokenFromEnv = ()=>{
+    // Use CRESC_API_TOKEN for cresc, PUSHY_API_TOKEN for pushy
+    const envToken = IS_CRESC ? process.env.CRESC_API_TOKEN : process.env.PUSHY_API_TOKEN;
+    if (envToken) {
+        apiToken = envToken;
+    }
+};
+export const replaceSession = (newSession)=>{
+    session = newSession;
+};
+export const loadSession = async ()=>{
+    loadApiTokenFromEnv();
+    if (fs.existsSync(credentialFile)) {
+        try {
+            replaceSession(JSON.parse(fs.readFileSync(credentialFile, 'utf8')));
+            savedSession = session;
+        } catch (e) {
+            console.error(`Failed to parse file ${credentialFile}. Try to remove it manually.`);
+            throw e;
+        }
+    }
+};
+export const saveSession = ()=>{
+    // Only save on change.
+    if (session !== savedSession) {
+        const current = session;
+        const data = JSON.stringify(current, null, 4);
+        fs.writeFileSync(credentialFile, data, 'utf8');
+        savedSession = current;
+    }
+};
+export const closeSession = ()=>{
+    if (fs.existsSync(credentialFile)) {
+        fs.unlinkSync(credentialFile);
+        savedSession = undefined;
+    }
+    session = undefined;
+};
+async function query(url, options) {
+    const baseUrl = await getBaseUrl;
+    const fullUrl = `${baseUrl}${url}`;
+    const resp = await fetch(fullUrl, options);
+    const text = await resp.text();
+    let json;
+    try {
+        json = JSON.parse(text);
+    } catch (e) {}
+    if (resp.status !== 200) {
+        const message = (json == null ? void 0 : json.message) || resp.statusText;
+        if (resp.status === 401) {
+            throw new Error(t('loginExpired'));
+        }
+        throw new Error(message);
+    }
+    return json;
+}
+function queryWithoutBody(method) {
+    return (api)=>{
+        const headers = {
+            'User-Agent': userAgent
+        };
+        if (apiToken) {
+            headers['x-api-token'] = apiToken;
+        } else if (session == null ? void 0 : session.token) {
+            headers['X-AccessToken'] = session.token;
+        }
+        return query(api, {
+            method,
+            headers
+        });
+    };
+}
+function queryWithBody(method) {
+    return (api, body)=>{
+        const headers = {
+            'User-Agent': userAgent,
+            'Content-Type': 'application/json'
+        };
+        if (apiToken) {
+            headers['x-api-token'] = apiToken;
+        } else if (session == null ? void 0 : session.token) {
+            headers['X-AccessToken'] = session.token;
+        }
+        return query(api, {
+            method,
+            headers,
+            body: JSON.stringify(body)
+        });
+    };
+}
+export const get = queryWithoutBody('GET');
+export const post = queryWithBody('POST');
+export const put = queryWithBody('PUT');
+export const doDelete = queryWithBody('DELETE');
+export async function uploadFile(fn, key) {
+    const { url, backupUrl, formData, maxSize } = await post('/upload', {
+        ext: path.extname(fn)
+    });
+    let realUrl = url;
+    if (backupUrl) {
+        // @ts-ignore
+        if (global.USE_ACC_OSS) {
+            realUrl = backupUrl;
+        } else {
+            const pingResult = await tcpPing({
+                address: url.replace('https://', ''),
+                attempts: 4,
+                timeout: 1000
+            });
+            // console.log({pingResult});
+            if (Number.isNaN(pingResult.avg) || pingResult.avg > 150) {
+                realUrl = backupUrl;
+            }
+        }
+    // console.log({realUrl});
+    }
+    const fileSize = fs.statSync(fn).size;
+    if (maxSize && fileSize > filesizeParser(maxSize)) {
+        const readableFileSize = `${(fileSize / 1048576).toFixed(1)}m`;
+        throw new Error(t('fileSizeExceeded', {
+            fileSize: readableFileSize,
+            maxSize,
+            pricingPageUrl
+        }));
+    }
+    const bar = new ProgressBar('  Uploading [:bar] :percent :etas', {
+        complete: '=',
+        incomplete: ' ',
+        total: fileSize
+    });
+    const form = new FormData();
+    for (const [k, v] of Object.entries(formData)){
+        form.append(k, v);
+    }
+    const fileStream = fs.createReadStream(fn);
+    fileStream.on('data', (data)=>{
+        bar.tick(data.length);
+    });
+    if (key) {
+        form.append('key', key);
+    }
+    form.append('file', fileStream);
+    // form.append('file', fileStream, {
+    //   contentType: 'application/octet-stream',
+    // });
+    const res = await fetch(realUrl, {
+        method: 'POST',
+        body: form
+    });
+    if (res.status > 299) {
+        throw new Error(`${res.status}: ${res.statusText}`);
+    }
+    // const body = await response.json();
+    return {
+        hash: key || formData.key
+    };
+}
+export const getAllPackages = async (appId)=>{
+    const { data } = await get(`/app/${appId}/package/list?limit=1000`);
+    return data;
+};

package/lib/esm/app..mjs

@@ -0,0 +1,130 @@
+import fs from "fs";
+import Table from "tty-table";
+import { question } from "./utils";
+import { doDelete, get, post } from "./api";
+import { t } from "./utils/i18n";
+const validPlatforms = [
+    'ios',
+    'android',
+    'harmony'
+];
+export async function getPlatform(platform) {
+    return assertPlatform(platform || await question(t('platformQuestion')));
+}
+export function assertPlatform(platform) {
+    if (!validPlatforms.includes(platform)) {
+        throw new Error(t('unsupportedPlatform', {
+            platform
+        }));
+    }
+    return platform;
+}
+export function getSelectedApp(platform) {
+    assertPlatform(platform);
+    if (!fs.existsSync('update.json')) {
+        throw new Error(t('appNotSelected', {
+            platform
+        }));
+    }
+    const updateInfo = JSON.parse(fs.readFileSync('update.json', 'utf8'));
+    if (!updateInfo[platform]) {
+        throw new Error(t('appNotSelected', {
+            platform
+        }));
+    }
+    return updateInfo[platform];
+}
+export async function listApp(platform = '') {
+    const { data } = await get('/app/list');
+    const list = platform ? data.filter((v)=>v.platform === platform) : data;
+    const header = [
+        {
+            value: t('appId')
+        },
+        {
+            value: t('appName')
+        },
+        {
+            value: t('platform')
+        }
+    ];
+    const rows = [];
+    for (const app of list){
+        rows.push([
+            app.id,
+            app.name,
+            app.platform
+        ]);
+    }
+    console.log(Table(header, rows).render());
+    console.log(`\n${t('totalApps', {
+        count: list.length,
+        platform
+    })}`);
+    return list;
+}
+export async function chooseApp(platform) {
+    const list = await listApp(platform);
+    while(true){
+        const id = await question(t('enterAppIdQuestion'));
+        const app = list.find((v)=>v.id === Number(id));
+        if (app) {
+            return app;
+        }
+    }
+}
+export const appCommands = {
+    createApp: async function({ options }) {
+        const name = options.name || await question(t('appNameQuestion'));
+        const { downloadUrl } = options;
+        const platform = await getPlatform(options.platform);
+        const { id } = await post('/app/create', {
+            name,
+            platform,
+            downloadUrl
+        });
+        console.log(t('createAppSuccess', {
+            id
+        }));
+        await this.selectApp({
+            args: [
+                id
+            ],
+            options: {
+                platform
+            }
+        });
+    },
+    deleteApp: async ({ args, options })=>{
+        const { platform } = options;
+        const id = args[0] || chooseApp(platform);
+        if (!id) {
+            console.log(t('cancelled'));
+        }
+        await doDelete(`/app/${id}`);
+        console.log(t('operationSuccess'));
+    },
+    apps: async ({ options })=>{
+        const { platform } = options;
+        listApp(platform);
+    },
+    selectApp: async ({ args, options })=>{
+        const platform = await getPlatform(options.platform);
+        const id = args[0] ? Number.parseInt(args[0]) : (await chooseApp(platform)).id;
+        let updateInfo = {};
+        if (fs.existsSync('update.json')) {
+            try {
+                updateInfo = JSON.parse(fs.readFileSync('update.json', 'utf8'));
+            } catch (e) {
+                console.error(t('failedToParseUpdateJson'));
+                throw e;
+            }
+        }
+        const { appKey } = await get(`/app/${id}`);
+        updateInfo[platform] = {
+            appId: id,
+            appKey
+        };
+        fs.writeFileSync('update.json', JSON.stringify(updateInfo, null, 4), 'utf8');
+    }
+};