@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 +1 -1
- package/src/domain/device.ts +32 -19
- package/src/domain/deviceLogs.ts +12 -1
- package/src/domain/featureRegistry.ts +18 -6
- package/src/domain/home.ts +7 -5
- package/src/domain/live.ts +1 -0
- package/src/domain/sharing.ts +88 -12
- package/src/domain/workspaceRole.ts +41 -2
- package/src/features/agent.ts +24 -18
- package/src/features/sharing.ts +58 -9
- package/src/http/device.ts +1 -7
- package/src/index.ts +16 -10
- package/src/protocol/agent.ts +4 -1
- package/src/sdk/client-ambient.d.ts +38 -4
- package/src/sdk/client.ts +15 -12
- package/src/sdk/move.test.ts +140 -0
- package/src/sdk/providers.ts +10 -0
- package/src/sdk/server.ts +200 -9
- package/src/sdk/testing.ts +18 -11
package/package.json
CHANGED
package/src/domain/device.ts
CHANGED
|
@@ -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
|
-
*
|
|
74
|
-
*
|
|
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
|
-
|
|
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
|
-
*
|
|
95
|
-
* l'empreinte (`uniq_workspace_fingerprint`)
|
|
96
|
-
* route publique
|
|
97
|
-
*
|
|
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
|
|
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
|
|
package/src/domain/deviceLogs.ts
CHANGED
|
@@ -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 =
|
|
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: '
|
|
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
|
|
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
|
|
301
|
-
*
|
|
302
|
-
*
|
|
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. */
|
package/src/domain/home.ts
CHANGED
|
@@ -16,9 +16,9 @@ import {
|
|
|
16
16
|
*/
|
|
17
17
|
|
|
18
18
|
/**
|
|
19
|
-
* Les
|
|
20
|
-
*
|
|
21
|
-
*
|
|
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
|
/**
|
package/src/domain/live.ts
CHANGED
package/src/domain/sharing.ts
CHANGED
|
@@ -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
|
-
*
|
|
66
|
-
*
|
|
67
|
-
*
|
|
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
|
|
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
|
-
/**
|
|
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
|
-
|
|
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:
|
|
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:
|
|
217
|
+
item_id: string;
|
|
145
218
|
role_id: number;
|
|
146
|
-
|
|
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>;
|
package/src/features/agent.ts
CHANGED
|
@@ -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 {
|
|
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).
|
|
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
|
-
*
|
|
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…).
|
|
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
|
-
*
|
|
170
|
-
*
|
|
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.
|
|
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 = {
|
package/src/features/sharing.ts
CHANGED
|
@@ -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
|
-
*
|
|
52
|
-
*
|
|
53
|
-
*
|
|
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
|
|
58
|
-
|
|
59
|
-
|
|
60
|
-
|
|
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
|
-
|
|
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;
|
package/src/http/device.ts
CHANGED
|
@@ -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>;
|