@deveye/types 0.15.0

package/src/features/database.ts

@@ -0,0 +1,461 @@
+import { z } from 'zod';
+import {
+    DATABASE_ALERT_MESSAGE_MAX_LENGTH,
+    DATABASE_ALERT_NAME_MAX_LENGTH,
+    DATABASE_HOST_MAX_LENGTH,
+    DATABASE_NAME_MAX_LENGTH,
+    DATABASE_SECRET_MAX_LENGTH,
+    DATABASE_SQL_MAX_LENGTH,
+    DATABASE_USER_MAX_LENGTH,
+    databaseAccessKindSchema,
+    databaseAlertSchema,
+    databaseCellSchema,
+    databaseCombinatorSchema,
+    databaseConditionSchema,
+    databaseEngineSchema,
+    databaseExecutionSchema,
+    databaseExportFormatSchema,
+    databaseFilterSchema,
+    databaseIdRangeSchema,
+    databaseProbeSchema,
+    databaseRowsSchema,
+    databaseSchema,
+    databaseSortSchema,
+    databaseSshAuthSchema,
+    databaseStructureSchema,
+    databaseTableSchema,
+    databaseUsageSchema
+} from '../domain/database';
+
+/**
+ * Commandes des bases de données de l'espace.
+ *
+ * Préfixe unique `database.`, comme `git.` et `project.` — d'où le camelCase
+ * derrière le point.
+ *
+ * ⚠️ Conséquence à connaître : le filet de démarrage (`MUTATION_VERB` dans
+ * `src/features/_topics.ts`) cherche un verbe **juste après le point**. Il ne
+ * verra donc **aucune** de ces commandes, et un `mutates` oublié ne produira
+ * aucun avertissement. Il se relit à la main.
+ *
+ * ## Rien ne se connecte tout seul
+ *
+ * Seules `test`, `inspect`, `tableList`, `tableRows` et `alertTest` joignent la
+ * base, et toutes sont déclenchées par un geste explicite. `list` et `get`
+ * lisent le cache local — ouvrir la feature ne réveille aucun serveur.
+ *
+ * L'espace visé n'apparaît dans aucune entrée : il voyage sur l'enveloppe WS et
+ * le dispatcheur le résout, appartenance vérifiée, avant le handler.
+ */
+
+const databaseId = z.number().int().positive();
+const alertId = z.number().int().positive();
+
+/** La partie réglable d'un accès, secret compris (jamais rendu en retour). */
+const accessInput = z.object({
+    kind: databaseAccessKindSchema,
+    host: z.string().max(DATABASE_HOST_MAX_LENGTH),
+    port: z.number().int().min(1).max(65535).nullable(),
+    username: z.string().max(DATABASE_USER_MAX_LENGTH),
+    auth: databaseSshAuthSchema,
+    /**
+     * Mot de passe SSH ou clé privée. Absent = on garde celui en place ; une
+     * chaîne vide l'efface. Le client ne le reçoit jamais, il ne peut donc pas
+     * le renvoyer inchangé — d'où cette convention plutôt qu'un champ obligatoire.
+     */
+    secret: z.string().max(DATABASE_SECRET_MAX_LENGTH).optional()
+});
+
+// ------------------------------------------------------------------- bases
+
+/** Le nombre de bases de l'espace, pour la tuile de l'accueil. */
+export const databaseCount = {
+    command: 'database.count' as const,
+    input: z.object({}),
+    output: z.object({ count: z.number().int().nonnegative() })
+};
+
+/** Les bases de l'espace, dans l'ordre de l'utilisateur. Lit le cache local. */
+export const databaseList = {
+    command: 'database.list' as const,
+    input: z.object({}),
+    output: z.object({ databases: z.array(databaseSchema) })
+};
+
+/** Une base, avec les projets qui s'en servent et ses alertes. */
+export const databaseGet = {
+    command: 'database.get' as const,
+    input: z.object({ databaseId }),
+    output: z.object({
+        database: databaseSchema,
+        usage: z.array(databaseUsageSchema),
+        alerts: z.array(databaseAlertSchema)
+    })
+};
+
+export const databaseAdd = {
+    command: 'database.add' as const,
+    input: z.object({
+        engine: databaseEngineSchema,
+        name: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
+        host: z.string().min(1).max(DATABASE_HOST_MAX_LENGTH),
+        port: z.number().int().min(1).max(65535),
+        database: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
+        username: z.string().max(DATABASE_USER_MAX_LENGTH),
+        password: z.string().max(DATABASE_SECRET_MAX_LENGTH),
+        access: accessInput,
+        monitorEnabled: z.boolean(),
+        intervalSeconds: z.number().int().min(60).max(86400),
+        autoLoadTables: z.boolean()
+    }),
+    output: z.object({ database: databaseSchema })
+};
+
+/**
+ * Modifie une base. `password` absent = on garde celui en place ; une chaîne
+ * vide l'efface. Même convention que le secret du tunnel, et pour la même
+ * raison : un secret rendu au client est un secret qu'on ne peut plus reprendre.
+ */
+export const databaseUpdate = {
+    command: 'database.update' as const,
+    input: z.object({
+        databaseId,
+        name: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
+        host: z.string().min(1).max(DATABASE_HOST_MAX_LENGTH),
+        port: z.number().int().min(1).max(65535),
+        database: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
+        username: z.string().max(DATABASE_USER_MAX_LENGTH),
+        password: z.string().max(DATABASE_SECRET_MAX_LENGTH).optional(),
+        access: accessInput,
+        monitorEnabled: z.boolean(),
+        intervalSeconds: z.number().int().min(60).max(86400),
+        autoLoadTables: z.boolean()
+    }),
+    output: z.object({ database: databaseSchema })
+};
+
+/**
+ * Retire une base de l'espace, avec ses alertes et toutes ses liaisons.
+ *
+ * Les projets liés ne sont **pas** touchés : ils perdent leur base, rien
+ * d'autre. Le serveur distant, lui, n'est évidemment jamais atteint.
+ */
+export const databaseRemove = {
+    command: 'database.remove' as const,
+    input: z.object({ databaseId }),
+    output: z.object({ databaseId })
+};
+
+/**
+ * Range les bases de l'espace : `ids` est la liste **complète** dans son ordre
+ * final. Une nouvelle base prend le rang suivant, donc la fin de la liste.
+ */
+export const databaseReorder = {
+    command: 'database.reorder' as const,
+    input: z.object({ ids: z.array(databaseId).min(1) }),
+    output: z.object({ ids: z.array(databaseId) })
+};
+
+// ------------------------------------------------------- à la demande
+
+/**
+ * Essaie de joindre la base, maintenant.
+ *
+ * Ne lève **jamais** sur un échec de connexion : un serveur injoignable est une
+ * réponse, pas une erreur de commande. Le message revient dans `error`, déjà
+ * traduit, et l'interface le montre sans rien bloquer.
+ */
+export const databaseTest = {
+    command: 'database.test' as const,
+    input: z.object({ databaseId }),
+    output: z.object({ probe: databaseProbeSchema })
+};
+
+/**
+ * Essaie une connexion **avant** de l'enregistrer.
+ *
+ * Le formulaire d'ajout décrit une base qui n'existe pas encore : `test` ne peut
+ * rien pour lui, il part d'un identifiant. Celui-ci prend les réglages tels
+ * qu'ils sont saisis, et n'écrit rien — ni ligne, ni état.
+ *
+ * `databaseId` sert à la modification : les secrets ne redescendant jamais au
+ * client, un champ laissé intact n'a rien à renvoyer, et le serveur reprend
+ * alors celui qu'il détient déjà. Sans cela, « Tester » échouerait sur une base
+ * qui fonctionne, faute de mot de passe.
+ */
+export const databaseTestDraft = {
+    command: 'database.testDraft' as const,
+    input: z.object({
+        databaseId: databaseId.optional(),
+        engine: databaseEngineSchema,
+        host: z.string().min(1).max(DATABASE_HOST_MAX_LENGTH),
+        port: z.number().int().min(1).max(65535),
+        database: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
+        username: z.string().max(DATABASE_USER_MAX_LENGTH),
+        password: z.string().max(DATABASE_SECRET_MAX_LENGTH).optional(),
+        access: accessInput
+    }),
+    output: z.object({ probe: databaseProbeSchema })
+};
+
+/**
+ * Relève l'inventaire maintenant : version du serveur, taille, nombre de
+ * tables, et l'état des alertes. C'est ce que fait le relevé périodique, sur
+ * demande explicite — ce qui le rend utile même sur une base au repos.
+ */
+export const databaseInspect = {
+    command: 'database.inspect' as const,
+    input: z.object({ databaseId }),
+    output: z.object({ database: databaseSchema, probe: databaseProbeSchema })
+};
+
+/** Les tables de la base, lues chez le serveur au moment de la demande. */
+export const databaseTableList = {
+    command: 'database.tableList' as const,
+    input: z.object({ databaseId }),
+    output: z.object({ tables: z.array(databaseTableSchema) })
+};
+
+/**
+ * Le contenu d'une table, page par page.
+ *
+ * ## Rien de ce qui vient du client n'entre tel quel dans une requête
+ *
+ * Un identifiant ne peut pas être un paramètre lié : nom de table, nom de
+ * colonne, sens du tri sont donc **confrontés au catalogue réel** avant d'être
+ * cités, et un nom qui n'y figure pas n'atteint jamais le moteur. Les valeurs,
+ * elles, sont toujours liées ; l'opérateur d'un filtre est choisi dans une
+ * énumération fermée. Aucun fragment de SQL ne traverse le contrat.
+ *
+ * `withStructure` évite un second aller-retour à la sélection d'une table : la
+ * structure et la première page arrivent alors dans la **même session**, ce qui
+ * compte quand chaque connexion rouvre un tunnel SSH.
+ */
+export const databaseTableRows = {
+    command: 'database.tableRows' as const,
+    input: z.object({
+        databaseId,
+        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
+        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
+        offset: z.number().int().nonnegative().max(1_000_000).optional(),
+        limit: z.number().int().positive().max(200).optional(),
+        filters: z.array(databaseFilterSchema).max(8).optional(),
+        combinator: databaseCombinatorSchema.optional(),
+        sort: databaseSortSchema.optional(),
+        withStructure: z.boolean().optional()
+    }),
+    output: z.object({ rows: databaseRowsSchema, structure: databaseStructureSchema.optional() })
+};
+
+/** La structure seule : colonnes, clé primaire, clés étrangères, index. */
+export const databaseTableStructure = {
+    command: 'database.tableStructure' as const,
+    input: z.object({
+        databaseId,
+        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
+        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH)
+    }),
+    output: z.object({ structure: databaseStructureSchema })
+};
+
+// ------------------------------------------------------- écrire des lignes
+
+/**
+ * Les trois écritures de l'explorateur.
+ *
+ * ## Ce que le serveur refuse, et pourquoi
+ *
+ * Modifier ou supprimer exige une **clé primaire**. Sans elle, aucune condition
+ * ne désigne *une* ligne : un `UPDATE` en toucherait plusieurs, un `DELETE` en
+ * emporterait autant, et rien ne permettrait de revenir en arrière. Le serveur
+ * refuse alors, avec la raison ; l'interface ne propose même pas le geste.
+ *
+ * ## Ce qui décide en dernier ressort
+ *
+ * Le compte saisi dans les réglages de la base. DevEye peut demander une
+ * écriture ; c'est le serveur distant qui l'accorde ou la refuse. Un compte en
+ * lecture seule rend donc tout ceci inoffensif, ce que dit le formulaire.
+ */
+export const databaseRowInsert = {
+    command: 'database.rowInsert' as const,
+    input: z.object({
+        databaseId,
+        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
+        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
+        values: z.array(databaseCellSchema).min(1).max(200)
+    }),
+    output: z.object({ inserted: z.number().int().nonnegative() })
+};
+
+export const databaseRowUpdate = {
+    command: 'database.rowUpdate' as const,
+    input: z.object({
+        databaseId,
+        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
+        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
+        /** La ligne visée, par ses colonnes de clé primaire. */
+        key: z.array(databaseCellSchema).min(1).max(16),
+        values: z.array(databaseCellSchema).min(1).max(200)
+    }),
+    output: z.object({ updated: z.number().int().nonnegative() })
+};
+
+export const databaseRowDelete = {
+    command: 'database.rowDelete' as const,
+    input: z.object({
+        databaseId,
+        schema: z.string().max(DATABASE_NAME_MAX_LENGTH),
+        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH),
+        /** Une entrée par ligne, chacune par ses colonnes de clé primaire. */
+        keys: z.array(z.array(databaseCellSchema).min(1).max(16)).min(1).max(200)
+    }),
+    output: z.object({ deleted: z.number().int().nonnegative() })
+};
+
+/**
+ * Une instruction libre, écriture comprise — le terminal.
+ *
+ * Distincte de `query`, qui refuse tout ce qui n'est pas une lecture parce
+ * qu'elle sert à mettre au point une condition d'alerte. Ici l'intention est
+ * l'inverse : administrer. Une seule instruction à la fois malgré tout, le
+ * point-virgule interne restant refusé — c'est ce qui empêche qu'un copier-coller
+ * en exécute trois quand on en visait une.
+ */
+export const databaseExecute = {
+    command: 'database.execute' as const,
+    input: z.object({ databaseId, sql: z.string().min(1).max(DATABASE_SQL_MAX_LENGTH) }),
+    output: z.object({ result: databaseExecutionSchema })
+};
+
+/**
+ * Exporte une table, ou toute la base.
+ *
+ * L'export est **complet** : il lit tout ce que la portée désigne, page par
+ * page. Le seul plafond qui subsiste est un garde-fou mémoire du serveur, très
+ * au-dessus de ce qu'un export normal atteint ; s'il est touché, `truncated` le
+ * dit et l'interface le répète. Pour une copie fidèle d'un serveur entier,
+ * `mysqldump` et `pg_dump` restent malgré tout les bons outils — eux savent
+ * rejouer schéma, index et contraintes.
+ *
+ * `idRanges` restreint l'export aux lignes dont la **clé primaire** tombe dans
+ * l'une des plages. Réservé à une portée d'une seule table : sur toute la base,
+ * les clés n'ont ni le même nom ni le même sens d'une table à l'autre.
+ */
+export const databaseExport = {
+    command: 'database.export' as const,
+    input: z.object({
+        databaseId,
+        format: databaseExportFormatSchema,
+        /** Absents : toute la base. Présents : cette table seule. */
+        schema: z.string().max(DATABASE_NAME_MAX_LENGTH).optional(),
+        table: z.string().min(1).max(DATABASE_NAME_MAX_LENGTH).optional(),
+        /** Plages d'identifiants, bornes comprises. Sans effet sans `table`. */
+        idRanges: z.array(databaseIdRangeSchema).max(64).optional()
+    }),
+    output: z.object({
+        filename: z.string(),
+        content: z.string(),
+        rowCount: z.number().int().nonnegative(),
+        tableCount: z.number().int().nonnegative(),
+        /** Le plafond a été atteint : ce qui suit manque. */
+        truncated: z.boolean()
+    })
+};
+
+// ----------------------------------------------------------------- alertes
+
+export const databaseAlertList = {
+    command: 'database.alertList' as const,
+    input: z.object({ databaseId }),
+    output: z.object({ alerts: z.array(databaseAlertSchema) })
+};
+
+export const databaseAlertAdd = {
+    command: 'database.alertAdd' as const,
+    input: z.object({
+        databaseId,
+        name: z.string().min(1).max(DATABASE_ALERT_NAME_MAX_LENGTH),
+        enabled: z.boolean(),
+        combinator: databaseCombinatorSchema,
+        conditions: z.array(databaseConditionSchema).min(1).max(8),
+        message: z.string().min(1).max(DATABASE_ALERT_MESSAGE_MAX_LENGTH)
+    }),
+    output: z.object({ alert: databaseAlertSchema })
+};
+
+export const databaseAlertUpdate = {
+    command: 'database.alertUpdate' as const,
+    input: z.object({
+        alertId,
+        name: z.string().min(1).max(DATABASE_ALERT_NAME_MAX_LENGTH),
+        enabled: z.boolean(),
+        combinator: databaseCombinatorSchema,
+        conditions: z.array(databaseConditionSchema).min(1).max(8),
+        message: z.string().min(1).max(DATABASE_ALERT_MESSAGE_MAX_LENGTH)
+    }),
+    output: z.object({ alert: databaseAlertSchema })
+};
+
+export const databaseAlertRemove = {
+    command: 'database.alertRemove' as const,
+    input: z.object({ alertId }),
+    output: z.object({ alertId })
+};
+
+/**
+ * Évalue une alerte tout de suite et rend ce que chaque condition a mesuré,
+ * **sans notifier personne**.
+ *
+ * C'est ce qui rend une condition écrivable : on voit le nombre que rend sa
+ * requête avant de choisir un seuil, au lieu d'attendre une notification pour
+ * découvrir qu'on s'est trompé de colonne.
+ */
+export const databaseAlertTest = {
+    command: 'database.alertTest' as const,
+    input: z.object({
+        databaseId,
+        combinator: databaseCombinatorSchema,
+        conditions: z.array(databaseConditionSchema).min(1).max(8)
+    }),
+    output: z.object({
+        firing: z.boolean(),
+        values: z.array(z.number().nullable()),
+        /** L'erreur de chaque condition, à sa place — `null` si elle a abouti. */
+        errors: z.array(z.string().nullable()),
+        elapsedMs: z.number().int().nonnegative()
+    })
+};
+
+/** Une requête libre en lecture seule, pour mettre au point une condition. */
+export const databaseQuery = {
+    command: 'database.query' as const,
+    input: z.object({ databaseId, sql: z.string().min(1).max(DATABASE_SQL_MAX_LENGTH) }),
+    output: z.object({ rows: databaseRowsSchema })
+};
+
+export const databaseCommands = [
+    databaseCount,
+    databaseList,
+    databaseGet,
+    databaseAdd,
+    databaseUpdate,
+    databaseRemove,
+    databaseReorder,
+    databaseTest,
+    databaseTestDraft,
+    databaseInspect,
+    databaseTableList,
+    databaseTableRows,
+    databaseTableStructure,
+    databaseRowInsert,
+    databaseRowUpdate,
+    databaseRowDelete,
+    databaseExecute,
+    databaseExport,
+    databaseAlertList,
+    databaseAlertAdd,
+    databaseAlertUpdate,
+    databaseAlertRemove,
+    databaseAlertTest,
+    databaseQuery
+] as const;

package/src/features/deploy.ts

@@ -0,0 +1,245 @@
+import { z } from 'zod';
+import {
+    CREDENTIAL_LABEL_MAX_LENGTH,
+    CREDENTIAL_SECRET_MAX_LENGTH,
+    credentialSchema
+} from '../domain/credential';
+import {
+    DEPLOY_DESCRIPTION_MAX_LENGTH,
+    DEPLOY_EXTERNAL_ID_MAX_LENGTH,
+    DEPLOY_TARGET_NAME_MAX_LENGTH,
+    DEPLOY_TITLE_MAX_LENGTH,
+    deployCandidateSchema,
+    deployHistoryEntrySchema,
+    deployTargetKindSchema,
+    deployTargetSchema,
+    deploymentSchema
+} from '../domain/deploy';
+
+/**
+ * Commandes du déploiement.
+ *
+ * Feature d'espace de premier rang, sur le modèle de Git : une cible appartient
+ * à l'espace, un projet n'y **pointe** (voir `project.deployLink`). Tout est à
+ * l'étage ouvert, donc aucune de ces commandes ne demande de session
+ * déverrouillée.
+ *
+ * Les clés d'API Dokploy vivent ici et non plus dans la feature Git, où elles
+ * n'avaient atterri que faute de module pour les accueillir : poser la clé qui
+ * déploie relève de `deploy`, pas de `git`.
+ */
+
+const targetId = z.number().int().positive();
+const credentialId = z.number().int().positive();
+
+/** Les cibles de l'espace, dans l'ordre choisi par l'utilisateur. */
+export const deployList = {
+    command: 'deploy.list' as const,
+    input: z.object({}),
+    output: z.object({ targets: z.array(deployTargetSchema) })
+};
+
+/**
+ * Compte les cibles. Métadonnée en clair pure : la tuile d'accueil affiche
+ * toujours un nombre, même session verrouillée.
+ */
+export const deployCount = {
+    command: 'deploy.count' as const,
+    input: z.object({}),
+    output: z.object({ count: z.number().int().nonnegative() })
+};
+
+/** Une cible et son historique de déclenchements, du plus récent au plus ancien. */
+export const deployGet = {
+    command: 'deploy.get' as const,
+    input: z.object({ targetId, limit: z.number().int().positive().max(50).optional() }),
+    output: z.object({
+        target: deployTargetSchema,
+        deployments: z.array(deploymentSchema),
+        /** Les projets qui la déploient, pour que la fiche sache où elle sert. */
+        projectIds: z.array(z.number().int().positive())
+    })
+};
+
+/**
+ * Déclare une cible. **Idempotente** sur (jeton, identifiant externe) : la même
+ * application déclarée deux fois est la même cible, et la seconde déclaration
+ * met simplement son intitulé à jour.
+ */
+export const deployAdd = {
+    command: 'deploy.add' as const,
+    input: z.object({
+        credentialId,
+        kind: deployTargetKindSchema,
+        externalId: z.string().min(1).max(DEPLOY_EXTERNAL_ID_MAX_LENGTH),
+        name: z.string().min(1).max(DEPLOY_TARGET_NAME_MAX_LENGTH)
+    }),
+    output: z.object({ target: deployTargetSchema })
+};
+
+/** Change le jeton, le type ou l'intitulé d'une cible. */
+export const deployUpdate = {
+    command: 'deploy.update' as const,
+    input: z.object({
+        targetId,
+        credentialId: credentialId.nullable(),
+        kind: deployTargetKindSchema,
+        externalId: z.string().min(1).max(DEPLOY_EXTERNAL_ID_MAX_LENGTH),
+        name: z.string().min(1).max(DEPLOY_TARGET_NAME_MAX_LENGTH)
+    }),
+    output: z.object({ target: deployTargetSchema })
+};
+
+/**
+ * Supprime une cible, **et son historique avec elle**.
+ *
+ * L'application chez le fournisseur n'est pas touchée : DevEye ne fait que la
+ * pointer. Les projets qui la déployaient perdent leur liaison, rien d'autre.
+ */
+export const deployRemove = {
+    command: 'deploy.remove' as const,
+    input: z.object({ targetId }),
+    output: z.object({ targetId })
+};
+
+/** Range la liste : `targetIds` en est le contenu complet, dans son ordre final. */
+export const deployReorder = {
+    command: 'deploy.reorder' as const,
+    input: z.object({ targetIds: z.array(targetId).min(1) }),
+    output: z.object({ targetIds: z.array(targetId) })
+};
+
+/**
+ * Les applications proposées par l'instance, pour en choisir une.
+ *
+ * Seule commande du module qui appelle un service externe en direct : elle sert
+ * à remplir un sélecteur, et attendre le prochain tour d'un ordonnanceur pour
+ * voir apparaître la liste n'aurait aucun sens.
+ */
+export const deployCandidates = {
+    command: 'deploy.candidates' as const,
+    input: z.object({ credentialId }),
+    output: z.object({ candidates: z.array(deployCandidateSchema) })
+};
+
+/**
+ * Déclenche un déploiement.
+ *
+ * Toujours audité en `warn` : c'est la seule action du module qui produise un
+ * effet **hors** de DevEye, et savoir qui a poussé quoi en production compte
+ * plus que le reste.
+ *
+ * `projectId` est facultatif et ne sert qu'à la frise du projet : déclenché
+ * depuis l'onglet d'un projet, l'événement y est inscrit ; déclenché depuis la
+ * feature, il n'appartient à aucun projet en particulier.
+ */
+export const deployTrigger = {
+    command: 'deploy.trigger' as const,
+    input: z.object({
+        targetId,
+        title: z.string().max(DEPLOY_TITLE_MAX_LENGTH),
+        description: z.string().max(DEPLOY_DESCRIPTION_MAX_LENGTH),
+        projectId: z.number().int().positive().optional()
+    }),
+    output: z.object({ deployment: deploymentSchema })
+};
+
+/**
+ * L'historique complet d'une cible, **tel que Dokploy le rend** — pas
+ * seulement ce que DevEye a déclenché : un déploiement lancé depuis
+ * l'interface de Dokploy ou une CI y apparaît aussi.
+ *
+ * Distincte de `deployGet`, qui reste le suivi local (léger, toujours
+ * disponible sans réseau vers le fournisseur) : celle-ci interroge Dokploy en
+ * direct à chaque appel, coûte une requête externe, et n'a donc de sens que
+ * là où on la demande explicitement — la fiche d'une cible dans la feature,
+ * pas l'onglet d'un projet qui en reliste plusieurs.
+ */
+export const deployHistory = {
+    command: 'deploy.history' as const,
+    input: z.object({ targetId }),
+    output: z.object({ entries: z.array(deployHistoryEntrySchema) })
+};
+
+/**
+ * Le journal complet d'un déploiement, tel que Dokploy l'a produit.
+ *
+ * `externalId` vient d'une ligne de `deployHistory` : c'est la seule façon dont
+ * le client connaît un déploiement dont DevEye n'a pas forcément la ligne
+ * locale. Repose sur un point d'entrée de Dokploy sans procédure tRPC dédiée
+ * (voir l'adaptateur `dokploy.ts`) : peut échouer sur une instance qui
+ * l'authentifie autrement, ou pas du tout — l'appelant le traite alors comme
+ * n'importe quelle autre panne réseau.
+ */
+export const deployLog = {
+    command: 'deploy.log' as const,
+    input: z.object({ targetId, externalId: z.string().min(1) }),
+    output: z.object({ log: z.string() })
+};
+
+// ------------------------------------------------------------------ jetons
+
+/**
+ * Les clés d'API Dokploy de l'espace.
+ *
+ * Quatre commandes jumelles de `git.credential*` : même table, même forme, mais
+ * chaque feature n'expose que les jetons de ses fournisseurs et les garde
+ * derrière son propre droit. Le secret n'est jamais rendu.
+ */
+export const deployCredentialList = {
+    command: 'deploy.credentialList' as const,
+    input: z.object({}),
+    output: z.object({ credentials: z.array(credentialSchema) })
+};
+
+/** Une instance Dokploy exige son adresse : sans elle, rien n'est adressable. */
+export const deployCredentialAdd = {
+    command: 'deploy.credentialAdd' as const,
+    input: z.object({
+        label: z.string().min(1).max(CREDENTIAL_LABEL_MAX_LENGTH),
+        baseUrl: z.string().min(1).max(255),
+        secret: z.string().min(1).max(CREDENTIAL_SECRET_MAX_LENGTH)
+    }),
+    output: z.object({ credential: credentialSchema })
+};
+
+/** `secret` omis = inchangé : le serveur ne l'a jamais rendu, on ne le réécrit pas. */
+export const deployCredentialUpdate = {
+    command: 'deploy.credentialUpdate' as const,
+    input: z.object({
+        credentialId,
+        label: z.string().min(1).max(CREDENTIAL_LABEL_MAX_LENGTH),
+        baseUrl: z.string().min(1).max(255),
+        secret: z.string().min(1).max(CREDENTIAL_SECRET_MAX_LENGTH).optional()
+    }),
+    output: z.object({ credential: credentialSchema })
+};
+
+/**
+ * Retire un jeton. Les cibles qui s'en servaient **restent**, sans jeton
+ * (`ON DELETE SET NULL`) : elles cessent d'être déployables et le disent, plutôt
+ * que de disparaître avec leur clé.
+ */
+export const deployCredentialRemove = {
+    command: 'deploy.credentialRemove' as const,
+    input: z.object({ credentialId }),
+    output: z.object({ credentialId })
+};
+
+export const deployCommands = [
+    deployList,
+    deployCount,
+    deployGet,
+    deployAdd,
+    deployUpdate,
+    deployRemove,
+    deployReorder,
+    deployCandidates,
+    deployTrigger,
+    deployHistory,
+    deployLog,
+    deployCredentialList,
+    deployCredentialAdd,
+    deployCredentialUpdate,
+    deployCredentialRemove
+] as const;