@cadence-app/compiler 0.4.0 → 0.6.0

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/dist/build.js CHANGED
@@ -7,6 +7,7 @@ import { gzipSync } from 'node:zlib';
7
7
  import * as esbuild from 'esbuild';
8
8
  import JSZip from 'jszip';
9
9
  import { copyAppAssets } from "./app-assets.js";
10
+ import { DEV_CLIENT_ENTRY, DEV_HOST_ENTRY, DEV_SCAFFOLD_FILES, DEV_SHELL_FILE, ENTRY_DOCUMENT, } from "./dev-scaffold.js";
10
11
  import { generateRenderFunction } from "./template/codegen.js";
11
12
  import { parseTemplate } from "./template/parser.js";
12
13
  import { compileStyle } from "./style/compile-style.js";
@@ -24,19 +25,6 @@ const HOST_DIR = path.join(path.dirname(fileURLToPath(import.meta.url)), 'host')
24
25
  change donc d'extension selon l'endroit d'où le compilateur tourne. */
25
26
  const HOST_EXTENSION = existsSync(path.join(HOST_DIR, 'engine-entry.ts')) ? '.ts' : '.js';
26
27
  const ENGINE_TARGET = 'es2020';
27
- const DEV_SHELL_FILE = 'dev.html';
28
- const DEV_HOST_ENTRY = 'dev-host';
29
- const DEV_CLIENT_ENTRY = 'dev-client';
30
- /**
31
- * L'échafaudage que `mini dev` sert dans le navigateur. Il reste dans `outDir`,
32
- * mais l'archive part sur le serveur de distribution et jusque sur les
33
- * appareils : elle n'embarque que ce que le conteneur exécute.
34
- */
35
- const DEV_SCAFFOLD_FILES = new Set([
36
- DEV_SHELL_FILE,
37
- `${DEV_HOST_ENTRY}.js`,
38
- `${DEV_CLIENT_ENTRY}.js`,
39
- ]);
40
28
  /**
41
29
  * Pipeline complet : manifest → compilation template+SCSS de chaque unité →
42
30
  * bundle esbuild (app + sous-packages, imports `@cadence/*` shimés vers le
@@ -67,7 +55,7 @@ export async function buildMiniApp(options) {
67
55
  });
68
56
  await rm(outDir, { recursive: true, force: true });
69
57
  await mkdir(outDir, { recursive: true });
70
- await bundleApp(outDir, virtualModules, subEntryNames, minified);
58
+ await bundleApp(miniappDir, outDir, virtualModules, subEntryNames, minified);
71
59
  await bundleHostScripts(outDir, minified);
72
60
  await writeHtmlShells(outDir, manifest.language ?? DEFAULT_DOCUMENT_LANGUAGE);
73
61
  await writeFile(path.join(outDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
@@ -249,7 +237,7 @@ function generateSubPackageEntry(pages) {
249
237
  });
250
238
  return lines.join('\n');
251
239
  }
252
- async function bundleApp(outDir, virtualModules, subEntryNames, minify) {
240
+ async function bundleApp(miniappDir, outDir, virtualModules, subEntryNames, minify) {
253
241
  const entryPoints = { app: 'cadence-entry:main' };
254
242
  for (const name of subEntryNames) {
255
243
  entryPoints[`subpackages/${name}`] = `cadence-entry:${name}`;
@@ -260,6 +248,7 @@ async function bundleApp(outDir, virtualModules, subEntryNames, minify) {
260
248
  entryNames: '[dir]/[name]',
261
249
  minify,
262
250
  plugins: [virtualModulesPlugin(virtualModules), cadenceShimPlugin()],
251
+ moduleNamingRoot: miniappDir,
263
252
  });
264
253
  }
265
254
  async function bundleHostScripts(outDir, minify) {
@@ -273,6 +262,7 @@ async function bundleHostScripts(outDir, minify) {
273
262
  entryNames: '[name]',
274
263
  minify,
275
264
  plugins: [],
265
+ moduleNamingRoot: HOST_DIR,
276
266
  });
277
267
  }
278
268
  async function runEsbuild(run) {
@@ -287,6 +277,7 @@ async function runEsbuild(run) {
287
277
  target: ENGINE_TARGET,
288
278
  minify: run.minify,
289
279
  plugins: run.plugins,
280
+ absWorkingDir: run.moduleNamingRoot,
290
281
  logLevel: 'silent',
291
282
  });
292
283
  }
@@ -380,7 +371,7 @@ function cadenceShimPlugin() {
380
371
  };
381
372
  }
382
373
  async function writeHtmlShells(outDir, language) {
383
- await writeFile(path.join(outDir, 'index.html'), htmlShell(['engine.js', 'app.js'], language));
374
+ await writeFile(path.join(outDir, ENTRY_DOCUMENT), htmlShell(['engine.js', 'app.js'], language));
384
375
  await writeFile(path.join(outDir, DEV_SHELL_FILE), htmlShell(['engine.js', `${DEV_HOST_ENTRY}.js`, 'app.js', `${DEV_CLIENT_ENTRY}.js`], language));
385
376
  }
386
377
  /* Le `lang` du document décrit ce qu'on lit, pas qui lit : il vient donc du
@@ -408,9 +399,30 @@ async function measure(filePath) {
408
399
  const contents = await readFile(filePath);
409
400
  return { raw: contents.byteLength, gzip: gzipSync(contents).byteLength };
410
401
  }
402
+ const ARCHIVE_ENTRY_DATE = new Date(Date.UTC(1980, 0, 1));
403
+ /**
404
+ * Horodate toute entrée de l'archive à une date fixe, dossiers compris.
405
+ *
406
+ * L'empreinte de l'archive est son identité dans le canal de distribution.
407
+ * Deux compilations des mêmes sources doivent donc rendre les mêmes octets,
408
+ * sans quoi rien ne rattache un bundle publié à ses sources. JSZip, lui, date
409
+ * chaque entrée de `new Date()`.
410
+ *
411
+ * Le parcours vient après l'ajout des fichiers parce que JSZip crée les
412
+ * entrées de dossier de lui-même : une date passée à `zip.file` les laisserait
413
+ * dehors. Le plancher de l'époque DOS est l'usage des archives reproductibles,
414
+ * et JSZip l'écrit par des accesseurs UTC — le fuseau de la machine n'y entre
415
+ * pas.
416
+ */
417
+ function dateEveryEntry(zip) {
418
+ zip.forEach((_entryPath, entry) => {
419
+ entry.date = ARCHIVE_ENTRY_DATE;
420
+ });
421
+ }
411
422
  async function writeBundleArchive(outDir, manifest) {
412
423
  const zip = new JSZip();
413
424
  await addDirectoryToZip(zip, outDir, '', DEV_SCAFFOLD_FILES);
425
+ dateEveryEntry(zip);
414
426
  const archiveName = `${manifest.name}-${manifest.version}.zip`;
415
427
  const buffer = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' });
416
428
  await writeFile(path.join(outDir, archiveName), buffer);
package/dist/cli.js CHANGED
@@ -3,8 +3,13 @@ import path from 'node:path';
3
3
  import { parseArgs } from 'node:util';
4
4
  import { buildMiniApp } from "./build.js";
5
5
  import { startDevServer } from "./dev-server.js";
6
+ import { ENTRY_DOCUMENT } from "./dev-scaffold.js";
7
+ import { channelDeepLink, pairingDeepLink } from "./dev-deep-link.js";
6
8
  import { ENGINE_GZIP_BUDGET_BYTES, engineBudgetVerdict } from "./engine-budget.js";
7
9
  import { initProject } from "./init-project.js";
10
+ import { openDevChannel } from "./dev-channel-session.js";
11
+ import { encodeQrCode } from "./qr/qr-code.js";
12
+ import { renderQrForTerminal } from "./qr/terminal-render.js";
8
13
  import { PROJECT_TEMPLATES, PROJECT_TEMPLATE_NAMES } from "./project-templates.js";
9
14
  import { clearCredentials, credentialsPath, normalizeRemoteUrl, readCredentials, writeCredentials, } from "./publish/credentials.js";
10
15
  import { DistributionClient } from "./publish/distribution-client.js";
@@ -20,7 +25,9 @@ ${TEMPLATE_LINES}
20
25
 
21
26
  Compiler :
22
27
  mini build <dossier-miniapp> [--out <dossier>] [--minify] [--no-zip]
23
- mini dev <dossier-miniapp> [--out <dossier>] [--port <n>]
28
+ mini dev <dossier-miniapp> [--out <dossier>] [--port <n>] [--channel]
29
+ --channel ouvre aussi un canal de développement sur le serveur de
30
+ distribution : l'appareil n'a plus à partager le réseau
24
31
 
25
32
  Publier :
26
33
  mini login --remote <url> [--token <pat>]
@@ -28,6 +35,102 @@ Publier :
28
35
  mini whoami
29
36
  mini publish <dossier-miniapp> [--app-id <uuid>]
30
37
  `;
38
+ /**
39
+ * Les adresses de `mini dev` : le navigateur pour écrire, le conteneur pour
40
+ * vérifier sur un vrai appareil. Les deux se rechargent à chaque compilation.
41
+ */
42
+ function printDevAddresses(server, port) {
43
+ console.log(`mini dev — ${server.url}`);
44
+ console.log('');
45
+ console.log(' navigateur mock natif intégré (Échap = retour)');
46
+ console.log(` conteneur ${server.url}${ENTRY_DOCUMENT} — rechargé à chaque compilation`);
47
+ console.log('');
48
+ console.log('Sur un appareil :');
49
+ console.log(` USB adb reverse tcp:${port} tcp:${port}, puis la même adresse`);
50
+ for (const url of server.networkUrls) {
51
+ console.log(` Wi-Fi ${url}${ENTRY_DOCUMENT}`);
52
+ }
53
+ const [firstNetworkUrl] = server.networkUrls;
54
+ if (firstNetworkUrl === undefined) {
55
+ return;
56
+ }
57
+ console.log(" (Android n'autorise le clair que sur localhost : préférer l'USB)");
58
+ printPairingCode(firstNetworkUrl);
59
+ }
60
+ /**
61
+ * Le lien d'appariement, à lire avec l'appareil photo du téléphone.
62
+ *
63
+ * Aucun lecteur à écrire : le système reconnaît une adresse, et l'hôte l'a
64
+ * enregistrée. Le QR porte la première adresse annoncée — les autres restent
65
+ * au-dessus, à recopier si c'est celle-là qui ne répond pas.
66
+ */
67
+ function printPairingCode(networkUrl) {
68
+ const link = pairingDeepLink(networkUrl.replace(/\/$/, ''));
69
+ console.log('');
70
+ console.log("Ou le scanner avec l'appareil photo du téléphone :");
71
+ console.log('');
72
+ console.log(renderQrForTerminal(encodeQrCode(link)));
73
+ console.log('');
74
+ console.log(` ${link}`);
75
+ console.log('');
76
+ console.log("Le jeton de l'adresse Wi-Fi meurt avec ce serveur. Sans lui, un appareil");
77
+ console.log("du même réseau n'obtient rien.");
78
+ }
79
+ /**
80
+ * Ouvre le canal pour ce bundle : l'application nommée, ou le slug du manifeste.
81
+ */
82
+ function openChannelFor(summary, distDir, appId) {
83
+ return openDevChannel({
84
+ distDir,
85
+ slug: summary.manifest.name,
86
+ ...(appId === undefined ? {} : { appId }),
87
+ });
88
+ }
89
+ /**
90
+ * Les deux voies d'un canal (ADR-038) : le code, qui dispense d'un appareil
91
+ * photo et sert donc un émulateur, et le QR, qui épargne de le recopier.
92
+ */
93
+ function printChannelPairing(channel) {
94
+ const link = channelDeepLink(channel.pollUrl);
95
+ console.log('');
96
+ console.log('Par le canal de développement — ni câble, ni réseau partagé :');
97
+ console.log(` code ${channel.displayCode}`);
98
+ console.log(` interrogé ${channel.pollUrl}`);
99
+ if (channel.expiresAt !== null) {
100
+ console.log(` expire ${channel.expiresAt}`);
101
+ }
102
+ console.log('');
103
+ console.log(renderQrForTerminal(encodeQrCode(link)));
104
+ console.log('');
105
+ console.log(` ${link}`);
106
+ console.log('');
107
+ console.log("Rien de ce que porte ce canal ne s'installe sur l'appareil, et le code");
108
+ console.log('meurt avec lui.');
109
+ console.log('');
110
+ }
111
+ /** Ce que le dernier envoi a changé, en une ligne. */
112
+ function printChannelPush(push) {
113
+ const uploadedCount = push.uploaded.length;
114
+ console.log(uploadedCount === 0
115
+ ? ` canal version ${push.version} — ${push.declared} fichiers, rien à monter`
116
+ : ` canal version ${push.version} — ${uploadedCount}/${push.declared} fichier(s), ${push.uploadedBytes} o montés`);
117
+ }
118
+ /**
119
+ * Une compilation qui échoue doit se voir sur l'appareil, au lieu d'y laisser
120
+ * la page d'avant. Un canal injoignable est dit et non fatal : le serveur
121
+ * local, lui, tourne toujours.
122
+ */
123
+ async function reportBuildFailure(channel, error) {
124
+ if (channel === null) {
125
+ return;
126
+ }
127
+ try {
128
+ await channel.reportError(error instanceof Error ? error.message : String(error));
129
+ }
130
+ catch (channelFailure) {
131
+ console.error("[cadence dev] canal injoignable pour signaler l'échec :", channelFailure);
132
+ }
133
+ }
31
134
  /** Commandes qui parlent au serveur plutôt qu'à un dossier de sources. */
32
135
  const ACCOUNT_COMMANDS = new Set(['login', 'logout', 'whoami']);
33
136
  async function main() {
@@ -43,6 +146,7 @@ async function main() {
43
146
  remote: { type: 'string' },
44
147
  token: { type: 'string' },
45
148
  'app-id': { type: 'string' },
149
+ channel: { type: 'boolean', default: false },
46
150
  help: { type: 'boolean', default: false },
47
151
  },
48
152
  });
@@ -90,20 +194,32 @@ async function main() {
90
194
  }
91
195
  if (command === 'dev') {
92
196
  const outDir = values.out ?? path.join(miniappDir, 'dist');
197
+ const distDir = path.resolve(outDir);
198
+ const build = () => buildMiniApp({ miniappDir, outDir, minify: false, zip: false });
199
+ /* Le canal s'ouvre après la première compilation : son nom d'application
200
+ se résout sur le slug du manifeste, que seule la compilation rend. */
201
+ const first = await build();
202
+ const channel = values.channel === true ? await openChannelFor(first, distDir, values['app-id']) : null;
93
203
  const rebuild = async () => {
94
- await buildMiniApp({ miniappDir, outDir, minify: false, zip: false });
204
+ let summary;
205
+ try {
206
+ summary = await build();
207
+ }
208
+ catch (error) {
209
+ await reportBuildFailure(channel, error);
210
+ throw error;
211
+ }
212
+ if (channel !== null) {
213
+ printChannelPush(await channel.push(summary.manifest));
214
+ }
95
215
  };
96
- await rebuild();
97
216
  const port = values.port === undefined ? DEFAULT_DEV_PORT : Number(values.port);
98
- const server = startDevServer({
99
- distDir: path.resolve(outDir),
100
- watchDir: miniappDir,
101
- port,
102
- rebuild,
103
- });
104
- console.log(`mini dev — ${server.url}`);
105
- console.log(' navigateur : mock natif intégré (Échap = retour)');
106
- console.log(` app hôte : pointer le conteneur Flutter sur ${server.url}index.html`);
217
+ const server = startDevServer({ distDir, watchDir: miniappDir, port, rebuild });
218
+ printDevAddresses(server, port);
219
+ if (channel !== null) {
220
+ printChannelPairing(channel);
221
+ printChannelPush(await channel.push(first.manifest));
222
+ }
107
223
  return;
108
224
  }
109
225
  exitWith(`commande inconnue '${command}'\n\n${HELP}`);
@@ -0,0 +1,61 @@
1
+ import type { FetchLike } from './publish/distribution-client.js';
2
+ /** Un canal ouvert, tel que le serveur le décrit. */
3
+ export interface OpenedDevChannel {
4
+ /** Le code tel qu'il voyage dans une URL. */
5
+ readonly code: string;
6
+ /** Le même, écrit pour être lu à voix haute et recopié. */
7
+ readonly displayCode: string;
8
+ /** L'adresse que l'appareil interroge. */
9
+ readonly pollUrl: string;
10
+ readonly expiresAt: string | null;
11
+ }
12
+ /** L'état du canal après un envoi de manifeste. */
13
+ export interface PushedBundle {
14
+ readonly version: number;
15
+ /**
16
+ * Les chemins que le canal ne tient pas à l'empreinte déclarée. Au second
17
+ * envoi d'un fichier inchangé, la liste est vide.
18
+ */
19
+ readonly missingAssets: readonly string[];
20
+ }
21
+ export interface DevChannelClientOptions {
22
+ readonly remoteUrl: string;
23
+ readonly token: string;
24
+ readonly fetch?: FetchLike;
25
+ }
26
+ /** Le serveur a refusé une opération du canal, pour une raison qu'il explique. */
27
+ export declare class DevChannelRejectedError extends Error {
28
+ readonly status: number;
29
+ readonly body: string;
30
+ readonly name = "DevChannelRejectedError";
31
+ constructor(status: number, body: string);
32
+ }
33
+ /**
34
+ * Le canal de développement, vu du CLI (ADR-038).
35
+ *
36
+ * Pousser ici ne crée aucune version : l'emplacement est éphémère, et le code
37
+ * court suffit à l'appareil qui le lit. Une méthode par intention, et des
38
+ * erreurs typées — aucun appelant n'a à lire un code HTTP.
39
+ */
40
+ export declare class DevChannelClient {
41
+ constructor(options: DevChannelClientOptions);
42
+ private readonly remoteUrl;
43
+ private readonly token;
44
+ private readonly fetch;
45
+ /** Ouvre un canal pour cette application, et rend son code. */
46
+ open(appId: string): Promise<OpenedDevChannel>;
47
+ /**
48
+ * Remplace le manifeste du canal, et rend ce qui lui manque encore.
49
+ *
50
+ * Le manifeste porte la carte d'intégrité du bundle — `assets`, une empreinte
51
+ * par chemin —, dont le serveur déduit sa réponse. Un manifeste sans cette
52
+ * carte vide le canal de ses fichiers.
53
+ */
54
+ pushBundle(code: string, manifest: Record<string, unknown>): Promise<PushedBundle>;
55
+ /** Dépose un fichier du bundle, que le manifeste courant doit avoir déclaré. */
56
+ putAsset(code: string, assetPath: string, bytes: Uint8Array, contentType: string): Promise<void>;
57
+ /** Fait porter une erreur de compilation à l'écran de l'appareil. */
58
+ reportError(code: string, message: string): Promise<void>;
59
+ private send;
60
+ private rejectionFor;
61
+ }
@@ -0,0 +1,168 @@
1
+ import { normalizeRemoteUrl } from "./publish/credentials.js";
2
+ import { InvalidTokenError, RemoteUnreachableError } from "./publish/publish-errors.js";
3
+ const HTTP_UNAUTHORIZED = 401;
4
+ const HTTP_FORBIDDEN = 403;
5
+ const CHANNELS_ENDPOINT = '/api/v1/dev-channels';
6
+ /** Le serveur a refusé une opération du canal, pour une raison qu'il explique. */
7
+ export class DevChannelRejectedError extends Error {
8
+ status;
9
+ body;
10
+ name = 'DevChannelRejectedError';
11
+ constructor(status, body) {
12
+ super(`le serveur a refusé le canal de développement (HTTP ${status})${body === '' ? '' : ` : ${body}`}`);
13
+ this.status = status;
14
+ this.body = body;
15
+ }
16
+ }
17
+ /**
18
+ * Le canal de développement, vu du CLI (ADR-038).
19
+ *
20
+ * Pousser ici ne crée aucune version : l'emplacement est éphémère, et le code
21
+ * court suffit à l'appareil qui le lit. Une méthode par intention, et des
22
+ * erreurs typées — aucun appelant n'a à lire un code HTTP.
23
+ */
24
+ export class DevChannelClient {
25
+ constructor(options) {
26
+ this.remoteUrl = normalizeRemoteUrl(options.remoteUrl);
27
+ this.token = options.token;
28
+ this.fetch = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
29
+ }
30
+ remoteUrl;
31
+ token;
32
+ fetch;
33
+ /** Ouvre un canal pour cette application, et rend son code. */
34
+ async open(appId) {
35
+ const response = await this.send(CHANNELS_ENDPOINT, {
36
+ method: 'POST',
37
+ headers: { 'content-type': 'application/json' },
38
+ body: JSON.stringify({ appId }),
39
+ });
40
+ if (!response.ok) {
41
+ throw this.rejectionFor(response.status, await readBody(response));
42
+ }
43
+ return parseOpenedChannel(await readBody(response));
44
+ }
45
+ /**
46
+ * Remplace le manifeste du canal, et rend ce qui lui manque encore.
47
+ *
48
+ * Le manifeste porte la carte d'intégrité du bundle — `assets`, une empreinte
49
+ * par chemin —, dont le serveur déduit sa réponse. Un manifeste sans cette
50
+ * carte vide le canal de ses fichiers.
51
+ */
52
+ async pushBundle(code, manifest) {
53
+ const response = await this.send(`${CHANNELS_ENDPOINT}/${code}/bundle`, {
54
+ method: 'PUT',
55
+ headers: { 'content-type': 'application/json' },
56
+ body: JSON.stringify(manifest),
57
+ });
58
+ if (!response.ok) {
59
+ throw this.rejectionFor(response.status, await readBody(response));
60
+ }
61
+ return parsePushedBundle(await readBody(response));
62
+ }
63
+ /** Dépose un fichier du bundle, que le manifeste courant doit avoir déclaré. */
64
+ async putAsset(code, assetPath, bytes, contentType) {
65
+ const response = await this.send(`${CHANNELS_ENDPOINT}/${code}/assets/${encodeAssetPath(assetPath)}`, {
66
+ method: 'PUT',
67
+ headers: { 'content-type': contentType },
68
+ body: bytes,
69
+ });
70
+ if (!response.ok) {
71
+ throw this.rejectionFor(response.status, await readBody(response));
72
+ }
73
+ }
74
+ /** Fait porter une erreur de compilation à l'écran de l'appareil. */
75
+ async reportError(code, message) {
76
+ const response = await this.send(`${CHANNELS_ENDPOINT}/${code}/error`, {
77
+ method: 'PUT',
78
+ headers: { 'content-type': 'application/json' },
79
+ body: JSON.stringify({ message }),
80
+ });
81
+ if (!response.ok) {
82
+ throw this.rejectionFor(response.status, await readBody(response));
83
+ }
84
+ }
85
+ async send(pathname, init) {
86
+ const url = `${this.remoteUrl}${pathname}`;
87
+ try {
88
+ return await this.fetch(url, {
89
+ ...init,
90
+ headers: { ...(init.headers ?? {}), authorization: `Bearer ${this.token}` },
91
+ });
92
+ }
93
+ catch (error) {
94
+ throw new RemoteUnreachableError(url, error);
95
+ }
96
+ }
97
+ rejectionFor(status, body) {
98
+ if (status === HTTP_UNAUTHORIZED || status === HTTP_FORBIDDEN) {
99
+ return new InvalidTokenError(status);
100
+ }
101
+ return new DevChannelRejectedError(status, body);
102
+ }
103
+ }
104
+ /**
105
+ * Chaque segment est encodé, les barres obliques restent des séparateurs : le
106
+ * serveur lit le chemin du fichier dans ce qui suit `/assets/`.
107
+ */
108
+ function encodeAssetPath(assetPath) {
109
+ return assetPath.split('/').map(encodeURIComponent).join('/');
110
+ }
111
+ /**
112
+ * Le code et l'adresse d'interrogation sont indispensables : sans eux, rien ne
113
+ * peut être poussé ni lu, et un canal à moitié décrit vaut une panne.
114
+ */
115
+ function parseOpenedChannel(body) {
116
+ const parsed = parseObject(body);
117
+ const code = asText(parsed['code']);
118
+ const pollUrl = asText(parsed['pollUrl']);
119
+ if (code === null || pollUrl === null) {
120
+ throw new Error(`le serveur a ouvert un canal sans code exploitable : ${body}`);
121
+ }
122
+ return {
123
+ code,
124
+ displayCode: asText(parsed['displayCode']) ?? code,
125
+ pollUrl,
126
+ expiresAt: asText(parsed['expiresAt']),
127
+ };
128
+ }
129
+ /** La version du canal est ce qui dit à l'appareil qu'il doit relire. */
130
+ function parsePushedBundle(body) {
131
+ const parsed = parseObject(body);
132
+ const version = parsed['version'];
133
+ if (typeof version !== 'number') {
134
+ throw new Error(`le serveur n'a pas rendu la version du canal : ${body}`);
135
+ }
136
+ const missing = parsed['missingAssets'];
137
+ return {
138
+ version,
139
+ missingAssets: Array.isArray(missing) ? missing.filter(isNonEmptyText) : [],
140
+ };
141
+ }
142
+ function parseObject(body) {
143
+ let parsed;
144
+ try {
145
+ parsed = JSON.parse(body);
146
+ }
147
+ catch {
148
+ throw new Error(`réponse illisible du serveur de canal : ${body}`);
149
+ }
150
+ if (typeof parsed !== 'object' || parsed === null) {
151
+ throw new Error(`réponse inattendue du serveur de canal : ${body}`);
152
+ }
153
+ return parsed;
154
+ }
155
+ function asText(value) {
156
+ return typeof value === 'string' && value !== '' ? value : null;
157
+ }
158
+ function isNonEmptyText(value) {
159
+ return typeof value === 'string' && value !== '';
160
+ }
161
+ async function readBody(response) {
162
+ try {
163
+ return (await response.text()).trim();
164
+ }
165
+ catch {
166
+ return '';
167
+ }
168
+ }
@@ -0,0 +1,46 @@
1
+ import type { MiniAppManifest } from './manifest.js';
2
+ import type { Credentials } from './publish/credentials.js';
3
+ import { DevChannelClient } from './dev-channel-client.js';
4
+ /** Ce qu'un envoi a réellement coûté, et ce qu'il a changé. */
5
+ export interface DevChannelPush {
6
+ readonly version: number;
7
+ /** Fichiers déclarés par le bundle. */
8
+ readonly declared: number;
9
+ /** Ceux que le canal n'avait pas, et qui viennent de monter. */
10
+ readonly uploaded: readonly string[];
11
+ readonly uploadedBytes: number;
12
+ }
13
+ /** Un canal ouvert, prêt à recevoir les compilations successives. */
14
+ export interface DevChannelSession {
15
+ readonly code: string;
16
+ readonly displayCode: string;
17
+ readonly pollUrl: string;
18
+ readonly expiresAt: string | null;
19
+ /**
20
+ * Déclare le bundle compilé, puis envoie les seuls fichiers qui manquent au
21
+ * canal. Un enregistrement qui ne change qu'un fichier n'en monte qu'un.
22
+ */
23
+ push(manifest: MiniAppManifest): Promise<DevChannelPush>;
24
+ /** Fait porter une erreur de compilation à l'écran de l'appareil. */
25
+ reportError(message: string): Promise<void>;
26
+ }
27
+ export interface OpenDevChannelOptions {
28
+ /** Le dossier compilé, dont chaque fichier est déclaré au canal. */
29
+ readonly distDir: string;
30
+ /** Ouvrir le canal de cette application-ci, au lieu de résoudre le slug. */
31
+ readonly appId?: string;
32
+ /** Le slug du manifeste, employé quand `appId` est absent. */
33
+ readonly slug: string;
34
+ /** Identifiants explicites, sinon ceux de `mini login`. */
35
+ readonly credentials?: Credentials;
36
+ /** Fabriques injectées : les tests n'ont alors aucun réseau à simuler. */
37
+ readonly createClient?: (credentials: Credentials) => DevChannelClient;
38
+ readonly resolveAppId?: (credentials: Credentials, slug: string) => Promise<string>;
39
+ }
40
+ /**
41
+ * Ouvre un canal de développement et rend de quoi l'alimenter (ADR-038).
42
+ *
43
+ * Le canal ne crée aucune version, et rien de ce qu'il porte ne s'installe sur
44
+ * l'appareil : ce qui tient la place d'une signature est l'éphémère.
45
+ */
46
+ export declare function openDevChannel(options: OpenDevChannelOptions): Promise<DevChannelSession>;
@@ -0,0 +1,113 @@
1
+ import { createHash } from 'node:crypto';
2
+ import { readFile, readdir } from 'node:fs/promises';
3
+ import path from 'node:path';
4
+ import { DEV_SCAFFOLD_FILES } from "./dev-scaffold.js";
5
+ import { contentTypeFor } from "./dev-server.js";
6
+ import { readCredentials } from "./publish/credentials.js";
7
+ import { DevChannelClient } from "./dev-channel-client.js";
8
+ import { DistributionClient } from "./publish/distribution-client.js";
9
+ import { NotAuthenticatedError } from "./publish/publish-errors.js";
10
+ /**
11
+ * Ouvre un canal de développement et rend de quoi l'alimenter (ADR-038).
12
+ *
13
+ * Le canal ne crée aucune version, et rien de ce qu'il porte ne s'installe sur
14
+ * l'appareil : ce qui tient la place d'une signature est l'éphémère.
15
+ */
16
+ export async function openDevChannel(options) {
17
+ const credentials = options.credentials ?? (await readCredentials());
18
+ if (credentials === null) {
19
+ throw new NotAuthenticatedError();
20
+ }
21
+ const client = options.createClient?.(credentials) ?? new DevChannelClient(credentials);
22
+ const appId = options.appId ?? (await resolveAppId(options, credentials));
23
+ const channel = await client.open(appId);
24
+ return {
25
+ code: channel.code,
26
+ displayCode: channel.displayCode,
27
+ pollUrl: channel.pollUrl,
28
+ expiresAt: channel.expiresAt,
29
+ async push(manifest) {
30
+ const files = await readBundleFiles(options.distDir);
31
+ const declared = integrityMap(files);
32
+ const pushed = await client.pushBundle(channel.code, { ...manifest, assets: declared });
33
+ const byPath = new Map(files.map((file) => [file.relativePath, file]));
34
+ let uploadedBytes = 0;
35
+ const uploaded = [];
36
+ for (const missing of pushed.missingAssets) {
37
+ const file = byPath.get(missing) ?? byPath.get(`assets/${missing}`);
38
+ if (file === undefined) {
39
+ /* Le serveur réclame un chemin que ce bundle ne déclare pas : se taire
40
+ laisserait l'appareil servir des octets d'une compilation d'avant. */
41
+ throw new Error(`le canal réclame « ${missing} », que le bundle compilé ne contient pas`);
42
+ }
43
+ await client.putAsset(channel.code, file.relativePath, file.bytes, contentTypeFor(file.relativePath));
44
+ uploaded.push(file.relativePath);
45
+ uploadedBytes += file.bytes.byteLength;
46
+ }
47
+ return {
48
+ version: pushed.version,
49
+ declared: files.length,
50
+ uploaded,
51
+ uploadedBytes,
52
+ };
53
+ },
54
+ async reportError(message) {
55
+ await client.reportError(channel.code, message);
56
+ },
57
+ };
58
+ }
59
+ async function resolveAppId(options, credentials) {
60
+ if (options.resolveAppId !== undefined) {
61
+ return options.resolveAppId(credentials, options.slug);
62
+ }
63
+ const app = await new DistributionClient(credentials).findAppBySlug(options.slug);
64
+ return app.id;
65
+ }
66
+ /**
67
+ * Les fichiers que le canal doit porter : exactement ceux de l'archive
68
+ * publiée, l'échafaudage du navigateur exclu par le même ensemble.
69
+ */
70
+ async function readBundleFiles(distDir) {
71
+ const files = [];
72
+ await collectFiles(distDir, '', files);
73
+ rejectColliding(files);
74
+ return files;
75
+ }
76
+ async function collectFiles(directory, prefix, collected) {
77
+ const entries = await readdir(directory, { withFileTypes: true });
78
+ for (const entry of entries) {
79
+ const relativePath = prefix === '' ? entry.name : `${prefix}/${entry.name}`;
80
+ if (DEV_SCAFFOLD_FILES.has(relativePath)) {
81
+ continue;
82
+ }
83
+ const entryPath = path.join(directory, entry.name);
84
+ if (entry.isDirectory()) {
85
+ await collectFiles(entryPath, relativePath, collected);
86
+ continue;
87
+ }
88
+ const bytes = await readFile(entryPath);
89
+ collected.push({ relativePath, bytes, sha256: sha256Hex(bytes) });
90
+ }
91
+ }
92
+ function integrityMap(files) {
93
+ return Object.fromEntries(files.map((file) => [file.relativePath, { sha256: file.sha256, size: file.bytes.byteLength }]));
94
+ }
95
+ /**
96
+ * Le serveur retire un préfixe `assets/` du chemin déclaré : `assets/logo.png`
97
+ * et `logo.png` y deviennent une seule clé, et le second écrirait sur le
98
+ * premier. Mieux vaut refuser que servir un fichier pour un autre.
99
+ */
100
+ function rejectColliding(files) {
101
+ const claimed = new Map();
102
+ for (const file of files) {
103
+ const key = file.relativePath.replace(/^assets\//, '');
104
+ const previous = claimed.get(key);
105
+ if (previous !== undefined) {
106
+ throw new Error(`« ${previous} » et « ${file.relativePath} » tiennent la même place dans un canal de développement`);
107
+ }
108
+ claimed.set(key, file.relativePath);
109
+ }
110
+ }
111
+ function sha256Hex(bytes) {
112
+ return createHash('sha256').update(bytes).digest('hex');
113
+ }