@indos/bibliotheque 4.3.0 → 4.5.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/CLAUDE.md CHANGED
@@ -2,54 +2,39 @@
2
2
 
3
3
  Le code que les apps partagent, intégré à l'image de chaque app au build, et le contrat d'une app : les règles que toute app suit, que le core, la bibliothèque, le kit ou les tests vérifient. À lire en entier avant d'écrire ou de changer une app.
4
4
 
5
- Sa version est celle de son `manifeste.json`, publiée sur npm sous `@indos/bibliotheque` ; `CHANGELOG.md` dit ce que chaque version change pour une app. Une app du catalogue, dans `apps/<nom>/` d'ind-os/sources, la cite par un lien de dossier ; une app du client, son propre dépôt cloné dans `code/<nom>/` du dépôt de l'OS, cite le paquet à une version exacte (« Comment une app s'en sert »).
6
-
7
- ## Commandes
8
-
9
- ```sh
10
- # dans ind-os/sources, depuis bibliotheque/, avant toute app du catalogue
11
- npm ci
12
- # depuis la racine du dépôt d'un OS : créer une app du client à partir du modèle
13
- node bibliotheque/bin/bibliotheque.ts creer-une-app <nom>
14
- # depuis le dossier de l'app (apps/<nom>/ ou code/<nom>/)
15
- npm install # la première fois, puis commiter package-lock.json
16
- npm test # construit la page, vérifie les types, tests de Node puis de la page
17
- npm run build # la page dans dist/
18
- npm run dev # la page à chaud sur localhost:5173
19
- ```
5
+ Sa version est celle de son `manifeste.json`, publiée sur npm sous `@indos/bibliotheque` ; `CHANGELOG.md` dit ce que chaque version change pour une app. Une app du catalogue, dans `apps/<nom>/` d'ind-os/sources, la cite par un lien de dossier (`apps/CLAUDE.md`) ; une app du client, son propre dépôt cloné dans `code/<nom>/` du dépôt de l'OS, cite le paquet à une version exacte (« Comment une app s'en sert »).
20
6
 
21
7
  ## La forme d'une app
22
8
 
23
9
  Le dossier de l'app porte :
24
10
 
25
11
  - `manifeste.json` :
26
- - `nom` : celui du dossier, `^[a-z][a-z0-9-]*$`, son chemin `https://<domaine>/<nom>` et son entrée dans `os.json`. Il ne change plus une fois l'app installée.
27
- - `titre` ; `description`, la phrase de sa carte, pour le dirigeant, sans mot technique ; `famille`, facultative, 1 à 40 caractères ; `version`, `<majeure>.<mineure>.<correctif>`.
28
- - `dependances` : les bornes npm des pièces, dont le core. `>=1.1` pour appeler une autre app, `>=1.2 <3` pour lire le logo, `>=1.7 <3` pour une app réservée ou qui partage, `>=2.3 <3` pour un logo, une documentation ou des réglages, `>=2.9 <3` pour une app à page. Le kit refuse une montée sur un core plus ancien.
12
+ - `nom` : celui du dossier, en minuscules, chiffres et tirets simples (`^[a-z][a-z0-9]*(-[a-z0-9]+)*$`), son chemin `https://<domaine>/<nom>` et son entrée dans `os.json`. Il ne prend ni un chemin du core ni le nom d'une app d'Indos, et ne change plus une fois l'app installée.
13
+ - `titre` ; `description`, la phrase de sa carte, pour la personne, sans mot technique ; `famille`, facultative ; `version`, `<majeure>.<mineure>.<correctif>`.
14
+ - `dependances` : pour chaque pièce que l'app demande, dont le core, une borne `>=a.b[.c]`, suivie ou non de ` <x[.y[.z]]` : `"core": ">=2.9 <3"` pour une app à page. Le kit refuse de poser l'app sur un core qui ne tient pas sa borne, et de monter le core au-delà.
29
15
  - `appelle` : les apps dont elle appelle les outils (`["fichiers"]`). Une app appelée n'est pas une dépendance : sans elle, l'app dit ce qu'elle n'a pas pu faire.
30
16
  - `pour`, `ecrans`, `reglages` (« Qui ouvre une app », « Les pages d'une app »).
31
17
  - Une app du client ne déclare pas `sousDomaine` : le kit le refuse.
32
18
  - `Dockerfile` et `Dockerfile.dockerignore` côte à côte (`**/node_modules`, `**/dist`, `.git`). Aucun `.dockerignore` à la racine du dépôt. Le modèle est `modeles/app-du-client/Dockerfile` :
33
- - une app du client se construit sur son seul dossier (`docker build .`), la bibliothèque prise du paquet, par la CI de son dépôt (`.github/workflows/publier-l-image.yml`, du modèle), qui pousse l'image sur ghcr.io ; une app du catalogue reproduit l'arbre du dépôt (`/depot/bibliotheque`, `/depot/apps/<nom>`) et ne prend, hors de son dossier, que `bibliotheque/` ;
34
- - elle ne prend aucun fichier de `bibliotheque/tests/`, absent chez un client (la CI le vérifie) ;
19
+ - une app du client se construit sur son seul dossier (`docker build .`), la bibliothèque prise du paquet, par la CI de son dépôt (`.github/workflows/publier-l-image.yml`, du modèle), qui pousse l'image sur ghcr.io ;
35
20
  - l'étape `tests` lance `npm test` et l'image prend `dist/` de cette étape : un test qui échoue arrête la construction ;
36
- - les étapes des tests sont à la plateforme du poste (`FROM --platform=$BUILDPLATFORM <image de Node>`), l'image à celle du serveur ;
37
- - l'image de Node est citée par sa version et son empreinte ; un seul `EXPOSE`, un `HEALTHCHECK` sur `/sante`, `USER node`.
21
+ - l'image de Node est citée par sa version et son empreinte ; un seul `EXPOSE`, `USER node` ;
22
+ - une app du client a de plus un `HEALTHCHECK` sur `/sante`, et ses étapes de tests à la plateforme du poste (`FROM --platform=$BUILDPLATFORM <image de Node>`), l'image à celle du serveur.
38
23
  - `package.json` et `package-lock.json` : un paquet autonome, chaque outil à une version exacte, sans espace de travail npm. Le serveur est en TypeScript exécuté par Node, sans build.
39
24
  - `src/` (le serveur), `migrations/` (`.sql`), `tests/`, `espace/` (la page), `dist/` (hors de git).
40
25
  - `GUIDE.md` : le texte d'usage pour Claude, les instructions MCP de l'app. Son premier paragraphe la présente dans les instructions du core ; le texte entier est rendu par l'outil `guide` du core.
41
26
  - `DOCUMENTATION.md`, facultatif : pour la personne, rendu à `/documentation/<nom>` en Markdown restreint (`##`, `###`, paragraphes, listes, étapes, gras, code, liens).
42
27
  - `logo.svg`, facultatif : 24×24, l'objet en graphite `currentColor`, en formes simples, le geste de l'agent tracé à la main au jaune `#F0B429` (entouré, coche, gribouillis, souligné, flèche), le même geste pour une même fonction. Sans logo, la carte porte l'initiale du titre.
43
28
 
44
- Une app écoute sur `PORT`, répond 200 sur `GET /sante`, s'arrête en huit secondes au plus sur `docker stop`, et garde tout dans sa base, sans volume. Elle reçoit `DATABASE_URL`, `CLE` (32 octets en base64), `ADRESSE` (`https://<domaine>/<nom>`), `CORE_ADRESSE` et `CLE_D_APPEL`.
29
+ Une app écoute sur `PORT`, répond 200 sur `GET /sante`, s'arrête en huit secondes au plus sur `docker stop`, et garde tout dans sa base ou au bucket de l'OS, sans volume. Elle reçoit `DATABASE_URL`, `CLE` (32 octets en base64), `ADRESSE` (`https://<domaine>/<nom>`), `CORE_ADRESSE` et `CLE_D_APPEL`, sa clé d'appel, que la bibliothèque transmet telle quelle au core (`Bearer <CLE_D_APPEL>`) pour appeler, notifier et lire l'annuaire.
45
30
 
46
- Ce que le kit lit d'une app du client, au commit publié et poussé, jamais depuis les fichiers du poste : son dépôt, rien d'autre. Il refuse un manifeste hors de forme avant tout geste, et refuse de publier quand `indos/` n'a plus l'empreinte que dit `indos.version`.
31
+ Ce que le kit lit d'une app du client, au commit publié et poussé, jamais depuis les fichiers du poste : son `manifeste.json`, son `logo.svg`, sa `DOCUMENTATION.md`, et l'image que la CI de son dépôt a poussée pour ce commit. Il refuse un manifeste dont le `nom` n'est pas celui de l'app ou qui déclare `sousDomaine`, et une image sans `HEALTHCHECK` ou qui n'expose pas un seul port.
47
32
 
48
- ## Qui ouvre une app
33
+ ### Qui ouvre une app
49
34
 
50
35
  Le core tient l'accès à une app. Sans `pour`, elle s'ouvre à toute l'équipe à sa première déclaration ; `"pour": "proprietaire"` la ferme au propriétaire seul jusqu'à ce qu'il l'ouvre dans « Équipe ». Une montée ne change pas ce réglage. Une app fermée à une personne n'existe pas pour elle : ni barre, ni outils, ni `/outils`, et ses pages lui répondent introuvables. L'app ne refait pas ce contrôle. Dans une app ouverte, `pour` sur un outil ou un écran réserve ce geste au propriétaire.
51
36
 
52
- ## Les pages d'une app
37
+ ### Les pages d'une app
53
38
 
54
39
  - `ecrans` : `[{ nom, titre, pour }]`, dans l'ordre de la barre et des onglets. `nom` est le chemin sous l'app : non vide, sans `/` au début ni à la fin, sans segment vide, `.`, `..`, espace, `?`, `#`, `\` ni `%` ; son premier segment n'est ni `reglages`, `outils`, `mcp`, `sante` ni `espace`. `pour: "proprietaire"` : le core ne le montre qu'au propriétaire, l'app reste juge sur sa page.
55
40
  - `reglages: true`, ou `{ "pour": "proprietaire" }` : l'écran `/<app>/reglages`. Celui d'une app à comptes branchés est `EcranDesComptes`.
@@ -57,7 +42,23 @@ Le core tient l'accès à une app. Sans `pour`, elle s'ouvre à toute l'équipe
57
42
  - Les scripts et les feuilles sont servis par l'app, de son chemin : aucun script en ligne, jamais un script qu'elle n'a pas écrit.
58
43
  - Une page sans coquille se sert sous le chemin de l'app sans rien déclarer.
59
44
 
60
- ## Le démarrage et l'arrêt d'une app
45
+ ### Comment une app s'en sert
46
+
47
+ Une app du client cite le paquet publié à une version exacte : `"@indos/bibliotheque": "<version>"`. npm installe ses dépendances d'exécution et ses dépendances de pair (React, TanStack, Tailwind, Vite, Vitest, leurs types) ; l'image ne garde aucune dépendance de pair (`npm ci --omit=dev --omit=peer`). Une version publiée ne change plus : l'app ne prend la suivante qu'en changeant ce numéro.
48
+
49
+ ### Une app du client
50
+
51
+ Le modèle, `modeles/app-du-client/`, est une app à page qui ne prend que la bibliothèque : une migration, deux outils, un écran, ses tests, son `Dockerfile` et son `Dockerfile.dockerignore`, sans `package-lock.json`. `creer-une-app <nom>` le copie dans `code/<nom>/` du dépôt d'un OS, y pose le nom et cite le paquet à la version de `manifeste.json` ; elle refuse un dossier qui existe et un nom hors de sa forme (« La forme d'une app »), et se lance avant toute installation.
52
+
53
+ Les gestes sont ceux du kit, par ses skills `indos-creer-une-app` et `indos-publier-une-app`. Une app se développe sur une branche de son dépôt ; le clone de l'OS reste sur `main`, d'où elle se publie. La première publication écrit l'entrée de l'app dans `os.json` (`kit publier <app>`) : ni `os.json` ni `apps/` ne se modifient à la main.
54
+
55
+ ### La note des versions
56
+
57
+ `CHANGELOG.md` s'écrit pour le développeur d'une app du client : une section `## <version>` par version, une rubrique « Ruptures » quand une version demande un geste dans les apps (et, pour une majeure, le core qu'elle demande), et « Pour monter ». Monter une app : sur une branche de son dépôt, les gestes des ruptures de chaque version sautée, puis la version du paquet dans `package.json`, `npm install` et `npm test` dans l'app.
58
+
59
+ ## Le serveur
60
+
61
+ ### Le démarrage et l'arrêt d'une app
61
62
 
62
63
  `src/demarrer.ts` est un appel à `demarrerLApp({ dossier, migrations, traiter, chemin })` (`@indos/bibliotheque/app`), sur le modèle de `modeles/app-du-client/src/demarrer.ts`.
63
64
 
@@ -68,29 +69,33 @@ Le core tient l'accès à une app. Sans `pour`, elle s'ouvre à toute l'équipe
68
69
  - Une erreur d'un traitement s'écrit au journal ; la requête reçoit la page simple en 500 pour une navigation, `{ "erreur": … }` en 500 sinon.
69
70
  - Sur `SIGTERM` ou `SIGINT` : le serveur cesse d'accepter, flux et connexions se coupent, puis `avantDeQuitter` écrit les choses ouvertes. Aucune requête ne reçoit de réponse pendant ou après `avantDeQuitter` : une écriture confirmée est une écriture qu'il enregistre. Au-delà de huit secondes, l'app quitte en échec.
70
71
 
71
- ## Les pièces
72
+ ### Les entrées de la bibliothèque
72
73
 
73
- Une entrée de `exports` par fonction (`package.json`), nommée par ce qu'elle fait : `@indos/bibliotheque/<entrée>`. Le serveur est dans les `.ts` de la racine de `src/`, le navigateur dans `src/ui/` et `src/espace/`.
74
+ Une entrée de `exports` par fonction (`package.json`), nommée par ce qu'elle fait : `@indos/bibliotheque/<entrée>`. Le serveur est dans les `.ts` de la racine de `src/`, le navigateur dans `src/ui/`, `src/espace/` et `src/direct/page.ts`.
74
75
 
75
- - Le code que l'image lance n'importe aucune dépendance de développement : `faux-core`, `base-d-essai`, `espace-d-essai`, `src/vite.ts` et le code du navigateur restent hors des autres entrées du serveur.
76
76
  - `deriver(cle, contexte)` (HKDF-SHA256, 32 octets) et les liens signés de `liens` (`signerUnLien(cle, sorte, charge)`, dix minutes, rien en base) ont des formats figés : le kit refait la même dérivation sans importer la bibliothèque, et un lien déjà donné se lit toujours.
77
77
  - Des octets servis en pièce jointe prennent `enTetesDUnTelechargement` (`sandbox`, `nosniff`).
78
78
  - `identifiant(id)` rend l'UUID en minuscules, ou rien : l'app répond alors « absente » sans demander à la base.
79
79
  - Le type d'un fichier qui entre se lit par `typeDuFichier`.
80
80
  - Le jeton du core (`jeton`) est vérifié en Ed25519 seul, pour l'app visée, une minute.
81
81
 
82
- ## Le MCP d'une app
82
+ ### Le MCP d'une app
83
83
 
84
- `creerLeMcp({ app, version, instructions, outils, adresse })` sert `/mcp` (Streamable HTTP sans état) et `POST /outils/<nom>`. Chaque outil déclare son schéma d'entrée et, s'il n'est pas pour tous, `pour`. Le jeton du core se vérifie à chaque requête (401 sinon, 503 sans `CORE_ADRESSE` ou si le core ne répond pas) ; l'app ne montre et n'exécute que les outils permis à la personne. Des arguments hors schéma donnent un résultat en erreur.
84
+ `creerLeMcp({ app, version, instructions, outils, adresse, adresseDuCore })` sert `/mcp` (Streamable HTTP sans état) et `POST /outils/<nom>`. Chaque outil déclare son schéma d'entrée et, s'il n'est pas pour tous, `pour`. Le jeton du core se vérifie à chaque requête (401 sinon, 503 sans `CORE_ADRESSE` ou si le core ne répond pas) ; l'app ne montre et n'exécute que les outils permis à la personne. Des arguments hors schéma donnent un résultat en erreur.
85
85
 
86
+ - Chaque outil déclare son `titre`, court, à l'infinitif, dans les mots de la personne (« Supprimer un lien »), et sa `sorte` (`SorteDUnOutil`), que `tools/list` rend en `title` et en annotations MCP, d'où le client de Claude range les outils et décide de l'accord :
87
+ - `lecture`, il ne change rien : `readOnlyHint: true` ;
88
+ - `ecriture`, il crée ou modifie, et cela se reprend : `readOnlyHint: false`, `destructiveHint: false` ;
89
+ - `definitif`, il supprime, émet, envoie, publie, élargit un partage ou donne : `readOnlyHint: false`, `destructiveHint: true`.
90
+ Un outil qui porte plusieurs gestes déclare la sorte la plus forte. Un outil sans titre ni sorte se liste sans `title` ni annotations.
86
91
  - Un geste définitif (supprimer, publier, émettre, annuler) prend `confirmer: true` ; sans lui, un `Refus` qui dit quoi demander à la personne.
87
92
  - Un argument manquant ou un choix à faire est un refus qui nomme les choix (« Préciser `compte` parmi : … ») ; un choix unique se prend sans demander.
88
93
 
89
- ### Un écran appelle ses outils
94
+ #### Un écran appelle ses outils
90
95
 
91
96
  L'app route `POST /outils/<nom>` vers `creerLeMcp`, comme `/mcp`. Les contrôles d'un geste d'écran s'appliquent (méthode, `Origin`, personne, corps), puis : outil hors de portée 403, inconnu 404, arguments hors schéma 400, refus 422 avec son texte, échec 500 sans sa cause, sinon 200 et le résultat MCP. L'outil reçoit la personne de la session, ses groupes compris.
92
97
 
93
- ## Un refus
98
+ ### Un refus
94
99
 
95
100
  Un outil qui ne fait pas ce qu'on lui demande ne rend jamais un succès.
96
101
 
@@ -99,30 +104,23 @@ Un outil qui ne fait pas ce qu'on lui demande ne rend jamais un succès.
99
104
  - Un geste qui rattrape une erreur pour la reformuler laisse passer un `Refus` tel quel.
100
105
  - `appeler` rend le résultat d'une autre app sans lever : `isError` dit qu'il n'a pas abouti, `estUnRefus` que c'est un refus. L'app qui appelle en fait un échec à elle, par `Error`, en citant le texte reçu.
101
106
 
102
- ## Un outil qui montre une image
107
+ ### Un outil qui montre une image
103
108
 
104
109
  `executer` rend un texte ou un contenu MCP `{ content: [...] }` (`ResultatDOutil`), texte et images en base64, passé tel quel. Un écran n'en lit que le texte (`texteDe`). Un fichier entre et sort par un lien de dix minutes : seule une image réduite passe par MCP.
105
110
 
106
- ## Les transactions
107
-
108
- `enTransaction(base, geste, { verrou })` : tout ou rien, `geste(client)` lit et écrit par `client`, jamais par le pool, qui peut n'avoir qu'une connexion. Une erreur annule tout et passe telle quelle. `verrou`, une clé ou une liste, se prend d'abord, plusieurs clés dans l'ordre de leur nom ; c'est `pg_advisory_xact_lock(hashtextextended(<clé>, 0))`, la même clé que prend un déclencheur de la base pour la même chose.
109
-
110
- ## La recherche sans accents
111
-
112
- Un texte cherché ignore accents et casse, par la même normalisation en SQL (`sansAccentsEnSql(expression)`, `motifSansAccents(texte)` pour `like`) et en JavaScript (`sansAccents`). L'expression SQL est écrite par l'app, jamais par la personne. La base est en UTF-8.
113
-
114
- ## Les formats
111
+ ### Les gestes d'écran
115
112
 
116
- `@indos/bibliotheque/format`, jamais `Intl` ni `toLocaleString` : l'écran, un PDF et un courrier écrivent la même chose. Les jours et les heures sont à l'heure de `Europe/Zurich` ; les milliers prennent l'apostrophe droite.
117
-
118
- - `jour` (« 28.10.2026 »), `jourEtHeure`, `tempsEcoule`, `nombre` (« 1'234 »).
119
- - `montant` (« CHF 12'400.00 ») et `montantRond` écrivent « **** » quand la page masque les montants ; `montantEnClair` ne masque jamais, pour un formulaire et la question d'un geste. Un serveur ne masque jamais.
113
+ Un geste d'écran est un appel de la page à sa pièce, en JSON, avec la session : l'appel d'un outil, ou un geste que Claude ne doit pas voir (un secret), `POST /<app>/espace/<geste>`, sans extension, routé avant `/espace/…`. Il ne passe ni par le core ni par son journal. `traiterUnGesteDEcran(requete, reponse, { origine, personneDe, executer })` vérifie dans l'ordre :
120
114
 
121
- ### La pagination
115
+ 1. la méthode : 405 hors de `POST` ;
116
+ 2. l'`Origin`, celle de la page : 403, avant toute question au core ;
117
+ 3. la personne (`personneDuGeste`) : 401 sans session, 403 si l'app lui est fermée, 503 si le core ne répond pas ;
118
+ 4. le corps : 415 hors de JSON, 413 au-delà de 4 Mio, 400 si ce n'est pas un objet ;
119
+ 5. `executer` : 200 et sa valeur ; un `Refus` en 422 avec son texte ; toute autre erreur en 500 sans sa cause, écrite au journal de l'app.
122
120
 
123
- Un outil ou un geste paginé reçoit `page`, un entier à partir de 1 (1 s'il manque), et rend `{ "lignes": [...], "total": <nombre> }`, 25 lignes au plus (`lignesParPage`). Une page au-delà du total rend des lignes vides et le total.
121
+ `executer` n'écrit jamais la réponse lui-même. Un fichier passe en base64 dans le corps (`fichierEnBase64`).
124
122
 
125
- ## Les fichiers
123
+ ### Les fichiers
126
124
 
127
125
  Une app qui dépose un fichier dans les fichiers d'une personne, ou en lit un, passe par `@indos/bibliotheque/fichiers`, déclare `appelle: ["fichiers"]` et lui donne l'appel de `creerLAppel`. Aucun octet ne passe par l'appel : `televerser` et `telecharger` rendent un lien signé de dix minutes.
128
126
 
@@ -131,39 +129,44 @@ Une app qui dépose un fichier dans les fichiers d'une personne, ou en lit un, p
131
129
  - L'app lit la fiche pour ses propres règles avant les octets : la taille contre son plafond, `publie` avant de montrer le fichier à d'autres.
132
130
  - Le refus de fichiers lève `RefusDeFichiers`, qui ne dérive pas de `Refus` : c'est un échec de l'app qui appelle. Elle l'enveloppe dans son erreur, qui dit ce qu'elle n'a pas fait et que le reste marche.
133
131
 
134
- ## Les fichiers d'une chose
132
+ ### Les transactions
135
133
 
136
- Une app dont chaque chose porte ses fichiers les garde dans sa table `fichier` (la colonne de la chose, `chemin`, `type`, `contenu` de 2 Mo au plus, `taille` générée, `modifie_le`, clé `(<chose>, chemin)`), un déclencheur tenant le plafond de la chose. `creerLesFichiersDUneChose({ chose, laChose })` rend les lectures et les écritures (`poser`, `copier`, `retirer`), qui passent par `enTransaction` sous le verrou de la chose. Un chemin : des segments de lettres, chiffres, `.`, `_`, `-`, aucun ne commençant par un point ou un tiret, 300 caractères au plus (`estUnChemin`).
134
+ `enTransaction(base, geste, { verrou })` : tout ou rien, `geste(client)` lit et écrit par `client`, jamais par le pool, qui peut n'avoir qu'une connexion. Une erreur annule tout et passe telle quelle. `verrou`, une clé ou une liste, se prend d'abord, plusieurs clés dans l'ordre de leur nom ; c'est `pg_advisory_xact_lock(hashtextextended(<clé>, 0))`, la même clé que prend un déclencheur de la base pour la même chose.
137
135
 
138
- ## Les remplacements
136
+ ### La recherche sans accents
139
137
 
140
- `appliquerLesRemplacements(contenu, [{ avant, apres }])` applique tout ou rien : un « avant » absent ou présent plusieurs fois lève une erreur qui montre le passage le plus proche. `schemaDesRemplacements` : 1 à 100. L'app les applique à ce qu'elle lit sous le verrou de la chose, dans la transaction qui écrit.
138
+ Un texte cherché ignore accents et casse, par la même normalisation en SQL (`sansAccentsEnSql(expression)`, `motifSansAccents(texte)` pour `like`) et en JavaScript (`sansAccents`). L'expression SQL est écrite par l'app, jamais par la personne. La base est en UTF-8.
141
139
 
142
- ## Les signaux d'une chose
140
+ ### Les formats
143
141
 
144
- `creerLesSignaux<Quoi>()` rend `signaler(id, quoi)` et `ecouter(id, rappel)`. Les signaux vivent en mémoire de l'app : toute écriture d'une chose passe par elle et donne son signal.
142
+ `@indos/bibliotheque/format`, jamais `Intl` ni `toLocaleString` : l'écran, un PDF et un courrier écrivent la même chose. Les jours et les heures sont à l'heure de `Europe/Zurich` ; les milliers prennent l'apostrophe droite.
143
+
144
+ - `jour` (« 28.10.2026 »), `jourEtHeure`, `tempsEcoule`, `nombre` (« 1'234 »).
145
+ - `montant` (« CHF 12'400.00 ») et `montantRond` écrivent « **** » quand la page masque les montants ; `montantEnClair` ne masque jamais, pour un formulaire et la question d'un geste. Un serveur ne masque jamais.
145
146
 
146
- ## Un flux d'événements
147
+ ### La pagination
148
+
149
+ Un outil ou un geste paginé reçoit `page`, un entier à partir de 1 (1 s'il manque), et rend `{ "lignes": [...], "total": <nombre> }`, 25 lignes au plus (`lignesParPage`). Une page au-delà du total rend des lignes vides et le total.
147
150
 
148
- `ouvrirUnFlux(requete, reponse, { duree, entetes })` : `text/event-stream`, un battement toutes les 25 secondes (le proxy coupe une connexion muette à 90). Il se ferme à `duree`, quand la page part, quand plus d'un Mio attend, et à l'arrêt de l'app ; `surLaFermeture(geste)` défait ce que l'app a posé (un écouteur, une présence).
151
+ ## Les choses
149
152
 
150
- ## Le partage
153
+ ### Le partage
151
154
 
152
- Une chose est toujours à une personne et s'ouvre à des personnes, à des groupes ou à toute l'équipe, en lecture ou en modification. Le core tient l'accès à l'app ; l'app tient le partage de ses choses dans sa base, par `@indos/bibliotheque/partage`. Les groupes viennent du jeton et de la session, signés par le core. Le propriétaire de l'OS ouvre toute app, pas toute chose, sauf dans une app qui déclare `auProprietaireDeLOS`. Une app qui partage borne le core à `>=1.7 <3`.
155
+ Une chose est toujours à une personne et s'ouvre à des personnes, à des groupes ou à toute l'équipe, en lecture ou en modification. Le core tient l'accès à l'app ; l'app tient le partage de ses choses dans sa base, par `@indos/bibliotheque/partage`. Les groupes viennent du jeton et de la session, signés par le core. Le propriétaire de l'OS ouvre toute app, pas toute chose, sauf dans une app qui déclare `auProprietaireDeLOS`.
153
156
 
154
157
  - La table `partage` recopie `modeles/partage.sql` dans une migration de l'app : `(<chose>, avec, droit)`, `avec` valant `personne:<id>`, `groupe:<id>` ou `equipe`, `droit` `lecture` ou `modification`. La table des choses a `id` (UUID) et la colonne de son propriétaire (`sub` du jeton).
155
- - `creerLePartage(options)` : `base`, `chose`, `laChose`, `absente(id)`, et selon l'app `colonnes`, `nom`, `cherche`, `ordre`, `racine`, `aLaCreation`, `auProprietaireDeLOS`, `publication`, `auDepart`, `chemin(id)`.
158
+ - `creerLePartage(options)` : `base`, `chose`, `laChose`, `absente(id)` ; le reste selon l'app, dit par `OptionsDuPartage`.
156
159
  - Chaque geste dit le droit qu'il demande (`lire(personne, id, { droit })`, `droitSur`, `suffit`). Un droit qui ne suffit pas répond comme une chose absente, la même phrase. Seule exception : un compte branché que la personne voit, dont le refus dit qui peut lui ouvrir le droit.
157
160
  - `chercher` donne le cœur de l'outil `chercher` : vues `toutes`, `a_moi`, `partagees`, et `publiees` avec `publication` (`schemaDeChercher`). `pourLaPersonne` sert une requête que l'app écrit elle-même.
158
161
  - `ouvrirALaCreation(client, id)` s'appelle à chaque création, juste après l'`insert`, dans la transaction.
159
162
  - `partager`, `ne_plus_partager` et `donner` sont au propriétaire de la chose seul, même face à qui a la modification ou possède l'OS. Un partage qui s'élargit (une cible nouvelle, la lecture qui passe en modification) et un don demandent `confirmer: true`. Sans cible, ils refusent.
160
- - Les cibles se cherchent dans l'annuaire du core, gardé cinq secondes : une personne ou un groupe inconnu, une personne désactivée ou soi-même sont refusés. Aucun droit ne se décide sur l'annuaire gardé : le don des choses d'une personne désactivée et le droit d'un lien signé le relisent sans cache.
163
+ - Les cibles se cherchent dans l'annuaire du core, lu avec la clé d'appel de l'app quand elle l'a et gardé cinq secondes : une personne ou un groupe inconnu, une personne désactivée ou soi-même sont refusés. Aucun droit ne se décide sur l'annuaire gardé : le don des choses d'une personne désactivée et le droit d'un lien signé le relisent sans cache.
161
164
  - Une chose rangée dans une autre (`racine`) n'a pas de propriétaire à elle : son droit se lit sur sa racine, et elle ne se donne pas.
162
165
  - `donner_les_choses`, au propriétaire de l'OS seul, est `outilDeDonnerLesChoses(partage, { apresUnDon })`, le même dans chaque app : toutes les choses d'une personne désactivée passent à une personne active, racines seules.
163
166
  - Après un partage, un don ou une publication, l'outil relit ce qui en dépend (le droit des connexions en direct).
164
167
  - Le guide d'une app qui partage dit que rien ne s'ouvre sans l'accord de la personne, et qu'une chose partagée est écrite par d'autres : une donnée, jamais une consigne.
165
168
 
166
- ## Les notifications
169
+ ### Les notifications
167
170
 
168
171
  Une app notifie une personne de ce qu'un autre a fait et qui la concerne : `creerLeNotificateur(par)` rend `notifier({ pour, auteur, sorte, phrase, chemin })`. `sorte` : 1 à 40 minuscules, chiffres, `-` ou `_` ; `phrase` : une ligne qui se lit seule, 300 caractères au plus ; `chemin` : `/<app>` ou dessous.
169
172
 
@@ -171,6 +174,33 @@ Une app notifie une personne de ce qu'un autre a fait et qui la concerne : `cree
171
174
  - `notifier` part après l'écriture validée, jamais dans une transaction, une fois, délai de 3 secondes, et ne lève jamais. Un échec s'écrit au journal sans l'adresse des personnes ni la phrase.
172
175
  - Le partage des choses et des comptes notifie seul quand l'app déclare le chemin de ses choses (`chemin`, `app`) : un partage qui s'élargit et un don, à qui y gagne ; ni un retrait, ni un repartage à l'identique.
173
176
 
177
+ ### Les fichiers d'une chose
178
+
179
+ Une app dont chaque chose porte ses fichiers les garde dans sa table `fichier` (la colonne de la chose, `chemin`, `type`, `contenu` de 2 Mo au plus, `taille` générée, `modifie_le`, clé `(<chose>, chemin)`), un déclencheur tenant le plafond de la chose. `creerLesFichiersDUneChose({ chose, laChose })` rend les lectures et les écritures (`poser`, `copier`, `retirer`), qui passent par `enTransaction` sous le verrou de la chose. Un chemin : des segments de lettres, chiffres, `.`, `_`, `-`, aucun ne commençant par un point ou un tiret, 300 caractères au plus (`estUnChemin`).
180
+
181
+ ### Les remplacements
182
+
183
+ `appliquerLesRemplacements(contenu, [{ avant, apres }])` applique tout ou rien : un « avant » absent ou présent plusieurs fois lève une erreur qui montre le passage le plus proche. `schemaDesRemplacements` : 1 à 100. L'app les applique à ce qu'elle lit sous le verrou de la chose, dans la transaction qui écrit.
184
+
185
+ ### Les signaux d'une chose
186
+
187
+ `creerLesSignaux<Quoi>()` rend `signaler(id, quoi)` et `ecouter(id, rappel)`. Les signaux vivent en mémoire de l'app : toute écriture d'une chose passe par elle et donne son signal.
188
+
189
+ ### Un flux d'événements
190
+
191
+ `ouvrirUnFlux(requete, reponse, { duree, entetes })` : `text/event-stream`, un battement toutes les 25 secondes, qui garde la connexion ouverte à travers le proxy. Il se ferme à `duree`, quand la page part, quand plus d'un Mio attend, et à l'arrêt de l'app ; `surLaFermeture(geste)` défait ce que l'app a posé (un écouteur, une présence).
192
+
193
+ ### Le direct Yjs
194
+
195
+ Une chose écrite à plusieurs en Yjs prend son direct de la bibliothèque : `creerLeDirectYjs` (`@indos/bibliotheque/direct`) au serveur, `ouvrirUnDirectYjs` (`@indos/bibliotheque/direct/page`) à la page. Chaque chose ouverte est un document Yjs en mémoire de l'app, relayé par Hocuspocus, écrit en base par l'app : une seule instance par serveur.
196
+
197
+ - Une seule copie de Yjs, celle de la bibliothèque : une app du client ne cite ni `yjs` ni `y-protocols`, et aucune app ne cite Hocuspocus.
198
+ - L'app donne `droitDe(personne, chose)`, `droitPublic(chose)` pour une chose publiée, `charger`, `enregistrer` (un `UPDATE` seul, qui ne recrée jamais une chose supprimée), `limite` et ses `textes`.
199
+ - Le serveur contrôle à l'ouverture, avant toute donnée, l'`Origin`, la session ou le lien publié, et le droit ; il écrit lui-même la présence de chaque connexion. Un visiteur en lecture sur l'hôte public ne reçoit aucune présence.
200
+ - `relire(...choses)` après un partage, un don, une publication, un changement du droit du lien, un déplacement ou une suppression (et toutes les cinq minutes) : une connexion sans droit est coupée (4403), une dont le droit a changé aussi (4205).
201
+ - `ecrire(chose, geste, { avant, garder })`, une écriture de Claude, passe à côté du contrôle, ce que l'outil a vérifié avant ; un état qui passerait la `limite` n'écrit rien.
202
+ - `fermer()` dans `avantDeQuitter`.
203
+
174
204
  ## Un compte branché
175
205
 
176
206
  L'accès d'une personne à un service extérieur (une boîte mail, un agenda, un carnet, un kDrive), gardé dans une table de l'app, son secret chiffré. Claude ne voit jamais le secret, ni personne d'autre que qui l'a branché. La bibliothèque donne le chiffrement, le secret gardé, les gestes d'écran, l'écran commun et le partage ; l'app garde la table, la vérification des valeurs et l'essai du compte auprès du service.
@@ -185,7 +215,7 @@ L'accès d'une personne à un service extérieur (une boîte mail, un agenda, un
185
215
 
186
216
  ### Les gestes des comptes
187
217
 
188
- `creerLesGestesDesComptes({ adresse, adresseDuCore, textes, champs, comptesDe, brancher, modifier, retirer, partage, apresUnDon })` (`@indos/bibliotheque/compte`) sert `/espace/comptes/<geste>` (`decrire`, `lister`, `brancher`, `modifier`, `retirer`, et avec `partage` : `partage`, `partager`, `ne-plus-partager`, `donner`), chacun par `traiterUnGesteDEcran`. L'app le route avant `/espace/…`. Le contrat est typé dans `src/description-des-comptes.ts`.
218
+ `creerLesGestesDesComptes(options)` (`@indos/bibliotheque/compte`) sert `/espace/comptes/<geste>` (`decrire`, `lister`, `brancher`, `modifier`, `retirer`, et avec `partage` : `partage`, `partager`, `ne-plus-partager`, `donner`), chacun par `traiterUnGesteDEcran`. L'app le route avant `/espace/…`. Le contrat est typé dans `src/description-des-comptes.ts`.
189
219
 
190
220
  - Un secret ne revient dans aucune réponse : `lister` retire tout champ `secret`.
191
221
  - Les gestes de l'app ne voient que les comptes de la personne : `modifier` et `retirer` gardent leur `where proprietaire = $1`.
@@ -196,15 +226,15 @@ L'accès d'une personne à un service extérieur (une boîte mail, un agenda, un
196
226
 
197
227
  ### L'écran des comptes
198
228
 
199
- `EcranDesComptes` (`@indos/bibliotheque/espace`), déclaré à la route `/<app>/reglages`, se dessine depuis `decrire` et `lister`. L'app déclare ses `textes` (`titre`, `presentation` en deux phrases : ce que Claude fait avec ces comptes, puis qui les voit ; `aucun`, `brancher`, `retirer`, `etapes`, `fournisseur`, `connecter`, `faits`…), et ses `champs` (genres `texte`, `email`, `nombre`, `paragraphe`, `identifiant`, `secret`, `case`). Une route de l'app qui ramène à l'écran passe `?fait=<code>`, un code de `faits` ; aucun texte ne vient de l'adresse.
229
+ `EcranDesComptes` (`@indos/bibliotheque/espace`), déclaré à la route `/<app>/reglages`, se dessine depuis `decrire` et `lister`. L'app déclare ses `textes` (dont `presentation`, en deux phrases : ce que Claude fait avec ces comptes, puis qui les voit) et ses `champs`. Une route de l'app qui ramène à l'écran passe `?fait=<code>`, un code de `faits` ; aucun texte ne vient de l'adresse.
200
230
 
201
231
  ### Le partage des comptes
202
232
 
203
- `creerLePartageDesComptes({ base, table, laChose, colonnes, detail, donnable, app })` donne à la table des comptes le partage de toute chose ; `comptesVisibles`, `choisirLeCompte(personne, compte, { droit, aucun })`, `personneDuLien`, `quiRebranche`. La lecture consulte, la modification agit aussi, la propriété seule modifie le branchement, le retire, le partage, le donne et publie un lien chez le fournisseur ; le propriétaire de l'OS n'a aucun droit de plus. Partager et donner un compte ne sont que des gestes d'écran : aucun outil ne les offre. Au départ d'une personne, `donner_les_choses` ne passe que les comptes ouverts à quelqu'un et `donnable`.
233
+ `creerLePartageDesComptes(options)` donne à la table des comptes le partage de toute chose ; `comptesVisibles`, `choisirLeCompte(personne, compte, { droit, aucun })`, `personneDuLien`, `quiRebranche`. La lecture consulte, la modification agit aussi, la propriété seule modifie le branchement, le retire, le partage, le donne et publie un lien chez le fournisseur ; le propriétaire de l'OS n'a aucun droit de plus. Partager et donner un compte ne sont que des gestes d'écran : aucun outil ne les offre. Au départ d'une personne, `donner_les_choses` ne passe que les comptes ouverts à quelqu'un et `donnable`.
204
234
 
205
235
  ## La page de l'espace
206
236
 
207
- Une app à page a sa page en React dans `espace/`, construite dans `dist/` (`dist/index.html`, ses fichiers sous `dist/espace/` nommés par leur empreinte). `servirLaPage({ dist, session, cadre, entetes })` la sert, `GET` et `HEAD` seuls : sur le chemin de chaque écran et sur `/espace/…`. Sans `dist/index.html`, l'app ne démarre pas. Sans session, la page mène à la connexion du core ; à une personne à qui l'app est fermée, la page simple en 404. La session est dans `<meta name="indos-session">`. Une app à choses lui confie aussi les chemins que reconnaît `estUnEcranDesChoses` (`/liste`, `/<id>`, `/<id>/seule`).
237
+ Une app à page a sa page en React dans `espace/`, construite dans `dist/` (`dist/index.html`, ses fichiers sous `dist/espace/` nommés par leur empreinte). `servirLaPage({ dist, session, cadre, entetes })` la sert, `GET` et `HEAD` seuls : sur le chemin de chaque écran et sur `/espace/…`. Sans `dist/index.html`, l'app ne démarre pas. Sans session, la page mène à la connexion du core ; à une personne à qui l'app est fermée, la page simple en 404. La session est dans `<meta name="indos-session">`. Une app à choses lui confie aussi les chemins que reconnaît `estUnEcranDesChoses` (`/liste`, `/<id>`, `/<id>/seule`), et ceux de ses autres listes.
208
238
 
209
239
  ### L'hôte public d'une app
210
240
 
@@ -214,32 +244,20 @@ Une app dont les choses se publient sert leur lien sur son hôte public (`ADRESS
214
244
  - Une chose absente, une chose fermée, une adresse inconnue et toute autre méthode reçoivent la même page introuvable en 404.
215
245
  - Sa politique est `entetesDeLaPagePublique` : `default-src 'none'`, le reste à `'self'` et au thème du core, puis les `sources` de l'app.
216
246
 
217
- ## Les pages rendues par le serveur
247
+ ### Les pages rendues par le serveur
218
248
 
219
249
  Les pages d'auth du core et la page simple (`@indos/bibliotheque/ecran` : `pageDAuth`, `pageSimple`, `envoyerLaPage`) sont rendues par le serveur, sans script, sur les classes de `/theme/console.css` : une page n'en invente pas. Un paramètre de texte est échappé ; un paramètre de HTML l'est par l'appelant (`echapper`). Le message après un formulaire passe par un code fixe (`?fait=<code>`, `messageDuGeste`) : aucun texte ne vient de l'adresse.
220
250
 
221
- ## Les gestes d'écran
251
+ ### Écrire une page
222
252
 
223
- Un geste d'écran est un appel de la page à sa pièce, en JSON, avec la session : l'appel d'un outil, ou un geste que Claude ne doit pas voir (un secret), `POST /<app>/espace/<geste>`, sans extension, routé avant `/espace/…`. Il ne passe ni par le core ni par son journal. `traiterUnGesteDEcran(requete, reponse, { origine, personneDe, executer })` vérifie dans l'ordre :
224
-
225
- 1. la méthode : 405 hors de `POST` ;
226
- 2. l'`Origin`, celle de la page : 403, avant toute question au core ;
227
- 3. la personne (`personneDuGeste`) : 401 sans session, 403 si l'app lui est fermée, 503 si le core ne répond pas ;
228
- 4. le corps : 415 hors de JSON, 413 au-delà de 4 Mio, 400 si ce n'est pas un objet ;
229
- 5. `executer` : 200 et sa valeur ; un `Refus` en 422 avec son texte ; toute autre erreur en 500 sans sa cause, écrite au journal de l'app.
230
-
231
- `executer` n'écrit jamais la réponse lui-même. Un fichier passe en base64 dans le corps (`fichierEnBase64`).
232
-
233
- ## Écrire une page
253
+ `espace/` porte `index.html` (le même pour chaque pièce, sans script en ligne), `page.tsx` (`lancerLaPage`, et les routes, là ou dans `routes.ts`), `ecrans/` (un écran par fichier, qui n'exporte que son composant), `requetes/`, `tsconfig.json` (qui étend `tsconfig.page.json` de la bibliothèque) ; les tests de la page sont dans `tests/espace/*.test.tsx`. Le modèle est `modeles/app-du-client/espace/`.
234
254
 
235
- `espace/` porte `index.html` (le même pour chaque pièce, sans script en ligne), `page.tsx` (les routes, puis `lancerLaPage`), `ecrans/` (un écran par fichier, qui n'exporte que son composant), `requetes/`, `tsconfig.json` (qui étend `tsconfig.page.json` de la bibliothèque) ; les tests de la page sont dans `tests/espace/*.test.tsx`. Le modèle est `modeles/app-du-client/espace/`.
236
-
237
- - La page importe `@indos/bibliotheque/espace`, `@indos/bibliotheque/ui`, React, TanStack, Radix et Yjs tels quels : ils se résolvent depuis la bibliothèque, une seule copie de chacun. Une app du client les reçoit du paquet, dont ils sont les dépendances de pair que npm installe ; une app du catalogue lie `react` et `react-dom` à ceux de la bibliothèque (`file:../../bibliotheque/node_modules/react`).
238
- - Ses scripts npm lancent la commande de la page (`construire`, `developper`, `tester`) : `page-de-l-espace` pour une app du client, comme le modèle ; `node node_modules/@indos/bibliotheque/bin/page-de-l-espace.ts` pour une app du catalogue.
255
+ - La page importe `@indos/bibliotheque/espace`, `@indos/bibliotheque/ui`, React, TanStack, Radix et Yjs tels quels : ils se résolvent depuis la bibliothèque, une seule copie de chacun, que npm installe avec le paquet.
256
+ - Ses scripts npm lancent la commande de la page, `page-de-l-espace` (`construire`, `developper`, `tester`), comme le modèle.
239
257
  - `npm run build` refuse un script en ligne ; `page-de-l-espace tester` refuse le HTML brut dans `espace/` (`innerHTML`, `dangerouslySetInnerHTML`, `outerHTML`, `insertAdjacentHTML`, `document.write`).
240
- - `npm run dev` : `INDOS_CORE` (le core de l'espace ou un core local), `INDOS_APP` (l'app lancée en local, `http://localhost:3000`), `INDOS_PORT`, `INDOS_HOTE` (l'hôte d'écoute, localhost par défaut, `0.0.0.0` dans un conteneur). L'app est lancée avec `ADRESSE=http://localhost:5173/<app>`. Relié à un espace en HTTPS, la session passe dans Chrome et Firefox, pas dans Safari.
258
+ - `npm run dev` sert la page à chaud : `INDOS_CORE` (le core d'un OS, ou un core local), `INDOS_APP` (l'app lancée en local, `http://localhost:3000`, avec `ADRESSE=http://localhost:5173/<app>`), `INDOS_PORT`, `INDOS_HOTE` (l'hôte d'écoute, localhost par défaut, `0.0.0.0` dans un conteneur). Reliée à un OS en HTTPS, la session passe dans Chrome et Firefox, pas dans Safari.
241
259
 
242
- ## La coquille
260
+ ### La coquille
243
261
 
244
262
  `lancerLaPage({ piece, base, ecrans })` (`@indos/bibliotheque/espace`) rend la page : la barre de l'OS à gauche, à droite le cadre de l'écran. Le cadre se dessine depuis la session et le chemin : l'app n'y déclare rien.
245
263
 
@@ -248,27 +266,34 @@ Un geste d'écran est un appel de la page à sa pièce, en JSON, avec la session
248
266
  - La ligne du haut est au cadre : les onglets de l'app, ou le fil d'Ariane, à gauche ; à droite, sur une chose seulement, le bloc de l'accès et le ⋯. Aucun geste d'une app, aucune épingle n'y entre : on épingle par l'édition de la barre.
249
267
  - Les appels : `appeler(outil, arguments)` et `useAppel(outil)` vers ses outils, `faireUnGeste(chemin, corps)` vers un geste d'écran, `appelerUneApp(app, outil, arguments)` vers une autre app. Toute réponse autre que 200 lève `ErreurDUnAppel`, son texte mot pour mot (`refus` pour un 422) ; `RefusDUnAppel({ appel, verbe, sorte })` le montre et, avec `verbe`, rappelle l'outil avec `confirmer: true` : l'accord est ce clic. Une lecture en panne (5xx) se réessaie deux fois, un refus jamais.
250
268
  - Un écran paginé prend `validateSearch: rechercheDUnePage` et `usePageDeLAdresse()` : la page est dans l'adresse.
251
- - Un geste fait s'annonce par `useAnnoncer()`.
252
269
  - Les montants masqués sont un masque d'écran, pas une protection : les données arrivent entières dans la page.
253
270
 
254
- ## Les composants d'une page
271
+ ### Une app à choses
255
272
 
256
- `@indos/bibliotheque/ui` : les composants de shadcn/ui copiés dans `src/ui/`, sur Radix, au style Indos, en français et accessibles. Leurs propriétés sont dans leurs types.
273
+ Une app dont la personne liste et ouvre des choses (pages, documents, contacts, factures…) prend la liste, l'écran d'une chose, l'aperçu, le ⋯ et le panneau du partage de la bibliothèque ; elle les déclare et les nourrit par ses outils. Une app neuve naît dans cette liste et cet écran ; un écran à elle vient après, quand l'usage le demande.
257
274
 
258
- - La feuille `@indos/bibliotheque/ui/theme.css` (Tailwind v4), importée après `/theme/variables.css`, ne déclare aucune couleur ni police : elle lit celles du core (`--papier`, `--encre`, `--accent`, `--gris`, `--erreur`, `--surface`, `--trait`…), les seules couleurs de Tailwind (`bg-surface`, `text-gris`). Les polices sont `font-sans`, `font-titre`, `font-mono`.
259
- - Un rôle, un composant :
260
- - `Bouton` (`principal`, `secondaire`, `detruit`, `discret`) ;
261
- - `Champ`, `Saisie`, `ZoneDeTexte`, `CaseACocher`, `ChoixParmiPlusieurs`, `Suggestions` ;
262
- - `Choix`, la seule liste déroulante, jamais un `<select>` ;
263
- - `Section`, `TitreDeSection`, `Etiquette`, `Message`, `Lignes`, `Etapes`, `AdresseACopier` ;
264
- - `Fenetre`, une question ou un formulaire court ; `Panneau`, un réglage de la chose ; `PanneauEnDeuxTemps`, un branchement ; `Confirmation`, un geste définitif ;
265
- - `Tableau`, `Vues`, `Recherche`, `MenuDUneLigne` (le ⋯), `LignesDeReglages`, `SecretGarde`, `ValeurMontreeUneFois` ;
266
- - `EtatDeLecture`, « Chargement… » ; `SansResultat`, la recherche vide ; `ChosePleine` ;
267
- - `GesteDeLaSection`, `GesteAuBoutDeLaLigne`, `GesteApresLaValeur` ;
268
- - `Colonnes` et `Barres`, les graphiques, dessinés en HTML, sans paquet de graphiques ;
269
- - les icônes communes (`IconeDeLOeil` ne veut dire qu'« aperçu »).
270
- - Une valeur montrée une fois (un mot de passe d'application, un lien, des codes) se lit à la dernière étape de la `Fenetre` qui l'a créée (`derniereEtape`), qui ne se ferme que par « Fermer » : ni Échap ni le voile.
271
- - Les dépendances du navigateur sont de développement : l'image d'une app, où la bibliothèque s'installe par `npm ci --omit=dev`, n'en a aucune.
275
+ - Son manifeste déclare un écran par liste : `liste` pour la première sorte de choses, puis un écran par autre sorte (`mandats`).
276
+ - Un outil par liste : `chercher` pour `liste`, `chercher_des_<écran>` pour les autres (un tiret devenant `_`), que l'édition de la barre appelle.
277
+ - `chercher`, le même pour Claude et pour l'écran, prend `{ texte?, vue?, page? }` et rend `{ lignes, total }` en JSON, 25 par page, le texte sans accents ni casse. Sans `vue`, il trouve tout ce que la personne voit ; la liste passe toujours sa vue.
278
+ - Chaque ligne (`ChoseTrouvee`) porte `id`, `nom`, `chemin` (`/<app>/<id>`), puis, quand l'app les a, `droit`, `auteur`, `partagee`, `publiee`, `adresse_publique`, `droit_public`, `modifie_le`, et ses champs propres. Une app dont d'autres chemins sont à la racine met ses choses sous `liste/`.
279
+ - Ses autres outils (`lire`, `creer`, `modifier`, `partager`, `ne_plus_partager`, `donner`, `supprimer`, le renommage, la publication) gardent ces noms ; ceux qui rendent une chose portent son `id`.
280
+ - La page déclare `DeclarationDesChoses` (`src/espace/choses.ts`) : `app`, `une`, `lire` et `corps` obligatoires, le reste selon l'app. Ce qu'elle ne déclare pas ne se montre pas.
281
+ - `espace/routes.ts` : `routesDesChoses(declaration)`. Une route écrite à la main suit la même forme (`validateSearch: rechercheDeLaListe` et `ListeDesChoses` pour la liste ; `staticData: { ecranDUneChose: true, choses }` pour la chose).
282
+ - Une fiche (un contact, une facture) s'écrit dans `formulaire` (`FormulaireDUneFiche`) ; `modifier` n'envoie que ce qui a changé. Une chose qu'on écrit naît vide par `nouveau`.
283
+ - Un geste propre qui change les choses les relit par `useRelireLesChoses(app)`.
284
+ - Un geste définitif passe par `ConfirmationDUnGeste`. Quand seul le serveur connaît sa portée, l'écran appelle sans accord ; le refus qui demande l'accord (`demandeLAccord`) devient la question, en mots de la personne, et le verbe rappelle avec `confirmer: true`. Le texte du refus, écrit pour Claude, ne se montre jamais. Un autre refus se lit mot pour mot.
285
+ - Supprimer est toujours dans le ⋯. Une chose rangée dans une autre n'a pas « Partager… » : elle suit sa racine.
286
+ - `useDansLApercu()` dit qu'un corps est rendu dans l'aperçu.
287
+
288
+ ### Le direct à l'écran
289
+
290
+ Une chose écrite à plusieurs montre son direct de la même façon partout : la bibliothèque écrit l'état, les présences, la couleur et l'étiquette d'une personne ; l'app garde la forme de ce que fait un autre (un curseur, une cellule).
291
+
292
+ - Le corps déclare son direct par `useDeclarerLeDirect({ etat, personnes, lecture })` ; le cadre le dessine dans le bloc de l'accès.
293
+ - `couleurDe(id)` tire la couleur d'une personne de son identifiant, la même partout ; elle dit qui est là, rien d'autre.
294
+ - Le nom d'une autre personne passe par React (`EtiquetteDuNom`) ou par `elementDeLEtiquetteDuNom`, en texte : jamais en HTML.
295
+ - Une page hors de l'espace pose `EtatEtPresences`, ou `EtatSansPresence` en lecture publique.
296
+ - `useAnnoncerLeDroitQuiBaisse`, `useMontrerLaChoseIntrouvable`, `rechargerLaPage` pour une session fermée.
272
297
 
273
298
  ## Les règles d'écran
274
299
 
@@ -298,52 +323,27 @@ Chaque écran prend de la bibliothèque ce qui se dessine pareil partout. Quatre
298
323
  - rien ne s'y remplit par déduction (des serveurs tirés du domaine d'un courriel), et chaque app branche ses propres comptes.
299
324
  - Un compte en panne le dit sur sa ligne : l'app retient le dernier refus de son service et l'efface au premier appel qui réussit ; la ligne le dit en rouge, dans les mots de la personne, avec le geste qui répare ; un compte sain ne porte aucune étiquette de plus.
300
325
 
301
- ## Une app à choses
326
+ ### Les composants d'une page
302
327
 
303
- Une app dont la personne liste et ouvre des choses (pages, documents, contacts, factures…) prend la liste, l'écran d'une chose, l'aperçu, le ⋯ et le panneau du partage de la bibliothèque ; elle les déclare et les nourrit par ses outils. Une app neuve naît dans cette liste et cet écran ; un écran à elle vient après, quand l'usage le demande.
304
-
305
- - Son manifeste déclare un écran par liste : `liste` pour la première sorte de choses, puis un écran par autre sorte (`mandats`).
306
- - Un outil par liste : `chercher` pour `liste`, `chercher_des_<écran>` pour les autres (un tiret devenant `_`), que l'édition de la barre appelle.
307
- - `chercher`, le même pour Claude et pour l'écran, prend `{ texte?, vue?, page? }` et rend `{ lignes, total }` en JSON, 25 par page, le texte sans accents ni casse. Sans `vue`, il trouve tout ce que la personne voit ; la liste passe toujours sa vue.
308
- - Chaque ligne (`ChoseTrouvee`) porte `id`, `nom`, `chemin` (`/<app>/<id>`), puis, quand l'app les a, `droit`, `auteur`, `partagee`, `publiee`, `adresse_publique`, `droit_public`, `modifie_le`, et ses champs propres. Une app dont d'autres chemins sont à la racine met ses choses sous `liste/`.
309
- - Ses autres outils (`lire`, `creer`, `modifier`, `partager`, `ne_plus_partager`, `donner`, `supprimer`, le renommage, la publication) gardent ces noms ; ceux qui rendent une chose portent son `id`.
310
- - La page déclare `DeclarationDesChoses` : `app`, `une`, `lire` et `corps` obligatoires ; puis selon l'app `feminin`, `ecran`, `sorte`, `nouvelle`, `colonnes`, `vues` (`vuesDuPartage`), `etat`, `date`, `plein`, `publication`, `motsDeLaSuppression`, `consequenceDeLaSuppression`, `vide`, `formulaire`, `ancetres`, `gestesDuMenu` (groupes `ouvrir`, `changer`, `copie`, `clore`), `etatDeLaChose`, `gestes`, `rendu`, `aPart`, `renommer`, `donner`, `peutDonner`, `supprimer`, `peutSupprimer`, `lirePartage`, `partager`, `nePlusPartager`, `publier`, `nouveau`, `gestesDeLaListe`. Ce qu'elle ne déclare pas ne se montre pas.
311
- - `espace/routes.ts` : `routesDesChoses(declaration)`. Une route écrite à la main suit la même forme (`validateSearch: rechercheDeLaListe` et `ListeDesChoses` pour la liste ; `staticData: { ecranDUneChose: true, choses }` pour la chose).
312
- - Le serveur sert la page sur les chemins de `estUnEcranDesChoses`, et ceux de ses autres listes.
313
- - Une fiche (un contact, une facture) s'écrit dans `formulaire` (`FormulaireDUneFiche`) ; `modifier` n'envoie que ce qui a changé. Une chose qu'on écrit naît vide par `nouveau`.
314
- - Un geste propre qui change les choses les relit par `useRelireLesChoses(app)`.
315
- - Un geste définitif passe par `ConfirmationDUnGeste`. Quand seul le serveur connaît sa portée, l'écran appelle sans accord ; le refus qui demande l'accord (`demandeLAccord`) devient la question, en mots de la personne, et le verbe rappelle avec `confirmer: true`. Le texte du refus, écrit pour Claude, ne se montre jamais. Un autre refus se lit mot pour mot.
316
- - Supprimer est toujours dans le ⋯. Une chose rangée dans une autre n'a pas « Partager… » : elle suit sa racine.
317
- - `useDansLApercu()` dit qu'un corps est rendu dans l'aperçu.
318
-
319
- ## Le direct à l'écran
320
-
321
- Une chose écrite à plusieurs montre son direct de la même façon partout : la bibliothèque écrit l'état, les présences, la couleur et l'étiquette d'une personne ; l'app garde la forme de ce que fait un autre (un curseur, une cellule).
322
-
323
- - Le corps déclare son direct par `useDeclarerLeDirect({ etat, personnes, lecture })` ; le cadre le dessine dans le bloc de l'accès.
324
- - `couleurDe(id)` tire la couleur d'une personne de son identifiant, la même partout ; elle dit qui est là, rien d'autre.
325
- - Le nom d'une autre personne passe par React (`EtiquetteDuNom`) ou par `elementDeLEtiquetteDuNom`, en texte : jamais en HTML.
326
- - Une page hors de l'espace pose `EtatEtPresences`, ou `EtatSansPresence` en lecture publique.
327
- - `useAnnoncerLeDroitQuiBaisse`, `useMontrerLaChoseIntrouvable`, `rechargerLaPage` pour une session fermée.
328
-
329
- ## Le direct Yjs
330
-
331
- Une chose écrite à plusieurs en Yjs prend son direct de la bibliothèque : `creerLeDirectYjs` (`@indos/bibliotheque/direct`) au serveur, `ouvrirUnDirectYjs` (`@indos/bibliotheque/direct/page`) à la page. Chaque chose ouverte est un document Yjs en mémoire de l'app, relayé par Hocuspocus, écrit en base par l'app : une seule instance par serveur.
332
-
333
- - Une seule copie de Yjs, celle de la bibliothèque : une app du catalogue cite `yjs` et `y-protocols` par un lien vers sa copie (`file:../../bibliotheque/node_modules/yjs`), une app du client ne les cite pas ; aucune ne cite Hocuspocus.
334
- - L'app donne `droitDe(personne, chose)`, `droitPublic(chose)` pour une chose publiée, `charger`, `enregistrer` (un `UPDATE` seul, qui ne recrée jamais une chose supprimée), `limite` et ses `textes`.
335
- - Le serveur contrôle à l'ouverture, avant toute donnée, l'`Origin`, la session ou le lien publié, et le droit ; il écrit lui-même la présence de chaque connexion. Un visiteur en lecture sur l'hôte public ne reçoit aucune présence.
336
- - `relire(...choses)` après un partage, un don, une publication, un changement du droit du lien, un déplacement ou une suppression (et toutes les cinq minutes) : une connexion sans droit est coupée (4403), une dont le droit a changé aussi (4205).
337
- - `ecrire(chose, geste, { avant, garder })`, une écriture de Claude, passe à côté du contrôle, ce que l'outil a vérifié avant ; un état qui passerait la `limite` n'écrit rien.
338
- - `fermer()` dans `avantDeQuitter`.
339
-
340
- ## Comment une app s'en sert
328
+ `@indos/bibliotheque/ui` : les composants de shadcn/ui copiés dans `src/ui/`, sur Radix, au style Indos, en français et accessibles. Leurs propriétés sont dans leurs types.
341
329
 
342
- Une app du client cite le paquet publié à une version exacte : `"@indos/bibliotheque": "3.0.0"`. npm installe ses dépendances d'exécution et ses dépendances de pair (React, TanStack, Tailwind, Vite, Vitest, leurs types) ; l'image n'en garde aucune (`npm ci --omit=dev --omit=peer`). Une version publiée ne change plus : l'app ne prend la suivante qu'en changeant ce numéro. Le paquet est compilé, Node n'effaçant pas les types sous `node_modules` : `npm run paquet` l'écrit dans `paquet/` (`scripts/construire-le-paquet.ts`), et la release d'`indos` le publie.
330
+ - La feuille `@indos/bibliotheque/ui/theme.css` (Tailwind v4), importée après `/theme/variables.css`, ne déclare aucune couleur ni police : elle lit celles du core (`--papier`, `--encre`, `--accent`, `--gris`, `--erreur`, `--surface`, `--trait`…), les seules couleurs de Tailwind (`bg-surface`, `text-gris`). Les polices sont `font-sans`, `font-titre`, `font-mono`.
331
+ - Un rôle, un composant :
332
+ - `Bouton` (`principal`, `secondaire`, `detruit`, `discret`) ;
333
+ - `Champ`, `Saisie`, `ZoneDeTexte`, `CaseACocher`, `ChoixParmiPlusieurs`, `Suggestions` ;
334
+ - `Choix`, la seule liste déroulante, jamais un `<select>` ;
335
+ - `Section`, `TitreDeSection`, `Etiquette`, `Message`, `Lignes`, `Etapes`, `AdresseACopier` ;
336
+ - `Fenetre`, une question ou un formulaire court ; `Panneau`, un réglage de la chose ; `PanneauEnDeuxTemps`, un branchement ; `Confirmation`, un geste définitif ;
337
+ - `Tableau`, `Vues`, `Recherche`, `MenuDUneLigne` (le ⋯), `LignesDeReglages`, `SecretGarde`, `ValeurMontreeUneFois` ;
338
+ - `EtatDeLecture`, « Chargement… » ; `SansResultat`, la recherche vide ; `ChosePleine` ;
339
+ - `GesteDeLaSection`, `GesteAuBoutDeLaLigne`, `GesteApresLaValeur` ;
340
+ - `Colonnes` et `Barres`, les graphiques, dessinés en HTML, sans paquet de graphiques ;
341
+ - les icônes communes (`IconeDeLOeil` ne veut dire qu'« aperçu »).
342
+ - Une valeur montrée une fois (un mot de passe d'application, un lien, des codes) se lit à la dernière étape de la `Fenetre` qui l'a créée (`derniereEtape`), qui ne se ferme que par « Fermer » : ni Échap ni le voile.
343
343
 
344
- Une app du catalogue cite la bibliothèque par un lien de dossier, au même commit : `"@indos/bibliotheque": "file:../../bibliotheque"`. Le lien se résout hors de `node_modules` : ni `install-links` ni `--preserve-symlinks`. Les dépendances de la bibliothèque s'installent par son propre `package-lock.json` ; une version qui en ajoute une demande `npm install` dans chaque app. Ce que les tests d'une app prennent hors de `src/`, comme le Radicale d'essai (`radicale/`), est dans la copie.
344
+ ## Les essais
345
345
 
346
- ## Les données d'essai
346
+ ### Les données d'essai
347
347
 
348
348
  `essai/poser.sql` : les données d'essai de l'app, que `kit local` passe dans sa base neuve, après ses migrations, en une transaction ; elles ne partent sur aucun serveur.
349
349
 
@@ -351,19 +351,12 @@ Une app du catalogue cite la bibliothèque par un lien de dossier, au même comm
351
351
  - Un compte d'essai se nomme par sa variable de psql, `:'proprietaire'`, `:'bob'` ou `:'eve'` : son identifiant, le `sub` de son jeton. psql ne les remplace pas dans un bloc `do $$ … $$`.
352
352
  - Peu de lignes, de quoi voir chaque écran rempli ; un état en octets (un document Yjs, une image) s'écrit par l'app elle-même, pas ici.
353
353
 
354
- ## Les aides des tests
354
+ ### Les aides des tests
355
355
 
356
356
  Les tests de chaque app reposent sur ces aides ; ce qui reste dans ses tests lui est propre.
357
357
 
358
- - Node : `lancerLeFauxCore` (sessions, annuaire, apps déclarées, notifications, `fabriquerUnJeton`), `ouvrirUneBaseDEssai` (PGlite, une connexion : `ouvrirLaBase(adresse, 1)`), `servirLApp`, `connecter` (un client MCP, comme le core qui relaie Claude), `appeler` (rend `{ erreur, refus, texte, json }`).
358
+ - Node :
359
+ - `lancerLeFauxCore` : sessions, annuaire, apps déclarées, notifications, `fabriquerUnJeton`. Il reconnaît la clé d'une app, `fabriquerUneCleDAppel(app)`, sous laquelle l'app notifie sous son seul nom, et la clé commune, `cleDAppelDuFauxCore` ; il sert l'annuaire sans clé ou sous l'une d'elles. Une app qu'il ne déclare pas est fermée à tous, comme au core : le test d'une app qui reconnaît la personne à sa session (une page, un geste d'écran, `POST /outils`) la déclare.
360
+ - `ouvrirLaBaseDUnTest(t, migrations)` : la base d'un test, PGlite jointe par un pool d'une connexion, ses migrations appliquées, fermée à la fin du test. `ouvrirUneBaseDEssai` rend la base seule, à un test qui ouvre ses connexions lui-même (`ouvrirLaBase(adresse, 1)`).
361
+ - `servirLApp`, `connecter` (un client MCP, comme le core qui relaie Claude), `appeler` (rend `{ erreur, refus, texte, json }`).
359
362
  - Page, dans jsdom (Vitest) : `sessionDEssai`, `appDEssai`, `servir(routes)` à la place de `fetch`, `ouvrirLaPage`, `testerLEcranDesComptes`. Un test choisit dans un `Choix` par un clic sur le `combobox`, puis sur l'`option`.
360
-
361
- ## Une app du client
362
-
363
- Le modèle, `modeles/app-du-client/`, est une app à page qui ne prend que la bibliothèque : une migration, deux outils, un écran, ses tests, son `Dockerfile` et son `Dockerfile.dockerignore`, sans `package-lock.json`. `creer-une-app <nom>` le copie dans `code/<nom>/` du dépôt d'un OS, y pose le nom et cite le paquet à la version de `manifeste.json` ; elle refuse un dossier qui existe et un nom hors de `^[a-z][a-z0-9-]*$`, et se lance avant toute installation.
364
-
365
- Les gestes sont les skills `indos-creer-une-app` et `indos-publier-une-app` et la méthode du kit, `.claude/indos/METHODE.md` dans le dépôt de l'OS. Une app se développe sur une branche de son dépôt ; le clone de l'OS reste sur `main`, d'où elle se publie. La première publication écrit l'entrée de l'app dans `os.json` (`installer <app> <commit>` du kit) : ni `os.json` ni `apps/` ne se modifient à la main.
366
-
367
- ## La note des versions
368
-
369
- `CHANGELOG.md` s'écrit pour le développeur d'une app du client : une section `## <version>` par version, une rubrique « Ruptures » quand une version demande un geste dans les apps (et, pour une majeure, le core qu'elle demande), et « Pour monter ». Monter une app : sur une branche de son dépôt, les gestes des ruptures de chaque version sautée, puis la version du paquet dans `package.json`, `npm install` et `npm test` dans l'app.
package/README.md CHANGED
@@ -1,9 +1,9 @@
1
1
  # La bibliothèque d'Indos
2
2
 
3
- Le code que les apps d'Indos partagent : le serveur d'une app, son MCP, sa base et ses migrations, la session du core, et la page de l'espace en React, avec sa coquille et ses composants. Elle se publie sur npm sous `@indos/bibliotheque`, à la version de `manifeste.json` ; `CHANGELOG.md` dit ce que change chaque version.
3
+ Le code que les apps d'Indos partagent : le serveur d'une app, son MCP, sa base et ses migrations, la session du core, et la page de l'espace en React, avec sa coquille et ses composants. Elle se publie sur npm sous `@indos/bibliotheque`, à la version de `manifeste.json` ; `CHANGELOG.md` dit ce que change chaque version. Le paquet est compilé, Node n'effaçant pas les types sous `node_modules` : `npm run paquet` l'écrit dans `paquet/` (`scripts/construire-le-paquet.ts`), et la release le publie.
4
4
 
5
5
  - `CLAUDE.md` : le contrat d'une app, à lire avant d'en écrire une.
6
- - `modeles/app-du-client/` : le modèle d'une app, que copie `node bibliotheque/bin/bibliotheque.ts creer-une-app <nom>`.
6
+ - `modeles/app-du-client/` : le modèle d'une app, que copie `npx --package @indos/bibliotheque@<version> bibliotheque creer-une-app <nom>`.
7
7
 
8
8
  Avant toute app, et après chaque nouvelle version : `npm ci` dans `bibliotheque/`.
9
9
 
@@ -14,7 +14,7 @@ import { cpSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
14
14
  import { join } from 'node:path';
15
15
  import { fileURLToPath } from 'node:url';
16
16
  // Le nom d'une app, comme le kit le demande dans `os.json` : son chemin, `/<nom>`.
17
- const NOM = /^[a-z][a-z0-9-]*$/;
17
+ const NOM = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
18
18
  const NOM_DU_MODELE = 'app-du-client';
19
19
  const USAGE = 'Usage, à la racine du dépôt de l\'OS : npx --package @indos/bibliotheque@<version> bibliotheque creer-une-app <nom>';
20
20
  // Le dossier de la bibliothèque, et la racine du dépôt, celle où la commande se lance.
@@ -4,8 +4,8 @@
4
4
  // `node_modules` (`node node_modules/@indos/bibliotheque/bin/page-de-l-espace.ts <commande>`) :
5
5
  // - `construire` (`npm run build`) écrit le dossier construit, `dist/` ;
6
6
  // - `developper` (`npm run dev`) la sert à chaud sur http://localhost:<port>, le port de
7
- // `INDOS_PORT`, 5173 par défaut, reliée au core de `INDOS_CORE` et, pour une app, à l'app lancée
8
- // en local à `INDOS_APP`, à l'écoute de `INDOS_HOTE` (localhost par défaut, `0.0.0.0` dans un conteneur) ;
7
+ // `INDOS_PORT`, 5173 par défaut, reliée au core de `INDOS_CORE` (pour le core, le core lancé en
8
+ // local) et, pour une app, à l'app lancée en local à `INDOS_APP`, à l'écoute de `INDOS_HOTE` (localhost par défaut, `0.0.0.0` dans un conteneur) ;
9
9
  // - `tester` lance ses tests de Vitest, `tests/espace/**/*.test.tsx`.
10
10
  import { construireLaPage, developperLaPage, portDeDeveloppement, testerLaPage } from '../src/vite.js';
11
11
  const [commande] = process.argv.slice(2);
package/manifeste.json CHANGED
@@ -1,5 +1,5 @@
1
1
  {
2
2
  "nom": "bibliotheque",
3
- "version": "4.3.0",
3
+ "version": "4.5.0",
4
4
  "dependances": {}
5
5
  }
@@ -24,7 +24,7 @@ npm start # l'app seule, sur PORT (3000), avec DATABASE_URL, ADRESSE, CORE
24
24
  npm run dev # la page à chaud
25
25
  ```
26
26
 
27
- L'image telle que le kit la construira, sur le seul dossier de l'app, commitée :
27
+ L'image telle que la CI du dépôt la construira, sur le seul dossier de l'app, commitée :
28
28
 
29
29
  ```sh
30
30
  c="$(mktemp -d)" && git archive HEAD | tar -x -C "$c" && docker build --build-arg GIT_SHA=local "$c"; rm -rf "$c"
@@ -6,7 +6,7 @@ import { cheminsDesEcrans, creerLeTraitement } from './serveur.ts';
6
6
  // derrière le proxy qui retire `/<nom>`, sur ce chemin.
7
7
  const ecrans = cheminsDesEcrans(JSON.parse(readFileSync(new URL('../manifeste.json', import.meta.url), 'utf8')) as ManifesteDeLApp);
8
8
 
9
- // Ce que le kit lui donne (README.md, « Ce que le kit attend ») : sa base par DATABASE_URL, son
9
+ // Ce que le kit lui donne : sa base par DATABASE_URL, son
10
10
  // adresse publique par ADRESSE, le core par CORE_ADRESSE. `demarrerLApp` ouvre la base, applique les
11
11
  // migrations, relit manifeste.json et GUIDE.md, écoute, et arrête l'app sur SIGTERM.
12
12
  await demarrerLApp({
@@ -11,6 +11,8 @@ export function outils(base: pg.Pool): Outil[] {
11
11
  return [
12
12
  {
13
13
  nom: 'ajouter',
14
+ titre: 'Ajouter une entrée',
15
+ sorte: 'ecriture',
14
16
  description: 'Ajoute une entrée, un texte court de 500 caractères au plus, à celles de la personne. Rend l\'entrée ajoutée.',
15
17
  schema: {
16
18
  type: 'object',
@@ -27,6 +29,8 @@ export function outils(base: pg.Pool): Outil[] {
27
29
  },
28
30
  {
29
31
  nom: 'lister',
32
+ titre: 'Lister ses entrées',
33
+ sorte: 'lecture',
30
34
  description: 'Liste les entrées de la personne, les plus récentes d\'abord, 25 par page. Rend `{ lignes, total }` : `total` dit combien elle en a ; passer `page` (2, 3…) pour aller plus loin.',
31
35
  schema: {
32
36
  type: 'object',
@@ -1,8 +1,7 @@
1
1
  import assert from 'node:assert/strict';
2
2
  import { readFileSync } from 'node:fs';
3
3
  import { test, type TestContext } from 'node:test';
4
- import { appliquerLesMigrations, ouvrirLaBase } from '@indos/bibliotheque/base';
5
- import { ouvrirUneBaseDEssai } from '@indos/bibliotheque/base-d-essai';
4
+ import { ouvrirLaBaseDUnTest } from '@indos/bibliotheque/base-d-essai';
6
5
  import { appeler, connecter, lancerLeFauxCore, servirLApp, type ClientDEssai } from '@indos/bibliotheque/faux-core';
7
6
  import { creerLeTraitement } from '../src/serveur.ts';
8
7
 
@@ -22,13 +21,7 @@ const apps = [{ nom, titre, lien: `https://exemple.ch/${nom}`, ecrans: [{ nom: '
22
21
  // proxy, qui retire son chemin comme `demarrerLApp`, et branchée au core donné ; rend son adresse,
23
22
  // avec son chemin.
24
23
  async function demarrer(t: TestContext, adresseDuCore?: string): Promise<string> {
25
- const essai = await ouvrirUneBaseDEssai();
26
- const base = ouvrirLaBase(essai.adresse, 1);
27
- t.after(async () => {
28
- await base.end();
29
- await essai.fermer();
30
- });
31
- await appliquerLesMigrations(base, new URL('../migrations/', import.meta.url));
24
+ const base = await ouvrirLaBaseDUnTest(t, new URL('../migrations/', import.meta.url));
32
25
  const servie = await servirLApp(t, nom);
33
26
  servie.brancher(creerLeTraitement({ base, adresse: servie.adresse, adresseDuCore, manifeste, instructions }));
34
27
  return servie.adresse;
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@indos/bibliotheque",
3
- "version": "4.3.0",
3
+ "version": "4.5.0",
4
4
  "description": "La bibliothèque des apps d'Indos : le serveur, le MCP, la base et la page de l'espace d'une app.",
5
5
  "license": "SEE LICENSE IN LICENSE",
6
6
  "type": "module",
package/src/app.js CHANGED
@@ -6,8 +6,8 @@ import { appliquerLesMigrations, ouvrirLaBase } from './base.js';
6
6
  import { envoyerLaPage, pageSimple } from './ecran.js';
7
7
  import { fermerLesFlux } from './flux.js';
8
8
  import { sansLeChemin } from './sans-le-chemin.js';
9
- // Le serveur HTTP d'une app : GET /sante (et HEAD) répond « ok » pour la sonde de Coolify
10
- // et de la surveillance ; tout le reste va à l'app.
9
+ // Le serveur HTTP d'une app : GET /sante (et HEAD) répond « ok » pour la sonde de l'image, le kit
10
+ // et la surveillance ; tout le reste va à l'app.
11
11
  export function creerLeServeur(traiter) {
12
12
  const serveur = createServer((requete, reponse) => {
13
13
  const chemin = requete.url?.split('?')[0];
@@ -18,8 +18,8 @@ export function creerLeServeur(traiter) {
18
18
  }
19
19
  traiter(requete, reponse);
20
20
  });
21
- // Le proxy de Coolify (Traefik) garde 90 s une connexion inactive vers l'app et peut y
22
- // envoyer la requête suivante : l'app la garde plus longtemps que lui, sinon c'est une 502.
21
+ // Le proxy garde une connexion inactive vers l'app et peut y envoyer la requête suivante :
22
+ // l'app la garde 95 s.
23
23
  serveur.keepAliveTimeout = 95_000;
24
24
  serveur.headersTimeout = 96_000;
25
25
  return serveur;
package/src/appeler.js CHANGED
@@ -5,8 +5,8 @@ export function estUnRefus(resultat) {
5
5
  return resultat.isError === true && resultat._meta?.['indos/refus'] === true;
6
6
  }
7
7
  // L'appel d'une app à l'outil d'une autre, pour une personne, par le core (bibliotheque/CLAUDE.md,
8
- // « Les pièces »). `par` est le nom de l'app qui appelle ; le kit passe la clé commune des apps dans
9
- // CLE_D_APPEL à toute app dont le compose la cite. Le résultat est celui de l'outil, refus compris ; une erreur ne vient que
8
+ // « Les entrées de la bibliothèque »). `par` est le nom de l'app qui appelle ; le kit passe sa clé d'appel dans
9
+ // CLE_D_APPEL à toute app dont le compose la cite, transmise telle quelle au core. Le résultat est celui de l'outil, refus compris ; une erreur ne vient que
10
10
  // d'un appel que le core refuse (clé, personne ou app inconnue) ou qui n'aboutit pas.
11
11
  export function creerLAppel(par, adresseDuCore = process.env.CORE_ADRESSE, cle = process.env.CLE_D_APPEL) {
12
12
  return async function appeler(app, outil, arguments_, personne) {
@@ -1,4 +1,7 @@
1
+ import type { TestContext } from 'node:test';
2
+ import type pg from 'pg';
1
3
  export declare function ouvrirUneBaseDEssai(): Promise<{
2
4
  adresse: string;
3
5
  fermer: () => Promise<void>;
4
6
  }>;
7
+ export declare function ouvrirLaBaseDUnTest(t: TestContext, migrations?: URL): Promise<pg.Pool>;
@@ -1,9 +1,10 @@
1
1
  import { PGlite } from '@electric-sql/pglite';
2
2
  import { PGLiteSocketServer } from '@electric-sql/pglite-socket';
3
+ import { appliquerLesMigrations, ouvrirLaBase } from './base.js';
3
4
  // Une vraie Postgres en mémoire pour les tests, sans service : PGlite, joint par le protocole
4
5
  // de Postgres. PGlite n'a qu'une session : la base n'accepte qu'une connexion à la fois, pour
5
6
  // que deux transactions ne s'y mêlent jamais sans bruit. Une app s'y branche avec un pool
6
- // d'une connexion (`ouvrirLaBase(adresse, 1)`).
7
+ // d'une connexion (`ouvrirLaBase(adresse, 1)`) : `ouvrirLaBaseDUnTest` le rend.
7
8
  export async function ouvrirUneBaseDEssai() {
8
9
  const db = await PGlite.create();
9
10
  const serveur = new PGLiteSocketServer({ db, host: '127.0.0.1', port: 0, maxConnections: 1 });
@@ -16,3 +17,18 @@ export async function ouvrirUneBaseDEssai() {
16
17
  },
17
18
  };
18
19
  }
20
+ // La base d'un test : une base d'essai neuve, jointe par un pool d'une connexion, avec les
21
+ // migrations du dossier `migrations` quand il est donné. Le pool et la base se ferment à la fin du
22
+ // test.
23
+ export async function ouvrirLaBaseDUnTest(t, migrations) {
24
+ const essai = await ouvrirUneBaseDEssai();
25
+ const base = ouvrirLaBase(essai.adresse, 1);
26
+ t.after(async () => {
27
+ await base.end();
28
+ await essai.fermer();
29
+ });
30
+ if (migrations) {
31
+ await appliquerLesMigrations(base, migrations);
32
+ }
33
+ return base;
34
+ }
@@ -10,6 +10,7 @@ export declare const cleDuFauxCore: KeyObject, clePubliqueDuFauxCore: KeyObject;
10
10
  export declare function fabriquerUnJeton(personne: Personne, app: string, cle?: KeyObject): string;
11
11
  export declare const logoDEssai = "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 10 10\"><rect width=\"10\" height=\"10\"/></svg>";
12
12
  export declare const cleDAppelDuFauxCore = "cle-d-appel-du-faux-core";
13
+ export declare function fabriquerUneCleDAppel(app: string): string;
13
14
  export type NotificationRecue = {
14
15
  par: string;
15
16
  pour: string;
package/src/faux-core.js CHANGED
@@ -3,12 +3,12 @@ import { once } from 'node:events';
3
3
  import { createServer } from 'node:http';
4
4
  import { Client, StreamableHTTPClientTransport } from '@modelcontextprotocol/client';
5
5
  import { creerLeServeur } from './app.js';
6
+ import { deriver } from './deriver.js';
6
7
  import { sansLeChemin } from './sans-le-chemin.js';
7
8
  // Un faux core pour les tests des apps : il sert sa clé publique et signe des jetons, fabriqués
8
9
  // ici à la main, sans le code du core.
9
10
  export const { privateKey: cleDuFauxCore, publicKey: clePubliqueDuFauxCore } = generateKeyPairSync('ed25519');
10
- // Le jeton porte les groupes de la personne quand elle en a (`groupes`), et ne les porte pas sinon,
11
- // comme celui d'un core d'avant 1.7.
11
+ // Le jeton porte les groupes de la personne quand elle en a (`groupes`).
12
12
  export function fabriquerUnJeton(personne, app, cle = cleDuFauxCore) {
13
13
  const iat = Math.floor(Date.now() / 1000);
14
14
  const b64 = (valeur) => Buffer.from(JSON.stringify(valeur)).toString('base64url');
@@ -20,9 +20,27 @@ export function fabriquerUnJeton(personne, app, cle = cleDuFauxCore) {
20
20
  }
21
21
  // Un logo d'essai, à donner au faux core.
22
22
  export const logoDEssai = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 10 10"><rect width="10" height="10"/></svg>';
23
- // La clé commune des apps que le faux core attend à `/notifier`, que le test donne à l'app
24
- // (`creerLeNotificateur(par, adresse, cleDAppelDuFauxCore)`, ou `CLE_D_APPEL`).
23
+ // La clé commune des apps que le faux core reconnaît à `/notifier` et à `/annuaire`, que le test
24
+ // donne à l'app (`creerLeNotificateur(par, adresse, cleDAppelDuFauxCore)`, ou `CLE_D_APPEL`) : l'app
25
+ // y notifie sous le nom qu'elle se donne.
25
26
  export const cleDAppelDuFauxCore = 'cle-d-appel-du-faux-core';
27
+ // La clé maître du faux core, dont dérive la clé d'appel de chaque app.
28
+ const cleMaitreDuFauxCore = Buffer.alloc(32, 9);
29
+ // La clé d'appel d'une app, dans la forme que le kit écrit dans `CLE_D_APPEL` : `<app>.<clé>`, la
30
+ // clé `deriver(clé du core, "appel/<app>")` en base64, ici celle du faux core. Avec elle, l'app
31
+ // notifie sous son seul nom.
32
+ export function fabriquerUneCleDAppel(app) {
33
+ return `${app}.${deriver(cleMaitreDuFauxCore, `appel/${app}`).toString('base64')}`;
34
+ }
35
+ // Qui appelle le faux core, d'après l'en-tête `Authorization`, comme au core : l'app que nomme sa
36
+ // clé, la clé commune, ou rien.
37
+ function quiAppelle(entete) {
38
+ if (entete === `Bearer ${cleDAppelDuFauxCore}`) {
39
+ return { commune: true };
40
+ }
41
+ const app = /^Bearer ([a-z0-9]+(?:-[a-z0-9]+)*)\./.exec(entete ?? '')?.[1];
42
+ return app && entete === `Bearer ${fabriquerUneCleDAppel(app)}` ? { app } : undefined;
43
+ }
26
44
  const notificationsRecues = new Map();
27
45
  // Les notifications qu'a reçues le faux core d'`adresse` (celle que rend `lancerLeFauxCore`), dans
28
46
  // l'ordre d'arrivée, une par personne, de `pour` seulement quand il est donné.
@@ -36,7 +54,7 @@ function estOuverte(app, proprietaire, groupes) {
36
54
  return proprietaire || acces.some((avec) => avec === 'equipe' || groupes.includes(avec));
37
55
  }
38
56
  // Ce que le core rend à `/session` des apps déclarées, pour une personne, dans sa forme
39
- // (bibliotheque/CLAUDE.md, « Les pièces ») : les apps qui lui sont ouvertes, d'après
57
+ // (bibliotheque/CLAUDE.md, « Les entrées de la bibliothèque ») : les apps qui lui sont ouvertes, d'après
40
58
  // ses groupes, dans l'ordre de leur titre, chacune avec ses réglages quand la personne a le droit de
41
59
  // les voir, les écrans qu'elle a le droit de voir, avec leur chemin, et son lien (son premier écran
42
60
  // visible, sinon ses réglages, sinon son lien déclaré) ; puis la barre de départ : le premier écran
@@ -77,16 +95,18 @@ export function sessionDuCore(apps, proprietaire, nomDeLOS, groupes = []) {
77
95
  // l'annuaire, dans l'ordre de leur nom), les apps qui lui sont ouvertes, la barre (`sessionDuCore`,
78
96
  // d'après `apps`, déclarées comme par le kit, à plat et rangée, et son accueil) et le thème
79
97
  // (`theme.nom`, « Indos » par défaut, et la présence de son logo) ; tout autre cookie reçoit 401.
80
- // Il sert les éléments de cette barre à `/espace/barre`, comme le geste du core. Sans app déclarée,
81
- // la session ne rend pas d'`apps`, comme un core d'avant 1.6 : aucune app n'y est fermée. Il sert l'annuaire
82
- // (`GET /annuaire`) : `annuaire`, ou, sans lui, les personnes des sessions, actives, sans groupe.
83
- // L'annuaire est tenu par référence et relu à chaque requête : un test qui retire un membre d'un
84
- // groupe ou désactive une personne en cours de route, sur l'objet qu'il a passé, le voit à l'appel
85
- // suivant.
98
+ // Il sert les éléments de cette barre à `/espace/barre`, comme le geste du core. Une app qu'il ne
99
+ // déclare pas est fermée à tous, comme au core : le test d'une app qui reconnaît la personne à sa
100
+ // session (une page, un geste d'écran, `POST /outils`) la déclare.
101
+ // Il sert l'annuaire (`GET /annuaire`) : `annuaire`, ou, sans lui, les personnes des sessions,
102
+ // actives, sans groupe ; sans en-tête `Authorization`, ou avec la clé d'une app
103
+ // (`fabriquerUneCleDAppel`) ou la clé commune (`cleDAppelDuFauxCore`), 401 avec une autre. L'annuaire est tenu par référence et relu à chaque requête : un test qui
104
+ // retire un membre d'un groupe ou désactive une personne en cours de route, sur l'objet qu'il a
105
+ // passé, le voit à l'appel suivant.
86
106
  // Il sert `theme.logo` sur `/theme/logo.svg`, lu à chaque requête (un test le change en cours de
87
107
  // route), ou 404 sans logo.
88
- // Il reçoit les notifications des apps à `POST /notifier`, comme le core : la clé commune
89
- // (`cleDAppelDuFauxCore`), `{ par, pour, auteur?, sorte, phrase, chemin }`, un chemin sous l'app ;
108
+ // Il reçoit les notifications des apps à `POST /notifier`, comme le core : la clé d'une app, `par`
109
+ // étant son nom (401 sinon), ou la clé commune ; `{ par, pour, auteur?, sorte, phrase, chemin }`, un chemin sous l'app ;
90
110
  // il les garde, à lire par `notificationsDuFauxCore`, et répond `{ notifiees }`. Avec
91
111
  // `notifications: true`, la session porte le nombre de notifications reçues par la personne, comme
92
112
  // celle du core.
@@ -123,7 +143,7 @@ export async function lancerLeFauxCore(t, sessions = {}, theme = {}, apps = [],
123
143
  reponse.end(JSON.stringify({
124
144
  ...personne,
125
145
  groupes,
126
- ...(apps.length ? { apps: ouvertes } : {}),
146
+ apps: ouvertes,
127
147
  barre,
128
148
  rangement,
129
149
  accueil,
@@ -133,6 +153,11 @@ export async function lancerLeFauxCore(t, sessions = {}, theme = {}, apps = [],
133
153
  return;
134
154
  }
135
155
  if (requete.url === '/annuaire') {
156
+ if (requete.headers.authorization !== undefined && !quiAppelle(requete.headers.authorization)) {
157
+ reponse.writeHead(401, { 'content-type': 'application/json' });
158
+ reponse.end(JSON.stringify({ erreur: 'La clé d\'appel ne convient pas.' }));
159
+ return;
160
+ }
136
161
  reponse.writeHead(200, { 'content-type': 'application/json' });
137
162
  reponse.end(JSON.stringify(servi));
138
163
  return;
@@ -155,7 +180,8 @@ async function recevoirUneNotification(requete, reponse, adresse) {
155
180
  reponse.writeHead(statut, { 'content-type': 'application/json' });
156
181
  reponse.end(JSON.stringify(corps));
157
182
  };
158
- if (requete.headers.authorization !== `Bearer ${cleDAppelDuFauxCore}`) {
183
+ const appelant = quiAppelle(requete.headers.authorization);
184
+ if (!appelant) {
159
185
  repondre(401, { erreur: 'La clé d\'appel est refusée.' });
160
186
  return;
161
187
  }
@@ -178,6 +204,10 @@ async function recevoirUneNotification(requete, reponse, adresse) {
178
204
  repondre(400, { erreur: 'Il faut {"par", "pour", "auteur"?, "sorte", "phrase", "chemin"}.' });
179
205
  return;
180
206
  }
207
+ if ('app' in appelant && par !== appelant.app) {
208
+ repondre(401, { erreur: `La clé d'appel est celle de l'app ${appelant.app} : \`par\` doit être ${appelant.app}.` });
209
+ return;
210
+ }
181
211
  if (chemin !== `/${par}` && !chemin.startsWith(`/${par}/`)) {
182
212
  repondre(400, { erreur: `Le chemin d'une notification est sous /${par}.` });
183
213
  return;
package/src/flux.js CHANGED
@@ -2,7 +2,7 @@
2
2
  // (bibliotheque/CLAUDE.md, « Un flux d'événements ») : un commentaire et `retry` à l'ouverture, un
3
3
  // battement qui garde la connexion ouverte au proxy, et la fermeture au bout de sa durée, d'un
4
4
  // lecteur trop lent et à l'arrêt de l'app. La page se reconnecte seule, `retry` après.
5
- // Un commentaire toutes les 25 secondes : le proxy de Coolify coupe une connexion muette à 90.
5
+ // Un commentaire toutes les 25 secondes, qui garde la connexion ouverte à travers le proxy.
6
6
  export const delaiDuBattement = 25_000;
7
7
  // Ce qu'attend le navigateur avant de rouvrir un flux fermé, en millisecondes.
8
8
  export const delaiDeReconnexion = 2_000;
package/src/liens.js CHANGED
@@ -1,6 +1,6 @@
1
1
  import { createHmac, timingSafeEqual } from 'node:crypto';
2
2
  import { deriver } from './deriver.js';
3
- // Les liens signés d'une app (bibliotheque/CLAUDE.md, « Les pièces ») : dix minutes, une charge
3
+ // Les liens signés d'une app (bibliotheque/CLAUDE.md, « Les entrées de la bibliothèque ») : dix minutes, une charge
4
4
  // signée, une clé propre à chaque sorte, tirée de la clé de l'app ; rien n'est gardé en base.
5
5
  export const dureeDUnLien = 600;
6
6
  function cleDeLaSorte(cle, sorte) {
package/src/mcp.d.ts CHANGED
@@ -6,8 +6,11 @@ export declare class Refus extends Error {
6
6
  export type ResultatDOutil = string | {
7
7
  content: CallToolResult['content'];
8
8
  };
9
+ export type SorteDUnOutil = 'lecture' | 'ecriture' | 'definitif';
9
10
  export type Outil = {
10
11
  nom: string;
12
+ titre?: string;
13
+ sorte?: SorteDUnOutil;
11
14
  description: string;
12
15
  schema: Tool['inputSchema'];
13
16
  pour?: (personne: Personne) => boolean;
package/src/mcp.js CHANGED
@@ -52,7 +52,7 @@ export function creerLeMcp(options) {
52
52
  serveur.setRequestHandler('tools/list', async () => ({
53
53
  tools: options.outils
54
54
  .filter((outil) => !outil.pour || outil.pour(personne))
55
- .map((outil) => ({ name: outil.nom, description: outil.description, inputSchema: outil.schema })),
55
+ .map(outilDeLaListe),
56
56
  }));
57
57
  serveur.setRequestHandler('tools/call', async (requete) => ((await appelerLOutil(requete.params.name, requete.params.arguments ?? {}, personne)).resultat));
58
58
  return serveur;
@@ -133,7 +133,25 @@ export function creerLeMcp(options) {
133
133
  await traiterLeMcp(requete, reponse);
134
134
  };
135
135
  }
136
- // Le chemin de la requête dans l'app : le proxy de Coolify retire le chemin de l'app, retiré ici
136
+ // Les annotations MCP de chaque sorte, que le client de Claude lit pour ranger les outils et
137
+ // demander l'accord.
138
+ const annotationsDeLaSorte = {
139
+ lecture: { readOnlyHint: true },
140
+ ecriture: { readOnlyHint: false, destructiveHint: false },
141
+ definitif: { readOnlyHint: false, destructiveHint: true },
142
+ };
143
+ // Un outil tel que `tools/list` le rend : son titre en `title`, sa sorte en annotations, chacun
144
+ // seulement s'il le déclare.
145
+ function outilDeLaListe(outil) {
146
+ return {
147
+ name: outil.nom,
148
+ ...(outil.titre === undefined ? {} : { title: outil.titre }),
149
+ description: outil.description,
150
+ inputSchema: outil.schema,
151
+ ...(outil.sorte === undefined ? {} : { annotations: { ...annotationsDeLaSorte[outil.sorte] } }),
152
+ };
153
+ }
154
+ // Le chemin de la requête dans l'app : le proxy retire le chemin de l'app, retiré ici
137
155
  // s'il arrive quand même.
138
156
  function cheminDansLApp(requete, adresse) {
139
157
  const chemin = new URL(requete.url ?? '/', 'http://app').pathname;
package/src/notifier.js CHANGED
@@ -3,7 +3,7 @@
3
3
  // montre dans l'écran « Notifications » et par la cloche de la barre.
4
4
  // Le délai laissé au core pour répondre, en millisecondes.
5
5
  export const delaiDUneNotification = 3_000;
6
- // La notification d'une app, vers le core (`CORE_ADRESSE/notifier`), avec la clé commune des apps
6
+ // La notification d'une app, vers le core (`CORE_ADRESSE/notifier`), avec sa clé d'appel
7
7
  // (`CLE_D_APPEL`, que le kit passe à toute app dont le compose la cite). `par` est le nom de l'app.
8
8
  //
9
9
  // `notifier` part après l'écriture validée, jamais dans une transaction, une seule fois, sans nouvel
package/src/partage.d.ts CHANGED
@@ -30,7 +30,7 @@ type SchemaDUnArgument = NonNullable<Outil['schema']['properties']>[string];
30
30
  export declare const dureeDeLAnnuaire = 5000;
31
31
  export declare function suffit(droit: DroitSurLaChose | undefined, attendu: DroitSurLaChose): boolean;
32
32
  export declare function ouverturesDe(personne: Personne): string[];
33
- export declare function creerLAnnuaire(adresseDuCore?: string | undefined, horloge?: () => number): ({ sansCache }?: {
33
+ export declare function creerLAnnuaire(adresseDuCore?: string | undefined, horloge?: () => number, cle?: string | undefined): ({ sansCache }?: {
34
34
  sansCache?: boolean;
35
35
  }) => Promise<Annuaire>;
36
36
  export declare function nomDe(annuaire: Annuaire, id: string): string;
package/src/partage.js CHANGED
@@ -16,19 +16,20 @@ export function suffit(droit, attendu) {
16
16
  export function ouverturesDe(personne) {
17
17
  return ['equipe', `personne:${personne.id}`, ...(personne.groupes ?? []).map((groupe) => `groupe:${groupe}`)];
18
18
  }
19
- // Lit l'annuaire du core (`CORE_ADRESSE/annuaire`), gardé `dureeDeLAnnuaire`. Un core qui n'en a
20
- // pas (d'avant 1.7, 404) rend un annuaire vide ; un core qui ne répond pas lève une erreur, qui
21
- // n'est pas gardée. `{ sansCache: true }` le relit au core, pour un geste qui décide sur ce qu'il
22
- // dit, comme le don des choses d'une personne désactivée ; la lecture remplace celle gardée.
19
+ // Lit l'annuaire du core (`CORE_ADRESSE/annuaire`), gardé `dureeDeLAnnuaire`. Un core qui ne le
20
+ // donne pas, ou qui ne répond pas, lève une erreur, qui n'est pas gardée. `{ sansCache: true }` le
21
+ // relit au core, pour un geste qui décide sur ce qu'il dit, comme le don des choses d'une personne
22
+ // désactivée ; la lecture remplace celle gardée. `cle`, la clé d'appel de l'app (`CLE_D_APPEL` par
23
+ // défaut), part en `Authorization: Bearer <cle>` ; sans elle, l'annuaire se demande sans en-tête.
23
24
  // `horloge` ne sert qu'aux tests.
24
- export function creerLAnnuaire(adresseDuCore = process.env.CORE_ADRESSE, horloge = Date.now) {
25
+ export function creerLAnnuaire(adresseDuCore = process.env.CORE_ADRESSE, horloge = Date.now, cle = process.env.CLE_D_APPEL) {
25
26
  let garde;
26
27
  return function lireLAnnuaire({ sansCache = false } = {}) {
27
28
  if (!adresseDuCore) {
28
29
  return Promise.reject(new Error('La variable CORE_ADRESSE manque : l\'adresse interne du core vient du kit.'));
29
30
  }
30
31
  if (sansCache || !garde || horloge() - garde.lu >= dureeDeLAnnuaire) {
31
- const lecture = { lu: horloge(), annuaire: demanderLAnnuaire(new URL('/annuaire', adresseDuCore)) };
32
+ const lecture = { lu: horloge(), annuaire: demanderLAnnuaire(new URL('/annuaire', adresseDuCore), cle) };
32
33
  lecture.annuaire.catch(() => {
33
34
  if (garde === lecture) {
34
35
  garde = undefined;
@@ -39,11 +40,8 @@ export function creerLAnnuaire(adresseDuCore = process.env.CORE_ADRESSE, horloge
39
40
  return garde.annuaire;
40
41
  };
41
42
  }
42
- async function demanderLAnnuaire(adresse) {
43
- const reponse = await fetch(adresse, { signal: AbortSignal.timeout(5000) });
44
- if (reponse.status === 404) {
45
- return { personnes: [], groupes: [] };
46
- }
43
+ async function demanderLAnnuaire(adresse, cle) {
44
+ const reponse = await fetch(adresse, { headers: cle ? { authorization: `Bearer ${cle}` } : {}, signal: AbortSignal.timeout(5000) });
47
45
  if (!reponse.ok) {
48
46
  throw new Error(`Le core ne donne pas l'annuaire : ${reponse.status}.`);
49
47
  }
@@ -168,7 +166,7 @@ export function creerLePartage(options) {
168
166
  // lit le droit : la racine, ou la chose elle-même.
169
167
  const depuis = racine ? `${table} join ${table} as racine on racine.id = ${table}.${racine}` : table;
170
168
  const aliasDuDroit = racine ? 'racine' : table;
171
- const lireLAnnuaire = creerLAnnuaire(options.adresseDuCore ?? process.env.CORE_ADRESSE);
169
+ const lireLAnnuaire = creerLAnnuaire(options.adresseDuCore ?? process.env.CORE_ADRESSE, Date.now, options.cleDAppel);
172
170
  const { chemin } = options;
173
171
  const nomAffiche = (lu) => (lu?.trim() ? lu : options.sansNom ?? 'Sans titre');
174
172
  // La notification d'une chose : `notifier` ne lève jamais, et part après l'écriture, hors de toute
@@ -478,6 +476,8 @@ export function creerLePartage(options) {
478
476
  export function outilDeDonnerLesChoses(partage, { apresUnDon } = {}) {
479
477
  return {
480
478
  nom: 'donner_les_choses',
479
+ titre: 'Donner ce qu\'avait une personne désactivée',
480
+ sorte: 'definitif',
481
481
  description: 'Au propriétaire de l\'OS seul : donne toutes les choses de cette app d\'une personne désactivée (`de`, son courriel) à une personne active de l\'équipe (`a`), qui en devient propriétaire ; leur partage reste. Une chose rangée dans une autre suit sa racine. Refusé pour une personne encore active : la désactiver d\'abord dans « Équipe ». Rend `{ nombre, choses }`, les choses données.',
482
482
  schema: schemaDeDonnerLesChoses(),
483
483
  pour: (personne) => personne.proprietaire,
package/src/session.js CHANGED
@@ -20,8 +20,7 @@ export function creerLaSession(adresse = process.env.ADRESSE, adresseDuCore = pr
20
20
  }
21
21
  // La session de la personne connectée, ou rien. Un core qui ne répond pas lève une erreur : l'app
22
22
  // répond par une erreur plutôt que de renvoyer vers une connexion qui ne répondrait pas non plus.
23
- // Une app est ouverte à la personne quand elle est parmi les apps que rend le core. Un core qui ne
24
- // rend pas les groupes ou les apps (d'avant 1.7, où toute app est ouverte à tous) n'en ferme aucune.
23
+ // Une app est ouverte à la personne quand elle est parmi les apps que rend le core.
25
24
  async function lireLaSession(requete) {
26
25
  if (!adresseDuCore) {
27
26
  throw new Error('La variable CORE_ADRESSE manque : l\'adresse interne du core vient du kit.');
@@ -45,7 +44,7 @@ export function creerLaSession(adresse = process.env.ADRESSE, adresseDuCore = pr
45
44
  const lues = appsDe(apps);
46
45
  return {
47
46
  personne: { id, email, nom, proprietaire, groupes: groupesDe(groupes), apps: lues, barre: barreDe(barre), theme: themeDe(theme) },
48
- ouvre: (app) => !Array.isArray(groupes) || !Array.isArray(apps) || lues.some((lue) => lue.nom === app),
47
+ ouvre: (app) => lues.some((lue) => lue.nom === app),
49
48
  corps,
50
49
  };
51
50
  }
@@ -116,7 +115,7 @@ function appsDe(apps) {
116
115
  });
117
116
  }
118
117
  // Les groupes de la personne, `[{ id, nom }]` dans `/session` : leurs identifiants, comme dans le
119
- // jeton. Un core qui ne les rend pas (d'avant 1.7) la met dans aucun groupe.
118
+ // jeton.
120
119
  function groupesDe(groupes) {
121
120
  return listeDe(groupes).flatMap(({ id }) => (typeof id === 'string' ? [id] : []));
122
121
  }
package/src/theme.js CHANGED
@@ -1,4 +1,4 @@
1
- // Le thème du client, que sert le core (bibliotheque/CLAUDE.md, « Les pièces ») : ses
1
+ // Le thème du client, que sert le core (bibliotheque/CLAUDE.md, « Les entrées de la bibliothèque ») : ses
2
2
  // variables CSS, lues à CORE_ADRESSE et gardées une minute. Si le core ne répond pas, le thème est
3
3
  // vide et la page garde les couleurs du navigateur. `horloge` ne sert qu'aux tests.
4
4
  export function creerLeLecteurDuTheme(adresseDuCore = process.env.CORE_ADRESSE, horloge = Date.now) {
package/src/vite.js CHANGED
@@ -99,12 +99,12 @@ function configuration(dossier, base) {
99
99
  export async function construireLaPage(dossier) {
100
100
  await build({ ...configuration(dossier, lirePiece(dossier).base), mode: 'production' });
101
101
  }
102
- // Les chemins sous la base d'une app que le serveur de développement garde, sans les relayer à
103
- // l'app : les siens, d'où Vite sert la page et ses modules (`@vite/client`, `@react-refresh`,
102
+ // Les chemins sous la base d'une pièce que le serveur de développement garde, sans les relayer à
103
+ // l'app ou au core : les siens, d'où Vite sert la page et ses modules (`@vite/client`, `@react-refresh`,
104
104
  // `@fs/…`, `@id/…`, et chaque fichier du dossier `espace/`, comme `<base>page.tsx`) ; le websocket du
105
105
  // rechargement à chaud (son protocole, `vite-hmr` ou `vite-ping`) ; et le `GET` d'un écran du
106
- // manifeste, dont il sert la page : `<base><écran>` et ce qui est dessous, `<base>reglages` pour une
107
- // app qui a des réglages, et, pour une app à choses (son écran `liste`), l'écran d'une chose et la
106
+ // manifeste, dont il sert la page : `<base><écran>` et ce qui est dessous (pour le core, `/bienvenue`
107
+ // ou `/documentation/<app>`), `<base>reglages` pour une app qui a des réglages, et, pour une app à choses (son écran `liste`), l'écran d'une chose et la
108
108
  // chose seule (`estUnEcranDesChoses`). La fonction rendue le dit d'une requête.
109
109
  export function cheminsGardes(dossier) {
110
110
  const page = join(dossier, 'espace');
@@ -142,15 +142,28 @@ export function cheminsGardes(dossier) {
142
142
  return ecrans.some((ecran) => dansLaBase === ecran || dansLaBase.startsWith(`${ecran}/`)) || (aChoses && estUnEcranDesChoses(`/${dansLaBase}`));
143
143
  };
144
144
  }
145
- // Les relais du serveur de développement. Vers le core : la connexion et l'auth, la session, le
146
- // thème et les gestes du core (sous `/espace/`), en lui présentant son origine et son hôte, ses
147
- // cookies posés pour le serveur de développement, et ses renvois vers lui-même ramenés au serveur
148
- // de développement. `/theme/variables.css` cite les polices à l'adresse publique du core : le relais
149
- // la ramène au serveur de développement, d'où la page charge les polices, de sa propre origine. Vers
150
- // l'app lancée en local (une app, pas le core) : tout ce qui est sous sa base et que `garde` ne
151
- // garde pas, quelle qu'en soit la méthode, websockets compris, sans le chemin de l'app, comme le
152
- // proxy du serveur, avec l'origine et l'hôte du serveur de développement.
145
+ // Les relais du serveur de développement.
146
+ // Pour le core, la pièce est le core lancé en local, à `core`, avec pour `ADRESSE` celle du serveur
147
+ // de développement : tout ce que `garde` ne garde pas lui va, quelle qu'en soit la méthode,
148
+ // websockets compris, avec l'origine et l'hôte du serveur de développement.
149
+ // Pour une app, vers le core : la connexion et l'auth, la session, le thème et les gestes du core
150
+ // (sous `/espace/`), en lui présentant son origine et son hôte, ses cookies posés pour le serveur de
151
+ // développement, et ses renvois vers lui-même ramenés au serveur de développement.
152
+ // `/theme/variables.css` cite les polices à l'adresse publique du core : le relais la ramène au
153
+ // serveur de développement, d'où la page charge les polices, de sa propre origine. Vers l'app lancée
154
+ // en local : tout ce qui est sous sa base et que `garde` ne garde pas, quelle qu'en soit la méthode,
155
+ // websockets compris, sans le chemin de l'app, comme le proxy du serveur, avec l'origine et l'hôte
156
+ // du serveur de développement.
153
157
  export function relais(options) {
158
+ if (options.base === '/') {
159
+ return {
160
+ '^/': {
161
+ target: new URL(options.core).origin,
162
+ ws: true,
163
+ bypass: (requete) => (options.garde(requete) ? requete.url : undefined),
164
+ },
165
+ };
166
+ }
154
167
  const origineDuCore = new URL(options.core).origin;
155
168
  const versLeCore = {
156
169
  target: origineDuCore,
@@ -192,20 +205,18 @@ export function relais(options) {
192
205
  '^/theme/variables\\.css': variablesDuCore,
193
206
  '^/(connexion|deconnexion|auth/|mot-de-passe|espace/|theme/)': versLeCore,
194
207
  };
195
- if (options.base !== '/') {
196
- relais[`^${options.base}`] = {
197
- target: new URL(options.app).origin,
198
- ws: true,
199
- bypass: (requete) => (options.garde(requete) ? requete.url : undefined),
200
- rewrite: (chemin) => chemin.slice(options.base.length - 1),
201
- };
202
- }
208
+ relais[`^${options.base}`] = {
209
+ target: new URL(options.app).origin,
210
+ ws: true,
211
+ bypass: (requete) => (options.garde(requete) ? requete.url : undefined),
212
+ rewrite: (chemin) => chemin.slice(options.base.length - 1),
213
+ };
203
214
  return relais;
204
215
  }
205
216
  // La configuration du serveur de développement de la pièce, sur `http://localhost:<port>`
206
217
  // (`portDeDeveloppement` par défaut), à l'écoute de `hote` (localhost par défaut ; `0.0.0.0` dans un
207
- // conteneur que joint un proxy), reliée au core de `core` (celui d'un espace ou un core local)
208
- // et, pour une app, à l'app lancée en local à `app`. Après la connexion, le core ramène à `/` : pour
218
+ // conteneur que joint un proxy), reliée au core de `core` (pour une app, celui d'un espace ou un core
219
+ // local ; pour le core, le core lancé en local) et, pour une app, à l'app lancée en local à `app`. Après la connexion, le core ramène à `/` : pour
209
220
  // une app, la racine mène à son premier écran.
210
221
  export function configurationDuDeveloppement(dossier, options) {
211
222
  const piece = lirePiece(dossier);