@xevy/skills 0.1.42 → 0.1.45

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.
@@ -2,7 +2,7 @@
2
2
  "name": "xevy",
3
3
  "displayName": "Xevy",
4
4
  "description": "Native /xevy:* SDLC workflow commands driven through the Xevy MCP server. Analyze, plan, execute, fix, and move-to-qa run locally by default and accept --cloud for the server Web Agent. Merge stays local; merge-pull-request evaluates and lands the remote PR.",
5
- "version": "0.1.42",
5
+ "version": "0.1.45",
6
6
  "author": {
7
7
  "name": "Xevy"
8
8
  },
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@xevy/skills",
3
- "version": "0.1.42",
3
+ "version": "0.1.45",
4
4
  "description": "Install Xevy agent skills and secure per-agent MCP transports for Cursor, Claude Code, Codex, and other coding agents.",
5
5
  "type": "module",
6
6
  "keywords": [
@@ -5,15 +5,15 @@ description: Operate connected Windows or macOS applications through Xevy Comput
5
5
 
6
6
  # Computer
7
7
 
8
- Use the connected desktop for the user's application task. Resolve the target Computer, app, environment, and intended result from the request and current context. Read the actual available tool schemas; MCP and public tools expose owner management while the autonomous server tools expose a task-scoped subset.
8
+ Use the connected desktop for the user's application task. Resolve the target Computer, app, environment, and intended result from the request and current context. Read the actual available tool schemas; MCP and public tools expose owner management while the autonomous server tools expose a task-scoped subset. When supported by the companion, shell and file actions run on that Computer through the same audited MCP session.
9
9
 
10
10
  ## Establish control
11
11
 
12
12
  Use `computer_list` and `computer_get` to find the requested device. Pairing uses `computer_pair` and Xevy Connect. Windows controls the signed-in user's desktop. macOS 14+ requires native Screen Recording and Accessibility consent; report missing consent as a blocker.
13
13
 
14
- Start an exclusive `agent` session with `computer_start`, associating the current project/task when relevant. Capture the session ID and generation. A recently heartbeating paused device can accept a fresh controller; input waits for the companion to resume. Explicit local pause requires the user to resume Xevy Connect. Offline, revoked, expired, or unavailable devices require recovery before input. Report the observed state and fixed `pauseReason` when available.
14
+ Start an `agent` session with `computer_start`, associating the current project/task when relevant. Agent sessions can coexist on one Computer; each keeps its own session ID and shares the device generation until a human takes over or the device pauses. Capture your session ID and generation. A recently heartbeating paused device can accept a fresh controller; input waits for the companion to resume. Explicit local pause requires the user to resume Xevy Connect. Offline, revoked, expired, or unavailable devices require recovery before input. Report the observed state and fixed `pauseReason` when available.
15
15
 
16
- Inspect an existing controller before changing it. Human take-over advances the generation and owns control. Continue only when control is explicitly returned; refresh session metadata before further input. Send the captured generation with pause/resume/stop, including cleanup, so an old agent cannot stop a new controller. Stop only the session this run owns. For owned cleanup, call `computer_control({computerId, sessionId, generation, transition: 'stop'})` with the captured generation. On the public surface, start with `computer_start({computerId, mode: 'agent', projectId, taskId})` using relevant context; the internal server surface takes only `computerId` and inherits its task, so follow the active tool schema.
16
+ Inspect existing sessions before changing control. Human take-over advances the generation and stops agent sessions. Continue only when control is explicitly returned; refresh session metadata before further input. Send the captured generation with pause/resume/stop, including cleanup, so an old agent cannot stop a new controller. Stop only the session this run owns; stopping one agent session leaves other agents connected. For owned cleanup, call `computer_control({computerId, sessionId, generation, transition: 'stop'})` with the captured generation. On the public surface, start with `computer_start({computerId, mode: 'agent', projectId, taskId})` using relevant context; the internal server surface takes only `computerId` and inherits its task, so follow the active tool schema.
17
17
 
18
18
  ## Browser control
19
19
 
@@ -21,16 +21,20 @@ For browser work, use tab-scoped browser actions when the companion advertises t
21
21
 
22
22
  Call `browser.connect` with the selected `browserId` and `profileId` to attach to an existing local debugging endpoint. A running browser with a usable endpoint should remain open. If there is no endpoint, explain that starting debugging requires closing and reopening the selected browser/profile. Send `restart: true` only when that restart is authorized; never terminate another profile to obtain a port. The companion owns the loopback debugging connection. Do not connect directly to a debug port from the agent host or expose it across the network.
23
23
 
24
- Use `browser.tabs` to select the actual tab, then `browser.navigate`, `browser.snapshot`, `browser.click`, `browser.type`, and `browser.key` as needed. Read every command result. Browser coordinates belong to the selected tab viewport; they are distinct from desktop screen coordinates. Prefer `browser.snapshot` for evidence because it captures the tab without unrelated desktop windows. Do not call `desktop.snapshot` as a substitute when a tab-scoped capture is available or a full-monitor capture is blocked. `browser.disconnect` releases the companion's browser connection; it closes a browser only when the companion owns that launch. Follow the tool's current schema and capability list, since older companion versions may offer desktop actions only.
24
+ Create a task-owned tab with `browser.newTab {url}` before parallel browser work, then use `browser.tabs`, `browser.navigate`, `browser.snapshot`, `browser.inspect`, `browser.click`, `browser.scroll`, `browser.type`, and `browser.key` as needed. `browser.snapshot {tabId,fullPage:true}` captures a bounded full page; `browser.inspect {tabId,selector?,limit?}` returns page title, URL, and bounded element metadata without running an arbitrary script. `browser.closeTab {tabId}` closes a tab owned by your session. A second agent cannot change a tab another agent owns; use a separate tab. Read every command result and take a fresh snapshot after input, since successful input dispatch alone does not prove the page changed. Browser coordinates belong to the selected tab viewport; they are distinct from desktop screen coordinates. Prefer `browser.snapshot` for evidence because it captures the tab without unrelated desktop windows. `browser.disconnect` releases this session's browser connection; it closes a managed browser only when no other session uses it. Follow the tool's current schema and capability list, since older companion versions may offer desktop actions only.
25
25
 
26
26
  ## Observe, act, verify
27
27
 
28
+ For shell work, queue `shell.run {executable,args?,cwd?,timeoutMs?}`. Pass an executable and an argument array; each invocation has a 30-second timeout and bounded stdout/stderr. Read the terminal command result and verify the effect of any write before repeating it. Shell commands may change many files or external records, so keep one focused invocation per operation and describe the intended effect in the operation completion. Block rules can target `shell.run`, executable names, and the working directory. A file-path rule governs structured `file.*` actions; block `shell.run` when shell access to that path must also be prevented. Command arguments and output stay out of durable audit summaries.
29
+
30
+ For file transfer, use absolute paths and chunks of at most 192 KiB. Download with `file.stat {path}` followed by `file.readChunk {path,offset,length}` until `eof`; verify each chunk's SHA-256 and the assembled file locally. Upload by calculating the full file's SHA-256, then call `file.uploadStart {path,size,sha256,replace?}`, send ordered `file.uploadChunk {transferId,offset,dataBase64}` actions, and finish with `file.uploadCommit {transferId}`. Use `file.uploadCancel` if abandoning a transfer. The companion stages at most 100 MiB across transfers and removes stale uploads after one hour. Transfer IDs belong to the creating agent session. Path block rules apply to reads and uploads, including chunk and commit steps. Treat the transferred bytes and shell output as ephemeral results; keep them out of operation summaries.
31
+
28
32
  1. Request `desktop.monitors` and `desktop.windows` through `computer_action`, then read their `computer_command` results. Select the actual target window and monitor.
29
33
  2. Request `desktop.snapshot` and inspect the image returned by `computer_command`. Identify controls from the current image. Coordinates use physical pixels in the monitor's global desktop coordinate space.
30
34
  3. Queue bounded actions with the current generation: focus, launch a supported application, click, drag, scroll, type, or press a key. Use observations to choose the next dependent action.
31
35
  4. Read each command until a terminal result, then take a fresh screenshot and check the expected app result. For a transaction, verify its final state, such as the saved file, submitted record, or visible deletion confirmation. Native input success establishes that the action executed; business success requires observed application evidence.
32
36
  5. A timeout or lost acknowledgement leaves the result uncertain. Inspect command status and the desktop before retrying a write. Resume from the observed state; avoid repeating a submit, payment, send, or delete whose outcome is unresolved.
33
- 6. After all operation commands finish and a final desktop or browser-tab screenshot is observed, call `computer_complete_operation` using the same `operationId`, current generation, and `completed`, `submitted`, `deleted`, or `failed`. Summarize the app result actually verified. Stop owned control when finished.
37
+ 6. After the final screenshot, queue `desktop.release {}` when you used native desktop input and wait for its terminal result. This releases the desktop focus lease so another agent can act. Browser tabs remain independent during the lease. Then call `computer_complete_operation` using the same `operationId`, current generation, and `completed`, `submitted`, `deleted`, or `failed`. Summarize the app result actually verified. Stop owned control when finished.
34
38
 
35
39
  Use the actual tool argument names and response envelope. Queue `const {command} = await computer_action({computerId, sessionId, generation, action: 'desktop.snapshot', payload: {}, operationId, summary: 'Verify the test record'})`, then read `await computer_command({computerId, commandId: command.id})`. The action response is `{command: {...}}`; take the ID from its nested `command`, while MCP clients parse the response's JSON text content. Read each action's current payload schema before constructing inputs.
36
40