@indos/bibliotheque 0.0.0-stage → 1.1.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.
Files changed (119) hide show
  1. package/CHANGELOG.md +36 -0
  2. package/LICENSE +21 -0
  3. package/README.md +8 -2
  4. package/bin/page-de-l-espace.d.ts +1 -0
  5. package/bin/page-de-l-espace.js +29 -0
  6. package/modeles/partage.sql +16 -0
  7. package/package.json +117 -4
  8. package/src/app.d.ts +3 -0
  9. package/src/app.js +30 -0
  10. package/src/appel-d-ecran.d.ts +18 -0
  11. package/src/appel-d-ecran.js +82 -0
  12. package/src/appeler.d.ts +13 -0
  13. package/src/appeler.js +33 -0
  14. package/src/base-d-essai.d.ts +4 -0
  15. package/src/base-d-essai.js +18 -0
  16. package/src/base.d.ts +3 -0
  17. package/src/base.js +49 -0
  18. package/src/compte.d.ts +53 -0
  19. package/src/compte.js +176 -0
  20. package/src/deriver.d.ts +2 -0
  21. package/src/deriver.js +28 -0
  22. package/src/description-des-comptes.d.ts +50 -0
  23. package/src/description-des-comptes.js +4 -0
  24. package/src/ecran.d.ts +90 -0
  25. package/src/ecran.js +139 -0
  26. package/src/espace/appel.d.ts +10 -0
  27. package/src/espace/appel.js +20 -0
  28. package/src/espace/appels.d.ts +23 -0
  29. package/src/espace/appels.js +81 -0
  30. package/src/espace/comptes.d.ts +1 -0
  31. package/src/espace/comptes.js +180 -0
  32. package/src/espace/contexte.d.ts +8 -0
  33. package/src/espace/contexte.js +6 -0
  34. package/src/espace/coquille.d.ts +2 -0
  35. package/src/espace/coquille.js +76 -0
  36. package/src/espace/ecran.d.ts +10 -0
  37. package/src/espace/ecran.js +23 -0
  38. package/src/espace/entree-active.d.ts +2 -0
  39. package/src/espace/entree-active.js +21 -0
  40. package/src/espace/erreur.d.ts +3 -0
  41. package/src/espace/erreur.js +23 -0
  42. package/src/espace/heure.d.ts +1 -0
  43. package/src/espace/heure.js +14 -0
  44. package/src/espace/index.d.ts +12 -0
  45. package/src/espace/index.js +13 -0
  46. package/src/espace/lancer.d.ts +3 -0
  47. package/src/espace/lancer.js +13 -0
  48. package/src/espace/lien.d.ts +6 -0
  49. package/src/espace/lien.js +43 -0
  50. package/src/espace/navigation.d.ts +1 -0
  51. package/src/espace/navigation.js +5 -0
  52. package/src/espace/page.d.ts +25 -0
  53. package/src/espace/page.js +51 -0
  54. package/src/espace/pagination.d.ts +8 -0
  55. package/src/espace/pagination.js +19 -0
  56. package/src/espace/session.d.ts +37 -0
  57. package/src/espace/session.js +13 -0
  58. package/src/faux-core.d.ts +29 -0
  59. package/src/faux-core.js +112 -0
  60. package/src/fichiers.d.ts +36 -0
  61. package/src/fichiers.js +109 -0
  62. package/src/jeton.d.ts +10 -0
  63. package/src/jeton.js +96 -0
  64. package/src/liens.d.ts +10 -0
  65. package/src/liens.js +52 -0
  66. package/src/mcp.d.ts +20 -0
  67. package/src/mcp.js +153 -0
  68. package/src/page.d.ts +17 -0
  69. package/src/page.js +127 -0
  70. package/src/pagination.d.ts +1 -0
  71. package/src/pagination.js +4 -0
  72. package/src/partage.d.ts +62 -0
  73. package/src/partage.js +248 -0
  74. package/src/session.d.ts +17 -0
  75. package/src/session.js +124 -0
  76. package/src/theme.d.ts +2 -0
  77. package/src/theme.js +52 -0
  78. package/src/type-de-fichier.d.ts +6 -0
  79. package/src/type-de-fichier.js +115 -0
  80. package/src/ui/annonce.d.ts +7 -0
  81. package/src/ui/annonce.js +18 -0
  82. package/src/ui/blocs.d.ts +44 -0
  83. package/src/ui/blocs.js +34 -0
  84. package/src/ui/bouton.d.ts +7 -0
  85. package/src/ui/bouton.js +13 -0
  86. package/src/ui/cases.d.ts +19 -0
  87. package/src/ui/cases.js +17 -0
  88. package/src/ui/champ.d.ts +21 -0
  89. package/src/ui/champ.js +25 -0
  90. package/src/ui/choix.d.ts +16 -0
  91. package/src/ui/choix.js +11 -0
  92. package/src/ui/classes.d.ts +2 -0
  93. package/src/ui/classes.js +7 -0
  94. package/src/ui/confirmation.d.ts +12 -0
  95. package/src/ui/confirmation.js +6 -0
  96. package/src/ui/fenetre.d.ts +13 -0
  97. package/src/ui/fenetre.js +40 -0
  98. package/src/ui/graphiques.d.ts +44 -0
  99. package/src/ui/graphiques.js +128 -0
  100. package/src/ui/index.d.ts +18 -0
  101. package/src/ui/index.js +20 -0
  102. package/src/ui/lien.d.ts +8 -0
  103. package/src/ui/lien.js +10 -0
  104. package/src/ui/menu.d.ts +8 -0
  105. package/src/ui/menu.js +20 -0
  106. package/src/ui/panneau.d.ts +12 -0
  107. package/src/ui/panneau.js +17 -0
  108. package/src/ui/repli.d.ts +12 -0
  109. package/src/ui/repli.js +6 -0
  110. package/src/ui/suggestions.d.ts +14 -0
  111. package/src/ui/suggestions.js +54 -0
  112. package/src/ui/tableau.d.ts +18 -0
  113. package/src/ui/tableau.js +28 -0
  114. package/src/ui/theme.css +112 -0
  115. package/src/ui/vues.d.ts +15 -0
  116. package/src/ui/vues.js +7 -0
  117. package/src/vite.d.ts +19 -0
  118. package/src/vite.js +195 -0
  119. package/tsconfig.page.json +30 -0
@@ -0,0 +1,19 @@
1
+ import { useNavigate, useSearch } from '@tanstack/react-router';
2
+ // Le `validateSearch` d'un écran paginé : la page, un entier à partir de 2 ; toute autre valeur
3
+ // est la première page.
4
+ export function rechercheDUnePage(recherche) {
5
+ const page = Number(recherche.page);
6
+ return Number.isInteger(page) && page > 1 ? { page } : {};
7
+ }
8
+ // La page de l'adresse, à partir de 1, et de quoi en changer : « Précédent » et « Suivant »
9
+ // changent l'adresse, la première page n'y est pas écrite.
10
+ export function usePageDeLAdresse() {
11
+ const recherche = useSearch({ strict: false });
12
+ const naviguer = useNavigate();
13
+ return {
14
+ page: recherche.page ?? 1,
15
+ changerDePage(page) {
16
+ void naviguer({ to: '.', search: (avant) => ({ ...avant, page: page > 1 ? page : undefined }) });
17
+ },
18
+ };
19
+ }
@@ -0,0 +1,37 @@
1
+ export type EcranDUneApp = {
2
+ nom: string;
3
+ titre: string;
4
+ chemin: string;
5
+ };
6
+ export type AppOuverte = {
7
+ nom: string;
8
+ titre: string;
9
+ lien: string;
10
+ reglages: boolean;
11
+ ecrans: EcranDUneApp[];
12
+ };
13
+ export type EntreeDeLaBarre = {
14
+ titre: string;
15
+ chemin: string;
16
+ app: string;
17
+ };
18
+ export type Session = {
19
+ id: string;
20
+ email: string;
21
+ nom: string;
22
+ proprietaire: boolean;
23
+ groupes: {
24
+ id: string;
25
+ nom: string;
26
+ }[];
27
+ apps: AppOuverte[];
28
+ barre: EntreeDeLaBarre[];
29
+ theme: {
30
+ nom: string;
31
+ logo: boolean;
32
+ };
33
+ };
34
+ export declare const requeteDeLaSession: import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Session, Error, Session, string[]>, "queryFn"> & {
35
+ queryFn?: import("@tanstack/react-query").QueryFunction<Session, string[], never> | undefined;
36
+ } & import("@tanstack/react-query").QueryKeyWithDataTag<string[], Session, Error>;
37
+ export declare function useSession(): Session;
@@ -0,0 +1,13 @@
1
+ import { queryOptions, useSuspenseQuery } from '@tanstack/react-query';
2
+ import { demander } from './appels.js';
3
+ // La requête de la session. Relue au retour sur la fenêtre, elle prolonge la session ; sans
4
+ // session, la connexion du core (`demander`).
5
+ export const requeteDeLaSession = queryOptions({
6
+ queryKey: ['session'],
7
+ queryFn: () => demander('/espace/session', { methode: 'GET' }),
8
+ staleTime: 30_000,
9
+ });
10
+ // La personne connectée, pour un écran : la session est lue avant qu'il ne s'affiche.
11
+ export function useSession() {
12
+ return useSuspenseQuery(requeteDeLaSession).data;
13
+ }
@@ -0,0 +1,29 @@
1
+ import { type KeyObject } from 'node:crypto';
2
+ import type { TestContext } from 'node:test';
3
+ import type { AppDeLaConsole, EntreeDeLaBarre } from './ecran.ts';
4
+ import type { Personne } from './jeton.ts';
5
+ import type { Annuaire } from './partage.ts';
6
+ export declare const cleDuFauxCore: KeyObject, clePubliqueDuFauxCore: KeyObject;
7
+ export declare function fabriquerUnJeton(personne: Personne, app: string, cle?: KeyObject): string;
8
+ export declare const logoDEssai = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 10 10\"><rect width=\"10\" height=\"10\"/></svg>";
9
+ export type AppDeclaree = {
10
+ nom: string;
11
+ titre: string;
12
+ lien: string;
13
+ pour?: 'proprietaire';
14
+ acces?: string[];
15
+ ecrans?: {
16
+ nom: string;
17
+ titre: string;
18
+ pour?: 'proprietaire';
19
+ }[];
20
+ reglages?: boolean;
21
+ };
22
+ export declare function sessionDuCore(apps: AppDeclaree[], proprietaire: boolean, nomDeLOS: string, groupes?: string[]): {
23
+ apps: AppDeLaConsole[];
24
+ barre: EntreeDeLaBarre[];
25
+ };
26
+ export declare function lancerLeFauxCore(t: TestContext, sessions?: Record<string, Personne>, theme?: {
27
+ logo?: string;
28
+ nom?: string;
29
+ }, apps?: AppDeclaree[], annuaire?: Annuaire): Promise<string>;
@@ -0,0 +1,112 @@
1
+ import { generateKeyPairSync, sign } from 'node:crypto';
2
+ import { once } from 'node:events';
3
+ import { createServer } from 'node:http';
4
+ // Un faux core pour les tests des apps : il sert sa clé publique et signe des jetons, fabriqués
5
+ // ici à la main, sans le code du core.
6
+ export const { privateKey: cleDuFauxCore, publicKey: clePubliqueDuFauxCore } = generateKeyPairSync('ed25519');
7
+ // Le jeton porte les groupes de la personne quand elle en a (`groupes`), et ne les porte pas sinon,
8
+ // comme celui d'un core d'avant 1.7.
9
+ export function fabriquerUnJeton(personne, app, cle = cleDuFauxCore) {
10
+ const iat = Math.floor(Date.now() / 1000);
11
+ const b64 = (valeur) => Buffer.from(JSON.stringify(valeur)).toString('base64url');
12
+ const donnees = `${b64({ alg: 'EdDSA', typ: 'JWT' })}.${b64({
13
+ iss: 'core', sub: personne.id, aud: app, email: personne.email, nom: personne.nom,
14
+ proprietaire: personne.proprietaire, ...(personne.groupes ? { groupes: personne.groupes } : {}), iat, exp: iat + 60,
15
+ })}`;
16
+ return `${donnees}.${sign(null, Buffer.from(donnees), cle).toString('base64url')}`;
17
+ }
18
+ // Un logo d'essai, à donner au faux core.
19
+ export const logoDEssai = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><rect width="10" height="10"/></svg>';
20
+ // Une app est ouverte à la personne quand ses accès l'ouvrent à l'équipe ou à l'un de ses groupes ;
21
+ // le propriétaire ouvre toute app.
22
+ function estOuverte(app, proprietaire, groupes) {
23
+ const acces = app.acces ?? (app.pour === 'proprietaire' ? [] : ['equipe']);
24
+ return proprietaire || acces.some((avec) => avec === 'equipe' || groupes.includes(avec));
25
+ }
26
+ // Ce que le core rend à `/session` des apps déclarées, pour une personne, dans sa forme
27
+ // (core/CLAUDE.md, « La personne connectée ») : les apps qui lui sont ouvertes, d'après
28
+ // ses groupes, dans l'ordre de leur titre, chacune avec ses réglages, les écrans que la personne a
29
+ // le droit de voir, avec leur chemin, et son lien (ses réglages, sinon son premier écran visible,
30
+ // sinon son lien déclaré) ; puis la barre de l'espace, leurs écrans, puis le journal, au nom de l'OS.
31
+ export function sessionDuCore(apps, proprietaire, nomDeLOS, groupes = []) {
32
+ const resolues = apps
33
+ .filter((app) => estOuverte(app, proprietaire, groupes))
34
+ .sort((une, autre) => une.titre.localeCompare(autre.titre, 'fr'))
35
+ .map((app) => {
36
+ const racine = app.lien.replace(/\/+$/, '');
37
+ const chemin = new URL(racine).pathname.replace(/\/+$/, '');
38
+ const ecrans = (app.ecrans ?? [])
39
+ .filter((ecran) => !ecran.pour || proprietaire)
40
+ .map((ecran) => ({ nom: ecran.nom, titre: ecran.titre, chemin: `${chemin}/${ecran.nom}` }));
41
+ const reglages = app.reglages === true;
42
+ return {
43
+ nom: app.nom,
44
+ titre: app.titre,
45
+ lien: reglages ? `${racine}/reglages` : ecrans[0] ? `${racine}/${ecrans[0].nom}` : app.lien,
46
+ reglages,
47
+ ecrans,
48
+ };
49
+ });
50
+ const barre = [
51
+ ...resolues.flatMap((app) => app.ecrans.map((ecran) => ({ titre: ecran.titre, chemin: ecran.chemin, app: app.titre }))),
52
+ { titre: 'Journal', chemin: '/journal', app: nomDeLOS },
53
+ ];
54
+ return { apps: resolues, barre };
55
+ }
56
+ // Lance le faux core et rend son adresse. Il sert sa clé publique, et dit qui est connecté à une
57
+ // page d'une app (`GET /session`) et à la page de l'espace (`GET /espace/session`, le même corps),
58
+ // dans la forme du core : `sessions` associe le cookie que
59
+ // présente l'app à la personne, rendue avec ses groupes (`personne.groupes`, nommés par
60
+ // l'annuaire, dans l'ordre de leur nom), les apps qui lui sont ouvertes, la barre (`sessionDuCore`,
61
+ // d'après `apps`, déclarées comme par le kit) et le thème (`theme.nom`, « Indos » par défaut, et
62
+ // la présence de son logo) ; tout autre cookie reçoit 401. Sans app déclarée, la session ne rend
63
+ // pas d'`apps`, comme un core d'avant 1.6 : aucune app n'y est fermée. Il sert l'annuaire
64
+ // (`GET /annuaire`) : `annuaire`, ou, sans lui, les personnes des sessions, actives, sans groupe.
65
+ // Il sert `theme.logo` sur `/theme/logo.svg`, lu à chaque requête (un test le change en cours de
66
+ // route), ou 404 sans logo.
67
+ export async function lancerLeFauxCore(t, sessions = {}, theme = {}, apps = [], annuaire) {
68
+ const jwk = JSON.stringify(clePubliqueDuFauxCore.export({ format: 'jwk' }));
69
+ const servi = annuaire ?? {
70
+ personnes: [...new Map(Object.values(sessions).map(({ id, nom, email }) => [id, { id, nom, email, active: true }])).values()],
71
+ groupes: [],
72
+ };
73
+ const serveur = createServer((requete, reponse) => {
74
+ if (requete.url === '/session' || requete.url === '/espace/session') {
75
+ const personne = sessions[requete.headers.cookie ?? ''];
76
+ const nom = theme.nom ?? 'Indos';
77
+ reponse.writeHead(personne ? 200 : 401, { 'content-type': 'application/json' });
78
+ if (!personne) {
79
+ reponse.end(JSON.stringify({ erreur: 'Personne n\'est connecté.' }));
80
+ return;
81
+ }
82
+ const ids = personne.groupes ?? [];
83
+ const groupes = servi.groupes
84
+ .filter((groupe) => ids.includes(groupe.id))
85
+ .map(({ id, nom: nomDuGroupe }) => ({ id, nom: nomDuGroupe }))
86
+ .sort((un, autre) => un.nom.localeCompare(autre.nom, 'fr'));
87
+ const { apps: ouvertes, barre } = sessionDuCore(apps, personne.proprietaire, nom, ids);
88
+ reponse.end(JSON.stringify({
89
+ ...personne,
90
+ groupes,
91
+ ...(apps.length ? { apps: ouvertes } : {}),
92
+ barre,
93
+ theme: { nom, logo: Boolean(theme.logo) },
94
+ }));
95
+ return;
96
+ }
97
+ if (requete.url === '/annuaire') {
98
+ reponse.writeHead(200, { 'content-type': 'application/json' });
99
+ reponse.end(JSON.stringify(servi));
100
+ return;
101
+ }
102
+ if (requete.url === '/theme/logo.svg') {
103
+ reponse.writeHead(theme.logo ? 200 : 404, { 'content-type': 'image/svg+xml' });
104
+ reponse.end(theme.logo ?? '');
105
+ return;
106
+ }
107
+ reponse.end(jwk);
108
+ }).listen(0, '127.0.0.1');
109
+ t.after(() => serveur.close());
110
+ await once(serveur, 'listening');
111
+ return `http://127.0.0.1:${serveur.address().port}`;
112
+ }
@@ -0,0 +1,36 @@
1
+ import { type Appeler } from './appeler.ts';
2
+ import type { Personne } from './jeton.ts';
3
+ export type Fiche = {
4
+ id: string;
5
+ nom: string;
6
+ type: string;
7
+ taille: number;
8
+ empreinte: string;
9
+ publie: boolean;
10
+ adresse_publique?: string;
11
+ entreprise?: boolean;
12
+ };
13
+ export type FicheDeposee = {
14
+ id: string;
15
+ nom: string;
16
+ type: string;
17
+ taille: number;
18
+ empreinte: string;
19
+ deja_entre: boolean;
20
+ entreprise?: boolean;
21
+ };
22
+ export declare class RefusDeFichiers extends Error {
23
+ constructor(texte: string);
24
+ }
25
+ export declare function deposerUnFichier(appeler: Appeler | undefined, personne: Personne, fichier: {
26
+ nom: string;
27
+ type?: string | null;
28
+ octets: Uint8Array;
29
+ entreprise?: boolean;
30
+ }): Promise<FicheDeposee>;
31
+ export declare function demanderUnFichier(appeler: Appeler | undefined, personne: Personne, id: string): Promise<{
32
+ fiche: Fiche;
33
+ lien: string;
34
+ }>;
35
+ export declare function donnerALEntreprise(appeler: Appeler | undefined, personne: Personne, id: string): Promise<Fiche>;
36
+ export declare function telechargerUnFichier(fiche: Pick<Fiche, 'nom' | 'taille' | 'empreinte'>, lien: string): Promise<Buffer>;
@@ -0,0 +1,109 @@
1
+ import { createHash } from 'node:crypto';
2
+ import { estUnRefus } from './appeler.js';
3
+ // Le refus d'un outil de fichiers (`estUnRefus`), son texte cité. C'est un échec de l'app qui
4
+ // appelle, jamais son refus : la classe ne dérive pas de `Refus`.
5
+ export class RefusDeFichiers extends Error {
6
+ constructor(texte) {
7
+ super(`fichiers a refusé : ${texte}`);
8
+ }
9
+ }
10
+ // Un fichier de 50 Mo, le plafond de fichiers, passe en deux minutes.
11
+ const delai = 120_000;
12
+ // Dépose un fichier dans les fichiers de la personne : le lien d'envoi demandé par `televerser`,
13
+ // les octets envoyés, la fiche rendue par le lien. Le nom est coupé à 200 caractères ; un type que
14
+ // fichiers n'accepte pas est omis, et fichiers lit alors le type aux octets. `entreprise` le fait
15
+ // entrer comme une pièce de l'entreprise.
16
+ export async function deposerUnFichier(appeler, personne, fichier) {
17
+ const nom = fichier.nom.slice(0, 200);
18
+ const type = typeAccepte(fichier.type);
19
+ const arguments_ = { nom, ...(type ? { type } : {}), ...(fichier.entreprise ? { entreprise: true } : {}) };
20
+ const { lien } = lireLeJson(await appelerFichiers(appeler, 'televerser', arguments_, personne));
21
+ if (typeof lien !== 'string') {
22
+ throw new Error('fichiers n\'a pas rendu de lien d\'envoi');
23
+ }
24
+ const envoi = await fetch(lien, { method: 'PUT', body: new Uint8Array(fichier.octets), signal: AbortSignal.timeout(delai) });
25
+ const corps = lireLeJson(await envoi.text());
26
+ if (!envoi.ok) {
27
+ throw new Error(`fichiers refuse l'envoi (${envoi.status}${typeof corps.erreur === 'string' ? `, ${corps.erreur.replace(/\.$/, '')}` : ''})`);
28
+ }
29
+ if (typeof corps.id !== 'string') {
30
+ throw new Error('fichiers n\'a pas rendu de fiche');
31
+ }
32
+ return corps;
33
+ }
34
+ // La fiche d'un fichier de la personne et son lien de lecture, demandés par `telecharger`. L'app
35
+ // lit la fiche avant les octets : sa taille, pour son plafond ; `publie`, pour ce qui le demande.
36
+ export async function demanderUnFichier(appeler, personne, id) {
37
+ const texte = await appelerFichiers(appeler, 'telecharger', { id }, personne);
38
+ const { fiche, lien } = lireLeJson(texte);
39
+ if (typeof fiche?.nom !== 'string' || typeof fiche.taille !== 'number' || typeof fiche.empreinte !== 'string' || typeof lien !== 'string') {
40
+ // Un texte qui n'est pas du JSON dit pourquoi fichiers ne rend pas le fichier.
41
+ throw new Error(`fichiers ne rend pas le fichier ${id}${texte && !texte.startsWith('{') ? ` : ${texte}` : ''}`);
42
+ }
43
+ return { fiche: fiche, lien };
44
+ }
45
+ // Donne une fiche de la personne à l'entreprise, par `donner_a_l_entreprise`, et rend sa fiche ;
46
+ // une pièce de l'entreprise est rendue telle quelle.
47
+ export async function donnerALEntreprise(appeler, personne, id) {
48
+ const texte = await appelerFichiers(appeler, 'donner_a_l_entreprise', { id }, personne);
49
+ const fiche = lireLeJson(texte);
50
+ if (typeof fiche.id !== 'string' || fiche.entreprise !== true) {
51
+ throw new Error(`fichiers ne donne pas le fichier ${id} à l'entreprise${texte && !texte.startsWith('{') ? ` : ${texte}` : ''}`);
52
+ }
53
+ return fiche;
54
+ }
55
+ // Les octets d'un fichier, lus au lien que rend `demanderUnFichier`, à l'empreinte SHA-256 de sa
56
+ // fiche. Jamais plus que la taille que la fiche annonce : un contenu plus long n'aurait pas son
57
+ // empreinte, et le plafond que l'app vérifie sur la fiche borne ce qu'elle lit.
58
+ export async function telechargerUnFichier(fiche, lien) {
59
+ const reponse = await fetch(lien, { signal: AbortSignal.timeout(delai) });
60
+ if (!reponse.ok) {
61
+ const { erreur } = lireLeJson(await reponse.text().catch(() => ''));
62
+ throw new Error(`fichiers refuse la lecture de « ${fiche.nom} » (${reponse.status}${typeof erreur === 'string' ? `, ${erreur.replace(/\.$/, '')}` : ''})`);
63
+ }
64
+ const morceaux = [];
65
+ let taille = 0;
66
+ if (reponse.body) {
67
+ for await (const morceau of reponse.body) {
68
+ taille += morceau.length;
69
+ if (taille > fiche.taille) {
70
+ throw new Error(`« ${fiche.nom} » n'a pas l'empreinte de sa fiche`);
71
+ }
72
+ morceaux.push(morceau);
73
+ }
74
+ }
75
+ const octets = Buffer.concat(morceaux);
76
+ if (createHash('sha256').update(octets).digest('hex') !== fiche.empreinte) {
77
+ throw new Error(`« ${fiche.nom} » n'a pas l'empreinte de sa fiche`);
78
+ }
79
+ return octets;
80
+ }
81
+ // Le texte du résultat d'un outil de fichiers : son refus lève `RefusDeFichiers`, son échec une
82
+ // erreur qui cite le texte reçu.
83
+ async function appelerFichiers(appeler, outil, arguments_, personne) {
84
+ if (!appeler) {
85
+ throw new Error('l\'appel aux autres apps n\'est pas ouvert à cette app');
86
+ }
87
+ const resultat = await appeler('fichiers', outil, arguments_, personne);
88
+ const texte = resultat.content[0]?.text ?? '';
89
+ if (estUnRefus(resultat)) {
90
+ throw new RefusDeFichiers(texte);
91
+ }
92
+ if (resultat.isError) {
93
+ throw new Error(texte || `fichiers_${outil} a échoué`);
94
+ }
95
+ return texte;
96
+ }
97
+ // Le type MIME que le schéma de `televerser` accepte, sinon aucun.
98
+ function typeAccepte(type) {
99
+ return type && type.length <= 100 && /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/.test(type) ? type : undefined;
100
+ }
101
+ function lireLeJson(texte) {
102
+ try {
103
+ const valeur = JSON.parse(texte);
104
+ return typeof valeur === 'object' && valeur !== null ? valeur : {};
105
+ }
106
+ catch {
107
+ return {};
108
+ }
109
+ }
package/src/jeton.d.ts ADDED
@@ -0,0 +1,10 @@
1
+ export type Personne = {
2
+ id: string;
3
+ email: string;
4
+ nom: string;
5
+ proprietaire: boolean;
6
+ groupes?: string[];
7
+ };
8
+ export declare class JetonRefuse extends Error {
9
+ }
10
+ export declare function creerLeVerificateur(app: string, adresseDuCore?: string | undefined, horloge?: () => number): (jeton: string) => Promise<Personne>;
package/src/jeton.js ADDED
@@ -0,0 +1,96 @@
1
+ import { createPublicKey, verify } from 'node:crypto';
2
+ export class JetonRefuse extends Error {
3
+ }
4
+ // Vérifie le jeton court que le core joint à chaque appel d'une app (docs/architecture.md, « Le
5
+ // contrat entre le MCP et une app ») : un JWT signé en Ed25519, valable une minute, pour cette app.
6
+ // La clé publique vient du core, à CORE_ADRESSE ; elle reste en mémoire, et se relit quand une
7
+ // signature échoue (le core a changé de clé), une fois par minute au plus.
8
+ // `horloge` ne sert qu'aux tests.
9
+ export function creerLeVerificateur(app, adresseDuCore = process.env.CORE_ADRESSE, horloge = Date.now) {
10
+ if (!adresseDuCore) {
11
+ throw new Error('La variable CORE_ADRESSE manque : l\'adresse interne du core vient du kit.');
12
+ }
13
+ const adresseDeLaCle = new URL('/cle-publique', adresseDuCore);
14
+ let cle;
15
+ let lueLe = 0;
16
+ function clePublique() {
17
+ if (!cle) {
18
+ lueLe = horloge();
19
+ cle = lireLaClePublique(adresseDeLaCle).catch((erreur) => {
20
+ cle = undefined; // le core n'a pas répondu : on redemandera au prochain jeton
21
+ throw erreur;
22
+ });
23
+ }
24
+ return cle;
25
+ }
26
+ async function signatureValide(donnees, signature) {
27
+ if (estValide(donnees, await clePublique(), signature)) {
28
+ return true;
29
+ }
30
+ if (horloge() - lueLe < 60_000) {
31
+ return false;
32
+ }
33
+ cle = undefined;
34
+ return estValide(donnees, await clePublique(), signature);
35
+ }
36
+ return async function verifier(jeton) {
37
+ const parties = jeton.split('.');
38
+ if (parties.length !== 3) {
39
+ throw new JetonRefuse('Le jeton n\'a pas la forme d\'un JWT.');
40
+ }
41
+ const [entete, charge, signature] = parties;
42
+ // L'algorithme est fixé ici, jamais lu dans l'en-tête : seul Ed25519 est accepté.
43
+ if (lireEnJson(entete).alg !== 'EdDSA') {
44
+ throw new JetonRefuse('Le jeton n\'est pas signé en Ed25519.');
45
+ }
46
+ if (!(await signatureValide(Buffer.from(`${entete}.${charge}`), Buffer.from(signature, 'base64url')))) {
47
+ throw new JetonRefuse('La signature du jeton ne vient pas du core.');
48
+ }
49
+ const contenu = lireEnJson(charge);
50
+ if (contenu.iss !== 'core' || contenu.aud !== app) {
51
+ throw new JetonRefuse(`Le jeton n'est pas destiné à ${app}.`);
52
+ }
53
+ if (typeof contenu.exp !== 'number' || contenu.exp * 1000 <= horloge()) {
54
+ throw new JetonRefuse('Le jeton a expiré.');
55
+ }
56
+ const { sub, email, nom, proprietaire, groupes } = contenu;
57
+ if (typeof sub !== 'string' || typeof email !== 'string' || typeof nom !== 'string' || typeof proprietaire !== 'boolean') {
58
+ throw new JetonRefuse('Le jeton ne nomme pas la personne.');
59
+ }
60
+ if (groupes === undefined) {
61
+ return { id: sub, email, nom, proprietaire };
62
+ }
63
+ if (!Array.isArray(groupes) || !groupes.every((groupe) => typeof groupe === 'string')) {
64
+ throw new JetonRefuse('Le jeton ne dit pas les groupes de la personne.');
65
+ }
66
+ return { id: sub, email, nom, proprietaire, groupes };
67
+ };
68
+ }
69
+ function estValide(donnees, cle, signature) {
70
+ try {
71
+ return verify(null, donnees, cle, signature);
72
+ }
73
+ catch {
74
+ return false;
75
+ }
76
+ }
77
+ async function lireLaClePublique(adresse) {
78
+ const reponse = await fetch(adresse, { signal: AbortSignal.timeout(5000) });
79
+ if (!reponse.ok) {
80
+ throw new Error(`Le core ne donne pas sa clé publique : ${reponse.status}.`);
81
+ }
82
+ const jwk = await reponse.json();
83
+ if (jwk.kty !== 'OKP' || jwk.crv !== 'Ed25519') {
84
+ throw new Error('La clé publique du core n\'est pas une clé Ed25519.');
85
+ }
86
+ return createPublicKey({ key: jwk, format: 'jwk' });
87
+ }
88
+ function lireEnJson(partie) {
89
+ try {
90
+ const valeur = JSON.parse(Buffer.from(partie, 'base64url').toString('utf8'));
91
+ return typeof valeur === 'object' && valeur !== null ? valeur : {};
92
+ }
93
+ catch {
94
+ throw new JetonRefuse('Le jeton est illisible.');
95
+ }
96
+ }
package/src/liens.d.ts ADDED
@@ -0,0 +1,10 @@
1
+ export declare const dureeDUnLien = 600;
2
+ export declare function signerUnLien<C extends object>(cle: Buffer, sorte: string, charge: C, maintenant?: number): string;
3
+ export declare function lireUnLien<C extends object>(cle: Buffer, sorte: string, jeton: string, maintenant?: number): (C & {
4
+ sorte: string;
5
+ expire: number;
6
+ }) | {
7
+ refus: 403 | 404 | 410;
8
+ };
9
+ export declare function enTetesDUnTelechargement(nom: string, taille?: number): Record<string, string>;
10
+ export declare function encoderLeNom(nom: string): string;
package/src/liens.js ADDED
@@ -0,0 +1,52 @@
1
+ import { createHmac, timingSafeEqual } from 'node:crypto';
2
+ import { deriver } from './deriver.js';
3
+ // Les liens signés d'une app (bibliotheque/CLAUDE.md, « Les pièces ») : dix minutes, une charge
4
+ // signée, une clé propre à chaque sorte, tirée de la clé de l'app ; rien n'est gardé en base.
5
+ export const dureeDUnLien = 600;
6
+ function cleDeLaSorte(cle, sorte) {
7
+ return deriver(cle, `lien/${sorte}`);
8
+ }
9
+ // Le jeton d'un lien : la charge, sa sorte et son expiration en JSON, en base64url, puis son
10
+ // HMAC-SHA256 par la clé de la sorte.
11
+ export function signerUnLien(cle, sorte, charge, maintenant = Date.now()) {
12
+ const contenu = Buffer.from(JSON.stringify({ ...charge, sorte, expire: Math.floor(maintenant / 1000) + dureeDUnLien })).toString('base64url');
13
+ const signature = createHmac('sha256', cleDeLaSorte(cle, sorte)).update(contenu).digest('base64url');
14
+ return `${contenu}.${signature}`;
15
+ }
16
+ // La charge d'un lien de cette sorte, ou le statut qui le refuse : 404 s'il n'a pas la forme d'un
17
+ // lien, 403 si sa signature est fausse (ou s'il est d'une autre sorte), 410 s'il a expiré.
18
+ export function lireUnLien(cle, sorte, jeton, maintenant = Date.now()) {
19
+ const [contenu, signature, ...reste] = jeton.split('.');
20
+ if (!contenu || !signature || reste.length > 0 || !/^[A-Za-z0-9_-]+$/.test(contenu + signature)) {
21
+ return { refus: 404 };
22
+ }
23
+ const attendue = createHmac('sha256', cleDeLaSorte(cle, sorte)).update(contenu).digest();
24
+ const recue = Buffer.from(signature, 'base64url');
25
+ if (recue.length !== attendue.length || !timingSafeEqual(recue, attendue)) {
26
+ return { refus: 403 };
27
+ }
28
+ const charge = JSON.parse(Buffer.from(contenu, 'base64url').toString('utf8'));
29
+ if (charge.sorte !== sorte) {
30
+ return { refus: 403 };
31
+ }
32
+ if (typeof charge.expire !== 'number' || charge.expire * 1000 <= maintenant) {
33
+ return { refus: 410 };
34
+ }
35
+ return charge;
36
+ }
37
+ // Les en-têtes d'octets servis en pièce jointe, sans jamais les exécuter : un type neutre, le nom
38
+ // du fichier, ni devinette du type, ni script, ni cache.
39
+ export function enTetesDUnTelechargement(nom, taille) {
40
+ return {
41
+ 'content-type': 'application/octet-stream',
42
+ ...(taille === undefined ? {} : { 'content-length': String(taille) }),
43
+ 'content-disposition': `attachment; filename*=UTF-8''${encoderLeNom(nom)}`,
44
+ 'x-content-type-options': 'nosniff',
45
+ 'content-security-policy': 'sandbox',
46
+ 'cache-control': 'no-store',
47
+ };
48
+ }
49
+ // Le nom d'un fichier pour `filename*` (RFC 5987) : encodeURIComponent laisse passer ' ( ) *.
50
+ export function encoderLeNom(nom) {
51
+ return encodeURIComponent(nom).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
52
+ }
package/src/mcp.d.ts ADDED
@@ -0,0 +1,20 @@
1
+ import type { IncomingMessage, ServerResponse } from 'node:http';
2
+ import { type Tool } from '@modelcontextprotocol/server';
3
+ import { type Personne } from './jeton.ts';
4
+ export declare class Refus extends Error {
5
+ }
6
+ export type Outil = {
7
+ nom: string;
8
+ description: string;
9
+ schema: Tool['inputSchema'];
10
+ pour?: (personne: Personne) => boolean;
11
+ executer: (arguments_: Record<string, unknown>, personne: Personne) => Promise<string> | string;
12
+ };
13
+ export declare function creerLeMcp(options: {
14
+ app: string;
15
+ version: string;
16
+ instructions: string;
17
+ outils: Outil[];
18
+ adresseDuCore?: string;
19
+ adresse?: string;
20
+ }): (requete: IncomingMessage, reponse: ServerResponse) => Promise<void>;