@aphrody/winclean 0.0.0-stage → 0.1.0
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/README.md +23 -3
- package/package.json +36 -4
- package/src/catalog.ts +3670 -0
- package/src/generated.ts +3726 -0
- package/src/index.ts +80 -0
- package/src/result.ts +73 -0
package/src/catalog.ts
ADDED
|
@@ -0,0 +1,3670 @@
|
|
|
1
|
+
// SPDX-License-Identifier: Apache-2.0
|
|
2
|
+
// Generated from crates/os/winclean/src/tools.json by scripts/tools/os/scripts/generate-winclean-catalog.ts.
|
|
3
|
+
// Do not edit by hand.
|
|
4
|
+
export const TOOL_CATALOG: ReadonlyArray<{ name: string; description: string; inputSchema: Record<string, unknown>; execution?: unknown }> = [
|
|
5
|
+
{
|
|
6
|
+
"name": "analyze_pe",
|
|
7
|
+
"description": "Performs static analysis and symbol recovery on a target Windows PE binary (.exe or .dll). Recovers sections, imports, entry point disassembly, and maps symbols using heuristics (no execution).",
|
|
8
|
+
"inputSchema": {
|
|
9
|
+
"type": "object",
|
|
10
|
+
"properties": {
|
|
11
|
+
"path": {
|
|
12
|
+
"description": "Absolute path to the target PE executable or DLL file.",
|
|
13
|
+
"type": "string"
|
|
14
|
+
}
|
|
15
|
+
},
|
|
16
|
+
"required": [
|
|
17
|
+
"path"
|
|
18
|
+
]
|
|
19
|
+
}
|
|
20
|
+
},
|
|
21
|
+
{
|
|
22
|
+
"name": "aob_scan",
|
|
23
|
+
"description": "Scans raw file bytes for an Array of Bytes (AOB) pattern with optional wildcards (? or ??). Pattern format: '48 8B ? ? 48 89' or 'E8 ? ? ? ? 85 C0'. Returns matching offsets in the binary.",
|
|
24
|
+
"inputSchema": {
|
|
25
|
+
"type": "object",
|
|
26
|
+
"properties": {
|
|
27
|
+
"path": {
|
|
28
|
+
"description": "Absolute path to the target binary.",
|
|
29
|
+
"type": "string"
|
|
30
|
+
},
|
|
31
|
+
"pattern": {
|
|
32
|
+
"description": "AOB pattern with hex bytes and wildcards, e.g. '48 89 5C 24 ? 48 89 74 24 ?'.",
|
|
33
|
+
"type": "string"
|
|
34
|
+
},
|
|
35
|
+
"maxMatches": {
|
|
36
|
+
"description": "Max matches to return (default 50, max 1000).",
|
|
37
|
+
"type": "integer",
|
|
38
|
+
"default": 50
|
|
39
|
+
}
|
|
40
|
+
},
|
|
41
|
+
"required": [
|
|
42
|
+
"path",
|
|
43
|
+
"pattern"
|
|
44
|
+
]
|
|
45
|
+
}
|
|
46
|
+
},
|
|
47
|
+
{
|
|
48
|
+
"name": "asar_list",
|
|
49
|
+
"description": "Lists files contained inside an Electron ASAR archive (.asar) without extraction or execution. Returns relative paths, offsets, and sizes.",
|
|
50
|
+
"inputSchema": {
|
|
51
|
+
"type": "object",
|
|
52
|
+
"properties": {
|
|
53
|
+
"path": {
|
|
54
|
+
"description": "Absolute path to the .asar archive.",
|
|
55
|
+
"type": "string"
|
|
56
|
+
}
|
|
57
|
+
},
|
|
58
|
+
"required": [
|
|
59
|
+
"path"
|
|
60
|
+
]
|
|
61
|
+
}
|
|
62
|
+
},
|
|
63
|
+
{
|
|
64
|
+
"name": "binary_aes_ctr_decrypt",
|
|
65
|
+
"description": "AES-128/256-CTR decryption of a file using caller-supplied key (hex) and 16-byte IV (hex). Streams large files. Returns sha256 of the plaintext. Key must be 16 or 32 bytes; IV must be 16 bytes.",
|
|
66
|
+
"inputSchema": {
|
|
67
|
+
"type": "object",
|
|
68
|
+
"properties": {
|
|
69
|
+
"inputPath": {
|
|
70
|
+
"description": "Absolute path to the ciphertext.",
|
|
71
|
+
"type": "string"
|
|
72
|
+
},
|
|
73
|
+
"outputPath": {
|
|
74
|
+
"description": "Absolute path of the plaintext output.",
|
|
75
|
+
"type": "string"
|
|
76
|
+
},
|
|
77
|
+
"keyHex": {
|
|
78
|
+
"description": "AES key in hex (32 or 64 hex chars).",
|
|
79
|
+
"type": "string"
|
|
80
|
+
},
|
|
81
|
+
"ivHex": {
|
|
82
|
+
"description": "Initial counter (IV) in hex (32 hex chars).",
|
|
83
|
+
"type": "string"
|
|
84
|
+
}
|
|
85
|
+
},
|
|
86
|
+
"required": [
|
|
87
|
+
"inputPath",
|
|
88
|
+
"outputPath",
|
|
89
|
+
"keyHex",
|
|
90
|
+
"ivHex"
|
|
91
|
+
]
|
|
92
|
+
}
|
|
93
|
+
},
|
|
94
|
+
{
|
|
95
|
+
"name": "binary_entropy_map",
|
|
96
|
+
"description": "Computes Shannon entropy (0..8 bits/byte) per fixed-size block. High entropy (>=7.5) typically indicates encryption or compression. Helps locate packed sections in a binary without disassembling.",
|
|
97
|
+
"inputSchema": {
|
|
98
|
+
"type": "object",
|
|
99
|
+
"properties": {
|
|
100
|
+
"path": {
|
|
101
|
+
"description": "Absolute path to the file.",
|
|
102
|
+
"type": "string"
|
|
103
|
+
},
|
|
104
|
+
"blockSize": {
|
|
105
|
+
"description": "Block size in bytes (default 4096, min 256, max 1048576).",
|
|
106
|
+
"type": "integer",
|
|
107
|
+
"default": 4096
|
|
108
|
+
}
|
|
109
|
+
},
|
|
110
|
+
"required": [
|
|
111
|
+
"path"
|
|
112
|
+
]
|
|
113
|
+
}
|
|
114
|
+
},
|
|
115
|
+
{
|
|
116
|
+
"name": "binary_extract_strings",
|
|
117
|
+
"description": "Extracts printable ASCII and UTF-16LE strings of >=minLength characters from a file. Returns up to maxResults entries with offset, encoding (ascii/utf16), and the string. Streams the file in 1 MiB chunks — works on large binaries.",
|
|
118
|
+
"inputSchema": {
|
|
119
|
+
"type": "object",
|
|
120
|
+
"properties": {
|
|
121
|
+
"path": {
|
|
122
|
+
"description": "Absolute path to the file.",
|
|
123
|
+
"type": "string"
|
|
124
|
+
},
|
|
125
|
+
"minLength": {
|
|
126
|
+
"description": "Minimum string length (default 4, capped at 256).",
|
|
127
|
+
"type": "integer",
|
|
128
|
+
"default": 4
|
|
129
|
+
},
|
|
130
|
+
"maxResults": {
|
|
131
|
+
"description": "Maximum strings to return (default 1000, capped at 50000).",
|
|
132
|
+
"type": "integer",
|
|
133
|
+
"default": 1000
|
|
134
|
+
}
|
|
135
|
+
},
|
|
136
|
+
"required": [
|
|
137
|
+
"path"
|
|
138
|
+
]
|
|
139
|
+
}
|
|
140
|
+
},
|
|
141
|
+
{
|
|
142
|
+
"name": "binary_hash_multi",
|
|
143
|
+
"description": "Computes MD5 + SHA1 + SHA256 of a file in a single pass. Streams the file (any size). Returns all three hex digests.",
|
|
144
|
+
"inputSchema": {
|
|
145
|
+
"type": "object",
|
|
146
|
+
"properties": {
|
|
147
|
+
"path": {
|
|
148
|
+
"description": "Absolute path to the file.",
|
|
149
|
+
"type": "string"
|
|
150
|
+
}
|
|
151
|
+
},
|
|
152
|
+
"required": [
|
|
153
|
+
"path"
|
|
154
|
+
]
|
|
155
|
+
}
|
|
156
|
+
},
|
|
157
|
+
{
|
|
158
|
+
"name": "binary_list_cpk",
|
|
159
|
+
"description": "Lists files inside a CRIWARE CPK archive (used by Inazuma Eleven Victory Road, many Japanese games). Parses the @UTF table at the start of the file. Returns up to maxEntries rows with internal path, offset, size, compressed size, CRC32.",
|
|
160
|
+
"inputSchema": {
|
|
161
|
+
"type": "object",
|
|
162
|
+
"properties": {
|
|
163
|
+
"path": {
|
|
164
|
+
"description": "Absolute path to the .cpk archive.",
|
|
165
|
+
"type": "string"
|
|
166
|
+
},
|
|
167
|
+
"maxEntries": {
|
|
168
|
+
"description": "Max entries to return (default 500, capped at 50000).",
|
|
169
|
+
"type": "integer",
|
|
170
|
+
"default": 500
|
|
171
|
+
}
|
|
172
|
+
},
|
|
173
|
+
"required": [
|
|
174
|
+
"path"
|
|
175
|
+
]
|
|
176
|
+
}
|
|
177
|
+
},
|
|
178
|
+
{
|
|
179
|
+
"name": "binary_parse_pe_header",
|
|
180
|
+
"description": "Parses the PE/COFF header of a Windows executable or DLL. Returns machine (x64/arm64/x86), characteristics, image base, entry RVA, subsystem (gui/console), is64bit flag, and section table (name + RVA + size + flags).",
|
|
181
|
+
"inputSchema": {
|
|
182
|
+
"type": "object",
|
|
183
|
+
"properties": {
|
|
184
|
+
"path": {
|
|
185
|
+
"description": "Absolute path to the PE file (.exe / .dll / .sys / .efi).",
|
|
186
|
+
"type": "string"
|
|
187
|
+
}
|
|
188
|
+
},
|
|
189
|
+
"required": [
|
|
190
|
+
"path"
|
|
191
|
+
]
|
|
192
|
+
}
|
|
193
|
+
},
|
|
194
|
+
{
|
|
195
|
+
"name": "binary_section_dump",
|
|
196
|
+
"description": "Dumps one named section (e.g. '.text', '.rdata', '.rsrc') of a PE file to outputPath. Returns offset, size, sha256.",
|
|
197
|
+
"inputSchema": {
|
|
198
|
+
"type": "object",
|
|
199
|
+
"properties": {
|
|
200
|
+
"path": {
|
|
201
|
+
"description": "Absolute path to the PE file.",
|
|
202
|
+
"type": "string"
|
|
203
|
+
},
|
|
204
|
+
"sectionName": {
|
|
205
|
+
"description": "Section name (e.g. '.text').",
|
|
206
|
+
"type": "string"
|
|
207
|
+
},
|
|
208
|
+
"outputPath": {
|
|
209
|
+
"description": "Output binary path. Empty = auto in %TEMP%.",
|
|
210
|
+
"type": [
|
|
211
|
+
"string",
|
|
212
|
+
"null"
|
|
213
|
+
],
|
|
214
|
+
"default": null
|
|
215
|
+
}
|
|
216
|
+
},
|
|
217
|
+
"required": [
|
|
218
|
+
"path",
|
|
219
|
+
"sectionName"
|
|
220
|
+
]
|
|
221
|
+
}
|
|
222
|
+
},
|
|
223
|
+
{
|
|
224
|
+
"name": "binary_xor_decrypt",
|
|
225
|
+
"description": "Writes 'decrypted' = encryptedFile XOR repeating-key to outputPath. Key in hex (e.g. 'A5 5A 12' or 'A55A12'). Streams large files. If the encryption is a single-byte XOR, pass one byte. Returns sha256 of result.",
|
|
226
|
+
"inputSchema": {
|
|
227
|
+
"type": "object",
|
|
228
|
+
"properties": {
|
|
229
|
+
"inputPath": {
|
|
230
|
+
"description": "Absolute path to the encrypted file.",
|
|
231
|
+
"type": "string"
|
|
232
|
+
},
|
|
233
|
+
"outputPath": {
|
|
234
|
+
"description": "Absolute path of the decrypted output.",
|
|
235
|
+
"type": "string"
|
|
236
|
+
},
|
|
237
|
+
"keyHex": {
|
|
238
|
+
"description": "Hex key (e.g. 'A5' or 'DEADBEEF').",
|
|
239
|
+
"type": "string"
|
|
240
|
+
}
|
|
241
|
+
},
|
|
242
|
+
"required": [
|
|
243
|
+
"inputPath",
|
|
244
|
+
"outputPath",
|
|
245
|
+
"keyHex"
|
|
246
|
+
]
|
|
247
|
+
}
|
|
248
|
+
},
|
|
249
|
+
{
|
|
250
|
+
"name": "click",
|
|
251
|
+
"description": "Performs a mouse click at the given screen coordinates. button: 'left' | 'right' | 'middle'. clicks: 0 = hover only, 1 = single click, 2 = double click.",
|
|
252
|
+
"inputSchema": {
|
|
253
|
+
"type": "object",
|
|
254
|
+
"properties": {
|
|
255
|
+
"x": {
|
|
256
|
+
"description": "X coordinate in screen pixels.",
|
|
257
|
+
"type": "integer"
|
|
258
|
+
},
|
|
259
|
+
"y": {
|
|
260
|
+
"description": "Y coordinate in screen pixels.",
|
|
261
|
+
"type": "integer"
|
|
262
|
+
},
|
|
263
|
+
"button": {
|
|
264
|
+
"description": "Mouse button: left | right | middle.",
|
|
265
|
+
"type": "string",
|
|
266
|
+
"default": "left"
|
|
267
|
+
},
|
|
268
|
+
"clicks": {
|
|
269
|
+
"description": "0 = hover, 1 = single, 2 = double.",
|
|
270
|
+
"type": "integer",
|
|
271
|
+
"default": 1
|
|
272
|
+
}
|
|
273
|
+
},
|
|
274
|
+
"required": [
|
|
275
|
+
"x",
|
|
276
|
+
"y"
|
|
277
|
+
]
|
|
278
|
+
}
|
|
279
|
+
},
|
|
280
|
+
{
|
|
281
|
+
"name": "computer_capture_screen",
|
|
282
|
+
"description": "Captures the primary desktop as a PNG image content block for visual computer use. Returns the screen dimensions and coordinate space in a text block before the image. Use computer_observe for a specific application and its UI Automation tree.",
|
|
283
|
+
"inputSchema": {
|
|
284
|
+
"type": "object",
|
|
285
|
+
"properties": {}
|
|
286
|
+
}
|
|
287
|
+
},
|
|
288
|
+
{
|
|
289
|
+
"name": "computer_click",
|
|
290
|
+
"description": "Clicks a point in the selected application using native mouse input. x/y are relative to the outer window rectangle returned by computer_observe. The window is restored and focused by default. Re-observe after the click because menus and layouts may change.",
|
|
291
|
+
"inputSchema": {
|
|
292
|
+
"type": "object",
|
|
293
|
+
"properties": {
|
|
294
|
+
"windowHandle": {
|
|
295
|
+
"description": "Exact HWND from the latest observation (0 = current foreground window).",
|
|
296
|
+
"type": "integer"
|
|
297
|
+
},
|
|
298
|
+
"x": {
|
|
299
|
+
"description": "Window-relative X coordinate in pixels.",
|
|
300
|
+
"type": "integer"
|
|
301
|
+
},
|
|
302
|
+
"y": {
|
|
303
|
+
"description": "Window-relative Y coordinate in pixels.",
|
|
304
|
+
"type": "integer"
|
|
305
|
+
},
|
|
306
|
+
"button": {
|
|
307
|
+
"description": "Mouse button: left | right | middle.",
|
|
308
|
+
"type": "string",
|
|
309
|
+
"default": "left"
|
|
310
|
+
},
|
|
311
|
+
"clicks": {
|
|
312
|
+
"description": "Number of clicks: 1 or 2.",
|
|
313
|
+
"type": "integer",
|
|
314
|
+
"default": 1
|
|
315
|
+
},
|
|
316
|
+
"activate": {
|
|
317
|
+
"description": "Restore and focus the target window before input.",
|
|
318
|
+
"type": "boolean",
|
|
319
|
+
"default": true
|
|
320
|
+
}
|
|
321
|
+
},
|
|
322
|
+
"required": [
|
|
323
|
+
"windowHandle",
|
|
324
|
+
"x",
|
|
325
|
+
"y"
|
|
326
|
+
]
|
|
327
|
+
}
|
|
328
|
+
},
|
|
329
|
+
{
|
|
330
|
+
"name": "computer_click_element",
|
|
331
|
+
"description": "Finds one UI Automation element in a selected application and clicks its center. Prefer automationId when present, otherwise use an exact name, className or controlType from the latest computer_observe result. If multiple elements match, set occurrence (zero-based) or the tool returns the candidates without clicking.",
|
|
332
|
+
"inputSchema": {
|
|
333
|
+
"type": "object",
|
|
334
|
+
"properties": {
|
|
335
|
+
"windowHandle": {
|
|
336
|
+
"description": "Exact HWND from the latest observation (0 = current foreground window).",
|
|
337
|
+
"type": "integer"
|
|
338
|
+
},
|
|
339
|
+
"automationId": {
|
|
340
|
+
"description": "Exact UIA AutomationId, when available.",
|
|
341
|
+
"type": [
|
|
342
|
+
"string",
|
|
343
|
+
"null"
|
|
344
|
+
],
|
|
345
|
+
"default": null
|
|
346
|
+
},
|
|
347
|
+
"name": {
|
|
348
|
+
"description": "Exact UIA Name, case-insensitive.",
|
|
349
|
+
"type": [
|
|
350
|
+
"string",
|
|
351
|
+
"null"
|
|
352
|
+
],
|
|
353
|
+
"default": null
|
|
354
|
+
},
|
|
355
|
+
"className": {
|
|
356
|
+
"description": "Exact UIA className, case-insensitive.",
|
|
357
|
+
"type": [
|
|
358
|
+
"string",
|
|
359
|
+
"null"
|
|
360
|
+
],
|
|
361
|
+
"default": null
|
|
362
|
+
},
|
|
363
|
+
"controlType": {
|
|
364
|
+
"description": "Exact UIA controlType, case-insensitive.",
|
|
365
|
+
"type": [
|
|
366
|
+
"string",
|
|
367
|
+
"null"
|
|
368
|
+
],
|
|
369
|
+
"default": null
|
|
370
|
+
},
|
|
371
|
+
"occurrence": {
|
|
372
|
+
"description": "Zero-based match to click when more than one element matches.",
|
|
373
|
+
"type": "integer",
|
|
374
|
+
"default": -1
|
|
375
|
+
},
|
|
376
|
+
"activate": {
|
|
377
|
+
"description": "Restore and focus the target window before clicking.",
|
|
378
|
+
"type": "boolean",
|
|
379
|
+
"default": true
|
|
380
|
+
}
|
|
381
|
+
},
|
|
382
|
+
"required": [
|
|
383
|
+
"windowHandle"
|
|
384
|
+
]
|
|
385
|
+
},
|
|
386
|
+
"execution": {
|
|
387
|
+
"taskSupport": "optional"
|
|
388
|
+
}
|
|
389
|
+
},
|
|
390
|
+
{
|
|
391
|
+
"name": "computer_drag",
|
|
392
|
+
"description": "Drags inside a selected application with interpolated native mouse movement. Coordinates are relative to the latest observed window image. Use this for canvas operations in Blender, Photoshop and similar software, then capture a fresh observation to verify the result.",
|
|
393
|
+
"inputSchema": {
|
|
394
|
+
"type": "object",
|
|
395
|
+
"properties": {
|
|
396
|
+
"windowHandle": {
|
|
397
|
+
"description": "Exact HWND from the latest observation (0 = current foreground window).",
|
|
398
|
+
"type": "integer"
|
|
399
|
+
},
|
|
400
|
+
"fromX": {
|
|
401
|
+
"description": "Window-relative start X.",
|
|
402
|
+
"type": "integer"
|
|
403
|
+
},
|
|
404
|
+
"fromY": {
|
|
405
|
+
"description": "Window-relative start Y.",
|
|
406
|
+
"type": "integer"
|
|
407
|
+
},
|
|
408
|
+
"toX": {
|
|
409
|
+
"description": "Window-relative end X.",
|
|
410
|
+
"type": "integer"
|
|
411
|
+
},
|
|
412
|
+
"toY": {
|
|
413
|
+
"description": "Window-relative end Y.",
|
|
414
|
+
"type": "integer"
|
|
415
|
+
},
|
|
416
|
+
"button": {
|
|
417
|
+
"description": "Mouse button: left | right | middle.",
|
|
418
|
+
"type": "string",
|
|
419
|
+
"default": "left"
|
|
420
|
+
},
|
|
421
|
+
"steps": {
|
|
422
|
+
"description": "Intermediate movement steps (8..200).",
|
|
423
|
+
"type": "integer",
|
|
424
|
+
"default": 20
|
|
425
|
+
},
|
|
426
|
+
"durationMs": {
|
|
427
|
+
"description": "Total drag duration in milliseconds (50..5000).",
|
|
428
|
+
"type": "integer",
|
|
429
|
+
"default": 250
|
|
430
|
+
},
|
|
431
|
+
"activate": {
|
|
432
|
+
"description": "Restore and focus the target window before input.",
|
|
433
|
+
"type": "boolean",
|
|
434
|
+
"default": true
|
|
435
|
+
}
|
|
436
|
+
},
|
|
437
|
+
"required": [
|
|
438
|
+
"windowHandle",
|
|
439
|
+
"fromX",
|
|
440
|
+
"fromY",
|
|
441
|
+
"toX",
|
|
442
|
+
"toY"
|
|
443
|
+
]
|
|
444
|
+
}
|
|
445
|
+
},
|
|
446
|
+
{
|
|
447
|
+
"name": "computer_key",
|
|
448
|
+
"description": "Sends a keyboard key or shortcut to a selected application using SendInput. Examples: ctrl+c, ctrl+shift+s, alt+f4, enter, tab, escape, f5. Windows-key shortcuts are intentionally rejected by this computer-use surface. Re-observe after actions that change UI.",
|
|
449
|
+
"inputSchema": {
|
|
450
|
+
"type": "object",
|
|
451
|
+
"properties": {
|
|
452
|
+
"windowHandle": {
|
|
453
|
+
"description": "Exact HWND from the latest observation (0 = current foreground window).",
|
|
454
|
+
"type": "integer"
|
|
455
|
+
},
|
|
456
|
+
"shortcut": {
|
|
457
|
+
"description": "Shortcut string such as ctrl+s, alt+f4, enter or f5.",
|
|
458
|
+
"type": "string"
|
|
459
|
+
},
|
|
460
|
+
"activate": {
|
|
461
|
+
"description": "Restore and focus the target window before input.",
|
|
462
|
+
"type": "boolean",
|
|
463
|
+
"default": true
|
|
464
|
+
}
|
|
465
|
+
},
|
|
466
|
+
"required": [
|
|
467
|
+
"windowHandle",
|
|
468
|
+
"shortcut"
|
|
469
|
+
]
|
|
470
|
+
}
|
|
471
|
+
},
|
|
472
|
+
{
|
|
473
|
+
"name": "computer_observe",
|
|
474
|
+
"description": "Observes a Windows application for computer use. Returns structured window metadata and a native UI Automation tree as text, plus a PNG image content block when capture succeeds. windowHandle=0 selects the foreground window; otherwise use an exact HWND returned by window_enum_all. Coordinates in later computer_* actions are relative to this window image. Use this before every state-dependent click, type or drag.",
|
|
475
|
+
"inputSchema": {
|
|
476
|
+
"type": "object",
|
|
477
|
+
"properties": {
|
|
478
|
+
"windowHandle": {
|
|
479
|
+
"description": "Exact HWND to inspect (0 = foreground window).",
|
|
480
|
+
"type": "integer",
|
|
481
|
+
"default": 0
|
|
482
|
+
},
|
|
483
|
+
"maxElements": {
|
|
484
|
+
"description": "Maximum UI Automation elements (1..1000, default 160).",
|
|
485
|
+
"type": "integer",
|
|
486
|
+
"default": 160
|
|
487
|
+
},
|
|
488
|
+
"includeUiTree": {
|
|
489
|
+
"description": "Include the UI Automation tree in the text block.",
|
|
490
|
+
"type": "boolean",
|
|
491
|
+
"default": true
|
|
492
|
+
},
|
|
493
|
+
"outputPath": {
|
|
494
|
+
"description": "Optional PNG export path. When set, the captured observation is also written there.",
|
|
495
|
+
"type": [
|
|
496
|
+
"string",
|
|
497
|
+
"null"
|
|
498
|
+
],
|
|
499
|
+
"default": null
|
|
500
|
+
}
|
|
501
|
+
}
|
|
502
|
+
},
|
|
503
|
+
"execution": {
|
|
504
|
+
"taskSupport": "optional"
|
|
505
|
+
}
|
|
506
|
+
},
|
|
507
|
+
{
|
|
508
|
+
"name": "computer_ocr",
|
|
509
|
+
"description": "Runs local Windows OCR over the selected application screenshot and returns exact text with line/word bounding boxes. region coordinates are relative to the observed window image. format=json returns structured OCR; format=markdown returns the extracted text as Markdown. Set speak=true to synthesize and play the result with the installed Windows voice.",
|
|
510
|
+
"inputSchema": {
|
|
511
|
+
"type": "object",
|
|
512
|
+
"properties": {
|
|
513
|
+
"windowHandle": {
|
|
514
|
+
"description": "Exact HWND from the latest observation (0 = foreground window).",
|
|
515
|
+
"type": "integer",
|
|
516
|
+
"default": 0
|
|
517
|
+
},
|
|
518
|
+
"format": {
|
|
519
|
+
"description": "json or markdown.",
|
|
520
|
+
"type": "string",
|
|
521
|
+
"default": "json"
|
|
522
|
+
},
|
|
523
|
+
"language": {
|
|
524
|
+
"description": "Windows OCR language tag, for example fr-FR or en-US. Null uses the user profile languages.",
|
|
525
|
+
"type": [
|
|
526
|
+
"string",
|
|
527
|
+
"null"
|
|
528
|
+
],
|
|
529
|
+
"default": null
|
|
530
|
+
},
|
|
531
|
+
"regionX": {
|
|
532
|
+
"description": "Region X relative to the captured window image (0 for full image).",
|
|
533
|
+
"type": "integer",
|
|
534
|
+
"default": 0
|
|
535
|
+
},
|
|
536
|
+
"regionY": {
|
|
537
|
+
"description": "Region Y relative to the captured window image (0 for full image).",
|
|
538
|
+
"type": "integer",
|
|
539
|
+
"default": 0
|
|
540
|
+
},
|
|
541
|
+
"regionWidth": {
|
|
542
|
+
"description": "Region width; 0 means the remaining image width.",
|
|
543
|
+
"type": "integer",
|
|
544
|
+
"default": 0
|
|
545
|
+
},
|
|
546
|
+
"regionHeight": {
|
|
547
|
+
"description": "Region height; 0 means the remaining image height.",
|
|
548
|
+
"type": "integer",
|
|
549
|
+
"default": 0
|
|
550
|
+
},
|
|
551
|
+
"speak": {
|
|
552
|
+
"description": "Play the recognized text through the installed local Windows voice.",
|
|
553
|
+
"type": "boolean",
|
|
554
|
+
"default": false
|
|
555
|
+
},
|
|
556
|
+
"outputPath": {
|
|
557
|
+
"description": "Optional JSON/Markdown export path.",
|
|
558
|
+
"type": [
|
|
559
|
+
"string",
|
|
560
|
+
"null"
|
|
561
|
+
],
|
|
562
|
+
"default": null
|
|
563
|
+
},
|
|
564
|
+
"audioPath": {
|
|
565
|
+
"description": "Optional WAV export path when speak=true; otherwise a temporary WAV is created.",
|
|
566
|
+
"type": [
|
|
567
|
+
"string",
|
|
568
|
+
"null"
|
|
569
|
+
],
|
|
570
|
+
"default": null
|
|
571
|
+
}
|
|
572
|
+
}
|
|
573
|
+
},
|
|
574
|
+
"execution": {
|
|
575
|
+
"taskSupport": "optional"
|
|
576
|
+
}
|
|
577
|
+
},
|
|
578
|
+
{
|
|
579
|
+
"name": "computer_record_clip",
|
|
580
|
+
"description": "Records a bounded, exportable clip of a window or the primary desktop as an uncompressed AVI. The clip is written locally without ffmpeg or a cloud service. durationMs is 1..30000 and fps is 1..30.",
|
|
581
|
+
"inputSchema": {
|
|
582
|
+
"type": "object",
|
|
583
|
+
"properties": {
|
|
584
|
+
"windowHandle": {
|
|
585
|
+
"description": "Exact HWND from the latest observation; 0 records the primary desktop.",
|
|
586
|
+
"type": "integer",
|
|
587
|
+
"default": 0
|
|
588
|
+
},
|
|
589
|
+
"outputPath": {
|
|
590
|
+
"description": "Output AVI path; null creates a timestamped file in the user temp directory.",
|
|
591
|
+
"type": [
|
|
592
|
+
"string",
|
|
593
|
+
"null"
|
|
594
|
+
],
|
|
595
|
+
"default": null
|
|
596
|
+
},
|
|
597
|
+
"durationMs": {
|
|
598
|
+
"description": "Clip duration in milliseconds (100..30000).",
|
|
599
|
+
"type": "integer",
|
|
600
|
+
"default": 5000
|
|
601
|
+
},
|
|
602
|
+
"fps": {
|
|
603
|
+
"description": "Frames per second (1..30).",
|
|
604
|
+
"type": "integer",
|
|
605
|
+
"default": 10
|
|
606
|
+
}
|
|
607
|
+
}
|
|
608
|
+
},
|
|
609
|
+
"execution": {
|
|
610
|
+
"taskSupport": "optional"
|
|
611
|
+
}
|
|
612
|
+
},
|
|
613
|
+
{
|
|
614
|
+
"name": "computer_scroll",
|
|
615
|
+
"description": "Scrolls a selected application using native wheel input. x/y are relative to the observed window image and identify the pane under the cursor. Re-observe after scrolling because lazy-loaded content and UI layouts can change.",
|
|
616
|
+
"inputSchema": {
|
|
617
|
+
"type": "object",
|
|
618
|
+
"properties": {
|
|
619
|
+
"windowHandle": {
|
|
620
|
+
"description": "Exact HWND from the latest observation (0 = current foreground window).",
|
|
621
|
+
"type": "integer"
|
|
622
|
+
},
|
|
623
|
+
"x": {
|
|
624
|
+
"description": "Window-relative X coordinate.",
|
|
625
|
+
"type": "integer"
|
|
626
|
+
},
|
|
627
|
+
"y": {
|
|
628
|
+
"description": "Window-relative Y coordinate.",
|
|
629
|
+
"type": "integer"
|
|
630
|
+
},
|
|
631
|
+
"axis": {
|
|
632
|
+
"description": "vertical or horizontal.",
|
|
633
|
+
"type": "string",
|
|
634
|
+
"default": "vertical"
|
|
635
|
+
},
|
|
636
|
+
"direction": {
|
|
637
|
+
"description": "up, down, left or right.",
|
|
638
|
+
"type": "string",
|
|
639
|
+
"default": "down"
|
|
640
|
+
},
|
|
641
|
+
"wheelTimes": {
|
|
642
|
+
"description": "Number of wheel notches (1..40).",
|
|
643
|
+
"type": "integer",
|
|
644
|
+
"default": 1
|
|
645
|
+
},
|
|
646
|
+
"activate": {
|
|
647
|
+
"description": "Restore and focus the target window before input.",
|
|
648
|
+
"type": "boolean",
|
|
649
|
+
"default": true
|
|
650
|
+
}
|
|
651
|
+
},
|
|
652
|
+
"required": [
|
|
653
|
+
"windowHandle",
|
|
654
|
+
"x",
|
|
655
|
+
"y"
|
|
656
|
+
]
|
|
657
|
+
}
|
|
658
|
+
},
|
|
659
|
+
{
|
|
660
|
+
"name": "computer_speak",
|
|
661
|
+
"description": "Speaks text using the installed local Windows speech synthesizer and plays it immediately. No cloud API or key is used. Returns the generated WAV path for export or later playback.",
|
|
662
|
+
"inputSchema": {
|
|
663
|
+
"type": "object",
|
|
664
|
+
"properties": {
|
|
665
|
+
"text": {
|
|
666
|
+
"description": "Text to speak, maximum 32768 characters.",
|
|
667
|
+
"type": "string"
|
|
668
|
+
},
|
|
669
|
+
"audioPath": {
|
|
670
|
+
"description": "Optional WAV export path; otherwise a temporary WAV is created.",
|
|
671
|
+
"type": [
|
|
672
|
+
"string",
|
|
673
|
+
"null"
|
|
674
|
+
],
|
|
675
|
+
"default": null
|
|
676
|
+
}
|
|
677
|
+
},
|
|
678
|
+
"required": [
|
|
679
|
+
"text"
|
|
680
|
+
]
|
|
681
|
+
},
|
|
682
|
+
"execution": {
|
|
683
|
+
"taskSupport": "optional"
|
|
684
|
+
}
|
|
685
|
+
},
|
|
686
|
+
{
|
|
687
|
+
"name": "computer_type",
|
|
688
|
+
"description": "Types literal Unicode text into a selected application. Focuses the point first; set clear=true to replace the current field. x/y are relative to the observed window image. Maximum payload is 4096 characters per call. Re-observe before submitting or pressing Enter.",
|
|
689
|
+
"inputSchema": {
|
|
690
|
+
"type": "object",
|
|
691
|
+
"properties": {
|
|
692
|
+
"windowHandle": {
|
|
693
|
+
"description": "Exact HWND from the latest observation (0 = current foreground window).",
|
|
694
|
+
"type": "integer"
|
|
695
|
+
},
|
|
696
|
+
"text": {
|
|
697
|
+
"description": "Text to type.",
|
|
698
|
+
"type": "string"
|
|
699
|
+
},
|
|
700
|
+
"x": {
|
|
701
|
+
"description": "Window-relative X coordinate in pixels.",
|
|
702
|
+
"type": "integer"
|
|
703
|
+
},
|
|
704
|
+
"y": {
|
|
705
|
+
"description": "Window-relative Y coordinate in pixels.",
|
|
706
|
+
"type": "integer"
|
|
707
|
+
},
|
|
708
|
+
"clear": {
|
|
709
|
+
"description": "Select all and delete existing field contents first.",
|
|
710
|
+
"type": "boolean",
|
|
711
|
+
"default": false
|
|
712
|
+
},
|
|
713
|
+
"pressEnter": {
|
|
714
|
+
"description": "Press Enter after typing.",
|
|
715
|
+
"type": "boolean",
|
|
716
|
+
"default": false
|
|
717
|
+
},
|
|
718
|
+
"activate": {
|
|
719
|
+
"description": "Restore and focus the target window before input.",
|
|
720
|
+
"type": "boolean",
|
|
721
|
+
"default": true
|
|
722
|
+
}
|
|
723
|
+
},
|
|
724
|
+
"required": [
|
|
725
|
+
"windowHandle",
|
|
726
|
+
"text",
|
|
727
|
+
"x",
|
|
728
|
+
"y"
|
|
729
|
+
]
|
|
730
|
+
}
|
|
731
|
+
},
|
|
732
|
+
{
|
|
733
|
+
"name": "coord_assign_task",
|
|
734
|
+
"description": "Publish a new .coord/CURRENT_TASK.md. The full body is the markdown content. Returns JSON {ok,bytes,path}.",
|
|
735
|
+
"inputSchema": {
|
|
736
|
+
"type": "object",
|
|
737
|
+
"properties": {
|
|
738
|
+
"markdown": {
|
|
739
|
+
"description": "Markdown content for the new CURRENT_TASK.md (overwrites the existing file).",
|
|
740
|
+
"type": "string"
|
|
741
|
+
}
|
|
742
|
+
},
|
|
743
|
+
"required": [
|
|
744
|
+
"markdown"
|
|
745
|
+
]
|
|
746
|
+
}
|
|
747
|
+
},
|
|
748
|
+
{
|
|
749
|
+
"name": "coord_query_stop",
|
|
750
|
+
"description": "Check the A2A kill switch — presence of .coord/STOP. Returns JSON {ok,stop:true|false}.",
|
|
751
|
+
"inputSchema": {
|
|
752
|
+
"type": "object",
|
|
753
|
+
"properties": {}
|
|
754
|
+
}
|
|
755
|
+
},
|
|
756
|
+
{
|
|
757
|
+
"name": "coord_read_status",
|
|
758
|
+
"description": "Read the latest status block for an agent from .coord/STATUS_<AGENT>.txt. Returns JSON {ok,agent,status} (status='' when the file is absent).",
|
|
759
|
+
"inputSchema": {
|
|
760
|
+
"type": "object",
|
|
761
|
+
"properties": {
|
|
762
|
+
"agent": {
|
|
763
|
+
"description": "Agent name to read. Case-insensitive.",
|
|
764
|
+
"type": "string"
|
|
765
|
+
}
|
|
766
|
+
},
|
|
767
|
+
"required": [
|
|
768
|
+
"agent"
|
|
769
|
+
]
|
|
770
|
+
}
|
|
771
|
+
},
|
|
772
|
+
{
|
|
773
|
+
"name": "coord_read_task",
|
|
774
|
+
"description": "Read the current .coord/CURRENT_TASK.md. Returns JSON {ok,content} (content='' when absent).",
|
|
775
|
+
"inputSchema": {
|
|
776
|
+
"type": "object",
|
|
777
|
+
"properties": {}
|
|
778
|
+
}
|
|
779
|
+
},
|
|
780
|
+
{
|
|
781
|
+
"name": "coord_report_status",
|
|
782
|
+
"description": "Write the status block for an agent. The block goes to .coord/STATUS_<AGENT>.txt where <AGENT> is the upper-case form of `agent`. Returns JSON {ok,agent,bytes}.",
|
|
783
|
+
"inputSchema": {
|
|
784
|
+
"type": "object",
|
|
785
|
+
"properties": {
|
|
786
|
+
"agent": {
|
|
787
|
+
"description": "Agent name (e.g. 'claude', 'gemini', 'aphrody-claude'). Case-insensitive on disk.",
|
|
788
|
+
"type": "string"
|
|
789
|
+
},
|
|
790
|
+
"status": {
|
|
791
|
+
"description": "Full multi-line status block. Trailing newline is normalised.",
|
|
792
|
+
"type": "string"
|
|
793
|
+
}
|
|
794
|
+
},
|
|
795
|
+
"required": [
|
|
796
|
+
"agent",
|
|
797
|
+
"status"
|
|
798
|
+
]
|
|
799
|
+
}
|
|
800
|
+
},
|
|
801
|
+
{
|
|
802
|
+
"name": "copy_path",
|
|
803
|
+
"description": "Copies a file or directory to a destination.",
|
|
804
|
+
"inputSchema": {
|
|
805
|
+
"type": "object",
|
|
806
|
+
"properties": {
|
|
807
|
+
"path": {
|
|
808
|
+
"description": "Source path (absolute or relative to Desktop).",
|
|
809
|
+
"type": "string"
|
|
810
|
+
},
|
|
811
|
+
"destination": {
|
|
812
|
+
"description": "Destination path (absolute or relative to Desktop).",
|
|
813
|
+
"type": "string"
|
|
814
|
+
},
|
|
815
|
+
"overwrite": {
|
|
816
|
+
"description": "Overwrite existing destination.",
|
|
817
|
+
"type": "boolean",
|
|
818
|
+
"default": false
|
|
819
|
+
}
|
|
820
|
+
},
|
|
821
|
+
"required": [
|
|
822
|
+
"path",
|
|
823
|
+
"destination"
|
|
824
|
+
]
|
|
825
|
+
}
|
|
826
|
+
},
|
|
827
|
+
{
|
|
828
|
+
"name": "delete_path",
|
|
829
|
+
"description": "Deletes a file or directory. Set recursive=true for non-empty directories.",
|
|
830
|
+
"inputSchema": {
|
|
831
|
+
"type": "object",
|
|
832
|
+
"properties": {
|
|
833
|
+
"path": {
|
|
834
|
+
"description": "Absolute or relative path. Relative paths are resolved against the user's Desktop folder.",
|
|
835
|
+
"type": "string"
|
|
836
|
+
},
|
|
837
|
+
"recursive": {
|
|
838
|
+
"description": "Recurse into directory contents.",
|
|
839
|
+
"type": "boolean",
|
|
840
|
+
"default": false
|
|
841
|
+
}
|
|
842
|
+
},
|
|
843
|
+
"required": [
|
|
844
|
+
"path"
|
|
845
|
+
]
|
|
846
|
+
}
|
|
847
|
+
},
|
|
848
|
+
{
|
|
849
|
+
"name": "delete_registry_entry",
|
|
850
|
+
"description": "Deletes a registry value (when name is set) or the entire key (when name is null/empty).",
|
|
851
|
+
"inputSchema": {
|
|
852
|
+
"type": "object",
|
|
853
|
+
"properties": {
|
|
854
|
+
"path": {
|
|
855
|
+
"description": "Key path including hive prefix.",
|
|
856
|
+
"type": "string"
|
|
857
|
+
},
|
|
858
|
+
"name": {
|
|
859
|
+
"description": "Value name; null/empty deletes the entire key.",
|
|
860
|
+
"type": [
|
|
861
|
+
"string",
|
|
862
|
+
"null"
|
|
863
|
+
],
|
|
864
|
+
"default": null
|
|
865
|
+
}
|
|
866
|
+
},
|
|
867
|
+
"required": [
|
|
868
|
+
"path"
|
|
869
|
+
]
|
|
870
|
+
}
|
|
871
|
+
},
|
|
872
|
+
{
|
|
873
|
+
"name": "disable_scheduled_task",
|
|
874
|
+
"description": "Disables a scheduled task via schtasks /Change /Disable.",
|
|
875
|
+
"inputSchema": {
|
|
876
|
+
"type": "object",
|
|
877
|
+
"properties": {
|
|
878
|
+
"path": {
|
|
879
|
+
"description": "Absolute task path.",
|
|
880
|
+
"type": "string"
|
|
881
|
+
}
|
|
882
|
+
},
|
|
883
|
+
"required": [
|
|
884
|
+
"path"
|
|
885
|
+
]
|
|
886
|
+
},
|
|
887
|
+
"execution": {
|
|
888
|
+
"taskSupport": "optional"
|
|
889
|
+
}
|
|
890
|
+
},
|
|
891
|
+
{
|
|
892
|
+
"name": "enable_scheduled_task",
|
|
893
|
+
"description": "Enables a scheduled task via schtasks /Change /Enable.",
|
|
894
|
+
"inputSchema": {
|
|
895
|
+
"type": "object",
|
|
896
|
+
"properties": {
|
|
897
|
+
"path": {
|
|
898
|
+
"description": "Absolute task path, e.g. '\\Microsoft\\Windows\\Defender\\Windows Defender Scheduled Scan'.",
|
|
899
|
+
"type": "string"
|
|
900
|
+
}
|
|
901
|
+
},
|
|
902
|
+
"required": [
|
|
903
|
+
"path"
|
|
904
|
+
]
|
|
905
|
+
},
|
|
906
|
+
"execution": {
|
|
907
|
+
"taskSupport": "optional"
|
|
908
|
+
}
|
|
909
|
+
},
|
|
910
|
+
{
|
|
911
|
+
"name": "gamepad_create_xbox360",
|
|
912
|
+
"description": "Allocates a virtual Xbox 360 controller via ViGEmBus and connects it to the system. The virtual controller is indexed by slotIndex (0–7). Returns {\"success\":true,\"slot\":N,\"vendorId\":\"045e\",\"productId\":\"028e\"} on success. Requires ViGEmBus: https://github.com/nefarius/ViGEmBus/releases",
|
|
913
|
+
"inputSchema": {
|
|
914
|
+
"type": "object",
|
|
915
|
+
"properties": {
|
|
916
|
+
"slotIndex": {
|
|
917
|
+
"description": "Slot index (0–7) used to reference this controller in subsequent calls.",
|
|
918
|
+
"type": "integer",
|
|
919
|
+
"default": 0
|
|
920
|
+
}
|
|
921
|
+
}
|
|
922
|
+
}
|
|
923
|
+
},
|
|
924
|
+
{
|
|
925
|
+
"name": "gamepad_destroy",
|
|
926
|
+
"description": "Removes and frees the virtual Xbox 360 controller at the given slot. Safe to call if the slot was never created (no-op).",
|
|
927
|
+
"inputSchema": {
|
|
928
|
+
"type": "object",
|
|
929
|
+
"properties": {
|
|
930
|
+
"slot": {
|
|
931
|
+
"description": "Slot index to destroy.",
|
|
932
|
+
"type": "integer"
|
|
933
|
+
}
|
|
934
|
+
},
|
|
935
|
+
"required": [
|
|
936
|
+
"slot"
|
|
937
|
+
]
|
|
938
|
+
}
|
|
939
|
+
},
|
|
940
|
+
{
|
|
941
|
+
"name": "gamepad_destroy_all",
|
|
942
|
+
"description": "Removes and frees ALL active virtual Xbox 360 controllers created in this process. Use as cleanup before shutdown or when resetting gamepad state.",
|
|
943
|
+
"inputSchema": {
|
|
944
|
+
"type": "object",
|
|
945
|
+
"properties": {}
|
|
946
|
+
}
|
|
947
|
+
},
|
|
948
|
+
{
|
|
949
|
+
"name": "gamepad_environment",
|
|
950
|
+
"description": "Diagnoses the ViGEmBus virtual gamepad environment. Reports whether ViGEmBus registry key exists, whether the service is running, and whether ViGEmClient.dll can be located on disk. Install ViGEmBus from https://github.com/nefarius/ViGEmBus/releases if absent.",
|
|
951
|
+
"inputSchema": {
|
|
952
|
+
"type": "object",
|
|
953
|
+
"properties": {}
|
|
954
|
+
}
|
|
955
|
+
},
|
|
956
|
+
{
|
|
957
|
+
"name": "gamepad_press_button",
|
|
958
|
+
"description": "Presses one or more buttons on a virtual Xbox 360 controller then releases them. buttonMask uses the same bitmask as GamepadSendXbox360State. holdMs: how long to hold the buttons down (clamped to [1, 5000] ms).",
|
|
959
|
+
"inputSchema": {
|
|
960
|
+
"type": "object",
|
|
961
|
+
"properties": {
|
|
962
|
+
"slot": {
|
|
963
|
+
"description": "Slot index from GamepadCreateXbox360.",
|
|
964
|
+
"type": "integer"
|
|
965
|
+
},
|
|
966
|
+
"buttonMask": {
|
|
967
|
+
"description": "Button bitmask to press (e.g. 4096 for A).",
|
|
968
|
+
"type": "integer"
|
|
969
|
+
},
|
|
970
|
+
"holdMs": {
|
|
971
|
+
"description": "Hold duration in milliseconds [1, 5000].",
|
|
972
|
+
"type": "integer",
|
|
973
|
+
"default": 100
|
|
974
|
+
}
|
|
975
|
+
},
|
|
976
|
+
"required": [
|
|
977
|
+
"slot",
|
|
978
|
+
"buttonMask"
|
|
979
|
+
]
|
|
980
|
+
}
|
|
981
|
+
},
|
|
982
|
+
{
|
|
983
|
+
"name": "gamepad_send_xbox360_state",
|
|
984
|
+
"description": "Sends a full Xbox 360 controller state update. buttons bitmask: DPAD_UP=1, DPAD_DOWN=2, DPAD_LEFT=4, DPAD_RIGHT=8, START=16, BACK=32, L3=64, R3=128, LB=256, RB=512, GUIDE=1024, A=4096, B=8192, X=16384, Y=32768. Axes lx/ly/rx/ry: [-32768, 32767]. Triggers lt/rt: [0, 255].",
|
|
985
|
+
"inputSchema": {
|
|
986
|
+
"type": "object",
|
|
987
|
+
"properties": {
|
|
988
|
+
"slot": {
|
|
989
|
+
"description": "Slot index from GamepadCreateXbox360.",
|
|
990
|
+
"type": "integer"
|
|
991
|
+
},
|
|
992
|
+
"buttons": {
|
|
993
|
+
"description": "Button bitmask (see description for values).",
|
|
994
|
+
"type": "integer"
|
|
995
|
+
},
|
|
996
|
+
"lx": {
|
|
997
|
+
"description": "Left stick X axis [-32768, 32767].",
|
|
998
|
+
"type": "integer",
|
|
999
|
+
"default": 0
|
|
1000
|
+
},
|
|
1001
|
+
"ly": {
|
|
1002
|
+
"description": "Left stick Y axis [-32768, 32767].",
|
|
1003
|
+
"type": "integer",
|
|
1004
|
+
"default": 0
|
|
1005
|
+
},
|
|
1006
|
+
"rx": {
|
|
1007
|
+
"description": "Right stick X axis [-32768, 32767].",
|
|
1008
|
+
"type": "integer",
|
|
1009
|
+
"default": 0
|
|
1010
|
+
},
|
|
1011
|
+
"ry": {
|
|
1012
|
+
"description": "Right stick Y axis [-32768, 32767].",
|
|
1013
|
+
"type": "integer",
|
|
1014
|
+
"default": 0
|
|
1015
|
+
},
|
|
1016
|
+
"lt": {
|
|
1017
|
+
"description": "Left trigger [0, 255].",
|
|
1018
|
+
"type": "integer",
|
|
1019
|
+
"default": 0
|
|
1020
|
+
},
|
|
1021
|
+
"rt": {
|
|
1022
|
+
"description": "Right trigger [0, 255].",
|
|
1023
|
+
"type": "integer",
|
|
1024
|
+
"default": 0
|
|
1025
|
+
}
|
|
1026
|
+
},
|
|
1027
|
+
"required": [
|
|
1028
|
+
"slot",
|
|
1029
|
+
"buttons"
|
|
1030
|
+
]
|
|
1031
|
+
}
|
|
1032
|
+
},
|
|
1033
|
+
{
|
|
1034
|
+
"name": "get_active_power_plan",
|
|
1035
|
+
"description": "Returns the GUID and friendly name of the active Windows power plan.",
|
|
1036
|
+
"inputSchema": {
|
|
1037
|
+
"type": "object",
|
|
1038
|
+
"properties": {}
|
|
1039
|
+
}
|
|
1040
|
+
},
|
|
1041
|
+
{
|
|
1042
|
+
"name": "get_clipboard_text",
|
|
1043
|
+
"description": "Reads UTF-16 text content from the Windows clipboard.",
|
|
1044
|
+
"inputSchema": {
|
|
1045
|
+
"type": "object",
|
|
1046
|
+
"properties": {}
|
|
1047
|
+
}
|
|
1048
|
+
},
|
|
1049
|
+
{
|
|
1050
|
+
"name": "get_cpu_info",
|
|
1051
|
+
"description": "Returns CPU topology as JSON: logical processors, physical cores, NUMA nodes, cache sizes (L1/L2/L3 aggregate), architecture.",
|
|
1052
|
+
"inputSchema": {
|
|
1053
|
+
"type": "object",
|
|
1054
|
+
"properties": {}
|
|
1055
|
+
}
|
|
1056
|
+
},
|
|
1057
|
+
{
|
|
1058
|
+
"name": "get_cpu_usage",
|
|
1059
|
+
"description": "Samples global CPU usage over a short interval (default 250 ms, clamp 50-2000) via GetSystemTimes. Returns usage/idle percent and raw idle/kernel/user deltas in seconds. Kernel time as reported by Windows INCLUDES idle time; this tool subtracts it before computing the percentage.",
|
|
1060
|
+
"inputSchema": {
|
|
1061
|
+
"type": "object",
|
|
1062
|
+
"properties": {
|
|
1063
|
+
"intervalMs": {
|
|
1064
|
+
"description": "Sample window in milliseconds. Clamped to [50, 2000]. Default 250.",
|
|
1065
|
+
"type": "integer",
|
|
1066
|
+
"default": 250
|
|
1067
|
+
}
|
|
1068
|
+
}
|
|
1069
|
+
}
|
|
1070
|
+
},
|
|
1071
|
+
{
|
|
1072
|
+
"name": "get_defender_status",
|
|
1073
|
+
"description": "Returns Windows Defender state as JSON: AntivirusEnabled, RealTimeProtectionEnabled, BehaviorMonitorEnabled, TamperProtected, AntivirusSignatureVersion, LastQuickScanStartUtc, LastFullScanStartUtc, ThreatCount.",
|
|
1074
|
+
"inputSchema": {
|
|
1075
|
+
"type": "object",
|
|
1076
|
+
"properties": {}
|
|
1077
|
+
},
|
|
1078
|
+
"execution": {
|
|
1079
|
+
"taskSupport": "optional"
|
|
1080
|
+
}
|
|
1081
|
+
},
|
|
1082
|
+
{
|
|
1083
|
+
"name": "get_disk_info",
|
|
1084
|
+
"description": "Returns logical-drive info (root, type, total/free/available bytes) as JSON via GetLogicalDriveStrings + GetDiskFreeSpaceEx.",
|
|
1085
|
+
"inputSchema": {
|
|
1086
|
+
"type": "object",
|
|
1087
|
+
"properties": {}
|
|
1088
|
+
}
|
|
1089
|
+
},
|
|
1090
|
+
{
|
|
1091
|
+
"name": "get_file_info",
|
|
1092
|
+
"description": "Returns metadata for a file or directory as JSON: size, dates, type, hidden flag.",
|
|
1093
|
+
"inputSchema": {
|
|
1094
|
+
"type": "object",
|
|
1095
|
+
"properties": {
|
|
1096
|
+
"path": {
|
|
1097
|
+
"description": "Absolute or relative path.",
|
|
1098
|
+
"type": "string"
|
|
1099
|
+
}
|
|
1100
|
+
},
|
|
1101
|
+
"required": [
|
|
1102
|
+
"path"
|
|
1103
|
+
]
|
|
1104
|
+
}
|
|
1105
|
+
},
|
|
1106
|
+
{
|
|
1107
|
+
"name": "get_gpu_preferences",
|
|
1108
|
+
"description": "Reads all per-app GPU preferences from HKCU\\SOFTWARE\\Microsoft\\DirectX\\UserGpuPreferences. Returns each registered exe path with its raw preference string ('GpuPreference=N;').",
|
|
1109
|
+
"inputSchema": {
|
|
1110
|
+
"type": "object",
|
|
1111
|
+
"properties": {}
|
|
1112
|
+
}
|
|
1113
|
+
},
|
|
1114
|
+
{
|
|
1115
|
+
"name": "get_hags_mode",
|
|
1116
|
+
"description": "Reads HKLM\\System\\CurrentControlSet\\Control\\GraphicsDrivers\\HwSchMode. 0 = WDDM CPU scheduling, 1 = OS-managed default, 2 = Hardware-Accelerated GPU Scheduling. Requires WDDM 2.7+ (Win10 20H1+ / Win11). Reboot to take effect.",
|
|
1117
|
+
"inputSchema": {
|
|
1118
|
+
"type": "object",
|
|
1119
|
+
"properties": {}
|
|
1120
|
+
}
|
|
1121
|
+
},
|
|
1122
|
+
{
|
|
1123
|
+
"name": "get_memory_info",
|
|
1124
|
+
"description": "Returns physical / virtual / page-file memory state as JSON via GlobalMemoryStatusEx.",
|
|
1125
|
+
"inputSchema": {
|
|
1126
|
+
"type": "object",
|
|
1127
|
+
"properties": {}
|
|
1128
|
+
}
|
|
1129
|
+
},
|
|
1130
|
+
{
|
|
1131
|
+
"name": "get_network_adapters",
|
|
1132
|
+
"description": "Lists network adapters (Name, Description, Status, MAC, link speed, IPv4 addresses) as JSON.",
|
|
1133
|
+
"inputSchema": {
|
|
1134
|
+
"type": "object",
|
|
1135
|
+
"properties": {}
|
|
1136
|
+
}
|
|
1137
|
+
},
|
|
1138
|
+
{
|
|
1139
|
+
"name": "get_os_info",
|
|
1140
|
+
"description": "Returns OS version info (ProductName, EditionId, DisplayVersion, BuildNumber, UBR, InstallationType, OSArchitecture, MachineName, UserName) as JSON.",
|
|
1141
|
+
"inputSchema": {
|
|
1142
|
+
"type": "object",
|
|
1143
|
+
"properties": {}
|
|
1144
|
+
}
|
|
1145
|
+
},
|
|
1146
|
+
{
|
|
1147
|
+
"name": "get_registry_value",
|
|
1148
|
+
"description": "Reads a registry value. Path uses PowerShell-style hive prefixes (HKCU:\\, HKLM:\\, HKCR:\\, HKU:\\, HKCC:\\).",
|
|
1149
|
+
"inputSchema": {
|
|
1150
|
+
"type": "object",
|
|
1151
|
+
"properties": {
|
|
1152
|
+
"path": {
|
|
1153
|
+
"description": "Key path including hive prefix, e.g. 'HKCU:\\Software\\MyApp'.",
|
|
1154
|
+
"type": "string"
|
|
1155
|
+
},
|
|
1156
|
+
"name": {
|
|
1157
|
+
"description": "Value name. Use '(default)' for the default unnamed value.",
|
|
1158
|
+
"type": "string"
|
|
1159
|
+
}
|
|
1160
|
+
},
|
|
1161
|
+
"required": [
|
|
1162
|
+
"path",
|
|
1163
|
+
"name"
|
|
1164
|
+
]
|
|
1165
|
+
}
|
|
1166
|
+
},
|
|
1167
|
+
{
|
|
1168
|
+
"name": "get_system_profile",
|
|
1169
|
+
"description": "Récupère le profil système complet pour vérifier l'état d'optimisation du poste.",
|
|
1170
|
+
"inputSchema": {
|
|
1171
|
+
"type": "object",
|
|
1172
|
+
"properties": {}
|
|
1173
|
+
},
|
|
1174
|
+
"execution": {
|
|
1175
|
+
"taskSupport": "optional"
|
|
1176
|
+
}
|
|
1177
|
+
},
|
|
1178
|
+
{
|
|
1179
|
+
"name": "golang_scan",
|
|
1180
|
+
"description": "Inspects a target binary for Golang runtime signatures (pclntab) and extracts Go package/symbol indicators. Passive inspection without execution.",
|
|
1181
|
+
"inputSchema": {
|
|
1182
|
+
"type": "object",
|
|
1183
|
+
"properties": {
|
|
1184
|
+
"path": {
|
|
1185
|
+
"description": "Absolute path to the target binary.",
|
|
1186
|
+
"type": "string"
|
|
1187
|
+
},
|
|
1188
|
+
"maxSymbols": {
|
|
1189
|
+
"description": "Max symbols to extract (default 200).",
|
|
1190
|
+
"type": "integer",
|
|
1191
|
+
"default": 200
|
|
1192
|
+
}
|
|
1193
|
+
},
|
|
1194
|
+
"required": [
|
|
1195
|
+
"path"
|
|
1196
|
+
]
|
|
1197
|
+
}
|
|
1198
|
+
},
|
|
1199
|
+
{
|
|
1200
|
+
"name": "keyboard_hold",
|
|
1201
|
+
"description": "Holds an arbitrary virtual key down (no release). Pair with KeyboardRelease to let go. Useful for charging mechanics, sustained movement keys, modifiers held across multiple ops.",
|
|
1202
|
+
"inputSchema": {
|
|
1203
|
+
"type": "object",
|
|
1204
|
+
"properties": {
|
|
1205
|
+
"vk": {
|
|
1206
|
+
"description": "Virtual-key code (e.g. 0x57 = W, 0x10 = Shift).",
|
|
1207
|
+
"type": "integer"
|
|
1208
|
+
}
|
|
1209
|
+
},
|
|
1210
|
+
"required": [
|
|
1211
|
+
"vk"
|
|
1212
|
+
]
|
|
1213
|
+
}
|
|
1214
|
+
},
|
|
1215
|
+
{
|
|
1216
|
+
"name": "keyboard_release",
|
|
1217
|
+
"description": "Releases a virtual key previously held by KeyboardHold.",
|
|
1218
|
+
"inputSchema": {
|
|
1219
|
+
"type": "object",
|
|
1220
|
+
"properties": {
|
|
1221
|
+
"vk": {
|
|
1222
|
+
"description": "Virtual-key code.",
|
|
1223
|
+
"type": "integer"
|
|
1224
|
+
}
|
|
1225
|
+
},
|
|
1226
|
+
"required": [
|
|
1227
|
+
"vk"
|
|
1228
|
+
]
|
|
1229
|
+
}
|
|
1230
|
+
},
|
|
1231
|
+
{
|
|
1232
|
+
"name": "keyboard_scan_code",
|
|
1233
|
+
"description": "Sends a single key by raw hardware SCAN CODE instead of virtual key. Some games (and anti-cheats) ignore Send-Input from virtual keys but accept scan codes because they match real keyboards. action: 'down' | 'up' | 'tap' (down+up).",
|
|
1234
|
+
"inputSchema": {
|
|
1235
|
+
"type": "object",
|
|
1236
|
+
"properties": {
|
|
1237
|
+
"scanCode": {
|
|
1238
|
+
"description": "Scan code (decimal or 0x-prefixed hex, e.g. 0x1E for 'A').",
|
|
1239
|
+
"type": "integer"
|
|
1240
|
+
},
|
|
1241
|
+
"action": {
|
|
1242
|
+
"description": "'down' | 'up' | 'tap'.",
|
|
1243
|
+
"type": "string",
|
|
1244
|
+
"default": "tap"
|
|
1245
|
+
},
|
|
1246
|
+
"extended": {
|
|
1247
|
+
"description": "Mark as extended (E0-prefixed) key (arrows, NumPad, RWIN, etc).",
|
|
1248
|
+
"type": "boolean",
|
|
1249
|
+
"default": false
|
|
1250
|
+
}
|
|
1251
|
+
},
|
|
1252
|
+
"required": [
|
|
1253
|
+
"scanCode"
|
|
1254
|
+
]
|
|
1255
|
+
}
|
|
1256
|
+
},
|
|
1257
|
+
{
|
|
1258
|
+
"name": "kill_process",
|
|
1259
|
+
"description": "Kills a process by PID (preferred) or name. Returns the count of terminated processes. Force=true requests an immediate kill (default true). PPL-protected processes return a labelled error.",
|
|
1260
|
+
"inputSchema": {
|
|
1261
|
+
"type": "object",
|
|
1262
|
+
"properties": {
|
|
1263
|
+
"pid": {
|
|
1264
|
+
"description": "Process ID. Takes precedence over name when set.",
|
|
1265
|
+
"type": [
|
|
1266
|
+
"integer",
|
|
1267
|
+
"null"
|
|
1268
|
+
],
|
|
1269
|
+
"default": null
|
|
1270
|
+
},
|
|
1271
|
+
"name": {
|
|
1272
|
+
"description": "Process name (no .exe extension required). Used when pid is null.",
|
|
1273
|
+
"type": [
|
|
1274
|
+
"string",
|
|
1275
|
+
"null"
|
|
1276
|
+
],
|
|
1277
|
+
"default": null
|
|
1278
|
+
},
|
|
1279
|
+
"force": {
|
|
1280
|
+
"description": "Force terminate (default true).",
|
|
1281
|
+
"type": "boolean",
|
|
1282
|
+
"default": true
|
|
1283
|
+
}
|
|
1284
|
+
}
|
|
1285
|
+
}
|
|
1286
|
+
},
|
|
1287
|
+
{
|
|
1288
|
+
"name": "launch_app",
|
|
1289
|
+
"description": "Launches a Windows application. Accepts an absolute path to an .exe (e.g. 'C:\\\\Windows\\\\System32\\\\notepad.exe'), an executable name resolvable via PATH (e.g. 'notepad.exe'), or a shell URI (mailto:, explorer:, ms-settings:).",
|
|
1290
|
+
"inputSchema": {
|
|
1291
|
+
"type": "object",
|
|
1292
|
+
"properties": {
|
|
1293
|
+
"target": {
|
|
1294
|
+
"description": "Path, executable name or shell URI to launch.",
|
|
1295
|
+
"type": "string"
|
|
1296
|
+
},
|
|
1297
|
+
"args": {
|
|
1298
|
+
"description": "Optional command-line arguments (space-separated, shell-escaped).",
|
|
1299
|
+
"type": [
|
|
1300
|
+
"string",
|
|
1301
|
+
"null"
|
|
1302
|
+
],
|
|
1303
|
+
"default": null
|
|
1304
|
+
},
|
|
1305
|
+
"workingDirectory": {
|
|
1306
|
+
"description": "Working directory for the new process.",
|
|
1307
|
+
"type": [
|
|
1308
|
+
"string",
|
|
1309
|
+
"null"
|
|
1310
|
+
],
|
|
1311
|
+
"default": null
|
|
1312
|
+
}
|
|
1313
|
+
},
|
|
1314
|
+
"required": [
|
|
1315
|
+
"target"
|
|
1316
|
+
]
|
|
1317
|
+
}
|
|
1318
|
+
},
|
|
1319
|
+
{
|
|
1320
|
+
"name": "list_directory",
|
|
1321
|
+
"description": "Lists directory contents as streamed JSON. Set recursive=true to descend, showHidden=true to include hidden entries, pattern to filter by glob, and exclude to omit matching entry names and skip matching directories. Exclusion matching is ASCII case-insensitive. Hard cap: 10000 entries returned; result is marked truncated when exceeded.",
|
|
1322
|
+
"inputSchema": {
|
|
1323
|
+
"type": "object",
|
|
1324
|
+
"properties": {
|
|
1325
|
+
"path": {
|
|
1326
|
+
"description": "Absolute or relative path. Relative paths are resolved against the user's Desktop folder.",
|
|
1327
|
+
"type": "string"
|
|
1328
|
+
},
|
|
1329
|
+
"pattern": {
|
|
1330
|
+
"description": "Glob pattern filter, e.g. '*.txt'. Empty = all entries.",
|
|
1331
|
+
"type": [
|
|
1332
|
+
"string",
|
|
1333
|
+
"null"
|
|
1334
|
+
],
|
|
1335
|
+
"default": null
|
|
1336
|
+
},
|
|
1337
|
+
"recursive": {
|
|
1338
|
+
"description": "Recurse into subdirectories.",
|
|
1339
|
+
"type": "boolean",
|
|
1340
|
+
"default": false
|
|
1341
|
+
},
|
|
1342
|
+
"showHidden": {
|
|
1343
|
+
"description": "Include hidden / system entries.",
|
|
1344
|
+
"type": "boolean",
|
|
1345
|
+
"default": false
|
|
1346
|
+
},
|
|
1347
|
+
"exclude": {
|
|
1348
|
+
"description": "Optional ASCII case-insensitive glob patterns matching entry names to omit. Matching directories are not returned or traversed.",
|
|
1349
|
+
"type": "array",
|
|
1350
|
+
"items": {
|
|
1351
|
+
"type": "string",
|
|
1352
|
+
"minLength": 1
|
|
1353
|
+
},
|
|
1354
|
+
"default": []
|
|
1355
|
+
}
|
|
1356
|
+
},
|
|
1357
|
+
"required": [
|
|
1358
|
+
"path"
|
|
1359
|
+
]
|
|
1360
|
+
}
|
|
1361
|
+
},
|
|
1362
|
+
{
|
|
1363
|
+
"name": "list_listening_ports",
|
|
1364
|
+
"description": "Lists TCP/IPv4 listening ports (LISTEN state only) as JSON.",
|
|
1365
|
+
"inputSchema": {
|
|
1366
|
+
"type": "object",
|
|
1367
|
+
"properties": {}
|
|
1368
|
+
}
|
|
1369
|
+
},
|
|
1370
|
+
{
|
|
1371
|
+
"name": "list_power_plans",
|
|
1372
|
+
"description": "Lists installed Windows power plans with their GUID, friendly name, and whether they are currently active. Returns JSON with the active GUID at the top.",
|
|
1373
|
+
"inputSchema": {
|
|
1374
|
+
"type": "object",
|
|
1375
|
+
"properties": {}
|
|
1376
|
+
}
|
|
1377
|
+
},
|
|
1378
|
+
{
|
|
1379
|
+
"name": "list_processes",
|
|
1380
|
+
"description": "Lists running processes as JSON. Filter by name (substring, case-insensitive). Sort by 'memory' (default), 'private', 'cpu', 'threads', 'handles' or 'name'. Limit caps the result count (default 20, max 1000). Backed by NtQuerySystemInformation for a single-syscall enumeration with full per-process metrics.",
|
|
1381
|
+
"inputSchema": {
|
|
1382
|
+
"type": "object",
|
|
1383
|
+
"properties": {
|
|
1384
|
+
"name": {
|
|
1385
|
+
"description": "Substring filter on process name (case-insensitive). Empty = no filter.",
|
|
1386
|
+
"type": [
|
|
1387
|
+
"string",
|
|
1388
|
+
"null"
|
|
1389
|
+
],
|
|
1390
|
+
"default": null
|
|
1391
|
+
},
|
|
1392
|
+
"sortBy": {
|
|
1393
|
+
"description": "Sort key: 'memory', 'private', 'cpu', 'threads', 'handles' or 'name'.",
|
|
1394
|
+
"type": "string",
|
|
1395
|
+
"default": "memory"
|
|
1396
|
+
},
|
|
1397
|
+
"limit": {
|
|
1398
|
+
"description": "Maximum number of results to return.",
|
|
1399
|
+
"type": "integer",
|
|
1400
|
+
"default": 20
|
|
1401
|
+
}
|
|
1402
|
+
}
|
|
1403
|
+
}
|
|
1404
|
+
},
|
|
1405
|
+
{
|
|
1406
|
+
"name": "list_registry_key",
|
|
1407
|
+
"description": "Lists sub-keys and values under a registry key as JSON.",
|
|
1408
|
+
"inputSchema": {
|
|
1409
|
+
"type": "object",
|
|
1410
|
+
"properties": {
|
|
1411
|
+
"path": {
|
|
1412
|
+
"description": "Key path including hive prefix.",
|
|
1413
|
+
"type": "string"
|
|
1414
|
+
}
|
|
1415
|
+
},
|
|
1416
|
+
"required": [
|
|
1417
|
+
"path"
|
|
1418
|
+
]
|
|
1419
|
+
}
|
|
1420
|
+
},
|
|
1421
|
+
{
|
|
1422
|
+
"name": "list_scheduled_tasks",
|
|
1423
|
+
"description": "Lists scheduled tasks under the given folder (default = root '\\') via schtasks /Query. Returns JSON: Path, Name, State, LastRunTimeUtc, LastTaskResult, Enabled.",
|
|
1424
|
+
"inputSchema": {
|
|
1425
|
+
"type": "object",
|
|
1426
|
+
"properties": {
|
|
1427
|
+
"folder": {
|
|
1428
|
+
"description": "Task folder, default '\\'. Use '\\Microsoft\\Windows\\Defender' for sub-folders.",
|
|
1429
|
+
"type": "string",
|
|
1430
|
+
"default": "\\"
|
|
1431
|
+
}
|
|
1432
|
+
}
|
|
1433
|
+
},
|
|
1434
|
+
"execution": {
|
|
1435
|
+
"taskSupport": "optional"
|
|
1436
|
+
}
|
|
1437
|
+
},
|
|
1438
|
+
{
|
|
1439
|
+
"name": "list_services",
|
|
1440
|
+
"description": "Lists Windows services as JSON. Filter by name substring (case-insensitive) and/or by status: Running, Stopped, Paused, StartPending, StopPending.",
|
|
1441
|
+
"inputSchema": {
|
|
1442
|
+
"type": "object",
|
|
1443
|
+
"properties": {
|
|
1444
|
+
"nameFilter": {
|
|
1445
|
+
"description": "Substring filter on service name (case-insensitive). Empty = no filter.",
|
|
1446
|
+
"type": [
|
|
1447
|
+
"string",
|
|
1448
|
+
"null"
|
|
1449
|
+
],
|
|
1450
|
+
"default": null
|
|
1451
|
+
},
|
|
1452
|
+
"statusFilter": {
|
|
1453
|
+
"description": "Status filter: Running, Stopped, Paused, StartPending, StopPending. Empty = any.",
|
|
1454
|
+
"type": [
|
|
1455
|
+
"string",
|
|
1456
|
+
"null"
|
|
1457
|
+
],
|
|
1458
|
+
"default": null
|
|
1459
|
+
}
|
|
1460
|
+
}
|
|
1461
|
+
}
|
|
1462
|
+
},
|
|
1463
|
+
{
|
|
1464
|
+
"name": "list_tcp_connections",
|
|
1465
|
+
"description": "Lists active TCP/IPv4 connections (Local/Remote address+port, state, owning PID) as JSON. Optional state filter (Listen, Established, CloseWait, TimeWait, Closed, SynSent, etc.).",
|
|
1466
|
+
"inputSchema": {
|
|
1467
|
+
"type": "object",
|
|
1468
|
+
"properties": {
|
|
1469
|
+
"stateFilter": {
|
|
1470
|
+
"description": "Optional state filter (case-insensitive). Empty = all states.",
|
|
1471
|
+
"type": [
|
|
1472
|
+
"string",
|
|
1473
|
+
"null"
|
|
1474
|
+
],
|
|
1475
|
+
"default": null
|
|
1476
|
+
}
|
|
1477
|
+
}
|
|
1478
|
+
}
|
|
1479
|
+
},
|
|
1480
|
+
{
|
|
1481
|
+
"name": "list_windows",
|
|
1482
|
+
"description": "Lists all visible top-level windows as JSON.",
|
|
1483
|
+
"inputSchema": {
|
|
1484
|
+
"type": "object",
|
|
1485
|
+
"properties": {}
|
|
1486
|
+
}
|
|
1487
|
+
},
|
|
1488
|
+
{
|
|
1489
|
+
"name": "mem_allocate",
|
|
1490
|
+
"description": "Allocates virtual memory in a remote process via VirtualAllocEx. Returns the base address of the new region. protect: 'rw' (PAGE_READWRITE), 'rwx' (PAGE_EXECUTE_READWRITE), 'rx' (PAGE_EXECUTE_READ).",
|
|
1491
|
+
"inputSchema": {
|
|
1492
|
+
"type": "object",
|
|
1493
|
+
"properties": {
|
|
1494
|
+
"pid": {
|
|
1495
|
+
"description": "Target process ID.",
|
|
1496
|
+
"type": "integer"
|
|
1497
|
+
},
|
|
1498
|
+
"size": {
|
|
1499
|
+
"description": "Size in bytes to commit.",
|
|
1500
|
+
"type": "integer"
|
|
1501
|
+
},
|
|
1502
|
+
"protect": {
|
|
1503
|
+
"description": "Protection flags: rw | rwx | rx.",
|
|
1504
|
+
"type": "string",
|
|
1505
|
+
"default": "rw"
|
|
1506
|
+
}
|
|
1507
|
+
},
|
|
1508
|
+
"required": [
|
|
1509
|
+
"pid",
|
|
1510
|
+
"size"
|
|
1511
|
+
]
|
|
1512
|
+
}
|
|
1513
|
+
},
|
|
1514
|
+
{
|
|
1515
|
+
"name": "mem_dump_region",
|
|
1516
|
+
"description": "Reads up to MAX_DUMP_BYTES (4 MiB) from a memory region and writes them to a host-side file (default: %TEMP%\\winclean_mcp_dump_<pid>_<addr>.bin). Returns the path and sha256 of the dump. Suspends the target during the read if suspend=true (avoids torn pages).",
|
|
1517
|
+
"inputSchema": {
|
|
1518
|
+
"type": "object",
|
|
1519
|
+
"properties": {
|
|
1520
|
+
"pid": {
|
|
1521
|
+
"description": "Target process ID.",
|
|
1522
|
+
"type": "integer"
|
|
1523
|
+
},
|
|
1524
|
+
"address": {
|
|
1525
|
+
"description": "Start address (decimal or 0x-prefixed hex).",
|
|
1526
|
+
"type": "integer"
|
|
1527
|
+
},
|
|
1528
|
+
"size": {
|
|
1529
|
+
"description": "Bytes to read. Capped at 4 MiB.",
|
|
1530
|
+
"type": "integer"
|
|
1531
|
+
},
|
|
1532
|
+
"outputPath": {
|
|
1533
|
+
"description": "Output file path. Empty = auto in %TEMP%.",
|
|
1534
|
+
"type": [
|
|
1535
|
+
"string",
|
|
1536
|
+
"null"
|
|
1537
|
+
],
|
|
1538
|
+
"default": null
|
|
1539
|
+
},
|
|
1540
|
+
"suspend": {
|
|
1541
|
+
"description": "Suspend the process for the duration of the read.",
|
|
1542
|
+
"type": "boolean",
|
|
1543
|
+
"default": false
|
|
1544
|
+
}
|
|
1545
|
+
},
|
|
1546
|
+
"required": [
|
|
1547
|
+
"pid",
|
|
1548
|
+
"address",
|
|
1549
|
+
"size"
|
|
1550
|
+
]
|
|
1551
|
+
}
|
|
1552
|
+
},
|
|
1553
|
+
{
|
|
1554
|
+
"name": "mem_enable_debug_privilege",
|
|
1555
|
+
"description": "Enables SeDebugPrivilege on the current MCP process so subsequent OpenProcess calls can attach to protected processes (most non-PPL user-mode targets). Idempotent — safe to call repeatedly.",
|
|
1556
|
+
"inputSchema": {
|
|
1557
|
+
"type": "object",
|
|
1558
|
+
"properties": {}
|
|
1559
|
+
}
|
|
1560
|
+
},
|
|
1561
|
+
{
|
|
1562
|
+
"name": "mem_free",
|
|
1563
|
+
"description": "Releases a region previously allocated with MemAllocate (MEM_RELEASE).",
|
|
1564
|
+
"inputSchema": {
|
|
1565
|
+
"type": "object",
|
|
1566
|
+
"properties": {
|
|
1567
|
+
"pid": {
|
|
1568
|
+
"description": "Target process ID.",
|
|
1569
|
+
"type": "integer"
|
|
1570
|
+
},
|
|
1571
|
+
"address": {
|
|
1572
|
+
"description": "Base address returned by MemAllocate (decimal or 0x-prefixed hex).",
|
|
1573
|
+
"type": "integer"
|
|
1574
|
+
}
|
|
1575
|
+
},
|
|
1576
|
+
"required": [
|
|
1577
|
+
"pid",
|
|
1578
|
+
"address"
|
|
1579
|
+
]
|
|
1580
|
+
}
|
|
1581
|
+
},
|
|
1582
|
+
{
|
|
1583
|
+
"name": "mem_get_module_base",
|
|
1584
|
+
"description": "Returns the base address and size of a named module in a process. Name comparison is case-insensitive. Returns the first match.",
|
|
1585
|
+
"inputSchema": {
|
|
1586
|
+
"type": "object",
|
|
1587
|
+
"properties": {
|
|
1588
|
+
"pid": {
|
|
1589
|
+
"description": "Target process ID.",
|
|
1590
|
+
"type": "integer"
|
|
1591
|
+
},
|
|
1592
|
+
"moduleName": {
|
|
1593
|
+
"description": "Module name to find (e.g. 'kernel32.dll'). Case-insensitive.",
|
|
1594
|
+
"type": "string"
|
|
1595
|
+
}
|
|
1596
|
+
},
|
|
1597
|
+
"required": [
|
|
1598
|
+
"pid",
|
|
1599
|
+
"moduleName"
|
|
1600
|
+
]
|
|
1601
|
+
}
|
|
1602
|
+
},
|
|
1603
|
+
{
|
|
1604
|
+
"name": "mem_list_modules",
|
|
1605
|
+
"description": "Lists all loaded modules (DLLs + EXE) of a process. Returns name, baseAddress, and sizeOfImage for each module.",
|
|
1606
|
+
"inputSchema": {
|
|
1607
|
+
"type": "object",
|
|
1608
|
+
"properties": {
|
|
1609
|
+
"pid": {
|
|
1610
|
+
"description": "Target process ID.",
|
|
1611
|
+
"type": "integer"
|
|
1612
|
+
}
|
|
1613
|
+
},
|
|
1614
|
+
"required": [
|
|
1615
|
+
"pid"
|
|
1616
|
+
]
|
|
1617
|
+
}
|
|
1618
|
+
},
|
|
1619
|
+
{
|
|
1620
|
+
"name": "mem_list_processes",
|
|
1621
|
+
"description": "Lists running processes filtered by name substring (case-insensitive). Returns pid, name, and sessionId for each match. Leave nameFilter empty to list all processes (capped at 512).",
|
|
1622
|
+
"inputSchema": {
|
|
1623
|
+
"type": "object",
|
|
1624
|
+
"properties": {
|
|
1625
|
+
"nameFilter": {
|
|
1626
|
+
"description": "Substring filter on process name (case-insensitive). Empty = all.",
|
|
1627
|
+
"type": "string",
|
|
1628
|
+
"default": ""
|
|
1629
|
+
}
|
|
1630
|
+
}
|
|
1631
|
+
}
|
|
1632
|
+
},
|
|
1633
|
+
{
|
|
1634
|
+
"name": "mem_protect",
|
|
1635
|
+
"description": "Changes page protection on a memory region via VirtualProtectEx. Returns the previous protection flags. protect: rw | rwx | rx | ro | noaccess.",
|
|
1636
|
+
"inputSchema": {
|
|
1637
|
+
"type": "object",
|
|
1638
|
+
"properties": {
|
|
1639
|
+
"pid": {
|
|
1640
|
+
"description": "Target process ID.",
|
|
1641
|
+
"type": "integer"
|
|
1642
|
+
},
|
|
1643
|
+
"address": {
|
|
1644
|
+
"description": "Base address.",
|
|
1645
|
+
"type": "integer"
|
|
1646
|
+
},
|
|
1647
|
+
"size": {
|
|
1648
|
+
"description": "Region size in bytes.",
|
|
1649
|
+
"type": "integer"
|
|
1650
|
+
},
|
|
1651
|
+
"protect": {
|
|
1652
|
+
"description": "New protection: rw | rwx | rx | ro | noaccess.",
|
|
1653
|
+
"type": "string"
|
|
1654
|
+
}
|
|
1655
|
+
},
|
|
1656
|
+
"required": [
|
|
1657
|
+
"pid",
|
|
1658
|
+
"address",
|
|
1659
|
+
"size",
|
|
1660
|
+
"protect"
|
|
1661
|
+
]
|
|
1662
|
+
}
|
|
1663
|
+
},
|
|
1664
|
+
{
|
|
1665
|
+
"name": "mem_query_region",
|
|
1666
|
+
"description": "Queries the virtual memory region containing the given address via VirtualQueryEx. Returns BaseAddress, RegionSize, State (Free/Reserve/Commit), Protect flags, and Type (Private/Image/Mapped).",
|
|
1667
|
+
"inputSchema": {
|
|
1668
|
+
"type": "object",
|
|
1669
|
+
"properties": {
|
|
1670
|
+
"pid": {
|
|
1671
|
+
"description": "Target process ID.",
|
|
1672
|
+
"type": "integer"
|
|
1673
|
+
},
|
|
1674
|
+
"address": {
|
|
1675
|
+
"description": "Any address within the region to query (decimal or 0x-prefixed hex).",
|
|
1676
|
+
"type": "integer"
|
|
1677
|
+
}
|
|
1678
|
+
},
|
|
1679
|
+
"required": [
|
|
1680
|
+
"pid",
|
|
1681
|
+
"address"
|
|
1682
|
+
]
|
|
1683
|
+
}
|
|
1684
|
+
},
|
|
1685
|
+
{
|
|
1686
|
+
"name": "mem_read_bytes",
|
|
1687
|
+
"description": "Reads raw bytes from a process's virtual address space via ReadProcessMemory. Length is capped at 65536 bytes. Returns hex-encoded bytes in the 'hex' field.",
|
|
1688
|
+
"inputSchema": {
|
|
1689
|
+
"type": "object",
|
|
1690
|
+
"properties": {
|
|
1691
|
+
"pid": {
|
|
1692
|
+
"description": "Target process ID.",
|
|
1693
|
+
"type": "integer"
|
|
1694
|
+
},
|
|
1695
|
+
"address": {
|
|
1696
|
+
"description": "Virtual address to read from (decimal or 0x-prefixed hex).",
|
|
1697
|
+
"type": "integer"
|
|
1698
|
+
},
|
|
1699
|
+
"length": {
|
|
1700
|
+
"description": "Number of bytes to read. Capped at 65536.",
|
|
1701
|
+
"type": "integer"
|
|
1702
|
+
}
|
|
1703
|
+
},
|
|
1704
|
+
"required": [
|
|
1705
|
+
"pid",
|
|
1706
|
+
"address",
|
|
1707
|
+
"length"
|
|
1708
|
+
]
|
|
1709
|
+
}
|
|
1710
|
+
},
|
|
1711
|
+
{
|
|
1712
|
+
"name": "mem_read_c_string",
|
|
1713
|
+
"description": "Reads a null-terminated ASCII C-string from a process's virtual memory. Stops at the first NUL byte or maxLength bytes, whichever comes first.",
|
|
1714
|
+
"inputSchema": {
|
|
1715
|
+
"type": "object",
|
|
1716
|
+
"properties": {
|
|
1717
|
+
"pid": {
|
|
1718
|
+
"description": "Target process ID.",
|
|
1719
|
+
"type": "integer"
|
|
1720
|
+
},
|
|
1721
|
+
"address": {
|
|
1722
|
+
"description": "Virtual address to read from (decimal or 0x-prefixed hex).",
|
|
1723
|
+
"type": "integer"
|
|
1724
|
+
},
|
|
1725
|
+
"maxLength": {
|
|
1726
|
+
"description": "Maximum bytes to read before stopping. Default 256, capped at 4096.",
|
|
1727
|
+
"type": "integer",
|
|
1728
|
+
"default": 256
|
|
1729
|
+
}
|
|
1730
|
+
},
|
|
1731
|
+
"required": [
|
|
1732
|
+
"pid",
|
|
1733
|
+
"address"
|
|
1734
|
+
]
|
|
1735
|
+
}
|
|
1736
|
+
},
|
|
1737
|
+
{
|
|
1738
|
+
"name": "mem_read_double",
|
|
1739
|
+
"description": "Reads a 64-bit IEEE 754 double (little-endian) from a process's virtual memory.",
|
|
1740
|
+
"inputSchema": {
|
|
1741
|
+
"type": "object",
|
|
1742
|
+
"properties": {
|
|
1743
|
+
"pid": {
|
|
1744
|
+
"description": "Target process ID.",
|
|
1745
|
+
"type": "integer"
|
|
1746
|
+
},
|
|
1747
|
+
"address": {
|
|
1748
|
+
"description": "Virtual address to read from (decimal or 0x-prefixed hex).",
|
|
1749
|
+
"type": "integer"
|
|
1750
|
+
}
|
|
1751
|
+
},
|
|
1752
|
+
"required": [
|
|
1753
|
+
"pid",
|
|
1754
|
+
"address"
|
|
1755
|
+
]
|
|
1756
|
+
}
|
|
1757
|
+
},
|
|
1758
|
+
{
|
|
1759
|
+
"name": "mem_read_float",
|
|
1760
|
+
"description": "Reads a 32-bit IEEE 754 float (little-endian) from a process's virtual memory.",
|
|
1761
|
+
"inputSchema": {
|
|
1762
|
+
"type": "object",
|
|
1763
|
+
"properties": {
|
|
1764
|
+
"pid": {
|
|
1765
|
+
"description": "Target process ID.",
|
|
1766
|
+
"type": "integer"
|
|
1767
|
+
},
|
|
1768
|
+
"address": {
|
|
1769
|
+
"description": "Virtual address to read from (decimal or 0x-prefixed hex).",
|
|
1770
|
+
"type": "integer"
|
|
1771
|
+
}
|
|
1772
|
+
},
|
|
1773
|
+
"required": [
|
|
1774
|
+
"pid",
|
|
1775
|
+
"address"
|
|
1776
|
+
]
|
|
1777
|
+
}
|
|
1778
|
+
},
|
|
1779
|
+
{
|
|
1780
|
+
"name": "mem_read_int32",
|
|
1781
|
+
"description": "Reads a signed 32-bit integer (little-endian) from a process's virtual memory.",
|
|
1782
|
+
"inputSchema": {
|
|
1783
|
+
"type": "object",
|
|
1784
|
+
"properties": {
|
|
1785
|
+
"pid": {
|
|
1786
|
+
"description": "Target process ID.",
|
|
1787
|
+
"type": "integer"
|
|
1788
|
+
},
|
|
1789
|
+
"address": {
|
|
1790
|
+
"description": "Virtual address to read from (decimal or 0x-prefixed hex).",
|
|
1791
|
+
"type": "integer"
|
|
1792
|
+
}
|
|
1793
|
+
},
|
|
1794
|
+
"required": [
|
|
1795
|
+
"pid",
|
|
1796
|
+
"address"
|
|
1797
|
+
]
|
|
1798
|
+
}
|
|
1799
|
+
},
|
|
1800
|
+
{
|
|
1801
|
+
"name": "mem_read_int64",
|
|
1802
|
+
"description": "Reads a signed 64-bit integer (little-endian) from a process's virtual memory.",
|
|
1803
|
+
"inputSchema": {
|
|
1804
|
+
"type": "object",
|
|
1805
|
+
"properties": {
|
|
1806
|
+
"pid": {
|
|
1807
|
+
"description": "Target process ID.",
|
|
1808
|
+
"type": "integer"
|
|
1809
|
+
},
|
|
1810
|
+
"address": {
|
|
1811
|
+
"description": "Virtual address to read from (decimal or 0x-prefixed hex).",
|
|
1812
|
+
"type": "integer"
|
|
1813
|
+
}
|
|
1814
|
+
},
|
|
1815
|
+
"required": [
|
|
1816
|
+
"pid",
|
|
1817
|
+
"address"
|
|
1818
|
+
]
|
|
1819
|
+
}
|
|
1820
|
+
},
|
|
1821
|
+
{
|
|
1822
|
+
"name": "mem_read_utf16",
|
|
1823
|
+
"description": "Reads a null-terminated UTF-16LE wide string from a process's virtual memory. Stops at the first NUL char or maxChars characters, whichever comes first.",
|
|
1824
|
+
"inputSchema": {
|
|
1825
|
+
"type": "object",
|
|
1826
|
+
"properties": {
|
|
1827
|
+
"pid": {
|
|
1828
|
+
"description": "Target process ID.",
|
|
1829
|
+
"type": "integer"
|
|
1830
|
+
},
|
|
1831
|
+
"address": {
|
|
1832
|
+
"description": "Virtual address to read from (decimal or 0x-prefixed hex).",
|
|
1833
|
+
"type": "integer"
|
|
1834
|
+
},
|
|
1835
|
+
"maxChars": {
|
|
1836
|
+
"description": "Maximum characters to read. Default 256, capped at 2048.",
|
|
1837
|
+
"type": "integer",
|
|
1838
|
+
"default": 256
|
|
1839
|
+
}
|
|
1840
|
+
},
|
|
1841
|
+
"required": [
|
|
1842
|
+
"pid",
|
|
1843
|
+
"address"
|
|
1844
|
+
]
|
|
1845
|
+
}
|
|
1846
|
+
},
|
|
1847
|
+
{
|
|
1848
|
+
"name": "mem_resume_process",
|
|
1849
|
+
"description": "Resumes every thread of the target process via NtResumeProcess.",
|
|
1850
|
+
"inputSchema": {
|
|
1851
|
+
"type": "object",
|
|
1852
|
+
"properties": {
|
|
1853
|
+
"pid": {
|
|
1854
|
+
"description": "Target process ID.",
|
|
1855
|
+
"type": "integer"
|
|
1856
|
+
}
|
|
1857
|
+
},
|
|
1858
|
+
"required": [
|
|
1859
|
+
"pid"
|
|
1860
|
+
]
|
|
1861
|
+
}
|
|
1862
|
+
},
|
|
1863
|
+
{
|
|
1864
|
+
"name": "mem_scan_aob",
|
|
1865
|
+
"description": "Scans a module's memory range for an IDA-style byte pattern (Array-of-Bytes scan). Pattern format: hex bytes separated by spaces, '??' as wildcard. Example: '48 8B 05 ?? ?? ?? ?? 48 89 01'. Reads the module in 256 KiB chunks. Returns up to maxHits matching addresses.",
|
|
1866
|
+
"inputSchema": {
|
|
1867
|
+
"type": "object",
|
|
1868
|
+
"properties": {
|
|
1869
|
+
"pid": {
|
|
1870
|
+
"description": "Target process ID.",
|
|
1871
|
+
"type": "integer"
|
|
1872
|
+
},
|
|
1873
|
+
"moduleName": {
|
|
1874
|
+
"description": "Module name to scan within (e.g. 'engine.dll').",
|
|
1875
|
+
"type": "string"
|
|
1876
|
+
},
|
|
1877
|
+
"pattern": {
|
|
1878
|
+
"description": "IDA-style byte pattern with '??' wildcards (e.g. '48 8B 05 ?? ?? ??').",
|
|
1879
|
+
"type": "string"
|
|
1880
|
+
},
|
|
1881
|
+
"maxHits": {
|
|
1882
|
+
"description": "Maximum number of matches to return. Default 10, capped at 100.",
|
|
1883
|
+
"type": "integer",
|
|
1884
|
+
"default": 10
|
|
1885
|
+
}
|
|
1886
|
+
},
|
|
1887
|
+
"required": [
|
|
1888
|
+
"pid",
|
|
1889
|
+
"moduleName",
|
|
1890
|
+
"pattern"
|
|
1891
|
+
]
|
|
1892
|
+
}
|
|
1893
|
+
},
|
|
1894
|
+
{
|
|
1895
|
+
"name": "mem_scan_value_int32",
|
|
1896
|
+
"description": "Cheat-Engine-style first scan: searches every committed RW page of the process for a 4-byte little-endian int32 value. Returns up to maxHits absolute addresses. Use MemReadInt32 to verify, then narrow via repeated scans.",
|
|
1897
|
+
"inputSchema": {
|
|
1898
|
+
"type": "object",
|
|
1899
|
+
"properties": {
|
|
1900
|
+
"pid": {
|
|
1901
|
+
"description": "Target process ID.",
|
|
1902
|
+
"type": "integer"
|
|
1903
|
+
},
|
|
1904
|
+
"value": {
|
|
1905
|
+
"description": "Value to search for.",
|
|
1906
|
+
"type": "integer"
|
|
1907
|
+
},
|
|
1908
|
+
"maxHits": {
|
|
1909
|
+
"description": "Maximum hits to return (default 200, capped at 5000).",
|
|
1910
|
+
"type": "integer",
|
|
1911
|
+
"default": 200
|
|
1912
|
+
}
|
|
1913
|
+
},
|
|
1914
|
+
"required": [
|
|
1915
|
+
"pid",
|
|
1916
|
+
"value"
|
|
1917
|
+
]
|
|
1918
|
+
}
|
|
1919
|
+
},
|
|
1920
|
+
{
|
|
1921
|
+
"name": "mem_suspend_process",
|
|
1922
|
+
"description": "Suspends every thread of the target process via NtSuspendProcess.",
|
|
1923
|
+
"inputSchema": {
|
|
1924
|
+
"type": "object",
|
|
1925
|
+
"properties": {
|
|
1926
|
+
"pid": {
|
|
1927
|
+
"description": "Target process ID.",
|
|
1928
|
+
"type": "integer"
|
|
1929
|
+
}
|
|
1930
|
+
},
|
|
1931
|
+
"required": [
|
|
1932
|
+
"pid"
|
|
1933
|
+
]
|
|
1934
|
+
}
|
|
1935
|
+
},
|
|
1936
|
+
{
|
|
1937
|
+
"name": "mem_write_bytes",
|
|
1938
|
+
"description": "Writes raw bytes to a process's virtual memory via WriteProcessMemory. hex format: continuous hex digits (e.g. '48895c2408') or space-separated ('48 89 5c 24 08'). Length capped at 65536. Requires PROCESS_VM_WRITE — call MemEnableDebugPrivilege first for protected targets.",
|
|
1939
|
+
"inputSchema": {
|
|
1940
|
+
"type": "object",
|
|
1941
|
+
"properties": {
|
|
1942
|
+
"pid": {
|
|
1943
|
+
"description": "Target process ID.",
|
|
1944
|
+
"type": "integer"
|
|
1945
|
+
},
|
|
1946
|
+
"address": {
|
|
1947
|
+
"description": "Virtual address to write to (decimal or 0x-prefixed hex).",
|
|
1948
|
+
"type": "integer"
|
|
1949
|
+
},
|
|
1950
|
+
"hex": {
|
|
1951
|
+
"description": "Hex string of bytes to write (e.g. 'deadbeef' or 'de ad be ef').",
|
|
1952
|
+
"type": "string"
|
|
1953
|
+
}
|
|
1954
|
+
},
|
|
1955
|
+
"required": [
|
|
1956
|
+
"pid",
|
|
1957
|
+
"address",
|
|
1958
|
+
"hex"
|
|
1959
|
+
]
|
|
1960
|
+
}
|
|
1961
|
+
},
|
|
1962
|
+
{
|
|
1963
|
+
"name": "mem_write_double",
|
|
1964
|
+
"description": "Writes a 64-bit IEEE 754 double to a process's memory.",
|
|
1965
|
+
"inputSchema": {
|
|
1966
|
+
"type": "object",
|
|
1967
|
+
"properties": {
|
|
1968
|
+
"pid": {
|
|
1969
|
+
"description": "Target process ID.",
|
|
1970
|
+
"type": "integer"
|
|
1971
|
+
},
|
|
1972
|
+
"address": {
|
|
1973
|
+
"description": "Virtual address (decimal or 0x-prefixed hex).",
|
|
1974
|
+
"type": "integer"
|
|
1975
|
+
},
|
|
1976
|
+
"value": {
|
|
1977
|
+
"description": "Value to write.",
|
|
1978
|
+
"type": "number"
|
|
1979
|
+
}
|
|
1980
|
+
},
|
|
1981
|
+
"required": [
|
|
1982
|
+
"pid",
|
|
1983
|
+
"address",
|
|
1984
|
+
"value"
|
|
1985
|
+
]
|
|
1986
|
+
}
|
|
1987
|
+
},
|
|
1988
|
+
{
|
|
1989
|
+
"name": "mem_write_float",
|
|
1990
|
+
"description": "Writes a 32-bit IEEE 754 float to a process's memory.",
|
|
1991
|
+
"inputSchema": {
|
|
1992
|
+
"type": "object",
|
|
1993
|
+
"properties": {
|
|
1994
|
+
"pid": {
|
|
1995
|
+
"description": "Target process ID.",
|
|
1996
|
+
"type": "integer"
|
|
1997
|
+
},
|
|
1998
|
+
"address": {
|
|
1999
|
+
"description": "Virtual address (decimal or 0x-prefixed hex).",
|
|
2000
|
+
"type": "integer"
|
|
2001
|
+
},
|
|
2002
|
+
"value": {
|
|
2003
|
+
"description": "Value to write.",
|
|
2004
|
+
"type": "number"
|
|
2005
|
+
}
|
|
2006
|
+
},
|
|
2007
|
+
"required": [
|
|
2008
|
+
"pid",
|
|
2009
|
+
"address",
|
|
2010
|
+
"value"
|
|
2011
|
+
]
|
|
2012
|
+
}
|
|
2013
|
+
},
|
|
2014
|
+
{
|
|
2015
|
+
"name": "mem_write_int32",
|
|
2016
|
+
"description": "Writes a signed 32-bit little-endian integer to a process's memory.",
|
|
2017
|
+
"inputSchema": {
|
|
2018
|
+
"type": "object",
|
|
2019
|
+
"properties": {
|
|
2020
|
+
"pid": {
|
|
2021
|
+
"description": "Target process ID.",
|
|
2022
|
+
"type": "integer"
|
|
2023
|
+
},
|
|
2024
|
+
"address": {
|
|
2025
|
+
"description": "Virtual address (decimal or 0x-prefixed hex).",
|
|
2026
|
+
"type": "integer"
|
|
2027
|
+
},
|
|
2028
|
+
"value": {
|
|
2029
|
+
"description": "Value to write.",
|
|
2030
|
+
"type": "integer"
|
|
2031
|
+
}
|
|
2032
|
+
},
|
|
2033
|
+
"required": [
|
|
2034
|
+
"pid",
|
|
2035
|
+
"address",
|
|
2036
|
+
"value"
|
|
2037
|
+
]
|
|
2038
|
+
}
|
|
2039
|
+
},
|
|
2040
|
+
{
|
|
2041
|
+
"name": "mem_write_int64",
|
|
2042
|
+
"description": "Writes a signed 64-bit little-endian integer to a process's memory.",
|
|
2043
|
+
"inputSchema": {
|
|
2044
|
+
"type": "object",
|
|
2045
|
+
"properties": {
|
|
2046
|
+
"pid": {
|
|
2047
|
+
"description": "Target process ID.",
|
|
2048
|
+
"type": "integer"
|
|
2049
|
+
},
|
|
2050
|
+
"address": {
|
|
2051
|
+
"description": "Virtual address (decimal or 0x-prefixed hex).",
|
|
2052
|
+
"type": "integer"
|
|
2053
|
+
},
|
|
2054
|
+
"value": {
|
|
2055
|
+
"description": "Value to write.",
|
|
2056
|
+
"type": "integer"
|
|
2057
|
+
}
|
|
2058
|
+
},
|
|
2059
|
+
"required": [
|
|
2060
|
+
"pid",
|
|
2061
|
+
"address",
|
|
2062
|
+
"value"
|
|
2063
|
+
]
|
|
2064
|
+
}
|
|
2065
|
+
},
|
|
2066
|
+
{
|
|
2067
|
+
"name": "mouse_drag_to",
|
|
2068
|
+
"description": "Performs a mouse drag from (x1,y1) to (x2,y2) with intermediate cursor moves so the OS drag-recognition logic actually fires (some apps reject teleported clicks). button: 'left' | 'right' | 'middle'. steps: number of intermediate move events (default 20).",
|
|
2069
|
+
"inputSchema": {
|
|
2070
|
+
"type": "object",
|
|
2071
|
+
"properties": {
|
|
2072
|
+
"x1": {
|
|
2073
|
+
"description": "Start X (screen pixels).",
|
|
2074
|
+
"type": "integer"
|
|
2075
|
+
},
|
|
2076
|
+
"y1": {
|
|
2077
|
+
"description": "Start Y (screen pixels).",
|
|
2078
|
+
"type": "integer"
|
|
2079
|
+
},
|
|
2080
|
+
"x2": {
|
|
2081
|
+
"description": "End X (screen pixels).",
|
|
2082
|
+
"type": "integer"
|
|
2083
|
+
},
|
|
2084
|
+
"y2": {
|
|
2085
|
+
"description": "End Y (screen pixels).",
|
|
2086
|
+
"type": "integer"
|
|
2087
|
+
},
|
|
2088
|
+
"button": {
|
|
2089
|
+
"description": "Mouse button: left | right | middle.",
|
|
2090
|
+
"type": "string",
|
|
2091
|
+
"default": "left"
|
|
2092
|
+
},
|
|
2093
|
+
"steps": {
|
|
2094
|
+
"description": "Intermediate move events (8..200).",
|
|
2095
|
+
"type": "integer",
|
|
2096
|
+
"default": 20
|
|
2097
|
+
},
|
|
2098
|
+
"durationMs": {
|
|
2099
|
+
"description": "Total drag duration in ms (clamped 50..5000).",
|
|
2100
|
+
"type": "integer",
|
|
2101
|
+
"default": 250
|
|
2102
|
+
}
|
|
2103
|
+
},
|
|
2104
|
+
"required": [
|
|
2105
|
+
"x1",
|
|
2106
|
+
"y1",
|
|
2107
|
+
"x2",
|
|
2108
|
+
"y2"
|
|
2109
|
+
]
|
|
2110
|
+
}
|
|
2111
|
+
},
|
|
2112
|
+
{
|
|
2113
|
+
"name": "mouse_move_smooth",
|
|
2114
|
+
"description": "Moves the mouse cursor smoothly along an interpolated path. Useful when the target window inspects MOUSEMOVE deltas (anti-automation heuristics) instead of a teleport via SetCursorPos. No button is pressed.",
|
|
2115
|
+
"inputSchema": {
|
|
2116
|
+
"type": "object",
|
|
2117
|
+
"properties": {
|
|
2118
|
+
"x": {
|
|
2119
|
+
"description": "Target X (screen pixels).",
|
|
2120
|
+
"type": "integer"
|
|
2121
|
+
},
|
|
2122
|
+
"y": {
|
|
2123
|
+
"description": "Target Y (screen pixels).",
|
|
2124
|
+
"type": "integer"
|
|
2125
|
+
},
|
|
2126
|
+
"steps": {
|
|
2127
|
+
"description": "Intermediate move events (4..200).",
|
|
2128
|
+
"type": "integer",
|
|
2129
|
+
"default": 30
|
|
2130
|
+
},
|
|
2131
|
+
"durationMs": {
|
|
2132
|
+
"description": "Total duration in ms (clamped 30..3000).",
|
|
2133
|
+
"type": "integer",
|
|
2134
|
+
"default": 200
|
|
2135
|
+
}
|
|
2136
|
+
},
|
|
2137
|
+
"required": [
|
|
2138
|
+
"x",
|
|
2139
|
+
"y"
|
|
2140
|
+
]
|
|
2141
|
+
}
|
|
2142
|
+
},
|
|
2143
|
+
{
|
|
2144
|
+
"name": "move",
|
|
2145
|
+
"description": "Moves the mouse cursor to the given screen coordinates. Set drag=true to perform a left-button drag from the current position to the target.",
|
|
2146
|
+
"inputSchema": {
|
|
2147
|
+
"type": "object",
|
|
2148
|
+
"properties": {
|
|
2149
|
+
"x": {
|
|
2150
|
+
"description": "X coordinate in screen pixels.",
|
|
2151
|
+
"type": "integer"
|
|
2152
|
+
},
|
|
2153
|
+
"y": {
|
|
2154
|
+
"description": "Y coordinate in screen pixels.",
|
|
2155
|
+
"type": "integer"
|
|
2156
|
+
},
|
|
2157
|
+
"drag": {
|
|
2158
|
+
"description": "Left-button drag from current position to (x,y) when true; cursor move (hover) otherwise.",
|
|
2159
|
+
"type": "boolean",
|
|
2160
|
+
"default": false
|
|
2161
|
+
}
|
|
2162
|
+
},
|
|
2163
|
+
"required": [
|
|
2164
|
+
"x",
|
|
2165
|
+
"y"
|
|
2166
|
+
]
|
|
2167
|
+
}
|
|
2168
|
+
},
|
|
2169
|
+
{
|
|
2170
|
+
"name": "move_path",
|
|
2171
|
+
"description": "Moves or renames a file or directory.",
|
|
2172
|
+
"inputSchema": {
|
|
2173
|
+
"type": "object",
|
|
2174
|
+
"properties": {
|
|
2175
|
+
"path": {
|
|
2176
|
+
"description": "Source path (absolute or relative to Desktop).",
|
|
2177
|
+
"type": "string"
|
|
2178
|
+
},
|
|
2179
|
+
"destination": {
|
|
2180
|
+
"description": "Destination path (absolute or relative to Desktop).",
|
|
2181
|
+
"type": "string"
|
|
2182
|
+
},
|
|
2183
|
+
"overwrite": {
|
|
2184
|
+
"description": "Overwrite existing destination.",
|
|
2185
|
+
"type": "boolean",
|
|
2186
|
+
"default": false
|
|
2187
|
+
}
|
|
2188
|
+
},
|
|
2189
|
+
"required": [
|
|
2190
|
+
"path",
|
|
2191
|
+
"destination"
|
|
2192
|
+
]
|
|
2193
|
+
}
|
|
2194
|
+
},
|
|
2195
|
+
{
|
|
2196
|
+
"name": "multi_edit",
|
|
2197
|
+
"description": "Types the same text into multiple UIA elements identified by exact Name property. Takes a comma-separated label list and a single text payload. Resolves labels against a fresh Snapshot() of the foreground window.",
|
|
2198
|
+
"inputSchema": {
|
|
2199
|
+
"type": "object",
|
|
2200
|
+
"properties": {
|
|
2201
|
+
"labels": {
|
|
2202
|
+
"description": "Comma-separated UIA element names to type into.",
|
|
2203
|
+
"type": "string"
|
|
2204
|
+
},
|
|
2205
|
+
"text": {
|
|
2206
|
+
"description": "Text payload (applied identically to each target).",
|
|
2207
|
+
"type": "string"
|
|
2208
|
+
}
|
|
2209
|
+
},
|
|
2210
|
+
"required": [
|
|
2211
|
+
"labels",
|
|
2212
|
+
"text"
|
|
2213
|
+
]
|
|
2214
|
+
},
|
|
2215
|
+
"execution": {
|
|
2216
|
+
"taskSupport": "optional"
|
|
2217
|
+
}
|
|
2218
|
+
},
|
|
2219
|
+
{
|
|
2220
|
+
"name": "multi_select",
|
|
2221
|
+
"description": "Clicks multiple UI elements identified by exact UIA Name property. Takes a comma-separated label list. Returns a JSON summary of clicked / notFound. Resolves labels against a fresh Snapshot() of the foreground window.",
|
|
2222
|
+
"inputSchema": {
|
|
2223
|
+
"type": "object",
|
|
2224
|
+
"properties": {
|
|
2225
|
+
"labels": {
|
|
2226
|
+
"description": "Comma-separated UIA element names to click in order.",
|
|
2227
|
+
"type": "string"
|
|
2228
|
+
}
|
|
2229
|
+
},
|
|
2230
|
+
"required": [
|
|
2231
|
+
"labels"
|
|
2232
|
+
]
|
|
2233
|
+
},
|
|
2234
|
+
"execution": {
|
|
2235
|
+
"taskSupport": "optional"
|
|
2236
|
+
}
|
|
2237
|
+
},
|
|
2238
|
+
{
|
|
2239
|
+
"name": "perf_dwm_flush",
|
|
2240
|
+
"description": "Forces the Desktop Window Manager to flush pending GPU work (DwmFlush). Useful right before / after a frame-rate critical operation to align with VBLANK.",
|
|
2241
|
+
"inputSchema": {
|
|
2242
|
+
"type": "object",
|
|
2243
|
+
"properties": {}
|
|
2244
|
+
}
|
|
2245
|
+
},
|
|
2246
|
+
{
|
|
2247
|
+
"name": "perf_empty_working_sets",
|
|
2248
|
+
"description": "Trims the working set of EVERY accessible process via NtSetSystemInformation (MemoryEmptyWorkingSets). Each process keeps its memory but pages are pushed to standby, freeing physical RAM immediately. No process is killed.",
|
|
2249
|
+
"inputSchema": {
|
|
2250
|
+
"type": "object",
|
|
2251
|
+
"properties": {}
|
|
2252
|
+
}
|
|
2253
|
+
},
|
|
2254
|
+
{
|
|
2255
|
+
"name": "perf_memory_status",
|
|
2256
|
+
"description": "Returns current physical and virtual memory pressure (MEMORYSTATUSEX). Use before/after PerfPurgeStandbyList or PerfEmptyWorkingSets to measure impact.",
|
|
2257
|
+
"inputSchema": {
|
|
2258
|
+
"type": "object",
|
|
2259
|
+
"properties": {}
|
|
2260
|
+
}
|
|
2261
|
+
},
|
|
2262
|
+
{
|
|
2263
|
+
"name": "perf_purge_standby_list",
|
|
2264
|
+
"description": "Purges the Windows memory standby list (cached pages that are no longer in any working set but kept around for re-use). Frees RAM instantly without touching working sets. Equivalent to RAMMap → Empty Standby List. Requires elevation.",
|
|
2265
|
+
"inputSchema": {
|
|
2266
|
+
"type": "object",
|
|
2267
|
+
"properties": {
|
|
2268
|
+
"lowPriorityOnly": {
|
|
2269
|
+
"description": "Purge low-priority only (faster, safer) instead of the full standby list.",
|
|
2270
|
+
"type": "boolean",
|
|
2271
|
+
"default": false
|
|
2272
|
+
}
|
|
2273
|
+
}
|
|
2274
|
+
}
|
|
2275
|
+
},
|
|
2276
|
+
{
|
|
2277
|
+
"name": "perf_set_eco_mode",
|
|
2278
|
+
"description": "Toggles Win11 EcoQoS (PowerThrottling) on a process. EcoMode = on → process is throttled to E-cores and capped frequency (saves power). EcoMode = off → release throttling (max performance). Reset all overrides with mode='default'.",
|
|
2279
|
+
"inputSchema": {
|
|
2280
|
+
"type": "object",
|
|
2281
|
+
"properties": {
|
|
2282
|
+
"pid": {
|
|
2283
|
+
"description": "Target process ID.",
|
|
2284
|
+
"type": "integer"
|
|
2285
|
+
},
|
|
2286
|
+
"mode": {
|
|
2287
|
+
"description": "'on' (eco), 'off' (max perf), 'default' (clear overrides).",
|
|
2288
|
+
"type": "string",
|
|
2289
|
+
"default": "on"
|
|
2290
|
+
}
|
|
2291
|
+
},
|
|
2292
|
+
"required": [
|
|
2293
|
+
"pid"
|
|
2294
|
+
]
|
|
2295
|
+
}
|
|
2296
|
+
},
|
|
2297
|
+
{
|
|
2298
|
+
"name": "power_shell",
|
|
2299
|
+
"description": "Executes a PowerShell command and returns stdout, stderr, exit code, and duration as JSON. Uses pwsh (PowerShell 7) when available, falling back to powershell.exe. Captures both streams without launching a window.",
|
|
2300
|
+
"inputSchema": {
|
|
2301
|
+
"type": "object",
|
|
2302
|
+
"properties": {
|
|
2303
|
+
"command": {
|
|
2304
|
+
"description": "PowerShell command or script to execute.",
|
|
2305
|
+
"type": "string"
|
|
2306
|
+
},
|
|
2307
|
+
"timeoutSeconds": {
|
|
2308
|
+
"description": "Timeout in seconds before the process is killed (default 30, max 600).",
|
|
2309
|
+
"type": "integer",
|
|
2310
|
+
"default": 30
|
|
2311
|
+
}
|
|
2312
|
+
},
|
|
2313
|
+
"required": [
|
|
2314
|
+
"command"
|
|
2315
|
+
]
|
|
2316
|
+
},
|
|
2317
|
+
"execution": {
|
|
2318
|
+
"taskSupport": "optional"
|
|
2319
|
+
}
|
|
2320
|
+
},
|
|
2321
|
+
{
|
|
2322
|
+
"name": "query_event_log",
|
|
2323
|
+
"description": "Queries a Windows Event Log channel via wevtapi and returns up to maxEvents entries (newest first) as JSON. Optional XPath filter (e.g. \"*[System[Level=2]]\" for Error-level only). Channel examples: Application, System, Security, Microsoft-Windows-WindowsUpdateClient/Operational.",
|
|
2324
|
+
"inputSchema": {
|
|
2325
|
+
"type": "object",
|
|
2326
|
+
"properties": {
|
|
2327
|
+
"channel": {
|
|
2328
|
+
"description": "Event log channel name.",
|
|
2329
|
+
"type": "string"
|
|
2330
|
+
},
|
|
2331
|
+
"maxEvents": {
|
|
2332
|
+
"description": "Maximum number of events to return (1..1000).",
|
|
2333
|
+
"type": "integer",
|
|
2334
|
+
"default": 50
|
|
2335
|
+
},
|
|
2336
|
+
"xpathFilter": {
|
|
2337
|
+
"description": "Optional XPath filter, e.g. \"*[System[Level=2]]\".",
|
|
2338
|
+
"type": [
|
|
2339
|
+
"string",
|
|
2340
|
+
"null"
|
|
2341
|
+
],
|
|
2342
|
+
"default": null
|
|
2343
|
+
}
|
|
2344
|
+
},
|
|
2345
|
+
"required": [
|
|
2346
|
+
"channel"
|
|
2347
|
+
]
|
|
2348
|
+
},
|
|
2349
|
+
"execution": {
|
|
2350
|
+
"taskSupport": "optional"
|
|
2351
|
+
}
|
|
2352
|
+
},
|
|
2353
|
+
{
|
|
2354
|
+
"name": "read_file",
|
|
2355
|
+
"description": "Reads a UTF-8 text file. Supports optional line offset and limit for reading large files in chunks. Returns the content prefixed with the resolved absolute path.",
|
|
2356
|
+
"inputSchema": {
|
|
2357
|
+
"type": "object",
|
|
2358
|
+
"properties": {
|
|
2359
|
+
"path": {
|
|
2360
|
+
"description": "Absolute or relative path. Relative paths are resolved against the user's Desktop folder.",
|
|
2361
|
+
"type": "string"
|
|
2362
|
+
},
|
|
2363
|
+
"offset": {
|
|
2364
|
+
"description": "Line offset (0-based). Default 0.",
|
|
2365
|
+
"type": "integer",
|
|
2366
|
+
"default": 0
|
|
2367
|
+
},
|
|
2368
|
+
"limit": {
|
|
2369
|
+
"description": "Maximum number of lines to read. 0 = no limit.",
|
|
2370
|
+
"type": "integer",
|
|
2371
|
+
"default": 0
|
|
2372
|
+
}
|
|
2373
|
+
},
|
|
2374
|
+
"required": [
|
|
2375
|
+
"path"
|
|
2376
|
+
]
|
|
2377
|
+
},
|
|
2378
|
+
"execution": {
|
|
2379
|
+
"taskSupport": "optional"
|
|
2380
|
+
}
|
|
2381
|
+
},
|
|
2382
|
+
{
|
|
2383
|
+
"name": "resize_window",
|
|
2384
|
+
"description": "Resizes / moves a window matched by title substring. Set width/height to 0 to keep current size.",
|
|
2385
|
+
"inputSchema": {
|
|
2386
|
+
"type": "object",
|
|
2387
|
+
"properties": {
|
|
2388
|
+
"titleSubstring": {
|
|
2389
|
+
"description": "Substring to match against the window title.",
|
|
2390
|
+
"type": "string"
|
|
2391
|
+
},
|
|
2392
|
+
"x": {
|
|
2393
|
+
"description": "X coordinate (screen pixels).",
|
|
2394
|
+
"type": "integer"
|
|
2395
|
+
},
|
|
2396
|
+
"y": {
|
|
2397
|
+
"description": "Y coordinate (screen pixels).",
|
|
2398
|
+
"type": "integer"
|
|
2399
|
+
},
|
|
2400
|
+
"width": {
|
|
2401
|
+
"description": "New width (0 = keep current).",
|
|
2402
|
+
"type": "integer",
|
|
2403
|
+
"default": 0
|
|
2404
|
+
},
|
|
2405
|
+
"height": {
|
|
2406
|
+
"description": "New height (0 = keep current).",
|
|
2407
|
+
"type": "integer",
|
|
2408
|
+
"default": 0
|
|
2409
|
+
}
|
|
2410
|
+
},
|
|
2411
|
+
"required": [
|
|
2412
|
+
"titleSubstring",
|
|
2413
|
+
"x",
|
|
2414
|
+
"y"
|
|
2415
|
+
]
|
|
2416
|
+
}
|
|
2417
|
+
},
|
|
2418
|
+
{
|
|
2419
|
+
"name": "restart_service",
|
|
2420
|
+
"description": "Restarts a Windows service. Stops then starts, waiting up to 10s per phase.",
|
|
2421
|
+
"inputSchema": {
|
|
2422
|
+
"type": "object",
|
|
2423
|
+
"properties": {
|
|
2424
|
+
"name": {
|
|
2425
|
+
"description": "Service short name.",
|
|
2426
|
+
"type": "string"
|
|
2427
|
+
}
|
|
2428
|
+
},
|
|
2429
|
+
"required": [
|
|
2430
|
+
"name"
|
|
2431
|
+
]
|
|
2432
|
+
},
|
|
2433
|
+
"execution": {
|
|
2434
|
+
"taskSupport": "optional"
|
|
2435
|
+
}
|
|
2436
|
+
},
|
|
2437
|
+
{
|
|
2438
|
+
"name": "run_scheduled_task",
|
|
2439
|
+
"description": "Runs a scheduled task immediately via schtasks /Run.",
|
|
2440
|
+
"inputSchema": {
|
|
2441
|
+
"type": "object",
|
|
2442
|
+
"properties": {
|
|
2443
|
+
"path": {
|
|
2444
|
+
"description": "Absolute task path.",
|
|
2445
|
+
"type": "string"
|
|
2446
|
+
}
|
|
2447
|
+
},
|
|
2448
|
+
"required": [
|
|
2449
|
+
"path"
|
|
2450
|
+
]
|
|
2451
|
+
},
|
|
2452
|
+
"execution": {
|
|
2453
|
+
"taskSupport": "optional"
|
|
2454
|
+
}
|
|
2455
|
+
},
|
|
2456
|
+
{
|
|
2457
|
+
"name": "scrape",
|
|
2458
|
+
"description": "Fetches a URL via HTTP GET and returns extracted plain text (script/style stripped, tags removed). Caps: 4 MiB download, 200k extracted chars, 30s timeout. For richer extraction prefer the docs MCP server (microsoft_docs_fetch / winclean_universal_web_fetch).",
|
|
2459
|
+
"inputSchema": {
|
|
2460
|
+
"type": "object",
|
|
2461
|
+
"properties": {
|
|
2462
|
+
"url": {
|
|
2463
|
+
"description": "Absolute URL (http:// or https://). Other schemes are rejected.",
|
|
2464
|
+
"type": "string"
|
|
2465
|
+
}
|
|
2466
|
+
},
|
|
2467
|
+
"required": [
|
|
2468
|
+
"url"
|
|
2469
|
+
]
|
|
2470
|
+
},
|
|
2471
|
+
"execution": {
|
|
2472
|
+
"taskSupport": "optional"
|
|
2473
|
+
}
|
|
2474
|
+
},
|
|
2475
|
+
{
|
|
2476
|
+
"name": "screenshot",
|
|
2477
|
+
"description": "Captures the primary monitor to a BMP file on disk. Returns the absolute file path. Width/height default to the full virtual screen.",
|
|
2478
|
+
"inputSchema": {
|
|
2479
|
+
"type": "object",
|
|
2480
|
+
"properties": {
|
|
2481
|
+
"outputPath": {
|
|
2482
|
+
"description": "Output file path. If null, a timestamped file is written to %TEMP%.",
|
|
2483
|
+
"type": [
|
|
2484
|
+
"string",
|
|
2485
|
+
"null"
|
|
2486
|
+
],
|
|
2487
|
+
"default": null
|
|
2488
|
+
}
|
|
2489
|
+
}
|
|
2490
|
+
}
|
|
2491
|
+
},
|
|
2492
|
+
{
|
|
2493
|
+
"name": "scroll",
|
|
2494
|
+
"description": "Scrolls at the given screen coordinates. axis: 'vertical' | 'horizontal'. direction: up/down for vertical, left/right for horizontal. wheelTimes is the number of wheel notches (each notch ≈ 3 lines).",
|
|
2495
|
+
"inputSchema": {
|
|
2496
|
+
"type": "object",
|
|
2497
|
+
"properties": {
|
|
2498
|
+
"x": {
|
|
2499
|
+
"description": "X coordinate in screen pixels (cursor is moved here before scrolling).",
|
|
2500
|
+
"type": "integer"
|
|
2501
|
+
},
|
|
2502
|
+
"y": {
|
|
2503
|
+
"description": "Y coordinate in screen pixels.",
|
|
2504
|
+
"type": "integer"
|
|
2505
|
+
},
|
|
2506
|
+
"axis": {
|
|
2507
|
+
"description": "Scroll axis: vertical | horizontal.",
|
|
2508
|
+
"type": "string",
|
|
2509
|
+
"default": "vertical"
|
|
2510
|
+
},
|
|
2511
|
+
"direction": {
|
|
2512
|
+
"description": "Scroll direction: up | down | left | right.",
|
|
2513
|
+
"type": "string",
|
|
2514
|
+
"default": "down"
|
|
2515
|
+
},
|
|
2516
|
+
"wheelTimes": {
|
|
2517
|
+
"description": "Number of wheel notches.",
|
|
2518
|
+
"type": "integer",
|
|
2519
|
+
"default": 1
|
|
2520
|
+
}
|
|
2521
|
+
},
|
|
2522
|
+
"required": [
|
|
2523
|
+
"x",
|
|
2524
|
+
"y"
|
|
2525
|
+
]
|
|
2526
|
+
}
|
|
2527
|
+
},
|
|
2528
|
+
{
|
|
2529
|
+
"name": "search_files",
|
|
2530
|
+
"description": "Searches a directory tree for files matching a glob pattern. Exclude basenames with glob patterns; excluded directories are not traversed. Hard cap: 10000 results; result is marked truncated when exceeded.",
|
|
2531
|
+
"inputSchema": {
|
|
2532
|
+
"type": "object",
|
|
2533
|
+
"properties": {
|
|
2534
|
+
"path": {
|
|
2535
|
+
"description": "Root path (absolute or relative to Desktop).",
|
|
2536
|
+
"type": "string"
|
|
2537
|
+
},
|
|
2538
|
+
"pattern": {
|
|
2539
|
+
"description": "Glob pattern, e.g. '*.log'.",
|
|
2540
|
+
"type": "string"
|
|
2541
|
+
},
|
|
2542
|
+
"recursive": {
|
|
2543
|
+
"description": "Recurse into subdirectories.",
|
|
2544
|
+
"type": "boolean",
|
|
2545
|
+
"default": true
|
|
2546
|
+
},
|
|
2547
|
+
"exclude": {
|
|
2548
|
+
"description": "Basename glob patterns to omit; matching directories are not traversed.",
|
|
2549
|
+
"type": "array",
|
|
2550
|
+
"items": {
|
|
2551
|
+
"type": "string"
|
|
2552
|
+
}
|
|
2553
|
+
}
|
|
2554
|
+
},
|
|
2555
|
+
"required": [
|
|
2556
|
+
"path",
|
|
2557
|
+
"pattern"
|
|
2558
|
+
]
|
|
2559
|
+
}
|
|
2560
|
+
},
|
|
2561
|
+
{
|
|
2562
|
+
"name": "search_windows",
|
|
2563
|
+
"description": "Effectue une recherche ultra-rapide sur le disque via l'indexeur natif Windows Search.",
|
|
2564
|
+
"inputSchema": {
|
|
2565
|
+
"type": "object",
|
|
2566
|
+
"properties": {
|
|
2567
|
+
"query": {
|
|
2568
|
+
"description": "Les mots clés de la recherche (nom de fichier ou contenu texte).",
|
|
2569
|
+
"type": "string"
|
|
2570
|
+
}
|
|
2571
|
+
},
|
|
2572
|
+
"required": [
|
|
2573
|
+
"query"
|
|
2574
|
+
]
|
|
2575
|
+
},
|
|
2576
|
+
"execution": {
|
|
2577
|
+
"taskSupport": "optional"
|
|
2578
|
+
}
|
|
2579
|
+
},
|
|
2580
|
+
{
|
|
2581
|
+
"name": "send_notification",
|
|
2582
|
+
"description": "Displays a Windows tray balloon notification with title and message. Note: balloon tips replace classic Win32 toasts; modern WinRT toast (requires WindowsAppSDK projection) is not yet wired up.",
|
|
2583
|
+
"inputSchema": {
|
|
2584
|
+
"type": "object",
|
|
2585
|
+
"properties": {
|
|
2586
|
+
"title": {
|
|
2587
|
+
"description": "Notification title (heading).",
|
|
2588
|
+
"type": "string"
|
|
2589
|
+
},
|
|
2590
|
+
"message": {
|
|
2591
|
+
"description": "Notification body message.",
|
|
2592
|
+
"type": "string"
|
|
2593
|
+
},
|
|
2594
|
+
"appId": {
|
|
2595
|
+
"description": "AUMID for branded toasts. Ignored in this Win32 balloon implementation.",
|
|
2596
|
+
"type": [
|
|
2597
|
+
"string",
|
|
2598
|
+
"null"
|
|
2599
|
+
],
|
|
2600
|
+
"default": null
|
|
2601
|
+
}
|
|
2602
|
+
},
|
|
2603
|
+
"required": [
|
|
2604
|
+
"title",
|
|
2605
|
+
"message"
|
|
2606
|
+
]
|
|
2607
|
+
}
|
|
2608
|
+
},
|
|
2609
|
+
{
|
|
2610
|
+
"name": "set_active_power_plan",
|
|
2611
|
+
"description": "Activates a Windows power plan by GUID. Common GUIDs: 381b4222-f694-41f0-9685-ff5bb260df2e (Balanced), 8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c (High performance), a1841308-3541-4fab-bc81-f71556f20b4a (Power saver), e9a42b02-d5df-448d-aa00-03f14749eb61 (Ultimate Performance).",
|
|
2612
|
+
"inputSchema": {
|
|
2613
|
+
"type": "object",
|
|
2614
|
+
"properties": {
|
|
2615
|
+
"guid": {
|
|
2616
|
+
"description": "GUID of the power plan to activate (with or without braces).",
|
|
2617
|
+
"type": "string"
|
|
2618
|
+
}
|
|
2619
|
+
},
|
|
2620
|
+
"required": [
|
|
2621
|
+
"guid"
|
|
2622
|
+
]
|
|
2623
|
+
}
|
|
2624
|
+
},
|
|
2625
|
+
{
|
|
2626
|
+
"name": "set_clipboard_text",
|
|
2627
|
+
"description": "Writes UTF-16 text to the Windows clipboard.",
|
|
2628
|
+
"inputSchema": {
|
|
2629
|
+
"type": "object",
|
|
2630
|
+
"properties": {
|
|
2631
|
+
"text": {
|
|
2632
|
+
"description": "Text to copy to the clipboard.",
|
|
2633
|
+
"type": "string"
|
|
2634
|
+
}
|
|
2635
|
+
},
|
|
2636
|
+
"required": [
|
|
2637
|
+
"text"
|
|
2638
|
+
]
|
|
2639
|
+
}
|
|
2640
|
+
},
|
|
2641
|
+
{
|
|
2642
|
+
"name": "set_gpu_preference",
|
|
2643
|
+
"description": "Writes per-app GPU preference in HKCU\\SOFTWARE\\Microsoft\\DirectX\\UserGpuPreferences. preference: 'SystemDefault' (0), 'PowerSaving' (1, iGPU), 'HighPerformance' (2, dGPU). exePath should be the absolute path to the .exe. Takes effect on next process launch. Format written: REG_SZ 'GpuPreference=N;'.",
|
|
2644
|
+
"inputSchema": {
|
|
2645
|
+
"type": "object",
|
|
2646
|
+
"properties": {
|
|
2647
|
+
"exePath": {
|
|
2648
|
+
"description": "Absolute path to the executable.",
|
|
2649
|
+
"type": "string"
|
|
2650
|
+
},
|
|
2651
|
+
"preference": {
|
|
2652
|
+
"description": "'SystemDefault' | 'PowerSaving' | 'HighPerformance'",
|
|
2653
|
+
"type": "string"
|
|
2654
|
+
}
|
|
2655
|
+
},
|
|
2656
|
+
"required": [
|
|
2657
|
+
"exePath",
|
|
2658
|
+
"preference"
|
|
2659
|
+
]
|
|
2660
|
+
}
|
|
2661
|
+
},
|
|
2662
|
+
{
|
|
2663
|
+
"name": "set_hags_mode",
|
|
2664
|
+
"description": "Writes HwSchMode in HKLM\\System\\CurrentControlSet\\Control\\GraphicsDrivers. Valid: 0 (WDDM CPU), 1 (OS default), 2 (HW-accelerated GPU scheduling). Requires admin + reboot. Microsoft + NVIDIA recommend 2 on WDDM 2.7+ hardware (validates DLSS 3 Frame Generation).",
|
|
2665
|
+
"inputSchema": {
|
|
2666
|
+
"type": "object",
|
|
2667
|
+
"properties": {
|
|
2668
|
+
"mode": {
|
|
2669
|
+
"description": "HwSchMode value: 0, 1, or 2.",
|
|
2670
|
+
"type": "integer"
|
|
2671
|
+
}
|
|
2672
|
+
},
|
|
2673
|
+
"required": [
|
|
2674
|
+
"mode"
|
|
2675
|
+
]
|
|
2676
|
+
}
|
|
2677
|
+
},
|
|
2678
|
+
{
|
|
2679
|
+
"name": "set_process_affinity",
|
|
2680
|
+
"description": "Sets the CPU affinity mask of a process. The mask is a bitmask where bit N means 'process may run on logical processor N'. Pass 0 to reset to the system default. Returns previous and new mask in hex as JSON.",
|
|
2681
|
+
"inputSchema": {
|
|
2682
|
+
"type": "object",
|
|
2683
|
+
"properties": {
|
|
2684
|
+
"pid": {
|
|
2685
|
+
"description": "Target process ID.",
|
|
2686
|
+
"type": "integer"
|
|
2687
|
+
},
|
|
2688
|
+
"mask": {
|
|
2689
|
+
"description": "Affinity bitmask. Bit N = run on logical CPU N. 0 resets to system mask.",
|
|
2690
|
+
"type": "integer"
|
|
2691
|
+
}
|
|
2692
|
+
},
|
|
2693
|
+
"required": [
|
|
2694
|
+
"pid",
|
|
2695
|
+
"mask"
|
|
2696
|
+
]
|
|
2697
|
+
}
|
|
2698
|
+
},
|
|
2699
|
+
{
|
|
2700
|
+
"name": "set_process_priority",
|
|
2701
|
+
"description": "Sets the Windows priority class of a process. Valid values: 'Idle', 'BelowNormal', 'Normal', 'AboveNormal', 'High', 'Realtime'. Returns previous and new class as JSON. Realtime requires Administrator and can starve system services.",
|
|
2702
|
+
"inputSchema": {
|
|
2703
|
+
"type": "object",
|
|
2704
|
+
"properties": {
|
|
2705
|
+
"pid": {
|
|
2706
|
+
"description": "Target process ID.",
|
|
2707
|
+
"type": "integer"
|
|
2708
|
+
},
|
|
2709
|
+
"priority": {
|
|
2710
|
+
"description": "Priority class name (case-insensitive).",
|
|
2711
|
+
"type": "string"
|
|
2712
|
+
}
|
|
2713
|
+
},
|
|
2714
|
+
"required": [
|
|
2715
|
+
"pid",
|
|
2716
|
+
"priority"
|
|
2717
|
+
]
|
|
2718
|
+
}
|
|
2719
|
+
},
|
|
2720
|
+
{
|
|
2721
|
+
"name": "set_registry_value",
|
|
2722
|
+
"description": "Writes a registry value. Creates the key if missing. Supported types: String, ExpandString, DWord, QWord, MultiString (newline-separated).",
|
|
2723
|
+
"inputSchema": {
|
|
2724
|
+
"type": "object",
|
|
2725
|
+
"properties": {
|
|
2726
|
+
"path": {
|
|
2727
|
+
"description": "Key path including hive prefix, e.g. 'HKCU:\\Software\\MyApp'.",
|
|
2728
|
+
"type": "string"
|
|
2729
|
+
},
|
|
2730
|
+
"name": {
|
|
2731
|
+
"description": "Value name. Use '(default)' for the default unnamed value.",
|
|
2732
|
+
"type": "string"
|
|
2733
|
+
},
|
|
2734
|
+
"value": {
|
|
2735
|
+
"description": "Value contents as string (parsed per type).",
|
|
2736
|
+
"type": "string"
|
|
2737
|
+
},
|
|
2738
|
+
"type": {
|
|
2739
|
+
"description": "Type: String, ExpandString, DWord, QWord, MultiString.",
|
|
2740
|
+
"type": "string",
|
|
2741
|
+
"default": "String"
|
|
2742
|
+
}
|
|
2743
|
+
},
|
|
2744
|
+
"required": [
|
|
2745
|
+
"path",
|
|
2746
|
+
"name",
|
|
2747
|
+
"value"
|
|
2748
|
+
]
|
|
2749
|
+
}
|
|
2750
|
+
},
|
|
2751
|
+
{
|
|
2752
|
+
"name": "shortcut",
|
|
2753
|
+
"description": "Sends a keyboard shortcut. The combo is a '+'-separated list of keys, e.g. 'ctrl+c', 'ctrl+shift+esc', 'win+r', 'alt+f4'. Modifier keys: ctrl, shift, alt, win. Literal keys: a-z, 0-9, f1-f24, esc, enter, tab, space, backspace, delete, home, end, up, down, left, right.",
|
|
2754
|
+
"inputSchema": {
|
|
2755
|
+
"type": "object",
|
|
2756
|
+
"properties": {
|
|
2757
|
+
"shortcut": {
|
|
2758
|
+
"description": "Shortcut string, e.g. 'ctrl+shift+esc'.",
|
|
2759
|
+
"type": "string"
|
|
2760
|
+
}
|
|
2761
|
+
},
|
|
2762
|
+
"required": [
|
|
2763
|
+
"shortcut"
|
|
2764
|
+
]
|
|
2765
|
+
}
|
|
2766
|
+
},
|
|
2767
|
+
{
|
|
2768
|
+
"name": "snapshot",
|
|
2769
|
+
"description": "Captures a UIA control-view tree snapshot of the foreground window via native UI Automation. Pass windowHandle to inspect a specific application without changing focus. Returns up to maxElements (default 200) descendants with name, controlType, automationId, className, bounds, focus and enabled state. Used by computer_* and MultiSelect/MultiEdit.",
|
|
2770
|
+
"inputSchema": {
|
|
2771
|
+
"type": "object",
|
|
2772
|
+
"properties": {
|
|
2773
|
+
"processName": {
|
|
2774
|
+
"description": "Optional process name filter (reserved for compatibility; use windowHandle for exact targeting).",
|
|
2775
|
+
"type": [
|
|
2776
|
+
"string",
|
|
2777
|
+
"null"
|
|
2778
|
+
],
|
|
2779
|
+
"default": null
|
|
2780
|
+
},
|
|
2781
|
+
"maxElements": {
|
|
2782
|
+
"description": "Maximum number of UI elements to return (1..1000).",
|
|
2783
|
+
"type": "integer",
|
|
2784
|
+
"default": 200
|
|
2785
|
+
},
|
|
2786
|
+
"windowHandle": {
|
|
2787
|
+
"description": "Exact HWND to inspect (0 = current foreground window).",
|
|
2788
|
+
"type": "integer",
|
|
2789
|
+
"default": 0
|
|
2790
|
+
}
|
|
2791
|
+
}
|
|
2792
|
+
},
|
|
2793
|
+
"execution": {
|
|
2794
|
+
"taskSupport": "optional"
|
|
2795
|
+
}
|
|
2796
|
+
},
|
|
2797
|
+
{
|
|
2798
|
+
"name": "start_service",
|
|
2799
|
+
"description": "Starts a stopped Windows service. Waits up to 10s for the Running state.",
|
|
2800
|
+
"inputSchema": {
|
|
2801
|
+
"type": "object",
|
|
2802
|
+
"properties": {
|
|
2803
|
+
"name": {
|
|
2804
|
+
"description": "Service short name (e.g. 'wuauserv', 'BITS').",
|
|
2805
|
+
"type": "string"
|
|
2806
|
+
}
|
|
2807
|
+
},
|
|
2808
|
+
"required": [
|
|
2809
|
+
"name"
|
|
2810
|
+
]
|
|
2811
|
+
},
|
|
2812
|
+
"execution": {
|
|
2813
|
+
"taskSupport": "optional"
|
|
2814
|
+
}
|
|
2815
|
+
},
|
|
2816
|
+
{
|
|
2817
|
+
"name": "steam_get_game",
|
|
2818
|
+
"description": "Returns full details of a single Steam game by appId. Returns {\"success\":false,...} if the appId is not found.",
|
|
2819
|
+
"inputSchema": {
|
|
2820
|
+
"type": "object",
|
|
2821
|
+
"properties": {
|
|
2822
|
+
"appId": {
|
|
2823
|
+
"description": "Steam AppID (integer).",
|
|
2824
|
+
"type": "integer"
|
|
2825
|
+
},
|
|
2826
|
+
"dbPath": {
|
|
2827
|
+
"description": "Absolute path to steam-scan.db. Default resolves via WINCLEAN_STEAM_SCAN_DB or <repo>/var/data/steam-scan.db.",
|
|
2828
|
+
"type": [
|
|
2829
|
+
"string",
|
|
2830
|
+
"null"
|
|
2831
|
+
],
|
|
2832
|
+
"default": null
|
|
2833
|
+
}
|
|
2834
|
+
},
|
|
2835
|
+
"required": [
|
|
2836
|
+
"appId"
|
|
2837
|
+
]
|
|
2838
|
+
}
|
|
2839
|
+
},
|
|
2840
|
+
{
|
|
2841
|
+
"name": "steam_get_game_status",
|
|
2842
|
+
"description": "Checks whether a Steam game process is currently running. Resolves install_dir and absolute_install_path from steam-scan.db. Executable name defaults to install_dir + \".exe\". Returns {\"appId\":N,\"running\":bool,\"pid\":N|null,\"executable\":\"...\",\"installDir\":\"...\"}.",
|
|
2843
|
+
"inputSchema": {
|
|
2844
|
+
"type": "object",
|
|
2845
|
+
"properties": {
|
|
2846
|
+
"appId": {
|
|
2847
|
+
"description": "Steam AppID (integer).",
|
|
2848
|
+
"type": "integer"
|
|
2849
|
+
},
|
|
2850
|
+
"executableName": {
|
|
2851
|
+
"description": "Override executable name (no .exe required). Defaults to install_dir + .exe.",
|
|
2852
|
+
"type": [
|
|
2853
|
+
"string",
|
|
2854
|
+
"null"
|
|
2855
|
+
],
|
|
2856
|
+
"default": null
|
|
2857
|
+
},
|
|
2858
|
+
"dbPath": {
|
|
2859
|
+
"description": "Absolute path to steam-scan.db. Default resolves via WINCLEAN_STEAM_SCAN_DB or <repo>/var/data/steam-scan.db.",
|
|
2860
|
+
"type": [
|
|
2861
|
+
"string",
|
|
2862
|
+
"null"
|
|
2863
|
+
],
|
|
2864
|
+
"default": null
|
|
2865
|
+
}
|
|
2866
|
+
},
|
|
2867
|
+
"required": [
|
|
2868
|
+
"appId"
|
|
2869
|
+
]
|
|
2870
|
+
}
|
|
2871
|
+
},
|
|
2872
|
+
{
|
|
2873
|
+
"name": "steam_kill_game",
|
|
2874
|
+
"description": "Kills a running Steam game by executable name. Returns {\"success\":true,\"pid\":N,\"killed\":1} or {\"success\":false,\"error\":\"not running\"}.",
|
|
2875
|
+
"inputSchema": {
|
|
2876
|
+
"type": "object",
|
|
2877
|
+
"properties": {
|
|
2878
|
+
"appId": {
|
|
2879
|
+
"description": "Steam AppID (informational only).",
|
|
2880
|
+
"type": "integer"
|
|
2881
|
+
},
|
|
2882
|
+
"executableName": {
|
|
2883
|
+
"description": "Executable name to kill (no .exe required).",
|
|
2884
|
+
"type": "string"
|
|
2885
|
+
}
|
|
2886
|
+
},
|
|
2887
|
+
"required": [
|
|
2888
|
+
"appId",
|
|
2889
|
+
"executableName"
|
|
2890
|
+
]
|
|
2891
|
+
}
|
|
2892
|
+
},
|
|
2893
|
+
{
|
|
2894
|
+
"name": "steam_launch_and_wait",
|
|
2895
|
+
"description": "Launches a Steam game via steam://rungameid/{appId} then waits for the process to appear. Combines SteamLaunchByAppId + SteamWaitForLaunch in a single MCP call. Returns {\"success\":true,\"pid\":N,\"elapsedMs\":N} or {\"success\":false,...}.",
|
|
2896
|
+
"inputSchema": {
|
|
2897
|
+
"type": "object",
|
|
2898
|
+
"properties": {
|
|
2899
|
+
"appId": {
|
|
2900
|
+
"description": "Steam AppID (integer).",
|
|
2901
|
+
"type": "integer"
|
|
2902
|
+
},
|
|
2903
|
+
"executableName": {
|
|
2904
|
+
"description": "Executable name to watch for (no .exe required).",
|
|
2905
|
+
"type": "string"
|
|
2906
|
+
},
|
|
2907
|
+
"timeoutMs": {
|
|
2908
|
+
"description": "Maximum wait in milliseconds. Default 60000.",
|
|
2909
|
+
"type": "integer",
|
|
2910
|
+
"default": 60000
|
|
2911
|
+
}
|
|
2912
|
+
},
|
|
2913
|
+
"required": [
|
|
2914
|
+
"appId",
|
|
2915
|
+
"executableName"
|
|
2916
|
+
]
|
|
2917
|
+
}
|
|
2918
|
+
},
|
|
2919
|
+
{
|
|
2920
|
+
"name": "steam_launch_by_app_id",
|
|
2921
|
+
"description": "Launches a Steam game via steam://rungameid/{appId}. Returns immediately — use SteamWaitForLaunch to block until the process is alive. Returns {\"success\":false,...} if Steam is not installed.",
|
|
2922
|
+
"inputSchema": {
|
|
2923
|
+
"type": "object",
|
|
2924
|
+
"properties": {
|
|
2925
|
+
"appId": {
|
|
2926
|
+
"description": "Steam AppID (integer).",
|
|
2927
|
+
"type": "integer"
|
|
2928
|
+
}
|
|
2929
|
+
},
|
|
2930
|
+
"required": [
|
|
2931
|
+
"appId"
|
|
2932
|
+
]
|
|
2933
|
+
}
|
|
2934
|
+
},
|
|
2935
|
+
{
|
|
2936
|
+
"name": "steam_list_games",
|
|
2937
|
+
"description": "Returns a JSON array of Steam games from steam-scan.db. By default only games whose files are present on disk (files_present > 0) are returned. Set includeMissing=true to include all rows regardless of files_present.",
|
|
2938
|
+
"inputSchema": {
|
|
2939
|
+
"type": "object",
|
|
2940
|
+
"properties": {
|
|
2941
|
+
"includeMissing": {
|
|
2942
|
+
"description": "Include games whose install directory is absent (files_present=0). Default false.",
|
|
2943
|
+
"type": "boolean",
|
|
2944
|
+
"default": false
|
|
2945
|
+
},
|
|
2946
|
+
"dbPath": {
|
|
2947
|
+
"description": "Absolute path to steam-scan.db. Default resolves via WINCLEAN_STEAM_SCAN_DB or <repo>/var/data/steam-scan.db.",
|
|
2948
|
+
"type": [
|
|
2949
|
+
"string",
|
|
2950
|
+
"null"
|
|
2951
|
+
],
|
|
2952
|
+
"default": null
|
|
2953
|
+
}
|
|
2954
|
+
}
|
|
2955
|
+
}
|
|
2956
|
+
},
|
|
2957
|
+
{
|
|
2958
|
+
"name": "steam_list_libraries",
|
|
2959
|
+
"description": "Returns all Steam library paths with their game_count and total_size_bytes as recorded in steam-scan.db.",
|
|
2960
|
+
"inputSchema": {
|
|
2961
|
+
"type": "object",
|
|
2962
|
+
"properties": {
|
|
2963
|
+
"dbPath": {
|
|
2964
|
+
"description": "Absolute path to steam-scan.db. Default resolves via WINCLEAN_STEAM_SCAN_DB or <repo>/var/data/steam-scan.db.",
|
|
2965
|
+
"type": [
|
|
2966
|
+
"string",
|
|
2967
|
+
"null"
|
|
2968
|
+
],
|
|
2969
|
+
"default": null
|
|
2970
|
+
}
|
|
2971
|
+
}
|
|
2972
|
+
}
|
|
2973
|
+
},
|
|
2974
|
+
{
|
|
2975
|
+
"name": "steam_open_uri",
|
|
2976
|
+
"description": "Opens any steam:// URI via ShellExecute. Allowed schemes: steam:// only. Returns {\"success\":true,\"uri\":\"...\"} or {\"success\":false,\"error\":\"invalid scheme\"}.",
|
|
2977
|
+
"inputSchema": {
|
|
2978
|
+
"type": "object",
|
|
2979
|
+
"properties": {
|
|
2980
|
+
"steamUri": {
|
|
2981
|
+
"description": "A steam:// URI, e.g. steam://store/2799860, steam://nav/console, steam://browsemedia.",
|
|
2982
|
+
"type": "string"
|
|
2983
|
+
}
|
|
2984
|
+
},
|
|
2985
|
+
"required": [
|
|
2986
|
+
"steamUri"
|
|
2987
|
+
]
|
|
2988
|
+
}
|
|
2989
|
+
},
|
|
2990
|
+
{
|
|
2991
|
+
"name": "steam_scan_summary",
|
|
2992
|
+
"description": "Returns aggregate counts from steam-scan.db: nb_installs, nb_libraries, nb_games, nb_games_present, total_size_bytes.",
|
|
2993
|
+
"inputSchema": {
|
|
2994
|
+
"type": "object",
|
|
2995
|
+
"properties": {
|
|
2996
|
+
"dbPath": {
|
|
2997
|
+
"description": "Absolute path to steam-scan.db. Default resolves via WINCLEAN_STEAM_SCAN_DB or <repo>/var/data/steam-scan.db.",
|
|
2998
|
+
"type": [
|
|
2999
|
+
"string",
|
|
3000
|
+
"null"
|
|
3001
|
+
],
|
|
3002
|
+
"default": null
|
|
3003
|
+
}
|
|
3004
|
+
}
|
|
3005
|
+
}
|
|
3006
|
+
},
|
|
3007
|
+
{
|
|
3008
|
+
"name": "steam_vault_status",
|
|
3009
|
+
"description": "Returns vault target metadata from secrets_vault_ref (target name, kind, description, user_hint). Secret material (passwords, tokens) is never included. Also attempts to invoke 'winclean-steam-auth list --json' (if present) for live vault status.",
|
|
3010
|
+
"inputSchema": {
|
|
3011
|
+
"type": "object",
|
|
3012
|
+
"properties": {
|
|
3013
|
+
"dbPath": {
|
|
3014
|
+
"description": "Absolute path to steam-scan.db. Default resolves via WINCLEAN_STEAM_SCAN_DB or <repo>/var/data/steam-scan.db.",
|
|
3015
|
+
"type": [
|
|
3016
|
+
"string",
|
|
3017
|
+
"null"
|
|
3018
|
+
],
|
|
3019
|
+
"default": null
|
|
3020
|
+
}
|
|
3021
|
+
}
|
|
3022
|
+
}
|
|
3023
|
+
},
|
|
3024
|
+
{
|
|
3025
|
+
"name": "steam_wait_for_launch",
|
|
3026
|
+
"description": "Polls until the named process appears or the timeout elapses. Returns {\"success\":true,\"pid\":N,\"elapsedMs\":N} or {\"success\":false,\"error\":\"timeout\",...}.",
|
|
3027
|
+
"inputSchema": {
|
|
3028
|
+
"type": "object",
|
|
3029
|
+
"properties": {
|
|
3030
|
+
"appId": {
|
|
3031
|
+
"description": "Steam AppID (informational only, used in the response).",
|
|
3032
|
+
"type": "integer"
|
|
3033
|
+
},
|
|
3034
|
+
"executableName": {
|
|
3035
|
+
"description": "Executable name to watch for (no .exe required).",
|
|
3036
|
+
"type": "string"
|
|
3037
|
+
},
|
|
3038
|
+
"timeoutMs": {
|
|
3039
|
+
"description": "Maximum wait in milliseconds. Default 60000.",
|
|
3040
|
+
"type": "integer",
|
|
3041
|
+
"default": 60000
|
|
3042
|
+
},
|
|
3043
|
+
"pollMs": {
|
|
3044
|
+
"description": "Poll interval in milliseconds. Default 500.",
|
|
3045
|
+
"type": "integer",
|
|
3046
|
+
"default": 500
|
|
3047
|
+
}
|
|
3048
|
+
},
|
|
3049
|
+
"required": [
|
|
3050
|
+
"appId",
|
|
3051
|
+
"executableName"
|
|
3052
|
+
]
|
|
3053
|
+
}
|
|
3054
|
+
},
|
|
3055
|
+
{
|
|
3056
|
+
"name": "stop_service",
|
|
3057
|
+
"description": "Stops a running Windows service. Waits up to 10s for the Stopped state.",
|
|
3058
|
+
"inputSchema": {
|
|
3059
|
+
"type": "object",
|
|
3060
|
+
"properties": {
|
|
3061
|
+
"name": {
|
|
3062
|
+
"description": "Service short name (e.g. 'wuauserv', 'BITS').",
|
|
3063
|
+
"type": "string"
|
|
3064
|
+
}
|
|
3065
|
+
},
|
|
3066
|
+
"required": [
|
|
3067
|
+
"name"
|
|
3068
|
+
]
|
|
3069
|
+
},
|
|
3070
|
+
"execution": {
|
|
3071
|
+
"taskSupport": "optional"
|
|
3072
|
+
}
|
|
3073
|
+
},
|
|
3074
|
+
{
|
|
3075
|
+
"name": "switch_to_window",
|
|
3076
|
+
"description": "Brings a window to the foreground by partial title match (case-insensitive). Restores it if minimized.",
|
|
3077
|
+
"inputSchema": {
|
|
3078
|
+
"type": "object",
|
|
3079
|
+
"properties": {
|
|
3080
|
+
"titleSubstring": {
|
|
3081
|
+
"description": "Substring to match against the window title.",
|
|
3082
|
+
"type": "string"
|
|
3083
|
+
}
|
|
3084
|
+
},
|
|
3085
|
+
"required": [
|
|
3086
|
+
"titleSubstring"
|
|
3087
|
+
]
|
|
3088
|
+
}
|
|
3089
|
+
},
|
|
3090
|
+
{
|
|
3091
|
+
"name": "trim_process_working_set",
|
|
3092
|
+
"description": "DIAGNOSTIC / DEBUG ONLY. Trims a process's working set via SetProcessWorkingSetSize(-1,-1). The OS does NOT free the pages — it moves them to the standby list. The next time the process touches that memory, it incurs a HARD PAGE FAULT (disk read). Mark Russinovich (Sysinternals creator, Azure CTO) documents this is anti-performance for normal use: see 'The Memory-Optimization Hoax'. The Microsoft API doc itself states the function is 'useful primarily for testing and tuning'. Use only on demonstrably-idle GUI apps where you accept the next-touch latency. Do NOT call in a loop.",
|
|
3093
|
+
"inputSchema": {
|
|
3094
|
+
"type": "object",
|
|
3095
|
+
"properties": {
|
|
3096
|
+
"pid": {
|
|
3097
|
+
"description": "Target process ID.",
|
|
3098
|
+
"type": "integer"
|
|
3099
|
+
}
|
|
3100
|
+
},
|
|
3101
|
+
"required": [
|
|
3102
|
+
"pid"
|
|
3103
|
+
]
|
|
3104
|
+
}
|
|
3105
|
+
},
|
|
3106
|
+
{
|
|
3107
|
+
"name": "type",
|
|
3108
|
+
"description": "Types text at the given screen coordinates. Set clear=true to send Ctrl+A + Delete before typing. Set pressEnter=true to submit with RETURN after typing. Max 4096 chars per call.",
|
|
3109
|
+
"inputSchema": {
|
|
3110
|
+
"type": "object",
|
|
3111
|
+
"properties": {
|
|
3112
|
+
"text": {
|
|
3113
|
+
"description": "Text to type.",
|
|
3114
|
+
"type": "string"
|
|
3115
|
+
},
|
|
3116
|
+
"x": {
|
|
3117
|
+
"description": "X coordinate in screen pixels (the field will be focused via a left-click).",
|
|
3118
|
+
"type": "integer"
|
|
3119
|
+
},
|
|
3120
|
+
"y": {
|
|
3121
|
+
"description": "Y coordinate in screen pixels.",
|
|
3122
|
+
"type": "integer"
|
|
3123
|
+
},
|
|
3124
|
+
"clear": {
|
|
3125
|
+
"description": "Clear the existing field contents first (Ctrl+A then Delete).",
|
|
3126
|
+
"type": "boolean",
|
|
3127
|
+
"default": false
|
|
3128
|
+
},
|
|
3129
|
+
"pressEnter": {
|
|
3130
|
+
"description": "Press ENTER after typing.",
|
|
3131
|
+
"type": "boolean",
|
|
3132
|
+
"default": false
|
|
3133
|
+
}
|
|
3134
|
+
},
|
|
3135
|
+
"required": [
|
|
3136
|
+
"text",
|
|
3137
|
+
"x",
|
|
3138
|
+
"y"
|
|
3139
|
+
]
|
|
3140
|
+
}
|
|
3141
|
+
},
|
|
3142
|
+
{
|
|
3143
|
+
"name": "wait",
|
|
3144
|
+
"description": "Pauses execution for the given duration in seconds (1..120).",
|
|
3145
|
+
"inputSchema": {
|
|
3146
|
+
"type": "object",
|
|
3147
|
+
"properties": {
|
|
3148
|
+
"seconds": {
|
|
3149
|
+
"description": "Sleep duration in seconds (clamped to [1,120]).",
|
|
3150
|
+
"type": "integer"
|
|
3151
|
+
}
|
|
3152
|
+
},
|
|
3153
|
+
"required": [
|
|
3154
|
+
"seconds"
|
|
3155
|
+
]
|
|
3156
|
+
},
|
|
3157
|
+
"execution": {
|
|
3158
|
+
"taskSupport": "optional"
|
|
3159
|
+
}
|
|
3160
|
+
},
|
|
3161
|
+
{
|
|
3162
|
+
"name": "window_capture",
|
|
3163
|
+
"description": "Captures the pixels of a window to a 24-bit BMP file via PrintWindow + GetDIBits. Works even when the window is MINIMISED, OFF-SCREEN or COVERED by another window (DWM redirection surface). Returns the saved BMP path and dimensions.",
|
|
3164
|
+
"inputSchema": {
|
|
3165
|
+
"type": "object",
|
|
3166
|
+
"properties": {
|
|
3167
|
+
"hwnd": {
|
|
3168
|
+
"description": "Target HWND.",
|
|
3169
|
+
"type": "integer"
|
|
3170
|
+
},
|
|
3171
|
+
"outputPath": {
|
|
3172
|
+
"description": "Output BMP path. Empty = auto in %TEMP%.",
|
|
3173
|
+
"type": [
|
|
3174
|
+
"string",
|
|
3175
|
+
"null"
|
|
3176
|
+
],
|
|
3177
|
+
"default": null
|
|
3178
|
+
},
|
|
3179
|
+
"fullContent": {
|
|
3180
|
+
"description": "Render the full window content via DWM (recommended). False = client-area only.",
|
|
3181
|
+
"type": "boolean",
|
|
3182
|
+
"default": true
|
|
3183
|
+
}
|
|
3184
|
+
},
|
|
3185
|
+
"required": [
|
|
3186
|
+
"hwnd"
|
|
3187
|
+
]
|
|
3188
|
+
}
|
|
3189
|
+
},
|
|
3190
|
+
{
|
|
3191
|
+
"name": "window_close",
|
|
3192
|
+
"description": "Sends WM_CLOSE to the window (graceful close request).",
|
|
3193
|
+
"inputSchema": {
|
|
3194
|
+
"type": "object",
|
|
3195
|
+
"properties": {
|
|
3196
|
+
"hwnd": {
|
|
3197
|
+
"description": "Target HWND.",
|
|
3198
|
+
"type": "integer"
|
|
3199
|
+
}
|
|
3200
|
+
},
|
|
3201
|
+
"required": [
|
|
3202
|
+
"hwnd"
|
|
3203
|
+
]
|
|
3204
|
+
}
|
|
3205
|
+
},
|
|
3206
|
+
{
|
|
3207
|
+
"name": "window_enum_all",
|
|
3208
|
+
"description": "Enumerates every top-level window (visible AND hidden). Filters by pid (0 = any), class substring, title substring (all case-insensitive). Returns hwnd, pid, classname, title, rect, visible, minimised, maximised flags.",
|
|
3209
|
+
"inputSchema": {
|
|
3210
|
+
"type": "object",
|
|
3211
|
+
"properties": {
|
|
3212
|
+
"pid": {
|
|
3213
|
+
"description": "Filter by process ID (0 = any).",
|
|
3214
|
+
"type": "integer",
|
|
3215
|
+
"default": 0
|
|
3216
|
+
},
|
|
3217
|
+
"classFilter": {
|
|
3218
|
+
"description": "Substring match on window class name (empty = any).",
|
|
3219
|
+
"type": "string",
|
|
3220
|
+
"default": ""
|
|
3221
|
+
},
|
|
3222
|
+
"titleFilter": {
|
|
3223
|
+
"description": "Substring match on window title (empty = any).",
|
|
3224
|
+
"type": "string",
|
|
3225
|
+
"default": ""
|
|
3226
|
+
},
|
|
3227
|
+
"includeHidden": {
|
|
3228
|
+
"description": "Include invisible windows (default true).",
|
|
3229
|
+
"type": "boolean",
|
|
3230
|
+
"default": true
|
|
3231
|
+
}
|
|
3232
|
+
}
|
|
3233
|
+
}
|
|
3234
|
+
},
|
|
3235
|
+
{
|
|
3236
|
+
"name": "window_enum_children",
|
|
3237
|
+
"description": "Enumerates direct + indirect child windows of a given HWND parent. Useful to drill into controls inside an app frame (edit fields, buttons, listviews).",
|
|
3238
|
+
"inputSchema": {
|
|
3239
|
+
"type": "object",
|
|
3240
|
+
"properties": {
|
|
3241
|
+
"parentHwnd": {
|
|
3242
|
+
"description": "Parent HWND (signed 64-bit).",
|
|
3243
|
+
"type": "integer"
|
|
3244
|
+
}
|
|
3245
|
+
},
|
|
3246
|
+
"required": [
|
|
3247
|
+
"parentHwnd"
|
|
3248
|
+
]
|
|
3249
|
+
}
|
|
3250
|
+
},
|
|
3251
|
+
{
|
|
3252
|
+
"name": "window_find_by_class",
|
|
3253
|
+
"description": "Finds the first top-level HWND with the exact class name (case-sensitive) and optionally a matching window title. Returns hwnd=0 if not found.",
|
|
3254
|
+
"inputSchema": {
|
|
3255
|
+
"type": "object",
|
|
3256
|
+
"properties": {
|
|
3257
|
+
"className": {
|
|
3258
|
+
"description": "Exact window class name (case-sensitive).",
|
|
3259
|
+
"type": "string"
|
|
3260
|
+
},
|
|
3261
|
+
"title": {
|
|
3262
|
+
"description": "Optional exact window title (empty = any).",
|
|
3263
|
+
"type": "string",
|
|
3264
|
+
"default": ""
|
|
3265
|
+
}
|
|
3266
|
+
},
|
|
3267
|
+
"required": [
|
|
3268
|
+
"className"
|
|
3269
|
+
]
|
|
3270
|
+
}
|
|
3271
|
+
},
|
|
3272
|
+
{
|
|
3273
|
+
"name": "window_get_text",
|
|
3274
|
+
"description": "Reads the text of a window or control via WM_GETTEXTLENGTH + WM_GETTEXT. Works on hidden controls; pair with WindowEnumChildren to locate the HWND.",
|
|
3275
|
+
"inputSchema": {
|
|
3276
|
+
"type": "object",
|
|
3277
|
+
"properties": {
|
|
3278
|
+
"hwnd": {
|
|
3279
|
+
"description": "Target HWND.",
|
|
3280
|
+
"type": "integer"
|
|
3281
|
+
}
|
|
3282
|
+
},
|
|
3283
|
+
"required": [
|
|
3284
|
+
"hwnd"
|
|
3285
|
+
]
|
|
3286
|
+
}
|
|
3287
|
+
},
|
|
3288
|
+
{
|
|
3289
|
+
"name": "window_minimise_all",
|
|
3290
|
+
"description": "Sends WM_KEYDOWN/UP for Win+D to the shell — minimises every visible window at once.",
|
|
3291
|
+
"inputSchema": {
|
|
3292
|
+
"type": "object",
|
|
3293
|
+
"properties": {}
|
|
3294
|
+
}
|
|
3295
|
+
},
|
|
3296
|
+
{
|
|
3297
|
+
"name": "window_move",
|
|
3298
|
+
"description": "Moves and/or resizes a window by HWND. Set width/height to 0 to keep current size, set x/y to a value outside the visible desktop to park the window off-screen.",
|
|
3299
|
+
"inputSchema": {
|
|
3300
|
+
"type": "object",
|
|
3301
|
+
"properties": {
|
|
3302
|
+
"hwnd": {
|
|
3303
|
+
"description": "Target HWND.",
|
|
3304
|
+
"type": "integer"
|
|
3305
|
+
},
|
|
3306
|
+
"x": {
|
|
3307
|
+
"description": "New X (screen pixels).",
|
|
3308
|
+
"type": "integer"
|
|
3309
|
+
},
|
|
3310
|
+
"y": {
|
|
3311
|
+
"description": "New Y (screen pixels).",
|
|
3312
|
+
"type": "integer"
|
|
3313
|
+
},
|
|
3314
|
+
"width": {
|
|
3315
|
+
"description": "New width (0 = keep).",
|
|
3316
|
+
"type": "integer",
|
|
3317
|
+
"default": 0
|
|
3318
|
+
},
|
|
3319
|
+
"height": {
|
|
3320
|
+
"description": "New height (0 = keep).",
|
|
3321
|
+
"type": "integer",
|
|
3322
|
+
"default": 0
|
|
3323
|
+
}
|
|
3324
|
+
},
|
|
3325
|
+
"required": [
|
|
3326
|
+
"hwnd",
|
|
3327
|
+
"x",
|
|
3328
|
+
"y"
|
|
3329
|
+
]
|
|
3330
|
+
}
|
|
3331
|
+
},
|
|
3332
|
+
{
|
|
3333
|
+
"name": "window_post_message",
|
|
3334
|
+
"description": "Posts a Win32 message to a window's queue via PostMessageW (asynchronous, non-blocking). Returns immediately even if the target ignores or hangs on the message.",
|
|
3335
|
+
"inputSchema": {
|
|
3336
|
+
"type": "object",
|
|
3337
|
+
"properties": {
|
|
3338
|
+
"hwnd": {
|
|
3339
|
+
"description": "Target HWND.",
|
|
3340
|
+
"type": "integer"
|
|
3341
|
+
},
|
|
3342
|
+
"msg": {
|
|
3343
|
+
"description": "Message id (decimal or 0x-prefixed hex).",
|
|
3344
|
+
"type": "integer"
|
|
3345
|
+
},
|
|
3346
|
+
"wParam": {
|
|
3347
|
+
"description": "wParam.",
|
|
3348
|
+
"type": "integer",
|
|
3349
|
+
"default": 0
|
|
3350
|
+
},
|
|
3351
|
+
"lParam": {
|
|
3352
|
+
"description": "lParam.",
|
|
3353
|
+
"type": "integer",
|
|
3354
|
+
"default": 0
|
|
3355
|
+
}
|
|
3356
|
+
},
|
|
3357
|
+
"required": [
|
|
3358
|
+
"hwnd",
|
|
3359
|
+
"msg"
|
|
3360
|
+
]
|
|
3361
|
+
}
|
|
3362
|
+
},
|
|
3363
|
+
{
|
|
3364
|
+
"name": "window_send_message",
|
|
3365
|
+
"description": "Sends a Win32 message to a window via SendMessageW (synchronous). Useful to drive controls without stealing focus — e.g. WM_LBUTTONDOWN/UP on a button HWND, WM_SETTEXT to set an edit field, WM_CLOSE to request close. wParam/lParam can be decimal or 0x-prefixed hex.",
|
|
3366
|
+
"inputSchema": {
|
|
3367
|
+
"type": "object",
|
|
3368
|
+
"properties": {
|
|
3369
|
+
"hwnd": {
|
|
3370
|
+
"description": "Target HWND.",
|
|
3371
|
+
"type": "integer"
|
|
3372
|
+
},
|
|
3373
|
+
"msg": {
|
|
3374
|
+
"description": "Message id (decimal or 0x-prefixed hex).",
|
|
3375
|
+
"type": "integer"
|
|
3376
|
+
},
|
|
3377
|
+
"wParam": {
|
|
3378
|
+
"description": "wParam.",
|
|
3379
|
+
"type": "integer",
|
|
3380
|
+
"default": 0
|
|
3381
|
+
},
|
|
3382
|
+
"lParam": {
|
|
3383
|
+
"description": "lParam.",
|
|
3384
|
+
"type": "integer",
|
|
3385
|
+
"default": 0
|
|
3386
|
+
}
|
|
3387
|
+
},
|
|
3388
|
+
"required": [
|
|
3389
|
+
"hwnd",
|
|
3390
|
+
"msg"
|
|
3391
|
+
]
|
|
3392
|
+
}
|
|
3393
|
+
},
|
|
3394
|
+
{
|
|
3395
|
+
"name": "window_set_opacity",
|
|
3396
|
+
"description": "Sets per-window opacity (0..255). Promotes the window to WS_EX_LAYERED if needed. Use 255 = fully opaque, 0 = fully transparent (but still receives input unless clickThrough).",
|
|
3397
|
+
"inputSchema": {
|
|
3398
|
+
"type": "object",
|
|
3399
|
+
"properties": {
|
|
3400
|
+
"hwnd": {
|
|
3401
|
+
"description": "Target HWND.",
|
|
3402
|
+
"type": "integer"
|
|
3403
|
+
},
|
|
3404
|
+
"alpha": {
|
|
3405
|
+
"description": "Alpha 0..255 (255 = opaque).",
|
|
3406
|
+
"type": "integer"
|
|
3407
|
+
},
|
|
3408
|
+
"clickThrough": {
|
|
3409
|
+
"description": "Make the window click-through (input passes underneath).",
|
|
3410
|
+
"type": "boolean",
|
|
3411
|
+
"default": false
|
|
3412
|
+
}
|
|
3413
|
+
},
|
|
3414
|
+
"required": [
|
|
3415
|
+
"hwnd",
|
|
3416
|
+
"alpha"
|
|
3417
|
+
]
|
|
3418
|
+
}
|
|
3419
|
+
},
|
|
3420
|
+
{
|
|
3421
|
+
"name": "window_set_text",
|
|
3422
|
+
"description": "Sets the text of a window or control via WM_SETTEXT. Targets edit fields, captions, listbox items. For complex Unicode UIs prefer UIA.",
|
|
3423
|
+
"inputSchema": {
|
|
3424
|
+
"type": "object",
|
|
3425
|
+
"properties": {
|
|
3426
|
+
"hwnd": {
|
|
3427
|
+
"description": "Target HWND.",
|
|
3428
|
+
"type": "integer"
|
|
3429
|
+
},
|
|
3430
|
+
"text": {
|
|
3431
|
+
"description": "New text (UTF-16).",
|
|
3432
|
+
"type": "string"
|
|
3433
|
+
}
|
|
3434
|
+
},
|
|
3435
|
+
"required": [
|
|
3436
|
+
"hwnd",
|
|
3437
|
+
"text"
|
|
3438
|
+
]
|
|
3439
|
+
}
|
|
3440
|
+
},
|
|
3441
|
+
{
|
|
3442
|
+
"name": "window_set_topmost",
|
|
3443
|
+
"description": "Sets the TOPMOST flag on a window (Z-order pinned above all non-topmost windows).",
|
|
3444
|
+
"inputSchema": {
|
|
3445
|
+
"type": "object",
|
|
3446
|
+
"properties": {
|
|
3447
|
+
"hwnd": {
|
|
3448
|
+
"description": "Target HWND.",
|
|
3449
|
+
"type": "integer"
|
|
3450
|
+
},
|
|
3451
|
+
"topmost": {
|
|
3452
|
+
"description": "true = pin topmost, false = release.",
|
|
3453
|
+
"type": "boolean",
|
|
3454
|
+
"default": true
|
|
3455
|
+
}
|
|
3456
|
+
},
|
|
3457
|
+
"required": [
|
|
3458
|
+
"hwnd"
|
|
3459
|
+
]
|
|
3460
|
+
}
|
|
3461
|
+
},
|
|
3462
|
+
{
|
|
3463
|
+
"name": "winml_get_version",
|
|
3464
|
+
"description": "Returns the ONNX Runtime version string powering Windows ML on this machine.",
|
|
3465
|
+
"inputSchema": {
|
|
3466
|
+
"type": "object",
|
|
3467
|
+
"properties": {}
|
|
3468
|
+
}
|
|
3469
|
+
},
|
|
3470
|
+
{
|
|
3471
|
+
"name": "winml_inspect_onnx",
|
|
3472
|
+
"description": "Loads an ONNX model and returns its input/output metadata (name, element type, shape). Use this before WinmlRunFloat32 to discover tensor shapes.",
|
|
3473
|
+
"inputSchema": {
|
|
3474
|
+
"type": "object",
|
|
3475
|
+
"properties": {
|
|
3476
|
+
"modelPath": {
|
|
3477
|
+
"description": "Absolute path to a .onnx model file.",
|
|
3478
|
+
"type": "string"
|
|
3479
|
+
}
|
|
3480
|
+
},
|
|
3481
|
+
"required": [
|
|
3482
|
+
"modelPath"
|
|
3483
|
+
]
|
|
3484
|
+
}
|
|
3485
|
+
},
|
|
3486
|
+
{
|
|
3487
|
+
"name": "winml_list_providers",
|
|
3488
|
+
"description": "Lists ONNX Runtime execution providers available in the current process (e.g. CPUExecutionProvider, DmlExecutionProvider, CUDAExecutionProvider). Reflects whatever EPs Windows ML / the loaded native dll registered.",
|
|
3489
|
+
"inputSchema": {
|
|
3490
|
+
"type": "object",
|
|
3491
|
+
"properties": {}
|
|
3492
|
+
}
|
|
3493
|
+
},
|
|
3494
|
+
{
|
|
3495
|
+
"name": "winml_run_float32",
|
|
3496
|
+
"description": "Runs inference on an ONNX model with float32 tensor inputs. inputsJson: '{\"input_name\":{\"shape\":[1,3,224,224],\"data\":[0.1,0.2,...]}}'. executionProvider: 'cpu' (default) | 'dml' (DirectML, any GPU) | 'cuda' (NVIDIA). Returns the first output tensor as float32 JSON.",
|
|
3497
|
+
"inputSchema": {
|
|
3498
|
+
"type": "object",
|
|
3499
|
+
"properties": {
|
|
3500
|
+
"modelPath": {
|
|
3501
|
+
"description": "Absolute path to a .onnx model file.",
|
|
3502
|
+
"type": "string"
|
|
3503
|
+
},
|
|
3504
|
+
"inputsJson": {
|
|
3505
|
+
"description": "JSON map of input name -> { shape: int[], data: float[] }.",
|
|
3506
|
+
"type": "string"
|
|
3507
|
+
},
|
|
3508
|
+
"executionProvider": {
|
|
3509
|
+
"description": "'cpu' | 'dml' | 'cuda'. Default 'cpu'.",
|
|
3510
|
+
"type": "string",
|
|
3511
|
+
"default": "cpu"
|
|
3512
|
+
}
|
|
3513
|
+
},
|
|
3514
|
+
"required": [
|
|
3515
|
+
"modelPath",
|
|
3516
|
+
"inputsJson"
|
|
3517
|
+
]
|
|
3518
|
+
}
|
|
3519
|
+
},
|
|
3520
|
+
{
|
|
3521
|
+
"name": "write_file",
|
|
3522
|
+
"description": "Writes UTF-8 text to a file. Creates parent directories as needed. Set append=true to append instead of overwrite.",
|
|
3523
|
+
"inputSchema": {
|
|
3524
|
+
"type": "object",
|
|
3525
|
+
"properties": {
|
|
3526
|
+
"path": {
|
|
3527
|
+
"description": "Absolute or relative path. Relative paths are resolved against the user's Desktop folder.",
|
|
3528
|
+
"type": "string"
|
|
3529
|
+
},
|
|
3530
|
+
"content": {
|
|
3531
|
+
"description": "Text content to write.",
|
|
3532
|
+
"type": "string"
|
|
3533
|
+
},
|
|
3534
|
+
"append": {
|
|
3535
|
+
"description": "Append to existing content instead of overwriting.",
|
|
3536
|
+
"type": "boolean",
|
|
3537
|
+
"default": false
|
|
3538
|
+
}
|
|
3539
|
+
},
|
|
3540
|
+
"required": [
|
|
3541
|
+
"path",
|
|
3542
|
+
"content"
|
|
3543
|
+
]
|
|
3544
|
+
},
|
|
3545
|
+
"execution": {
|
|
3546
|
+
"taskSupport": "optional"
|
|
3547
|
+
}
|
|
3548
|
+
},
|
|
3549
|
+
{
|
|
3550
|
+
"name": "wsl_execute",
|
|
3551
|
+
"description": "Runs a command in an existing WSL distribution using an argv array, with a 30-second bound and captured stdout/stderr. command must contain the executable followed by arguments; it is never concatenated into a shell command. For deliberate shell scripting, pass /bin/sh, -lc, and the script as separate command entries.",
|
|
3552
|
+
"inputSchema": {
|
|
3553
|
+
"type": "object",
|
|
3554
|
+
"properties": {
|
|
3555
|
+
"distribution": {
|
|
3556
|
+
"description": "Exact distribution name returned by wsl_list_distributions.",
|
|
3557
|
+
"type": "string"
|
|
3558
|
+
},
|
|
3559
|
+
"command": {
|
|
3560
|
+
"description": "Executable followed by its arguments; 1..64 values, no control characters.",
|
|
3561
|
+
"type": "array",
|
|
3562
|
+
"items": {
|
|
3563
|
+
"type": "string"
|
|
3564
|
+
}
|
|
3565
|
+
}
|
|
3566
|
+
},
|
|
3567
|
+
"required": [
|
|
3568
|
+
"distribution",
|
|
3569
|
+
"command"
|
|
3570
|
+
]
|
|
3571
|
+
},
|
|
3572
|
+
"execution": {
|
|
3573
|
+
"taskSupport": "optional"
|
|
3574
|
+
}
|
|
3575
|
+
},
|
|
3576
|
+
{
|
|
3577
|
+
"name": "wsl_get_status",
|
|
3578
|
+
"description": "Returns the local WSL installation status. This is read-only and reports the Windows WSL configuration, default distribution, and kernel information when available.",
|
|
3579
|
+
"inputSchema": {
|
|
3580
|
+
"type": "object",
|
|
3581
|
+
"properties": {}
|
|
3582
|
+
},
|
|
3583
|
+
"execution": {
|
|
3584
|
+
"taskSupport": "optional"
|
|
3585
|
+
}
|
|
3586
|
+
},
|
|
3587
|
+
{
|
|
3588
|
+
"name": "wsl_list_distributions",
|
|
3589
|
+
"description": "Lists installed WSL distributions with their state and WSL version. This is read-only; it never starts, terminates, imports, exports, or unregisters a distribution.",
|
|
3590
|
+
"inputSchema": {
|
|
3591
|
+
"type": "object",
|
|
3592
|
+
"properties": {}
|
|
3593
|
+
},
|
|
3594
|
+
"execution": {
|
|
3595
|
+
"taskSupport": "optional"
|
|
3596
|
+
}
|
|
3597
|
+
},
|
|
3598
|
+
{
|
|
3599
|
+
"name": "wsl_list_processes",
|
|
3600
|
+
"description": "Lists Linux processes in an existing WSL distribution. This is read-only and returns PID, parent PID, command, and arguments.",
|
|
3601
|
+
"inputSchema": {
|
|
3602
|
+
"type": "object",
|
|
3603
|
+
"properties": {
|
|
3604
|
+
"distribution": {
|
|
3605
|
+
"description": "Exact distribution name returned by wsl_list_distributions.",
|
|
3606
|
+
"type": "string"
|
|
3607
|
+
}
|
|
3608
|
+
},
|
|
3609
|
+
"required": [
|
|
3610
|
+
"distribution"
|
|
3611
|
+
]
|
|
3612
|
+
},
|
|
3613
|
+
"execution": {
|
|
3614
|
+
"taskSupport": "optional"
|
|
3615
|
+
}
|
|
3616
|
+
},
|
|
3617
|
+
{
|
|
3618
|
+
"name": "wsl_read_only_probe",
|
|
3619
|
+
"description": "Runs one fixed, read-only diagnostic inside an existing WSL distribution. probe must be one of: system-info, re-toolchain, processes, mounts, or network. No arbitrary shell command is accepted.",
|
|
3620
|
+
"inputSchema": {
|
|
3621
|
+
"type": "object",
|
|
3622
|
+
"properties": {
|
|
3623
|
+
"distribution": {
|
|
3624
|
+
"description": "Exact distribution name returned by wsl_list_distributions.",
|
|
3625
|
+
"type": "string"
|
|
3626
|
+
},
|
|
3627
|
+
"probe": {
|
|
3628
|
+
"description": "One of: system-info, re-toolchain, processes, mounts, network.",
|
|
3629
|
+
"type": "string"
|
|
3630
|
+
}
|
|
3631
|
+
},
|
|
3632
|
+
"required": [
|
|
3633
|
+
"distribution",
|
|
3634
|
+
"probe"
|
|
3635
|
+
]
|
|
3636
|
+
},
|
|
3637
|
+
"execution": {
|
|
3638
|
+
"taskSupport": "optional"
|
|
3639
|
+
}
|
|
3640
|
+
},
|
|
3641
|
+
{
|
|
3642
|
+
"name": "wsl_send_signal",
|
|
3643
|
+
"description": "Sends HUP, INT, TERM, or KILL to one exact Linux PID in an existing WSL distribution. Call wsl_list_processes first to identify the target PID.",
|
|
3644
|
+
"inputSchema": {
|
|
3645
|
+
"type": "object",
|
|
3646
|
+
"properties": {
|
|
3647
|
+
"distribution": {
|
|
3648
|
+
"description": "Exact distribution name returned by wsl_list_distributions.",
|
|
3649
|
+
"type": "string"
|
|
3650
|
+
},
|
|
3651
|
+
"processId": {
|
|
3652
|
+
"description": "Exact positive Linux PID returned by wsl_list_processes.",
|
|
3653
|
+
"type": "integer"
|
|
3654
|
+
},
|
|
3655
|
+
"signal": {
|
|
3656
|
+
"description": "HUP, INT, TERM, or KILL.",
|
|
3657
|
+
"type": "string",
|
|
3658
|
+
"default": "TERM"
|
|
3659
|
+
}
|
|
3660
|
+
},
|
|
3661
|
+
"required": [
|
|
3662
|
+
"distribution",
|
|
3663
|
+
"processId"
|
|
3664
|
+
]
|
|
3665
|
+
},
|
|
3666
|
+
"execution": {
|
|
3667
|
+
"taskSupport": "optional"
|
|
3668
|
+
}
|
|
3669
|
+
}
|
|
3670
|
+
];
|