android-publisher-cli 0.0.0-stage → 0.2.0-dev

package/build/channels/types.js

@@ -0,0 +1,53 @@
+import { digest } from '../model.js';
+import { ChannelHTTP } from './http.js';
+export class BaseAdapter {
+    batch;
+    target;
+    secrets;
+    store;
+    fetcher;
+    http;
+    constructor(batch, target, secrets, store, fetcher = fetch) {
+        this.batch = batch;
+        this.target = target;
+        this.secrets = secrets;
+        this.store = store;
+        this.fetcher = fetcher;
+        this.http = new ChannelHTTP(target.channel, fetcher, operationId => {
+            const op = store.operationById(operationId);
+            return op?.effect === 'intent' && op.channel === target.channel && op.batch_id === batch.batch_id;
+        });
+    }
+    savedPreflight() {
+        const row = this.store.target(this.batch.batch_id, this.target.channel);
+        if (!row.preflight || !row.preflight_digest)
+            throw new Error('missing saved preflight');
+        const value = JSON.parse(row.preflight);
+        if (value.digest !== row.preflight_digest)
+            throw new Error('preflight digest changed');
+        return value;
+    }
+    material(step) {
+        const op = this.store.latestOperation(this.batch.batch_id, this.target.channel, step);
+        if (!op || op.effect !== 'confirmed_applied')
+            throw new Error(`missing confirmed ${step} receipt`);
+        return this.store.readMaterial(op);
+    }
+    ref(step) {
+        const op = this.store.latestOperation(this.batch.batch_id, this.target.channel, step);
+        if (!op || op.effect !== 'confirmed_applied' || !op.remote_ref)
+            throw new Error(`missing confirmed ${step} receipt`);
+        return op.remote_ref;
+    }
+    preflightRecord(remote) {
+        const value = { channel: this.target.channel, account: this.target.account, app_id: this.target.app_id,
+            package_name: this.batch.package_name, version_code: this.batch.version_code,
+            ...remote, inspected_at: new Date().toISOString() };
+        return { ...value, digest: digest(value) };
+    }
+    observation(review, availability, association, source, remoteRef, context) {
+        return { review, availability, association, source, observed_at: new Date().toISOString(),
+            ...(remoteRef ? { remote_ref: remoteRef } : {}), ...(context ? { context } : {}) };
+    }
+    async reconcile(_operation) { return { effect: 'unknown' }; }
+}

package/build/channels/vivo.js

@@ -0,0 +1,120 @@
+import { digest } from '../model.js';
+import { md5File } from '../private-file.js';
+import { BaseAdapter } from './types.js';
+import { check, decimal, hmacSign, object, required, str, unknown } from './http.js';
+const metadataFields = ['onlineType', 'updateDesc', 'detailDesc', 'icon', 'screenshot', 'mainTitle', 'subTitle',
+    'appClassify', 'subAppClassify', 'remark', 'specialQualifications', 'ecopyright', 'copyrightList',
+    'copyrightAuthLetter', 'safetyreport', 'networkCultureLicense', 'privateSelfCheck', 'compatibleDevice',
+    'customerService', 'video', 'videoCover', 'simpleDesc', 'commitmentLetter', 'icpRecordType',
+    'icpLicenseType', 'icpLicenseNo', 'icpAuthLetter', 'offInternetLetter', 'rateAge', 'status', 'saleStatus'];
+const attachmentFields = new Set(['icon', 'screenshot', 'specialQualifications', 'ecopyright', 'copyrightList',
+    'copyrightAuthLetter', 'safetyreport', 'video', 'videoCover', 'commitmentLetter', 'icpAuthLetter', 'offInternetLetter']);
+export class VivoAdapter extends BaseAdapter {
+    channel = 'vivo';
+    steps = ['upload', 'submit'];
+    async pace() {
+        const pause = this.store.reservePacing(digest(['vivo', this.target.account]), 60_000);
+        if (pause > 0)
+            await new Promise(resolve => setTimeout(resolve, pause));
+    }
+    signed(method, fields) {
+        const secret = this.secrets.access_secret ?? '';
+        const access = this.target.client_id ?? '';
+        required(secret, access);
+        const values = { ...fields, method, access_key: access, timestamp: String(Date.now()),
+            format: 'json', v: '1.0', sign_method: 'HMAC-SHA256', target_app_key: 'developer' };
+        return { ...values, sign: hmacSign(values, secret, ['sign', 'file']) };
+    }
+    validate(response) {
+        check(response, 'code');
+        if (response.subCode !== '0')
+            throw unknown();
+    }
+    async details() {
+        await this.pace();
+        const response = await this.http.form('/router/rest', 'read', this.signed('app.query.details', { packageName: this.batch.package_name }));
+        this.validate(response);
+        const data = object(response.data);
+        const version = decimal(data.versionCode);
+        if (!version || data.packageName !== this.batch.package_name)
+            throw unknown();
+        const metadata = {};
+        for (const key of metadataFields) {
+            const value = data[key];
+            if (typeof value === 'string')
+                metadata[key] = value;
+            else if (typeof value === 'number' || typeof value === 'bigint')
+                metadata[key] = String(value);
+        }
+        return { version, name: str(data.versionName), metadata };
+    }
+    async preflight() {
+        const details = await this.details();
+        if (BigInt(details.version) >= BigInt(this.batch.version_code))
+            throw new Error('vivo target version must exceed the existing version');
+        if (!['1', '2', '3'].includes(details.metadata.compatibleDevice ?? '') ||
+            !(details.metadata.ecopyright || details.metadata.copyrightList))
+            throw new Error('vivo baseline is missing required device or copyright fields');
+        if ([...this.batch.release_notes].length > 200 || [...(details.metadata.detailDesc ?? '')].length < 50 ||
+            [...(details.metadata.detailDesc ?? '')].length > 1000)
+            throw new Error('vivo release metadata does not meet publishing requirements');
+        return this.preflightRecord({ remote_version_code: details.version, metadata: details.metadata });
+    }
+    async execute(step, operationId) {
+        if (step === 'upload') {
+            await this.pace();
+            const file = this.target.artifact;
+            const md5 = md5File(file.path, file.sha256);
+            const fields = this.signed('app.upload.apk.app', { packageName: this.batch.package_name, fileMd5: md5 });
+            const response = await this.http.multipart('/router/rest', fields, { file }, 'write', operationId);
+            this.validate(response);
+            const data = object(response.data);
+            const version = decimal(data.versionCode);
+            const serial = str(data.serialnumber);
+            if (data.packageName !== this.batch.package_name || version !== this.batch.version_code ||
+                data.versionName !== this.batch.version_name || !serial || str(data.fileMd5).toLowerCase() !== md5)
+                throw unknown();
+            const uploaded = { serial, package_name: this.batch.package_name, version_code: version,
+                version_name: this.batch.version_name, md5 };
+            return { ref: serial, material: { value: uploaded, expiresAt: '9999-12-31T00:00:00.000Z' } };
+        }
+        if (step === 'submit') {
+            const uploaded = this.material('upload');
+            if (uploaded.serial !== this.ref('upload') || uploaded.version_code !== this.batch.version_code)
+                throw new Error('vivo upload receipt differs from target');
+            const baseline = this.savedPreflight().metadata;
+            if (!baseline)
+                throw new Error('vivo baseline missing');
+            const fields = {};
+            for (const key of metadataFields)
+                if (!attachmentFields.has(key) && key !== 'status' && key !== 'saleStatus' && baseline[key] !== undefined)
+                    fields[key] = baseline[key];
+            const notes = this.batch.release_notes;
+            if ([...notes].length < 5 || [...notes].length > 200 ||
+                [...(fields.detailDesc ?? '')].length < 50 || [...(fields.detailDesc ?? '')].length > 1000 ||
+                !['1', '2', '3'].includes(fields.compatibleDevice ?? ''))
+                throw new Error('vivo metadata does not meet publishing requirements');
+            fields.updateDesc = notes;
+            fields.packageName = this.batch.package_name;
+            fields.versionCode = this.batch.version_code;
+            fields.apk = uploaded.serial;
+            fields.fileMd5 = uploaded.md5;
+            fields.onlineType = '1';
+            await this.pace();
+            const response = await this.http.form('/router/rest', 'write', this.signed('app.sync.update.app', fields), operationId);
+            this.validate(response);
+            return { ref: `ack-${operationId}` };
+        }
+        throw new Error('unsupported vivo step');
+    }
+    async observe(_remoteRef) {
+        const details = await this.details();
+        if (details.version !== this.batch.version_code)
+            return this.observation('unknown', 'unknown', 'unconfirmed', 'vivo_details', undefined, { observed_version_code: details.version });
+        const code = details.metadata.status;
+        const review = code === '2' ? 'in_review' : code === '3' ? 'approved' : code === '4' ? 'rejected' : 'unknown';
+        const availability = details.metadata.saleStatus === '1' && review === 'approved' ? 'live' :
+            ['0', '2'].includes(details.metadata.saleStatus ?? '') ? 'not_live' : 'unknown';
+        return this.observation(review, availability, 'confirmed', 'vivo_target_version');
+    }
+}

package/build/channels/xiaomi.js

@@ -0,0 +1,99 @@
+import { createHash, createPublicKey, publicEncrypt, constants, X509Certificate } from 'node:crypto';
+import path from 'node:path';
+import { parseStrictJSON } from '../model.js';
+import { hashFile, md5File } from '../private-file.js';
+import { BaseAdapter } from './types.js';
+import { check, decimal, object, required, str, unknown } from './http.js';
+function xiaomiSIG(fields, files, password, keyPEM) {
+    required(password, keyPEM);
+    let key;
+    try {
+        key = keyPEM.includes('BEGIN CERTIFICATE') ? new X509Certificate(keyPEM).publicKey : createPublicKey(keyPEM);
+    }
+    catch {
+        throw new Error('invalid Xiaomi public key');
+    }
+    if (key.asymmetricKeyType !== 'rsa' || (key.asymmetricKeyDetails?.modulusLength ?? 0) < 1024)
+        throw new Error('invalid Xiaomi public key');
+    const sig = Object.entries(fields).map(([name, value]) => ({ name, hash: createHash('md5').update(value).digest('hex') }));
+    for (const [name, file] of Object.entries(files))
+        sig.push({ name, hash: md5File(file.path, file.sha256) });
+    sig.sort((a, b) => a.name.localeCompare(b.name));
+    const plaintext = Buffer.from(JSON.stringify({ sig, password }));
+    const keyBytes = Math.ceil((key.asymmetricKeyDetails?.modulusLength ?? 0) / 8);
+    const chunks = [];
+    for (let pos = 0; pos < plaintext.length; pos += keyBytes - 11)
+        chunks.push(publicEncrypt({ key, padding: constants.RSA_PKCS1_PADDING }, plaintext.subarray(pos, pos + keyBytes - 11)));
+    plaintext.fill(0);
+    return Buffer.concat(chunks).toString('hex');
+}
+function validTestAccounts(source) {
+    const parsed = object(parseStrictJSON(source));
+    const zh = object(parsed.zh_CN);
+    if (!Array.isArray(zh.accounts) || zh.accounts.length > 5 || typeof zh.auditNotes !== 'string' || [...zh.auditNotes].length > 500)
+        throw new Error('Xiaomi test accounts are invalid');
+    for (const item of zh.accounts) {
+        const row = object(item);
+        if (![1, 2].includes(row.t) || typeof row.a !== 'string' || typeof row.p !== 'string' || typeof row.c !== 'string' ||
+            Boolean(row.a) !== Boolean(row.p) || [row.a, row.p, row.c].some(value => [...value].length > 50))
+            throw new Error('Xiaomi test accounts are invalid');
+    }
+}
+export class XiaomiAdapter extends BaseAdapter {
+    channel = 'xiaomi';
+    steps = ['push'];
+    async call(verb, data, files = {}, operationId) {
+        const requestData = JSON.stringify(data);
+        const fields = { RequestData: requestData };
+        const sig = xiaomiSIG(fields, files, this.secrets.api_secret ?? '', this.secrets.public_key_pem ?? '');
+        const response = await this.http.multipart(`/devupload/dev/${verb}`, { ...fields, SIG: sig }, files, verb === 'push' ? 'write' : 'read', operationId);
+        check(response, 'result');
+        return response;
+    }
+    async details() {
+        const response = await this.call('query', { packageName: this.batch.package_name, userName: this.target.client_id });
+        const info = object(response.packageInfo);
+        const version = decimal(info.versionCode);
+        if (!version || info.packageName !== this.batch.package_name || typeof response.updateVersion !== 'boolean')
+            throw unknown();
+        return { version, appName: str(info.appName), updateAllowed: response.updateVersion };
+    }
+    async preflight() {
+        if (!this.target.client_id || !this.target.icon_path || !this.target.icon_sha256 || !this.target.privacy_url)
+            throw new Error('Xiaomi public configuration is incomplete');
+        const details = await this.details();
+        if (!details.updateAllowed || BigInt(details.version) >= BigInt(this.batch.version_code) || !details.appName)
+            throw new Error('Xiaomi existing application or update permission is not verified');
+        const icon = hashFile(this.target.icon_path);
+        if (icon.sha256 !== this.target.icon_sha256 || icon.size !== this.target.icon_size)
+            throw new Error('Xiaomi icon changed');
+        if (this.secrets.test_account_json)
+            validTestAccounts(this.secrets.test_account_json);
+        return this.preflightRecord({ remote_version_code: details.version, metadata: { app_name: details.appName, privacy_url: this.target.privacy_url } });
+    }
+    async waitBeforeStep(step) {
+        if (step === 'push' && this.secrets.test_account_json)
+            validTestAccounts(this.secrets.test_account_json);
+    }
+    async execute(step, operationId) {
+        if (step !== 'push')
+            throw new Error('unsupported Xiaomi step');
+        const preflight = this.savedPreflight();
+        const appName = preflight.metadata?.app_name ?? '';
+        const icon = { path: this.target.icon_path, filename: path.basename(this.target.icon_path),
+            sha256: this.target.icon_sha256, size: this.target.icon_size };
+        required(appName, this.target.privacy_url ?? '', this.batch.release_notes);
+        const info = { packageName: this.batch.package_name, appName, privacyUrl: this.target.privacy_url,
+            updateDesc: this.batch.release_notes, versionName: this.batch.version_name };
+        if (this.secrets.test_account_json) {
+            validTestAccounts(this.secrets.test_account_json);
+            info.testAccount = this.secrets.test_account_json;
+        }
+        await this.call('push', { userName: this.target.client_id, synchroType: 1, appInfo: info }, { apk: this.target.artifact, icon }, operationId);
+        return { ref: `ack-${operationId}` };
+    }
+    async observe(_remoteRef) {
+        const details = await this.details();
+        return this.observation('unknown', 'unknown', 'unconfirmed', 'xiaomi_package_query', undefined, { version_code: details.version, inference: BigInt(details.version) === BigInt(this.batch.version_code) ? 'target_version_returned' : 'version_differs' });
+    }
+}

package/build/cli.js

@@ -0,0 +1,275 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import readline from 'node:readline/promises';
+import { AndroidTools } from './artifact.js';
+import { FileCredentials, PromptCredentials } from './credentials.js';
+import { prepare, preflight, publicError, reconcile, report, review, saveProject, submit, refresh } from './engine.js';
+import { CHANNELS, isChannel, validateBatchInput, validateProject, validAbsolute, validId } from './model.js';
+import { readJSON, writePrivate } from './private-file.js';
+import { Store } from './state.js';
+function flags(args, values, booleans = []) {
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        const name = args[i];
+        if (!name?.startsWith('--') || name === '--')
+            throw new Error(`unexpected argument: ${name ?? ''}`);
+        const key = name.slice(2);
+        if (key in result || !values.includes(key) && !booleans.includes(key))
+            throw new Error(`unsupported or duplicate flag: ${name}`);
+        if (booleans.includes(key))
+            result[key] = true;
+        else {
+            const value = args[++i];
+            if (!value || value.startsWith('--'))
+                throw new Error(`${name} needs a value`);
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function requiredFlag(f, key) {
+    const value = f[key];
+    if (typeof value !== 'string' || !value)
+        throw new Error(`--${key} is required`);
+    return value;
+}
+function channelsFlag(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string')
+        throw new Error('invalid channel selection');
+    const channels = value.split(',').map(item => item.trim());
+    if (!channels.length || new Set(channels).size !== channels.length || channels.some(ch => !isChannel(ch)))
+        throw new Error('unknown or duplicate channel');
+    return channels;
+}
+function credentialSource(f) {
+    const file = f['credentials-file'];
+    if (!file)
+        return new PromptCredentials();
+    if (typeof file !== 'string' || !validAbsolute(file))
+        throw new Error('credentials file must be an absolute path');
+    return new FileCredentials(file);
+}
+function output(value) { process.stdout.write(`${JSON.stringify(value)}\n`); }
+function toolFlags(f) {
+    const sdk = typeof f['sdk-root'] === 'string' ? f['sdk-root'] : undefined;
+    const java = typeof f['java-home'] === 'string' ? f['java-home'] : undefined;
+    return new AndroidTools(sdk, java);
+}
+function help() {
+    process.stdout.write(`Android Publisher CLI (TypeScript + npm)\n\n` +
+        `android-release doctor [--sdk-root DIR] [--java-home DIR]\n` +
+        `android-release inspect --apk /absolute/file.apk\n` +
+        `android-release setup --project ID --apk /absolute/trusted.apk\n` +
+        `android-release setup --file /absolute/project.json --apk /absolute/trusted.apk [--replace]\n` +
+        `android-release prepare --file /absolute/batch.json\n` +
+        `android-release batch preflight --batch ID [--channels LIST] [--credentials-file FILE]\n` +
+        `android-release batch review --batch ID --file /absolute/approval.json [--channels LIST]\n` +
+        `android-release batch submit|resume --batch ID --approval FILE --approve-plan SHA256 [--credentials-file FILE]\n` +
+        `android-release batch status --batch ID [--refresh] [--credentials-file FILE]\n` +
+        `android-release batch reconcile --batch ID [--credentials-file FILE]\n` +
+        `android-release batch report --batch ID --file /absolute/report.md\n` +
+        `android-release history | protocols | version [--json]\n\n` +
+        `Credentials are requested in the terminal by default. A 0600 JSON file is supported for automation.\n`);
+}
+async function setupWizard(projectId, apk, tools) {
+    if (!validId(projectId) || !validAbsolute(apk))
+        throw new Error('project ID or trusted APK path is invalid');
+    const inspected = tools.inspect(apk);
+    const io = readline.createInterface({ input: process.stdin, output: process.stderr });
+    const ask = async (label, fallback = '') => {
+        const typed = (await io.question(`${label}${fallback ? ` [${fallback}]` : ''}：`)).trim();
+        if (typed.toLowerCase() === 'cancel')
+            throw new Error('setup canceled');
+        return typed || fallback;
+    };
+    try {
+        process.stderr.write(`包名：${inspected.package_name}\n签名 SHA-256：${inspected.signer_sha256}\n`);
+        if ((await ask('确认信任这个包名和签名，输入 yes')) !== 'yes')
+            throw new Error('setup canceled');
+        const selection = channelsFlag(await ask('选择渠道，逗号分隔', CHANNELS.join(',')));
+        const rows = [];
+        for (const channel of selection) {
+            process.stderr.write(`${channel}：只输入公开账号和应用标识。凭据在执行命令时另行输入。\n`);
+            const account = await ask(channel === 'oppo' ? 'OPPO client_id（也作为本机账号名）' : '本机账号名', channel === 'oppo' ? '' : `${channel}-main`);
+            const appId = await ask('渠道应用 ID；小米、OPPO、vivo 使用包名', ['xiaomi', 'oppo', 'vivo'].includes(channel) ? inspected.package_name : '');
+            const row = { channel, account, app_id: appId };
+            const clientLabels = { honor: 'Honor client_id', xiaomi: '小米 userName',
+                vivo: 'vivo access_key', tencent: '应用宝用户 uid' };
+            if (clientLabels[channel])
+                row.client_id = await ask(clientLabels[channel]);
+            if (channel === 'huawei' || channel === 'honor') {
+                const language = await ask('中文语言 ID，可留空自动匹配');
+                if (language)
+                    row.language_id = language;
+            }
+            if (channel === 'xiaomi') {
+                row.icon_path = await ask('小米图标绝对路径');
+                row.privacy_url = await ask('小米公开 HTTPS 隐私政策 URL');
+            }
+            rows.push(row);
+        }
+        const project = { schema_version: 2, project_id: projectId, package_name: inspected.package_name,
+            signer_sha256: inspected.signer_sha256, channels: rows };
+        validateProject(project);
+        process.stderr.write(`项目摘要：${JSON.stringify(project)}\n`);
+        if ((await ask('确认保存，输入 yes')) !== 'yes')
+            throw new Error('setup canceled');
+        return project;
+    }
+    finally {
+        io.close();
+    }
+}
+async function run(args) {
+    if (!args.length || args[0] === 'help' || args[0] === '--help' || args[0] === '-h') {
+        help();
+        return 0;
+    }
+    const command = args[0];
+    if (command === 'version' || command === '--version') {
+        const f = flags(args.slice(1), [], ['json']);
+        const packagePath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json');
+        const version = JSON.parse(fs.readFileSync(packagePath, 'utf8')).version;
+        if (f.json)
+            output({ schema_version: 2, version, runtime: process.version, arch: process.arch, platform: process.platform });
+        else
+            process.stdout.write(`${version}\n`);
+        return 0;
+    }
+    if (command === 'doctor') {
+        const f = flags(args.slice(1), ['sdk-root', 'java-home']);
+        const diagnostic = toolFlags(f).diagnostic();
+        output({ schema_version: 2, ...diagnostic });
+        return diagnostic.ready ? 0 : 2;
+    }
+    if (command === 'inspect') {
+        const f = flags(args.slice(1), ['apk', 'sdk-root', 'java-home']);
+        output({ schema_version: 2, ...toolFlags(f).inspect(requiredFlag(f, 'apk')) });
+        return 0;
+    }
+    if (command === 'protocols') {
+        if (args.length !== 1)
+            throw new Error('protocols takes no flags');
+        output({ schema_version: 2, channels: CHANNELS.map(channel => ({ channel,
+                protocol_mock_verified: true, account_verified: false, live_verified: false,
+                note: 'Real account access and lost-response reconciliation require separate evidence.' })) });
+        return 0;
+    }
+    if (command === 'setup') {
+        const f = flags(args.slice(1), ['file', 'project', 'apk', 'sdk-root', 'java-home'], ['replace']);
+        const apk = requiredFlag(f, 'apk');
+        if (Boolean(f.file) === Boolean(f.project))
+            throw new Error('choose --file or --project');
+        const tools = toolFlags(f);
+        let project;
+        if (f.file) {
+            project = validateProject(readJSON(requiredFlag(f, 'file'), 64 * 1024));
+            const trusted = tools.inspect(apk);
+            if (project.package_name !== trusted.package_name || project.signer_sha256 !== trusted.signer_sha256)
+                throw new Error('project file differs from trusted APK');
+        }
+        else
+            project = await setupWizard(requiredFlag(f, 'project'), apk, tools);
+        saveProject(project, undefined, Boolean(f.replace));
+        output({ schema_version: 2, project_id: project.project_id, package_name: project.package_name,
+            signer_sha256: project.signer_sha256, channels: project.channels.map(row => row.channel), saved: true });
+        return 0;
+    }
+    if (command === 'prepare') {
+        const f = flags(args.slice(1), ['file', 'sdk-root', 'java-home']);
+        const input = validateBatchInput(readJSON(requiredFlag(f, 'file'), 64 * 1024));
+        const store = new Store();
+        try {
+            const batch = prepare(input, toolFlags(f), store);
+            output({ ...store.summary(batch.batch_id), effect: 'offline' });
+            return 0;
+        }
+        finally {
+            store.close();
+        }
+    }
+    if (command === 'history') {
+        if (args.length !== 1)
+            throw new Error('history takes no flags');
+        const store = new Store();
+        try {
+            output({ schema_version: 2, batches: store.batchIds().map(id => store.summary(id)) });
+            return 0;
+        }
+        finally {
+            store.close();
+        }
+    }
+    if (command === 'batch') {
+        const action = args[1];
+        if (!action)
+            throw new Error('batch action is required');
+        const values = {
+            preflight: ['batch', 'channels', 'credentials-file'],
+            review: ['batch', 'channels', 'file'],
+            submit: ['batch', 'approval', 'approve-plan', 'credentials-file', 'sdk-root', 'java-home'],
+            resume: ['batch', 'approval', 'approve-plan', 'credentials-file', 'sdk-root', 'java-home'],
+            status: ['batch', 'channels', 'credentials-file'],
+            reconcile: ['batch', 'channels', 'credentials-file'],
+            report: ['batch', 'file'],
+        };
+        if (!values[action])
+            throw new Error('unsupported batch action');
+        const f = flags(args.slice(2), values[action], action === 'status' ? ['refresh'] : []);
+        const batchId = requiredFlag(f, 'batch');
+        const selection = channelsFlag(f.channels);
+        if (action === 'status' && !f.refresh && (selection?.length || f['credentials-file']))
+            throw new Error('cached status does not use channels or credentials');
+        const store = new Store();
+        try {
+            if (action === 'preflight') {
+                const result = await preflight(store, batchId, credentialSource(f), selection);
+                output(result);
+                return Object.keys(result.errors).length ? 3 : 0;
+            }
+            if (action === 'review') {
+                const approval = review(store, batchId, requiredFlag(f, 'file'), selection);
+                output({ schema_version: 2, effect: 'offline', approval });
+                return 0;
+            }
+            if (action === 'submit' || action === 'resume') {
+                if (selection?.length)
+                    throw new Error('channel selection is bound by the approval file');
+                const result = await submit(store, batchId, requiredFlag(f, 'approval'), requiredFlag(f, 'approve-plan'), credentialSource(f), toolFlags(f), action === 'resume');
+                output(result);
+                return Object.keys(result.errors).length ? 3 : 0;
+            }
+            if (action === 'status') {
+                const result = f.refresh ? await refresh(store, batchId, credentialSource(f), selection) : { ...store.summary(batchId), effect: 'cached' };
+                output(result);
+                return 'errors' in result && Object.keys(result.errors).length ? 3 : 0;
+            }
+            if (action === 'reconcile') {
+                const result = await reconcile(store, batchId, credentialSource(f), selection);
+                output(result);
+                return Object.keys(result.errors).length ? 3 : 0;
+            }
+            if (action === 'report') {
+                const file = requiredFlag(f, 'file');
+                if (!validAbsolute(file))
+                    throw new Error('report file path must be absolute');
+                writePrivate(file, report(store, batchId));
+                output({ schema_version: 2, effect: 'read_only', report: file });
+                return 0;
+            }
+            throw new Error('unsupported batch action');
+        }
+        finally {
+            store.close();
+        }
+    }
+    throw new Error('unsupported command; run android-release --help');
+}
+run(process.argv.slice(2)).then(code => { process.exitCode = code; }).catch(error => {
+    output({ schema_version: 2, error: publicError(error), effect: 'not_sent', next_action: 'check_input_or_reconcile' });
+    process.exitCode = 2;
+});

package/build/credentials.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import tty from 'node:tty';
+import { assertObject, parseStrictJSON } from './model.js';
+import { regularFile } from './private-file.js';
+export const credentialFields = {
+    huawei: ['service_account_json'],
+    honor: ['client_secret'],
+    xiaomi: ['api_secret', 'public_key_pem'],
+    oppo: ['client_secret'],
+    vivo: ['access_secret'],
+    tencent: ['api_secret'],
+};
+export class FileCredentials {
+    document;
+    constructor(file) {
+        const input = regularFile(file, 256 * 1024, true).toString('utf8');
+        const parsed = parseStrictJSON(input);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            throw new Error('credentials file must be an object');
+        this.document = parsed;
+    }
+    async forChannel(channel) {
+        const value = this.document[channel];
+        assertObject(value, credentialFields[channel], channel === 'xiaomi' ? ['test_account_json'] : []);
+        for (const field of credentialFields[channel])
+            if (typeof value[field] !== 'string' || !value[field] || Buffer.byteLength(value[field]) > 64 * 1024 || /[\u0000\u007f]/u.test(value[field]))
+                throw new Error(`${channel}: missing credential field ${field}`);
+        if (channel === 'xiaomi' && value.test_account_json !== undefined && (typeof value.test_account_json !== 'string' || Buffer.byteLength(value.test_account_json) > 64 * 1024))
+            throw new Error('Xiaomi test account input is invalid');
+        return value;
+    }
+}
+function askHidden(label) {
+    return new Promise((resolve, reject) => {
+        let fd;
+        try {
+            fd = fs.openSync('/dev/tty', 'r+');
+        }
+        catch {
+            reject(new Error('interactive credentials require a terminal; use --credentials-file for automation'));
+            return;
+        }
+        const input = new tty.ReadStream(fd);
+        if (!input.isTTY || !input.setRawMode) {
+            input.destroy();
+            reject(new Error('terminal input unavailable'));
+            return;
+        }
+        const output = (value) => fs.writeSync(fd, value);
+        const bytes = [];
+        let done = false;
+        const finish = (error) => {
+            if (done)
+                return;
+            done = true;
+            input.setRawMode(false);
+            input.removeAllListeners('data');
+            input.pause();
+            output('\n');
+            input.destroy();
+            if (error)
+                reject(error);
+            else
+                resolve(Buffer.from(bytes).toString('utf8'));
+            bytes.fill(0);
+        };
+        output(`${label}（输入 @/绝对路径 可从私有文件读取）：`);
+        input.setRawMode(true);
+        input.resume();
+        input.on('data', (chunk) => {
+            for (const byte of chunk) {
+                if (byte === 3 || byte === 4) {
+                    finish(new Error('credential input canceled'));
+                    return;
+                }
+                if (byte === 13 || byte === 10) {
+                    finish();
+                    return;
+                }
+                if (byte === 127 || byte === 8) {
+                    bytes.pop();
+                    continue;
+                }
+                if (bytes.length >= 64 * 1024) {
+                    finish(new Error('credential input is too long'));
+                    return;
+                }
+                bytes.push(byte);
+            }
+        });
+        input.on('error', () => finish(new Error('credential input failed')));
+    });
+}
+export class PromptCredentials {
+    cache = new Map();
+    async forChannel(channel) {
+        const cached = this.cache.get(channel);
+        if (cached)
+            return cached;
+        const credentials = {};
+        for (const field of credentialFields[channel]) {
+            const typed = await askHidden(`${channel} ${field}`);
+            const value = typed.startsWith('@/') ? regularFile(typed.slice(1), 64 * 1024, true).toString('utf8').trimEnd() : typed;
+            if (!value || Buffer.byteLength(value) > 64 * 1024 || /[\u0000\u007f]/u.test(value))
+                throw new Error(`${channel}: credential input is invalid`);
+            credentials[field] = value;
+        }
+        if (channel === 'xiaomi') {
+            const typed = await askHidden('xiaomi test_account_json（可留空）');
+            if (typed)
+                credentials.test_account_json = typed.startsWith('@/')
+                    ? regularFile(typed.slice(1), 64 * 1024, true).toString('utf8').trimEnd() : typed;
+        }
+        this.cache.set(channel, credentials);
+        return credentials;
+    }
+    clear() { this.cache.clear(); }
+}