267 lines
16 KiB
TypeScript
267 lines
16 KiB
TypeScript
// The apps on a store account, and whether the account's key works. No storebound.config.ts needed: credentials come
|
|
// from the environment or .storebound/credentials.json of the current folder (the desktop app passes one account's
|
|
// key per call). Read-only.
|
|
// storebound apps list [--store apple|play] [--icons] [--json] every app the key can see (App Store Connect team /
|
|
// every Play developer account that invited the
|
|
// service account)
|
|
// storebound apps check [--store apple|play] [--json] auth OK / permission missing / key revoked, with the fix
|
|
// storebound apps folders [--json] the app folders of this machine (~/.storebound/projects.json,
|
|
// the same list as the desktop app's App folders)
|
|
// storebound apps add [<folder>] | apps remove <folder> add / remove a folder in that list (the folder itself stays)
|
|
// storebound apps add --store apple|play --app-id <id> [--account <profile>] [--name <n>] [--bundle-id <id>]
|
|
// a store app with no project on this machine: the
|
|
// desktop shows it read-only ("no local project");
|
|
// apps remove apple:<id> | <entry id> takes it out
|
|
import type { Args } from './lib/args';
|
|
import { ascKey, playServiceAccount } from './lib/credentials';
|
|
import type { AccountCheck, AppsListResult } from './lib/desktop-protocol';
|
|
import { PLAY_SCOPE, REPORTING_SCOPE, tokenSource } from './lib/google-auth';
|
|
import { errorBody } from './lib/http';
|
|
import { log, printJson, warn } from './lib/log';
|
|
import { appleCheck, type Bytes, dataUrl, type Get, isServiceDisabled, listAppleApps, listPlayApps, localPlayApps, MAX_ICON_BYTES, playCheck } from './lib/store-apps';
|
|
import { textTable } from './lib/table';
|
|
import { ascClient } from './apple/asc';
|
|
import { REPORTING_API } from './play/google';
|
|
import * as rt from './lib/rt';
|
|
import { existsSync, readFileSync } from 'node:fs';
|
|
import { basename, join, resolve } from 'node:path';
|
|
import { CONFIG_NAMES } from './lib/config';
|
|
import { addFolder, addStoreApp, readRegistry, registryFile, removeFolder, removeStoreApp } from './lib/registry';
|
|
|
|
type Store = 'apple' | 'play';
|
|
|
|
function stores(args: Args, root: string): Store[] {
|
|
const s = args.get('store');
|
|
if (s === 'apple' || s === 'play') return [s];
|
|
if (s !== undefined) throw new Error('--store: apple or play');
|
|
// every store whose credentials are set (env, or .storebound/credentials.json in this folder)
|
|
const out: Store[] = [];
|
|
try { ascKey(root); out.push('apple'); } catch { /* not set */ }
|
|
try { playServiceAccount(root); out.push('play'); } catch { /* not set */ }
|
|
if (!out.length) throw new Error('no store credentials: set ASC_KEY_ID + ASC_ISSUER_ID + ASC_P8 and / or PLAY_SERVICE_ACCOUNT (env or .storebound/credentials.json)');
|
|
return out;
|
|
}
|
|
|
|
const bytes: Bytes = async url => {
|
|
const r = await fetch(url);
|
|
if (!r.ok) return null;
|
|
const len = Number(r.headers.get('content-length') ?? 0);
|
|
if (len > MAX_ICON_BYTES) { await r.body?.cancel(); return null; }
|
|
return { type: (r.headers.get('content-type') ?? 'image/png').split(';')[0]!, data: new Uint8Array(await r.arrayBuffer()) };
|
|
};
|
|
|
|
async function appleGet(root: string): Promise<Get> {
|
|
const c = await ascClient(root, '');
|
|
return path => c.asc('GET', path);
|
|
}
|
|
|
|
function googleGet(token: () => Promise<string>, base: string): Get {
|
|
return async path => {
|
|
for (let attempt = 0; ; attempt++) {
|
|
const r = await fetch(path.startsWith('http') ? path : base + path, { headers: { Authorization: 'Bearer ' + (await token()) } });
|
|
const t = await r.text();
|
|
if ((r.status === 429 || r.status >= 500) && attempt < 3) { await rt.sleep(1500 * (attempt + 1)); continue; }
|
|
if (!r.ok) throw new Error(`GET ${path.replace(/^https:\/\/[^/]+/, '')} -> ${r.status} ${errorBody(t, 800)}`);
|
|
return t ? JSON.parse(t) : {};
|
|
}
|
|
};
|
|
}
|
|
|
|
/** Play icon of one package: an edit is opened, the default language's icon listed, and the edit deleted (never committed). */
|
|
function playIcon(root: string): (pkg: string) => Promise<string | null> {
|
|
const token = tokenSource(playServiceAccount(root), PLAY_SCOPE);
|
|
const API = 'https://androidpublisher.googleapis.com/androidpublisher/v3/applications/';
|
|
const call = async (method: string, url: string) => {
|
|
const r = await fetch(url, { method, headers: { Authorization: 'Bearer ' + (await token()) } });
|
|
const t = await r.text();
|
|
if (!r.ok) throw new Error(`${method} -> ${r.status} ${errorBody(t, 300)}`);
|
|
return t ? JSON.parse(t) : {};
|
|
};
|
|
return async pkg => {
|
|
const base = API + encodeURIComponent(pkg);
|
|
const edit = await call('POST', `${base}/edits`);
|
|
try {
|
|
const details = await call('GET', `${base}/edits/${edit.id}/details`);
|
|
const lang = details.defaultLanguage ?? 'en-US';
|
|
const imgs = await call('GET', `${base}/edits/${edit.id}/listings/${encodeURIComponent(lang)}/icon`);
|
|
const url = imgs.images?.[0]?.url;
|
|
if (typeof url !== 'string' || !/^https:\/\/[^/]+\.googleusercontent\.com\//.test(url)) return null;
|
|
const img = await bytes(`${url}=s128`);
|
|
return img && img.data.length <= MAX_ICON_BYTES ? dataUrl(img.type, img.data) : null;
|
|
} finally {
|
|
await call('DELETE', `${base}/edits/${edit.id}`).catch(() => {});
|
|
}
|
|
};
|
|
}
|
|
|
|
const principalOf = (root: string): string | null => { try { return playServiceAccount(root).client_email; } catch { return null; } };
|
|
|
|
export async function listApps(store: Store, root: string, icons: boolean): Promise<AppsListResult> {
|
|
const at = new Date().toISOString();
|
|
if (store === 'apple') {
|
|
const r = await listAppleApps(await appleGet(root), { icons, bytes });
|
|
return { store: 'ios', ...r, at };
|
|
}
|
|
const sa = playServiceAccount(root);
|
|
try {
|
|
const r = await listPlayApps(googleGet(tokenSource(sa, REPORTING_SCOPE), REPORTING_API), icons ? { icon: playIcon(root) } : {});
|
|
return { store: 'android', ...r, at };
|
|
} catch (e) {
|
|
// the Reporting API is off in the service account's Cloud project: a clear finding with the exact link, and the
|
|
// Play apps this machine knows (app folders' configs, store-only entries) instead of failing the whole list
|
|
if (!isServiceDisabled(e)) throw e;
|
|
const c = playCheck(sa.client_email, { error: e });
|
|
const known = knownPlayPackages(root);
|
|
return { store: 'android', apps: localPlayApps(known), at,
|
|
warnings: [`${c.message} Fix: ${c.fix}`, known.length ? `listed ${known.length} Play app(s) from this machine's app folders and store-only entries instead (not read from Google Play)` : 'no Play app folders on this machine to list instead (storebound apps add)'] };
|
|
}
|
|
}
|
|
|
|
/** Play package names this machine knows without the Reporting API: the config of `root`, every app folder of
|
|
* ~/.storebound/projects.json (read as text, never run) and the store-only Play entries. */
|
|
export function knownPlayPackages(root: string): { packageName: string; name: string; source: string }[] {
|
|
const out: { packageName: string; name: string; source: string }[] = [];
|
|
const reg = readRegistry();
|
|
const fromFolder = (dir: string, name: string) => {
|
|
for (const n of CONFIG_NAMES) {
|
|
const f = join(dir, n);
|
|
if (!existsSync(f)) continue;
|
|
try {
|
|
const text = readFileSync(f, 'utf8');
|
|
const pkg = /\bpackageName\s*["']?\s*:\s*["']([A-Za-z][\w]*(?:\.[A-Za-z][\w]*)+)["']/.exec(text)?.[1];
|
|
const appName = /\bapp\s*["']?\s*:\s*\{[^}]*?\bname\s*["']?\s*:\s*["']([^"'\n]+)["']/.exec(text)?.[1];
|
|
if (pkg && !out.some(o => o.packageName === pkg)) out.push({ packageName: pkg, name: appName ?? name, source: dir });
|
|
} catch { /* unreadable: skipped */ }
|
|
return;
|
|
}
|
|
};
|
|
fromFolder(root, '');
|
|
for (const p of reg.projects) fromFolder(p.path, p.name);
|
|
for (const a of reg.storeApps ?? []) if (a.store === 'play' && !out.some(o => o.packageName === a.appId)) out.push({ packageName: a.appId, name: a.name, source: 'store-only entry' });
|
|
return out;
|
|
}
|
|
|
|
export async function checkAccount(store: Store, root: string): Promise<AccountCheck> {
|
|
if (store === 'apple') {
|
|
try {
|
|
// one app is enough to prove the key; the team's app count is meta.paging.total
|
|
const page = await (await appleGet(root))('/v1/apps?fields[apps]=bundleId&limit=1');
|
|
return appleCheck({ apps: Number(page.meta?.paging?.total ?? (page.data ?? []).length) });
|
|
} catch (e) { return appleCheck({ error: e }); }
|
|
}
|
|
let principal: string | null = null;
|
|
try {
|
|
const sa = playServiceAccount(root);
|
|
principal = sa.client_email;
|
|
const page = await googleGet(tokenSource(sa, REPORTING_SCOPE), REPORTING_API)('/apps:search?pageSize=1000');
|
|
return playCheck(principal, { apps: (page.apps ?? []).length });
|
|
} catch (e) { return playCheck(principal, { error: e }); }
|
|
}
|
|
|
|
const tilde = (p: string) => (process.env.HOME && p.startsWith(process.env.HOME) ? '~' + p.slice(process.env.HOME.length) : p);
|
|
|
|
/** apps folders / add / remove: the machine's app folder list (cli/lib/registry.ts). */
|
|
async function folders(sub: string, args: Args): Promise<void> {
|
|
// `apps folders add [<dir>]` / `apps folders remove <dir>`: the same as `apps add` / `apps remove` (this form used
|
|
// to fall through to the list and add nothing, without a word)
|
|
if (sub === 'folders' && (args._[1] === 'add' || args._[1] === 'remove')) { sub = args._[1]; args._.splice(0, 1); }
|
|
if (sub === 'folders' && args._[1]) throw new Error(`storebound apps folders ${args._[1]}: unknown; to add a folder: storebound apps add [<folder>] (or apps folders add [<folder>]), to list: storebound apps folders`);
|
|
if (sub === 'folders') {
|
|
const r = readRegistry();
|
|
if (args.has('json')) { printJson({ file: registryFile(), projects: r.projects.map(p => ({ ...p, missing: !existsSync(p.path) })), storeApps: r.storeApps ?? [] }); return; }
|
|
if (r.storeApps?.length) {
|
|
console.log(textTable(['store app', 'store', 'app id', 'profile', ''], r.storeApps.map(a => [a.name, a.store, a.appId, a.account ?? '(default)', 'no local project'])));
|
|
console.log('');
|
|
}
|
|
if (!r.projects.length) { console.log(`no app folders yet (${tilde(registryFile())}): storebound apps add, in an app folder (or storebound desktop there)`); return; }
|
|
console.log(textTable(['app', 'folder', ''], r.projects.map(p => [p.name, tilde(p.path), existsSync(p.path) ? '' : 'folder not found'])));
|
|
console.log(`
|
|
${tilde(registryFile())}: the same list as the desktop app's App folders`);
|
|
return;
|
|
}
|
|
const store = args.get('store');
|
|
if (sub === 'add' && store !== undefined) {
|
|
if (store !== 'apple' && store !== 'play') throw new Error('--store: apple or play');
|
|
const appId = args.get('app-id');
|
|
if (!appId) throw new Error('storebound apps add --store apple|play --app-id <id> [--account <profile>] [--name <name>]');
|
|
let name = args.get('name'), bundleId = args.get('bundle-id') ?? null;
|
|
// Apple: the name and bundle id from App Store Connect when the profile's key can read them (read-only; offline is fine)
|
|
if (store === 'apple' && (!name || !bundleId) && /^\d{6,12}$/.test(appId)) {
|
|
try {
|
|
const a = (await (await appleGet(process.cwd()))(`/v1/apps/${appId}?fields[apps]=name,bundleId`)).data;
|
|
name ||= a?.attributes?.name; bundleId ||= a?.attributes?.bundleId ?? null;
|
|
} catch { /* no key or no access: the entry keeps what was given */ }
|
|
}
|
|
const r = addStoreApp({ store, appId, account: args.get('account') ?? (process.env.STOREBOUND_PROFILE || null), name, bundleId });
|
|
log('apps', r.added ? `added ${store} app ${r.app.appId} (${r.app.name}) with no local project${r.app.account ? `, profile ${r.app.account}` : ''}: the desktop shows it read-only (status, reviews, analytics)`
|
|
: r.changed ? `updated ${store} app ${r.app.appId}` : `${store} app ${r.app.appId} is already in the list`);
|
|
return;
|
|
}
|
|
if (sub === 'remove' && args._[1] && (/^(apple|play):/.test(args._[1]) || (readRegistry().storeApps ?? []).some(a => a.id === args._[1]))) {
|
|
const removed = removeStoreApp(args._[1]);
|
|
log('apps', removed ? `removed ${removed.store} app ${removed.appId} from the list` : `${args._[1]} is not in the list`);
|
|
return;
|
|
}
|
|
const dir = resolve(args._[1] ?? '.');
|
|
if (sub === 'add') {
|
|
if (!existsSync(dir)) throw new Error(`${dir}: no such folder`);
|
|
const cfg = CONFIG_NAMES.find(n => existsSync(join(dir, n)));
|
|
if (!cfg) throw new Error(`${dir}: not added, no storebound config here (${CONFIG_NAMES.join(', ')}); run storebound init in it, then this again`);
|
|
const r = addFolder(dir);
|
|
log('apps', r.added ? `added ${tilde(r.project.path)} (it shows in the desktop app too)` : `${tilde(r.project.path)} is already in the list`);
|
|
const note = templateNote(join(dir, cfg));
|
|
if (note) warn('apps', note);
|
|
return;
|
|
}
|
|
if (!args._[1]) throw new Error('storebound apps remove <folder>');
|
|
const removed = removeFolder(args._[1]!.match(/^[0-9a-f]{16}$/) ? args._[1]! : dir);
|
|
log('apps', removed ? `removed ${tilde(removed.path)} from the list (the folder and its files stay)` : `${tilde(dir)} is not in the list`);
|
|
}
|
|
|
|
export async function run(args: Args): Promise<void> {
|
|
const sub = args._[0];
|
|
const root = process.cwd();
|
|
const json = args.has('json');
|
|
if (sub === 'folders' || sub === 'add' || sub === 'remove') return folders(sub, args);
|
|
if (sub === 'list') {
|
|
const out: AppsListResult[] = [];
|
|
for (const s of stores(args, root)) {
|
|
try { out.push(await listApps(s, root, args.has('icons'))); } catch (e) {
|
|
// say what is wrong and how to fix it (the same words as `apps check`), not the raw API error
|
|
const c = s === 'apple' ? appleCheck({ error: e }) : playCheck(principalOf(root), { error: e });
|
|
const why = `${c.message}${c.fix ? ` Fix: ${c.fix}` : ''}`;
|
|
if (args.get('store')) throw new Error(why);
|
|
warn('apps', `${s}: ${why}`);
|
|
}
|
|
}
|
|
if (json) { printJson(args.get('store') ? out[0] : out); return; }
|
|
for (const r of out) {
|
|
log('apps', `${r.store === 'ios' ? 'App Store Connect' : 'Google Play'}: ${r.apps.length} apps`);
|
|
console.log(textTable(['name', 'id', 'bundle / package', 'platforms', 'newest'], r.apps.map(a => [a.name, a.id, a.bundleId, a.platforms.join(' '), a.latest ? `${a.latest.version} ${a.latest.state}` : ''])));
|
|
for (const w of r.warnings) warn('apps', w);
|
|
}
|
|
return;
|
|
}
|
|
if (sub === 'check') {
|
|
const out: AccountCheck[] = [];
|
|
for (const s of stores(args, root)) out.push(await checkAccount(s, root));
|
|
if (json) { printJson(args.get('store') ? out[0] : out); return; }
|
|
for (const c of out) {
|
|
log('apps', `${c.store === 'ios' ? 'App Store Connect' : 'Google Play'}: ${c.status} · ${c.message}`);
|
|
if (c.fix) console.log(` fix: ${c.fix}`);
|
|
if (c.docs) console.log(` ${c.docs}`);
|
|
}
|
|
if (out.some(c => c.status !== 'ok')) process.exitCode = 1;
|
|
return;
|
|
}
|
|
console.error('usage: storebound apps list [--store apple|play] [--icons] [--json] | apps check [--store apple|play] [--json] | apps folders [--json] | apps add [<folder>] | apps add --store apple|play --app-id <id> [--account <profile>] | apps remove <folder> | apps remove apple:<id>');
|
|
process.exit(2);
|
|
}
|
|
|
|
/** A note when the config still holds the template's placeholders (the folder is added anyway: it is the owner's). */
|
|
export function templateNote(file: string): string | null {
|
|
let t = '';
|
|
try { t = readFileSync(file, 'utf8'); } catch { return null; }
|
|
const left = [/['"]Example App['"]/.test(t) && "app.name is still the template's 'Example App'", /com\.example\./.test(t) && 'the bundle id / package is still com.example.*'].filter(Boolean);
|
|
return left.length ? `${left.join('; ')}: set your app's values in ${basename(file)} (storebound check lists the rest)` : null;
|
|
}
|