screenhand 0.1.1 → 0.2.0

package/dist/src/util/atomic-write.js

@@ -0,0 +1,118 @@
+// Copyright (C) 2025 Clazro Technology Private Limited
+// SPDX-License-Identifier: AGPL-3.0-only
+//
+// This file is part of ScreenHand.
+//
+// ScreenHand is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, version 3.
+//
+// ScreenHand is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with ScreenHand. If not, see <https://www.gnu.org/licenses/>.
+/**
+ * Atomic file writes — temp file + rename to prevent corruption on crash.
+ *
+ * Also provides corrupt-file recovery: if the primary file is unreadable,
+ * falls back to the `.bak` backup created on the previous successful write.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+/**
+ * Write data atomically: write to a temp file in the same directory,
+ * then rename over the target. On POSIX, rename is atomic within the
+ * same filesystem, so readers always see either the old or new content.
+ *
+ * Also keeps a single `.bak` of the previous version for recovery.
+ */
+export function writeFileAtomicSync(filePath, data) {
+    const dir = path.dirname(filePath);
+    const tmp = path.join(dir, `.${path.basename(filePath)}.${crypto.randomBytes(4).toString("hex")}.tmp`);
+    try {
+        fs.writeFileSync(tmp, data, { mode: 0o644 });
+        // Back up current file before overwriting (ignore if it doesn't exist yet)
+        try {
+            fs.copyFileSync(filePath, filePath + ".bak");
+        }
+        catch {
+            // No existing file to back up — fine
+        }
+        fs.renameSync(tmp, filePath);
+    }
+    catch (err) {
+        // Clean up temp file on failure
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
+}
+/**
+ * Async variant — same temp+rename approach but non-blocking.
+ * Falls back to sync rename (rename is fast, effectively atomic).
+ */
+export function writeFileAtomic(filePath, data, callback) {
+    const dir = path.dirname(filePath);
+    const tmp = path.join(dir, `.${path.basename(filePath)}.${crypto.randomBytes(4).toString("hex")}.tmp`);
+    fs.writeFile(tmp, data, { mode: 0o644 }, (writeErr) => {
+        if (writeErr) {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch { /* ignore */ }
+            callback(writeErr);
+            return;
+        }
+        // Back up current file (best-effort, sync is fine for a copy)
+        try {
+            fs.copyFileSync(filePath, filePath + ".bak");
+        }
+        catch { /* ignore */ }
+        fs.rename(tmp, filePath, (renameErr) => {
+            if (renameErr) {
+                try {
+                    fs.unlinkSync(tmp);
+                }
+                catch { /* ignore */ }
+            }
+            callback(renameErr);
+        });
+    });
+}
+/**
+ * Read a JSON file with corrupt-file recovery.
+ * If the primary file fails to parse, tries the `.bak` backup.
+ * Returns the parsed object, or null if both are unreadable.
+ */
+export function readJsonWithRecovery(filePath) {
+    // Try primary file
+    const primary = tryParseJsonFile(filePath);
+    if (primary !== null)
+        return primary;
+    // Primary is missing or corrupt — try backup
+    const backup = tryParseJsonFile(filePath + ".bak");
+    if (backup !== null) {
+        // Restore backup as primary so next read is fast
+        try {
+            fs.copyFileSync(filePath + ".bak", filePath);
+        }
+        catch { /* ignore */ }
+        return backup;
+    }
+    return null;
+}
+function tryParseJsonFile(filePath) {
+    try {
+        const data = fs.readFileSync(filePath, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/test-mcp-protocol.js

@@ -0,0 +1,138 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, "..");
+const tsxBin = path.join(projectRoot, "node_modules", ".bin", "tsx");
+const TIMEOUT_MS = 10_000;
+const proc = spawn(tsxBin, [path.join(projectRoot, "src/mcp-entry.ts")], {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: { ...process.env, SCREENHAND_ADAPTER: "placeholder" },
+    cwd: projectRoot,
+});
+let stderrBuf = "";
+proc.stderr.on("data", (d) => { stderrBuf += d.toString(); });
+// MCP SDK v1.27 uses newline-delimited JSON (NDJSON), not Content-Length framing
+function send(msg) {
+    proc.stdin.write(JSON.stringify(msg) + "\n");
+}
+const rl = createInterface({ input: proc.stdout });
+const lineQueue = [];
+let lineWaiter = null;
+rl.on("line", (line) => {
+    if (lineWaiter) {
+        const w = lineWaiter;
+        lineWaiter = null;
+        w(line);
+    }
+    else {
+        lineQueue.push(line);
+    }
+});
+function readResponse() {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            lineWaiter = null;
+            reject(new Error(`Timeout. stderr: ${stderrBuf.slice(-300)}`));
+        }, TIMEOUT_MS);
+        const handle = (line) => {
+            clearTimeout(timer);
+            resolve(JSON.parse(line));
+        };
+        const queued = lineQueue.shift();
+        if (queued) {
+            clearTimeout(timer);
+            resolve(JSON.parse(queued));
+        }
+        else {
+            lineWaiter = handle;
+        }
+    });
+}
+function fail(msg) {
+    console.error("FAIL:", msg);
+    proc.kill();
+    process.exit(1);
+}
+try {
+    // Wait for server to start
+    await new Promise((r) => setTimeout(r, 2000));
+    // 1. Initialize
+    console.log("Sending initialize...");
+    send({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "initialize",
+        params: {
+            protocolVersion: "2024-11-05",
+            capabilities: {},
+            clientInfo: { name: "test-client", version: "1.0" },
+        },
+    });
+    const initResp = await readResponse();
+    const initResult = initResp.result;
+    if (!initResult)
+        fail(`No init result: ${JSON.stringify(initResp)}`);
+    console.log("=== Initialize ===");
+    console.log(`  Protocol: ${initResult.protocolVersion}`);
+    console.log(`  Server: ${JSON.stringify(initResult.serverInfo)}`);
+    // 2. Send initialized notification
+    send({ jsonrpc: "2.0", method: "notifications/initialized" });
+    await new Promise((r) => setTimeout(r, 300));
+    // 3. List tools
+    console.log("\nListing tools...");
+    send({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} });
+    const toolsResp = await readResponse();
+    const toolsResult = toolsResp.result;
+    if (!toolsResult)
+        fail(`No tools result: ${JSON.stringify(toolsResp)}`);
+    const tools = toolsResult.tools ?? [];
+    console.log("=== Tools ===");
+    for (const tool of tools) {
+        console.log(`  ${tool.name}: ${(tool.description ?? "").slice(0, 70)}`);
+    }
+    console.log(`\n  Total: ${tools.length} tools`);
+    if (tools.length < 10)
+        fail(`Expected 16 tools, got ${tools.length}`);
+    // 4. Test session_start
+    console.log("\nCalling session_start...");
+    send({
+        jsonrpc: "2.0",
+        id: 3,
+        method: "tools/call",
+        params: { name: "session_start", arguments: {} },
+    });
+    const sessionResp = await readResponse();
+    const sessionResult = sessionResp.result;
+    if (!sessionResult)
+        fail(`No session result: ${JSON.stringify(sessionResp)}`);
+    const sessionContent = sessionResult.content;
+    const sessionData = JSON.parse(sessionContent?.[0]?.text ?? "{}");
+    console.log("=== session_start ===");
+    console.log(`  Session ID: ${sessionData.sessionId}`);
+    console.log(`  Profile: ${sessionData.profile}`);
+    if (!sessionData.sessionId)
+        fail("No sessionId returned");
+    // 5. Test app_list (should work with placeholder)
+    console.log("\nCalling app_list...");
+    send({
+        jsonrpc: "2.0",
+        id: 4,
+        method: "tools/call",
+        params: { name: "app_list", arguments: { sessionId: sessionData.sessionId } },
+    });
+    const appResp = await readResponse();
+    const appResult = appResp.result;
+    console.log("=== app_list ===");
+    const appContent = appResult?.content;
+    const isError = appResult?.isError;
+    console.log(`  isError: ${isError ?? false}`);
+    console.log(`  Response: ${(appContent?.[0]?.text ?? "").slice(0, 100)}`);
+    proc.kill();
+    console.log("\nAll tests passed!");
+    process.exit(0);
+}
+catch (e) {
+    fail(e instanceof Error ? e.message : String(e));
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,18 +1,32 @@
 {
   "name": "screenhand",
-  "version": "0.1.1",
+  "version": "0.2.0",
+  "mcpName": "io.github.manushi4/screenhand",
   "description": "Give AI eyes and hands on your desktop. ScreenHand is an open-source MCP server that lets Claude and other AI agents see your screen, click buttons, type text, and control any app on macOS and Windows.",
   "homepage": "https://screenhand.com",
   "type": "module",
+  "bin": {
+    "screenhand": "dist/mcp-desktop.js",
+    "screenhand-agent": "dist/src/agent/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
-    "dev": "tsx src/index.ts",
+    "dev": "tsx mcp-desktop.ts",
+    "dev:modular": "tsx src/mcp-entry.ts",
     "build": "tsc -p tsconfig.json",
     "check": "tsc --noEmit -p tsconfig.check.json",
-    "start": "node dist/index.js",
+    "start": "node dist/mcp-desktop.js",
+    "agent": "tsx src/agent/cli.ts",
     "build:native": "cd native/macos-bridge && swift build -c release",
     "build:native:windows": "cd native/windows-bridge && dotnet build -c Release",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "codex:monitor": "tsx scripts/codex-monitor-daemon.ts",
+    "codex:watch": "node scripts/vscode-codex-watch.mjs"
   },
   "repository": {
     "type": "git",

package/.claude/commands/automate.md

@@ -1,28 +0,0 @@
-Automate a desktop workflow described by the user.
-
-The user will describe what they want done: $ARGUMENTS
-
-Plan and execute the workflow step by step using the desktop automation MCP tools:
-
-## Planning
-1. Break the task into discrete steps
-2. Identify which apps are involved (`apps`, `windows`)
-3. For each step, pick the FASTEST approach — try them in this order:
-   - **Accessibility (FASTEST — always try first)**: `ui_tree` → `ui_find` → `ui_press` / `ui_set_value`. ~50ms per action, no screenshots.
-   - **Keyboard shortcuts**: `key` for known shortcuts (cmd+s, cmd+c, etc.) — instant
-   - **AppleScript**: `applescript` for scriptable apps (Finder, Mail, Notes) — fast
-   - **Chrome CDP**: `browser_dom` → `browser_click` / `browser_type` — direct DOM, no vision
-   - **Visual (LAST RESORT only)**: `screenshot` → `click_text` — slow, only when Accessibility can't see the element (canvas, games, images)
-
-IMPORTANT: Do NOT use screenshot/OCR/click_text to interact with standard UI elements. Use ui_tree + ui_press instead — it's 10x faster and more reliable.
-
-## Execution
-- Execute each step, verifying success before moving to the next
-- After key actions, use `screenshot` or `ui_tree` to confirm the expected state
-- If a step fails, try an alternative approach before giving up
-- Report progress as you go
-
-## Completion
-- Summarize what was done
-- Note any steps that required fallbacks
-- Flag anything that didn't work as expected

package/.claude/commands/debug-ui.md

@@ -1,19 +0,0 @@
-Inspect and debug the UI structure of an app.
-
-1. Use `apps` to list running applications
-2. If the user specified an app name ($ARGUMENTS), find its PID. Otherwise use the frontmost app.
-3. Use `focus` to bring the app to the front
-4. Use `ui_tree` with the app's PID to get the full Accessibility tree
-5. Use `windows` to get the window bounds
-
-Then analyze and report:
-- App name and bundle ID
-- Window hierarchy and layout
-- Interactive elements (buttons, text fields, menus) with their states (enabled/disabled, value)
-- Navigation structure
-- Any elements that look broken or inaccessible
-- Suggested selectors for automating key actions (titles to use with `ui_press`, `ui_find`)
-
-Format as a structured report with sections.
-
-$ARGUMENTS

package/.claude/commands/screenshot.md

@@ -1,15 +0,0 @@
-Take a screenshot of the current screen and describe what you see.
-
-1. Use the `screenshot` MCP tool to capture the screen and OCR it
-2. Use `apps` to identify which apps are running
-3. Use `windows` to see window positions
-
-Then provide a clear summary:
-- What apps are visible
-- What the user appears to be doing
-- Key UI elements and text on screen
-- Any notable state (dialogs open, errors visible, etc.)
-
-If the user provides an app name as argument, focus on that app: use `focus` to bring it forward first, then screenshot.
-
-$ARGUMENTS

package/.github/FUNDING.yml

@@ -1 +0,0 @@
-github: manushi4

package/.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,27 +0,0 @@
----
-name: Bug Report
-about: Report a bug in ScreenHand
-title: "[Bug] "
-labels: bug
----
-
-**Platform**
-- [ ] macOS
-- [ ] Windows
-
-**Describe the bug**
-A clear description of what went wrong.
-
-**To reproduce**
-1. Tool called: `...`
-2. Parameters: `...`
-3. Error/unexpected output: `...`
-
-**Expected behavior**
-What you expected to happen.
-
-**Environment**
-- OS version:
-- Node.js version:
-- ScreenHand version:
-- AI client (Claude Desktop / Claude Code / Cursor / other):

package/.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature Request
-about: Suggest a new tool or improvement for ScreenHand
-title: "[Feature] "
-labels: enhancement
----
-
-**What problem does this solve?**
-Describe the use case.
-
-**Proposed solution**
-How should it work? What MCP tool name/parameters would you expect?
-
-**Alternatives considered**
-Any workarounds you've tried.
-
-**Platform**
-- [ ] macOS
-- [ ] Windows
-- [ ] Both

package/.mcp.json

@@ -1,8 +0,0 @@
-{
-  "mcpServers": {
-    "desktop": {
-      "command": "npx",
-      "args": ["tsx", "mcp-desktop.ts"]
-    }
-  }
-}

package/DESKTOP_MCP_GUIDE.md

@@ -1,92 +0,0 @@
-# ScreenHand MCP — Usage Guide
-
-You have access to the ScreenHand MCP server that can control any macOS/Windows application and Chrome browser. Use it for app debugging, design inspection, UI testing, and automation.
-
-## Quick Reference
-
-### How to discover what's on screen
-1. `apps` → get running apps with PIDs
-2. `windows` → get window IDs and positions
-3. `ui_tree(pid, maxDepth)` → get full UI structure instantly (50ms, no OCR)
-4. `screenshot(windowId)` → capture + OCR a window (600ms, use when you need visual text)
-
-### How to interact with native macOS apps (Finder, Notes, Xcode, etc.)
-- **Read UI structure**: `ui_tree(pid=1234, maxDepth=4)` — returns every button, menu, text field with positions
-- **Find element**: `ui_find(pid=1234, title="Save")` — find by text
-- **Click element**: `ui_press(pid=1234, title="Save")` — click by accessibility
-- **Click menu**: `menu_click(pid=1234, menuPath="File/Save As...")` — click any menu item
-- **Set text**: `ui_set_value(pid=1234, title="Search", value="hello")`
-- **Key combo**: `key(combo="cmd+s")` or `key(combo="cmd+shift+n")`
-
-### How to interact with Chrome/web pages (FAST — use this, not OCR)
-- **List tabs**: `browser_tabs()`
-- **Open URL**: `browser_open(url="https://example.com")`
-- **Run JS**: `browser_js(code="document.title")` — execute any JavaScript, returns result
-- **Query DOM**: `browser_dom(selector="button.primary")` — find elements with text, positions, attributes
-- **Click element**: `browser_click(selector="#submit-btn")`
-- **Type in input**: `browser_type(selector="input[name=search]", text="hello")`
-- **Wait for load**: `browser_wait(condition="document.querySelector('.results')")`
-- **Page content**: `browser_page_info()` — title, URL, text content
-
-### How to use AppleScript
-- `applescript(script='tell application "Finder" to get name of every file of desktop')`
-- `applescript(script='tell application "Safari" to set URL of current tab of front window to "https://google.com"')`
-
-## Rules & Best Practices
-
-### Speed hierarchy — always prefer the fastest method:
-1. **Accessibility (ui_tree, ui_press, menu_click)** — 50ms, structured, reliable. Use for ALL native app interactions.
-2. **CDP (browser_js, browser_dom, browser_click)** — 10ms, structured. Use for ALL web/browser interactions.
-3. **AppleScript** — 50ms, for app-specific scripting (Finder files, Safari URLs, Mail compose).
-4. **OCR (screenshot, click_text)** — 600ms, last resort. Only use when AX and CDP aren't available.
-
-### For app debugging:
-- Start with `apps` to find the PID
-- Use `ui_tree(pid, maxDepth=4)` to see the full UI hierarchy — every button, text field, label, with positions
-- Use `ui_tree(pid, maxDepth=6)` for deep inspection of complex views
-- Use `screenshot(windowId)` only when you need to see actual rendered text/images
-
-### For design inspection:
-- `screenshot_file(windowId)` returns the image path — you can read it to see the actual design
-- `ui_tree` shows the component structure (like React DevTools but for any app)
-- `browser_dom(selector="*")` with limit shows the DOM tree of any web page
-- `browser_js` can extract computed styles: `getComputedStyle(el).color`
-
-### For web app debugging:
-- Use `browser_js` to run any debugging code — console.log, inspect state, check network
-- Use `browser_dom` to find elements and their properties
-- Use `browser_wait` before interacting with dynamic content
-- Chain: `browser_navigate` → `browser_wait` → `browser_dom` → `browser_click`
-
-### Common patterns:
-
-**Debug a native app's UI:**
-```
-apps → find pid
-ui_tree(pid, 4) → see structure
-ui_find(pid, "button text") → locate element
-ui_press(pid, "button text") → interact
-```
-
-**Debug a web page:**
-```
-browser_tabs → find the tab
-browser_dom("main", tabId) → see page structure
-browser_js("document.querySelector('.error')?.textContent", tabId) → inspect
-```
-
-**Automate a flow:**
-```
-launch(bundleId) → open app
-ui_tree(pid, 3) → understand layout
-menu_click(pid, "File/New") → trigger action
-ui_set_value(pid, "Name", "test") → fill form
-ui_press(pid, "Save") → submit
-```
-
-### Important notes:
-- Chrome must be running with `--remote-debugging-port=9222 --user-data-dir=/tmp/chrome-debug` for browser_* tools
-- PIDs change when apps restart — always call `apps` first to get current PIDs
-- Window IDs change when windows are recreated — call `windows` to get current IDs
-- `ui_tree` requires Accessibility permissions (System Settings → Privacy → Accessibility)
-- For clicking by coordinates, use `click(x, y)` — coordinates are screen-absolute

package/SECURITY.md

@@ -1,44 +0,0 @@
-# Security Policy
-
-## Overview
-
-ScreenHand is a desktop automation tool with significant system access. We take security seriously.
-
-## What ScreenHand Can Access
-
-- **Screen content** via screenshots and OCR
-- **UI elements** via native Accessibility APIs (macOS) / UI Automation (Windows)
-- **Keyboard and mouse** input simulation
-- **Chrome browser** tabs via DevTools Protocol (requires Chrome launched with debug port)
-- **AppleScript** execution (macOS only)
-
-## What ScreenHand Cannot Do
-
-- ScreenHand does **not** send screen data or any information to external servers
-- It does **not** access browser cookies, passwords, or stored credentials
-- It does **not** run with elevated/admin privileges
-- It does **not** modify system settings or install background services
-- It does **not** communicate with any remote server (all operations are local)
-
-## Permissions Required
-
-### macOS
-- **Accessibility permission**: System Settings > Privacy & Security > Accessibility > enable your terminal app
-- This is a standard macOS requirement for any app that reads UI elements or simulates input
-
-### Windows
-- No special permissions needed — UI Automation works without admin for most applications
-
-## Audit Logging
-
-All tool calls are logged to `.audit-log.jsonl` with timestamps. This file is gitignored by default and stays on your machine.
-
-## Reporting a Vulnerability
-
-If you discover a security vulnerability, please email **security@screenhand.com** instead of opening a public issue.
-
-We will acknowledge receipt within 48 hours and aim to provide a fix within 7 days for critical issues.
-
-## Responsible Use
-
-ScreenHand is designed for legitimate automation, testing, and productivity use cases. Users are responsible for ensuring their use complies with applicable laws and the terms of service of any applications they automate.

package/docs/architecture.md

@@ -1,47 +0,0 @@
-# MVP Architecture
-
-## Design Goals
-- Fast execution by keeping session and context persistent.
-- Predictable completion by hard action budgets.
-- No infinite loops: each tool call returns success or structured failure.
-- LLM plans high-level intent; runtime handles micro-logic.
-
-## Layers
-1. `MCP Server Layer`
-- Accepts tool requests (`session_start`, `navigate`, `press`, `type_into`, `wait_for`, `extract`, `screenshot`).
-- Validates args and forwards to runtime service.
-
-2. `Runtime Service Layer`
-- Orchestrates session manager, executor, adapter, logging, and cache.
-- Converts low-level errors into structured failure payloads.
-
-3. `Executor Layer`
-- Runs bounded state machine for action tools:
-  - locate (cached first, fallback strategy)
-  - act
-  - verify
-  - optional retry
-- Enforces per-step time budgets.
-
-4. `Browser Adapter Layer`
-- Thin contract for browser operations.
-- Current scaffold uses a placeholder adapter; later replace with CDP or Playwright robot-mode adapter.
-
-## Core Runtime Flow
-1. `session_start(profile)` ensures a persistent session ID.
-2. `navigate(url)` completes within timeout and returns url/title.
-3. `press` / `type_into` run bounded loop with max retries.
-4. `wait_for(condition)` waits only for explicit UI conditions.
-5. `extract(target, format)` returns structured data.
-6. On failure, return structured diagnostics + timings.
-
-## Key Data Contracts
-- `ActionBudget`: `locateMs`, `actMs`, `verifyMs`, `maxRetries`.
-- `ActionTelemetry`: per-action timing + retry count + status.
-- `RuntimeError`: error code, attempts, page meta, and cause.
-
-## Next Implementation Phase
-- Harden the current CDP adapter with richer locator heuristics and cleanup hooks.
-- Add locator strategy expansion (role/text/selector priority + fuzzy fallback).
-- Persist locator cache per site/action.
-- Wire transport for actual MCP protocol endpoint.

package/install-skills.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-# Install ScreenHand skills globally for Claude Code
-# Usage: ./install-skills.sh
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-TARGET="$HOME/.claude/commands"
-
-mkdir -p "$TARGET"
-
-cp "$SCRIPT_DIR/.claude/commands/screenshot.md" "$TARGET/desktop-screenshot.md"
-cp "$SCRIPT_DIR/.claude/commands/debug-ui.md" "$TARGET/desktop-debug-ui.md"
-cp "$SCRIPT_DIR/.claude/commands/automate.md" "$TARGET/desktop-automate.md"
-
-echo "Installed skills to $TARGET:"
-echo "  /desktop-screenshot  — capture and describe your screen"
-echo "  /desktop-debug-ui    — inspect any app's UI tree"
-echo "  /desktop-automate    — automate a multi-step workflow"
-echo ""
-echo "These are now available globally in any Claude Code session."