Aller au contenu

Ponts entre espaces

43 routes. Chemins relatifs à https://api.nexus-engine.eu/api/v1.

GET /ponts/espaces

Mes AUTRES espaces de travail (la même personne, adresse prouvée), comme destinations d’un transfert : ce qui manque pour y recevoir (administrateur, second facteur à passer).

Réponse{ espaces: EspaceDestinationDto[] }
POST /ponts/transferts

Copier, déplacer ou synchroniser des sites, des machines et des accès vers un autre de MES espaces (administrateur des deux). `apercu: true` n’écrit rien et dit ce qui part et ce qui ne suit pas. `secrets: true` envoie les secrets (rechiffrés dans le serveur, jamais rendus) : une personne, ou l’agent qu’elle conduit. DEPLACEMENT supprime ici après relecture : une personne seulement.

Corps{ versAgencyId, mode: COPIE|DEPLACEMENT|SYNCHRO, sites?, serveurs?, acces?, secrets?, apercu? }
RéponseTransfertResultatDto
GET /ponts/transferts

Les liens de copie synchronisée dont mon espace est un bout (SORTANT : il fait foi ; ENTRANT : il reçoit), leur état et leur dernière synchronisation. Administrateur.

Réponse{ liens: PontTransfertDto[] }
POST /ponts/transferts/:id/synchroniser

Resynchroniser maintenant une copie depuis l’espace qui fait foi (sinon : à chaque écriture, et un tour toutes les quinze minutes). Administrateur de l’espace de départ.

Réponse{ resultat: ok|inchange|fini }
DELETE /ponts/transferts/:id

Rompre un lien de copie synchronisée, d’un bout ou de l’autre : la copie reste une fiche ordinaire de l’espace d’arrivée. Administrateur.

Réponse{ ok: true }
POST /ponts/invitations

Inviter un membre d’un AUTRE espace de travail à un objet de mon espace (projet, création, portefeuille Social Hub), sur son adresse : il le voit dans SON espace, sans basculer, une fois qu’il a accepté. Une personne ou son agent ; journalisé. Refusé sur un projet en mode aveugle, et pour une adresse déjà membre ici.

Corps{ objetType: PROJET|CREATION|PORTEFEUILLE, objetId, email, permission?: LECTURE|COMMENTAIRE|ECRITURE, message?, coffre?: boolean, coffreAgents?: boolean }
Réponse{ invitation: PontInvitationDto }
NoteLe coffre d’un projet ne s’ouvre que par `coffre` (et `coffreAgents` pour les agents de la personne) — jamais par la permission seule, et seulement par une personne en session (403 `PERSONNE_SEULE` pour un agent ou une clé). Un accès seul se partage par POST /acces/:id/ponts.
GET /ponts/invitations

Les invitations hors de l’espace d’un objet que je peux ouvrir : l’adresse, la permission, l’état, et le nom de la personne une fois acceptée — jamais son espace.

RequêteobjetType, objetId
Réponse{ invitations: PontInvitationDto[] }
PATCH /ponts/invitations/:id

Changer la permission d’une invitation (lecture, commentaire, écriture). Jamais plus : inviter et retirer restent aux membres de l’espace. Sur un pont qui ouvre le coffre (un accès partagé, ou un projet dont le coffre est ouvert), réservé à une personne en session : 403 `PERSONNE_SEULE` pour un agent ou une clé.

Corps{ permission }
Réponse{ invitation: PontInvitationDto }
PATCH /ponts/invitations/:id/coffre session de l’application seulement

Ouvrir ou fermer le coffre d’une invitation : pour un projet, `coffre` (la personne lit les accès DU PROJET — jamais ceux des machines ou des sites) et `coffreAgents` (ses agents aussi, qui exige `coffre`) ; pour un accès partagé, `coffreAgents` seul. Refermer le coffre d’un pont accepté sonne les secrets lus (`SECRET_ROTATION`).

Corps{ coffre?: boolean, coffreAgents?: boolean }
Réponse{ invitation: PontInvitationDto }
NoteUn secret sort de l’entreprise, ou se met à portée d’agents : le geste d’une personne en session. Journal `pont.invitation-coffre`.
POST /acces/:id/ponts session de l’application seulement

Partager UN accès du coffre (entreprise, projet ou machine) avec une personne d’un AUTRE espace, sur son adresse prouvée : un POINTEUR — elle lit la fiche vivante d’ici, un changement d’ici se voit aussitôt chez elle. LECTURE : la fiche et le secret sur demande ; ÉCRITURE : en plus, modifier la fiche et le secret, jamais supprimer. `coffreAgents` : ses agents le reçoivent aussi (jamais un accès caché des agents).

Corps{ email, permission?: LECTURE|COMMENTAIRE|ECRITURE, coffreAgents?: boolean, message? }
Réponse{ invitation: PontInvitationDto }
NoteRéservé à une personne en session qui peut révéler cet accès. Refusé (409 `MODE_AVEUGLE`) pour un accès rangé dans un projet couvert, (409 `DEJA_MEMBRE`) pour une adresse membre d’ici. Journal `pont.invitation`.
GET /acces/:id/ponts

Les partages d’un accès avec d’autres espaces : l’adresse, la permission, ses agents ou non, l’état, le nom de la personne une fois acceptée, et combien de fois un secret a été révélé par ce pont.

Réponse{ invitations: PontInvitationDto[] }
GET /ponts/coffre

Les accès du coffre que d’AUTRES espaces m’ouvrent, à cet instant (« Partagés avec moi ») : des accès partagés, et le coffre des projets partagés dont le coffre est ouvert — sans secret, avec l’entreprise d’origine et qui a partagé. Un agent ne reçoit que les ponts ouverts aux agents ; `?projet=` borne aux ponts que la personne a rattachés à CE projet de son espace.

Requêteprojet?
Réponse{ acces: AccesPartageAvecMoiDto[], avertissement }
GET /ponts/invitations/:id/acces/:accesId/secret

Révéler le secret d’un accès partagé avec moi. Compté sur le plafond de révélation ; journalisé chez moi (`pont.secret-revele`) et chez qui partage (`secret.revele`, avec mon nom). Un agent n’y entre que si le pont est ouvert aux agents et l’accès exposé aux agents là-bas.

Réponse{ secret: string | null, avertissement }
NoteL’invitation et l’AUTORITÉ de qui a partagé sont relues à chaque appel : compte désactivé, retiré du projet, accès supprimé = 404.
PATCH /ponts/invitations/:id/acces/:accesId

Modifier un accès partagé avec moi en ÉCRITURE : libellé, environnement, hôte, port, identifiant, adresse, base, notes, secret — dans l’espace qui partage (le même accès). Jamais supprimer, jamais changer son exposition aux agents.

Corps{ label?, environment?, host?, port?, username?, url?, database?, notes?, secret? }
Réponse{ acces: AccesPartageAvecMoiDto }
NoteJournal `pont.acces-modifie` chez moi, `acces.modifie-par-pont` chez qui partage (jamais la valeur du secret).
PUT /ponts/recues/:id/projet-agents session de l’application seulement

Choisir le projet de MON espace dont les agents reçoivent ce qu’un pont m’ouvre du coffre (list_project_credentials, get_project_credential, run_server_command…) — `null` : aucun. Il faut aussi que l’espace qui partage ait ouvert le pont à mes agents.

Corps{ projectId: string | null }
Réponse{ projetAgentsId: string | null }
NoteChoisir avec quelle clé ses agents agiront ne se délègue pas : une personne en session.
DELETE /ponts/invitations/:id

Révoquer une invitation : la requête suivante de l’invité rend 404. Ce qu’il a écrit reste.

Réponse{ invitation: PontInvitationDto }
GET /ponts/recues

Les invitations qu’un membre d’un autre espace adresse à mon adresse prouvée — projets, créations, portefeuilles Social Hub partagés avec moi : l’objet, l’entreprise, qui invite, la permission, l’état. C’est la porte d’entrée : un partage ACCEPTÉ se lit ensuite par /ponts/invitations/:id/projet, …/creation ou …/portefeuille, sans changer d’espace.

Réponse{ recues: PontRecuDto[] }
POST /ponts/recues/:id/accepter session de l’application seulement

Accepter une invitation d’un autre espace : l’objet devient lisible d’ici, selon la permission.

Réponse{ recue: PontRecuDto }
NoteRéservé à la personne invitée, en session : une clé d’API ou un agent reçoivent 403. Accepter fait entrer le contenu d’une autre entreprise à portée de ses agents.
POST /ponts/recues/:id/refuser

Refuser une invitation en attente, ou quitter un partage accepté.

Réponse{ ok: true }
POST /ponts/recues/:id/quitter

Quitter un partage accepté (même porte que refuser).

Réponse{ ok: true }
GET /ponts/invitations/:id/projet

Le projet partagé avec moi par un autre espace : la fiche, l’équipe (des noms), les tâches, les discussions de l’équipe (jamais une privée), les fichiers, les derniers messages du fil. L’invitation est relue à chaque requête : révoquée, quittée ou le projet passé en mode aveugle, 404.

Réponse{ pont, projet, equipe, taches, discussions, fichiers, messages, avertissement }
GET /ponts/invitations/:id/projet/discussions/:sessionId

Une discussion de l’équipe du projet partagé : son fil, borné aux 300 derniers messages.

Réponse{ id, titre, auteur, messages, tronquee, avertissement }
GET /ponts/invitations/:id/projet/fichiers/:pieceId

Un fichier du projet partagé, en base64 (8 Mo au plus).

Réponse{ nom, type, dataBase64 }
POST /ponts/invitations/:id/projet/messages

Écrire dans le fil de l’équipe du projet partagé (permission COMMENTAIRE ou ÉCRITURE). Journalisé dans l’espace qui invite.

Corps{ texte }
Réponse{ id, le }
POST /ponts/invitations/:id/projet/taches

Créer une tâche dans le projet partagé (permission ÉCRITURE). L’auteur est l’invité, nommé tel quel.

Corps{ titre, description? }
Réponse{ id }
PATCH /ponts/invitations/:id/projet/taches/:taskId

Modifier le titre, la description ou le statut d’une tâche du projet partagé (permission ÉCRITURE).

Corps{ titre?, description?, statut?: TODO|IN_PROGRESS|IN_REVIEW|DONE }
Réponse{ ok: true }
GET /ponts/invitations/:id/politique

La POLITIQUE D’AUTONOMIE d’une invitation de mon espace (projet ou accès) : ce que la personne invitée d’un autre espace, et ses agents, peuvent faire — capacités, règles de connecteur (WordPress…), consignes —, sa version, qui l’a rédigée, l’ouverture du partage (permission, coffre) et un résumé en clair. `consigneAgent` dit comment un agent la règle.

Réponse{ politique: PolitiquePontDto }
NoteAbsente (`politique: null`) : le comportement d’avant. Une politique RESTREINT ce que le partage ouvre, elle n’ouvre jamais (doctrine : ponts-permissions-13-novembre).
PUT /ponts/invitations/:id/politique

Écrire la politique d’autonomie d’une invitation de mon espace — une version de plus, journalisée (`pont.politique`). Une personne ou son agent : analyser d’abord le projet (get_project, connector_describe), puis écrire, puis dire en clair à la personne ce que l’invité pourra et ne pourra pas faire. L’invité ne l’écrit jamais (404).

Corps{ politique: { niveau, capacites: CapacitePolitique[], connecteurs: [{ service, regles: [{ methodes, chemin, effet: PERMIS|REFUS, champs?, note? }] }], consignes } | null } — ou { niveau: TOUT_GERER|CONTENU_SEULEMENT|CONSULTATION, consignes? }
Réponse{ politique: PolitiquePontDto }
NoteCapacités : PROJET_LIRE, DISCUSSIONS_LIRE, MESSAGES_ECRIRE, TACHES_ECRIRE, DEMANDES_LIRE, COFFRE_LIRE, COFFRE_ECRIRE, CODE_ECRIRE, DEPLOYER_PREPROD, DEPLOYER_PROD, SERVEUR_LIRE, SERVEUR_ECRIRE, BASE_LIRE, BASE_ECRIRE, PRODUCTION. Un chemin de règle est celui de connector_describe (`/wp/v2/posts*`) ; un REFUS l’emporte ; ce qu’aucune règle ne couvre est refusé. Création et portefeuille : 400.
GET /ponts/invitations/:id/politique/versions

Les versions successives de la politique d’une invitation de mon espace, de la plus récente à la plus ancienne : le contenu, qui l’a rédigée (personne ou agent) et quand.

Réponse{ versions: VersionPolitiqueDto[] }
GET /ponts/recues/:id/politique

CE QUE MON ACCÈS PERMET : la politique d’autonomie qu’un autre espace a posée sur une invitation qu’il m’a faite — en lecture seule, avec son résumé en clair. À lire avant d’agir sur un projet partagé : un geste hors d’elle est refusé (403 `POLITIQUE`), et il ne se réessaie pas par un autre chemin.

Réponse{ politique: PolitiquePontDto & { avertissement } }
GET /ponts/invitations/:id/projet/demandes

Les demandes reçues des sites du projet partagé avec moi (portail client, demandes saisies) et leur premier message. N’existe que si la politique du partage accorde DEMANDES_LIRE.

Réponse{ demandes: [{ id, statut, site, creeLe, derniereActivite, auteur, premierMessage, messages }], avertissement }
GET /ponts/invitations/:id/connecteurs

Les connecteurs du projet partagé avec moi (WordPress, Stripe…) que la politique du partage nomme, et ses règles. Sans politique : aucun.

Réponse{ connecteurs: [{ slug, mode, site, siteLibelle }], regles, note, avertissement }
POST /ponts/invitations/:id/connecteurs/:slug/requete

Appeler un connecteur du projet partagé avec moi — même corps que connector_request. Jugé par la politique du partage (méthode, chemin, champs) AVANT de partir ; la clé ne quitte jamais l’espace qui partage. Une écriture demande aussi la permission ÉCRITURE. Journalisé des deux côtés.

Requêtemode (DEVELOPMENT|PRODUCTION)
Corps{ method, path, params?, cible?, fichier?, xml? }
RéponseReponseAppelDto & { avis }
NoteUn refus de la politique rend 403 `POLITIQUE` avec ce qui manque : le dire à la personne, ne pas réessayer par un autre chemin.
GET /ponts/invitations/:id/creation

Une création du Studio partagée avec moi par un AUTRE espace (`:id` = l’invitation acceptée, lue dans GET /ponts/recues) : la fiche, ses versions (sans contenu) et ses commentaires. L’invitation est relue à chaque requête : révoquée, quittée, création retirée ou projet en mode aveugle, 404.

RéponseCreationPartageeDto { pont, creation, versions, commentaires, avertissement }
GET /ponts/invitations/:id/creation/versions/:n/contenu

Le contenu d’une version de la création partagée, en base64 (8 Mo au plus). Un fichier gardé sur les postes de l’autre espace et pas encore sur le serveur est DEMANDÉ à ces postes : `attente` vrai, `raison` le dit — relire plus tard.

RéponseContenuPartageDto { nom, type, taille, adresse, dataBase64, attente, raison }
GET /ponts/invitations/:id/creation/versions/:n/vignette

La vignette d’une version de la création partagée.

Réponse{ type, dataBase64 }
GET /ponts/invitations/:id/creation/versions/:n/pieces/:nom

Une pièce posée à côté du fichier principal d’une version partagée (l’image d’une page, le rush d’un montage), par son NOM. Même règle d’attente que le contenu.

RéponseContenuPartageDto
POST /ponts/invitations/:id/creation/commentaires

Commenter la création partagée (permission COMMENTAIRE ou ÉCRITURE) : le commentaire arrive « à traiter » dans l’atelier de l’autre espace, signé « nom (autre espace) ». Journalisé là-bas.

Corps{ texte, version? }
Réponse{ id, le }
POST /ponts/invitations/:id/creation/versions

Déposer une NOUVELLE version de la création partagée (permission ÉCRITURE, 15 Mo au plus) — jamais remplacer, jamais valider ni publier. Le même contrôle que tout fichier du Studio.

Corps{ nomFichier, dataBase64, note? }
Réponse{ version }
GET /ponts/invitations/:id/portefeuille

Un portefeuille Social Hub partagé avec moi par un AUTRE espace : ses comptes (réseau, nom, abonnés — jamais un jeton), ses publications et son plan de contenu. Relu à chaque requête.

RéponsePortefeuillePartageDto { pont, portefeuille, comptes, publications, contenus, avertissement }
POST /ponts/invitations/:id/portefeuille/contenus

Ajouter une carte au plan de contenu du portefeuille partagé : une IDÉE en permission COMMENTAIRE ; en ÉCRITURE, aussi « en rédaction » ou « à relire ». Valider, programmer, publier restent à l’autre espace.

Corps{ titre, brief?, genre?, etat?: IDEE|EN_REDACTION|A_RELIRE, date? }
Réponse{ id }
PATCH /ponts/invitations/:id/portefeuille/contenus/:carteId

Modifier une carte du plan de contenu partagé (permission ÉCRITURE), tant qu’elle n’est ni validée, ni programmée, ni publiée (409 sinon).

Corps{ titre?, brief?, etat?, date? }
Réponse{ ok: true }
POST /ponts/invitations/:id/portefeuille/brouillons

Écrire un BROUILLON de publication sur des comptes du portefeuille partagé (permission ÉCRITURE). Il naît sans date : le programmer et le publier restent à l’autre espace.

Corps{ texte, comptes: string[], note? }
Réponse{ id }