rn-update-cli 1.0.0

package/lib/api.js

@@ -0,0 +1,671 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllPackages = exports.doDelete = exports.put = exports.post = exports.get = exports.closeSession = exports.saveSession = exports.loadSession = exports.replaceSession = exports.setApiToken = exports.getApiToken = exports.getSession = void 0;
+exports.unwrapData = unwrapData;
+exports.servicePath = servicePath;
+exports.redactRequestUrl = redactRequestUrl;
+exports.getMembershipEntitlement = getMembershipEntitlement;
+exports.uploadTimeoutMs = uploadTimeoutMs;
+exports.isTransientUploadError = isTransientUploadError;
+exports.uploadFile = uploadFile;
+exports.getHermesBase = getHermesBase;
+exports.getChannels = getChannels;
+exports.createChannel = createChannel;
+/**
+ * [INPUT]: 依赖运行时 HTTP、独立服务 multipart 协议与 CLI 会话凭据
+ * [OUTPUT]: 对外提供认证请求、当前应用会员权益读取、按字节显示进度的对象上传、应用渠道（含创建）、原生包、不可变热更新包/投放策略与 Hermes base 查询 API
+ * [POS]: CLI 传输边界，统一旧服务兼容路径与独立 Go 服务管理路径，确保 standalone 包体和 Deployment 请求不落回旧 /app 路由
+ */
+const filesize_parser_1 = __importDefault(require("filesize-parser"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const stream_1 = require("stream");
+const package_json_1 = __importDefault(require("../package.json"));
+const constants_1 = require("./utils/constants");
+const http_helper_1 = require("./utils/http-helper");
+const i18n_1 = require("./utils/i18n");
+const runtime_1 = require("./utils/runtime");
+const http_helper_2 = require("./utils/http-helper");
+let session;
+let savedSession;
+let apiToken;
+function credentialPath() {
+    return (0, constants_1.credentialFileForService)(process.env.RNU_SERVICE_URL || process.env.RNU_API_MODE === 'standalone'
+        ? process.env.RNU_SERVICE_URL
+        : undefined);
+}
+/** Unwrap the standalone service's `{ data: ... }` envelope. */
+function unwrapData(response) {
+    if (response && typeof response === 'object' && 'data' in response) {
+        return response.data;
+    }
+    return response;
+}
+/** Prefix management routes only when talking to the independent Go service. */
+function servicePath(route) {
+    if (!route.startsWith('/')) {
+        route = `/${route}`;
+    }
+    if (!(0, http_helper_2.isStandaloneService)())
+        return route;
+    const configured = process.env.RNU_SERVICE_URL?.trim().replace(/\/+$/, '');
+    return configured?.endsWith('/admin/api/v1') ? route : `/admin/api/v1${route}`;
+}
+const userAgent = `rn-update-cli/${package_json_1.default.version}`;
+const getSession = () => session;
+exports.getSession = getSession;
+const getApiToken = () => apiToken;
+exports.getApiToken = getApiToken;
+const setApiToken = (token) => {
+    apiToken = token;
+};
+exports.setApiToken = setApiToken;
+const loadApiTokenFromEnv = () => {
+    const envToken = process.env.PAKTA_API_TOKEN;
+    if (envToken) {
+        apiToken = envToken;
+    }
+};
+const replaceSession = (newSession) => {
+    session = newSession;
+};
+exports.replaceSession = replaceSession;
+const loadSession = async () => {
+    loadApiTokenFromEnv();
+    const file = credentialPath();
+    if (fs_1.default.existsSync(file)) {
+        try {
+            (0, exports.replaceSession)(JSON.parse(fs_1.default.readFileSync(file, 'utf8')));
+            savedSession = session;
+        }
+        catch (e) {
+            console.error(`Failed to parse file ${file}. Try to remove it manually.`);
+            throw e;
+        }
+    }
+};
+exports.loadSession = loadSession;
+const saveSession = () => {
+    // Only save on change.
+    if (session !== savedSession) {
+        const current = session;
+        const data = JSON.stringify(current, null, 4);
+        const file = credentialPath();
+        fs_1.default.writeFileSync(file, data, { encoding: 'utf8', mode: 0o600 });
+        try {
+            // mode above only applies on creation; tighten pre-existing files too
+            fs_1.default.chmodSync(file, 0o600);
+        }
+        catch {
+            // best-effort (e.g. exotic filesystems); the token is still saved
+        }
+        savedSession = current;
+    }
+};
+exports.saveSession = saveSession;
+const closeSession = () => {
+    const file = credentialPath();
+    if (fs_1.default.existsSync(file)) {
+        fs_1.default.unlinkSync(file);
+        savedSession = undefined;
+    }
+    session = undefined;
+};
+exports.closeSession = closeSession;
+/** Remove credentials, query signatures and fragments before logging a URL. */
+function redactRequestUrl(requestUrl) {
+    try {
+        const parsed = new URL(requestUrl);
+        return `${parsed.protocol}//${parsed.host}${parsed.pathname}${parsed.search ? '?<redacted>' : ''}`;
+    }
+    catch {
+        const secretStart = requestUrl.search(/[?#]/);
+        return secretStart < 0
+            ? requestUrl
+            : `${requestUrl.slice(0, secretStart)}?<redacted>`;
+    }
+}
+function createRequestError(error, requestUrl, status) {
+    const message = typeof error === 'string'
+        ? error
+        : error instanceof Error
+            ? error.message
+            : String(error);
+    const cause = error instanceof Error || (typeof error === 'object' && error !== null)
+        ? error
+        : undefined;
+    const requestError = new Error(`${message}\nURL: ${redactRequestUrl(requestUrl)}`, cause === undefined ? undefined : { cause });
+    requestError.status = status;
+    return requestError;
+}
+const PROXY_ERROR_PATTERNS = [
+    'socket disconnected before secure TLS connection',
+    'ECONNRESET',
+    'ECONNREFUSED',
+    'DEPTH_ZERO_SELF_SIGNED_CERT',
+    'UNABLE_TO_VERIFY_LEAF_SIGNATURE',
+    'CERT_HAS_EXPIRED',
+    'self signed certificate',
+    'proxy',
+    'ETIMEDOUT',
+    'EHOSTUNREACH',
+    'ENETUNREACH',
+];
+function isProxyRelatedError(error) {
+    const seen = new Set();
+    const parts = [];
+    let current = error;
+    while (current !== undefined && current !== null && !seen.has(current)) {
+        seen.add(current);
+        if (current instanceof Error) {
+            const code = current.code;
+            parts.push(`${current.name} ${code ?? ''} ${current.message}`);
+        }
+        else {
+            parts.push(String(current));
+        }
+        current =
+            typeof current === 'object'
+                ? current.cause
+                : undefined;
+    }
+    const lower = parts.join('\n').toLowerCase();
+    return PROXY_ERROR_PATTERNS.some((p) => lower.includes(p.toLowerCase()));
+}
+async function query(url, options) {
+    const baseUrl = await (0, http_helper_1.getBaseUrl)();
+    const fullUrl = `${baseUrl}${url}`;
+    let resp;
+    try {
+        resp = await (0, runtime_1.runtimeFetch)(fullUrl, options);
+    }
+    catch (error) {
+        const baseError = createRequestError(error, fullUrl);
+        if (isProxyRelatedError(error)) {
+            throw new Error(`${baseError.message}\n\n${(0, i18n_1.t)('proxyNetworkError')}\n${(0, i18n_1.t)('proxyNetworkErrorTips')}`, { cause: baseError });
+        }
+        throw baseError;
+    }
+    const text = await resp.text();
+    let json;
+    try {
+        json = JSON.parse(text);
+    }
+    catch (_e) {
+        if (resp.status >= 200 && resp.status < 300) {
+            // a proxy/gateway likely replaced the response; surface it instead of
+            // returning undefined and crashing callers on destructuring
+            throw createRequestError(`API returned 200 with non-JSON body (${text.length} bytes)`, fullUrl, resp.status);
+        }
+    }
+    if (resp.status < 200 || resp.status >= 300) {
+        const message = json?.message || json?.error?.message || resp.statusText || `HTTP ${resp.status}`;
+        if (resp.status === 401) {
+            // 迁移后旧 JWT/PAT 会统一返回 401；浏览器之外的 CLI 也要立即清理旧会话文件。
+            if (session?.token) {
+                (0, exports.closeSession)();
+            }
+            throw createRequestError((0, i18n_1.t)('loginExpired'), fullUrl, resp.status);
+        }
+        throw createRequestError(message, fullUrl, resp.status);
+    }
+    return resp.status === 204 ? undefined : json;
+}
+function queryWithoutBody(method) {
+    return (api) => {
+        const headers = {
+            'User-Agent': userAgent,
+        };
+        if (apiToken) {
+            headers['x-api-token'] = apiToken;
+        }
+        else if (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?.token) {
+            headers['X-AccessToken'] = session.token;
+        }
+        return query(api, {
+            method,
+            headers,
+            body: JSON.stringify(body),
+        });
+    };
+}
+exports.get = queryWithoutBody('GET');
+exports.post = queryWithBody('POST');
+exports.put = queryWithBody('PUT');
+exports.doDelete = queryWithBody('DELETE');
+async function getMembershipEntitlement(appId) {
+    return unwrapData(await (0, exports.get)(servicePath(`/membership/entitlement/${encodeURIComponent(appId)}`)));
+}
+// Upload deadline: generous for a slow link (1 s/MB on top of a 30 s base,
+// never below 60 s) but bounded, so a stalled connection cannot hang a CI job
+// forever. The bar keeps ticking while bytes flow; the deadline is absolute.
+const UPLOAD_TIMEOUT_BASE_MS = 30_000;
+const UPLOAD_TIMEOUT_PER_MB_MS = 1_000;
+const UPLOAD_TIMEOUT_MIN_MS = 60_000;
+const UPLOAD_MAX_RETRIES = 1;
+function uploadTimeoutMs(fileSize) {
+    const megabytes = Math.ceil(Math.max(0, fileSize) / 1048576);
+    return Math.max(UPLOAD_TIMEOUT_MIN_MS, UPLOAD_TIMEOUT_BASE_MS + megabytes * UPLOAD_TIMEOUT_PER_MB_MS);
+}
+const TRANSIENT_UPLOAD_ERROR_CODES = ['ECONNRESET', 'ETIMEDOUT', 'EPIPE'];
+/**
+ * A network-level failure worth one more attempt: a reset/timed-out/broken
+ * pipe connection, or our own deadline abort. HTTP responses (4xx/5xx) never
+ * get here — they are surfaced as-is.
+ */
+function isTransientUploadError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const { name, code, type, message } = error;
+    if (name === 'AbortError' || type === 'aborted' || code === 'ABORT_ERR') {
+        return true;
+    }
+    const text = `${code ?? ''} ${message ?? ''}`;
+    return TRANSIENT_UPLOAD_ERROR_CODES.some((c) => text.includes(c));
+}
+class UploadTimeoutError extends Error {
+    code = 'ETIMEDOUT';
+    constructor(timeoutMs) {
+        super(`Upload timed out after ${Math.round(timeoutMs / 1000)}s`);
+        this.name = 'UploadTimeoutError';
+    }
+}
+/**
+ * node-fetch is only needed for the streaming multipart / PUT upload below
+ * (the built-in fetch cannot stream a form-data body). Loading it eagerly
+ * pulled whatwg-url → punycode into every command, which Node ≥ 21 greets
+ * with a DEP0040 deprecation warning on stderr; so it is loaded on first use.
+ */
+function loadNodeFetch() {
+    const mod = require('node-fetch');
+    return (mod.default ?? mod);
+}
+/**
+ * Send the file with a size-scaled deadline and one retry on a transient
+ * network error. `buildRequest` is invoked per attempt with a fresh file
+ * stream (a consumed stream/form cannot be replayed).
+ */
+async function sendUpload(fn, realUrl, fileSize, bar, buildRequest) {
+    const timeoutMs = uploadTimeoutMs(fileSize);
+    const nodeFetch = loadNodeFetch();
+    // HTTP(S)_PROXY / NO_PROXY, like every other request of the CLI
+    const agent = (0, runtime_1.proxyAgentFor)(realUrl);
+    for (let attempt = 0;; attempt++) {
+        const controller = new AbortController();
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs);
+        const fileStream = fs_1.default.createReadStream(fn);
+        trackUploadProgress(fileStream, bar);
+        try {
+            return await nodeFetch(realUrl, {
+                ...buildRequest(fileStream),
+                agent,
+                signal: controller.signal,
+            });
+        }
+        catch (rawError) {
+            fileStream.destroy();
+            const error = timedOut ? new UploadTimeoutError(timeoutMs) : rawError;
+            if (attempt < UPLOAD_MAX_RETRIES && isTransientUploadError(error)) {
+                const reason = error instanceof Error ? error.message : String(error);
+                console.warn(`\nUpload interrupted (${reason}), retrying...`);
+                // restart the bar from zero for the second pass
+                bar.curr = 0;
+                continue;
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}
+/**
+ * 创建与旧 CLI 一致的上传进度条，并把文件流读取量映射为已上传字节。
+ */
+function createUploadProgressBar(fileSize) {
+    const progressModule = require('progress');
+    const ProgressBarImpl = progressModule.default ??
+        progressModule;
+    return new ProgressBarImpl('  Uploading [:bar] :percent :etas', {
+        complete: '=',
+        incomplete: ' ',
+        total: Math.max(fileSize, 1),
+    });
+}
+/**
+ * 监听上传流的数据事件，保持旧服务与 standalone multipart 的进度语义一致。
+ */
+function trackUploadProgress(fileStream, bar) {
+    fileStream.on('data', (data) => {
+        bar.tick(Buffer.byteLength(data));
+    });
+}
+async function uploadFile(fn, key, appId) {
+    if ((0, http_helper_2.isStandaloneService)()) {
+        return uploadMultipartFile(fn, appId);
+    }
+    // appId 用于服务端路由:绑定了自托管节点(rnu-node)的应用,
+    // 上传指令会指向节点或其对象存储
+    const resp = await (0, exports.post)('/upload', {
+        ext: path_1.default.extname(fn),
+        ...(appId ? { appId: Number(appId) } : {}),
+    });
+    const { url, backupUrl, formData, maxSize } = resp;
+    let realUrl = url;
+    if (backupUrl) {
+        if (global.USE_ACC_OSS) {
+            realUrl = backupUrl;
+        }
+        else if (!(0, runtime_1.resolveProxy)(url)) {
+            // a direct TCP probe says nothing about the path through a proxy (and
+            // usually cannot connect at all): the primary url stays in that case
+            const latency = await (0, runtime_1.measureTcpLatency)(url, {
+                attempts: 4,
+                timeout: 1000,
+            });
+            if (!Number.isFinite(latency) || latency > 150) {
+                realUrl = backupUrl;
+            }
+        }
+        // console.log({realUrl});
+    }
+    const fileSize = fs_1.default.statSync(fn).size;
+    if (maxSize && fileSize > (0, filesize_parser_1.default)(maxSize)) {
+        const readableFileSize = `${(fileSize / 1048576).toFixed(1)}m`;
+        throw new Error((0, i18n_1.t)('fileSizeExceeded', {
+            fileSize: readableFileSize,
+            maxSize,
+            pricingPageUrl: constants_1.pricingPageUrl,
+        }));
+    }
+    // progress/form-data are only needed here; keep them off the startup path
+    const bar = createUploadProgressBar(fileSize);
+    const rethrowUploadError = (error) => {
+        const baseError = createRequestError(error, realUrl);
+        if (isProxyRelatedError(error)) {
+            throw new Error(`${baseError.message}\n\n${(0, i18n_1.t)('proxyNetworkError')}\n${(0, i18n_1.t)('proxyNetworkErrorTips')}`, { cause: baseError });
+        }
+        throw baseError;
+    };
+    // 自托管节点的 s3 直传:服务端下发预签名 PUT,字节直达用户的对象存储
+    if (resp.method === 'PUT') {
+        let putRes;
+        try {
+            putRes = await sendUpload(fn, realUrl, fileSize, bar, (fileStream) => ({
+                method: 'PUT',
+                body: fileStream,
+                // 预签名 PUT 不接受 chunked 传输,必须显式声明长度
+                headers: {
+                    'content-length': String(fileSize),
+                    ...(resp.headers || {}),
+                },
+            }));
+        }
+        catch (error) {
+            return rethrowUploadError(error);
+        }
+        if (putRes.status > 299) {
+            throw createRequestError(`${putRes.status}: ${putRes.statusText || 'Upload failed'}`, realUrl);
+        }
+        return { hash: resp.key };
+    }
+    const FormData = require('form-data');
+    let res;
+    try {
+        res = await sendUpload(fn, realUrl, fileSize, bar, (fileStream) => {
+            const form = new FormData();
+            for (const [k, v] of Object.entries(formData)) {
+                form.append(k, v);
+            }
+            if (key) {
+                form.append('key', key);
+            }
+            // With every part's length known node-fetch sends Content-Length instead
+            // of a chunked body: what object stores expect, and the only framing
+            // that survives http-proxy-agent's rewrite of the buffered request head.
+            form.append('file', fileStream, { knownLength: fileSize });
+            return { method: 'POST', body: form };
+        });
+    }
+    catch (error) {
+        return rethrowUploadError(error);
+    }
+    if (res.status > 299) {
+        throw createRequestError(`${res.status}: ${res.statusText || 'Upload failed'}`, realUrl);
+    }
+    // const body = await response.json();
+    return { hash: key || formData.key };
+}
+/**
+ * 通过独立服务的四阶段 multipart API 上传文件。预签名 URL 直接接收文件流，
+ * 进度条按每个分片实际读取的字节数累加；管理 API 只负责元数据与最终 ETag。
+ */
+async function uploadMultipartFile(fn, appId) {
+    if (!appId) {
+        throw new Error('独立服务上传必须提供 appId。');
+    }
+    const fileName = path_1.default.basename(fn);
+    const contentType = fileName.endsWith('.ppk')
+        ? 'application/octet-stream'
+        : fileName.endsWith('.map')
+            ? 'application/json'
+            : 'application/octet-stream';
+    const kind = /\.(apk|ipa|app|aab|hap)$/i.test(fileName) ? 'native' : 'hot';
+    const fileSize = fs_1.default.statSync(fn).size;
+    const created = unwrapData(await (0, exports.post)(servicePath('/uploads/multipart'), {
+        appId: String(appId),
+        fileName,
+        contentType,
+        kind,
+        declaredSize: fileSize,
+    }));
+    const partSize = 8 * 1024 * 1024;
+    const partCount = Math.max(1, Math.ceil(fileSize / partSize));
+    const partNumbers = Array.from({ length: partCount }, (_, index) => index + 1);
+    let presigned;
+    try {
+        presigned = unwrapData(await (0, exports.post)(servicePath('/uploads/multipart/parts'), {
+            key: created.key,
+            uploadId: created.uploadId,
+            partNumbers,
+        }));
+    }
+    catch (error) {
+        // 会话创建成功后，预签名请求也可能在网络层失败；此时立即回收会话。
+        await (0, exports.post)(servicePath('/uploads/multipart/abort'), {
+            key: created.key,
+            uploadId: created.uploadId,
+        }).catch(() => undefined);
+        throw error;
+    }
+    const nodeFetch = loadNodeFetch();
+    const bar = createUploadProgressBar(fileSize);
+    const completed = [];
+    try {
+        for (const part of presigned.parts) {
+            const start = (part.partNumber - 1) * partSize;
+            const length = Math.min(partSize, Math.max(0, fileSize - start));
+            // 预签名 PUT 需要已知 Content-Length；流式读取分片既满足该约束，
+            // 又让进度条随着真实上传数据持续推进，而不是在请求前一次性读入 Buffer。
+            const partStream = length === 0
+                ? stream_1.Readable.from([])
+                : fs_1.default.createReadStream(fn, {
+                    start,
+                    end: start + length - 1,
+                });
+            trackUploadProgress(partStream, bar);
+            let response;
+            try {
+                response = await nodeFetch(part.url, {
+                    method: 'PUT',
+                    body: partStream,
+                    headers: { 'content-length': String(length) },
+                });
+            }
+            catch (error) {
+                partStream.destroy();
+                throw error;
+            }
+            if (!response.ok) {
+                throw new Error(`对象存储上传失败：HTTP ${response.status}`);
+            }
+            const eTag = response.headers.get('etag');
+            if (!eTag) {
+                throw new Error(`对象存储未返回第 ${part.partNumber} 个分片的 ETag。`);
+            }
+            completed.push({ partNumber: part.partNumber, eTag, size: length });
+        }
+    }
+    catch (error) {
+        await (0, exports.post)(servicePath('/uploads/multipart/abort'), {
+            key: created.key,
+            uploadId: created.uploadId,
+        }).catch(() => undefined);
+        throw error;
+    }
+    let result;
+    try {
+        result = unwrapData(await (0, exports.post)(servicePath('/uploads/multipart/complete'), {
+            key: created.key,
+            uploadId: created.uploadId,
+            parts: completed,
+        }));
+    }
+    catch (error) {
+        // 完成请求本身也可能在网络层失败；清理会话和对象，避免留下悬挂 multipart。
+        await (0, exports.post)(servicePath('/uploads/multipart/abort'), {
+            key: created.key,
+            uploadId: created.uploadId,
+        }).catch(() => undefined);
+        throw error;
+    }
+    return { hash: result.key, url: result.url, key: result.key };
+}
+/**
+ * Ask the active service for a Hermes base. The legacy service may resolve an
+ * HBC epoch directly; the standalone service returns its newest native package
+ * and leaves the downloaded bundle's HBC verification to hermes-base.ts.
+ */
+async function getHermesBase(appId, bytecodeVersion) {
+    try {
+        const data = await (0, exports.get)((0, http_helper_2.isStandaloneService)()
+            ? servicePath(`/apps/${encodeURIComponent(appId)}/hermes-base?bytecodeVersion=${bytecodeVersion}`)
+            : `/app/${appId}/hermesBase?bytecodeVersion=${bytecodeVersion}`);
+        const record = data && typeof data === 'object' && 'data' in data ? data.data : data;
+        if (!record || typeof record !== 'object' || !record.url || !record.hash) {
+            return null;
+        }
+        return record;
+    }
+    catch (error) {
+        if (error?.status === 404) {
+            return null;
+        }
+        throw error;
+    }
+}
+const getAllPackages = async (appId) => {
+    if ((0, http_helper_2.isStandaloneService)()) {
+        const packages = [];
+        let pageNumber = 1;
+        let total = Number.POSITIVE_INFINITY;
+        while (packages.length < total) {
+            const response = await (0, exports.get)(servicePath(`/apps/${encodeURIComponent(appId)}/versions?page=${pageNumber}&pageSize=100`));
+            const page = unwrapData(response);
+            const items = page?.items ?? [];
+            total = typeof page?.total === 'number' ? page.total : packages.length + items.length;
+            packages.push(...items.map((item) => ({
+                ...item,
+                name: item.name ?? item.packageVersion ?? '',
+                versionName: item.versionName ?? item.packageVersion,
+                hash: item.hash ?? item.bundleHash,
+            })));
+            if (items.length === 0)
+                break;
+            pageNumber += 1;
+        }
+        return packages;
+    }
+    // the server caps limit at 100, so page through with offset
+    const limit = 100;
+    let offset = 0;
+    let allPackages;
+    while (true) {
+        const { data, count } = await (0, exports.get)(`/app/${appId}/package/list?offset=${offset}&limit=${limit}`);
+        const packages = data;
+        if (allPackages === undefined || allPackages === null) {
+            allPackages = packages;
+        }
+        else if (packages) {
+            allPackages.push(...packages);
+        }
+        if (!packages || packages.length === 0) {
+            break;
+        }
+        offset += packages.length;
+        if (offset >= Number(count || 0)) {
+            break;
+        }
+    }
+    return allPackages;
+};
+exports.getAllPackages = getAllPackages;
+/** Resolve the registered channel code to the UUID required by the Go API. */
+async function getChannels(appId) {
+    if (!(0, http_helper_2.isStandaloneService)()) {
+        return [];
+    }
+    const pageSize = 100;
+    const channels = [];
+    for (let pageNumber = 1;; pageNumber += 1) {
+        const response = await (0, exports.get)(servicePath(`/apps/${encodeURIComponent(appId)}/channels?page=${pageNumber}&pageSize=${pageSize}`));
+        const page = unwrapData(response);
+        const items = page?.items ?? [];
+        channels.push(...items);
+        if (items.length === 0 ||
+            (page?.total !== undefined && channels.length >= page.total) ||
+            items.length < pageSize) {
+            break;
+        }
+    }
+    return channels;
+}
+/** Create one standalone-service channel with an explicit code/name identity. */
+async function createChannel(appId, code, name = code) {
+    if (!(0, http_helper_2.isStandaloneService)()) {
+        throw new Error('渠道管理需要独立服务（请设置 RNU_SERVICE_URL）。');
+    }
+    const response = await (0, exports.post)(servicePath(`/apps/${encodeURIComponent(appId)}/channels`), {
+        code,
+        name,
+        nativePackageUrl: '',
+        paused: false,
+    });
+    return unwrapData(response);
+}