运行时脚本与 API 文档

Aitiy 内置了一个轻量、强悍的本地 JavaScript 运行环境 (Runtime)。它通过微软 WebView2 提供支持，并与 Aitiy 的 C++ 原生核心保持高效的双向通信。

这使得用户可以编写简单的 JavaScript 代码来完全自定义手势轨迹、快捷键和选中文本工具栏的交互动作。借助本地 Runtime，你的鼠标将不仅能触发预设快捷键，还能执行高度灵活的宏脚本和外部工作流！

本地优先与安全

Aitiy Runtime 的所有脚本与执行完全在您的本机进行，绝不依赖云端。我们确保您的输入数据与脚本隐私保持 100% 本地化。

编写自定义脚本

在 Aitiy 设置面板中（如「手势设置」、「选中文本工具栏」或「全局热键」），将动作类型切换为 「自定义动作脚本」 即可开始编写 JavaScript 代码。

执行原理

您编写的所有脚本在被执行时，都会被自动封装进一个异步立即执行函数表达式 (Async IIFE) 中：

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // 自动注入的当前动作上下文
  
  // ============================
  // 您在设置中编写的 JS 代码将会放在这里：
  // ============================
  
})();

这意味着您可以在代码中直接使用 await 关键字来调用各种 Promise 异步 API（例如 await runtime.getClipboardText()）。

两大核心全局变量

context (或 window.__aitiy_action_context)：包含执行动作那一瞬间的桌面状态（比如鼠标起始位置、前台应用名称、选中的文本等）。
runtime (或 window.runtime)：包含了与原生 C++ 进行通信的核心控制接口。

动作上下文 (Action Context)

当手势、热键或工具栏触发时，原生侧会捕获当下的环境状态并注入到脚本作用域中，使您可以通过全局变量 context 属性直接读取这些数据：

属性名	类型	说明 / 描述
tempstr	`string`	当前选中的文本内容（常用于选中文本工具栏动作）。
filepath	`string`	当前焦点窗口所在应用的完整文件路径（如 `C:\Windows\notepad.exe`）。
filename	`string`	当前焦点应用的可执行文件名（如 `notepad.exe`）。
hwnd	`number`	触发动作时处于前台的窗口句柄 (HWND)。
window_title	`string`	触发动作时的窗口标题名。
window_class	`string`	触发动作时的窗口 Class 名称。
start_x, start_y	`number`	手势动作绘制时的起点屏幕物理坐标。
end_x, end_y	`number`	手势动作绘制结束（或热键触发时）的屏幕物理坐标。
rect	`object`	前台窗口的边框范围：`{left, top, right, bottom, w, h}`。
snapshot_rect	`object`	仅截图动作下可用，当前圈选的截图范围坐标：`{x, y, w, h}`。

运行时 API 参考 (Runtime APIs)

通过全局 runtime 变量，您可以调用以下方法来与 Windows 系统或 Aitiy 主窗口进行深度交互。

1. 进程执行与命令运行

runtime.execute(path, args, options)

启动一个外部程序，运行一个 shell 命令，或者打开一个网页链接。

方式一：直接运行命令字符串

JavaScript

// 打开记事本并加载特定的日志文件
runtime.execute("notepad.exe C:\\log.txt");

// 直接在默认浏览器中打开指定网页
runtime.execute("https://github.com");

方式二：通过配置对象精确控制参数

JavaScript

// 以管理员权限静默运行批处理脚本
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // 以管理员运行 (RunAs)
  hide: true,   // 隐藏控制台窗口
  wait: false   // 不阻塞脚本，后台运行
});

执行参数动态替换占位符

在 runtime.execute 传入的路径与参数字符串中，你可以直接使用特定的占位符，运行时会自动替换：
%tempstr% 替换为选中文本；%clipboard% 替换为当前剪贴板文本；%filepath% / %filename% 替换为当前窗口关联的程序路径；还支持系统环境变量（如 %TEMP%, %USERPROFILE%）。

2. 模拟按键和鼠标输入

runtime.sendKeys(keysStr)

模拟发出键盘组合键。多个键通过 + 进行拼接。

JavaScript

// 模拟按下 Ctrl+Alt+Tab 呼出系统多窗口视图
runtime.sendKeys("CTRL+ALT+TAB");

// 模拟按下 Windows徽标键+D 显示桌面
runtime.sendKeys("WIN+D");

// 发送常规字母键与功能键
runtime.sendKeys("CTRL+SHIFT+T"); // 恢复最近关闭的浏览器标签页

支持的虚拟按键列表：

修饰键：CTRL/CONTROL, SHIFT, ALT/MENU, WIN/WINDOWS
动作/导航键：ESC/ESCAPE, TAB, ENTER/RETURN, SPACE, BACKSPACE, DEL/DELETE, INS/INSERT, HOME, END, PAGEUP/PGUP, PAGEDOWN/PGDN
方向键：UP, DOWN, LEFT, RIGHT
多媒体导航：BACK (浏览器后退), FORWARD (浏览器前进), PRTSC/PRINTSCREEN
功能键：F1 至 F24
常规键：单字符（如 A, B, 1, 2 等）

runtime.sendClick(button)

模拟点击鼠标按键。参数 button 可选 "left" (默认), "right", "middle"。

runtime.mouseMove(x, y)

移动鼠标指针。x, y 可以是具体的屏幕物理坐标数值，或指定特殊值 "start" 代表手势起始处的坐标点（如 runtime.mouseMove("start start")）。

3. 截图与剪贴板控制

runtime.screenshot(mode, options)

触发截图。mode 可以是 "ocr" (截图后立即OCR识别)，"pin" (截图后立即贴图)，或者 "croplock" (锁定矩形截图)。

runtime.setClipboardText(text)

将纯文本写入系统剪贴板。

await runtime.getClipboardText()

(异步) 获取系统剪贴板中当前的文本内容。

4. 窗口管理器与系统接口

API 方法	返回类型	描述
`runtime.window.close()`	`void`	关闭当前的焦点窗口。
`runtime.window.maximize()`	`void`	最大化当前的焦点窗口。
`runtime.window.minimize()`	`void`	最小化当前的焦点窗口。
`runtime.window.setTopmost(enable)`	`void`	设置焦点窗口是否置顶显示 (传入 `true` 或 `false`)。
`runtime.window.closeSimilar()`	`void`	关闭相同应用的其他同类窗口。
`runtime.window.hideToTray()`	`void`	将当前窗口最小化隐藏到系统托盘区。
`runtime.internal.showSettings()`	`void`	呼出 Aitiy 本身的设置面板窗口。
`runtime.internal.togglePause()`	`void`	暂停或恢复 Aitiy 对全局手势与快捷键的捕获。
`runtime.internal.getSelection()`	`string`	内部发出 Ctrl+C 自动提取前台选中文本并直接返回，不污染您原有的剪贴板。
`runtime.system.setBrightness(val)`	`void`	调节系统屏幕亮度（`val` 范围为 `0` 至 `100`）。

实用动作脚本示例

下面为您提供了几个在日常办公中非常实用的脚本模板，您可直接复制到设置面板中进行调试。

示例一：在 Google 中搜索鼠标选中的文本

适合放置于：「选中文本工具栏」自定义动作。

JavaScript

// 检查选中内容是否为空
if (context.tempstr && context.tempstr.trim().length > 0) {
  // 直接以带有选中词汇的 URL 运行默认浏览器
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

示例二：一键将选中的文件备份到 D 盘备份夹

适合放置于：「鼠标手势」或者「全局热键」。

JavaScript

// 我们通过 clipboard 取得当前在资源管理器中选中的文件路径
const path = await runtime.getClipboardText();
if (path) {
  runtime.execute({
    path: "powershell.exe",
    args: `-NoProfile -Command "Copy-Item '${path}' -Destination 'D:\\Backup\\' -Force"`,
    hide: true
  });
}

示例三：复制选中内容，静默运行翻译接口并贴图显示

适合放置于：「选中文本工具栏」。

JavaScript

// 提取选中字符
const text = context.tempstr;
if (text) {
  // 先把文本保存回剪贴板，随后触发 OCR 识别/贴图
  runtime.setClipboardText("Translate result for: " + text);
  runtime.screenshot("pin");
}

執行階段指令碼與 API 文件

Aitiy 內建了一個輕量、強大的本地 JavaScript 執行環境 (Runtime)。它透過微軟 WebView2 提供支援，並與 Aitiy 的 C++ 原生核心保持高效的雙向通訊。

這讓使用者可以編寫簡單的 JavaScript 程式碼，完全自訂手勢軌跡、快速鍵和選取文字工具列的互動動作。借助本地 Runtime，你的滑鼠不僅能觸發預設快速鍵，還能執行高度靈活的巨集指令碼和外部工作流程！

本地優先與安全

Aitiy Runtime 的所有指令碼與執行完全在您的本機進行，絕不依賴雲端。我們確保您的輸入資料與指令碼隱私保持 100% 本地化。

編寫自訂指令碼

在 Aitiy 設定面板中（如「手勢設定」、「選取文字工具列」或「全域快速鍵」），將動作類型切換為 「自訂動作指令碼」 即可開始編寫 JavaScript 程式碼。

執行原理

您編寫的所有指令碼在執行時，都會被自動封裝進一個非同步立即執行函式運算式 (Async IIFE) 中：

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // 自動注入的當前動作上下文
  
  // ============================
  // 您在設定中編寫的 JS 程式碼將會放在這裡：
  // ============================
  
})();

這意味著您可以在程式碼中直接使用 await 關鍵字來呼叫各種 Promise 非同步 API（例如 await runtime.getClipboardText()）。

兩大核心全域變數

context (或 window.__aitiy_action_context)：包含執行動作那一瞬間的桌面狀態（例如滑鼠起始位置、前景應用名稱、選取的文字等）。
runtime (或 window.runtime)：包含了與原生 C++ 進行通訊的核心控制介面。

動作上下文 (Action Context)

當手勢、快速鍵或工具列觸發時，原生端會擷取當下的環境狀態並注入到指令碼作用域中，讓您可以透過全域變數 context 屬性直接讀取這些資料：

屬性名	型別	說明 / 描述
tempstr	`string`	目前選取的文字內容（常用於選取文字工具列動作）。
filepath	`string`	目前焦點視窗所在應用的完整檔案路徑（如 `C:\Windows\notepad.exe`）。
filename	`string`	目前焦點應用的可執行檔案名稱（如 `notepad.exe`）。
hwnd	`number`	觸發動作時位於前景的視窗控制代碼 (HWND)。
window_title	`string`	觸發動作時的視窗標題名稱。
window_class	`string`	觸發動作時的視窗 Class 名稱。
start_x, start_y	`number`	手勢動作繪製時的起點螢幕物理座標。
end_x, end_y	`number`	手勢動作繪製結束（或快速鍵觸發時）的螢幕物理座標。
rect	`object`	前景視窗的邊框範圍：`{left, top, right, bottom, w, h}`。
snapshot_rect	`object`	僅截圖動作下可用，目前圈選的截圖範圍座標：`{x, y, w, h}`。

執行階段 API 參考 (Runtime APIs)

透過全域 runtime 變數，您可以呼叫以下方法與 Windows 系統或 Aitiy 主視窗進行深度互動。

1. 處理程序執行與命令執行

runtime.execute(path, args, options)

啟動一個外部程式、執行一個 shell 命令，或開啟一個網頁連結。

方式一：直接執行命令字串

JavaScript

// 開啟記事本並載入特定的記錄檔
runtime.execute("notepad.exe C:\\log.txt");

// 直接在預設瀏覽器中開啟指定網頁
runtime.execute("https://github.com");

方式二：透過設定物件精確控制參數

JavaScript

// 以系統管理員權限靜默執行批次指令碼
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // 以系統管理員執行 (RunAs)
  hide: true,   // 隱藏主控台視窗
  wait: false   // 不封鎖指令碼，背景執行
});

執行參數動態替換預留位置

在 runtime.execute 傳入的路徑與參數字串中，你可以直接使用特定的預留位置，執行階段會自動替換：
%tempstr% 替換為選取文字；%clipboard% 替換為目前剪貼簿文字；%filepath% / %filename% 替換為目前視窗關聯的程式路徑；還支援系統環境變數（如 %TEMP%, %USERPROFILE%）。

2. 模擬按鍵和滑鼠輸入

runtime.sendKeys(keysStr)

模擬發出鍵盤組合鍵。多個鍵透過 + 進行拼接。

JavaScript

// 模擬按下 Ctrl+Alt+Tab 呼叫系統多視窗檢視
runtime.sendKeys("CTRL+ALT+TAB");

// 模擬按下 Windows 標誌鍵+D 顯示桌面
runtime.sendKeys("WIN+D");

// 傳送一般字母鍵與功能鍵
runtime.sendKeys("CTRL+SHIFT+T"); // 復原最近關閉的瀏覽器標籤頁

支援的虛擬按鍵清單：

修飾鍵：CTRL/CONTROL, SHIFT, ALT/MENU, WIN/WINDOWS
動作/導覽鍵：ESC/ESCAPE, TAB, ENTER/RETURN, SPACE, BACKSPACE, DEL/DELETE, INS/INSERT, HOME, END, PAGEUP/PGUP, PAGEDOWN/PGDN
方向鍵：UP, DOWN, LEFT, RIGHT
多媒體導覽：BACK (瀏覽器後退), FORWARD (瀏覽器前進), PRTSC/PRINTSCREEN
功能鍵：F1 至 F24
一般鍵：單一字元（如 A, B, 1, 2 等）

runtime.sendClick(button)

模擬點選滑鼠按鍵。參數 button 可選 "left" (預設), "right", "middle"。

runtime.mouseMove(x, y)

移動滑鼠指標。x, y 可以是具體的螢幕物理座標數值，或指定特殊值 "start" 代表手勢起始處的座標點（如 runtime.mouseMove("start start")）。

3. 截圖與剪貼簿控制

runtime.screenshot(mode, options)

觸發截圖。mode 可以是 "ocr" (截圖後立即OCR辨識)，"pin" (截圖後立即貼圖)，或者 "croplock" (鎖定矩形截圖)。

runtime.setClipboardText(text)

將純文字寫入系統剪貼簿。

await runtime.getClipboardText()

(非同步) 取得系統剪貼簿中目前的文字內容。

4. 視窗管理員與系統介面

API 方法	回傳型別	描述
`runtime.window.close()`	`void`	關閉目前的焦點視窗。
`runtime.window.maximize()`	`void`	最大化目前的焦點視窗。
`runtime.window.minimize()`	`void`	最小化目前的焦點視窗。
`runtime.window.setTopmost(enable)`	`void`	設定焦點視窗是否置頂顯示 (傳入 `true` 或 `false`)。
`runtime.window.closeSimilar()`	`void`	關閉相同應用的其他同類視窗。
`runtime.window.hideToTray()`	`void`	將目前視窗最小化隱藏到系統通知區域。
`runtime.internal.showSettings()`	`void`	呼叫 Aitiy 本身的設定面板視窗。
`runtime.internal.togglePause()`	`void`	暫停或復原 Aitiy 對全域手勢與快速鍵的擷取。
`runtime.internal.getSelection()`	`string`	內部發出 Ctrl+C 自動提取前景選取文字並直接回傳，不汙染您原有的剪貼簿。
`runtime.system.setBrightness(val)`	`void`	調節系統螢幕亮度（`val` 範圍為 `0` 至 `100`）。

實用動作指令碼範例

下面為您提供了幾個在日常辦公中非常實用的指令碼範本，您可直接複製到設定面板中進行偵錯。

範例一：在 Google 中搜尋滑鼠選取的文字

適合放置於：「選取文字工具列」自訂動作。

JavaScript

// 檢查選取內容是否為空
if (context.tempstr && context.tempstr.trim().length > 0) {
  // 直接以帶有選取詞彙的 URL 執行預設瀏覽器
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

範例二：一鍵將選取的檔案備份到 D 碟備份資料夾

適合放置於：「滑鼠手勢」或者「全域快速鍵」。

JavaScript

// 我們透過 clipboard 取得目前在檔案總管中選取的檔案路徑
const path = await runtime.getClipboardText();
if (path) {
  runtime.execute({
    path: "powershell.exe",
    args: `-NoProfile -Command "Copy-Item '${path}' -Destination 'D:\\Backup\\' -Force"`,
    hide: true
  });
}

範例三：複製選取內容，靜默執行翻譯介面並貼圖顯示

適合放置於：「選取文字工具列」。

JavaScript

// 提取選取字元
const text = context.tempstr;
if (text) {
  // 先把文字儲存回剪貼簿，隨後觸發 OCR 辨識/貼圖
  runtime.setClipboardText("Translate result for: " + text);
  runtime.screenshot("pin");
}

Runtime Scripts & API Documentation

Aitiy features a built-in, lightweight, and powerful local JavaScript Runtime environment. Powered by Microsoft WebView2, it communicates bi-directionally with the native C++ core of Aitiy at native performance speed.

This allows you to write simple JavaScript code snippets to customize the actions of mouse gestures, hotkeys, and the selection toolbar. With the local Runtime, you are no longer limited to executing static keystrokes, but can execute dynamic macros and automate complex tasks!

Local-First and Secure

All scripts run strictly on your local machine. No text or keystroke simulation data is ever sent to the cloud, ensuring 100% privacy for your automated tasks.

Writing Custom Scripts

In the Aitiy settings panel (e.g. Mouse Gestures, Selection Toolbar, or Hotkeys), set the Action type to "Custom Action Script" to begin coding in JavaScript.

How Scripting Works

Under the hood, every custom script you write is automatically wrapped in an asynchronous Immediately Invoked Function Expression (Async IIFE):

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // Injected current action context
  
  // ============================
  // Your custom JS code goes here:
  // ============================
  
})();

Because of this wrapper, you can freely use the await keyword directly in your script to pause execution for promises (such as reading clipboard text with await runtime.getClipboardText()).

Core Global Variables

context (also available as window.__aitiy_action_context): Contains environmental data at the moment the action was triggered (e.g., active window title, file path, current selection, coordinates).
runtime (also available as window.runtime): Exposes native C++ API endpoints to control input simulation, windows, process launching, and configuration.

Action Context Reference

The global context object exposes properties containing window state and user input context at the moment the gesture or key is invoked:

Property	Type	Description
tempstr	`string`	The highlighted/selected text (mostly populated for Selection Toolbar actions).
filepath	`string`	Absolute file path to the executable of the active window (e.g., `C:\Windows\notepad.exe`).
filename	`string`	Executable filename of the active window (e.g., `notepad.exe`).
hwnd	`number`	Window handle (HWND) of the active window.
window_title	`string`	Title text of the active window.
window_class	`string`	Win32 Window class name of the active window.
start_x, start_y	`number`	Starting cursor coordinate (in physical pixels) of the mouse gesture.
end_x, end_y	`number`	Ending cursor coordinate (in physical pixels) of the mouse gesture.
rect	`object`	Bounding rectangle coordinates of the active window: `{left, top, right, bottom, w, h}`.
snapshot_rect	`object`	Bounding rectangle of selected screenshot area if in cropping mode: `{x, y, w, h}`.

Runtime API Reference

The global runtime namespace allows you to trigger native commands, simulate inputs, and control windows.

1. Execution and Launching Processes

runtime.execute(path, args, options)

Launches an external application, shell command, or opens a web URL in the default browser.

Syntax 1: Passing a simple command string

JavaScript

// Launch Notepad and open a log file
runtime.execute("notepad.exe C:\\log.txt");

// Open a URL in the default browser
runtime.execute("https://github.com");

Syntax 2: Passing an options object

JavaScript

// Launch a batch file as admin and run it hidden
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // Launch with admin privileges
  hide: true,   // Hide the console window
  wait: false   // Async run, don't wait for exit
});

Dynamic Placeholders in Commands

Strings passed to runtime.execute automatically expand special placeholders:
%tempstr% (selected text), %clipboard% (current clipboard text), %filepath% / %filename% (executable path of active app), and system environment variables (like %TEMP%, %USERPROFILE%).

2. Key and Input Simulation

runtime.sendKeys(keysStr)

Simulates virtual keystrokes. Join multiple keys using a + character.

JavaScript

// Press Ctrl+Alt+Tab to show task view
runtime.sendKeys("CTRL+ALT+TAB");

// Press Windows key + D to show desktop
runtime.sendKeys("WIN+D");

// Press Ctrl+Shift+T to reopen browser tab
runtime.sendKeys("CTRL+SHIFT+T");

Supported Key tokens (case-insensitive):

Modifiers: CTRL / CONTROL, SHIFT, ALT / MENU, WIN / WINDOWS
Action Keys: ESC / ESCAPE, TAB, ENTER / RETURN, SPACE, BACKSPACE, DEL / DELETE, INS / INSERT, HOME, END, PAGEUP / PGUP, PAGEDOWN / PGDN
Arrows: UP, DOWN, LEFT, RIGHT
Media / Navigation: BACK (Browser back), FORWARD (Browser forward), PRTSC / PRINTSCREEN
Function Keys: F1 to F24
Standard Keys: Single alphanumeric character (e.g., A, 1, Z)

runtime.sendClick(button)

Simulates a mouse button click. The button can be "left", "right", or "middle".

runtime.mouseMove(x, y)

Moves the mouse cursor. x and y can be absolute coordinates or the string "start" (referring to the starting coordinates of the mouse gesture, e.g., runtime.mouseMove("start start")).

3. Clipboard & Screenshot

runtime.screenshot(mode, options)

Triggers screenshot capture. The optional mode parameter can be "ocr", "pin", or "croplock".

runtime.setClipboardText(text)

Writes text content directly to the system clipboard.

await runtime.getClipboardText()

(Async) Reads the current text content from the system clipboard.

4. Window Operations & System Commands

API Method	Return Type	Description
`runtime.window.close()`	`void`	Closes the currently active (focused) window.
`runtime.window.maximize()`	`void`	Maximizes the active window.
`runtime.window.minimize()`	`void`	Minimizes the active window.
`runtime.window.setTopmost(enable)`	`void`	Toggles whether the active window stays on top (pass `true` or `false`).
`runtime.window.closeSimilar()`	`void`	Closes other open windows belonging to the same application process.
`runtime.window.hideToTray()`	`void`	Minimizes the current window and hides it to the system tray.
`runtime.internal.showSettings()`	`void`	Displays the Aitiy settings panel.
`runtime.internal.togglePause()`	`void`	Pauses/resumes global keyboard hooks and gestures of Aitiy.
`runtime.internal.getSelection()`	`string`	Forces standard selection copying (Ctrl+C simulation) to retrieve selected text without corrupting the user's current clipboard.
`runtime.system.setBrightness(val)`	`void`	Sets screen brightness levels (takes an integer value between `0` and `100`).

Script Snippets & Examples

Get started quickly by copying and pasting these commonly used automation scripts.

Example 1: Search selected text on Google

Best for: "Selection Toolbar" action script.

JavaScript

if (context.tempstr && context.tempstr.trim().length > 0) {
  // Construct the search query URL and execute
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

Example 2: Open selected directory path in File Explorer

Best for: "Mouse Gestures" or "Selection Toolbar".

JavaScript

// Read selected text or clipboard as folder path
const folderPath = context.tempstr || await runtime.getClipboardText();
if (folderPath && folderPath.indexOf(":\\") !== -1) {
  runtime.execute({
    path: "explorer.exe",
    args: `/select,"${folderPath.trim()}"`
  });
}

Example 3: Double click simulation via keys

Best for: "Mouse Gestures".

JavaScript

// Simulate double left click
runtime.sendClick("left");
setTimeout(() => {
  runtime.sendClick("left");
}, 80);

Documentación de Scripts y API en Tiempo de Ejecución

Aitiy incluye un entorno de ejecución JavaScript (Runtime) local, ligero y potente. Impulsado por Microsoft WebView2, se comunica bidireccionalmente con el núcleo C++ nativo de Aitiy a velocidad de rendimiento nativo.

Esto te permite escribir fragmentos de código JavaScript simples para personalizar las acciones de los gestos del ratón, las teclas de acceso rápido y la barra de herramientas de selección. ¡Con el Runtime local, ya no estás limitado a ejecutar pulsaciones de teclas estáticas, sino que puedes ejecutar macros dinámicas y automatizar tareas complejas!

Local y Seguro

Todos los scripts se ejecutan estrictamente en tu máquina local. Ningún texto o dato de simulación de pulsaciones se envía nunca a la nube, garantizando un 100% de privacidad para tus tareas automatizadas.

Escribir Scripts Personalizados

En el panel de configuración de Aitiy (por ejemplo, Gestos del Ratón, Barra de Selección o Teclas de Acceso Rápido), establece el tipo de Acción en "Script de Acción Personalizado" para comenzar a programar en JavaScript.

Cómo Funciona el Scripting

Internamente, cada script personalizado que escribes se envuelve automáticamente en una Expresión de Función Invocada Inmediatamente Asíncrona (Async IIFE):

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // Contexto de acción actual inyectado
  
  // ============================
  // Tu código JS personalizado va aquí:
  // ============================
  
})();

Gracias a este envoltorio, puedes usar libremente la palabra clave await directamente en tu script para pausar la ejecución de promesas (como leer el texto del portapapeles con await runtime.getClipboardText()).

Variables Globales Principales

context (también disponible como window.__aitiy_action_context): Contiene datos del entorno en el momento en que se activó la acción (por ejemplo, título de la ventana activa, ruta del archivo, selección actual, coordenadas).
runtime (también disponible como window.runtime): Expone endpoints de API C++ nativa para controlar la simulación de entrada, ventanas, lanzamiento de procesos y configuración.

Referencia del Contexto de Acción

El objeto global context expone propiedades que contienen el estado de la ventana y el contexto de entrada del usuario en el momento en que se invoca el gesto o la tecla:

Propiedad	Tipo	Descripción
tempstr	`string`	El texto resaltado/seleccionado (principalmente para acciones de la Barra de Selección).
filepath	`string`	Ruta absoluta del ejecutable de la ventana activa (ej., `C:\Windows\notepad.exe`).
filename	`string`	Nombre del ejecutable de la ventana activa (ej., `notepad.exe`).
hwnd	`number`	Identificador de ventana (HWND) de la ventana activa.
window_title	`string`	Título de la ventana activa.
window_class	`string`	Nombre de clase de ventana Win32 de la ventana activa.
start_x, start_y	`number`	Coordenada inicial del cursor (en píxeles físicos) del gesto del ratón.
end_x, end_y	`number`	Coordenada final del cursor (en píxeles físicos) del gesto del ratón.
rect	`object`	Coordenadas del rectángulo delimitador de la ventana activa: `{left, top, right, bottom, w, h}`.
snapshot_rect	`object`	Rectángulo delimitador del área de captura seleccionada en modo recorte: `{x, y, w, h}`.

Referencia de la API de Runtime

El espacio de nombres global runtime te permite ejecutar comandos nativos, simular entradas y controlar ventanas.

1. Ejecución y Lanzamiento de Procesos

runtime.execute(path, args, options)

Lanza una aplicación externa, un comando de shell o abre una URL web en el navegador predeterminado.

Sintaxis 1: Pasando una cadena de comando simple

JavaScript

// Iniciar el Bloc de notas y abrir un archivo de registro
runtime.execute("notepad.exe C:\\log.txt");

// Abrir una URL en el navegador predeterminado
runtime.execute("https://github.com");

Sintaxis 2: Pasando un objeto de opciones

JavaScript

// Ejecutar un archivo por lotes como administrador en modo oculto
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // Ejecutar con privilegios de administrador
  hide: true,   // Ocultar la ventana de consola
  wait: false   // Ejecución asíncrona, no esperar a que termine
});

Marcadores de Posición Dinámicos en Comandos

Las cadenas pasadas a runtime.execute expanden automáticamente marcadores especiales:
%tempstr% (texto seleccionado), %clipboard% (texto actual del portapapeles), %filepath% / %filename% (ruta del ejecutable de la aplicación activa) y variables de entorno del sistema (como %TEMP%, %USERPROFILE%).

2. Simulación de Teclas y Entrada

runtime.sendKeys(keysStr)

Simula pulsaciones de teclas virtuales. Une varias teclas con el carácter +.

JavaScript

// Presionar Ctrl+Alt+Tab para mostrar la vista de tareas
runtime.sendKeys("CTRL+ALT+TAB");

// Presionar tecla Windows + D para mostrar el escritorio
runtime.sendKeys("WIN+D");

// Presionar Ctrl+Shift+T para reabrir pestaña del navegador
runtime.sendKeys("CTRL+SHIFT+T");

Tokens de teclas compatibles (sin distinción de mayúsculas):

Modificadores: CTRL / CONTROL, SHIFT, ALT / MENU, WIN / WINDOWS
Teclas de Acción: ESC / ESCAPE, TAB, ENTER / RETURN, SPACE, BACKSPACE, DEL / DELETE, INS / INSERT, HOME, END, PAGEUP / PGUP, PAGEDOWN / PGDN
Flechas: UP, DOWN, LEFT, RIGHT
Multimedia / Navegación: BACK (Retroceso del navegador), FORWARD (Avance del navegador), PRTSC / PRINTSCREEN
Teclas de Función: F1 a F24
Teclas Estándar: Un solo carácter alfanumérico (ej., A, 1, Z)

runtime.sendClick(button)

Simula un clic de botón del ratón. button puede ser "left", "right" o "middle".

runtime.mouseMove(x, y)

Mueve el cursor del ratón. x e y pueden ser coordenadas absolutas o la cadena "start" (refiriéndose a las coordenadas iniciales del gesto, ej., runtime.mouseMove("start start")).

3. Portapapeles y Captura de Pantalla

runtime.screenshot(mode, options)

Activa la captura de pantalla. El parámetro opcional mode puede ser "ocr", "pin" o "croplock".

runtime.setClipboardText(text)

Escribe contenido de texto directamente en el portapapeles del sistema.

await runtime.getClipboardText()

(Asíncrono) Lee el contenido de texto actual del portapapeles del sistema.

4. Operaciones de Ventana y Comandos del Sistema

Método API	Tipo de Retorno	Descripción
`runtime.window.close()`	`void`	Cierra la ventana activa actual (enfocada).
`runtime.window.maximize()`	`void`	Maximiza la ventana activa.
`runtime.window.minimize()`	`void`	Minimiza la ventana activa.
`runtime.window.setTopmost(enable)`	`void`	Alterna si la ventana activa permanece siempre visible (pasa `true` o `false`).
`runtime.window.closeSimilar()`	`void`	Cierra otras ventanas abiertas que pertenecen al mismo proceso de aplicación.
`runtime.window.hideToTray()`	`void`	Minimiza la ventana actual y la oculta en la bandeja del sistema.
`runtime.internal.showSettings()`	`void`	Muestra el panel de configuración de Aitiy.
`runtime.internal.togglePause()`	`void`	Pausa/reanuda los ganchos de teclado globales y gestos de Aitiy.
`runtime.internal.getSelection()`	`string`	Fuerza la copia de selección estándar (simulación Ctrl+C) para recuperar el texto seleccionado sin dañar el portapapeles actual del usuario.
`runtime.system.setBrightness(val)`	`void`	Establece los niveles de brillo de la pantalla (toma un valor entero entre `0` y `100`).

Fragmentos de Script y Ejemplos

Comienza rápidamente copiando y pegando estos scripts de automatización comúnmente utilizados.

Ejemplo 1: Buscar texto seleccionado en Google

Ideal para: script de acción de "Barra de Selección".

JavaScript

if (context.tempstr && context.tempstr.trim().length > 0) {
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

Ejemplo 2: Abrir ruta de directorio seleccionada en el Explorador de Archivos

Ideal para: "Gestos del Ratón" o "Barra de Selección".

JavaScript

const folderPath = context.tempstr || await runtime.getClipboardText();
if (folderPath && folderPath.indexOf(":\\") !== -1) {
  runtime.execute({
    path: "explorer.exe",
    args: `/select,"${folderPath.trim()}"`
  });
}

Ejemplo 3: Simulación de doble clic mediante teclas

Ideal para: "Gestos del Ratón".

JavaScript

runtime.sendClick("left");
setTimeout(() => {
  runtime.sendClick("left");
}, 80);

Documentação de Scripts e API de Runtime

O Aitiy possui um ambiente de execução JavaScript (Runtime) local, leve e poderoso. Alimentado pelo Microsoft WebView2, ele se comunica bidirecionalmente com o núcleo C++ nativo do Aitiy com desempenho nativo.

Isso permite que você escreva trechos simples de código JavaScript para personalizar as ações dos gestos do mouse, teclas de atalho e da barra de ferramentas de seleção. Com o Runtime local, você não está mais limitado a executar pressionamentos de tecla estáticos, mas pode executar macros dinâmicas e automatizar tarefas complexas!

Local e Seguro

Todos os scripts são executados estritamente na sua máquina local. Nenhum texto ou dado de simulação de teclas é enviado para a nuvem, garantindo 100% de privacidade para suas tarefas automatizadas.

Escrevendo Scripts Personalizados

No painel de configurações do Aitiy (por exemplo, Gestos do Mouse, Barra de Seleção ou Teclas de Atalho), defina o tipo de Ação como "Script de Ação Personalizado" para começar a programar em JavaScript.

Como o Script Funciona

Internamente, cada script personalizado que você escreve é automaticamente envolvido em uma Expressão de Função Invocada Imediatamente Assíncrona (Async IIFE):

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // Contexto de ação atual injetado
  
  // ============================
  // Seu código JS personalizado vai aqui:
  // ============================
  
})();

Graças a esse envoltório, você pode usar livremente a palavra-chave await diretamente no seu script para pausar a execução de promessas (como ler o texto da área de transferência com await runtime.getClipboardText()).

Variáveis Globais Principais

context (também disponível como window.__aitiy_action_context): Contém dados ambientais no momento em que a ação foi acionada (por exemplo, título da janela ativa, caminho do arquivo, seleção atual, coordenadas).
runtime (também disponível como window.runtime): Expõe endpoints da API C++ nativa para controlar simulação de entrada, janelas, inicialização de processos e configuração.

Referência do Contexto da Ação

O objeto global context expõe propriedades contendo o estado da janela e o contexto de entrada do usuário no momento em que o gesto ou tecla é invocado:

Propriedade	Tipo	Descrição
tempstr	`string`	O texto destacado/selecionado (principalmente para ações da Barra de Seleção).
filepath	`string`	Caminho absoluto do executável da janela ativa (ex., `C:\Windows\notepad.exe`).
filename	`string`	Nome do executável da janela ativa (ex., `notepad.exe`).
hwnd	`number`	Identificador da janela (HWND) da janela ativa.
window_title	`string`	Título da janela ativa.
window_class	`string`	Nome da classe de janela Win32 da janela ativa.
start_x, start_y	`number`	Coordenada inicial do cursor (em pixels físicos) do gesto do mouse.
end_x, end_y	`number`	Coordenada final do cursor (em pixels físicos) do gesto do mouse.
rect	`object`	Coordenadas do retângulo delimitador da janela ativa: `{left, top, right, bottom, w, h}`.
snapshot_rect	`object`	Retângulo delimitador da área de captura selecionada no modo de recorte: `{x, y, w, h}`.

Referência da API de Runtime

O namespace global runtime permite que você execute comandos nativos, simule entradas e controle janelas.

1. Execução e Inicialização de Processos

runtime.execute(path, args, options)

Inicia um aplicativo externo, comando de shell ou abre uma URL da web no navegador padrão.

Sintaxe 1: Passando uma string de comando simples

JavaScript

// Iniciar o Bloco de Notas e abrir um arquivo de log
runtime.execute("notepad.exe C:\\log.txt");

// Abrir uma URL no navegador padrão
runtime.execute("https://github.com");

Sintaxe 2: Passando um objeto de opções

JavaScript

// Executar um arquivo em lote como admin em modo oculto
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // Executar com privilégios de administrador
  hide: true,   // Ocultar a janela do console
  wait: false   // Execução assíncrona, não esperar a saída
});

Marcadores Dinâmicos em Comandos

Strings passadas para runtime.execute expandem automaticamente marcadores especiais:
%tempstr% (texto selecionado), %clipboard% (texto atual da área de transferência), %filepath% / %filename% (caminho do executável do aplicativo ativo) e variáveis de ambiente do sistema (como %TEMP%, %USERPROFILE%).

2. Simulação de Teclas e Entrada

runtime.sendKeys(keysStr)

Simula pressionamentos de tecla virtuais. Junte várias teclas usando o caractere +.

JavaScript

// Pressionar Ctrl+Alt+Tab para mostrar a visão de tarefas
runtime.sendKeys("CTRL+ALT+TAB");

// Pressionar tecla Windows + D para mostrar a área de trabalho
runtime.sendKeys("WIN+D");

// Pressionar Ctrl+Shift+T para reabrir aba do navegador
runtime.sendKeys("CTRL+SHIFT+T");

Tokens de tecla suportados (sem distinção de maiúsculas):

Modificadores: CTRL / CONTROL, SHIFT, ALT / MENU, WIN / WINDOWS
Teclas de Ação: ESC / ESCAPE, TAB, ENTER / RETURN, SPACE, BACKSPACE, DEL / DELETE, INS / INSERT, HOME, END, PAGEUP / PGUP, PAGEDOWN / PGDN
Setas: UP, DOWN, LEFT, RIGHT
Mídia / Navegação: BACK (Voltar do navegador), FORWARD (Avançar do navegador), PRTSC / PRINTSCREEN
Teclas de Função: F1 a F24
Teclas Padrão: Um único caractere alfanumérico (ex., A, 1, Z)

runtime.sendClick(button)

Simula um clique do botão do mouse. button pode ser "left", "right" ou "middle".

runtime.mouseMove(x, y)

Move o cursor do mouse. x e y podem ser coordenadas absolutas ou a string "start" (referindo-se às coordenadas iniciais do gesto, ex., runtime.mouseMove("start start")).

3. Área de Transferência e Captura de Tela

runtime.screenshot(mode, options)

Aciona a captura de tela. O parâmetro opcional mode pode ser "ocr", "pin" ou "croplock".

runtime.setClipboardText(text)

Escreve conteúdo de texto diretamente na área de transferência do sistema.

await runtime.getClipboardText()

(Assíncrono) Lê o conteúdo de texto atual da área de transferência do sistema.

4. Operações de Janela e Comandos do Sistema

Método API	Tipo de Retorno	Descrição
`runtime.window.close()`	`void`	Fecha a janela atualmente ativa (focada).
`runtime.window.maximize()`	`void`	Maximiza a janela ativa.
`runtime.window.minimize()`	`void`	Minimiza a janela ativa.
`runtime.window.setTopmost(enable)`	`void`	Alterna se a janela ativa permanece no topo (passe `true` ou `false`).
`runtime.window.closeSimilar()`	`void`	Fecha outras janelas abertas pertencentes ao mesmo processo de aplicativo.
`runtime.window.hideToTray()`	`void`	Minimiza a janela atual e a oculta na bandeja do sistema.
`runtime.internal.showSettings()`	`void`	Exibe o painel de configurações do Aitiy.
`runtime.internal.togglePause()`	`void`	Pausa/retoma os ganchos de teclado globais e gestos do Aitiy.
`runtime.internal.getSelection()`	`string`	Força a cópia de seleção padrão (simulação Ctrl+C) para recuperar o texto selecionado sem corromper a área de transferência atual do usuário.
`runtime.system.setBrightness(val)`	`void`	Define os níveis de brilho da tela (aceita um valor inteiro entre `0` e `100`).

Trechos de Script e Exemplos

Comece rapidamente copiando e colando estes scripts de automação comumente usados.

Exemplo 1: Pesquisar texto selecionado no Google

Ideal para: script de ação da "Barra de Seleção".

JavaScript

if (context.tempstr && context.tempstr.trim().length > 0) {
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

Exemplo 2: Abrir caminho de diretório selecionado no Explorador de Arquivos

Ideal para: "Gestos do Mouse" ou "Barra de Seleção".

JavaScript

const folderPath = context.tempstr || await runtime.getClipboardText();
if (folderPath && folderPath.indexOf(":\\") !== -1) {
  runtime.execute({
    path: "explorer.exe",
    args: `/select,"${folderPath.trim()}"`
  });
}

Exemplo 3: Simulação de clique duplo via teclas

Ideal para: "Gestos do Mouse".

JavaScript

runtime.sendClick("left");
setTimeout(() => {
  runtime.sendClick("left");
}, 80);

Documentation des Scripts et de l'API d'Exécution

Aitiy intègre un environnement d'exécution JavaScript (Runtime) local, léger et puissant. Propulsé par Microsoft WebView2, il communique de manière bidirectionnelle avec le cœur C++ natif d'Aitiy à des performances natives.

Cela vous permet d'écrire de simples extraits de code JavaScript pour personnaliser les actions des gestes de la souris, des raccourcis clavier et de la barre d'outils de sélection. Avec le Runtime local, vous n'êtes plus limité à exécuter des frappes statiques, mais vous pouvez exécuter des macros dynamiques et automatiser des tâches complexes !

Local et Sécurisé

Tous les scripts s'exécutent strictement sur votre machine locale. Aucun texte ou donnée de simulation de frappe n'est jamais envoyé dans le cloud, garantissant une confidentialité à 100 % pour vos tâches automatisées.

Écrire des Scripts Personnalisés

Dans le panneau des paramètres d'Aitiy (par exemple, Gestes de la souris, Barre d'outils de sélection ou Raccourcis), définissez le type d'Action sur "Script d'action personnalisé" pour commencer à coder en JavaScript.

Fonctionnement des Scripts

En interne, chaque script personnalisé que vous écrivez est automatiquement enveloppé dans une expression de fonction immédiatement invoquée asynchrone (Async IIFE) :

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // Contexte d'action actuel injecté
  
  // ============================
  // Votre code JS personnalisé ici :
  // ============================
  
})();

Grâce à cette enveloppe, vous pouvez librement utiliser le mot-clé await directement dans votre script pour mettre en pause l'exécution des promesses (comme la lecture du texte du presse-papiers avec await runtime.getClipboardText()).

Variables Globales Principales

context (également disponible sous window.__aitiy_action_context) : Contient les données environnementales au moment où l'action a été déclenchée (par exemple, titre de la fenêtre active, chemin du fichier, sélection actuelle, coordonnées).
runtime (également disponible sous window.runtime) : Expose les points de terminaison de l'API C++ native pour contrôler la simulation d'entrée, les fenêtres, le lancement de processus et la configuration.

Référence du Contexte d'Action

L'objet global context expose des propriétés contenant l'état de la fenêtre et le contexte de saisie utilisateur au moment où le geste ou la touche est invoqué :

Propriété	Type	Description
tempstr	`string`	Le texte surligné/sélectionné (principalement pour les actions de la Barre d'outils de sélection).
filepath	`string`	Chemin absolu de l'exécutable de la fenêtre active (ex., `C:\Windows\notepad.exe`).
filename	`string`	Nom de l'exécutable de la fenêtre active (ex., `notepad.exe`).
hwnd	`number`	Identifiant de fenêtre (HWND) de la fenêtre active.
window_title	`string`	Titre de la fenêtre active.
window_class	`string`	Nom de classe de fenêtre Win32 de la fenêtre active.
start_x, start_y	`number`	Coordonnée de départ du curseur (en pixels physiques) du geste de la souris.
end_x, end_y	`number`	Coordonnée de fin du curseur (en pixels physiques) du geste de la souris.
rect	`object`	Coordonnées du rectangle englobant de la fenêtre active : `{left, top, right, bottom, w, h}`.
snapshot_rect	`object`	Rectangle englobant de la zone de capture sélectionnée en mode recadrage : `{x, y, w, h}`.

Référence de l'API d'Exécution

L'espace de noms global runtime vous permet d'exécuter des commandes natives, de simuler des entrées et de contrôler des fenêtres.

1. Exécution et Lancement de Processus

runtime.execute(path, args, options)

Lance une application externe, une commande shell ou ouvre une URL web dans le navigateur par défaut.

Syntaxe 1 : Passer une chaîne de commande simple

JavaScript

// Lancer le Bloc-notes et ouvrir un fichier journal
runtime.execute("notepad.exe C:\\log.txt");

// Ouvrir une URL dans le navigateur par défaut
runtime.execute("https://github.com");

Syntaxe 2 : Passer un objet d'options

JavaScript

// Exécuter un fichier batch en tant qu'admin en mode masqué
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // Lancer avec les privilèges administrateur
  hide: true,   // Masquer la fenêtre de console
  wait: false   // Exécution asynchrone, ne pas attendre la fin
});

Espaces Réservés Dynamiques dans les Commandes

Les chaînes passées à runtime.execute développent automatiquement des espaces réservés spéciaux :
%tempstr% (texte sélectionné), %clipboard% (texte actuel du presse-papiers), %filepath% / %filename% (chemin de l'exécutable de l'application active) et les variables d'environnement système (comme %TEMP%, %USERPROFILE%).

2. Simulation de Touches et de Saisie

runtime.sendKeys(keysStr)

Simule des frappes de touches virtuelles. Joignez plusieurs touches avec le caractère +.

JavaScript

// Appuyer sur Ctrl+Alt+Tab pour afficher la vue des tâches
runtime.sendKeys("CTRL+ALT+TAB");

// Appuyer sur touche Windows + D pour afficher le bureau
runtime.sendKeys("WIN+D");

// Appuyer sur Ctrl+Shift+T pour rouvrir l'onglet du navigateur
runtime.sendKeys("CTRL+SHIFT+T");

Tokens de touche pris en charge (insensibles à la casse) :

Modificateurs : CTRL / CONTROL, SHIFT, ALT / MENU, WIN / WINDOWS
Touches d'Action : ESC / ESCAPE, TAB, ENTER / RETURN, SPACE, BACKSPACE, DEL / DELETE, INS / INSERT, HOME, END, PAGEUP / PGUP, PAGEDOWN / PGDN
Flèches : UP, DOWN, LEFT, RIGHT
Média / Navigation : BACK (Retour du navigateur), FORWARD (Avance du navigateur), PRTSC / PRINTSCREEN
Touches de Fonction : F1 à F24
Touches Standard : Un seul caractère alphanumérique (ex., A, 1, Z)

runtime.sendClick(button)

Simule un clic de bouton de souris. button peut être "left", "right" ou "middle".

runtime.mouseMove(x, y)

Déplace le curseur de la souris. x et y peuvent être des coordonnées absolues ou la chaîne "start" (faisant référence aux coordonnées de départ du geste, ex., runtime.mouseMove("start start")).

3. Presse-papiers et Capture d'Écran

runtime.screenshot(mode, options)

Déclenche la capture d'écran. Le paramètre optionnel mode peut être "ocr", "pin" ou "croplock".

runtime.setClipboardText(text)

Écrit du contenu texte directement dans le presse-papiers système.

await runtime.getClipboardText()

(Asynchrone) Lit le contenu texte actuel du presse-papiers système.

4. Opérations sur les Fenêtres et Commandes Système

Méthode API	Type de Retour	Description
`runtime.window.close()`	`void`	Ferme la fenêtre actuellement active (focalisée).
`runtime.window.maximize()`	`void`	Agrandit la fenêtre active.
`runtime.window.minimize()`	`void`	Réduit la fenêtre active.
`runtime.window.setTopmost(enable)`	`void`	Bascule si la fenêtre active reste au premier plan (passez `true` ou `false`).
`runtime.window.closeSimilar()`	`void`	Ferme les autres fenêtres ouvertes appartenant au même processus d'application.
`runtime.window.hideToTray()`	`void`	Réduit la fenêtre actuelle et la masque dans la barre d'état système.
`runtime.internal.showSettings()`	`void`	Affiche le panneau des paramètres d'Aitiy.
`runtime.internal.togglePause()`	`void`	Suspend/Reprend les hooks de clavier globaux et les gestes d'Aitiy.
`runtime.internal.getSelection()`	`string`	Force la copie de sélection standard (simulation Ctrl+C) pour récupérer le texte sélectionné sans corrompre le presse-papiers actuel de l'utilisateur.
`runtime.system.setBrightness(val)`	`void`	Définit les niveaux de luminosité de l'écran (prend une valeur entière entre `0` et `100`).

Extraits de Script et Exemples

Commencez rapidement en copiant et collant ces scripts d'automatisation couramment utilisés.

Exemple 1 : Rechercher le texte sélectionné sur Google

Idéal pour : script d'action "Barre d'outils de sélection".

JavaScript

if (context.tempstr && context.tempstr.trim().length > 0) {
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

Exemple 2 : Ouvrir le chemin du répertoire sélectionné dans l'Explorateur de fichiers

Idéal pour : "Gestes de la souris" ou "Barre d'outils de sélection".

JavaScript

const folderPath = context.tempstr || await runtime.getClipboardText();
if (folderPath && folderPath.indexOf(":\\") !== -1) {
  runtime.execute({
    path: "explorer.exe",
    args: `/select,"${folderPath.trim()}"`
  });
}

Exemple 3 : Simulation de double clic via des touches

Idéal pour : "Gestes de la souris".

JavaScript

runtime.sendClick("left");
setTimeout(() => {
  runtime.sendClick("left");
}, 80);

Laufzeit-Skripte & API-Dokumentation

Aitiy verfügt über eine integrierte, leichtgewichtige und leistungsstarke lokale JavaScript-Laufzeitumgebung (Runtime). Angetrieben von Microsoft WebView2 kommuniziert sie bidirektional mit dem nativen C++-Kern von Aitiy in nativer Geschwindigkeit.

Dies ermöglicht es Ihnen, einfache JavaScript-Codeausschnitte zu schreiben, um die Aktionen von Mausgesten, Hotkeys und der Auswahl-Symbolleiste anzupassen. Mit der lokalen Laufzeitumgebung sind Sie nicht mehr auf statische Tastenanschläge beschränkt, sondern können dynamische Makros ausführen und komplexe Aufgaben automatisieren!

Lokal und Sicher

Alle Skripte werden ausschließlich auf Ihrem lokalen Rechner ausgeführt. Es werden niemals Texte oder Tastensimulationsdaten in die Cloud gesendet, was 100 % Privatsphäre für Ihre automatisierten Aufgaben gewährleistet.

Benutzerdefinierte Skripte Schreiben

Stellen Sie im Einstellungsbereich von Aitiy (z. B. Mausgesten, Auswahl-Symbolleiste oder Hotkeys) den Aktionstyp auf "Benutzerdefiniertes Aktionsskript" ein, um mit der JavaScript-Programmierung zu beginnen.

So Funktioniert die Skripterstellung

Intern wird jedes von Ihnen geschriebene benutzerdefinierte Skript automatisch in einen asynchronen sofort ausgeführten Funktionsausdruck (Async IIFE) verpackt:

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // Injizierter aktueller Aktionskontext
  
  // ============================
  // Ihr benutzerdefinierter JS-Code hier:
  // ============================
  
})();

Dank dieses Wrappers können Sie das Schlüsselwort await direkt in Ihrem Skript verwenden, um die Ausführung für Promises anzuhalten (z. B. Lesen des Zwischenablage-Textes mit await runtime.getClipboardText()).

Wichtige Globale Variablen

context (auch verfügbar als window.__aitiy_action_context): Enthält Umgebungsdaten zum Zeitpunkt der Aktionsauslösung (z. B. Titel des aktiven Fensters, Dateipfad, aktuelle Auswahl, Koordinaten).
runtime (auch verfügbar als window.runtime): Stellt native C++-API-Endpunkte zur Steuerung von Eingabesimulation, Fenstern, Prozessstart und Konfiguration bereit.

Aktionskontext-Referenz

Das globale context-Objekt stellt Eigenschaften mit Fensterzustand und Benutzereingabekontext zum Zeitpunkt der Geste oder Tastenauslösung bereit:

Eigenschaft	Typ	Beschreibung
tempstr	`string`	Der markierte/ausgewählte Text (hauptsächlich für Aktionen der Auswahl-Symbolleiste).
filepath	`string`	Absoluter Dateipfad zur ausführbaren Datei des aktiven Fensters (z. B. `C:\Windows\notepad.exe`).
filename	`string`	Ausführbarer Dateiname des aktiven Fensters (z. B. `notepad.exe`).
hwnd	`number`	Fenstergriff (HWND) des aktiven Fensters.
window_title	`string`	Titeltext des aktiven Fensters.
window_class	`string`	Win32-Fensterklassenname des aktiven Fensters.
start_x, start_y	`number`	Startkoordinate des Cursors (in physischen Pixeln) der Mausgeste.
end_x, end_y	`number`	Endkoordinate des Cursors (in physischen Pixeln) der Mausgeste.
rect	`object`	Begrenzungsrechteck-Koordinaten des aktiven Fensters: `{left, top, right, bottom, w, h}`.
snapshot_rect	`object`	Begrenzungsrechteck des ausgewählten Screenshot-Bereichs im Zuschneidemodus: `{x, y, w, h}`.

Laufzeit-API-Referenz

Der globale runtime-Namespace ermöglicht es Ihnen, native Befehle auszulösen, Eingaben zu simulieren und Fenster zu steuern.

1. Ausführung und Prozessstart

runtime.execute(path, args, options)

Startet eine externe Anwendung, einen Shell-Befehl oder öffnet eine Web-URL im Standardbrowser.

Syntax 1: Übergeben einer einfachen Befehlszeichenfolge

JavaScript

// Editor starten und eine Protokolldatei öffnen
runtime.execute("notepad.exe C:\\log.txt");

// Eine URL im Standardbrowser öffnen
runtime.execute("https://github.com");

Syntax 2: Übergeben eines Optionsobjekts

JavaScript

// Eine Batch-Datei als Administrator versteckt ausführen
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // Mit Administratorrechten starten
  hide: true,   // Konsolenfenster ausblenden
  wait: false   // Asynchron ausführen, nicht auf Beendigung warten
});

Dynamische Platzhalter in Befehlen

An runtime.execute übergebene Zeichenfolgen erweitern automatisch spezielle Platzhalter:
%tempstr% (ausgewählter Text), %clipboard% (aktueller Zwischenablage-Text), %filepath% / %filename% (ausführbarer Pfad der aktiven App) und Systemumgebungsvariablen (wie %TEMP%, %USERPROFILE%).

2. Tasten- und Eingabesimulation

runtime.sendKeys(keysStr)

Simuliert virtuelle Tastenanschläge. Mehrere Tasten mit dem Zeichen + verbinden.

JavaScript

// Strg+Alt+Tab drücken, um die Aufgabenansicht anzuzeigen
runtime.sendKeys("CTRL+ALT+TAB");

// Windows-Taste + D drücken, um den Desktop anzuzeigen
runtime.sendKeys("WIN+D");

// Strg+Umschalt+T drücken, um Browser-Tab wieder zu öffnen
runtime.sendKeys("CTRL+SHIFT+T");

Unterstützte Tastenkürzel (Groß-/Kleinschreibung nicht relevant):

Modifikatoren: CTRL / CONTROL, SHIFT, ALT / MENU, WIN / WINDOWS
Aktionstasten: ESC / ESCAPE, TAB, ENTER / RETURN, SPACE, BACKSPACE, DEL / DELETE, INS / INSERT, HOME, END, PAGEUP / PGUP, PAGEDOWN / PGDN
Pfeiltasten: UP, DOWN, LEFT, RIGHT
Medien / Navigation: BACK (Browser zurück), FORWARD (Browser vorwärts), PRTSC / PRINTSCREEN
Funktionstasten: F1 bis F24
Standardtasten: Einzelnes alphanumerisches Zeichen (z. B. A, 1, Z)

runtime.sendClick(button)

Simuliert einen Mausklick. button kann "left", "right" oder "middle" sein.

runtime.mouseMove(x, y)

Bewegt den Mauszeiger. x und y können absolute Koordinaten oder die Zeichenfolge "start" sein (bezieht sich auf die Startkoordinaten der Mausgeste, z. B. runtime.mouseMove("start start")).

3. Zwischenablage & Screenshot

runtime.screenshot(mode, options)

Löst die Screenshot-Aufnahme aus. Der optionale Parameter mode kann "ocr", "pin" oder "croplock" sein.

runtime.setClipboardText(text)

Schreibt Textinhalt direkt in die Systemzwischenablage.

await runtime.getClipboardText()

(Asynchron) Liest den aktuellen Textinhalt aus der Systemzwischenablage.

4. Fensteroperationen & Systembefehle

API-Methode	Rückgabetyp	Beschreibung
`runtime.window.close()`	`void`	Schließt das aktuell aktive (fokussierte) Fenster.
`runtime.window.maximize()`	`void`	Maximiert das aktive Fenster.
`runtime.window.minimize()`	`void`	Minimiert das aktive Fenster.
`runtime.window.setTopmost(enable)`	`void`	Legt fest, ob das aktive Fenster im Vordergrund bleibt (`true` oder `false` übergeben).
`runtime.window.closeSimilar()`	`void`	Schließt andere geöffnete Fenster desselben Anwendungsprozesses.
`runtime.window.hideToTray()`	`void`	Minimiert das aktuelle Fenster und blendet es in der Taskleiste aus.
`runtime.internal.showSettings()`	`void`	Zeigt das Einstellungsfenster von Aitiy an.
`runtime.internal.togglePause()`	`void`	Pausiert/Setzt die globalen Tastatur-Hooks und Gesten von Aitiy fort.
`runtime.internal.getSelection()`	`string`	Erzwingt das standardmäßige Kopieren der Auswahl (Strg+C-Simulation), um ausgewählten Text abzurufen, ohne die aktuelle Zwischenablage des Benutzers zu beschädigen.
`runtime.system.setBrightness(val)`	`void`	Legt die Bildschirmhelligkeit fest (nimmt einen ganzzahligen Wert zwischen `0` und `100`).

Skript-Ausschnitte & Beispiele

Beginnen Sie schnell, indem Sie diese häufig verwendeten Automatisierungsskripte kopieren und einfügen.

Beispiel 1: Ausgewählten Text bei Google suchen

Am besten geeignet für: Aktionsskript der "Auswahl-Symbolleiste".

JavaScript

if (context.tempstr && context.tempstr.trim().length > 0) {
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

Beispiel 2: Ausgewählten Verzeichnispfad im Datei-Explorer öffnen

Am besten geeignet für: "Mausgesten" oder "Auswahl-Symbolleiste".

JavaScript

const folderPath = context.tempstr || await runtime.getClipboardText();
if (folderPath && folderPath.indexOf(":\\") !== -1) {
  runtime.execute({
    path: "explorer.exe",
    args: `/select,"${folderPath.trim()}"`
  });
}

Beispiel 3: Doppelklick-Simulation über Tasten

Am besten geeignet für: "Mausgesten".

JavaScript

runtime.sendClick("left");
setTimeout(() => {
  runtime.sendClick("left");
}, 80);

ランタイムスクリプト & API ドキュメント

Aitiy は、軽量かつ強力なローカル JavaScript ランタイム環境 を内蔵しています。Microsoft WebView2 を基盤とし、Aitiy のネイティブ C++ コアと高速な双方向通信を行います。

これにより、マウスジェスチャー、ホットキー、選択ツールバーのアクションをカスタマイズする簡単な JavaScript コードを記述できます。ローカルランタイムにより、静的なキーストロークだけでなく、動的マクロの実行や複雑なタスクの自動化が可能になります！

ローカルファースト & 安全

すべてのスクリプトは、お使いのローカルマシン上でのみ実行されます。テキストやキーストロークのシミュレーションデータがクラウドに送信されることは一切なく、自動化タスクの 100% のプライバシーが保証されます。

カスタムスクリプトの作成

Aitiy 設定パネル（マウスジェスチャー、選択ツールバー、ホットキーなど）で、アクションタイプを 「カスタムアクションスクリプト」 に設定して JavaScript コーディングを開始します。

スクリプトの仕組み

内部的には、作成したすべてのカスタムスクリプトは 非同期即時実行関数式 (Async IIFE) で自動的にラップされます：

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // 注入された現在のアクションコンテキスト
  
  // ============================
  // カスタム JS コードをここに記述：
  // ============================
  
})();

このラッパーにより、スクリプト内で直接 await キーワードを使用して Promise の実行を一時停止できます（例：await runtime.getClipboardText() でクリップボードテキストを読み取る）。

主要なグローバル変数

context（window.__aitiy_action_context としても利用可能）：アクションがトリガーされた瞬間の環境データ（アクティブウィンドウのタイトル、ファイルパス、現在の選択、座標など）を含みます。
runtime（window.runtime としても利用可能）：入力シミュレーション、ウィンドウ、プロセス起動、設定を制御するためのネイティブ C++ API エンドポイントを公開します。

アクションコンテキストリファレンス

グローバル context オブジェクトは、ジェスチャーまたはキーが呼び出された時点のウィンドウ状態とユーザー入力コンテキストを含むプロパティを公開します：

プロパティ	型	説明
tempstr	`string`	ハイライト/選択されたテキスト（主に選択ツールバーアクション用）。
filepath	`string`	アクティブウィンドウの実行可能ファイルの絶対パス（例：`C:\Windows\notepad.exe`）。
filename	`string`	アクティブウィンドウの実行可能ファイル名（例：`notepad.exe`）。
hwnd	`number`	アクティブウィンドウのウィンドウハンドル (HWND)。
window_title	`string`	アクティブウィンドウのタイトルテキスト。
window_class	`string`	アクティブウィンドウの Win32 ウィンドウクラス名。
start_x, start_y	`number`	マウスジェスチャーの開始カーソル座標（物理ピクセル単位）。
end_x, end_y	`number`	マウスジェスチャーの終了カーソル座標（物理ピクセル単位）。
rect	`object`	アクティブウィンドウの境界矩形座標：`{left, top, right, bottom, w, h}`。
snapshot_rect	`object`	トリミングモード時の選択スクリーンショット領域の境界矩形：`{x, y, w, h}`。

ランタイム API リファレンス

グローバル runtime 名前空間を使用して、ネイティブコマンドの実行、入力のシミュレーション、ウィンドウの制御を行うことができます。

1. 実行とプロセス起動

runtime.execute(path, args, options)

外部アプリケーションの起動、シェルコマンドの実行、またはデフォルトブラウザでの Web URL のオープンを行います。

構文 1：シンプルなコマンド文字列を渡す

JavaScript

// メモ帳を起動してログファイルを開く
runtime.execute("notepad.exe C:\\log.txt");

// デフォルトブラウザで URL を開く
runtime.execute("https://github.com");

構文 2：オプションオブジェクトを渡す

JavaScript

// 管理者としてバッチファイルを非表示で実行
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // 管理者権限で起動
  hide: true,   // コンソールウィンドウを非表示
  wait: false   // 非同期実行、終了を待たない
});

コマンド内の動的プレースホルダー

runtime.execute に渡された文字列は、特別なプレースホルダーを自動的に展開します：
%tempstr%（選択テキスト）、%clipboard%（現在のクリップボードテキスト）、%filepath% / %filename%（アクティブアプリの実行可能パス）、およびシステム環境変数（%TEMP%、%USERPROFILE% など）。

2. キーと入力のシミュレーション

runtime.sendKeys(keysStr)

仮想キーストロークをシミュレートします。+ 文字で複数のキーを結合します。

JavaScript

// Ctrl+Alt+Tab を押してタスクビューを表示
runtime.sendKeys("CTRL+ALT+TAB");

// Windows キー + D を押してデスクトップを表示
runtime.sendKeys("WIN+D");

// Ctrl+Shift+T を押してブラウザタブを再オープン
runtime.sendKeys("CTRL+SHIFT+T");

サポートされているキートークン（大文字小文字を区別しない）：

修飾キー：CTRL / CONTROL, SHIFT, ALT / MENU, WIN / WINDOWS
アクションキー：ESC / ESCAPE, TAB, ENTER / RETURN, SPACE, BACKSPACE, DEL / DELETE, INS / INSERT, HOME, END, PAGEUP / PGUP, PAGEDOWN / PGDN
矢印キー：UP, DOWN, LEFT, RIGHT
メディア / ナビゲーション：BACK（ブラウザ戻る）, FORWARD（ブラウザ進む）, PRTSC / PRINTSCREEN
ファンクションキー：F1 ～ F24
標準キー：単一の英数字（例：A, 1, Z）

runtime.sendClick(button)

マウスボタンのクリックをシミュレートします。button は "left", "right", "middle" のいずれかです。

runtime.mouseMove(x, y)

マウスカーソルを移動します。x と y は絶対座標、または文字列 "start"（マウスジェスチャーの開始座標を参照、例：runtime.mouseMove("start start")）を指定できます。

3. クリップボードとスクリーンショット

runtime.screenshot(mode, options)

スクリーンショットキャプチャをトリガーします。オプションの mode パラメータは "ocr", "pin", "croplock" のいずれかです。

runtime.setClipboardText(text)

テキストコンテンツをシステムクリップボードに直接書き込みます。

await runtime.getClipboardText()

（非同期） システムクリップボードから現在のテキストコンテンツを読み取ります。

4. ウィンドウ操作とシステムコマンド

API メソッド	戻り値の型	説明
`runtime.window.close()`	`void`	現在アクティブな（フォーカスされた）ウィンドウを閉じます。
`runtime.window.maximize()`	`void`	アクティブウィンドウを最大化します。
`runtime.window.minimize()`	`void`	アクティブウィンドウを最小化します。
`runtime.window.setTopmost(enable)`	`void`	アクティブウィンドウを常に最前面に表示するかどうかを切り替えます（`true` または `false` を渡します）。
`runtime.window.closeSimilar()`	`void`	同じアプリケーションプロセスに属する他の開いているウィンドウを閉じます。
`runtime.window.hideToTray()`	`void`	現在のウィンドウを最小化してシステムトレイに隠します。
`runtime.internal.showSettings()`	`void`	Aitiy 設定パネルを表示します。
`runtime.internal.togglePause()`	`void`	Aitiy のグローバルキーボードフックとジェスチャーを一時停止/再開します。
`runtime.internal.getSelection()`	`string`	標準選択コピー（Ctrl+C シミュレーション）を強制実行し、ユーザーの現在のクリップボードを破損することなく選択テキストを取得します。
`runtime.system.setBrightness(val)`	`void`	画面の明るさレベルを設定します（`0` ～ `100` の整数値）。

スクリプトスニペット & 例

よく使われる自動化スクリプトをコピー＆ペーストしてすぐに始めましょう。

例 1：選択したテキストを Google で検索

最適な配置場所：「選択ツールバー」アクションスクリプト。

JavaScript

if (context.tempstr && context.tempstr.trim().length > 0) {
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

例 2：選択したディレクトリパスをエクスプローラーで開く

最適な配置場所：「マウスジェスチャー」または「選択ツールバー」。

JavaScript

const folderPath = context.tempstr || await runtime.getClipboardText();
if (folderPath && folderPath.indexOf(":\\") !== -1) {
  runtime.execute({
    path: "explorer.exe",
    args: `/select,"${folderPath.trim()}"`
  });
}

例 3：キーによるダブルクリックシミュレーション

最適な配置場所：「マウスジェスチャー」。

JavaScript

runtime.sendClick("left");
setTimeout(() => {
  runtime.sendClick("left");
}, 80);

런타임 스크립트 및 API 문서

Aitiy는 가볍고 강력한 로컬 JavaScript 런타임 환경을 내장하고 있습니다. Microsoft WebView2를 기반으로 하며, Aitiy의 네이티브 C++ 코어와 고속 양방향 통신을 수행합니다.

이를 통해 마우스 제스처, 단축키, 선택 도구 모음의 동작을 사용자 정의하는 간단한 JavaScript 코드를 작성할 수 있습니다. 로컬 런타임을 통해 정적 키 입력뿐만 아니라 동적 매크로 실행과 복잡한 작업 자동화가 가능합니다!

로컬 우선 및 보안

모든 스크립트는 사용자의 로컬 컴퓨터에서만 실행됩니다. 텍스트나 키 입력 시뮬레이션 데이터가 클라우드로 전송되지 않으므로 자동화 작업의 100% 개인정보 보호가 보장됩니다.

사용자 정의 스크립트 작성

Aitiy 설정 패널(마우스 제스처, 선택 도구 모음, 단축키 등)에서 동작 유형을 "사용자 정의 동작 스크립트"로 설정하여 JavaScript 코딩을 시작하세요.

스크립트 작동 방식

내부적으로 작성한 모든 사용자 정의 스크립트는 비동기 즉시 실행 함수 표현식 (Async IIFE)으로 자동 래핑됩니다:

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // 주입된 현재 동작 컨텍스트
  
  // ============================
  // 사용자 정의 JS 코드를 여기에 작성:
  // ============================
  
})();

이 래퍼 덕분에 스크립트에서 직접 await 키워드를 사용하여 Promise 실행을 일시 중지할 수 있습니다(예: await runtime.getClipboardText()로 클립보드 텍스트 읽기).

주요 전역 변수

context (window.__aitiy_action_context로도 사용 가능): 동작이 트리거된 순간의 환경 데이터(활성 창 제목, 파일 경로, 현재 선택, 좌표 등)를 포함합니다.
runtime (window.runtime으로도 사용 가능): 입력 시뮬레이션, 창, 프로세스 시작, 구성을 제어하는 네이티브 C++ API 엔드포인트를 노출합니다.

동작 컨텍스트 참조

전역 context 객체는 제스처나 키가 호출된 시점의 창 상태와 사용자 입력 컨텍스트를 포함하는 속성을 노출합니다:

속성	유형	설명
tempstr	`string`	강조 표시/선택된 텍스트(주로 선택 도구 모음 동작용).
filepath	`string`	활성 창 실행 파일의 절대 경로(예: `C:\Windows\notepad.exe`).
filename	`string`	활성 창의 실행 파일 이름(예: `notepad.exe`).
hwnd	`number`	활성 창의 창 핸들(HWND).
window_title	`string`	활성 창의 제목 텍스트.
window_class	`string`	활성 창의 Win32 창 클래스 이름.
start_x, start_y	`number`	마우스 제스처의 시작 커서 좌표(물리 픽셀 단위).
end_x, end_y	`number`	마우스 제스처의 종료 커서 좌표(물리 픽셀 단위).
rect	`object`	활성 창의 경계 사각형 좌표: `{left, top, right, bottom, w, h}`.
snapshot_rect	`object`	자르기 모드에서 선택한 스크린샷 영역의 경계 사각형: `{x, y, w, h}`.

런타임 API 참조

전역 runtime 네임스페이스를 사용하여 네이티브 명령 실행, 입력 시뮬레이션, 창 제어를 수행할 수 있습니다.

1. 실행 및 프로세스 시작

runtime.execute(path, args, options)

외부 애플리케이션을 시작하거나, 셸 명령을 실행하거나, 기본 브라우저에서 웹 URL을 엽니다.

구문 1: 간단한 명령 문자열 전달

JavaScript

// 메모장을 실행하고 로그 파일 열기
runtime.execute("notepad.exe C:\\log.txt");

// 기본 브라우저에서 URL 열기
runtime.execute("https://github.com");

구문 2: 옵션 객체 전달

JavaScript

// 관리자 권한으로 배치 파일을 숨김 모드로 실행
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // 관리자 권한으로 실행
  hide: true,   // 콘솔 창 숨기기
  wait: false   // 비동기 실행, 종료 대기 안 함
});

명령의 동적 자리 표시자

runtime.execute에 전달된 문자열은 특수 자리 표시자를 자동으로 확장합니다:
%tempstr%(선택 텍스트), %clipboard%(현재 클립보드 텍스트), %filepath% / %filename%(활성 앱의 실행 파일 경로) 및 시스템 환경 변수(%TEMP%, %USERPROFILE% 등).

2. 키 및 입력 시뮬레이션

runtime.sendKeys(keysStr)

가상 키 입력을 시뮬레이션합니다. + 문자로 여러 키를 결합합니다.

JavaScript

// Ctrl+Alt+Tab을 눌러 작업 보기 표시
runtime.sendKeys("CTRL+ALT+TAB");

// Windows 키 + D를 눌러 바탕 화면 표시
runtime.sendKeys("WIN+D");

// Ctrl+Shift+T를 눌러 브라우저 탭 다시 열기
runtime.sendKeys("CTRL+SHIFT+T");

지원되는 키 토큰(대소문자 구분 없음):

수정자 키: CTRL / CONTROL, SHIFT, ALT / MENU, WIN / WINDOWS
동작 키: ESC / ESCAPE, TAB, ENTER / RETURN, SPACE, BACKSPACE, DEL / DELETE, INS / INSERT, HOME, END, PAGEUP / PGUP, PAGEDOWN / PGDN
화살표 키: UP, DOWN, LEFT, RIGHT
미디어 / 내비게이션: BACK (브라우저 뒤로), FORWARD (브라우저 앞으로), PRTSC / PRINTSCREEN
기능 키: F1 ~ F24
표준 키: 단일 영숫자 문자(예: A, 1, Z)

runtime.sendClick(button)

마우스 버튼 클릭을 시뮬레이션합니다. button은 "left", "right", "middle" 중 하나입니다.

runtime.mouseMove(x, y)

마우스 커서를 이동합니다. x와 y는 절대 좌표 또는 문자열 "start"(마우스 제스처의 시작 좌표 참조, 예: runtime.mouseMove("start start"))일 수 있습니다.

3. 클립보드 및 스크린샷

runtime.screenshot(mode, options)

스크린샷 캡처를 트리거합니다. 선택적 mode 매개변수는 "ocr", "pin", "croplock" 중 하나입니다.

runtime.setClipboardText(text)

텍스트 콘텐츠를 시스템 클립보드에 직접 씁니다.

await runtime.getClipboardText()

(비동기) 시스템 클립보드에서 현재 텍스트 콘텐츠를 읽습니다.

4. 창 작업 및 시스템 명령

API 메서드	반환 유형	설명
`runtime.window.close()`	`void`	현재 활성(포커스된) 창을 닫습니다.
`runtime.window.maximize()`	`void`	활성 창을 최대화합니다.
`runtime.window.minimize()`	`void`	활성 창을 최소화합니다.
`runtime.window.setTopmost(enable)`	`void`	활성 창을 항상 위에 표시할지 전환합니다(`true` 또는 `false` 전달).
`runtime.window.closeSimilar()`	`void`	동일한 애플리케이션 프로세스에 속한 다른 열린 창을 닫습니다.
`runtime.window.hideToTray()`	`void`	현재 창을 최소화하고 시스템 트레이에 숨깁니다.
`runtime.internal.showSettings()`	`void`	Aitiy 설정 패널을 표시합니다.
`runtime.internal.togglePause()`	`void`	Aitiy의 전역 키보드 후크 및 제스처를 일시 중지/재개합니다.
`runtime.internal.getSelection()`	`string`	표준 선택 복사(Ctrl+C 시뮬레이션)를 강제 실행하여 사용자의 현재 클립보드를 손상시키지 않고 선택된 텍스트를 검색합니다.
`runtime.system.setBrightness(val)`	`void`	화면 밝기 수준을 설정합니다(`0`에서 `100` 사이의 정수 값).

스크립트 조각 및 예제

자주 사용되는 자동화 스크립트를 복사하여 붙여넣고 빠르게 시작하세요.

예제 1: 선택한 텍스트를 Google에서 검색

적합한 위치: "선택 도구 모음" 동작 스크립트.

JavaScript

if (context.tempstr && context.tempstr.trim().length > 0) {
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

예제 2: 선택한 디렉토리 경로를 파일 탐색기에서 열기

적합한 위치: "마우스 제스처" 또는 "선택 도구 모음".

JavaScript

const folderPath = context.tempstr || await runtime.getClipboardText();
if (folderPath && folderPath.indexOf(":\\") !== -1) {
  runtime.execute({
    path: "explorer.exe",
    args: `/select,"${folderPath.trim()}"`
  });
}

예제 3: 키를 통한 더블 클릭 시뮬레이션

적합한 위치: "마우스 제스처".

JavaScript

runtime.sendClick("left");
setTimeout(() => {
  runtime.sendClick("left");
}, 80);

Документация по Скриптам и API Среды Выполнения

Aitiy оснащён встроенной, легковесной и мощной локальной средой выполнения JavaScript (Runtime). Работая на базе Microsoft WebView2, она двунаправленно взаимодействует с нативным ядром C++ Aitiy на высокой скорости.

Это позволяет вам писать простые фрагменты кода JavaScript для настройки действий жестов мыши, горячих клавиш и панели инструментов выделения. С локальной средой выполнения вы больше не ограничены статическими нажатиями клавиш — вы можете выполнять динамические макросы и автоматизировать сложные задачи!

Локально и Безопасно

Все скрипты выполняются строго на вашем локальном компьютере. Никакой текст или данные симуляции нажатий клавиш никогда не отправляются в облако, что обеспечивает 100% конфиденциальность ваших автоматизированных задач.

Написание Пользовательских Скриптов

В панели настроек Aitiy (например, «Жесты мыши», «Панель выделения» или «Горячие клавиши») установите тип действия на «Пользовательский скрипт действия», чтобы начать программировать на JavaScript.

Как Работают Скрипты

Внутренне каждый написанный вами пользовательский скрипт автоматически оборачивается в асинхронное немедленно вызываемое функциональное выражение (Async IIFE):

Runtime Wrapper (Internal)

(async function() {
  var context = { ... }; // Внедрённый текущий контекст действия
  
  // ============================
  // Ваш пользовательский JS-код здесь:
  // ============================
  
})();

Благодаря этой обёртке вы можете свободно использовать ключевое слово await непосредственно в скрипте для приостановки выполнения промисов (например, чтение текста буфера обмена с помощью await runtime.getClipboardText()).

Основные Глобальные Переменные

context (также доступен как window.__aitiy_action_context): Содержит данные окружения в момент срабатывания действия (например, заголовок активного окна, путь к файлу, текущее выделение, координаты).
runtime (также доступен как window.runtime): Предоставляет конечные точки нативного C++ API для управления симуляцией ввода, окнами, запуском процессов и конфигурацией.

Справочник Контекста Действия

Глобальный объект context предоставляет свойства, содержащие состояние окна и контекст ввода пользователя в момент вызова жеста или клавиши:

Свойство	Тип	Описание
tempstr	`string`	Выделенный/выбранный текст (в основном для действий Панели выделения).
filepath	`string`	Абсолютный путь к исполняемому файлу активного окна (например, `C:\Windows\notepad.exe`).
filename	`string`	Имя исполняемого файла активного окна (например, `notepad.exe`).
hwnd	`number`	Дескриптор окна (HWND) активного окна.
window_title	`string`	Заголовок активного окна.
window_class	`string`	Имя класса окна Win32 активного окна.
start_x, start_y	`number`	Начальная координата курсора (в физических пикселях) жеста мыши.
end_x, end_y	`number`	Конечная координата курсора (в физических пикселях) жеста мыши.
rect	`object`	Координаты ограничивающего прямоугольника активного окна: `{left, top, right, bottom, w, h}`.
snapshot_rect	`object`	Ограничивающий прямоугольник выбранной области снимка экрана в режиме обрезки: `{x, y, w, h}`.

Справочник API Среды Выполнения

Глобальное пространство имён runtime позволяет запускать нативные команды, имитировать ввод и управлять окнами.

1. Запуск и Выполнение Процессов

runtime.execute(path, args, options)

Запускает внешнее приложение, выполняет команду оболочки или открывает веб-URL в браузере по умолчанию.

Синтаксис 1: Передача простой командной строки

JavaScript

// Запустить Блокнот и открыть файл журнала
runtime.execute("notepad.exe C:\\log.txt");

// Открыть URL в браузере по умолчанию
runtime.execute("https://github.com");

Синтаксис 2: Передача объекта параметров

JavaScript

// Запустить пакетный файл от имени администратора в скрытом режиме
runtime.execute({
  path: "cmd.exe",
  args: "/c C:\\backup.bat",
  admin: true,  // Запуск с правами администратора
  hide: true,   // Скрыть окно консоли
  wait: false   // Асинхронный запуск, не ждать завершения
});

Динамические Заполнители в Командах

Строки, передаваемые в runtime.execute, автоматически расширяют специальные заполнители:
%tempstr% (выделенный текст), %clipboard% (текущий текст буфера обмена), %filepath% / %filename% (путь к исполняемому файлу активного приложения) и системные переменные окружения (такие как %TEMP%, %USERPROFILE%).

2. Имитация Клавиш и Ввода

runtime.sendKeys(keysStr)

Имитирует виртуальные нажатия клавиш. Объединяйте несколько клавиш с помощью символа +.

JavaScript

// Нажать Ctrl+Alt+Tab для отображения представления задач
runtime.sendKeys("CTRL+ALT+TAB");

// Нажать клавишу Windows + D для отображения рабочего стола
runtime.sendKeys("WIN+D");

// Нажать Ctrl+Shift+T для повторного открытия вкладки браузера
runtime.sendKeys("CTRL+SHIFT+T");

Поддерживаемые обозначения клавиш (без учёта регистра):

Модификаторы: CTRL / CONTROL, SHIFT, ALT / MENU, WIN / WINDOWS
Клавиши действий: ESC / ESCAPE, TAB, ENTER / RETURN, SPACE, BACKSPACE, DEL / DELETE, INS / INSERT, HOME, END, PAGEUP / PGUP, PAGEDOWN / PGDN
Стрелки: UP, DOWN, LEFT, RIGHT
Медиа / Навигация: BACK (Назад в браузере), FORWARD (Вперёд в браузере), PRTSC / PRINTSCREEN
Функциональные клавиши: F1–F24
Стандартные клавиши: Одиночный буквенно-цифровой символ (например, A, 1, Z)

runtime.sendClick(button)

Имитирует щелчок кнопкой мыши. button может быть "left", "right" или "middle".

runtime.mouseMove(x, y)

Перемещает курсор мыши. x и y могут быть абсолютными координатами или строкой "start" (ссылаясь на начальные координаты жеста мыши, например, runtime.mouseMove("start start")).

3. Буфер Обмена и Снимки Экрана

runtime.screenshot(mode, options)

Запускает захват снимка экрана. Необязательный параметр mode может быть "ocr", "pin" или "croplock".

runtime.setClipboardText(text)

Записывает текстовое содержимое непосредственно в системный буфер обмена.

await runtime.getClipboardText()

(Асинхронно) Читает текущее текстовое содержимое из системного буфера обмена.

4. Операции с Окнами и Системные Команды

Метод API	Тип Возврата	Описание
`runtime.window.close()`	`void`	Закрывает текущее активное (сфокусированное) окно.
`runtime.window.maximize()`	`void`	Разворачивает активное окно.
`runtime.window.minimize()`	`void`	Сворачивает активное окно.
`runtime.window.setTopmost(enable)`	`void`	Переключает, остаётся ли активное окно поверх других (передайте `true` или `false`).
`runtime.window.closeSimilar()`	`void`	Закрывает другие открытые окна, принадлежащие тому же процессу приложения.
`runtime.window.hideToTray()`	`void`	Сворачивает текущее окно и скрывает его в системном трее.
`runtime.internal.showSettings()`	`void`	Отображает панель настроек Aitiy.
`runtime.internal.togglePause()`	`void`	Приостанавливает/возобновляет глобальные перехватчики клавиатуры и жесты Aitiy.
`runtime.internal.getSelection()`	`string`	Принудительно выполняет стандартное копирование выделения (имитация Ctrl+C) для получения выделенного текста без нарушения текущего буфера обмена пользователя.
`runtime.system.setBrightness(val)`	`void`	Устанавливает уровень яркости экрана (принимает целое число от `0` до `100`).

Фрагменты Скриптов и Примеры

Быстро начните работу, скопировав и вставив эти часто используемые скрипты автоматизации.

Пример 1: Поиск выделенного текста в Google

Лучше всего подходит для: скрипта действия «Панель выделения».

JavaScript

if (context.tempstr && context.tempstr.trim().length > 0) {
  runtime.execute("https://www.google.com/search?q=" + encodeURIComponent(context.tempstr.trim()));
}

Пример 2: Открыть выбранный путь к каталогу в Проводнике

Лучше всего подходит для: «Жесты мыши» или «Панель выделения».

JavaScript

const folderPath = context.tempstr || await runtime.getClipboardText();
if (folderPath && folderPath.indexOf(":\\") !== -1) {
  runtime.execute({
    path: "explorer.exe",
    args: `/select,"${folderPath.trim()}"`
  });
}

Пример 3: Имитация двойного щелчка с помощью клавиш

Лучше всего подходит для: «Жесты мыши».

JavaScript

runtime.sendClick("left");
setTimeout(() => {
  runtime.sendClick("left");
}, 80);