@deveye/types 0.16.1 → 0.17.1

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/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@deveye/types",
3
- "version": "0.16.1",
3
+ "version": "0.17.1",
4
4
  "description": "Shared contracts (types + zod schemas) for DevEye apps",
5
5
  "main": "src/index.ts",
6
6
  "types": "src/index.ts",
@@ -25,6 +25,15 @@ export type DeviceStatus = z.infer<typeof deviceStatusSchema>;
25
25
  export const devicePlatformSchema = z.enum(['linux', 'macos', 'windows']);
26
26
  export type DevicePlatform = z.infer<typeof devicePlatformSchema>;
27
27
 
28
+ /**
29
+ * OS account a terminal session opens under. Restricted to safe username
30
+ * characters (no shell metacharacters), since it reaches a `su` on the device.
31
+ */
32
+ export const terminalUser = z
33
+ .string()
34
+ .regex(/^[A-Za-z0-9._-]+$/, 'Nom d’utilisateur invalide')
35
+ .max(32);
36
+
28
37
  /**
29
38
  * Client-facing device. Secrets (token hash, public key) are never exposed.
30
39
  * `online` is live presence, derived from an active agent connection.
@@ -70,10 +79,20 @@ export const deviceSchema = z.object({
70
79
  */
71
80
  retentionDays: z.number().int().positive().nullable().default(null),
72
81
  /**
73
- * Workspaces this device is shared with. A device is reachable from every
74
- * workspace listed here; its pairing workspace is always among them.
82
+ * Account new terminal sessions open under (`su -l`); null → the account the
83
+ * agent itself runs as.
84
+ */
85
+ terminalDefaultUser: terminalUser.nullable().default(null),
86
+ /**
87
+ * On shell exit: `true` closes the terminal straight away, `false` keeps it
88
+ * open with a "Relancer"/"Fermer" banner.
89
+ */
90
+ terminalCloseOnExit: z.boolean().default(true),
91
+ /**
92
+ * Seen from a workspace it was projected into, not the one it was paired
93
+ * in: read-only marks and a "shared" badge hang on it.
75
94
  */
76
- workspaceIds: z.array(z.number().int().positive()).default([]),
95
+ foreign: z.boolean().default(false),
77
96
  /**
78
97
  * Last self-destruct failure message: set when an agent failed to wipe itself
79
98
  * during deletion, so the UI can surface it and the deletion is aborted.
@@ -91,12 +110,12 @@ export interface DeviceRow {
91
110
  id: string;
92
111
  owner_id: number;
93
112
  /**
94
- * Espace d'appairage (celui du code de liaison) : porte l'unicité de
95
- * l'empreinte (`uniq_workspace_fingerprint`) et sert le ré-enrôlement par la
96
- * route publique. La frontière d'accès est `device_workspaces`, où il figure
97
- * toujours. `null` si cet espace a été supprimé : l'appareil survit.
113
+ * Le domicile de l'appareil, celui du code de liaison : il porte l'unicité
114
+ * de l'empreinte (`uniq_workspace_fingerprint`), sert le ré-enrôlement par
115
+ * la route publique, et c'est depuis lui que l'appareil se projette
116
+ * ailleurs (`item_shares`).
98
117
  */
99
- workspace_id: number | null;
118
+ workspace_id: number;
100
119
  name: string;
101
120
  fingerprint: string;
102
121
  platform: string;
@@ -119,21 +138,15 @@ export interface DeviceRow {
119
138
  process_capture: string | null;
120
139
  /** History retention in days (metrics, presence, processes); null → server default. */
121
140
  retention_days: number | null;
141
+ /** Account terminal sessions open under; null → the agent's own account. */
142
+ terminal_default_user: string | null;
143
+ /** 1 = closing the shell closes the terminal, 0 = it stays open on a banner. */
144
+ terminal_close_on_exit: number;
122
145
  /** Status to restore if a pending deletion is cancelled; null otherwise. */
123
146
  status_before_delete: string | null;
124
147
  /** Last self-destruct failure message (deletion aborted); null otherwise. */
125
148
  delete_error: string | null;
126
- }
127
-
128
- /**
129
- * Un appareil rangé dans un espace (`device_workspaces`). Le rang est porté par
130
- * la jonction et non par l'appareil : le même appareil est rangé
131
- * indépendamment dans chaque espace qui y a accès.
132
- */
133
- export interface DeviceWorkspaceRow {
134
- device_id: string;
135
- workspace_id: number;
136
- /** Rank in *that* workspace's list, entirely the user's (`device.reorder`). */
149
+ /** Rang chez lui ; celui des espaces qui ne font que le voir vit dans `item_shares`. */
137
150
  sort_order: number;
138
151
  }
139
152
 
@@ -58,7 +58,18 @@ export const deviceLogLineSchema = z.object({
58
58
  export type DeviceLogLine = z.infer<typeof deviceLogLineSchema>;
59
59
 
60
60
  export const DEVICE_LOG_PAGE_MAX = 1000;
61
- export const DEVICE_LOG_PAGE_DEFAULT = 200;
61
+ export const DEVICE_LOG_PAGE_DEFAULT = 500;
62
+ /** How far back a query may skip, so a runaway offset can't drive an unbounded read. */
63
+ export const DEVICE_LOG_OFFSET_MAX = 20_000;
64
+
65
+ /**
66
+ * Which end of the log `offset` counts from. A query returns the window
67
+ * `[offset, offset + limit)` walking back from the newest line, or forward from the
68
+ * oldest one — the latter is how the viewer jumps straight to a log's beginning
69
+ * without paging through everything in between.
70
+ */
71
+ export const deviceLogAnchorSchema = z.enum(['newest', 'oldest']);
72
+ export type DeviceLogAnchor = z.infer<typeof deviceLogAnchorSchema>;
62
73
 
63
74
  /**
64
75
  * Advanced search surface for a query. Every field is optional and combines as
@@ -75,7 +75,7 @@ export const FEATURE_REGISTRY: readonly (FeatureDescriptor & { id: WorkspaceFeat
75
75
  notifies: false,
76
76
  hasItems: true,
77
77
  itemNoun: 'appareil',
78
- shareTier: 'never'
78
+ shareTier: 'open'
79
79
  },
80
80
  {
81
81
  id: 'sentinel',
@@ -247,6 +247,19 @@ export const FEATURE_REGISTRY: readonly (FeatureDescriptor & { id: WorkspaceFeat
247
247
  sources: {
248
248
  hint: 'Les clés d’API des fournisseurs, toutes facultatives : chaque sonde libre fonctionne déjà, une clé ne fait qu’enrichir la sienne.'
249
249
  }
250
+ },
251
+ {
252
+ id: 'cve',
253
+ label: 'Veille CVE',
254
+ description:
255
+ 'Lecture : le fil des vulnérabilités et la recherche. Écriture : épingler, et poser la clé du NVD.',
256
+ icon: 'bug',
257
+ notifies: false,
258
+ hasItems: false,
259
+ shareTier: 'never',
260
+ sources: {
261
+ hint: 'La clé d’API du NVD, facultative : sans elle le catalogue se remplit quand même, elle ne fait que relever le quota de requêtes.'
262
+ }
250
263
  }
251
264
  ];
252
265
 
@@ -267,7 +280,7 @@ export function registerExternalFeature(desc: FeatureDescriptor & { id: External
267
280
  EXTERNAL_BY_ID.set(desc.id, desc);
268
281
  }
269
282
 
270
- /** Le registre fusionné : les seize natives puis les modules, dans l'ordre d'enregistrement. */
283
+ /** Le registre fusionné : les natives puis les modules, dans l'ordre d'enregistrement. */
271
284
  export function allFeatureDescriptors(): readonly FeatureDescriptor[] {
272
285
  return EXTERNAL_BY_ID.size === 0
273
286
  ? FEATURE_REGISTRY
@@ -297,10 +310,9 @@ export function featureLabel(id: FeatureId): string {
297
310
  }
298
311
 
299
312
  /**
300
- * Les trois `never` : `devices` a déjà son partage inter-espaces, d'une autre
301
- * nature (`device_workspaces` est une adhésion, pas une projection) ;
302
- * `password` vit toujours à l'étage gardé ; `cloudsync` range ses contenus
303
- * dans un magasin de blobs chiffrés par la BMK, pas par une clé d'espace.
313
+ * Les deux `never` : `password` vit toujours à l'étage gardé ; `cloudsync`
314
+ * range ses contenus dans un magasin de blobs chiffrés par la BMK, pas par une
315
+ * clé d'espace.
304
316
  */
305
317
 
306
318
  /** Les fonctionnalités dont un élément **pourrait** voyager, côté chiffrement. */
@@ -16,9 +16,9 @@ import {
16
16
  */
17
17
 
18
18
  /**
19
- * Les seize tuiles de fonctionnalités natives. Une tuile porte l'id de sa
20
- * feature : la tuile Monitoring est celle de la feature `devices`, dont le
21
- * module fournit la carte et la vue.
19
+ * Les tuiles de fonctionnalités natives. Une tuile porte l'id de sa feature :
20
+ * la tuile Monitoring est celle de la feature `devices`, dont le module
21
+ * fournit la carte et la vue.
22
22
  */
23
23
  export const nativeHomeFeatureIdSchema = z.enum([
24
24
  'devices',
@@ -36,7 +36,8 @@ export const nativeHomeFeatureIdSchema = z.enum([
36
36
  'backup',
37
37
  'finance',
38
38
  'audience',
39
- 'osint'
39
+ 'osint',
40
+ 'cve'
40
41
  ]);
41
42
  export type NativeHomeFeatureId = z.infer<typeof nativeHomeFeatureIdSchema>;
42
43
 
@@ -55,10 +56,11 @@ export type HomeFeatureId = NativeHomeFeatureId | ExternalFeatureId;
55
56
  * - `weather` → current temperature of the primary city.
56
57
  * - `secrecy` → password-encryption lock state + re-validation countdown.
57
58
  * - `live` → qui d'autre est dans l'espace, et où (bulles cliquables).
59
+ * - `publicIp` → l'adresse publique par laquelle CE navigateur sort.
58
60
  * A module's widget is declared by its manifest (`topbarWidget`) and keyed by
59
61
  * its feature id (`homeTopbarWidgetIdSchema`).
60
62
  */
61
- export const nativeHomeTopbarWidgetIdSchema = z.enum(['weather', 'secrecy', 'live']);
63
+ export const nativeHomeTopbarWidgetIdSchema = z.enum(['weather', 'secrecy', 'live', 'publicIp']);
62
64
  export type NativeHomeTopbarWidgetId = z.infer<typeof nativeHomeTopbarWidgetIdSchema>;
63
65
 
64
66
  /**
@@ -186,6 +186,7 @@ export const TOPIC_FEATURE: Record<NativeLiveTopic, WorkspaceFeatureId | null> =
186
186
  finance: 'finance',
187
187
  audience: 'audience',
188
188
  osint: 'osint',
189
+ cve: 'cve',
189
190
  workspace: null,
190
191
  home: null,
191
192
  account: null,
@@ -57,17 +57,68 @@ export const itemShareStateSchema = z.object({
57
57
  /** Les espaces de l'appelant, l'origine comprise et marquée. */
58
58
  workspaces: z.array(itemShareSchema),
59
59
  /** Renseigné quand le partage est impossible ; les cases sont alors inertes. */
60
- blocker: shareBlockerSchema.nullable()
60
+ blocker: shareBlockerSchema.nullable(),
61
+ /**
62
+ * L'élément peut changer d'espace : sa fonctionnalité sait le re-chiffrer,
63
+ * il est chez lui ici, et l'appelant a le droit de l'y écrire. Faux ne dit
64
+ * pas pourquoi : c'est `share.movePreview`, une fois la cible choisie, qui
65
+ * porte les motifs.
66
+ */
67
+ movable: z.boolean().default(false)
61
68
  });
62
69
  export type ItemShareState = z.infer<typeof itemShareStateSchema>;
63
70
 
64
71
  /**
65
- * Ce qu'un rôle peut faire sur un élément. Restrictif seulement : `none` ou
66
- * `read` abaissent ce que le rôle a sur la fonctionnalité, jamais l'inverse ;
67
- * le droit de feature reste le plafond, et l'écran des rôles dit à lui seul
68
- * qui voit quoi.
72
+ * Une liaison que le déplacement va rompre. Une liaison ne traverse jamais un
73
+ * espace : ce qui vise l'élément depuis celui qu'il quitte est retiré, et
74
+ * l'écran le nomme avant de confirmer.
69
75
  */
70
- export const itemAccessSchema = z.enum(['none', 'read']);
76
+ export const itemMoveDependencySchema = z.object({
77
+ feature: featureIdSchema,
78
+ itemId: z.string().min(1).max(64),
79
+ /** Son intitulé sous le codec de son espace ; « Élément disparu » si illisible. */
80
+ label: z.string(),
81
+ /** Pourquoi elle ne peut pas suivre, dit à la place de l'utilisateur. */
82
+ reason: z.string()
83
+ });
84
+ export type ItemMoveDependency = z.infer<typeof itemMoveDependencySchema>;
85
+
86
+ /**
87
+ * Ce qu'un déplacement ferait, calculé sans rien écrire. C'est le contenu du
88
+ * popup de confirmation : ce qui l'empêche, ce qu'il détruit, ce qu'il emmène.
89
+ */
90
+ export const itemMovePreviewSchema = z.object({
91
+ workspaceId: z.number().int().positive(),
92
+ workspaceName: z.string(),
93
+ /** L'espace d'origine, nommé : la phrase du popup le cite. */
94
+ homeWorkspaceName: z.string(),
95
+ /**
96
+ * L'origine est un espace partagé : ses autres membres perdront l'accès.
97
+ * Dit plutôt que gardé, la suppression n'exigeant pas davantage.
98
+ */
99
+ losesSharedAccess: z.boolean(),
100
+ /** Vide = le déplacement est possible. Sinon la première phrase est le motif affiché. */
101
+ blockers: z.array(z.string()),
102
+ /** Ce qui sera détruit ou retiré, nommé : projections, restrictions, historique. */
103
+ drops: z.array(z.string()),
104
+ /** Cellules chiffrées à convertir, pour annoncer l'ampleur plutôt que faire attendre. */
105
+ rows: z.number().int().nonnegative(),
106
+ /** Les liaisons rompues, nommées une par une. */
107
+ dependencies: z.array(itemMoveDependencySchema)
108
+ });
109
+ export type ItemMovePreview = z.infer<typeof itemMovePreviewSchema>;
110
+
111
+ /**
112
+ * Ce qu'un rôle peut faire sur un élément, **en surcharge** de ce que la
113
+ * fonctionnalité lui donne : `none` masque, `read` passe en lecture seule,
114
+ * `write` ouvre l'écriture à un rôle qui ne l'a qu'en lecture ailleurs.
115
+ *
116
+ * Un plancher demeure : sans au moins la LECTURE sur la fonctionnalité, aucun
117
+ * élément n'existe pour le rôle et rien ne se surcharge. C'est ce qui garde à
118
+ * l'écran des rôles sa réponse à « qui a accès à Uptime ? » ; sous ce plancher,
119
+ * il faudrait parcourir tous les éléments de l'espace pour le savoir.
120
+ */
121
+ export const itemAccessSchema = z.enum(['none', 'read', 'write']);
71
122
  export type ItemAccess = z.infer<typeof itemAccessSchema>;
72
123
 
73
124
  export const itemRoleGrantSchema = z.object({
@@ -75,6 +126,15 @@ export const itemRoleGrantSchema = z.object({
75
126
  /** Absent de la liste = le rôle garde ce que la fonctionnalité lui donne. */
76
127
  access: itemAccessSchema
77
128
  });
129
+
130
+ /**
131
+ * Les permissions propres surchargées sur un élément : `true` accorde, `false`
132
+ * retire, une clé absente suit la fonctionnalité. Les deux sens, contrairement
133
+ * au niveau d'antan : confier le terminal sur UNE machine à un rôle qui ne l'a
134
+ * pas partout est le cas qui a fait sauter la règle du « restrictif seulement ».
135
+ */
136
+ export const itemExtraOverridesSchema = z.record(z.string().max(24), z.boolean());
137
+ export type ItemExtraOverrides = z.infer<typeof itemExtraOverridesSchema>;
78
138
  export type ItemRoleGrant = z.infer<typeof itemRoleGrantSchema>;
79
139
 
80
140
  /**
@@ -91,8 +151,12 @@ export const itemRoleGrantViewSchema = z.object({
91
151
  * effective quand `access` est `null`.
92
152
  */
93
153
  featureAccess: z.enum(['none', 'read', 'write']),
94
- /** L'exception posée sur cet élément, ou `null` : « comme la fonctionnalité ». */
95
- access: itemAccessSchema.nullable()
154
+ /** La surcharge posée sur cet élément, ou `null` : « comme la fonctionnalité ». */
155
+ access: itemAccessSchema.nullable(),
156
+ /** Les permissions propres que le rôle tient sur la **fonctionnalité** : l'héritage. */
157
+ featureExtras: z.array(z.string().max(24)).default([]),
158
+ /** Celles que cet élément-ci accorde (`true`) ou retire (`false`) au rôle. */
159
+ extraOverrides: itemExtraOverridesSchema.default({})
96
160
  });
97
161
  export type ItemRoleGrantView = z.infer<typeof itemRoleGrantViewSchema>;
98
162
 
@@ -100,6 +164,12 @@ export type ItemRoleGrantView = z.infer<typeof itemRoleGrantViewSchema>;
100
164
  export const itemGrantStateSchema = z.object({
101
165
  workspaceId: z.number().int().positive(),
102
166
  workspaceName: z.string(),
167
+ /**
168
+ * Les permissions propres de la fonctionnalité qui se surchargent élément par
169
+ * élément, intitulés compris : les booléens seulement. Un choix borné n'a
170
+ * pas d'ordre que le socle connaisse, et reste réglé sur le rôle.
171
+ */
172
+ extras: z.array(z.object({ key: z.string().max(24), label: z.string() })).default([]),
103
173
  roles: z.array(itemRoleGrantViewSchema)
104
174
  });
105
175
  export type ItemGrantState = z.infer<typeof itemGrantStateSchema>;
@@ -110,7 +180,8 @@ export type ItemGrantState = z.infer<typeof itemGrantStateSchema>;
110
180
  */
111
181
  export const itemRefSchema = z.object({
112
182
  feature: featureIdSchema,
113
- itemId: z.number().int().positive()
183
+ /** Texte : une feature choisit la clé de sa table, entière ou non (un appareil est un UUID). */
184
+ itemId: z.string().min(1).max(64)
114
185
  });
115
186
  export type ItemRef = z.infer<typeof itemRefSchema>;
116
187
 
@@ -131,19 +202,24 @@ export type ForeignRef = z.infer<typeof foreignRefSchema>;
131
202
  export interface ItemShareRow {
132
203
  workspace_id: number;
133
204
  feature: string;
134
- item_id: number;
205
+ item_id: string;
135
206
  home_workspace_id: number;
136
207
  shared_by_user_id: number;
137
208
  created: number;
209
+ /** Le rang de l'élément dans l'espace qui le reçoit, propre à cet espace. */
210
+ sort_order: number;
138
211
  }
139
212
 
140
213
  /** Ligne de `item_role_grants` (serveur uniquement). */
141
214
  export interface ItemRoleGrantRow {
142
215
  workspace_id: number;
143
216
  feature: string;
144
- item_id: number;
217
+ item_id: string;
145
218
  role_id: number;
146
- access: ItemAccess;
219
+ /** `null` quand la ligne n'existe que pour des permissions surchargées. */
220
+ access: ItemAccess | null;
221
+ /** Objet JSON `clé → booléen` des permissions surchargées ; `null` = aucune. */
222
+ extra_overrides: string | null;
147
223
  }
148
224
 
149
225
  export { featureAccessSchema };
@@ -83,7 +83,12 @@ export const workspaceFeatureIdSchema = z.enum([
83
83
  * OSINT. `read` = chercher et consulter l'historique de l'espace, `write` =
84
84
  * effacer l'historique et poser les clés d'API des fournisseurs.
85
85
  */
86
- 'osint'
86
+ 'osint',
87
+ /**
88
+ * Veille CVE. `read` = lire le fil et chercher dans le catalogue, `write` =
89
+ * épingler une CVE pour tout l'espace et poser la clé d'API du NVD.
90
+ */
91
+ 'cve'
87
92
  ]);
88
93
 
89
94
  export type WorkspaceFeatureId = z.infer<typeof workspaceFeatureIdSchema>;
@@ -142,6 +147,17 @@ export const workspaceFeatureGrantSchema = z.object({
142
147
  * n'émet pas de notifications.
143
148
  */
144
149
  channels: z.boolean(),
150
+ /**
151
+ * Régler ce que chaque rôle peut faire d'un élément pris séparément (l'onglet
152
+ * Permissions d'un élément). Distinct de `access` : surcharger un appareil
153
+ * n'est pas gérer la flotte, et distinct de la capacité `workspace.roles`,
154
+ * qui gouverne les rôles eux-mêmes — on peut confier le réglage par élément
155
+ * d'une fonctionnalité sans ouvrir l'écran des rôles.
156
+ *
157
+ * Ce droit-ci ne se surcharge PAS par élément, sans quoi il servirait à
158
+ * s'accorder tout le reste. Sans effet sur une fonctionnalité sans éléments.
159
+ */
160
+ itemPermissions: z.boolean().default(false),
145
161
  /**
146
162
  * Permissions déclarées par la feature elle-même (`extraPermissions` du
147
163
  * manifest) : booléen pour un `toggle`, valeur d'un `choice`. Une clé
@@ -187,6 +203,21 @@ export interface WorkspaceRoleRow {
187
203
  created: number;
188
204
  }
189
205
 
206
+ /**
207
+ * Une surcharge d'élément, du point de vue de l'appelant : ce que CE rôle-là
208
+ * obtient sur cette ligne, en remplacement de ce que la fonctionnalité donne.
209
+ */
210
+ export const itemGrantOverrideSchema = z.object({
211
+ feature: featureIdSchema,
212
+ itemId: z.string().min(1).max(64),
213
+ /** `null` : le niveau suit la fonctionnalité, seules les permissions changent. */
214
+ access: z.enum(['none', 'read', 'write']).nullable(),
215
+ /** `true` accorde, `false` retire ; une clé absente suit la fonctionnalité. */
216
+ extras: z.record(z.string().max(24), z.boolean()).default({})
217
+ });
218
+
219
+ export type ItemGrantOverride = z.infer<typeof itemGrantOverrideSchema>;
220
+
190
221
  /**
191
222
  * Droits effectifs de l'appelant dans l'espace actif, tels que le client les
192
223
  * reçoit pour n'afficher que ce qui est réellement accessible.
@@ -197,7 +228,15 @@ export interface WorkspaceRoleRow {
197
228
  export const workspacePermissionsSchema = z.object({
198
229
  isOwner: z.boolean(),
199
230
  capabilities: z.array(workspaceCapabilitySchema),
200
- features: z.array(workspaceFeatureGrantSchema)
231
+ features: z.array(workspaceFeatureGrantSchema),
232
+ /**
233
+ * Les surcharges posées sur des éléments précis pour le rôle de l'appelant.
234
+ * Elles voyagent avec ses droits parce que l'interface en a besoin élément
235
+ * par élément — griser le terminal d'UNE machine, ouvrir l'écriture sur une
236
+ * autre — et que `features` seule ne peut pas y répondre. Seules les
237
+ * exceptions y figurent ; l'absence vaut « comme la fonctionnalité ».
238
+ */
239
+ itemOverrides: z.array(itemGrantOverrideSchema).default([])
201
240
  });
202
241
 
203
242
  export type WorkspacePermissions = z.infer<typeof workspacePermissionsSchema>;
@@ -1,7 +1,12 @@
1
1
  import { z } from 'zod';
2
- import { deviceSchema } from '../domain/device';
2
+ import { deviceSchema, terminalUser } from '../domain/device';
3
3
  import { fileMutateOpSchema, fileSearchFilterSchema } from '../domain/deviceFiles';
4
- import { deviceLogFilterSchema, DEVICE_LOG_PAGE_MAX } from '../domain/deviceLogs';
4
+ import {
5
+ deviceLogAnchorSchema,
6
+ deviceLogFilterSchema,
7
+ DEVICE_LOG_OFFSET_MAX,
8
+ DEVICE_LOG_PAGE_MAX
9
+ } from '../domain/deviceLogs';
5
10
  import { packageManagerIdSchema } from '../domain/packages';
6
11
  import { agentLifecycleActionSchema, agentPowerActionSchema } from '../protocol/agent';
7
12
 
@@ -44,7 +49,8 @@ export const agentCollect = {
44
49
 
45
50
  /**
46
51
  * Run a system power action on the device (shutdown / reboot / suspend / hibernate
47
- * / lock). Owner-or-admin; the agent must be online. The command only acknowledges
52
+ * / lock). Needs the `system` permission on Appareils; the agent must be online.
53
+ * The command only acknowledges
48
54
  * the request — the agent applies it best-effort and the outcome streams back as a
49
55
  * `device.powerResult` push event (the caller must be subscribed to the device).
50
56
  */
@@ -58,8 +64,8 @@ export const agentPower = {
58
64
  * Stop or cleanly restart the agent process on the device (not the machine).
59
65
  * `stop`: a supervised agent is relaunched by its manager, a standalone one
60
66
  * stays offline until relaunched on the machine. `restart`: exit-and-relaunch.
61
- * Owner-or-admin; the agent must be online. Fire-and-forget: the outcome is
62
- * observed through presence.
67
+ * Needs `devices: write`; the agent must be online. Fire-and-forget: the outcome
68
+ * is observed through presence.
63
69
  */
64
70
  export const agentLifecycle = {
65
71
  command: 'agent.lifecycle' as const,
@@ -132,7 +138,8 @@ export const agentUpgradePackages = {
132
138
 
133
139
  /**
134
140
  * Ask the agent to enumerate the log sources present on the device (system journal,
135
- * Docker containers, log files…). Owner-or-admin + agent online. The command only
141
+ * Docker containers, log files…). Needs the `logs` permission on Appareils +
142
+ * agent online. The command only
136
143
  * acknowledges; the list arrives as a `device.logSources` push event (the caller
137
144
  * must be subscribed to the device).
138
145
  */
@@ -146,6 +153,10 @@ export const agentLogSources = {
146
153
  * Query one source with an advanced filter. `queryId` correlates the streamed
147
154
  * result back to this request (results have no requestId). Lines arrive as one or
148
155
  * more `device.logLines` push events, the last carrying `done: true`.
156
+ *
157
+ * `offset` and `anchor` page through the history: the agent returns the window
158
+ * `[offset, offset + limit)` counted from the anchor end. A short page means the
159
+ * source held nothing more in that direction.
149
160
  */
150
161
  export const agentLogQuery = {
151
162
  command: 'agent.logQuery' as const,
@@ -155,7 +166,9 @@ export const agentLogQuery = {
155
166
  /** Client-generated id echoed back on every `device.logLines` for this query. */
156
167
  queryId: z.string().min(1).max(64),
157
168
  filter: deviceLogFilterSchema.optional(),
158
- limit: z.number().int().positive().max(DEVICE_LOG_PAGE_MAX).optional()
169
+ limit: z.number().int().positive().max(DEVICE_LOG_PAGE_MAX).optional(),
170
+ offset: z.number().int().nonnegative().max(DEVICE_LOG_OFFSET_MAX).optional(),
171
+ anchor: deviceLogAnchorSchema.optional()
159
172
  }),
160
173
  output: z.object({ ok: z.boolean() })
161
174
  };
@@ -166,16 +179,8 @@ const rows = z.number().int().min(1).max(2000);
166
179
  /** Base64-encoded terminal bytes, capped per frame (~1.5 MB). */
167
180
  const termData = z.string().max(2_000_000);
168
181
  /**
169
- * Optional OS account to open the session under. Restricted to safe username
170
- * characters (no shell metacharacters), since it reaches a `su` on the device.
171
- */
172
- export const terminalUser = z
173
- .string()
174
- .regex(/^[A-Za-z0-9._-]+$/, 'Nom d’utilisateur invalide')
175
- .max(32);
176
-
177
- /**
178
- * Open an interactive terminal (PTY) on the device. Owner-or-admin + agent online.
182
+ * Open an interactive terminal (PTY) on the device. Needs the `terminal`
183
+ * permission on Appareils + agent online.
179
184
  * `sessionId` is client-generated and ties every later input/resize/close and the
180
185
  * streamed `device.termOutput` / `device.termExit` push events together (the caller
181
186
  * must be subscribed). `user` runs the shell under that account (`su -l`); omitted
@@ -213,7 +218,8 @@ const opId = z.string().min(1).max(64);
213
218
  const path = z.string().min(1).max(4096);
214
219
 
215
220
  /**
216
- * List a directory. Owner-or-admin + agent online. The listing arrives as a
221
+ * List a directory. Needs the `files` permission on Appareils + agent online.
222
+ * The listing arrives as a
217
223
  * `device.filesListing` push event keyed by `opId` (the caller must be subscribed).
218
224
  */
219
225
  export const agentFilesList = {
@@ -2,7 +2,9 @@ import { z } from 'zod';
2
2
 
3
3
  import {
4
4
  itemAccessSchema,
5
+ itemExtraOverridesSchema,
5
6
  itemGrantStateSchema,
7
+ itemMovePreviewSchema,
6
8
  itemRefSchema,
7
9
  itemShareStateSchema
8
10
  } from '../domain/sharing';
@@ -48,18 +50,65 @@ export const itemGrantList = {
48
50
  };
49
51
 
50
52
  /**
51
- * Abaisse (ou rétablit) ce qu'un rôle peut faire sur cet élément, dans l'espace
52
- * visé (`workspaceId` absent = l'actif). `access: null` retire la restriction :
53
- * le rôle reprend ce que la fonctionnalité lui donne.
53
+ * Surcharge ce qu'un rôle peut faire sur cet élément, dans l'espace visé
54
+ * (`workspaceId` absent = l'actif). Les deux volets se règlent seuls : un champ
55
+ * omis reste inchangé, comme pour la configuration d'un appareil.
56
+ *
57
+ * `access: null` et `extraOverrides: {}` rendent l'élément à l'héritage : le
58
+ * rôle reprend ce que la fonctionnalité lui donne. Une surcharge va dans les
59
+ * deux sens, le plancher de visibilité mis à part : il faut au moins la lecture
60
+ * sur la fonctionnalité pour que l'élément existe (cf. `itemAccessSchema`).
61
+ *
62
+ * Écrire exige `workspace.roles` sur l'espace visé, ou le champ
63
+ * `itemPermissions` du grant de cette fonctionnalité.
54
64
  */
55
65
  export const itemGrantSet = {
56
66
  command: 'share.grantSet' as const,
57
- input: itemRefSchema.extend({
58
- workspaceId: z.number().int().positive().optional(),
59
- roleId: z.number().int().positive(),
60
- access: itemAccessSchema.nullable()
61
- }),
67
+ input: itemRefSchema
68
+ .extend({
69
+ workspaceId: z.number().int().positive().optional(),
70
+ roleId: z.number().int().positive(),
71
+ access: itemAccessSchema.nullable().optional(),
72
+ /** Remplace l'ensemble des permissions surchargées sur cet élément. */
73
+ extraOverrides: itemExtraOverridesSchema.optional()
74
+ })
75
+ .refine((v) => v.access !== undefined || v.extraOverrides !== undefined, {
76
+ message: 'No grant field provided'
77
+ }),
62
78
  output: itemGrantStateSchema
63
79
  };
64
80
 
65
- export const sharingCommands = [shareGet, shareSet, itemGrantList, itemGrantSet] as const;
81
+ /**
82
+ * Ce qu'un déplacement vers cet espace ferait, sans rien écrire : ce qui
83
+ * l'empêche, ce qu'il détruit, les liaisons qui suivent et celles qu'on peut
84
+ * emmener. Le popup de confirmation n'affiche rien d'autre.
85
+ */
86
+ export const itemMovePreview = {
87
+ command: 'share.movePreview' as const,
88
+ input: itemRefSchema.extend({ workspaceId: z.number().int().positive() }),
89
+ output: itemMovePreviewSchema
90
+ };
91
+
92
+ /**
93
+ * Déplace l'élément : sa donnée est déchiffrée sous la clé de son espace et
94
+ * re-chiffrée sous celle de la cible. La seule opération du système qui change
95
+ * un blob de clé, et donc la seule qui ne se rejoue pas.
96
+ *
97
+ * Il arrive nu : ses projections, les surcharges de rôle posées dessus, sa route
98
+ * de notification et les liaisons qui le visaient tombent, toutes désignant
99
+ * l'espace qu'il quitte.
100
+ */
101
+ export const itemMove = {
102
+ command: 'share.move' as const,
103
+ input: itemRefSchema.extend({ workspaceId: z.number().int().positive() }),
104
+ output: z.object({ workspaceId: z.number().int().positive() })
105
+ };
106
+
107
+ export const sharingCommands = [
108
+ shareGet,
109
+ shareSet,
110
+ itemGrantList,
111
+ itemGrantSet,
112
+ itemMovePreview,
113
+ itemMove
114
+ ] as const;
@@ -26,13 +26,7 @@ export const linkCodeRequestSchema = z.object({
26
26
  * Approve the device the moment it enrols with this code, instead of
27
27
  * leaving it `pending` for manual approval. Defaults to `false`.
28
28
  */
29
- autoApprove: z.boolean().default(false),
30
- /**
31
- * Espace dans lequel la machine sera rangée à l'enrôlement. Omis → l'espace
32
- * actif de l'émetteur. Explicite (n'importe quel espace existant) : réservé
33
- * à l'administrateur global.
34
- */
35
- workspaceId: z.number().int().positive().optional()
29
+ autoApprove: z.boolean().default(false)
36
30
  });
37
31
 
38
32
  export type LinkCodeRequest = z.infer<typeof linkCodeRequestSchema>;