@agentorg/computer-sdk 0.0.0-stage → 0.0.35
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/LICENSE +201 -0
- package/NOTICE +2 -0
- package/README.md +4 -2
- package/dist/THIRD_PARTY_LICENSES.txt +596 -0
- package/dist/sdk.js +24937 -0
- package/dist/types/generated/schema.d.ts +1399 -0
- package/dist/types/sdk.d.ts +282 -0
- package/package.json +32 -4
|
@@ -0,0 +1,1399 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* This file was auto-generated by openapi-typescript.
|
|
3
|
+
* Do not make direct changes to the file.
|
|
4
|
+
*/
|
|
5
|
+
|
|
6
|
+
export interface paths {
|
|
7
|
+
"/v1/info": {
|
|
8
|
+
parameters: {
|
|
9
|
+
query?: never;
|
|
10
|
+
header?: never;
|
|
11
|
+
path?: never;
|
|
12
|
+
cookie?: never;
|
|
13
|
+
};
|
|
14
|
+
/** What this service offers: this computer, the kinds of computer it can make, and the browsers that can go with each, every one ready or not and why. The screen's readiness is read afresh where the last reading is more than 10 seconds old, waited for up to a second; a reading that takes longer is answered the next time. */
|
|
15
|
+
get: operations["getInfo"];
|
|
16
|
+
put?: never;
|
|
17
|
+
post?: never;
|
|
18
|
+
delete?: never;
|
|
19
|
+
options?: never;
|
|
20
|
+
head?: never;
|
|
21
|
+
patch?: never;
|
|
22
|
+
trace?: never;
|
|
23
|
+
};
|
|
24
|
+
"/v1/connection": {
|
|
25
|
+
parameters: {
|
|
26
|
+
query?: never;
|
|
27
|
+
header?: never;
|
|
28
|
+
path?: never;
|
|
29
|
+
cookie?: never;
|
|
30
|
+
};
|
|
31
|
+
/** Who is connected to the service: each client that holds a WebSocket open at this same path, with the control token in its Authorization header and its name as `?name=`. It carries nothing either way, and one that stops answering the service's pings is dropped. */
|
|
32
|
+
get: operations["getConnection"];
|
|
33
|
+
put?: never;
|
|
34
|
+
post?: never;
|
|
35
|
+
delete?: never;
|
|
36
|
+
options?: never;
|
|
37
|
+
head?: never;
|
|
38
|
+
patch?: never;
|
|
39
|
+
trace?: never;
|
|
40
|
+
};
|
|
41
|
+
"/v1/setup": {
|
|
42
|
+
parameters: {
|
|
43
|
+
query?: never;
|
|
44
|
+
header?: never;
|
|
45
|
+
path?: never;
|
|
46
|
+
cookie?: never;
|
|
47
|
+
};
|
|
48
|
+
/** For each part of the service's machine an agent can use, the person's switch, whether it has all it needs, and each thing it needs, read afresh each time. */
|
|
49
|
+
get: operations["getSetup"];
|
|
50
|
+
put?: never;
|
|
51
|
+
post?: never;
|
|
52
|
+
delete?: never;
|
|
53
|
+
options?: never;
|
|
54
|
+
head?: never;
|
|
55
|
+
patch?: never;
|
|
56
|
+
trace?: never;
|
|
57
|
+
};
|
|
58
|
+
"/v1/setup/{capability}": {
|
|
59
|
+
parameters: {
|
|
60
|
+
query?: never;
|
|
61
|
+
header?: never;
|
|
62
|
+
path: {
|
|
63
|
+
capability: components["schemas"]["Switch"];
|
|
64
|
+
};
|
|
65
|
+
cookie?: never;
|
|
66
|
+
};
|
|
67
|
+
get?: never;
|
|
68
|
+
/** Set a part's switch, which lasts across restarts. Turning it on, or on again, makes only the requests that show nothing, on the service's machine, macOS only: from macOS 26, Screen Recording's for an app hosting Cua Driver, while it is missing, which lists the app in its pane. Nothing that shows an alert or a window comes from the switch: Accessibility's alert, Cua Driver's own grant window and a browser's inspect page each come from ask with that need, on the person's click. Before macOS 26 Screen Recording's request is taken to draw an alert, so it waits for ask too; that is untested. Where a request it makes couldn't be started, it answers 409, saying why, and the switch stays on. */
|
|
69
|
+
put: operations["setSetup"];
|
|
70
|
+
post?: never;
|
|
71
|
+
delete?: never;
|
|
72
|
+
options?: never;
|
|
73
|
+
head?: never;
|
|
74
|
+
patch?: never;
|
|
75
|
+
trace?: never;
|
|
76
|
+
};
|
|
77
|
+
"/v1/setup/{capability}/ask": {
|
|
78
|
+
parameters: {
|
|
79
|
+
query?: never;
|
|
80
|
+
header?: never;
|
|
81
|
+
path: {
|
|
82
|
+
capability: components["schemas"]["Switch"];
|
|
83
|
+
};
|
|
84
|
+
cookie?: never;
|
|
85
|
+
};
|
|
86
|
+
get?: never;
|
|
87
|
+
put?: never;
|
|
88
|
+
/** Ask the person, on the service's machine, macOS only, for one thing a part needs, for a button they press for it. screen-recording or accessibility, while it is missing: for a driver an app hosts, the app makes macOS's request each time, so that macOS asks again whenever it would, such as after a reset of the app's privacy entries. That grant's pane of System Settings opens as well, a second later, except at the first request the service has made, for that app's bundle identifier, of a grant whose request may draw an alert: accessibility, and screen-recording before macOS 26. macOS draws that alert until it has been answered, and the alert's own button opens the pane; after a reset, the alert and the pane both come. From macOS 26 Screen Recording's request draws nothing, so its pane opens each time. For Cua Driver's own app, while it is missing: its own grant, its app started first, which makes the system's requests in its own order, Accessibility first, in a window of its own. chrome or edge: that browser opens at its inspect page, where remote debugging is switched on. folders, for the files: each folder macOS protects that is here is read once, one after another, so that macOS asks for each in turn, now, and waits for the person's answer; their state is unknown until all are answered. With none named, it makes only what turning the part on makes. It answers once the steps have started, with each part then; what the person does next is read afresh later. A browser the service was given only the folder of, the person opens. Elsewhere it asks for nothing. */
|
|
89
|
+
post: operations["askSetup"];
|
|
90
|
+
delete?: never;
|
|
91
|
+
options?: never;
|
|
92
|
+
head?: never;
|
|
93
|
+
patch?: never;
|
|
94
|
+
trace?: never;
|
|
95
|
+
};
|
|
96
|
+
"/v1/setup/{capability}/settings": {
|
|
97
|
+
parameters: {
|
|
98
|
+
query?: never;
|
|
99
|
+
header?: never;
|
|
100
|
+
path: {
|
|
101
|
+
capability: components["schemas"]["Switch"];
|
|
102
|
+
};
|
|
103
|
+
cookie?: never;
|
|
104
|
+
};
|
|
105
|
+
get?: never;
|
|
106
|
+
put?: never;
|
|
107
|
+
/** Open the pane of System Settings for one thing a part needs, on the service's machine, macOS only, for the person to switch it there: screen-recording or accessibility, that grant's pane under Privacy & Security, whether it is missing or not; folders, the pane of Files and Folders, where a folder refused is switched on again. macOS lists an app there once it has asked, so this follows ask. It is for the person's own choice, such as a button they press: the service opens a pane only here and from ask, each on the person's click. Where an app hosts the driver, it is that app that sees the change and starts its driver again. It answers once the pane is asked to open, with each part then. Elsewhere it answers 409. */
|
|
108
|
+
post: operations["openSetupSettings"];
|
|
109
|
+
delete?: never;
|
|
110
|
+
options?: never;
|
|
111
|
+
head?: never;
|
|
112
|
+
patch?: never;
|
|
113
|
+
trace?: never;
|
|
114
|
+
};
|
|
115
|
+
"/v1/acting": {
|
|
116
|
+
parameters: {
|
|
117
|
+
query?: never;
|
|
118
|
+
header?: never;
|
|
119
|
+
path?: never;
|
|
120
|
+
cookie?: never;
|
|
121
|
+
};
|
|
122
|
+
/** Who is acting now on the computers attached to this machine, all of them at once: each one, on what, and when they last acted there, the most recent first, as each computer's presence surface has it. A computer in a container isn't included: its own presence surface has it. */
|
|
123
|
+
get: operations["getActing"];
|
|
124
|
+
put?: never;
|
|
125
|
+
post?: never;
|
|
126
|
+
delete?: never;
|
|
127
|
+
options?: never;
|
|
128
|
+
head?: never;
|
|
129
|
+
patch?: never;
|
|
130
|
+
trace?: never;
|
|
131
|
+
};
|
|
132
|
+
"/v1/computers": {
|
|
133
|
+
parameters: {
|
|
134
|
+
query?: never;
|
|
135
|
+
header?: never;
|
|
136
|
+
path?: never;
|
|
137
|
+
cookie?: never;
|
|
138
|
+
};
|
|
139
|
+
/** List the computers. */
|
|
140
|
+
get: operations["listComputers"];
|
|
141
|
+
put?: never;
|
|
142
|
+
/**
|
|
143
|
+
* Create a computer. It answers once the computer is running.
|
|
144
|
+
* @description Meanwhile, once any `copyFrom` copy is done, it is listed by `listComputers` as `starting`, with the name and metadata given here, its `reason`, and its image's `progress` where that is counted: that is how a caller shows a computer being made before `create` has answered.
|
|
145
|
+
*/
|
|
146
|
+
post: operations["createComputer"];
|
|
147
|
+
delete?: never;
|
|
148
|
+
options?: never;
|
|
149
|
+
head?: never;
|
|
150
|
+
patch?: never;
|
|
151
|
+
trace?: never;
|
|
152
|
+
};
|
|
153
|
+
"/v1/computers/attach": {
|
|
154
|
+
parameters: {
|
|
155
|
+
query?: never;
|
|
156
|
+
header?: never;
|
|
157
|
+
path?: never;
|
|
158
|
+
cookie?: never;
|
|
159
|
+
};
|
|
160
|
+
get?: never;
|
|
161
|
+
put?: never;
|
|
162
|
+
/** Attach this computer, the machine the service runs on, whole: its files and commands reach all of it, as whoever started the service. Each call attaches it as a computer of its own, with its own id and token. Killing one detaches it and removes nothing of the machine's. Refused with 409 by a service that other machines can reach, which doesn't offer it. */
|
|
163
|
+
post: operations["attachComputer"];
|
|
164
|
+
delete?: never;
|
|
165
|
+
options?: never;
|
|
166
|
+
head?: never;
|
|
167
|
+
patch?: never;
|
|
168
|
+
trace?: never;
|
|
169
|
+
};
|
|
170
|
+
"/v1/computers/{computerID}": {
|
|
171
|
+
parameters: {
|
|
172
|
+
query?: never;
|
|
173
|
+
header?: never;
|
|
174
|
+
path: {
|
|
175
|
+
computerID: components["parameters"]["computerID"];
|
|
176
|
+
};
|
|
177
|
+
cookie?: never;
|
|
178
|
+
};
|
|
179
|
+
/** One computer, with how long it has run and the tools it offers. */
|
|
180
|
+
get: operations["getComputer"];
|
|
181
|
+
put?: never;
|
|
182
|
+
post?: never;
|
|
183
|
+
/** Stop it for good and remove what the service made. A folder someone named stays. */
|
|
184
|
+
delete: operations["killComputer"];
|
|
185
|
+
options?: never;
|
|
186
|
+
head?: never;
|
|
187
|
+
patch?: never;
|
|
188
|
+
trace?: never;
|
|
189
|
+
};
|
|
190
|
+
"/v1/computers/{computerID}/timeout": {
|
|
191
|
+
parameters: {
|
|
192
|
+
query?: never;
|
|
193
|
+
header?: never;
|
|
194
|
+
path: {
|
|
195
|
+
computerID: components["parameters"]["computerID"];
|
|
196
|
+
};
|
|
197
|
+
cookie?: never;
|
|
198
|
+
};
|
|
199
|
+
get?: never;
|
|
200
|
+
put?: never;
|
|
201
|
+
/** It now stops this many seconds from now, replacing any earlier timeout. */
|
|
202
|
+
post: operations["setComputerTimeout"];
|
|
203
|
+
delete?: never;
|
|
204
|
+
options?: never;
|
|
205
|
+
head?: never;
|
|
206
|
+
patch?: never;
|
|
207
|
+
trace?: never;
|
|
208
|
+
};
|
|
209
|
+
"/v1/computers/{computerID}/stop": {
|
|
210
|
+
parameters: {
|
|
211
|
+
query?: never;
|
|
212
|
+
header?: never;
|
|
213
|
+
path: {
|
|
214
|
+
computerID: components["parameters"]["computerID"];
|
|
215
|
+
};
|
|
216
|
+
cookie?: never;
|
|
217
|
+
};
|
|
218
|
+
get?: never;
|
|
219
|
+
put?: never;
|
|
220
|
+
/** Stop what it is running. Its folder and its token stay, and it can start again. */
|
|
221
|
+
post: operations["stopComputer"];
|
|
222
|
+
delete?: never;
|
|
223
|
+
options?: never;
|
|
224
|
+
head?: never;
|
|
225
|
+
patch?: never;
|
|
226
|
+
trace?: never;
|
|
227
|
+
};
|
|
228
|
+
"/v1/computers/{computerID}/start": {
|
|
229
|
+
parameters: {
|
|
230
|
+
query?: never;
|
|
231
|
+
header?: never;
|
|
232
|
+
path: {
|
|
233
|
+
computerID: components["parameters"]["computerID"];
|
|
234
|
+
};
|
|
235
|
+
cookie?: never;
|
|
236
|
+
};
|
|
237
|
+
get?: never;
|
|
238
|
+
put?: never;
|
|
239
|
+
/** Start a stopped computer again, with the same token and folder. */
|
|
240
|
+
post: operations["startComputer"];
|
|
241
|
+
delete?: never;
|
|
242
|
+
options?: never;
|
|
243
|
+
head?: never;
|
|
244
|
+
patch?: never;
|
|
245
|
+
trace?: never;
|
|
246
|
+
};
|
|
247
|
+
"/v1/computers/{computerID}/logs": {
|
|
248
|
+
parameters: {
|
|
249
|
+
query?: never;
|
|
250
|
+
header?: never;
|
|
251
|
+
path: {
|
|
252
|
+
computerID: components["parameters"]["computerID"];
|
|
253
|
+
};
|
|
254
|
+
cookie?: never;
|
|
255
|
+
};
|
|
256
|
+
/** What its servers wrote, and each request it was sent. */
|
|
257
|
+
get: operations["getComputerLogs"];
|
|
258
|
+
put?: never;
|
|
259
|
+
post?: never;
|
|
260
|
+
delete?: never;
|
|
261
|
+
options?: never;
|
|
262
|
+
head?: never;
|
|
263
|
+
patch?: never;
|
|
264
|
+
trace?: never;
|
|
265
|
+
};
|
|
266
|
+
"/v1/computers/{computerID}/live": {
|
|
267
|
+
parameters: {
|
|
268
|
+
query?: never;
|
|
269
|
+
header?: never;
|
|
270
|
+
path: {
|
|
271
|
+
computerID: components["parameters"]["computerID"];
|
|
272
|
+
};
|
|
273
|
+
cookie?: never;
|
|
274
|
+
};
|
|
275
|
+
get?: never;
|
|
276
|
+
put?: never;
|
|
277
|
+
/** A one-time ticket to watch or operate one of its surfaces live: its terminals, its files, its browser, or its load. Open its url as a WebSocket within 60 seconds. */
|
|
278
|
+
post: operations["createLiveSession"];
|
|
279
|
+
delete?: never;
|
|
280
|
+
options?: never;
|
|
281
|
+
head?: never;
|
|
282
|
+
patch?: never;
|
|
283
|
+
trace?: never;
|
|
284
|
+
};
|
|
285
|
+
"/v1/live/{liveID}": {
|
|
286
|
+
parameters: {
|
|
287
|
+
query?: never;
|
|
288
|
+
header?: never;
|
|
289
|
+
path: {
|
|
290
|
+
liveID: string;
|
|
291
|
+
};
|
|
292
|
+
cookie?: never;
|
|
293
|
+
};
|
|
294
|
+
/** Open a live session as a WebSocket. The ticket in its path is its authority and works once, so it takes no token. A request with an Origin header is refused unless the service was told to allow that origin. */
|
|
295
|
+
get: operations["openLiveSession"];
|
|
296
|
+
put?: never;
|
|
297
|
+
post?: never;
|
|
298
|
+
delete?: never;
|
|
299
|
+
options?: never;
|
|
300
|
+
head?: never;
|
|
301
|
+
patch?: never;
|
|
302
|
+
trace?: never;
|
|
303
|
+
};
|
|
304
|
+
}
|
|
305
|
+
export type webhooks = Record<string, never>;
|
|
306
|
+
export interface components {
|
|
307
|
+
schemas: {
|
|
308
|
+
Error: {
|
|
309
|
+
code: number;
|
|
310
|
+
message: string;
|
|
311
|
+
};
|
|
312
|
+
/**
|
|
313
|
+
* @description How far it reaches into files and commands, each level containing the one before: `read` has about, read, list and search; `files` adds edit; `terminal` adds exec_command, write_stdin and list_sessions. Below terminal, the browser's code-running tool is hidden.
|
|
314
|
+
* @enum {string}
|
|
315
|
+
*/
|
|
316
|
+
Access: "none" | "read" | "files" | "terminal";
|
|
317
|
+
/**
|
|
318
|
+
* @description starting: it is being made, started, or brought back as the service starts. Its `reason` says what it waits on, and its `progress` how far that has come, where it counts. Its endpoints and live sessions are refused with 409 and that `reason` until it is running. `create` and `start` answer once it is running, and it is listed meanwhile; `start` on one already starting answers at once. failed: it was to be running and isn't, because its browser or container ended by itself, or because it couldn't be brought back when the service started. Its `reason` says why, and its logs say more. Stop it and start it again. The screen fails none: a computer with the screen, brought back or started again while the screen can't be used, is running. Its screen's tools say why, in the switch's words or the screen's, and while the screen isn't ready its `screen` surface is `unavailable` with the same words; the next call after the screen can be used works, with no restart. Cua Driver stopping, as when an app hosting it starts it again for a grant, ends only the connection, which the next call makes again.
|
|
319
|
+
* @enum {string}
|
|
320
|
+
*/
|
|
321
|
+
ComputerState: "starting" | "running" | "stopped" | "failed";
|
|
322
|
+
/** @description How far a step that counts its bytes has come: today only fetching a computer's image, where Docker is on a socket on the service's machine. */
|
|
323
|
+
Progress: {
|
|
324
|
+
/** @description The step, in words with no numbers: "Downloading its image". */
|
|
325
|
+
title: string;
|
|
326
|
+
/** @description Bytes come so far. */
|
|
327
|
+
done: number;
|
|
328
|
+
/** @description Bytes to come, as far as is known: Docker gives each layer's size as the layer begins, so it can grow. Null while nothing is known. */
|
|
329
|
+
total: number | null;
|
|
330
|
+
/**
|
|
331
|
+
* Format: date-time
|
|
332
|
+
* @description When it last moved: bytes came, or, for an image, a layer was unpacked. When the step began, until then.
|
|
333
|
+
*/
|
|
334
|
+
moved: string;
|
|
335
|
+
};
|
|
336
|
+
/** @description Seconds from now until the computer stops. */
|
|
337
|
+
Timeout: number;
|
|
338
|
+
/** @description Your own labels, kept and returned as given. */
|
|
339
|
+
Metadata: {
|
|
340
|
+
[key: string]: string;
|
|
341
|
+
};
|
|
342
|
+
NewComputer: {
|
|
343
|
+
name?: string;
|
|
344
|
+
access: components["schemas"]["Access"];
|
|
345
|
+
/**
|
|
346
|
+
* @description Whether it has a browser. With access none, it must.
|
|
347
|
+
* @default false
|
|
348
|
+
*/
|
|
349
|
+
browser: boolean;
|
|
350
|
+
/** @description The full path of a folder that exists, on the service's machine. With none, the service makes a folder, which goes when the computer is killed. A folder named here never does. */
|
|
351
|
+
workspace?: string;
|
|
352
|
+
/** @description The full path of a folder on the service's machine. The workspace the service makes starts with a copy of what is in it, taken once when the computer is made; the folder itself is never mounted or changed. Links are copied as they are, and sockets, pipes and devices are left out. Use it instead of workspace; it needs access other than none. */
|
|
353
|
+
copyFrom?: string;
|
|
354
|
+
/** @description How it is isolated, which it keeps for as long as it exists: container, the default. One with no isolation is no longer made, and asking for one is refused: attach this computer instead. */
|
|
355
|
+
isolation?: components["schemas"]["Isolation"];
|
|
356
|
+
timeout?: components["schemas"]["Timeout"];
|
|
357
|
+
metadata?: components["schemas"]["Metadata"];
|
|
358
|
+
};
|
|
359
|
+
AttachComputer: {
|
|
360
|
+
name?: string;
|
|
361
|
+
access: components["schemas"]["Access"];
|
|
362
|
+
/**
|
|
363
|
+
* @description Its browser. true: a headless one of its own. own: the person's own, Chrome or else Edge, signed in, reached through the browser's own attach, which asks the person to allow the connection; attaching waits up to 2 minutes for that, and is refused with 409 if it isn't allowed, or where `info` says it isn't ready. Its agent works only in tabs it opens: the person's own tabs are left alone. It is never closed: when the computer stops, it is only let go. With access none, the computer must have a browser or the screen.
|
|
364
|
+
* @default false
|
|
365
|
+
*/
|
|
366
|
+
browser: boolean | "own";
|
|
367
|
+
/**
|
|
368
|
+
* @description Whether its agent has the machine's screen: to see it and act on it, through Cua Driver, which the person installs and grants Screen Recording and Accessibility once. It acts as the person, whatever `access` says. Refused with 409 where `info` says the screen isn't ready, except where all it lacks is macOS's grants for the driver: then the computer starts, and its screen's tools say which grants are missing and work once they are given, with no restart. Once attached, the computer doesn't rest on it: brought back or started again while the screen can't be used, it runs, and its screen's tools say why.
|
|
369
|
+
* @default false
|
|
370
|
+
*/
|
|
371
|
+
screen: boolean;
|
|
372
|
+
/** @description Its work folder: the full path of a folder that exists. Commands and relative paths start there and its agent is told to work there, but nothing keeps its files inside it. Detaching never removes it. */
|
|
373
|
+
workspace: string;
|
|
374
|
+
timeout?: components["schemas"]["Timeout"];
|
|
375
|
+
metadata?: components["schemas"]["Metadata"];
|
|
376
|
+
};
|
|
377
|
+
/**
|
|
378
|
+
* @description none: processes of whoever started the service, which only this computer has now; a computer made with no isolation before can't start again. container: a container of its own, which needs Docker on the service's machine.
|
|
379
|
+
* @enum {string}
|
|
380
|
+
*/
|
|
381
|
+
Isolation: "none" | "container";
|
|
382
|
+
/** @description MCP over Streamable HTTP, each taking the computer's access token as a bearer. */
|
|
383
|
+
Endpoints: {
|
|
384
|
+
/** @description The terminal and files. */
|
|
385
|
+
computer: string | null;
|
|
386
|
+
/** @description The browser. */
|
|
387
|
+
browser: string | null;
|
|
388
|
+
/** @description The screen endpoint, or null when this computer was attached without `screen`. */
|
|
389
|
+
screen: string | null;
|
|
390
|
+
};
|
|
391
|
+
Computer: {
|
|
392
|
+
computerID: string;
|
|
393
|
+
name: string;
|
|
394
|
+
state: components["schemas"]["ComputerState"];
|
|
395
|
+
/** @description In a line a person reads: while it is starting, the step it waits on, with no numbers, such as "Its image is being fetched.", "Its container is being started." or "It is being started."; while it is failed, why. Null while it is running or stopped. */
|
|
396
|
+
reason: string | null;
|
|
397
|
+
/** @description While it is starting, how far its step has come, where the step counts its bytes; null otherwise. */
|
|
398
|
+
progress: components["schemas"]["Progress"] | null;
|
|
399
|
+
access: components["schemas"]["Access"];
|
|
400
|
+
/** @description The isolation it was made in. It is never run in another. */
|
|
401
|
+
isolation: components["schemas"]["Isolation"];
|
|
402
|
+
/** @description Whether it is this computer, attached rather than made: the service's machine, whole, acting as whoever started the service, with no isolation. False with isolation none marks a computer made with no isolation by an earlier version, which can't start again; its workspace is kept. */
|
|
403
|
+
attached: boolean;
|
|
404
|
+
/** @description The version of the program it ran at its last start. For this computer it is the service's `version` (see `getInfo`). In a container it is the version inside its image, and null for a container made before 0.0.17, which doesn't say, until it is made again. It is kept from its last start, so a stopped computer's can be older than the service's until it starts. Compare it with the service's to show that a computer runs an older program. */
|
|
405
|
+
version: string | null;
|
|
406
|
+
/** @description Its browser, as it was given, or false where it has none. */
|
|
407
|
+
browser: boolean | "own";
|
|
408
|
+
/** @description Whether its agent has the screen: only this computer can have one. */
|
|
409
|
+
screen: boolean;
|
|
410
|
+
workspace: string | null;
|
|
411
|
+
/**
|
|
412
|
+
* Format: date-time
|
|
413
|
+
* @description When it last started.
|
|
414
|
+
*/
|
|
415
|
+
startedAt: string;
|
|
416
|
+
/**
|
|
417
|
+
* Format: date-time
|
|
418
|
+
* @description When it will stop; null if it has no timeout.
|
|
419
|
+
*/
|
|
420
|
+
endAt: string | null;
|
|
421
|
+
metadata: components["schemas"]["Metadata"];
|
|
422
|
+
endpoints: components["schemas"]["Endpoints"];
|
|
423
|
+
};
|
|
424
|
+
CreatedComputer: components["schemas"]["Computer"] & {
|
|
425
|
+
/** @description Good only for this computer's endpoints. Shown only now. */
|
|
426
|
+
accessToken: string;
|
|
427
|
+
};
|
|
428
|
+
ComputerDetail: components["schemas"]["Computer"] & {
|
|
429
|
+
uptimeSeconds: number;
|
|
430
|
+
/** @description What can be opened live while it runs. */
|
|
431
|
+
surfaces: components["schemas"]["SurfaceInfo"][];
|
|
432
|
+
tools: {
|
|
433
|
+
computer: string[];
|
|
434
|
+
browser: string[];
|
|
435
|
+
screen: string[];
|
|
436
|
+
};
|
|
437
|
+
};
|
|
438
|
+
/**
|
|
439
|
+
* @description terminal: every terminal on it, the agent's commands and a person's shells alike, on one socket in terminal@1: text messages are TerminalEvent one way and TerminalInput the other. Watching reads them all; operating also opens a shell, types into any of them, the agent's included, sizes and stops them. files: its workspace's files, in files@1: text messages are FilesRequest one way and FilesAnswer the other, and a file's bytes travel as binary messages of at most 1,048,576 bytes. Watching lists and reads; operating also writes, which a computer with read access doesn't offer. browser: its browser, in screencast@1: binary messages are JPEG frames of the page shown, text messages are ScreencastEvent one way and ScreencastInput the other. Nobody waits for anybody: the agent's tools and a person's input act on the same browser at once. The page shown is each socket's own. A socket is shown each new tab as it opens, until it sends a tab input to show or open one; from then its page changes only when that page closes. load: how busy it is, in metrics@1, to watch only: a LoadReading every two seconds while a socket is open, the first two seconds after the first socket opens, and the last one at once to a socket that opens later. One that can't be taken is left out, and a socket that hasn't read the one before is not sent the next. Nothing is read while nobody watches or asks. presence: who is acting on it now, in presence@1, to watch only: a PresenceEvent when the socket opens, and another each time someone starts or stops acting on something. screen: the machine's screen, for this computer attached with it, in screen@1: binary messages are PNG frames of the whole screen, at most 1,280 pixels on their longest side, text messages are ScreenEvent one way and ScreenInput the other. The screen is taken twice a second while a socket is open, and a frame is sent only when the picture changed, so a socket is sent the last one when it opens and nothing more while the screen is still. A socket with more than 4 MiB still to be sent to it is sent nothing until it catches up.
|
|
440
|
+
* @enum {string}
|
|
441
|
+
*/
|
|
442
|
+
Surface: "terminal" | "files" | "browser" | "load" | "presence" | "screen";
|
|
443
|
+
/**
|
|
444
|
+
* @description In watch you see and don't act: what you send is dropped, except that a files socket may still ask to list, to read and for what changed.
|
|
445
|
+
* @enum {string}
|
|
446
|
+
*/
|
|
447
|
+
LiveMode: "watch" | "operate";
|
|
448
|
+
SurfaceInfo: {
|
|
449
|
+
surface: components["schemas"]["Surface"];
|
|
450
|
+
protocol: string;
|
|
451
|
+
/** @description Whether it can be operated */
|
|
452
|
+
operate: boolean;
|
|
453
|
+
/** @description Why it can't be opened now, if it can't. */
|
|
454
|
+
unavailable?: string;
|
|
455
|
+
};
|
|
456
|
+
NewLiveSession: {
|
|
457
|
+
surface: components["schemas"]["Surface"];
|
|
458
|
+
/** @default watch */
|
|
459
|
+
mode: components["schemas"]["LiveMode"];
|
|
460
|
+
};
|
|
461
|
+
LiveSession: {
|
|
462
|
+
/** @description The WebSocket to open */
|
|
463
|
+
url: string;
|
|
464
|
+
protocol: string;
|
|
465
|
+
surface: components["schemas"]["Surface"];
|
|
466
|
+
mode: components["schemas"]["LiveMode"];
|
|
467
|
+
/** Format: date-time */
|
|
468
|
+
expiresAt: string;
|
|
469
|
+
};
|
|
470
|
+
/** @description What the service sends on a screencast@1 socket, as JSON text. */
|
|
471
|
+
ScreencastEvent: {
|
|
472
|
+
/** @constant */
|
|
473
|
+
type: "tabs";
|
|
474
|
+
tabs: {
|
|
475
|
+
id: number;
|
|
476
|
+
url: string;
|
|
477
|
+
title: string;
|
|
478
|
+
}[];
|
|
479
|
+
shown: number | null;
|
|
480
|
+
} | {
|
|
481
|
+
/** @constant */
|
|
482
|
+
type: "viewport";
|
|
483
|
+
width: number;
|
|
484
|
+
height: number;
|
|
485
|
+
} | {
|
|
486
|
+
/** @constant */
|
|
487
|
+
type: "dialog";
|
|
488
|
+
open: boolean;
|
|
489
|
+
/** @enum {string} */
|
|
490
|
+
kind?: "alert" | "confirm" | "prompt" | "beforeunload";
|
|
491
|
+
message?: string;
|
|
492
|
+
defaultValue?: string;
|
|
493
|
+
} | {
|
|
494
|
+
/** @constant */
|
|
495
|
+
type: "file-chooser";
|
|
496
|
+
open: boolean;
|
|
497
|
+
multiple?: boolean;
|
|
498
|
+
} | {
|
|
499
|
+
/** @constant */
|
|
500
|
+
type: "choice";
|
|
501
|
+
multiple: boolean;
|
|
502
|
+
options: {
|
|
503
|
+
value: string;
|
|
504
|
+
label: string;
|
|
505
|
+
selected: boolean;
|
|
506
|
+
}[];
|
|
507
|
+
};
|
|
508
|
+
/** @description What an operate socket sends on screencast@1, as JSON text. A watch socket's is dropped. */
|
|
509
|
+
ScreencastInput: {
|
|
510
|
+
/** @constant */
|
|
511
|
+
type: "mouse";
|
|
512
|
+
/** @enum {string} */
|
|
513
|
+
action: "move" | "down" | "up" | "wheel";
|
|
514
|
+
x: number;
|
|
515
|
+
y: number;
|
|
516
|
+
/** @enum {string} */
|
|
517
|
+
button?: "left" | "right" | "middle";
|
|
518
|
+
deltaX?: number;
|
|
519
|
+
deltaY?: number;
|
|
520
|
+
} | {
|
|
521
|
+
/** @constant */
|
|
522
|
+
type: "key";
|
|
523
|
+
/** @enum {string} */
|
|
524
|
+
action: "down" | "up";
|
|
525
|
+
/** @description A key name */
|
|
526
|
+
key: string;
|
|
527
|
+
} | {
|
|
528
|
+
/** @constant */
|
|
529
|
+
type: "text";
|
|
530
|
+
text: string;
|
|
531
|
+
} | {
|
|
532
|
+
/** @constant */
|
|
533
|
+
type: "dialog";
|
|
534
|
+
accept: boolean;
|
|
535
|
+
text?: string;
|
|
536
|
+
} | {
|
|
537
|
+
/** @constant */
|
|
538
|
+
type: "files";
|
|
539
|
+
files: {
|
|
540
|
+
name: string;
|
|
541
|
+
mimeType?: string;
|
|
542
|
+
/** @description Base64. */
|
|
543
|
+
data: string;
|
|
544
|
+
}[];
|
|
545
|
+
} | {
|
|
546
|
+
/** @constant */
|
|
547
|
+
type: "choice";
|
|
548
|
+
values: string[];
|
|
549
|
+
} | {
|
|
550
|
+
/** @constant */
|
|
551
|
+
type: "tab";
|
|
552
|
+
/** @enum {string} */
|
|
553
|
+
action: "show" | "open" | "close";
|
|
554
|
+
id?: number;
|
|
555
|
+
url?: string;
|
|
556
|
+
} | {
|
|
557
|
+
/** @constant */
|
|
558
|
+
type: "navigate";
|
|
559
|
+
/** @description A URL, or back, forward or reload. */
|
|
560
|
+
to: string;
|
|
561
|
+
};
|
|
562
|
+
/** @description What the service sends on a screen@1 socket, as JSON text. */
|
|
563
|
+
ScreenEvent: {
|
|
564
|
+
/** @constant */
|
|
565
|
+
type: "size";
|
|
566
|
+
width: number;
|
|
567
|
+
height: number;
|
|
568
|
+
} | {
|
|
569
|
+
/** @constant */
|
|
570
|
+
type: "refused";
|
|
571
|
+
message: string;
|
|
572
|
+
};
|
|
573
|
+
/** @description What an operate socket sends on screen@1, as JSON text, no message over 65,536 bytes: a larger one closes the socket. Each is done in order, through Cua Driver, as the person. A point is in pixels of the frames, as the last size says, scaled to the screen; keys and text go to the window in front. A click, drag or scroll is made in the foreground at its point, as a person's own would be, which moves the machine's pointer there; the pointer is then put back once where it was, as far as anyone at the machine moved it meanwhile, and where it isn't, the computer's log says why. Such inputs, and every agent's input that moves the real pointer, are made one at a time on the machine's screen. What isn't done is answered with refused, and why: what Cua Driver refuses, what is none of these, and what is sent while 32 are still waiting. Binary messages, and whatever a watch socket sends, are dropped. */
|
|
574
|
+
ScreenInput: {
|
|
575
|
+
/** @constant */
|
|
576
|
+
type: "mouse";
|
|
577
|
+
/** @enum {string} */
|
|
578
|
+
action: "click" | "double_click" | "right_click" | "drag" | "scroll";
|
|
579
|
+
x: number;
|
|
580
|
+
y: number;
|
|
581
|
+
to_x?: number;
|
|
582
|
+
to_y?: number;
|
|
583
|
+
/** @enum {string} */
|
|
584
|
+
direction?: "up" | "down" | "left" | "right";
|
|
585
|
+
amount?: number;
|
|
586
|
+
} | {
|
|
587
|
+
/** @constant */
|
|
588
|
+
type: "key";
|
|
589
|
+
keys: string[];
|
|
590
|
+
} | {
|
|
591
|
+
/** @constant */
|
|
592
|
+
type: "text";
|
|
593
|
+
text: string;
|
|
594
|
+
};
|
|
595
|
+
/** @description What the service sends on a terminal@1 socket, as JSON text, no message over 65,536 bytes. A terminal is a command the agent started or a shell a person opened; its id is the session id the agent's tools use. A new socket is first sent, for each terminal already there, the oldest first, its start, the end of what it wrote (its last 65,536 characters), and its exit if it has ended; then each event as it happens, with nothing to mark where the first ends. The last 64 that ended are among those already there, and one that leaves that list is not told. A character here is a UTF-16 unit. A socket with more than 4 MiB still to be sent to it is closed, with no close frame (1006): one that has stopped reading, or one that is reading while a terminal writes tens of megabytes at once. It isn't an error. Opened again, it is sent every terminal afresh, with the last 65,536 characters each wrote, in place of whatever it held. */
|
|
596
|
+
TerminalEvent: {
|
|
597
|
+
/** @constant */
|
|
598
|
+
type: "start";
|
|
599
|
+
id: string;
|
|
600
|
+
/**
|
|
601
|
+
* @description The way in it came: agent through a tool, person through this surface.
|
|
602
|
+
* @enum {string}
|
|
603
|
+
*/
|
|
604
|
+
by: "agent" | "person";
|
|
605
|
+
/** @description Its command, the first 8,000 characters of it. */
|
|
606
|
+
cmd: string;
|
|
607
|
+
/** @description Its folder, the first 2,000 characters of it. */
|
|
608
|
+
workdir: string;
|
|
609
|
+
/** @description Whether it is on a terminal device, as a person's shell is. One that isn't, as the agent's commands aren't, echoes nothing typed into it and wants a line feed for Enter. Nothing tells the size of one that is. */
|
|
610
|
+
tty: boolean;
|
|
611
|
+
/** Format: date-time */
|
|
612
|
+
at: string;
|
|
613
|
+
} | {
|
|
614
|
+
/** @constant */
|
|
615
|
+
type: "output";
|
|
616
|
+
id: string;
|
|
617
|
+
/**
|
|
618
|
+
* @description Left out for one on a terminal device, which has one stream, and in what a new socket is first sent, where the two are one text.
|
|
619
|
+
* @enum {string}
|
|
620
|
+
*/
|
|
621
|
+
stream?: "stdout" | "stderr";
|
|
622
|
+
text: string;
|
|
623
|
+
} | {
|
|
624
|
+
/** @constant */
|
|
625
|
+
type: "exit";
|
|
626
|
+
id: string;
|
|
627
|
+
exitCode: number;
|
|
628
|
+
/** Format: date-time */
|
|
629
|
+
at: string;
|
|
630
|
+
} | {
|
|
631
|
+
/** @constant */
|
|
632
|
+
type: "refused";
|
|
633
|
+
message: string;
|
|
634
|
+
};
|
|
635
|
+
/** @description What an operate socket sends on terminal@1, as JSON text. One that can't be done, or that is none of these, is answered with refused. What a watch socket sends is dropped. A message over 65,536 bytes closes the socket, so a long text goes as several inputs. */
|
|
636
|
+
TerminalInput: {
|
|
637
|
+
/** @constant */
|
|
638
|
+
type: "open";
|
|
639
|
+
columns: number;
|
|
640
|
+
rows: number;
|
|
641
|
+
} | {
|
|
642
|
+
/** @constant */
|
|
643
|
+
type: "input";
|
|
644
|
+
id: string;
|
|
645
|
+
text: string;
|
|
646
|
+
} | {
|
|
647
|
+
/** @constant */
|
|
648
|
+
type: "resize";
|
|
649
|
+
id: string;
|
|
650
|
+
columns: number;
|
|
651
|
+
rows: number;
|
|
652
|
+
} | {
|
|
653
|
+
/** @constant */
|
|
654
|
+
type: "stop";
|
|
655
|
+
id: string;
|
|
656
|
+
};
|
|
657
|
+
/** @description What the service sends on a metrics@1 socket, as JSON text. What a socket sends is dropped. */
|
|
658
|
+
LoadReading: {
|
|
659
|
+
/** @constant */
|
|
660
|
+
type: "reading";
|
|
661
|
+
/**
|
|
662
|
+
* @description Whose numbers these are. computer: the computer's own, as a container's are. machine: the whole machine's, as this computer's are, which it shares with whatever else runs there; and a container's where it can't read its own.
|
|
663
|
+
* @enum {string}
|
|
664
|
+
*/
|
|
665
|
+
scope: "computer" | "machine";
|
|
666
|
+
/** @description Of all the machine's CPUs, since the reading before. One decimal. */
|
|
667
|
+
cpuUsedPct: number;
|
|
668
|
+
/** @description Bytes in use. */
|
|
669
|
+
memUsed: number;
|
|
670
|
+
/** @description Bytes the machine has: no computer has a limit. */
|
|
671
|
+
memTotal: number;
|
|
672
|
+
/** @description Bytes used on the volume its workspace is on, or its own folder where it has no workspace. The volume's, not the workspace's own size. */
|
|
673
|
+
diskUsed: number;
|
|
674
|
+
/** @description Bytes on that volume. */
|
|
675
|
+
diskTotal: number;
|
|
676
|
+
};
|
|
677
|
+
/**
|
|
678
|
+
* @description A part of the service's machine an agent can use: its terminal, its files, its screen, and the person's own browser.
|
|
679
|
+
* @enum {string}
|
|
680
|
+
*/
|
|
681
|
+
Switch: "terminal" | "files" | "screen" | "browser";
|
|
682
|
+
/**
|
|
683
|
+
* @description install: Cua Driver, which the screen works through. screen-recording and accessibility: Cua Driver's two grants. chrome and edge: each browser, with remote debugging on or off; named: the one browser a service was given the folder of. folders: on a Mac, the folders macOS protects, which the files need and macOS asks for one by one: Desktop, Documents, Downloads, iCloud Drive, each cloud drive's folder and each mounted volume.
|
|
684
|
+
* @enum {string}
|
|
685
|
+
*/
|
|
686
|
+
NeedName: "install" | "screen-recording" | "accessibility" | "chrome" | "edge" | "named" | "folders";
|
|
687
|
+
Need: {
|
|
688
|
+
need: components["schemas"]["NeedName"];
|
|
689
|
+
/** @description A browser's name: Chrome, Edge, or the browser. */
|
|
690
|
+
name?: string;
|
|
691
|
+
/** @description For folders that are not-granted, the ones macOS refused at the person's last click, by name: Desktop, Documents, Downloads, iCloud Drive, a cloud drive's folder or a volume. */
|
|
692
|
+
refused?: string[];
|
|
693
|
+
/** @description For a grant, whose it is, as System Settings lists it: the outermost app Cua Driver is inside, CuaDriver for its own app, or an app that carries the driver. None where Cua Driver is in no app. */
|
|
694
|
+
holder?: string;
|
|
695
|
+
/**
|
|
696
|
+
* @description missing: not installed. unknown: it can't be read now. A browser is on while it is open with its remote debugging switched on. The folders are unknown until the person has asked for them, and while they are being asked for, since macOS gives no way to read a folder's grant without asking; then granted, or not-granted with the ones refused.
|
|
697
|
+
* @enum {string}
|
|
698
|
+
*/
|
|
699
|
+
state: "missing" | "granted" | "not-granted" | "unknown" | "on" | "off";
|
|
700
|
+
};
|
|
701
|
+
Setup: {
|
|
702
|
+
/** @description terminal, files, screen and browser, in that order. */
|
|
703
|
+
capabilities: {
|
|
704
|
+
capability: components["schemas"]["Switch"];
|
|
705
|
+
/** @description The person's switch. Off, agents' new calls to the part refuse, saying the person turned it off, and `info` says so; what an agent already started runs on. The terminal and the screen each reach the whole machine: commands read any file, and the screen acts in any app. The browser's switch is for the person's own; any browser's code-running tool answers to the terminal's switch, and a browser call that names files, by `paths` or `filename`, to the files'. A service started with `--lend` starts with every one off; any other, with every one on. */
|
|
706
|
+
on: boolean;
|
|
707
|
+
/** @description Whether the part has all it needs, apart from its switch: the screen, each item granted; the browser, one browser on. The terminal and files always do. */
|
|
708
|
+
ready: boolean;
|
|
709
|
+
/** @description Each thing the part needs, always, with its state. The terminal and files need nothing. The screen needs Cua Driver, which while it isn't installed is the one item, and on macOS its two grants. The browser lists Chrome then Edge, each on, off or missing, or the one browser named; with both on, the agent's is Chrome. */
|
|
710
|
+
needs: components["schemas"]["Need"][];
|
|
711
|
+
}[];
|
|
712
|
+
};
|
|
713
|
+
Connection: {
|
|
714
|
+
/** @description Whether any client holds a connection now. */
|
|
715
|
+
connected: boolean;
|
|
716
|
+
/** @description Each client holding one, the earliest first. */
|
|
717
|
+
clients: {
|
|
718
|
+
/** @description The name it gave, its first 100 characters, or empty: such as AgentOrg 0.0.15. */
|
|
719
|
+
name: string;
|
|
720
|
+
/** Format: date-time */
|
|
721
|
+
since: string;
|
|
722
|
+
/** @description Whether it connects from this machine, by the address it connects from. False behind --tls-proxy, where every client comes from the proxy. */
|
|
723
|
+
local: boolean;
|
|
724
|
+
}[];
|
|
725
|
+
};
|
|
726
|
+
/** @description Someone who acted on a computer in the last 10 seconds, or the agent while a command it started there still runs. The person acts in a live view at operate: opening a shell, typing into or stopping a terminal, writing a file, any input to the browser but moving the pointer, or any input to the screen that Cua Driver did. Watching is not acting, and the person's own use of the screen, outside a live view, can't be seen. The person's shell, and what runs in it, counts for 10 seconds after their last input there. The agent acts by calling its endpoints: starting a command, which is acting on its terminal until the command ends, even one left running, such as a server, as the terminal shows it running; typing into one (waiting on its output adds nothing); any file tool, reads among them; any browser tool that is answered; and any screen tool. Computers attached to the same machine share its files and its screen: each is shown the person and the other computers' agents acting on them, by name. */
|
|
727
|
+
Acting: {
|
|
728
|
+
/** @enum {string} */
|
|
729
|
+
who: "person" | "agent";
|
|
730
|
+
/** @description The agent's name */
|
|
731
|
+
name?: string;
|
|
732
|
+
/** @enum {string} */
|
|
733
|
+
capability: "terminal" | "files" | "browser" | "screen";
|
|
734
|
+
/** @description Which terminal, by its id; only for a terminal. */
|
|
735
|
+
terminal?: string;
|
|
736
|
+
/**
|
|
737
|
+
* Format: date-time
|
|
738
|
+
* @description When it last acted there, as of this message: one who goes on acting is sent again only when someone starts or stops. For the agent's command still running, when the agent started it or last typed into it, which can be more than 10 seconds ago; its end is its last act.
|
|
739
|
+
*/
|
|
740
|
+
at: string;
|
|
741
|
+
};
|
|
742
|
+
/** @description What the service sends on a presence@1 socket, as JSON text: the whole list of everyone acting now, the most recent first, empty where nobody is. It is sent when the socket opens and each time someone starts acting on something, or stops: 10 seconds after they last acted there, or, for the agent's command, 10 seconds after it ended. Nothing is refused by it. What a socket sends is dropped. */
|
|
743
|
+
PresenceEvent: {
|
|
744
|
+
/** @constant */
|
|
745
|
+
type: "presence";
|
|
746
|
+
acting: components["schemas"]["Acting"][];
|
|
747
|
+
};
|
|
748
|
+
/** @description What a socket sends on files@1, as JSON text. Each has an id of its own choosing, which the answer repeats; answers come as they are ready, in any order, and ids aren't checked for repeats. A request still unanswered when the socket closes gets no answer. A path is from the workspace, with / between its parts, or absolute inside it, and nothing outside the workspace is reached. A binary message that follows no write closes the socket, and so does any message over 1,048,576 bytes. */
|
|
749
|
+
FilesRequest: {
|
|
750
|
+
/** @constant */
|
|
751
|
+
type: "list";
|
|
752
|
+
id: string;
|
|
753
|
+
/** @description The workspace itself, if left out. */
|
|
754
|
+
path?: string;
|
|
755
|
+
} | {
|
|
756
|
+
/** @constant */
|
|
757
|
+
type: "read";
|
|
758
|
+
id: string;
|
|
759
|
+
path: string;
|
|
760
|
+
offset: number;
|
|
761
|
+
length: number;
|
|
762
|
+
} | {
|
|
763
|
+
/** @constant */
|
|
764
|
+
type: "changed";
|
|
765
|
+
id: string;
|
|
766
|
+
/** Format: date-time */
|
|
767
|
+
since: string;
|
|
768
|
+
} | {
|
|
769
|
+
/** @constant */
|
|
770
|
+
type: "write";
|
|
771
|
+
id: string;
|
|
772
|
+
path: string;
|
|
773
|
+
offset: number;
|
|
774
|
+
length: number;
|
|
775
|
+
last: boolean;
|
|
776
|
+
};
|
|
777
|
+
/** @description What the service sends on files@1, as JSON text, each with the id it answers. Nothing comes between a data message and its bytes. */
|
|
778
|
+
FilesAnswer: {
|
|
779
|
+
/** @constant */
|
|
780
|
+
type: "entries";
|
|
781
|
+
id: string;
|
|
782
|
+
/** @description What the workspace is called: its folder's own name, and nothing of where it is. It comes with every entries answer, whichever folder was asked for, so that with path it names the folder. A computer in a container made before `workspace` was added sends none, and there path alone names the folder. It is `workspace` for a workspace the service made, and empty for one at the top of a disk. */
|
|
783
|
+
workspace?: string;
|
|
784
|
+
/** @description The folder as it was asked for: `.` for the workspace itself. */
|
|
785
|
+
path: string;
|
|
786
|
+
entries: {
|
|
787
|
+
name: string;
|
|
788
|
+
/** @enum {string} */
|
|
789
|
+
kind: "file" | "folder" | "link";
|
|
790
|
+
size: number;
|
|
791
|
+
/** Format: date-time */
|
|
792
|
+
modifiedAt: string;
|
|
793
|
+
}[];
|
|
794
|
+
/** @description Whether the folder has more than these. */
|
|
795
|
+
more: boolean;
|
|
796
|
+
} | {
|
|
797
|
+
/** @constant */
|
|
798
|
+
type: "data";
|
|
799
|
+
id: string;
|
|
800
|
+
path: string;
|
|
801
|
+
offset: number;
|
|
802
|
+
/** @description How many bytes follow. */
|
|
803
|
+
length: number;
|
|
804
|
+
size: number;
|
|
805
|
+
/** Format: date-time */
|
|
806
|
+
modifiedAt: string;
|
|
807
|
+
} | {
|
|
808
|
+
/** @constant */
|
|
809
|
+
type: "changes";
|
|
810
|
+
id: string;
|
|
811
|
+
/** Format: date-time */
|
|
812
|
+
since: string;
|
|
813
|
+
changes: {
|
|
814
|
+
path: string;
|
|
815
|
+
size: number;
|
|
816
|
+
/** Format: date-time */
|
|
817
|
+
modifiedAt: string;
|
|
818
|
+
}[];
|
|
819
|
+
/** @description Whether more than these changed. */
|
|
820
|
+
more: boolean;
|
|
821
|
+
} | {
|
|
822
|
+
/** @constant */
|
|
823
|
+
type: "written";
|
|
824
|
+
id: string;
|
|
825
|
+
path: string;
|
|
826
|
+
size: number;
|
|
827
|
+
} | {
|
|
828
|
+
/** @constant */
|
|
829
|
+
type: "refused";
|
|
830
|
+
id: string;
|
|
831
|
+
message: string;
|
|
832
|
+
};
|
|
833
|
+
ComputerLogs: {
|
|
834
|
+
logs: {
|
|
835
|
+
/** Format: date-time */
|
|
836
|
+
timestamp: string;
|
|
837
|
+
line: string;
|
|
838
|
+
}[];
|
|
839
|
+
};
|
|
840
|
+
Readiness: {
|
|
841
|
+
ready: boolean;
|
|
842
|
+
/** @description Why it isn't ready, in a line a person reads. Only when it isn't. */
|
|
843
|
+
reason?: string;
|
|
844
|
+
};
|
|
845
|
+
/**
|
|
846
|
+
* @description What a computer offers its agent and the person: what it is, its terminals, its files and its screen. This computer's screen is reached through Cua Driver: it is ready where Cua Driver is installed, at 0.49.7 or later, and granted Screen Recording and Accessibility, and otherwise the reason says what to do: for a missing grant, where an app hosts the driver, to set it up in that app, by its name, and otherwise to grant it in System Settings. A part the person switched off on that machine isn't ready either.
|
|
847
|
+
* @enum {string}
|
|
848
|
+
*/
|
|
849
|
+
Capability: "about" | "terminal" | "files" | "screen";
|
|
850
|
+
CapabilityState: components["schemas"]["Readiness"] & {
|
|
851
|
+
capability: components["schemas"]["Capability"];
|
|
852
|
+
};
|
|
853
|
+
/**
|
|
854
|
+
* @description headless: a headless browser with a profile of its own, beside the computer, which a person watches and controls through its live view. own: the person's own browser on the service's machine, Chrome or Edge, signed in, offered for this computer: ready where one is open with its remote debugging switched on, Chrome first, which the person does once on its inspect page; the browser then asks them to allow each connection. Not ready, the reason names the browser and what to do on that machine. Switched off by the person on that machine, it isn't ready either.
|
|
855
|
+
* @enum {string}
|
|
856
|
+
*/
|
|
857
|
+
BrowserKind: "headless" | "own";
|
|
858
|
+
BrowserState: components["schemas"]["Readiness"] & {
|
|
859
|
+
kind: components["schemas"]["BrowserKind"];
|
|
860
|
+
};
|
|
861
|
+
Offer: components["schemas"]["Readiness"] & {
|
|
862
|
+
/** @description What such a computer has, each ready or not. */
|
|
863
|
+
capabilities: components["schemas"]["CapabilityState"][];
|
|
864
|
+
/** @description The browsers that can go with it, each ready or not. */
|
|
865
|
+
browsers: components["schemas"]["BrowserState"][];
|
|
866
|
+
};
|
|
867
|
+
MadeKind: components["schemas"]["Offer"] & {
|
|
868
|
+
isolation: components["schemas"]["Isolation"];
|
|
869
|
+
};
|
|
870
|
+
ServiceInfo: {
|
|
871
|
+
version: string;
|
|
872
|
+
/** @description This computer, the machine the service runs on, attached whole, as whoever started the service. It can be attached while ready: only where the service listens on loopback, with no proxy in front and no public address. Elsewhere it isn't offered, and one attached before is refused at start. */
|
|
873
|
+
thisComputer: components["schemas"]["Offer"];
|
|
874
|
+
/** @description Each kind of computer it makes, ready while it can be made now. A container is ready while Docker answers on the service's machine: asked for a second here and for ten when one is made, so one that is slow can be not ready here and still be made. */
|
|
875
|
+
made: components["schemas"]["MadeKind"][];
|
|
876
|
+
};
|
|
877
|
+
};
|
|
878
|
+
responses: {
|
|
879
|
+
/** @description It was refused. */
|
|
880
|
+
Error: {
|
|
881
|
+
headers: {
|
|
882
|
+
[name: string]: unknown;
|
|
883
|
+
};
|
|
884
|
+
content: {
|
|
885
|
+
"application/json": components["schemas"]["Error"];
|
|
886
|
+
};
|
|
887
|
+
};
|
|
888
|
+
/** @description No valid token. */
|
|
889
|
+
Unauthorized: {
|
|
890
|
+
headers: {
|
|
891
|
+
[name: string]: unknown;
|
|
892
|
+
};
|
|
893
|
+
content?: never;
|
|
894
|
+
};
|
|
895
|
+
};
|
|
896
|
+
parameters: {
|
|
897
|
+
computerID: string;
|
|
898
|
+
};
|
|
899
|
+
requestBodies: never;
|
|
900
|
+
headers: never;
|
|
901
|
+
pathItems: never;
|
|
902
|
+
}
|
|
903
|
+
export type $defs = Record<string, never>;
|
|
904
|
+
export interface operations {
|
|
905
|
+
getInfo: {
|
|
906
|
+
parameters: {
|
|
907
|
+
query?: never;
|
|
908
|
+
header?: never;
|
|
909
|
+
path?: never;
|
|
910
|
+
cookie?: never;
|
|
911
|
+
};
|
|
912
|
+
requestBody?: never;
|
|
913
|
+
responses: {
|
|
914
|
+
/** @description The service. */
|
|
915
|
+
200: {
|
|
916
|
+
headers: {
|
|
917
|
+
[name: string]: unknown;
|
|
918
|
+
};
|
|
919
|
+
content: {
|
|
920
|
+
"application/json": components["schemas"]["ServiceInfo"];
|
|
921
|
+
};
|
|
922
|
+
};
|
|
923
|
+
401: components["responses"]["Unauthorized"];
|
|
924
|
+
};
|
|
925
|
+
};
|
|
926
|
+
getConnection: {
|
|
927
|
+
parameters: {
|
|
928
|
+
query?: never;
|
|
929
|
+
header?: never;
|
|
930
|
+
path?: never;
|
|
931
|
+
cookie?: never;
|
|
932
|
+
};
|
|
933
|
+
requestBody?: never;
|
|
934
|
+
responses: {
|
|
935
|
+
/** @description Who is connected. */
|
|
936
|
+
200: {
|
|
937
|
+
headers: {
|
|
938
|
+
[name: string]: unknown;
|
|
939
|
+
};
|
|
940
|
+
content: {
|
|
941
|
+
"application/json": components["schemas"]["Connection"];
|
|
942
|
+
};
|
|
943
|
+
};
|
|
944
|
+
401: components["responses"]["Unauthorized"];
|
|
945
|
+
};
|
|
946
|
+
};
|
|
947
|
+
getSetup: {
|
|
948
|
+
parameters: {
|
|
949
|
+
query?: never;
|
|
950
|
+
header?: never;
|
|
951
|
+
path?: never;
|
|
952
|
+
cookie?: never;
|
|
953
|
+
};
|
|
954
|
+
requestBody?: never;
|
|
955
|
+
responses: {
|
|
956
|
+
/** @description Each part. */
|
|
957
|
+
200: {
|
|
958
|
+
headers: {
|
|
959
|
+
[name: string]: unknown;
|
|
960
|
+
};
|
|
961
|
+
content: {
|
|
962
|
+
"application/json": components["schemas"]["Setup"];
|
|
963
|
+
};
|
|
964
|
+
};
|
|
965
|
+
401: components["responses"]["Unauthorized"];
|
|
966
|
+
};
|
|
967
|
+
};
|
|
968
|
+
setSetup: {
|
|
969
|
+
parameters: {
|
|
970
|
+
query?: never;
|
|
971
|
+
header?: never;
|
|
972
|
+
path: {
|
|
973
|
+
capability: components["schemas"]["Switch"];
|
|
974
|
+
};
|
|
975
|
+
cookie?: never;
|
|
976
|
+
};
|
|
977
|
+
requestBody: {
|
|
978
|
+
content: {
|
|
979
|
+
"application/json": {
|
|
980
|
+
on: boolean;
|
|
981
|
+
};
|
|
982
|
+
};
|
|
983
|
+
};
|
|
984
|
+
responses: {
|
|
985
|
+
/** @description Set, and any request it makes started. */
|
|
986
|
+
200: {
|
|
987
|
+
headers: {
|
|
988
|
+
[name: string]: unknown;
|
|
989
|
+
};
|
|
990
|
+
content: {
|
|
991
|
+
"application/json": components["schemas"]["Setup"];
|
|
992
|
+
};
|
|
993
|
+
};
|
|
994
|
+
401: components["responses"]["Unauthorized"];
|
|
995
|
+
/** @description On, but a request it makes couldn't be started. */
|
|
996
|
+
409: {
|
|
997
|
+
headers: {
|
|
998
|
+
[name: string]: unknown;
|
|
999
|
+
};
|
|
1000
|
+
content: {
|
|
1001
|
+
"application/json": components["schemas"]["Error"];
|
|
1002
|
+
};
|
|
1003
|
+
};
|
|
1004
|
+
};
|
|
1005
|
+
};
|
|
1006
|
+
askSetup: {
|
|
1007
|
+
parameters: {
|
|
1008
|
+
query?: never;
|
|
1009
|
+
header?: never;
|
|
1010
|
+
path: {
|
|
1011
|
+
capability: components["schemas"]["Switch"];
|
|
1012
|
+
};
|
|
1013
|
+
cookie?: never;
|
|
1014
|
+
};
|
|
1015
|
+
requestBody?: {
|
|
1016
|
+
content: {
|
|
1017
|
+
"application/json": {
|
|
1018
|
+
need?: components["schemas"]["NeedName"];
|
|
1019
|
+
};
|
|
1020
|
+
};
|
|
1021
|
+
};
|
|
1022
|
+
responses: {
|
|
1023
|
+
/** @description Asked, its steps started. */
|
|
1024
|
+
200: {
|
|
1025
|
+
headers: {
|
|
1026
|
+
[name: string]: unknown;
|
|
1027
|
+
};
|
|
1028
|
+
content: {
|
|
1029
|
+
"application/json": components["schemas"]["Setup"];
|
|
1030
|
+
};
|
|
1031
|
+
};
|
|
1032
|
+
401: components["responses"]["Unauthorized"];
|
|
1033
|
+
/** @description The part doesn't need that here, or what it needs can't be asked for, such as a browser that isn't installed, or the steps couldn't be started, or, once macOS's request was made, the grant's pane couldn't be opened. */
|
|
1034
|
+
409: {
|
|
1035
|
+
headers: {
|
|
1036
|
+
[name: string]: unknown;
|
|
1037
|
+
};
|
|
1038
|
+
content: {
|
|
1039
|
+
"application/json": components["schemas"]["Error"];
|
|
1040
|
+
};
|
|
1041
|
+
};
|
|
1042
|
+
};
|
|
1043
|
+
};
|
|
1044
|
+
openSetupSettings: {
|
|
1045
|
+
parameters: {
|
|
1046
|
+
query?: never;
|
|
1047
|
+
header?: never;
|
|
1048
|
+
path: {
|
|
1049
|
+
capability: components["schemas"]["Switch"];
|
|
1050
|
+
};
|
|
1051
|
+
cookie?: never;
|
|
1052
|
+
};
|
|
1053
|
+
requestBody: {
|
|
1054
|
+
content: {
|
|
1055
|
+
"application/json": {
|
|
1056
|
+
need: components["schemas"]["NeedName"];
|
|
1057
|
+
};
|
|
1058
|
+
};
|
|
1059
|
+
};
|
|
1060
|
+
responses: {
|
|
1061
|
+
/** @description Its pane asked to open. */
|
|
1062
|
+
200: {
|
|
1063
|
+
headers: {
|
|
1064
|
+
[name: string]: unknown;
|
|
1065
|
+
};
|
|
1066
|
+
content: {
|
|
1067
|
+
"application/json": components["schemas"]["Setup"];
|
|
1068
|
+
};
|
|
1069
|
+
};
|
|
1070
|
+
401: components["responses"]["Unauthorized"];
|
|
1071
|
+
/** @description The part doesn't need that here, it has no pane of System Settings, or the pane couldn't be opened. */
|
|
1072
|
+
409: {
|
|
1073
|
+
headers: {
|
|
1074
|
+
[name: string]: unknown;
|
|
1075
|
+
};
|
|
1076
|
+
content: {
|
|
1077
|
+
"application/json": components["schemas"]["Error"];
|
|
1078
|
+
};
|
|
1079
|
+
};
|
|
1080
|
+
};
|
|
1081
|
+
};
|
|
1082
|
+
getActing: {
|
|
1083
|
+
parameters: {
|
|
1084
|
+
query?: never;
|
|
1085
|
+
header?: never;
|
|
1086
|
+
path?: never;
|
|
1087
|
+
cookie?: never;
|
|
1088
|
+
};
|
|
1089
|
+
requestBody?: never;
|
|
1090
|
+
responses: {
|
|
1091
|
+
/** @description Who is acting now. */
|
|
1092
|
+
200: {
|
|
1093
|
+
headers: {
|
|
1094
|
+
[name: string]: unknown;
|
|
1095
|
+
};
|
|
1096
|
+
content: {
|
|
1097
|
+
"application/json": components["schemas"]["Acting"][];
|
|
1098
|
+
};
|
|
1099
|
+
};
|
|
1100
|
+
401: components["responses"]["Unauthorized"];
|
|
1101
|
+
};
|
|
1102
|
+
};
|
|
1103
|
+
listComputers: {
|
|
1104
|
+
parameters: {
|
|
1105
|
+
query?: {
|
|
1106
|
+
/** @description Only computers in this state. */
|
|
1107
|
+
state?: components["schemas"]["ComputerState"];
|
|
1108
|
+
};
|
|
1109
|
+
header?: never;
|
|
1110
|
+
path?: never;
|
|
1111
|
+
cookie?: never;
|
|
1112
|
+
};
|
|
1113
|
+
requestBody?: never;
|
|
1114
|
+
responses: {
|
|
1115
|
+
/** @description The computers, newest first. */
|
|
1116
|
+
200: {
|
|
1117
|
+
headers: {
|
|
1118
|
+
[name: string]: unknown;
|
|
1119
|
+
};
|
|
1120
|
+
content: {
|
|
1121
|
+
"application/json": components["schemas"]["Computer"][];
|
|
1122
|
+
};
|
|
1123
|
+
};
|
|
1124
|
+
401: components["responses"]["Unauthorized"];
|
|
1125
|
+
};
|
|
1126
|
+
};
|
|
1127
|
+
createComputer: {
|
|
1128
|
+
parameters: {
|
|
1129
|
+
query?: never;
|
|
1130
|
+
header?: never;
|
|
1131
|
+
path?: never;
|
|
1132
|
+
cookie?: never;
|
|
1133
|
+
};
|
|
1134
|
+
requestBody: {
|
|
1135
|
+
content: {
|
|
1136
|
+
"application/json": components["schemas"]["NewComputer"];
|
|
1137
|
+
};
|
|
1138
|
+
};
|
|
1139
|
+
responses: {
|
|
1140
|
+
/** @description The computer, with its access token, shown only now. */
|
|
1141
|
+
201: {
|
|
1142
|
+
headers: {
|
|
1143
|
+
[name: string]: unknown;
|
|
1144
|
+
};
|
|
1145
|
+
content: {
|
|
1146
|
+
"application/json": components["schemas"]["CreatedComputer"];
|
|
1147
|
+
};
|
|
1148
|
+
};
|
|
1149
|
+
400: components["responses"]["Error"];
|
|
1150
|
+
401: components["responses"]["Unauthorized"];
|
|
1151
|
+
409: components["responses"]["Error"];
|
|
1152
|
+
};
|
|
1153
|
+
};
|
|
1154
|
+
attachComputer: {
|
|
1155
|
+
parameters: {
|
|
1156
|
+
query?: never;
|
|
1157
|
+
header?: never;
|
|
1158
|
+
path?: never;
|
|
1159
|
+
cookie?: never;
|
|
1160
|
+
};
|
|
1161
|
+
requestBody: {
|
|
1162
|
+
content: {
|
|
1163
|
+
"application/json": components["schemas"]["AttachComputer"];
|
|
1164
|
+
};
|
|
1165
|
+
};
|
|
1166
|
+
responses: {
|
|
1167
|
+
/** @description It, with its access token, shown only now. */
|
|
1168
|
+
201: {
|
|
1169
|
+
headers: {
|
|
1170
|
+
[name: string]: unknown;
|
|
1171
|
+
};
|
|
1172
|
+
content: {
|
|
1173
|
+
"application/json": components["schemas"]["CreatedComputer"];
|
|
1174
|
+
};
|
|
1175
|
+
};
|
|
1176
|
+
400: components["responses"]["Error"];
|
|
1177
|
+
401: components["responses"]["Unauthorized"];
|
|
1178
|
+
409: components["responses"]["Error"];
|
|
1179
|
+
};
|
|
1180
|
+
};
|
|
1181
|
+
getComputer: {
|
|
1182
|
+
parameters: {
|
|
1183
|
+
query?: never;
|
|
1184
|
+
header?: never;
|
|
1185
|
+
path: {
|
|
1186
|
+
computerID: components["parameters"]["computerID"];
|
|
1187
|
+
};
|
|
1188
|
+
cookie?: never;
|
|
1189
|
+
};
|
|
1190
|
+
requestBody?: never;
|
|
1191
|
+
responses: {
|
|
1192
|
+
/** @description The computer. */
|
|
1193
|
+
200: {
|
|
1194
|
+
headers: {
|
|
1195
|
+
[name: string]: unknown;
|
|
1196
|
+
};
|
|
1197
|
+
content: {
|
|
1198
|
+
"application/json": components["schemas"]["ComputerDetail"];
|
|
1199
|
+
};
|
|
1200
|
+
};
|
|
1201
|
+
401: components["responses"]["Unauthorized"];
|
|
1202
|
+
404: components["responses"]["Error"];
|
|
1203
|
+
};
|
|
1204
|
+
};
|
|
1205
|
+
killComputer: {
|
|
1206
|
+
parameters: {
|
|
1207
|
+
query?: never;
|
|
1208
|
+
header?: never;
|
|
1209
|
+
path: {
|
|
1210
|
+
computerID: components["parameters"]["computerID"];
|
|
1211
|
+
};
|
|
1212
|
+
cookie?: never;
|
|
1213
|
+
};
|
|
1214
|
+
requestBody?: never;
|
|
1215
|
+
responses: {
|
|
1216
|
+
/** @description Gone. */
|
|
1217
|
+
204: {
|
|
1218
|
+
headers: {
|
|
1219
|
+
[name: string]: unknown;
|
|
1220
|
+
};
|
|
1221
|
+
content?: never;
|
|
1222
|
+
};
|
|
1223
|
+
401: components["responses"]["Unauthorized"];
|
|
1224
|
+
404: components["responses"]["Error"];
|
|
1225
|
+
/** @description It can't be removed here: a container while Docker doesn't answer, or one made before under a service that now only lends this machine. */
|
|
1226
|
+
409: {
|
|
1227
|
+
headers: {
|
|
1228
|
+
[name: string]: unknown;
|
|
1229
|
+
};
|
|
1230
|
+
content: {
|
|
1231
|
+
"application/json": components["schemas"]["Error"];
|
|
1232
|
+
};
|
|
1233
|
+
};
|
|
1234
|
+
};
|
|
1235
|
+
};
|
|
1236
|
+
setComputerTimeout: {
|
|
1237
|
+
parameters: {
|
|
1238
|
+
query?: never;
|
|
1239
|
+
header?: never;
|
|
1240
|
+
path: {
|
|
1241
|
+
computerID: components["parameters"]["computerID"];
|
|
1242
|
+
};
|
|
1243
|
+
cookie?: never;
|
|
1244
|
+
};
|
|
1245
|
+
requestBody: {
|
|
1246
|
+
content: {
|
|
1247
|
+
"application/json": {
|
|
1248
|
+
timeout: components["schemas"]["Timeout"];
|
|
1249
|
+
};
|
|
1250
|
+
};
|
|
1251
|
+
};
|
|
1252
|
+
responses: {
|
|
1253
|
+
/** @description The computer. */
|
|
1254
|
+
200: {
|
|
1255
|
+
headers: {
|
|
1256
|
+
[name: string]: unknown;
|
|
1257
|
+
};
|
|
1258
|
+
content: {
|
|
1259
|
+
"application/json": components["schemas"]["Computer"];
|
|
1260
|
+
};
|
|
1261
|
+
};
|
|
1262
|
+
401: components["responses"]["Unauthorized"];
|
|
1263
|
+
404: components["responses"]["Error"];
|
|
1264
|
+
409: components["responses"]["Error"];
|
|
1265
|
+
};
|
|
1266
|
+
};
|
|
1267
|
+
stopComputer: {
|
|
1268
|
+
parameters: {
|
|
1269
|
+
query?: never;
|
|
1270
|
+
header?: never;
|
|
1271
|
+
path: {
|
|
1272
|
+
computerID: components["parameters"]["computerID"];
|
|
1273
|
+
};
|
|
1274
|
+
cookie?: never;
|
|
1275
|
+
};
|
|
1276
|
+
requestBody?: never;
|
|
1277
|
+
responses: {
|
|
1278
|
+
/** @description The computer. */
|
|
1279
|
+
200: {
|
|
1280
|
+
headers: {
|
|
1281
|
+
[name: string]: unknown;
|
|
1282
|
+
};
|
|
1283
|
+
content: {
|
|
1284
|
+
"application/json": components["schemas"]["Computer"];
|
|
1285
|
+
};
|
|
1286
|
+
};
|
|
1287
|
+
401: components["responses"]["Unauthorized"];
|
|
1288
|
+
404: components["responses"]["Error"];
|
|
1289
|
+
};
|
|
1290
|
+
};
|
|
1291
|
+
startComputer: {
|
|
1292
|
+
parameters: {
|
|
1293
|
+
query?: never;
|
|
1294
|
+
header?: never;
|
|
1295
|
+
path: {
|
|
1296
|
+
computerID: components["parameters"]["computerID"];
|
|
1297
|
+
};
|
|
1298
|
+
cookie?: never;
|
|
1299
|
+
};
|
|
1300
|
+
requestBody?: {
|
|
1301
|
+
content: {
|
|
1302
|
+
"application/json": {
|
|
1303
|
+
timeout?: components["schemas"]["Timeout"];
|
|
1304
|
+
};
|
|
1305
|
+
};
|
|
1306
|
+
};
|
|
1307
|
+
responses: {
|
|
1308
|
+
/** @description The computer. */
|
|
1309
|
+
200: {
|
|
1310
|
+
headers: {
|
|
1311
|
+
[name: string]: unknown;
|
|
1312
|
+
};
|
|
1313
|
+
content: {
|
|
1314
|
+
"application/json": components["schemas"]["Computer"];
|
|
1315
|
+
};
|
|
1316
|
+
};
|
|
1317
|
+
401: components["responses"]["Unauthorized"];
|
|
1318
|
+
404: components["responses"]["Error"];
|
|
1319
|
+
409: components["responses"]["Error"];
|
|
1320
|
+
};
|
|
1321
|
+
};
|
|
1322
|
+
getComputerLogs: {
|
|
1323
|
+
parameters: {
|
|
1324
|
+
query?: never;
|
|
1325
|
+
header?: never;
|
|
1326
|
+
path: {
|
|
1327
|
+
computerID: components["parameters"]["computerID"];
|
|
1328
|
+
};
|
|
1329
|
+
cookie?: never;
|
|
1330
|
+
};
|
|
1331
|
+
requestBody?: never;
|
|
1332
|
+
responses: {
|
|
1333
|
+
/** @description The logs. */
|
|
1334
|
+
200: {
|
|
1335
|
+
headers: {
|
|
1336
|
+
[name: string]: unknown;
|
|
1337
|
+
};
|
|
1338
|
+
content: {
|
|
1339
|
+
"application/json": components["schemas"]["ComputerLogs"];
|
|
1340
|
+
};
|
|
1341
|
+
};
|
|
1342
|
+
401: components["responses"]["Unauthorized"];
|
|
1343
|
+
404: components["responses"]["Error"];
|
|
1344
|
+
};
|
|
1345
|
+
};
|
|
1346
|
+
createLiveSession: {
|
|
1347
|
+
parameters: {
|
|
1348
|
+
query?: never;
|
|
1349
|
+
header?: never;
|
|
1350
|
+
path: {
|
|
1351
|
+
computerID: components["parameters"]["computerID"];
|
|
1352
|
+
};
|
|
1353
|
+
cookie?: never;
|
|
1354
|
+
};
|
|
1355
|
+
requestBody: {
|
|
1356
|
+
content: {
|
|
1357
|
+
"application/json": components["schemas"]["NewLiveSession"];
|
|
1358
|
+
};
|
|
1359
|
+
};
|
|
1360
|
+
responses: {
|
|
1361
|
+
/** @description The ticket. */
|
|
1362
|
+
201: {
|
|
1363
|
+
headers: {
|
|
1364
|
+
[name: string]: unknown;
|
|
1365
|
+
};
|
|
1366
|
+
content: {
|
|
1367
|
+
"application/json": components["schemas"]["LiveSession"];
|
|
1368
|
+
};
|
|
1369
|
+
};
|
|
1370
|
+
400: components["responses"]["Error"];
|
|
1371
|
+
401: components["responses"]["Unauthorized"];
|
|
1372
|
+
404: components["responses"]["Error"];
|
|
1373
|
+
409: components["responses"]["Error"];
|
|
1374
|
+
};
|
|
1375
|
+
};
|
|
1376
|
+
openLiveSession: {
|
|
1377
|
+
parameters: {
|
|
1378
|
+
query?: never;
|
|
1379
|
+
header?: never;
|
|
1380
|
+
path: {
|
|
1381
|
+
liveID: string;
|
|
1382
|
+
};
|
|
1383
|
+
cookie?: never;
|
|
1384
|
+
};
|
|
1385
|
+
requestBody?: never;
|
|
1386
|
+
responses: {
|
|
1387
|
+
/** @description The socket */
|
|
1388
|
+
101: {
|
|
1389
|
+
headers: {
|
|
1390
|
+
[name: string]: unknown;
|
|
1391
|
+
};
|
|
1392
|
+
content?: never;
|
|
1393
|
+
};
|
|
1394
|
+
403: components["responses"]["Error"];
|
|
1395
|
+
404: components["responses"]["Error"];
|
|
1396
|
+
426: components["responses"]["Error"];
|
|
1397
|
+
};
|
|
1398
|
+
};
|
|
1399
|
+
}
|