@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 +28 -16
- package/dist/cli.js +128 -12
- package/dist/dev-channel-client.d.ts +61 -0
- package/dist/dev-channel-client.js +168 -0
- package/dist/dev-channel-session.d.ts +46 -0
- package/dist/dev-channel-session.js +113 -0
- package/dist/dev-deep-link.d.ts +22 -0
- package/dist/dev-deep-link.js +45 -0
- package/dist/dev-scaffold.d.ts +12 -0
- package/dist/dev-scaffold.js +16 -0
- package/dist/dev-server.d.ts +17 -0
- package/dist/dev-server.js +113 -7
- package/dist/host/browser-mock-host.js +3 -0
- package/dist/host/dev-client.js +3 -1
- package/dist/host/engine-entry.js +84 -13
- package/dist/index.d.ts +5 -1
- package/dist/index.js +3 -1
- package/dist/local-addresses.d.ts +10 -0
- package/dist/local-addresses.js +23 -0
- package/dist/pairing-token.d.ts +40 -0
- package/dist/pairing-token.js +76 -0
- package/dist/qr/galois.d.ts +9 -0
- package/dist/qr/galois.js +48 -0
- package/dist/qr/matrix.d.ts +9 -0
- package/dist/qr/matrix.js +316 -0
- package/dist/qr/qr-code.d.ts +19 -0
- package/dist/qr/qr-code.js +131 -0
- package/dist/qr/qr-error.d.ts +4 -0
- package/dist/qr/qr-error.js +7 -0
- package/dist/qr/terminal-render.d.ts +8 -0
- package/dist/qr/terminal-render.js +59 -0
- package/package.json +5 -5
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,
|
|
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
|
-
|
|
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
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
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
|
+
}
|