@novacraft-engineering/pulsar-cli 1.4.1 → 1.5.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -25,7 +25,9 @@ pulsar login <apiUrl> # authenticate (API key or browser), saved
25
25
  pulsar apps # list your apps and deployment keys
26
26
 
27
27
  pulsar release <app> <deployment> --platform ios|android --target <ver> \
28
- [--rollout 25] [--mandatory] [--disabled] [--devices id1,id2,...] [--description "fix crash"]
28
+ [--rollout 25] [--mandatory] [--disabled] [--devices id1,id2,...] [--description "fix crash"] \
29
+ [--private-key key.pem] [--bundle-key <file>]
30
+ [--plain-copy-for-old-builds | --plain | --only-older-builds]
29
31
 
30
32
  pulsar promote <app> <from> <to> [--rollout 100]
31
33
  pulsar rollback <app> <deployment>
@@ -35,6 +37,11 @@ pulsar deployment add <app> <name> # create a new deployment (e.g. QA)
35
37
  pulsar history <app> <deployment> # release history
36
38
  pulsar patch <app> <deployment> <label> [--rollout N] [--mandatory] [--disable] [--enable] [--devices id1,id2,...]
37
39
  pulsar migrate --from <serverUrl> --access-key <key> # move apps from RevoPush / code-push-server (see below)
40
+
41
+ pulsar keygen # write pulsar-private.pem + pulsar-public.pem for code signing
42
+ pulsar bundle-key create --app <name> [--out <file>] # create a private-bundles key (see below)
43
+ pulsar bundle-key id [--bundle-key <file>] # print the key ids in PULSAR_BUNDLE_KEY or the file
44
+ pulsar changes --app <name> --deployment <dep> --label <vN> # unlock a private release locally, print what changed
38
45
  ```
39
46
 
40
47
  ### Targeting a release's reach
@@ -53,6 +60,74 @@ then downloads it in the background and swaps it in on next launch.
53
60
 
54
61
  Auth is read from `PULSAR_API_URL` / `PULSAR_TOKEN` env, or `~/.pulsar/config.json` (written by `pulsar login`). Nothing is committed.
55
62
 
63
+ ## Code signing
64
+
65
+ ```bash
66
+ pulsar keygen
67
+ ```
68
+
69
+ Writes `pulsar-private.pem` (mode 0600) and `pulsar-public.pem` in the current folder. Put the
70
+ public key in your app as `CodePushPublicKey` (iOS `Info.plist`, Android `strings.xml`). From then on
71
+ the device rejects any update not signed with the matching private key.
72
+
73
+ - `--private-key <file>` signs the release locally with that key.
74
+ - `PULSAR_SIGNING_KEY` does the same with the key itself in the environment, which suits CI.
75
+ - With neither, the CLI asks Pulsar to sign with the app's stored key. If Pulsar holds no key for
76
+ the app, the release goes out unsigned and the CLI says so.
77
+
78
+ ## Private bundles (encrypted releases)
79
+
80
+ When an app's Private bundles setting is Manual unlock or Auto unlock, `pulsar release` encrypts
81
+ the bundle, diff, manifest and source map before upload, so Pulsar stores and serves only ciphertext.
82
+ It is not protection against reverse engineering: the key ships inside your store build. Full guide:
83
+ [usepulsar.dev/docs/private-bundles](https://usepulsar.dev/docs/private-bundles).
84
+
85
+ ```bash
86
+ pulsar bundle-key create --app MyApp
87
+ ```
88
+
89
+ Generates a key, writes `pulsar-bundle-key-MyApp.txt` (mode 0600, never overwrites an existing
90
+ file; `--out <file>` to choose the path), registers the key id with Pulsar and prints the
91
+ `Info.plist` / `strings.xml` snippets. Back the key up: Pulsar can't recover it, and builds that
92
+ carry only a lost key can't receive OTAs until a store build ships a new one.
93
+
94
+ The key string is `kid:base64key`, comma separated for several keys. The same string goes in
95
+ `PULSAR_BUNDLE_KEY` and in `CodePushBundleKeys` (SDK 1.8 or later):
96
+
97
+ ```xml
98
+ <!-- iOS Info.plist -->
99
+ <key>CodePushBundleKeys</key><string>KID:BASE64KEY</string>
100
+
101
+ <!-- Android res/values/strings.xml -->
102
+ <string moduleConfig="true" name="CodePushBundleKeys">KID:BASE64KEY</string>
103
+ ```
104
+
105
+ Releasing a private app needs the bundle key and a local signing key:
106
+
107
+ ```bash
108
+ export PULSAR_BUNDLE_KEY="$(cat pulsar-bundle-key-MyApp.txt)"
109
+ export PULSAR_SIGNING_KEY="$(cat pulsar-private.pem)"
110
+ pulsar release MyApp Production --platform ios --target 1.4.0
111
+ ```
112
+
113
+ - `--bundle-key <file>` reads the key string from a file instead of `PULSAR_BUNDLE_KEY`.
114
+ - `--plain-copy-for-old-builds` also uploads the signed, unencrypted zip of the same release, so
115
+ builds that can't open the encrypted copy still get the fix. Pulsar can read that copy.
116
+ - `--plain` releases unencrypted on purpose while private bundles are on: every build gets it, and
117
+ Pulsar can read it.
118
+ - `--only-older-builds` releases unencrypted only to builds that can't open private releases; builds
119
+ holding the key keep their encrypted release.
120
+ - `pulsar history` tags releases `[private]`, `[private + plain copy]` and `[plain, older builds only]`.
121
+ - Each encrypted release prints its reach (devices that will get it, devices that stay on their
122
+ current bundle). A mandatory encrypted release with no reach and no plain copy is blocked.
123
+ - The CLI warns when a key registered for the app is missing from the keys you gave it, and wraps
124
+ each release for every key it is given, which is how you rotate.
125
+ - Older builds are never sent a release they can't open; they stay on their current bundle.
126
+
127
+ `pulsar changes --app MyApp --deployment Production --label v12` downloads that release's encrypted
128
+ manifests and source maps, unlocks them on your machine and prints what changed. The key never
129
+ leaves your machine.
130
+
56
131
  ## Migrating from RevoPush / code-push-server
57
132
 
58
133
  `pulsar migrate` copies apps from any server that speaks the CodePush management API
@@ -99,6 +174,8 @@ Both env vars are all a GitHub Actions / GitLab CI job needs:
99
174
  PULSAR_TOKEN: ${{ secrets.PULSAR_TOKEN }}
100
175
  ```
101
176
 
177
+ Add `PULSAR_SIGNING_KEY` to sign locally, and `PULSAR_BUNDLE_KEY` for apps with private bundles on.
178
+
102
179
  Or connect the repo in the dashboard and fire a release for any commit without leaving the browser.
103
180
 
104
181
  ## Related
package/envelope.js ADDED
@@ -0,0 +1,215 @@
1
+ const MAGIC = [0x50, 0x4c, 0x53, 0x42];
2
+ const VERSION = 1;
3
+ const PREFIX_LENGTH = 9;
4
+ const MAX_HEADER = 16384;
5
+ export const SEGMENT_SIZE = 65536;
6
+ const TAG_LENGTH = 16;
7
+ export const ALGORITHM = 'A256GCM-SEG64K';
8
+ export const KINDS = ['full', 'diff', 'manifest', 'sourcemap'];
9
+ export const SEALED_CONTENT_TYPE = 'application/vnd.pulsar.sealed';
10
+
11
+ const KID_PATTERN = /^[0-9a-f]{16}$/;
12
+ const HASH_PATTERN = /^[0-9a-f]{64}$/;
13
+ const encoder = new TextEncoder();
14
+ const decoder = new TextDecoder();
15
+ const subtle = () => globalThis.crypto.subtle;
16
+
17
+ export function toBase64(bytes) {
18
+ let binary = '';
19
+ const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
20
+ for (let offset = 0; offset < view.length; offset += 0x8000) {
21
+ binary += String.fromCharCode(...view.subarray(offset, offset + 0x8000));
22
+ }
23
+ return btoa(binary);
24
+ }
25
+
26
+ export function fromBase64(text) {
27
+ const binary = atob(String(text));
28
+ const bytes = new Uint8Array(binary.length);
29
+ for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
30
+ return bytes;
31
+ }
32
+
33
+ const toHex = (bytes) => [...bytes].map((byte) => byte.toString(16).padStart(2, '0')).join('');
34
+
35
+ export async function kidOf(rawKey) {
36
+ const digest = new Uint8Array(await subtle().digest('SHA-256', rawKey));
37
+ return toHex(digest.subarray(0, 8));
38
+ }
39
+
40
+ export async function generateKeyString() {
41
+ const raw = globalThis.crypto.getRandomValues(new Uint8Array(32));
42
+ return `${await kidOf(raw)}:${toBase64(raw)}`;
43
+ }
44
+
45
+ export async function parseKeys(keyString) {
46
+ const entries = String(keyString || '')
47
+ .split(/[\s,]+/)
48
+ .map((entry) => entry.trim())
49
+ .filter(Boolean);
50
+ if (!entries.length) throw new Error('No bundle key given');
51
+ const keys = [];
52
+ for (const entry of entries) {
53
+ const [kid, encoded, extra] = entry.split(':');
54
+ if (extra !== undefined || !KID_PATTERN.test(kid || '') || !encoded) throw new Error('A bundle key must look like <kid>:<base64 key>');
55
+ let raw;
56
+ try {
57
+ raw = fromBase64(encoded);
58
+ } catch {
59
+ throw new Error(`Bundle key ${kid} is not valid base64`);
60
+ }
61
+ if (raw.length !== 32) throw new Error(`Bundle key ${kid} must be 32 bytes`);
62
+ if ((await kidOf(raw)) !== kid) throw new Error(`Bundle key ${kid} does not match its key id`);
63
+ keys.push({kid, key: raw});
64
+ }
65
+ return keys;
66
+ }
67
+
68
+ async function aesKey(material, usages) {
69
+ if (material instanceof Uint8Array || material instanceof ArrayBuffer) {
70
+ return subtle().importKey('raw', material, 'AES-GCM', false, usages);
71
+ }
72
+ return material;
73
+ }
74
+
75
+ export function isSealed(bytes) {
76
+ const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
77
+ return view.length >= 4 && MAGIC.every((value, index) => view[index] === value);
78
+ }
79
+
80
+ function validateHeader(header) {
81
+ if (!header || typeof header !== 'object' || Array.isArray(header)) throw new Error('Envelope header is not an object');
82
+ if (header.alg !== ALGORITHM) throw new Error('Unsupported envelope algorithm');
83
+ if (!KINDS.includes(header.kind)) throw new Error('Unknown envelope kind');
84
+ if (typeof header.appId !== 'string' || !header.appId || header.appId.length > 128) throw new Error('Envelope header has no app id');
85
+ if (!HASH_PATTERN.test(header.packageHash || '')) throw new Error('Envelope header has no package hash');
86
+ if (header.kind === 'diff' && !HASH_PATTERN.test(header.baseHash || '')) throw new Error('Diff envelope has no base hash');
87
+ if (fromBase64(header.nonce || '').length !== 7) throw new Error('Envelope nonce must be 7 bytes');
88
+ if (!Array.isArray(header.keys) || !header.keys.length || header.keys.length > 16) throw new Error('Envelope must wrap 1 to 16 keys');
89
+ for (const entry of header.keys) {
90
+ if (!KID_PATTERN.test(entry?.kid || '')) throw new Error('Envelope key id is malformed');
91
+ if (fromBase64(entry.iv || '').length !== 12 || fromBase64(entry.wrapped || '').length !== 48) throw new Error('Envelope key entry is malformed');
92
+ }
93
+ }
94
+
95
+ export function parseEnvelope(bytes) {
96
+ const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
97
+ if (!isSealed(view)) throw new Error('Not a sealed Pulsar file');
98
+ if (view.length < PREFIX_LENGTH || view[4] !== VERSION) throw new Error('Unsupported envelope version');
99
+ const headerLength = new DataView(view.buffer, view.byteOffset, view.byteLength).getUint32(5);
100
+ if (headerLength < 1 || headerLength > MAX_HEADER || PREFIX_LENGTH + headerLength > view.length) throw new Error('Envelope header length is out of range');
101
+ const headerBytes = view.subarray(PREFIX_LENGTH, PREFIX_LENGTH + headerLength);
102
+ let header;
103
+ try {
104
+ header = JSON.parse(decoder.decode(headerBytes));
105
+ } catch {
106
+ throw new Error('Envelope header is not JSON');
107
+ }
108
+ validateHeader(header);
109
+ return {header, headerBytes, payloadOffset: PREFIX_LENGTH + headerLength};
110
+ }
111
+
112
+ const wrapContext = (kid, header) => encoder.encode(`pulsar-dek|v1|${kid}|${header.appId}|${header.packageHash}|${header.kind}`);
113
+
114
+ function segmentNonce(prefix, index, last) {
115
+ const nonce = new Uint8Array(12);
116
+ nonce.set(prefix, 0);
117
+ new DataView(nonce.buffer).setUint32(7, index);
118
+ nonce[11] = last ? 1 : 0;
119
+ return nonce;
120
+ }
121
+
122
+ export async function seal({plaintext, keys, appId, packageHash, kind, baseHash}, {random = (length) => globalThis.crypto.getRandomValues(new Uint8Array(length))} = {}) {
123
+ const body = plaintext instanceof Uint8Array ? plaintext : new Uint8Array(plaintext);
124
+ if (!keys?.length) throw new Error('No bundle key given');
125
+ const dataKeyRaw = random(32);
126
+ const header = {
127
+ alg: ALGORITHM,
128
+ nonce: toBase64(random(7)),
129
+ appId,
130
+ packageHash,
131
+ kind,
132
+ ...(kind === 'diff' ? {baseHash} : {}),
133
+ keys: [],
134
+ };
135
+ for (const {kid, key} of keys) {
136
+ const iv = random(12);
137
+ const wrapped = await subtle().encrypt({name: 'AES-GCM', iv, additionalData: wrapContext(kid, header)}, await aesKey(key, ['encrypt']), dataKeyRaw);
138
+ header.keys.push({kid, iv: toBase64(iv), wrapped: toBase64(new Uint8Array(wrapped))});
139
+ }
140
+ validateHeader(header);
141
+ const headerBytes = encoder.encode(JSON.stringify(header));
142
+ if (headerBytes.length > MAX_HEADER) throw new Error('Envelope header is too large');
143
+ const aad = new Uint8Array(await subtle().digest('SHA-256', headerBytes));
144
+ const dataKey = await subtle().importKey('raw', dataKeyRaw, 'AES-GCM', false, ['encrypt']);
145
+ const prefix = fromBase64(header.nonce);
146
+ const segmentCount = Math.max(1, Math.ceil(body.length / SEGMENT_SIZE));
147
+ const parts = [];
148
+ for (let index = 0; index < segmentCount; index++) {
149
+ const chunk = body.subarray(index * SEGMENT_SIZE, (index + 1) * SEGMENT_SIZE);
150
+ const iv = segmentNonce(prefix, index, index === segmentCount - 1);
151
+ parts.push(new Uint8Array(await subtle().encrypt({name: 'AES-GCM', iv, additionalData: aad}, dataKey, chunk)));
152
+ }
153
+ const total = PREFIX_LENGTH + headerBytes.length + parts.reduce((sum, part) => sum + part.length, 0);
154
+ const output = new Uint8Array(total);
155
+ output.set(MAGIC, 0);
156
+ output[4] = VERSION;
157
+ new DataView(output.buffer).setUint32(5, headerBytes.length);
158
+ output.set(headerBytes, PREFIX_LENGTH);
159
+ let offset = PREFIX_LENGTH + headerBytes.length;
160
+ for (const part of parts) {
161
+ output.set(part, offset);
162
+ offset += part.length;
163
+ }
164
+ return output;
165
+ }
166
+
167
+ export async function unwrapDataKey(header, keys) {
168
+ for (const entry of header.keys) {
169
+ const match = keys.find((candidate) => candidate.kid === entry.kid);
170
+ if (!match) continue;
171
+ try {
172
+ const raw = await subtle().decrypt(
173
+ {name: 'AES-GCM', iv: fromBase64(entry.iv), additionalData: wrapContext(entry.kid, header)},
174
+ await aesKey(match.key, ['decrypt']),
175
+ fromBase64(entry.wrapped),
176
+ );
177
+ return subtle().importKey('raw', raw, 'AES-GCM', false, ['decrypt']);
178
+ } catch {
179
+ throw new Error(`Bundle key ${entry.kid} could not unlock this file`);
180
+ }
181
+ }
182
+ throw new Error(`None of your bundle keys can open this file (it needs ${header.keys.map((entry) => entry.kid).join(' or ')})`);
183
+ }
184
+
185
+ export async function open(bytes, keys, expected = {}) {
186
+ const view = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
187
+ const {header, headerBytes, payloadOffset} = parseEnvelope(view);
188
+ for (const field of ['appId', 'packageHash', 'kind', 'baseHash']) {
189
+ if (expected[field] !== undefined && header[field] !== expected[field]) throw new Error(`Envelope ${field} does not match`);
190
+ }
191
+ const dataKey = await unwrapDataKey(header, keys);
192
+ const aad = new Uint8Array(await subtle().digest('SHA-256', headerBytes));
193
+ const prefix = fromBase64(header.nonce);
194
+ const payload = view.subarray(payloadOffset);
195
+ const stride = SEGMENT_SIZE + TAG_LENGTH;
196
+ const segmentCount = Math.max(1, Math.ceil(payload.length / stride));
197
+ if (payload.length < TAG_LENGTH || (payload.length % stride !== 0 && payload.length % stride < TAG_LENGTH)) throw new Error('Envelope payload is truncated');
198
+ const parts = [];
199
+ for (let index = 0; index < segmentCount; index++) {
200
+ const segment = payload.subarray(index * stride, (index + 1) * stride);
201
+ const iv = segmentNonce(prefix, index, index === segmentCount - 1);
202
+ try {
203
+ parts.push(new Uint8Array(await subtle().decrypt({name: 'AES-GCM', iv, additionalData: aad}, dataKey, segment)));
204
+ } catch {
205
+ throw new Error('Envelope failed authentication: the file was altered, truncated or is for another release');
206
+ }
207
+ }
208
+ const output = new Uint8Array(parts.reduce((sum, part) => sum + part.length, 0));
209
+ let offset = 0;
210
+ for (const part of parts) {
211
+ output.set(part, offset);
212
+ offset += part.length;
213
+ }
214
+ return {header, plaintext: output};
215
+ }
package/migrate.js CHANGED
@@ -115,7 +115,9 @@ async function migrateApp({source, sourceApp, org, pulsarApps, args, dryRun, row
115
115
  }
116
116
  row.sourceKey = sourceDeployment.key || '-';
117
117
 
118
- row.pulsarKey = pulsarApp?.deployments?.[deploymentName]?.key;
118
+ const existingDeployment = pulsarApp?.deployments?.[deploymentName];
119
+ if (existingDeployment && !existingDeployment.key) throw new Error('Deployment keys are hidden for this login. Run "pulsar login" again, then retry.');
120
+ row.pulsarKey = existingDeployment?.key;
119
121
  if (!row.pulsarKey && dryRun) row.pulsarKey = '(new)';
120
122
  else if (!row.pulsarKey) {
121
123
  ({key: row.pulsarKey} = await api(`/apps/${pulsarApp.id}/deployments`, {method: 'POST', body: {name: deploymentName}}));
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@novacraft-engineering/pulsar-cli",
3
- "version": "1.4.1",
3
+ "version": "1.5.1",
4
4
  "description": "Pulsar OTA release CLI — bundle, hash, and ship React Native updates over-the-air.",
5
5
  "type": "module",
6
6
  "bin": {
@@ -10,6 +10,9 @@
10
10
  "pulsar.js",
11
11
  "hash.js",
12
12
  "migrate.js",
13
+ "private.js",
14
+ "envelope.js",
15
+ "releaseCompare.js",
13
16
  "README.md",
14
17
  "LICENSE"
15
18
  ],
@@ -27,7 +30,7 @@
27
30
  "node": ">=18"
28
31
  },
29
32
  "scripts": {
30
- "test": "node test/hash.test.js && node test/security.test.js && node test/signing.test.js && node test/entry.test.js && node test/migrate.test.js"
33
+ "test": "node test/hash.test.js && node test/security.test.js && node test/signing.test.js && node test/entry.test.js && node test/migrate.test.js && node test/envelope.test.js && node test/private.test.js"
31
34
  },
32
35
  "keywords": [
33
36
  "cli",
package/private.js ADDED
@@ -0,0 +1,161 @@
1
+ import fs from 'node:fs';
2
+ import path from 'node:path';
3
+ import {api, die, getFlag, loadConfig, resolveApp} from './pulsar.js';
4
+ import {seal, open, parseKeys, generateKeyString, SEALED_CONTENT_TYPE} from './envelope.js';
5
+ import {compareManifests, compareModules, manifestParts} from './releaseCompare.js';
6
+
7
+ export async function loadBundleKeys(args) {
8
+ const keyFile = getFlag(args, 'bundle-key');
9
+ if (keyFile && !fs.existsSync(keyFile)) die(`no bundle key file at ${keyFile}`);
10
+ const keyString = keyFile ? fs.readFileSync(keyFile, 'utf8') : (process.env.PULSAR_BUNDLE_KEY || '').trim();
11
+ if (!keyString) return [];
12
+ try {
13
+ return await parseKeys(keyString);
14
+ } catch (err) {
15
+ die(`bundle key: ${err.message}`);
16
+ }
17
+ }
18
+
19
+ export async function privateContext(app, args, localKey) {
20
+ let settings;
21
+ try {
22
+ settings = await api(`/apps/${app.id}/private-bundles`, {optional: true});
23
+ } catch {
24
+ return null;
25
+ }
26
+ if (!settings || settings.mode === 'off') return null;
27
+ if (!localKey) die(`${app.name} uses private bundles, which need local signing: pass --private-key <file> or set PULSAR_SIGNING_KEY. Nothing was uploaded.`);
28
+ const plain = args.includes('--only-older-builds') ? 'older' : args.includes('--plain') ? 'all' : null;
29
+ if (plain && args.includes('--plain-copy-for-old-builds')) die('--plain-copy-for-old-builds goes with an encrypted release; drop it when releasing plain. Nothing was uploaded.');
30
+ const given = await loadBundleKeys(args);
31
+ const registered = new Set(settings.keys.map((entry) => entry.kid));
32
+ const keys = given.filter((key) => registered.has(key.kid));
33
+ if (plain) return {keys, readiness: settings.readiness, plain};
34
+ if (!given.length) die(`${app.name} uses private bundles: pass --bundle-key <file> or set PULSAR_BUNDLE_KEY, or release plain on purpose with --plain or --only-older-builds. Nothing was uploaded.`);
35
+ if (!keys.length) die(`none of your bundle keys (${given.map((key) => key.kid).join(', ')}) are registered for ${app.name}. Registered: ${[...registered].join(', ') || 'none'}`);
36
+ const missing = [...registered].filter((kid) => !keys.some((key) => key.kid === kid));
37
+ if (missing.length) console.log(`⚠ registered key ${missing.join(', ')} wasn't given, so builds holding only that key won't get this release`);
38
+ return {keys, readiness: settings.readiness, plain: null};
39
+ }
40
+
41
+ export function reportReach(context, {mandatory, plainCopy}) {
42
+ const {total = 0, ready = 0, windowDays = 30} = context.readiness || {};
43
+ const left = total - ready;
44
+ if (context.plain === 'all') {
45
+ console.log(`• plain release on purpose: reaches all ${total} devices seen in the last ${windowDays} days, and Pulsar can read it`);
46
+ return;
47
+ }
48
+ if (context.plain === 'older') {
49
+ console.log(`• plain release for older builds only: reaches the ${left} of ${total} devices that can't open private releases; Pulsar can read it. The ${ready} that can keep their encrypted release`);
50
+ if (mandatory && left === 0) die('every recent device can open private releases, so an older-builds-only release would reach nobody. Nothing was uploaded.');
51
+ return;
52
+ }
53
+ if (plainCopy) {
54
+ console.log(`• private release: ${ready} of ${total} devices seen in the last ${windowDays} days get the encrypted copy; ${left} get the plain copy for older builds, which Pulsar can read`);
55
+ return;
56
+ }
57
+ console.log(`• private release: reaches ${ready} of ${total} devices seen in the last ${windowDays} days; ${left} stay on their current bundle`);
58
+ if (mandatory && ready === 0) {
59
+ die('no device can open private releases yet, so a mandatory one would reach nobody. Ship store builds with SDK 1.8 and the bundle key, or add --plain-copy-for-old-builds. Nothing was uploaded.');
60
+ }
61
+ }
62
+
63
+ export const sealArtifact = (context, app, packageHash, plaintext, kind, extra = {}) =>
64
+ seal({plaintext: new Uint8Array(plaintext), keys: context.keys, appId: app.id, packageHash, kind, ...extra});
65
+
66
+ export async function openArtifact(keys, bytes, expected) {
67
+ return Buffer.from((await open(new Uint8Array(bytes), keys, expected)).plaintext);
68
+ }
69
+
70
+ export const sealedHeaders = {'content-type': SEALED_CONTENT_TYPE};
71
+
72
+ async function cmdBundleKeyCreate(args) {
73
+ const appName = getFlag(args, 'app');
74
+ if (!appName) die('Usage: pulsar bundle-key create --app <name> [--out <file>] [--platform ios|android]');
75
+ const app = await resolveApp(appName, getFlag(args, 'platform'));
76
+ const outFile = getFlag(args, 'out', `pulsar-bundle-key-${app.name.replace(/[^A-Za-z0-9._-]+/g, '-')}.txt`);
77
+ if (fs.existsSync(outFile)) die(`${outFile} already exists. Pick another --out; never overwrite a bundle key.`);
78
+ const keyString = await generateKeyString();
79
+ const [{kid}] = await parseKeys(keyString);
80
+ fs.writeFileSync(outFile, `${keyString}\n`, {mode: 0o600, flag: 'wx'});
81
+ console.log(`✓ wrote bundle key ${kid} to ${path.resolve(outFile)} (owner-only)`);
82
+ try {
83
+ await api(`/apps/${app.id}/private-bundles`, {method: 'PUT', body: {addKids: [kid]}, optional: true});
84
+ console.log(`✓ registered key id ${kid} with ${app.name}`);
85
+ } catch (err) {
86
+ console.log(`⚠ couldn't register the key id (${err.message}). An admin can add ${kid} under Private bundles in the dashboard.`);
87
+ }
88
+ console.log('\nBack this file up now (password manager or secrets vault). If it is lost, builds that carry only this key can\'t receive updates until a new store build ships.');
89
+ console.log('\nCI: set PULSAR_BUNDLE_KEY to the file\'s contents.');
90
+ console.log('\niOS Info.plist:');
91
+ console.log(` <key>CodePushBundleKeys</key>\n <string>${keyString}</string>`);
92
+ console.log('\nAndroid res/values/strings.xml:');
93
+ console.log(` <string moduleConfig="true" name="CodePushBundleKeys">${keyString}</string>`);
94
+ }
95
+
96
+ async function cmdBundleKeyId(args) {
97
+ const keys = await loadBundleKeys(args);
98
+ if (!keys.length) die('pass --bundle-key <file> or set PULSAR_BUNDLE_KEY');
99
+ for (const key of keys) console.log(key.kid);
100
+ }
101
+
102
+ export async function cmdBundleKey(args) {
103
+ const [sub, ...rest] = args;
104
+ if (sub === 'create') return cmdBundleKeyCreate(rest);
105
+ if (sub === 'id') return cmdBundleKeyId(rest);
106
+ die('Usage: pulsar bundle-key <create|id> [--app <name>] [--bundle-key <file>]');
107
+ }
108
+
109
+ async function fetchSealed(app, deployment, label, kind) {
110
+ const {apiUrl, token} = loadConfig();
111
+ const response = await fetch(`${apiUrl.replace(/\/$/, '')}/apps/${app.id}/deployments/${deployment}/releases/${label}/sealed/${kind}`, {headers: {authorization: `Bearer ${token}`}});
112
+ if (!response.ok) return null;
113
+ return new Uint8Array(await response.arrayBuffer());
114
+ }
115
+
116
+ export async function cmdChanges(args) {
117
+ const appName = getFlag(args, 'app');
118
+ const deployment = getFlag(args, 'deployment', 'Staging');
119
+ const label = getFlag(args, 'label');
120
+ if (!appName || !label) die('Usage: pulsar changes --app <name> --deployment <Staging|Production> --label <vN> [--base <vM>] [--bundle-key <file>]');
121
+ const app = await resolveApp(appName, getFlag(args, 'platform'));
122
+ const base = getFlag(args, 'base');
123
+ const summary = await api(`/apps/${app.id}/deployments/${deployment}/releases/${label}/changes${base ? `?base=${encodeURIComponent(base)}` : ''}`);
124
+ if (!summary.base) return console.log(`${label} has nothing earlier to compare with.`);
125
+ let files = summary.files;
126
+ let modules = summary.modules;
127
+ if (summary.sealed) {
128
+ const keys = await loadBundleKeys(args);
129
+ if (!keys.length) die('this release is private: pass --bundle-key <file> or set PULSAR_BUNDLE_KEY to unlock it here');
130
+ const releases = await api(`/apps/${app.id}/deployments/${deployment}/releases`);
131
+ const hashOf = (wanted) => releases.find((entry) => entry.label === wanted)?.packageHash;
132
+ const unlock = async (wanted, kind) => {
133
+ const bytes = await fetchSealed(app, deployment, wanted, kind);
134
+ if (!bytes) return null;
135
+ return JSON.parse((await openArtifact(keys, bytes, {appId: app.id, packageHash: hashOf(wanted), kind})).toString('utf8'));
136
+ };
137
+ const [before, after] = (await Promise.all([unlock(summary.base, 'manifest'), unlock(summary.target, 'manifest')])).map(manifestParts);
138
+ files = before.files && after.files ? compareManifests(before.files, after.files) : null;
139
+ let beforeModules = before.modules;
140
+ let afterModules = after.modules;
141
+ if (!beforeModules || !afterModules) {
142
+ const [beforeMap, afterMap] = await Promise.all([unlock(summary.base, 'sourcemap'), unlock(summary.target, 'sourcemap')]);
143
+ beforeModules = beforeMap?.sources || null;
144
+ afterModules = afterMap?.sources || null;
145
+ }
146
+ modules = beforeModules && afterModules ? compareModules(beforeModules, afterModules) : null;
147
+ }
148
+ console.log(`${summary.target} compared with ${summary.base}${summary.sealed ? ' (unlocked on this machine)' : ''}`);
149
+ if (!files && !modules) return console.log('No file list or source map was uploaded for one of these releases.');
150
+ if (files) {
151
+ console.log(` files: ${files.counts.added} added, ${files.counts.modified} modified, ${files.counts.removed} removed, ${files.counts.unchanged} unchanged`);
152
+ for (const entry of files.added) console.log(` + ${entry.path}`);
153
+ for (const entry of files.modified) console.log(` ~ ${entry.path}`);
154
+ for (const entry of files.removed) console.log(` - ${entry.path}`);
155
+ }
156
+ if (modules) {
157
+ console.log(` modules: ${modules.counts.added} added, ${modules.counts.removed} removed`);
158
+ for (const name of modules.added) console.log(` + ${name}`);
159
+ for (const name of modules.removed) console.log(` - ${name}`);
160
+ }
161
+ }
package/pulsar.js CHANGED
@@ -9,6 +9,7 @@ import crypto from 'node:crypto';
9
9
  import {fileURLToPath} from 'node:url';
10
10
  import {computePackageHash, fileHashes} from './hash.js';
11
11
  import {migrate} from './migrate.js';
12
+ import {privateContext, reportReach, sealArtifact, openArtifact, sealedHeaders, cmdBundleKey, cmdChanges} from './private.js';
12
13
 
13
14
  // Code signing: sign the package hash into an RS256 JWT the client verifies against its
14
15
  // CodePushPublicKey (Info.plist). Both native SDKs read it from <update>/CodePush/.codepushrelease
@@ -350,18 +351,21 @@ async function cmdLogin(args) {
350
351
  const email = await prompt('Email: ');
351
352
  const password = await prompt('Password: ', true);
352
353
  const deviceId = loadConfig().deviceId || crypto.randomBytes(16).toString('hex');
353
- const {token, user} = await api('/auth/login', {method: 'POST', body: {email, password}, headers: {'x-device-id': deviceId}, allowAnonymous: true});
354
+ const {token, user} = await api('/auth/login', {method: 'POST', body: {email, password, client: 'cli'}, headers: {'x-device-id': deviceId}, allowAnonymous: true});
354
355
  saveConfig({apiUrl, token, deviceId});
355
356
  console.log(`✓ logged in as ${user.email} (${user.platformRole})`);
356
357
  }
357
358
 
359
+ const HIDDEN_KEYS = 'Deployment keys are hidden for this login. Run "pulsar login" again to see them.';
360
+ const shownKey = (deployment) => deployment.key || `${deployment.keyHint || ''}•••• (hidden: run "pulsar login" again)`;
361
+
358
362
  async function cmdApps() {
359
363
  const apps = await api('/apps');
360
364
  if (!apps.length) return console.log('(no apps)');
361
365
  for (const app of apps) {
362
366
  console.log(`\n${app.name} [${app.os}] ${app.id}`);
363
367
  for (const [name, deployment] of Object.entries(app.deployments)) {
364
- console.log(` ${name.padEnd(11)} key: ${deployment.key}`);
368
+ console.log(` ${name.padEnd(11)} key: ${shownKey(deployment)}`);
365
369
  }
366
370
  }
367
371
  }
@@ -392,9 +396,14 @@ async function signForApp(app, deployment, contentsDir, packageHash, localKey) {
392
396
 
393
397
  // Sign and push an already-built bundle to one app's deployment, then generate and upload a
394
398
  // differential patch against whatever that deployment was serving.
395
- async function pushBuiltRelease(app, deployment, args, contentsDir, packageHash, localKey, {sourcemapPath} = {}) {
399
+ async function pushBuiltRelease(app, deployment, args, contentsDir, packageHash, localKey, {sourcemapPath, reachReported = false} = {}) {
400
+ const privateBundles = await privateContext(app, args, localKey);
401
+ const sealing = Boolean(privateBundles) && !privateBundles.plain;
402
+ const plainCopy = sealing && args.includes('--plain-copy-for-old-builds');
403
+ if (privateBundles && !reachReported) reportReach(privateBundles, {mandatory: args.includes('--mandatory'), plainCopy});
396
404
  await signForApp(app, deployment, contentsDir, packageHash, localKey);
397
- const zip = fs.readFileSync(zipContents(contentsDir));
405
+ const plainZip = fs.readFileSync(zipContents(contentsDir));
406
+ const zip = sealing ? Buffer.from(await sealArtifact(privateBundles, app, packageHash, plainZip, 'full')) : plainZip;
398
407
  let prevLatest = null;
399
408
  try {
400
409
  const existing = await api(`/apps/${app.id}/deployments/${deployment}/releases`, {optional: true});
@@ -426,7 +435,11 @@ async function pushBuiltRelease(app, deployment, args, contentsDir, packageHash,
426
435
  body: zip,
427
436
  onUploadProgress: uploadProgress(`uploading ${(zip.length / 1e6).toFixed(1)}MB bundle`),
428
437
  headers: {
429
- 'content-type': 'application/zip',
438
+ ...(sealing
439
+ ? {...sealedHeaders, 'x-encrypted': '1', 'x-key-ids': privateBundles.keys.map((key) => key.kid).join(','), 'x-release-signature': fs.readFileSync(path.join(contentsDir, SIGNATURE_PATH), 'utf8')}
440
+ : {'content-type': 'application/zip'}),
441
+ ...(privateBundles?.plain === 'all' ? {'x-plain': '1'} : {}),
442
+ ...(privateBundles?.plain === 'older' ? {'x-audience': 'older-builds'} : {}),
430
443
  'x-app-version': getFlag(args, 'target'),
431
444
  'x-package-hash': packageHash,
432
445
  'x-is-mandatory': String(args.includes('--mandatory')),
@@ -449,7 +462,18 @@ async function pushBuiltRelease(app, deployment, args, contentsDir, packageHash,
449
462
  release.targetFromLabels?.length ? `devices on ${release.targetFromLabels.join('/')}` : null,
450
463
  ].filter(Boolean);
451
464
  const reach = scopes.length ? scopes.join(' + ') : `${release.rollout}% of devices`;
452
- console.log(`✓ released ${release.label} to ${app.name}/${deployment} — ${release.isDisabled ? 'DISABLED' : reach}`);
465
+ const privacy = release.encrypted ? ' (private)' : release.olderBuildsOnly ? ' (plain, older builds only)' : privateBundles ? ' (plain)' : '';
466
+ console.log(`✓ released ${release.label} to ${app.name}/${deployment} — ${release.isDisabled ? 'DISABLED' : reach}${privacy}`);
467
+ if (plainCopy) {
468
+ await api(`/apps/${app.id}/deployments/${deployment}/releases/${release.label}/plain-copy`, {
469
+ method: 'POST',
470
+ raw: true,
471
+ body: plainZip,
472
+ onUploadProgress: uploadProgress(`uploading ${(plainZip.length / 1e6).toFixed(1)}MB plain copy for older builds`),
473
+ headers: {'content-type': 'application/zip'},
474
+ });
475
+ console.log('• plain copy uploaded: older builds get this release too, and Pulsar can read that copy');
476
+ }
453
477
  if (release.approval && !release.approval.approvedAt) {
454
478
  console.log(`⏸ waiting for approval: ${deployment} needs a second admin or owner to approve ${release.label} in the dashboard before devices get it`);
455
479
  }
@@ -460,22 +484,35 @@ async function pushBuiltRelease(app, deployment, args, contentsDir, packageHash,
460
484
  if (release.rolloutRamp) console.log(` gradual rollout — ${release.rollout}% to ${release.rolloutRamp.to}% over ${release.rolloutRamp.hours}h`);
461
485
 
462
486
  try {
463
- await api(`/apps/${app.id}/deployments/${deployment}/releases/${release.label}/manifest`, {method: 'POST', body: {files: fileManifest(contentsDir)}, optional: true});
487
+ const files = {files: fileManifest(contentsDir)};
488
+ const sealedManifest = () => {
489
+ let modules = null;
490
+ try {
491
+ modules = sourcemapPath && fs.existsSync(sourcemapPath) ? JSON.parse(fs.readFileSync(sourcemapPath, 'utf8')).sources || null : null;
492
+ } catch {
493
+ modules = null;
494
+ }
495
+ return Buffer.from(JSON.stringify(modules ? {...files, modules} : files));
496
+ };
497
+ await api(`/apps/${app.id}/deployments/${deployment}/releases/${release.label}/manifest`, sealing
498
+ ? {method: 'POST', raw: true, optional: true, body: await sealArtifact(privateBundles, app, packageHash, sealedManifest(), 'manifest'), headers: sealedHeaders}
499
+ : {method: 'POST', body: files, optional: true});
464
500
  } catch (err) {
465
501
  console.log(`• file list not recorded: ${err.message}`);
466
502
  }
467
503
  if (sourcemapPath && fs.existsSync(sourcemapPath)) {
468
504
  try {
469
- const map = fs.readFileSync(sourcemapPath);
505
+ const plainMap = fs.readFileSync(sourcemapPath);
506
+ const map = sealing ? Buffer.from(await sealArtifact(privateBundles, app, packageHash, plainMap, 'sourcemap')) : plainMap;
470
507
  await api(`/apps/${app.id}/deployments/${deployment}/releases/${release.label}/sourcemap`, {
471
508
  method: 'POST',
472
509
  raw: true,
473
510
  optional: true,
474
511
  body: map,
475
512
  onUploadProgress: uploadProgress(`uploading ${(map.length / 1e6).toFixed(1)}MB source map`),
476
- headers: {'content-type': 'application/json'},
513
+ headers: sealing ? sealedHeaders : {'content-type': 'application/json'},
477
514
  });
478
- console.log('• source map uploaded: crash stacks for this release will show your source files');
515
+ console.log(sealing ? '• source map uploaded, encrypted: unlock it in the dashboard or with pulsar changes' : '• source map uploaded: crash stacks for this release will show your source files');
479
516
  } catch (err) {
480
517
  console.log(`• source map not uploaded: ${err.message}`);
481
518
  }
@@ -484,16 +521,24 @@ async function pushBuiltRelease(app, deployment, args, contentsDir, packageHash,
484
521
  if (!args.includes('--no-diff') && prevLatest && prevLatest.packageHash && prevLatest.packageHash !== packageHash) {
485
522
  try {
486
523
  const {apiUrl} = loadConfig();
487
- const baseZip = await fetchBlob(apiUrl, app.id, `${prevLatest.packageHash}.zip`);
524
+ const baseFile = prevLatest.encrypted && prevLatest.blobKey ? prevLatest.blobKey.slice(app.id.length + 1) : `${prevLatest.packageHash}.zip`;
525
+ let baseZip = await fetchBlob(apiUrl, app.id, baseFile);
526
+ if (prevLatest.encrypted) {
527
+ if (!privateBundles?.keys.length) throw new Error(`${prevLatest.label} is private and no bundle key was given`);
528
+ baseZip = await openArtifact(privateBundles.keys, baseZip, {appId: app.id, packageHash: prevLatest.packageHash, kind: 'full'});
529
+ }
488
530
  const diffDir = await buildDiffPackage(baseZip, contentsDir);
489
- const diffZip = fs.readFileSync(zipContents(diffDir));
531
+ const plainDiff = fs.readFileSync(zipContents(diffDir));
532
+ const diffZip = sealing
533
+ ? Buffer.from(await sealArtifact(privateBundles, app, packageHash, plainDiff, 'diff', {baseHash: prevLatest.packageHash}))
534
+ : plainDiff;
490
535
  await api(`/apps/${app.id}/deployments/${deployment}/releases/${release.label}/diff`, {
491
536
  method: 'POST',
492
537
  raw: true,
493
538
  optional: true,
494
539
  body: diffZip,
495
540
  onUploadProgress: uploadProgress(`uploading ${(diffZip.length / 1e6).toFixed(1)}MB diff`),
496
- headers: {'content-type': 'application/zip', 'x-base-hash': prevLatest.packageHash},
541
+ headers: {...(sealing ? sealedHeaders : {'content-type': 'application/zip'}), 'x-base-hash': prevLatest.packageHash},
497
542
  });
498
543
  const saved = Math.round((1 - diffZip.length / zip.length) * 100);
499
544
  console.log(`• diff vs ${prevLatest.label}: ${(diffZip.length / 1e3).toFixed(0)} KB (${saved}% smaller)`);
@@ -506,11 +551,23 @@ async function pushBuiltRelease(app, deployment, args, contentsDir, packageHash,
506
551
 
507
552
  // Build the JS bundle once and return what every target app's release is made from. A local key
508
553
  // (--private-key <file>, or PULSAR_SIGNING_KEY holding the key itself) overrides Pulsar's signing.
509
- function buildOnce(args) {
510
- const platform = getFlag(args, 'platform', 'ios');
554
+ function localSigningKey(args) {
511
555
  const privateKeyPath = getFlag(args, 'private-key');
512
556
  if (privateKeyPath && !fs.existsSync(privateKeyPath)) die(`no signing key at ${privateKeyPath} — drop --private-key to have Pulsar sign`);
513
- const localKey = privateKeyPath ? fs.readFileSync(privateKeyPath, 'utf8') : (process.env.PULSAR_SIGNING_KEY || '').trim();
557
+ return privateKeyPath ? fs.readFileSync(privateKeyPath, 'utf8') : (process.env.PULSAR_SIGNING_KEY || '').trim();
558
+ }
559
+
560
+ async function checkPrivateBeforeBuild(apps, args) {
561
+ const localKey = localSigningKey(args);
562
+ for (const app of apps) {
563
+ const context = await privateContext(app, args, localKey);
564
+ if (context) reportReach(context, {mandatory: args.includes('--mandatory'), plainCopy: args.includes('--plain-copy-for-old-builds')});
565
+ }
566
+ }
567
+
568
+ function buildOnce(args) {
569
+ const platform = getFlag(args, 'platform', 'ios');
570
+ const localKey = localSigningKey(args);
514
571
  const contentsDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pulsar-build-'));
515
572
  const sourcemapPath = args.includes('--no-sourcemap') ? null : `${contentsDir}.map`;
516
573
  bundle(platform, contentsDir, sourcemapPath);
@@ -521,14 +578,15 @@ function buildOnce(args) {
521
578
 
522
579
  async function cmdRelease(args) {
523
580
  const [nameOrId, deployment = 'Staging'] = args;
524
- if (!nameOrId) die('Usage: pulsar release <app> <Staging|Production> --platform ios|android --target <ver> [--mandatory] [--disabled] [--rollout N] [--schedule +6h|ISO] [--ramp 100@48] [--from v6,ota,binary] [--devices id1,id2,...] [--device-models model1;model2] [--users u1,u2] [--private-key key.pem] [--no-diff] [--no-sourcemap] [--max-growth <percent>] [--description "..."]');
581
+ if (!nameOrId) die('Usage: pulsar release <app> <Staging|Production> --platform ios|android --target <ver> [--mandatory] [--disabled] [--rollout N] [--schedule +6h|ISO] [--ramp 100@48] [--from v6,ota,binary] [--devices id1,id2,...] [--device-models model1;model2] [--users u1,u2] [--private-key key.pem] [--bundle-key key.txt] [--plain-copy-for-old-builds | --plain | --only-older-builds] [--no-diff] [--no-sourcemap] [--max-growth <percent>] [--description "..."]');
525
582
  if (!getFlag(args, 'target')) die('--target <binary version> is required (e.g. --target 1.0.0)');
526
583
  const app = await resolveApp(nameOrId, getFlag(args, 'platform', 'ios'));
527
584
  if (app.os !== getFlag(args, 'platform', 'ios')) {
528
585
  console.log(`• note: resolved app "${app.name}" is ${app.os}; bundling ${getFlag(args, 'platform', 'ios')}`);
529
586
  }
587
+ await checkPrivateBeforeBuild([app], args);
530
588
  const {contentsDir, packageHash, localKey, sourcemapPath} = buildOnce(args);
531
- await pushBuiltRelease(app, deployment, args, contentsDir, packageHash, localKey, {sourcemapPath});
589
+ await pushBuiltRelease(app, deployment, args, contentsDir, packageHash, localKey, {sourcemapPath, reachReported: true});
532
590
  }
533
591
 
534
592
  // Release the same built bundle to several apps at once (shared-codebase / white-label fleets).
@@ -553,11 +611,12 @@ async function cmdReleaseTrain(args) {
553
611
  apps = apps.filter((app) => app.os === platform);
554
612
  if (!apps.length) die(`No ${platform} apps matched.`);
555
613
 
614
+ await checkPrivateBeforeBuild(apps, args);
556
615
  const {contentsDir, packageHash, localKey, sourcemapPath} = buildOnce(args);
557
616
  console.log(`• release train → ${apps.length} app(s): ${apps.map((app) => app.name).join(', ')}`);
558
617
  for (const app of apps) {
559
618
  try {
560
- await pushBuiltRelease(app, deployment, args, contentsDir, packageHash, localKey, {sourcemapPath});
619
+ await pushBuiltRelease(app, deployment, args, contentsDir, packageHash, localKey, {sourcemapPath, reachReported: true});
561
620
  } catch (err) {
562
621
  console.log(`✗ ${app.name}: ${err.message}`);
563
622
  }
@@ -587,11 +646,11 @@ async function cmdDeployment(args) {
587
646
  if (sub === 'add') {
588
647
  if (!depName) die('Usage: pulsar deployment add <app> <name>');
589
648
  const created = await api(`/apps/${app.id}/deployments`, {method: 'POST', body: {name: depName}});
590
- console.log(`✓ added ${created.name}\n key: ${created.key}`);
649
+ console.log(`✓ added ${created.name}\n key: ${shownKey(created)}`);
591
650
  } else if (sub === 'ls' || sub === 'list') {
592
651
  const full = await api(`/apps/${app.id}`);
593
652
  for (const [name, deployment] of Object.entries(full.deployments)) {
594
- console.log(` ${name.padEnd(12)} ${deployment.key}`);
653
+ console.log(` ${name.padEnd(12)} ${shownKey(deployment)}`);
595
654
  }
596
655
  } else {
597
656
  die('Usage: pulsar deployment <add|ls> <app> [name]');
@@ -604,7 +663,8 @@ async function cmdHistory(args) {
604
663
  const releases = await api(`/apps/${app.id}/deployments/${deployment}/releases`);
605
664
  if (!releases.length) return console.log('(no releases)');
606
665
  for (const release of [...releases].reverse()) {
607
- const flags = `${release.isMandatory ? ' [mandatory]' : ''}${release.isDisabled ? ' [disabled]' : ''}`;
666
+ const privacy = release.encrypted ? ` [private${release.plainCopy ? ' + plain copy' : ''}]` : release.olderBuildsOnly ? ' [plain, older builds only]' : release.plainOnPurpose ? ' [plain]' : '';
667
+ const flags = `${release.isMandatory ? ' [mandatory]' : ''}${release.isDisabled ? ' [disabled]' : ''}${privacy}`;
608
668
  const rollout = release.currentRollout ?? release.rollout;
609
669
  const state = release.state && release.state !== 'live' ? ` [${release.state}]` : '';
610
670
  const when = release.startsAt ? ` starts ${new Date(release.startsAt).toLocaleString()}` : '';
@@ -650,6 +710,7 @@ async function cmdKeys(args) {
650
710
  const matches = apps.filter((app) => app.name.toLowerCase().startsWith(`${project.toLowerCase()}-`));
651
711
  if (!matches.length) die(`No apps for project "${project}". Known: ${apps.map((app) => app.name).join(', ')}`);
652
712
 
713
+ if (matches.some((app) => Object.values(app.deployments || {}).some((deployment) => !deployment.key))) die(HIDDEN_KEYS);
653
714
  const vars = {};
654
715
  for (const app of matches) {
655
716
  for (const deployment of ['Staging', 'Production']) {
@@ -686,7 +747,7 @@ async function cmdKeys(args) {
686
747
  console.log(`✓ wrote ${Object.keys(vars).length} key(s) to ${target} (${written.size} updated, ${missing.length} added)`);
687
748
  }
688
749
 
689
- export {saveConfig, browserLogin, signCodePushJWT, SIGNATURE_PATH, api, die, getFlag, loadConfig, pushBuiltRelease, splitList};
750
+ export {saveConfig, browserLogin, signCodePushJWT, SIGNATURE_PATH, api, die, getFlag, loadConfig, pushBuiltRelease, splitList, resolveApp};
690
751
 
691
752
  // Only dispatch when run as the CLI — importing the module (e.g. from tests) must not execute a command.
692
753
  // Compare real paths: a global install runs through a bin symlink, so argv[1] is not this file's path.
@@ -712,6 +773,8 @@ if (invokedAsCli()) {
712
773
  patch: cmdPatch,
713
774
  keygen: cmdKeygen,
714
775
  keys: cmdKeys,
776
+ 'bundle-key': cmdBundleKey,
777
+ changes: cmdChanges,
715
778
  migrate,
716
779
  };
717
780
 
@@ -722,7 +785,7 @@ if (invokedAsCli()) {
722
785
  }
723
786
 
724
787
  (commands[command] || (() => {
725
- console.log('pulsar <login|apps|keys|release|release-train|promote|rollback|deployment|history|patch|keygen|migrate>');
788
+ console.log('pulsar <login|apps|keys|release|release-train|promote|rollback|deployment|history|patch|keygen|bundle-key|changes|migrate>');
726
789
  process.exit(command ? 1 : 0);
727
790
  }))(rest);
728
791
  }
@@ -0,0 +1,45 @@
1
+ const LIST_LIMIT = 200;
2
+
3
+ export function compareManifests(before, after) {
4
+ const added = [];
5
+ const removed = [];
6
+ const modified = [];
7
+ let unchanged = 0;
8
+ for (const [filePath, entry] of Object.entries(after)) {
9
+ const previous = before[filePath];
10
+ if (!previous) added.push({path: filePath, size: entry.size});
11
+ else if (previous.hash !== entry.hash) modified.push({path: filePath, before: previous.size, after: entry.size});
12
+ else unchanged += 1;
13
+ }
14
+ for (const [filePath, entry] of Object.entries(before)) if (!after[filePath]) removed.push({path: filePath, size: entry.size});
15
+ const total = (manifest) => Object.values(manifest).reduce((sum, entry) => sum + entry.size, 0);
16
+ const bySize = (left, right) => (right.size ?? Math.abs(right.after - right.before)) - (left.size ?? Math.abs(left.after - left.before));
17
+ return {
18
+ added: added.sort(bySize).slice(0, LIST_LIMIT),
19
+ removed: removed.sort(bySize).slice(0, LIST_LIMIT),
20
+ modified: modified.sort(bySize).slice(0, LIST_LIMIT),
21
+ counts: {added: added.length, removed: removed.length, modified: modified.length, unchanged},
22
+ size: {before: total(before), after: total(after)},
23
+ };
24
+ }
25
+
26
+ export const moduleName = (source) => {
27
+ const text = String(source || '');
28
+ const match = /(?:^|\/)(node_modules\/.*)$/.exec(text) || /(?:^|\/)(src\/.*)$/.exec(text);
29
+ return match ? match[1] : text.replace(/^.*\/(?=[^/]+\/[^/]+$)/, '');
30
+ };
31
+
32
+ export function compareModules(beforeSources, afterSources) {
33
+ const before = new Set((beforeSources || []).map(moduleName));
34
+ const after = new Set((afterSources || []).map(moduleName));
35
+ const added = [...after].filter((name) => !before.has(name));
36
+ const removed = [...before].filter((name) => !after.has(name));
37
+ return {added: added.slice(0, LIST_LIMIT), removed: removed.slice(0, LIST_LIMIT), counts: {added: added.length, removed: removed.length}};
38
+ }
39
+
40
+ export function manifestParts(document) {
41
+ if (document?.files && typeof document.files === 'object' && !Array.isArray(document.files)) {
42
+ return {files: document.files, modules: Array.isArray(document.modules) ? document.modules : null};
43
+ }
44
+ return {files: document || null, modules: null};
45
+ }