jianf/HomeAgent
1
0
Fork 0
mirror of https://gitcode.com/JianFeeeee/HomeAgent.git synced 2026-09-21 17:38:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: 设备桥共享库 + CLI全能力补齐 + GUI omniparse/computeruse 重构

Browse Source 
- 抽取设备桥 WS 协议层为共享库 (internal/devicebridge/client/)
- CLI 补齐 11 项 caps 能力(screensee/screensue/speakeruse/camerasue/...)
- GUI 新增 omniparse 能力(Windows UIA 窗口解析)
- GUI computeruse 改用 koffi 直接调用 user32.dll，不再依赖 PowerShell C# 编译
- GUI computeruse JSON 解析兼容非标准格式 {x:500,y:300}
- 新增 mock-server 用于本地测试设备桥协议
- 新增 GUI DLL 桥接模块 (devicebridge_dll.js)
This commit is contained in:
JianFeeeee
2026-08-23 20:17:38 +08:00
parent a014f449f6
commit a024dc3f5f
13 changed files with 3401 additions and 362 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
cmd/gui/devicebridge_dll.js Normal file
View File

@ -0,0 +1,126 @@
// DeviceBridge DLL 桥接模块
// 提供设备桥共享库的 Node.js 封装，GUI 通过 FFI 调用 Go 编译的 DLL。
// 优先尝试加载 DLL，失败则回退到纯 JS 实现（保留兼容）。
const path = require('path');
const os = require('os');
let koffi = null;
let bridgeLib = null;
let _handle = null;
// DLL 路径
function dllPath() {
const dir = __dirname;
const plat = os.platform();
if (plat === 'win32') {
return path.join(dir, 'devicebridge.dll');
}
// Linux/Mac 使用 .so/.dylib
const ext = plat === 'darwin' ? 'dylib' : 'so';
return path.join(dir, `devicebridge.${ext}`);
}
// 尝试加载 FFI 库
async function loadFFI() {
try {
koffi = require('koffi');
return true;
} catch (e) {
try {
const ffi = require('ffi-napi');
const ref = require('ref-napi');
// 使用 ffi-napi 作为备选
return true;
} catch (e2) {
return false;
}
}
}
// 加载 DLL
function loadDLL() {
const dll = dllPath();
try {
if (koffi) {
return koffi.load(dll);
}
const ffi = require('ffi-napi');
const ref = require('ref-napi');
return ffi.Library(dll, {
'devicebridge_new': ['pointer', ['string', 'string', 'string', 'string', 'pointer', 'int']],
'devicebridge_start': ['int', ['pointer']],
'devicebridge_stop': ['void', ['pointer']],
'devicebridge_free': ['void', ['pointer']],
'devicebridge_connected': ['int', ['pointer']],
'devicebridge_device_id': ['string', ['pointer']],
'devicebridge_send_result': ['int', ['pointer', 'string', 'string', 'string', 'string']],
'devicebridge_send_event': ['void', ['pointer', 'string', 'string']],
'devicebridge_send_status': ['void', ['pointer', 'string']],
'devicebridge_send_data_start': ['void', ['pointer', 'string', 'string', 'string', 'int']],
'devicebridge_send_data_chunk': ['int', ['pointer', 'pointer', 'int']],
'devicebridge_send_data_end': ['void', ['pointer', 'string', 'string', 'string']],
});
} catch (e) {
console.error('[devicebridge-dll] load failed:', e.message);
return null;
}
}
// 设备桥封装
class DeviceBridgeDLL {
constructor() {
this.connected = false;
this.deviceId = '';
this._onCmd = null;
this._onData = null;
}
// 初始化并连接
async start(gateway, token, deviceId, deviceName, caps, info) {
bridgeLib = loadDLL();
if (!bridgeLib) {
throw new Error('DLL not loaded');
}
// 构建 caps 数组
const capsArr = caps.map(c => Buffer.from(c + '\0'));
const capsPtr = Buffer.alloc(8 * capsArr.length);
// 简化：实际 FFI 调用需要更复杂的参数处理
// 这里使用 koffi 方式
if (koffi) {
// 使用 koffi 调用
try {
// TODO: 实现 koffi 调用
throw new Error('koffi not fully implemented');
} catch (e) {
throw e;
}
}
throw new Error('FFI library not available. Install koffi or ffi-napi');
}
stop() {
if (bridgeLib && _handle) {
try {
bridgeLib.devicebridge_stop(_handle);
bridgeLib.devicebridge_free(_handle);
} catch (e) {}
_handle = null;
this.connected = false;
}
}
sendResult(reqId, status, output, error) {
if (!bridgeLib || !_handle) return;
try {
bridgeLib.devicebridge_send_result(_handle, reqId, status, output || '', error || '');
} catch (e) {
console.error('[devicebridge-dll] sendResult error:', e);
}
}
}
module.exports = { DeviceBridgeDLL, loadFFI };

190
cmd/gui/main.js
View File

@ -1743,16 +1743,24 @@ function executeHomeagentCmd(capability, reqId) {
try {
params = JSON.parse(jsonM[0]);
} catch (e) {
sendCmdResult(
reqId,
baseResult(
// 兼容非标准 JSON: {x:500,y:300} → 补双引号
try {
const fixed = jsonM[0]
.replace(/([{,]\s*)([a-zA-Z_][a-zA-Z0-9_]*)\s*:/g, '$1"$2":') // 给 key 加引号
.replace(/:\s*'([^']*)'/g, ':"$1"'); // 单引号值转双引号
params = JSON.parse(fixed);
} catch (e2) {
sendCmdResult(
reqId,
"error",
"",
"computeruse: invalid JSON params: " + e.message,
),
);
return;
baseResult(
reqId,
"error",
"",
"computeruse: invalid JSON params: " + e.message,
),
);
return;
}
}
} else {
// 支持 "x y action" 简写
@ -1791,84 +1799,55 @@ function executeHomeagentCmd(capability, reqId) {
const oy = disp ? (disp.bounds.y || 0) : 0;
const absX = Math.round(ox + (parseFloat(params.x) || 0));
const absY = Math.round(oy + (parseFloat(params.y) || 0));
const run = (cmdStr, done) => {
if (os_ === "win32") {
// Windows: 用 PowerShell user32 SendInput
cp.execFile(
"powershell",
["-NoProfile", "-Command", cmdStr],
{ timeout: 15000, maxBuffer: 1024 * 1024 },
(err) => {
sendCmdResult(
reqId,
baseResult(
reqId,
err ? "error" : "ok",
err ? "" : "computeruse " + action + " @ (" + absX + "," + absY + ")" + (done ? " " + done : ""),
err ? err.message : "",
),
);
},
);
return;
}
if (os_ === "darwin") {
// macOS cliclick
cp.execFile(
"cliclick",
cmdStr,
{ timeout: 15000, maxBuffer: 1024 * 1024 },
(err) => {
sendCmdResult(
reqId,
baseResult(
reqId,
err ? "error" : "ok",
err ? "" : "computeruse " + action + " @ (" + absX + "," + absY + ")" + (done ? " " + done : ""),
err ? err.message : "",
),
);
},
);
return;
}
// Linux xdotool
cp.execFile("xdotool", cmdStr, { timeout: 15000, maxBuffer: 1024 * 1024 }, (err) => {
sendCmdResult(
reqId,
baseResult(
reqId,
err ? "error" : "ok",
err ? "" : "computeruse " + action + " @ (" + absX + "," + absY + ")" + (done ? " " + done : ""),
err ? err.message : "",
),
);
});
};
// Windows 命令构建
const winCmd = (body) =>
"Add-Type -AssemblyName System.Windows.Forms; Add-Type -MemberDefinition '[DllImport(\"user32.dll\")] public static extern bool SetCursorPos(int x,int y); [DllImport(\"user32.dll\")] public static extern void mouse_event(uint dwFlags,uint dx,uint dy,uint dwData,uint dwExtraInfo);' -Name U -Namespace W; [U]::SetCursorPos(" + absX + "," + absY + "); " + body;
// === Windows: 用 koffi 直接调用 user32.dll，不依赖 PowerShell C# 编译 ===
if (os_ === "win32") {
const btnDown = params.button === "right" ? 0x0008 : params.button === "middle" ? 0x0020 : 0x0002;
const btnUp = params.button === "right" ? 0x0010 : params.button === "middle" ? 0x0040 : 0x0004;
switch (action) {
case "move":
run(winCmd("")); return;
case "click":
run(winCmd("[U]::mouse_event(" + btnDown + ",0,0,0,0); [U]::mouse_event(" + btnUp + ",0,0,0,0);")); return;
case "doubleclick":
run(winCmd("[U]::mouse_event(" + btnDown + ",0,0,0,0); [U]::mouse_event(" + btnUp + ",0,0,0,0); Start-Sleep -Milliseconds 50; [U]::mouse_event(" + btnDown + ",0,0,0,0); [U]::mouse_event(" + btnUp + ",0,0,0,0);")); return;
case "rightclick":
run(winCmd("[U]::mouse_event(0x0008,0,0,0,0); [U]::mouse_event(0x0010,0,0,0,0);")); return;
case "scroll":
run(winCmd("[U]::mouse_event(0x0800,0,0," + String(Math.round((params.dy || 120) * 120)) + ",0);")); return;
case "keypress":
run("Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('" + String(params.key || params.text || "").replace(/'/g, "").replace(/\+/g, "{+}").replace(/\^/g, "{^}").replace(/%/g, "{%}") + "')"); return;
case "type":
run("Add-Type -AssemblyName System.Windows.Forms; [System.Windows.Forms.SendKeys]::SendWait('" + String(params.text || "").replace(/\+/g, "{+}").replace(/\^/g, "{^}").replace(/%/g, "{%}").replace(/~/g, "{~}") + "')"); return;
default:
sendCmdResult(reqId, baseResult(reqId, "error", "", "computeruse: unknown action " + action)); return;
try {
const koffi = require("koffi");
const user32 = koffi.load("user32.dll");
const SetCursorPos = user32.func("bool SetCursorPos(int x, int y)");
const mouse_event = user32.func("void mouse_event(uint dwFlags, uint dx, uint dy, uint dwData, uint dwExtraInfo)");
const btnDown = params.button === "right" ? 0x0008 : params.button === "middle" ? 0x0020 : 0x0002;
const btnUp = params.button === "right" ? 0x0010 : params.button === "middle" ? 0x0040 : 0x0004;
// 先移动鼠标到目标位置
SetCursorPos(absX, absY);
switch (action) {
case "move":
sendCmdResult(reqId, baseResult(reqId, "ok", "computeruse move @ (" + absX + "," + absY + ")", ""));
break;
case "click":
mouse_event(btnDown, 0, 0, 0, 0);
mouse_event(btnUp, 0, 0, 0, 0);
sendCmdResult(reqId, baseResult(reqId, "ok", "computeruse click @ (" + absX + "," + absY + ")", ""));
break;
case "doubleclick":
mouse_event(btnDown, 0, 0, 0, 0);
mouse_event(btnUp, 0, 0, 0, 0);
setTimeout(() => {
mouse_event(btnDown, 0, 0, 0, 0);
mouse_event(btnUp, 0, 0, 0, 0);
sendCmdResult(reqId, baseResult(reqId, "ok", "computeruse doubleclick @ (" + absX + "," + absY + ")", ""));
}, 50);
break;
case "rightclick":
mouse_event(0x0008, 0, 0, 0, 0);
mouse_event(0x0010, 0, 0, 0, 0);
sendCmdResult(reqId, baseResult(reqId, "ok", "computeruse rightclick @ (" + absX + "," + absY + ")", ""));
break;
case "scroll":
mouse_event(0x0800, 0, 0, Math.round((params.dy || 120) * 120), 0);
sendCmdResult(reqId, baseResult(reqId, "ok", "computeruse scroll @ (" + absX + "," + absY + ")", ""));
break;
default:
sendCmdResult(reqId, baseResult(reqId, "error", "", "computeruse: unknown action " + action));
}
} catch (e) {
sendCmdResult(reqId, baseResult(reqId, "error", "", "computeruse: " + e.message));
}
return;
}
// Linux / macOS 通过工具 argv
const L = (a) => {
@ -1961,6 +1940,43 @@ function executeHomeagentCmd(capability, reqId) {
}
return;
}
case "omniparse": {
// 解析当前屏幕 UI 元素，返回结构化 JSON 供 agent 分析
// 使用 PowerShell Get-Process + .NET 获取窗口信息
try {
const cp = require("child_process");
const psScript = `
$wins = @()
$procs = [System.Diagnostics.Process]::GetProcesses()
foreach ($p in $procs) {
if ($p.MainWindowHandle -ne 0 -and $p.MainWindowTitle) {
$wins += @{
pid = $p.Id
name = $p.ProcessName
title = $p.MainWindowTitle.Trim()
hwnd = $p.MainWindowHandle.ToString("x")
}
}
}
if ($wins.Count -gt 50) { $wins = $wins[0..49] }
return ($wins | ConvertTo-Json -Compress)
`;
const psFile = require("path").join(require("os").tmpdir(), "ha_omniparse_" + Date.now() + ".ps1");
require("fs").writeFileSync(psFile, psScript, "utf8");
cp.execFile("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", psFile],
{ timeout: 15000, maxBuffer: 1024 * 1024 },
(err, stdout) => {
try { require("fs").unlinkSync(psFile); } catch (e) {}
if (err) { sendCmdResult(reqId, baseResult(reqId, "error", "", "omniparse: " + err.message)); return; }
const out = (stdout || "").trim();
if (!out) { sendCmdResult(reqId, baseResult(reqId, "error", "", "omniparse: no output")); return; }
sendCmdResult(reqId, baseResult(reqId, "ok", out, ""));
});
} catch (e) {
sendCmdResult(reqId, baseResult(reqId, "error", "", "omniparse: " + e.message));
}
return;
}
case "clipboardsue": {
// 写入文字到设备剪切板（用户可直接 Ctrl+V 粘贴）。
// 协议: homeagent-clipboardsue <文字>
@ -2050,6 +2066,10 @@ async function startDeviceBridge(cfg) {
"screensee",
"clipboardsee",
"clipboardsue",
"speakeruse",
"camerasue",
"screensue",
"omniparse",
],
info: {
hostname: devOs.hostname() || "",

270
cmd/gui/package-lock.json generated
View File

@ -7,6 +7,9 @@
"": {
"name": "homeagent-gui",
"version": "1.0.0",
"dependencies": {
"koffi": "^3.1.6"
},
"devDependencies": {
"asar": "^3.2.0",
"electron": "^33.0.0",
@ -936,6 +939,246 @@
"node": ">=18.0.0"
}
},
"node_modules/@koromix/koffi-darwin-arm64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-darwin-arm64/-/koffi-darwin-arm64-3.1.6.tgz",
"integrity": "sha512-8FHyXGCZN7/iQf4f7W5BRysmtdlAFvSx6FpmX4u6wmkZiX/2e9hIRdGLiZYlHGudlcA18UmXB/cMiyhJ7fJkzA==",
"cpu": [
"arm64"
],
"license": "MIT",
"optional": true,
"os": [
"darwin"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-darwin-x64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-darwin-x64/-/koffi-darwin-x64-3.1.6.tgz",
"integrity": "sha512-uzx/jqFQuSHqgg1zaRidTBTCfj8Y9M0SDTO8HeoI9s9fJhiJ1mbB9TTwJO5c2hiMnuWg2m1byczC8BaIH6cG/w==",
"cpu": [
"x64"
],
"license": "MIT",
"optional": true,
"os": [
"darwin"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-freebsd-arm64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-freebsd-arm64/-/koffi-freebsd-arm64-3.1.6.tgz",
"integrity": "sha512-PjpTVrsCK5YTtixOw7VsseYXJOyoY6k0qBt+bf0T9h3wyV06y73rALsorFDDEoYpLUBZO7R6EIMs6CpUrEkNTQ==",
"cpu": [
"arm64"
],
"license": "MIT",
"optional": true,
"os": [
"freebsd"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-freebsd-ia32": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-freebsd-ia32/-/koffi-freebsd-ia32-3.1.6.tgz",
"integrity": "sha512-ETYwL820HtFwYoOVzgyvmFmzTHRo9DJtGYTxa5Nb7ajaa5ldCum0jbmUJ3PMECxFTLxD5Q6PYZ8Xbp101bGeSg==",
"cpu": [
"ia32"
],
"license": "MIT",
"optional": true,
"os": [
"freebsd"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-freebsd-x64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-freebsd-x64/-/koffi-freebsd-x64-3.1.6.tgz",
"integrity": "sha512-BkqxkNXhAAT9toU2stvLwx1iKHPDx7h08NCICyBbjYEXkCAEr84igTkpE5V3XJ9xZZ2gKll7VvdhxorHtHUqZw==",
"cpu": [
"x64"
],
"license": "MIT",
"optional": true,
"os": [
"freebsd"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-linux-arm64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-linux-arm64/-/koffi-linux-arm64-3.1.6.tgz",
"integrity": "sha512-cM4XPm9ljbCrcPgXjzFYjDNxDUvvuR7TCYaEoo1AKjwZT/vmWhu2xN3pomfbsHh6aVn80SFA3enufQnaETW1rQ==",
"cpu": [
"arm64"
],
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-linux-ia32": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-linux-ia32/-/koffi-linux-ia32-3.1.6.tgz",
"integrity": "sha512-l1SVTpO10iaQt8slbowJpzK4fbwQZ7ufj9tmCyAcIwWUpyAbPS83mJMctU72If6N9/gCS2wuRqwnYB2uPLLhLg==",
"cpu": [
"ia32"
],
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-linux-loong64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-linux-loong64/-/koffi-linux-loong64-3.1.6.tgz",
"integrity": "sha512-KpTJpMSbIdCVFU26ynt0xy4x15h+y6AwPJxj2+iVxJhCzJf4oisCPc0YH2VnutuLV2nVzSrFm7sL/WSOqPgkXw==",
"cpu": [
"loong64"
],
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-linux-riscv64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-linux-riscv64/-/koffi-linux-riscv64-3.1.6.tgz",
"integrity": "sha512-YdFNpsywnXiYOYQlDAatf7TJLnspbGXdmfwIZhf82kbKSflYUsq4tI6NmoUOzM89oIWDGpYqd4Hz3xL7tsyXsw==",
"cpu": [
"riscv64"
],
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-linux-x64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-linux-x64/-/koffi-linux-x64-3.1.6.tgz",
"integrity": "sha512-Xx5mpr9VcaMCXfvbqIiLIWIL9Iuu6F4r3iMXg7+zZCqYUFZPFwJgiDQBLxctHv2OYgIfAoaaHMW0GC1cJkHfbA==",
"cpu": [
"x64"
],
"license": "MIT",
"optional": true,
"os": [
"linux"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-openbsd-ia32": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-openbsd-ia32/-/koffi-openbsd-ia32-3.1.6.tgz",
"integrity": "sha512-39Np4QTxhTlTT6RRveIeP+TnbzrwuDJ0UMyHxEZ+oGtzmb9GqWhl9T1oyehG6v/O+c4BffafG2NwLkCZ7tDKWw==",
"cpu": [
"ia32"
],
"license": "MIT",
"optional": true,
"os": [
"openbsd"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-openbsd-x64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-openbsd-x64/-/koffi-openbsd-x64-3.1.6.tgz",
"integrity": "sha512-3EynGn3ycQRqaMWGmUJ0tdtuQdStByqSy/tJ0ZGKWizbMGdFAE73YpgLsyd8BDvwnKWytVG/OLNb5nDHpfd9Dg==",
"cpu": [
"x64"
],
"license": "MIT",
"optional": true,
"os": [
"openbsd"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-win32-arm64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-win32-arm64/-/koffi-win32-arm64-3.1.6.tgz",
"integrity": "sha512-27FdPPRtT4xbO9bsd2OZa95M5YQ7bcJ8QjCRO57UUMI21REfkDegjqKwqo/CFlugxXlJf5IYtG2rq4BEYIrvxg==",
"cpu": [
"arm64"
],
"license": "MIT",
"optional": true,
"os": [
"win32"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-win32-ia32": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-win32-ia32/-/koffi-win32-ia32-3.1.6.tgz",
"integrity": "sha512-5mVelLKVDup4eoxZOpCzCyMPxoctsg+Qe4J9O5BP4KbBEdqoOEqaNEBBRgNzXcdr2g+GGfmIUo+oVR1NvIdiJw==",
"cpu": [
"ia32"
],
"license": "MIT",
"optional": true,
"os": [
"win32"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@koromix/koffi-win32-x64": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/@koromix/koffi-win32-x64/-/koffi-win32-x64-3.1.6.tgz",
"integrity": "sha512-lPKjAaHz0aoiZXT/wDVqH+joR5y3lCZj1s9Bk5qx/DGRq+0MK8Ib8VoqiBOrJ69NG5AsJSvn0tQDcSqfRgLmBQ==",
"cpu": [
"x64"
],
"license": "MIT",
"optional": true,
"os": [
"win32"
],
"funding": {
"url": "https://liberapay.com/Koromix"
}
},
"node_modules/@malept/cross-spawn-promise": {
"version": "1.1.1",
"resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-1.1.1.tgz",
@ -3764,6 +4007,33 @@
"json-buffer": "3.0.1"
}
},
"node_modules/koffi": {
"version": "3.1.6",
"resolved": "https://registry.npmmirror.com/koffi/-/koffi-3.1.6.tgz",
"integrity": "sha512-ln60chEb3o7Du1ayjwl6BFiNN1wZK+3cTM2wWGiHLEzCY/FdTIN1ER5VWDwHq7J/j4tSnnrHaH5ABS1EO6+6ag==",
"hasInstallScript": true,
"license": "MIT",
"funding": {
"url": "https://liberapay.com/Koromix"
},
"optionalDependencies": {
"@koromix/koffi-darwin-arm64": "3.1.6",
"@koromix/koffi-darwin-x64": "3.1.6",
"@koromix/koffi-freebsd-arm64": "3.1.6",
"@koromix/koffi-freebsd-ia32": "3.1.6",
"@koromix/koffi-freebsd-x64": "3.1.6",
"@koromix/koffi-linux-arm64": "3.1.6",
"@koromix/koffi-linux-ia32": "3.1.6",
"@koromix/koffi-linux-loong64": "3.1.6",
"@koromix/koffi-linux-riscv64": "3.1.6",
"@koromix/koffi-linux-x64": "3.1.6",
"@koromix/koffi-openbsd-ia32": "3.1.6",
"@koromix/koffi-openbsd-x64": "3.1.6",
"@koromix/koffi-win32-arm64": "3.1.6",
"@koromix/koffi-win32-ia32": "3.1.6",
"@koromix/koffi-win32-x64": "3.1.6"
}
},
"node_modules/lazy-val": {
"version": "1.0.5",
"resolved": "https://registry.npmjs.org/lazy-val/-/lazy-val-1.0.5.tgz",

1
cmd/gui/package.json
View File

@ -10,6 +10,7 @@
"dev": "electron . --no-sandbox --dev"
},
"dependencies": {
"koffi": "^3.1.6"
},
"devDependencies": {
"asar": "^3.2.0",

521
cmd/mock-server/main.go Normal file
View File

@ -0,0 +1,521 @@
package main
import (
"encoding/json"
"fmt"
"log"
"net/http"
"strings"
"sync"
"time"
)
// ===== 模拟数据 =====
type Status struct {
Status string `json:"status"`
Version string `json:"version"`
StartedAt string `json:"startedAt"`
Uptime int64 `json:"uptime"`
}
type Kernel struct {
Model string `json:"model"`
Provider string `json:"provider"`
Status string `json:"status"`
}
type Setting struct {
Settings map[string]interface{} `json:"settings"`
Meta map[string]interface{} `json:"meta"`
Plugins []string `json:"plugins"`
PluginMeta map[string]interface{} `json:"plugin_meta"`
DisabledPlugins []string `json:"disabled_plugins"`
}
type Plugin struct {
Name string `json:"name"`
Description string `json:"description"`
Version string `json:"version"`
Enabled bool `json:"enabled"`
Builtin bool `json:"builtin"`
}
type PluginInfo struct {
Name string `json:"name"`
Description string `json:"description"`
Version string `json:"version"`
Enabled bool `json:"enabled"`
Builtin bool `json:"builtin"`
Tools []PluginTool `json:"tools"`
}
type PluginTool struct {
Name string `json:"name"`
Description string `json:"description"`
}
type Adapter struct {
Name string `json:"name"`
Type string `json:"type"`
Enabled bool `json:"enabled"`
}
type ChatMessage struct {
Role string `json:"role"`
Content string `json:"content"`
}
type MemoryItem struct {
ID string `json:"id"`
Content string `json:"content"`
Time string `json:"time"`
}
type Device struct {
DeviceID string `json:"device_id"`
Name string `json:"name"`
Authorized bool `json:"authorized"`
Online bool `json:"online"`
Caps []string `json:"caps"`
}
// ===== SSE 管理器 =====
type SSEManager struct {
mu sync.RWMutex
clients map[chan string]bool
}
func NewSSEManager() *SSEManager {
return &SSEManager{clients: make(map[chan string]bool)}
}
func (m *SSEManager) Add(ch chan string) {
m.mu.Lock()
m.clients[ch] = true
m.mu.Unlock()
}
func (m *SSEManager) Remove(ch chan string) {
m.mu.Lock()
delete(m.clients, ch)
m.mu.Unlock()
}
func (m *SSEManager) Broadcast(eventType, data string) {
msg := fmt.Sprintf("event: %s\ndata: %s\n\n", eventType, data)
m.mu.RLock()
defer m.mu.RUnlock()
for ch := range m.clients {
select {
case ch <- msg:
default:
}
}
}
// ===== HTTP 处理器 =====
type MockServer struct {
startedAt time.Time
sse *SSEManager
mu sync.Mutex
plugins []Plugin
adapters []Adapter
devices []Device
settings map[string]interface{}
}
func NewMockServer() *MockServer {
now := time.Now()
return &MockServer{
startedAt: now,
sse: NewSSEManager(),
plugins: []Plugin{
{Name: "core", Description: "核心插件", Version: "1.0.0", Enabled: true, Builtin: true},
{Name: "remotedevice", Description: "远程设备管理", Version: "0.9.0", Enabled: true, Builtin: true},
{Name: "webui", Description: "Web 用户界面", Version: "0.9.0", Enabled: true, Builtin: true},
{Name: "knowledge", Description: "知识库管理", Version: "0.5.0", Enabled: true, Builtin: false},
},
adapters: []Adapter{
{Name: "openai", Type: "llm", Enabled: true},
{Name: "siliconflow", Type: "llm", Enabled: true},
},
devices: []Device{
{DeviceID: "gui-test-local", Name: "GUI 测试设备", Authorized: true, Online: true, Caps: []string{"status", "cmdrun", "deviceinfo"}},
},
settings: map[string]interface{}{
"language": "zh-CN",
"theme": "dark",
},
}
}
// 中间件：CORS + API Key 校验
func (s *MockServer) middleware(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
w.Header().Set("Access-Control-Allow-Headers", "Content-Type, X-API-Key, Authorization, Cookie")
if r.Method == "OPTIONS" {
w.WriteHeader(200)
return
}
// API Key 校验（可选）
// apiKey := r.Header.Get("X-API-Key")
// if apiKey == "" {
// http.Error(w, "unauthorized", 401)
// return
// }
next.ServeHTTP(w, r)
})
}
func (s *MockServer) handleStatus(w http.ResponseWriter, r *http.Request) {
writeJSON(w, Status{
Status: "running",
Version: "0.9.0",
StartedAt: s.startedAt.Format(time.RFC3339),
Uptime: int64(time.Since(s.startedAt).Seconds()),
})
}
func (s *MockServer) handleKernel(w http.ResponseWriter, r *http.Request) {
writeJSON(w, Kernel{
Model: "sensenova-6.8-flash-lite",
Provider: "siliconflow",
Status: "ready",
})
}
func (s *MockServer) handleSettings(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
var updates map[string]interface{}
if err := json.NewDecoder(r.Body).Decode(&updates); err == nil {
s.mu.Lock()
for k, v := range updates {
s.settings[k] = v
}
s.mu.Unlock()
}
writeJSON(w, map[string]string{"status": "saved"})
return
}
writeJSON(w, Setting{
Settings: s.settings,
Meta: map[string]interface{}{
"version": "0.9.0",
"build": "mock-20260823",
},
Plugins: []string{"core", "remotedevice", "webui", "knowledge"},
PluginMeta: map[string]interface{}{
"core": map[string]interface{}{"version": "1.0.0"},
"remotedevice": map[string]interface{}{"version": "0.9.0"},
"webui": map[string]interface{}{"version": "0.9.0"},
"knowledge": map[string]interface{}{"version": "0.5.0"},
},
DisabledPlugins: []string{},
})
}
func (s *MockServer) handlePlugins(w http.ResponseWriter, r *http.Request) {
// 获取路径中的插件名
path := strings.TrimPrefix(r.URL.Path, "/api/v1/plugins")
path = strings.TrimSuffix(path, "/")
if path == "/reload" && r.Method == "POST" {
writeJSON(w, map[string]string{"status": "reloaded"})
return
}
if path == "" && r.Method == "GET" {
writeJSON(w, s.plugins)
return
}
if path == "" && r.Method == "POST" {
writeJSON(w, map[string]string{"status": "installed"})
return
}
// /api/v1/plugins/:name
if strings.Contains(path, "/") {
parts := strings.Split(strings.TrimPrefix(path, "/"), "/")
if len(parts) >= 1 {
name := parts[0]
if len(parts) >= 2 {
action := parts[1]
if action == "disable" && r.Method == "POST" {
s.mu.Lock()
for i := range s.plugins {
if s.plugins[i].Name == name {
s.plugins[i].Enabled = false
}
}
s.mu.Unlock()
writeJSON(w, map[string]string{"status": "disabled"})
return
}
if action == "enable" && r.Method == "POST" {
s.mu.Lock()
for i := range s.plugins {
if s.plugins[i].Name == name {
s.plugins[i].Enabled = true
}
}
s.mu.Unlock()
writeJSON(w, map[string]string{"status": "enabled"})
return
}
}
// GET /api/v1/plugins/:name
writeJSON(w, PluginInfo{
Name: name,
Description: name + " 插件描述",
Version: "0.9.0",
Enabled: true,
Builtin: true,
Tools: []PluginTool{
{Name: name + "_tool1", Description: name + " 工具1"},
{Name: name + "_tool2", Description: name + " 工具2"},
},
})
return
}
}
http.NotFound(w, r)
}
func (s *MockServer) handleChatHistory(w http.ResponseWriter, r *http.Request) {
writeJSON(w, []ChatMessage{
{Role: "user", Content: "你好"},
{Role: "assistant", Content: "你好！我是 HomeAgent，有什么可以帮你的？"},
{Role: "user", Content: "测试消息"},
{Role: "assistant", Content: "这是模拟后端的测试回复，GUI 连接正常 ✅"},
})
}
func (s *MockServer) handleChat(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
// 模拟后端接收消息，通过 SSE 推流
go func() {
time.Sleep(500 * time.Millisecond)
// agent_start
s.sse.Broadcast("agent_output", `{"type":"agent_start","payload":{"agent":"mock"}}`)
time.Sleep(300 * time.Millisecond)
// tool_call
s.sse.Broadcast("agent_output", `{"type":"tool_call","payload":{"tool":"mock_tool","args":{},"id":"call_001"}}`)
time.Sleep(500 * time.Millisecond)
// channel_output
s.sse.Broadcast("agent_output", `{"type":"channel_output","payload":{"kind":"channel_output","channel":"mock","content":"这是一条来自模拟后端的测试回复。\n\n- 模拟后端状态: running\n- 版本: 0.9.0\n- 连接测试: ✅ 成功\n\nGUI 所有功能验证正常！"}}`)
time.Sleep(300 * time.Millisecond)
// agent_end
s.sse.Broadcast("agent_output", `{"type":"agent_end","payload":{"agent":"mock"}}`)
}()
writeJSON(w, map[string]string{"status": "queued", "id": "mock_" + time.Now().Format("150405")})
return
}
http.Error(w, "method not allowed", 405)
}
func (s *MockServer) handleChatEvents(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("Connection", "keep-alive")
ch := make(chan string, 100)
s.sse.Add(ch)
defer s.sse.Remove(ch)
// 发送初始连接成功事件
fmt.Fprintf(w, "event: connected\ndata: {\"status\":\"connected\"}\n\n")
w.(http.Flusher).Flush()
ctx := r.Context()
for {
select {
case <-ctx.Done():
return
case msg := <-ch:
fmt.Fprint(w, msg)
w.(http.Flusher).Flush()
}
}
}
func (s *MockServer) handleMemoryGraph(w http.ResponseWriter, r *http.Request) {
writeJSON(w, map[string]interface{}{
"nodes": []map[string]interface{}{
{"id": "1", "label": "HomeAgent", "group": "system"},
{"id": "2", "label": "GUI 测试", "group": "user"},
},
"edges": []map[string]interface{}{
{"from": "1", "to": "2", "label": "connected"},
},
})
}
func (s *MockServer) handleMemory(w http.ResponseWriter, r *http.Request) {
writeJSON(w, []MemoryItem{
{ID: "m1", Content: "这是模拟内存中的测试数据", Time: time.Now().Format(time.RFC3339)},
})
}
func (s *MockServer) handleMemoryContext(w http.ResponseWriter, r *http.Request) {
writeJSON(w, map[string]interface{}{
"context": "模拟上下文：用户正在测试 GUI 功能",
"items": []MemoryItem{},
})
}
func (s *MockServer) handleKnowledge(w http.ResponseWriter, r *http.Request) {
if r.Method == "POST" {
writeJSON(w, map[string]string{"status": "saved"})
return
}
writeJSON(w, []map[string]interface{}{
{"id": "k1", "title": "模拟知识条目1", "content": "这是模拟知识库的测试内容"},
{"id": "k2", "title": "模拟知识条目2", "content": "GUI 功能验证测试数据"},
})
}
func (s *MockServer) handleTerminals(w http.ResponseWriter, r *http.Request) {
writeJSON(w, []map[string]interface{}{
{"id": "t1", "name": "终端 1", "status": "running"},
{"id": "t2", "name": "终端 2", "status": "idle"},
})
}
func (s *MockServer) handleCmdHistory(w http.ResponseWriter, r *http.Request) {
writeJSON(w, []map[string]interface{}{
{"cmd": "echo hello", "time": time.Now().Add(-5 * time.Minute).Format(time.RFC3339)},
{"cmd": "ls -la", "time": time.Now().Add(-10 * time.Minute).Format(time.RFC3339)},
})
}
func (s *MockServer) handleDevices(w http.ResponseWriter, r *http.Request) {
path := strings.TrimPrefix(r.URL.Path, "/api/v1/device")
path = strings.TrimSuffix(path, "/")
switch {
case path == "/online" || path == "":
writeJSON(w, s.devices)
case path == "/auth" && r.Method == "POST":
var req struct {
DeviceID string `json:"device_id"`
Authorized bool `json:"authorize"`
}
json.NewDecoder(r.Body).Decode(&req)
s.mu.Lock()
for i := range s.devices {
if s.devices[i].DeviceID == req.DeviceID {
s.devices[i].Authorized = req.Authorized
}
}
s.mu.Unlock()
writeJSON(w, map[string]interface{}{
"authorized": true,
"device_id": req.DeviceID,
})
case path == "/push" && r.Method == "POST":
writeJSON(w, map[string]string{"status": "pushed"})
default:
http.NotFound(w, r)
}
}
func (s *MockServer) handleAdapters(w http.ResponseWriter, r *http.Request) {
path := strings.TrimPrefix(r.URL.Path, "/api/v1/adapters")
path = strings.TrimSuffix(path, "/")
switch {
case path == "" && r.Method == "GET":
writeJSON(w, s.adapters)
case path == "" && r.Method == "POST":
var a Adapter
if err := json.NewDecoder(r.Body).Decode(&a); err == nil {
s.mu.Lock()
s.adapters = append(s.adapters, a)
s.mu.Unlock()
}
writeJSON(w, map[string]string{"status": "added"})
case strings.Count(path, "/") == 1 && r.Method == "DELETE":
name := strings.TrimPrefix(path, "/")
s.mu.Lock()
for i := range s.adapters {
if s.adapters[i].Name == name {
s.adapters = append(s.adapters[:i], s.adapters[i+1:]...)
break
}
}
s.mu.Unlock()
writeJSON(w, map[string]string{"status": "deleted"})
default:
http.NotFound(w, r)
}
}
func (s *MockServer) handleWebSocket(w http.ResponseWriter, r *http.Request) {
// 简单返回 400，GUI 的 main.js 会尝试连接设备桥 WS
// 这里只验证 HTTP 路由可达
http.Error(w, "WebSocket upgrade required (mock server)", 400)
}
// ===== 路由注册 =====
func (s *MockServer) registerRoutes(mux *http.ServeMux) {
mux.HandleFunc("/api/v1/status", s.handleStatus)
mux.HandleFunc("/api/v1/kernel", s.handleKernel)
mux.HandleFunc("/api/v1/settings", s.handleSettings)
mux.HandleFunc("/api/v1/plugins", s.handlePlugins)
mux.HandleFunc("/api/v1/plugins/", s.handlePlugins)
mux.HandleFunc("/api/v1/chat/history", s.handleChatHistory)
mux.HandleFunc("/api/v1/chat", s.handleChat)
mux.HandleFunc("/api/v1/chat/events", s.handleChatEvents)
mux.HandleFunc("/api/v1/memory/graph", s.handleMemoryGraph)
mux.HandleFunc("/api/v1/memory", s.handleMemory)
mux.HandleFunc("/api/v1/memory/context", s.handleMemoryContext)
mux.HandleFunc("/api/v1/knowledge", s.handleKnowledge)
mux.HandleFunc("/api/v1/terminals", s.handleTerminals)
mux.HandleFunc("/api/v1/cmd/history", s.handleCmdHistory)
mux.HandleFunc("/api/v1/device", s.handleDevices)
mux.HandleFunc("/api/v1/device/", s.handleDevices)
mux.HandleFunc("/api/v1/adapters", s.handleAdapters)
mux.HandleFunc("/api/v1/adapters/", s.handleAdapters)
mux.HandleFunc("/api/v1/device/ws", s.handleDeviceWS)
}
func writeJSON(w http.ResponseWriter, v interface{}) {
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(v)
}
func main() {
server := NewMockServer()
mux := http.NewServeMux()
server.registerRoutes(mux)
addr := ":9099"
log.Printf("=== HomeAgent Mock Server ====")
log.Printf("监听地址: http://0.0.0.0%s", addr)
log.Printf("API 基础路径: http://0.0.0.0%s/api/v1/", addr)
log.Printf("SSE 端点: http://0.0.0.0%s/api/v1/chat/events", addr)
log.Printf("设备桥 WS: ws://0.0.0.0%s/api/v1/device/ws", addr)
log.Printf("==============================")
log.Fatal(http.ListenAndServe(addr, server.middleware(mux)))
}

472
cmd/mock-server/ws.go Normal file
View File

@ -0,0 +1,472 @@
package main
import (
"bufio"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/binary"
"encoding/json"
"fmt"
"io"
"log"
"net"
"net/http"
"sync"
"time"
"gitcode.com/JianFeeeee/HomeAgent/internal/devicebridge/client"
)
// ===== WebSocket 帧编码/解码（RFC 6455） =====
const wsGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
type WSConn struct {
conn net.Conn
rw *bufio.ReadWriter
mu sync.Mutex
}
func upgradeWS(w http.ResponseWriter, r *http.Request) (*WSConn, error) {
if r.Header.Get("Upgrade") != "websocket" {
http.Error(w, "not websocket", 400)
return nil, fmt.Errorf("not websocket upgrade")
}
key := r.Header.Get("Sec-WebSocket-Key")
if key == "" {
http.Error(w, "missing key", 400)
return nil, fmt.Errorf("missing Sec-WebSocket-Key")
}
h := sha256.Sum256([]byte(key + wsGUID))
accept := base64.StdEncoding.EncodeToString(h[:])
hijacker, ok := w.(http.Hijacker)
if !ok {
http.Error(w, "hijack not supported", 500)
return nil, fmt.Errorf("hijack not supported")
}
conn, bufrw, err := hijacker.Hijack()
if err != nil {
http.Error(w, "hijack failed", 500)
return nil, err
}
resp := "HTTP/1.1 101 Switching Protocols\r\n" +
"Upgrade: websocket\r\n" +
"Connection: Upgrade\r\n" +
"Sec-WebSocket-Accept: " + accept + "\r\n\r\n"
if _, err := bufrw.WriteString(resp); err != nil {
conn.Close()
return nil, err
}
if err := bufrw.Flush(); err != nil {
conn.Close()
return nil, err
}
return &WSConn{conn: conn, rw: bufrw}, nil
}
func (ws *WSConn) ReadFrame() (opcode byte, payload []byte, err error) {
for {
b0, err := ws.rw.ReadByte()
if err != nil {
return 0, nil, err
}
opcode = b0 & 0x0F
b1, err := ws.rw.ReadByte()
if err != nil {
return 0, nil, err
}
masked := b1&0x80 != 0
length := int64(b1 & 0x7F)
switch {
case length == 126:
var b [2]byte
if _, err := io.ReadFull(ws.rw, b[:]); err != nil {
return 0, nil, err
}
length = int64(binary.BigEndian.Uint16(b[:]))
case length == 127:
var b [8]byte
if _, err := io.ReadFull(ws.rw, b[:]); err != nil {
return 0, nil, err
}
length = int64(binary.BigEndian.Uint64(b[:]))
}
var maskKey [4]byte
if masked {
if _, err := io.ReadFull(ws.rw, maskKey[:]); err != nil {
return 0, nil, err
}
}
payload = make([]byte, length)
if _, err := io.ReadFull(ws.rw, payload); err != nil {
return 0, nil, err
}
if masked {
for i := range payload {
payload[i] ^= maskKey[i%4]
}
}
if opcode == 0x8 { // Close
ws.sendFrame(0x8, nil, false)
return opcode, payload, fmt.Errorf("ws closed")
}
if opcode == 0x9 { // Ping
ws.sendFrame(0xA, payload, false) // Pong
continue
}
if opcode == 0xA { // Pong
continue
}
return opcode, payload, nil
}
}
func (ws *WSConn) sendFrame(opcode byte, payload []byte, masked bool) error {
ws.mu.Lock()
defer ws.mu.Unlock()
buf := []byte{0x80 | opcode} // FIN + opcode
length := len(payload)
switch {
case length <= 125:
if masked {
buf = append(buf, byte(length)|0x80)
} else {
buf = append(buf, byte(length))
}
case length <= 65535:
if masked {
buf = append(buf, 126|0x80)
} else {
buf = append(buf, 126)
}
b := make([]byte, 2)
binary.BigEndian.PutUint16(b, uint16(length))
buf = append(buf, b...)
default:
if masked {
buf = append(buf, 127|0x80)
} else {
buf = append(buf, 127)
}
b := make([]byte, 8)
binary.BigEndian.PutUint64(b, uint64(length))
buf = append(buf, b...)
}
var maskKey [4]byte
if masked {
rand.Read(maskKey[:])
buf = append(buf, maskKey[:]...)
maskedPayload := make([]byte, length)
copy(maskedPayload, payload)
for i := range maskedPayload {
maskedPayload[i] ^= maskKey[i%4]
}
buf = append(buf, maskedPayload...)
} else {
buf = append(buf, payload...)
}
_, err := ws.conn.Write(buf)
return err
}
func (ws *WSConn) WriteJSON(v interface{}) error {
b, err := json.Marshal(v)
if err != nil {
return err
}
return ws.sendFrame(0x1, b, false) // Text frame
}
func (ws *WSConn) ReadJSON(v interface{}) error {
_, payload, err := ws.ReadFrame()
if err != nil {
return err
}
return json.Unmarshal(payload, v)
}
func (ws *WSConn) Close() {
ws.sendFrame(0x8, nil, false)
ws.conn.Close()
}
// ===== Mock Remotedevice 设备桥 =====
type MockDevice struct {
DeviceID string
Name string
Caps []string
Conn *WSConn
Online bool
}
type MockRemoteDevice struct {
mu sync.Mutex
devices map[string]*MockDevice
}
func NewMockRemoteDevice() *MockRemoteDevice {
return &MockRemoteDevice{
devices: make(map[string]*MockDevice),
}
}
func (s *MockServer) handleDeviceWS(w http.ResponseWriter, r *http.Request) {
ws, err := upgradeWS(w, r)
if err != nil {
log.Printf("[ws] upgrade failed: %v", err)
return
}
defer ws.Close()
log.Printf("[ws] 新设备连接")
// 处理 hello/bind/cmd 协议
var device *MockDevice
for {
var msg struct {
Op string `json:"op"`
DeviceID string `json:"device_id"`
Token string `json:"token"`
ReqID string `json:"req_id"`
Command string `json:"command"`
CmdType string `json:"cmd_type"`
Status string `json:"status"`
Output string `json:"output"`
Error string `json:"error"`
Device json.RawMessage `json:"device"`
Payload json.RawMessage `json:"payload"`
}
if err := ws.ReadJSON(&msg); err != nil {
log.Printf("[ws] read error: %v", err)
break
}
switch msg.Op {
case "hello":
var devMeta struct {
DeviceID string `json:"device_id"`
Name string `json:"name"`
Kind string `json:"kind"`
Caps []string `json:"caps"`
}
json.Unmarshal(msg.Device, &devMeta)
device = &MockDevice{
DeviceID: devMeta.DeviceID,
Name: devMeta.Name,
Caps: devMeta.Caps,
Conn: ws,
Online: true,
}
s.mu.Lock()
// 更新设备列表
found := false
for i := range s.devices {
if s.devices[i].DeviceID == devMeta.DeviceID {
s.devices[i].Online = true
s.devices[i].Caps = devMeta.Caps
found = true
break
}
}
if !found {
s.devices = append(s.devices, Device{
DeviceID: devMeta.DeviceID,
Name: devMeta.Name,
Authorized: false,
Online: true,
Caps: devMeta.Caps,
})
}
s.mu.Unlock()
ws.WriteJSON(map[string]interface{}{
"op": "hello_ack",
"code": 0,
})
log.Printf("[ws] 设备登记: %s (%s) caps=%v", devMeta.DeviceID, devMeta.Name, devMeta.Caps)
case "bind":
if msg.DeviceID == "" || msg.Token == "" {
ws.WriteJSON(map[string]interface{}{
"op": "bind_ack",
"code": 1,
"error": "missing device_id or token",
})
break
}
s.mu.Lock()
for i := range s.devices {
if s.devices[i].DeviceID == msg.DeviceID {
s.devices[i].Authorized = true
}
}
s.mu.Unlock()
ws.WriteJSON(map[string]interface{}{
"op": "bind_ack",
"code": 0,
})
log.Printf("[ws] 设备授权: %s", msg.DeviceID)
// 绑定成功后，发送全量能力测试命令序列
go func() {
time.Sleep(500 * time.Millisecond)
// 测试 1: screensee 截图
log.Printf("[ws] 发命令 1/7: homeagent-screensee")
ws.WriteJSON(client.CmdMsg{
Op: "cmd",
ReqID: "test_1_screensee_" + fmt.Sprintf("%d", time.Now().UnixMilli()),
Command: "homeagent-screensee",
CmdType: "homeagent",
})
time.Sleep(800 * time.Millisecond)
// 测试 2: clipboardsue 写入剪贴板
log.Printf("[ws] 发命令 2/7: homeagent-clipboardsue")
ws.WriteJSON(client.CmdMsg{
Op: "cmd",
ReqID: "test_2_clipboardsue_" + fmt.Sprintf("%d", time.Now().UnixMilli()),
Command: "homeagent-clipboardsue HomeAgent远程测试_" + fmt.Sprintf("%d", time.Now().UnixMilli()),
CmdType: "homeagent",
})
time.Sleep(800 * time.Millisecond)
// 测试 3: clipboardsee 读取剪贴板
log.Printf("[ws] 发命令 3/7: homeagent-clipboardsee")
ws.WriteJSON(client.CmdMsg{
Op: "cmd",
ReqID: "test_3_clipboardsee_" + fmt.Sprintf("%d", time.Now().UnixMilli()),
Command: "homeagent-clipboardsee",
CmdType: "homeagent",
})
time.Sleep(800 * time.Millisecond)
// 测试 4: computeruse 鼠标移动（使用非标准 JSON 格式测试兼容性）
log.Printf("[ws] 发命令 4/7: homeagent-computeruse move")
ws.WriteJSON(client.CmdMsg{
Op: "cmd",
ReqID: "test_4_computeruse_" + fmt.Sprintf("%d", time.Now().UnixMilli()),
Command: `homeagent-computeruse move {x:500,y:300}`,
CmdType: "homeagent",
})
time.Sleep(800 * time.Millisecond)
// 测试 4b: computeruse 鼠标点击（标准 JSON 格式）
log.Printf("[ws] 发命令 4b/7: homeagent-computeruse click")
ws.WriteJSON(client.CmdMsg{
Op: "cmd",
ReqID: "test_4b_click_" + fmt.Sprintf("%d", time.Now().UnixMilli()),
Command: `homeagent-computeruse {"x":800,"y":500,"action":"click","button":"left"}`,
CmdType: "homeagent",
})
time.Sleep(800 * time.Millisecond)
// 测试 5: speakeruse TTS 播报
log.Printf("[ws] 发命令 5/7: homeagent-speakeruse")
ws.WriteJSON(client.CmdMsg{
Op: "cmd",
ReqID: "test_5_speakeruse_" + fmt.Sprintf("%d", time.Now().UnixMilli()),
Command: "homeagent-speakeruse 你好，这是来自远程Mock服务器的测试播报",
CmdType: "homeagent",
})
time.Sleep(800 * time.Millisecond)
// 测试 6: screensue 弹窗显示
log.Printf("[ws] 发命令 6/7: homeagent-screensue（HTML）")
ws.WriteJSON(client.CmdMsg{
Op: "cmd",
ReqID: "test_6_screensue_" + fmt.Sprintf("%d", time.Now().UnixMilli()),
Command: `homeagent-screensue 10 <!DOCTYPE html><html><head><meta charset="utf-8"><style>body{background:linear-gradient(135deg,#667eea,#764ba2);color:white;font-family:sans-serif;padding:30px;margin:0}h1{font-size:32px;text-shadow:0 2px 8px rgba(0,0,0,0.3)}.card{background:rgba(255,255,255,0.15);border-radius:12px;padding:20px;margin:12px 0;backdrop-filter:blur(8px)}.badge{display:inline-block;background:#4ade80;color:#000;padding:3px 10px;border-radius:16px;font-weight:bold}</style></head><body><h1>HomeAgent GUI 全量测试</h1><div class="card"><h2>能力测试结果</h2><table border="1" cellpadding="6" style="border-collapse:collapse;width:100%"><tr><th>能力</th><th>结果</th></tr><tr><td>screensee 截图</td><td><span class="badge">通过</span></td></tr><tr><td>clipboard 读写</td><td><span class="badge">通过</span></td></tr><tr><td>computeruse 操控</td><td><span class="badge">通过</span></td></tr><tr><td>speakeruse TTS</td><td><span class="badge">通过</span></td></tr><tr><td>screensue 渲染</td><td><span class="badge">通过</span></td></tr></table></div><p style="text-align:center;color:rgba(255,255,255,0.7)">2026-08-23 19:50</p></body></html>`,
CmdType: "homeagent",
})
time.Sleep(800 * time.Millisecond)
// 测试 7: omniparse 解析当前窗口 UI 元素
log.Printf("[ws] 发命令 7/7: homeagent-omniparse")
ws.WriteJSON(client.CmdMsg{
Op: "cmd",
ReqID: "test_7_omniparse_" + fmt.Sprintf("%d", time.Now().UnixMilli()),
Command: "homeagent-omniparse",
CmdType: "homeagent",
})
}()
case "cmd_result":
log.Printf("[ws] 命令结果: req=%s status=%s", msg.ReqID, msg.Status)
if msg.Output != "" {
output := msg.Output
if len(output) > 100 {
output = output[:100] + "..."
}
log.Printf("[ws] 输出: %s", output)
}
if msg.Error != "" {
log.Printf("[ws] 错误: %s", msg.Error)
}
case "data_start":
var ds client.DataStart
json.Unmarshal(msg.Payload, &ds)
log.Printf("[ws] 二进制数据开始: req=%s kind=%s mime=%s total=%d", ds.ReqID, ds.Kind, ds.MIME, ds.Total)
case "data_end":
log.Printf("[ws] 二进制数据结束: req=%s status=%s", msg.ReqID, msg.Status)
case "speech_start":
log.Printf("[ws] TTS 音频开始: req=%s", msg.ReqID)
case "speech_end":
log.Printf("[ws] TTS 音频结束: req=%s", msg.ReqID)
case "status":
log.Printf("[ws] 状态上报: %s -> %s", msg.DeviceID, msg.Status)
case "event":
log.Printf("[ws] 事件上报: %s type=%s", msg.DeviceID, string(msg.Payload))
default:
log.Printf("[ws] 未知消息类型: %s", msg.Op)
}
}
if device != nil {
device.Online = false
s.mu.Lock()
for i := range s.devices {
if s.devices[i].DeviceID == device.DeviceID {
s.devices[i].Online = false
}
}
s.mu.Unlock()
}
log.Printf("[ws] 设备断开")
}

974
cmd/waiter/device.go
View File

File diff suppressed because it is too large Load Diff

39
cmd/waiter/main.go
View File

@ -83,8 +83,16 @@ func main() {
say := flag.String("say", "", "deprecated alias of -chat")
deviceGateway := flag.String("device", "", "remotedevice 网关地址（如 127.0.0.1:9890），启动设备桥")
deviceToken := flag.String("device-token", "", "设备接入 token")
testCap := flag.String("test-cap", "", "测试本地能力（screensue/speakeruse/screensee/clipboardsee/clipboardsue/computeruse/camerasue），如 --test-cap screensue")
testCapArgs := flag.String("test-cap-args", "", "测试能力的参数")
flag.Parse()
// 本地能力测试模式（无需连接服务器）
if *testCap != "" {
runCapTest(*testCap, *testCapArgs)
return
}
cfg := discoverConfig(*configPath)
cfg.MergeCLI(*socket, *remote, *apiKey)
cfg.ApplyDefault()
@ -106,7 +114,6 @@ func main() {
defer state.Disconnect()
// 设备桥：--device 或配置 device_gateway 时，waiter 作为被控设备接入 remotedevice
var bridge *deviceBridge
dg := *deviceGateway
if dg == "" {
dg = cfg.DeviceGateway
@ -116,12 +123,11 @@ func main() {
dt = cfg.DeviceToken
}
if dg != "" && dt != "" {
bridge = newDeviceBridge(dg, dt)
if err := bridge.Start(); err != nil {
if err := startDeviceBridge(dg, dt); err != nil {
printlnC(colorYellow, fmt.Sprintf("device bridge: %v (continue without)", err))
} else {
printlnC(colorGreen, "device bridge active: "+bridge.deviceID)
defer bridge.Stop()
printlnC(colorGreen, "device bridge active: "+deviceBridgeID)
defer stopDeviceBridge()
}
}
@ -129,6 +135,7 @@ func main() {
oneshot(state, oneShotMsg)
return
}
runInteractive(state, cfg)
}
@ -141,6 +148,28 @@ func oneshot(state *State, msg string) {
fmt.Println(resp)
}
// runCapTest 本地能力测试（无需连接服务器）
func runCapTest(capName, args string) {
fmt.Printf("=== 测试能力: %s ===\n", capName)
fmt.Printf("参数: %s\n", args)
fmt.Println("===========================")
// 覆盖 sendBridgeResult 为本地打印
sendBridgeResult = func(reqID, status, output, errMsg string) {
fmt.Printf("结果状态: %s\n", status)
if output != "" {
fmt.Printf("输出: %s\n", output)
}
if errMsg != "" {
fmt.Printf("错误: %s\n", errMsg)
}
}
handleHomeagentCmd("test-001", "homeagent-"+capName+" "+args)
fmt.Println("===========================")
fmt.Println("测试完成")
}
func runInteractive(state *State, cfg *Config) {
sigCh := make(chan os.Signal, 1)
signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)

101
internal/devicebridge/client/binary.go Normal file
View File

@ -0,0 +1,101 @@
package client
// BinaryChunker 提供二进制数据分块传输功能。
// 用于将大体积数据（如录像 mp4、大图片）按分块协议发送。
// 协议:
// cmd_data_start {op, req_id, kind, total, chunk_size, mime} —— 文本帧
// <N 个二进制帧 0x2> —— data bytes
// cmd_data_end {op, req_id, status:ok|error, error?} —— 文本帧
const (
// DefaultChunkSize 默认分块大小（8KB）
DefaultChunkSize = 8192
// MaxBinaryFrameSize 二进制帧最大大小（8MB）
MaxBinaryFrameSize = 8 << 20
)
// ChunkCallback 分块发送回调，用于逐块处理。
type ChunkCallback func(chunk []byte) error
// ChunkData 将数据按指定大小分块。
func ChunkData(data []byte, chunkSize int) [][]byte {
if chunkSize <= 0 {
chunkSize = DefaultChunkSize
}
total := len(data)
var chunks [][]byte
for off := 0; off < total; off += chunkSize {
end := off + chunkSize
if end > total {
end = total
}
chunks = append(chunks, data[off:end])
}
return chunks
}
// SendChunked 使用回调逐块发送数据。
func SendChunked(data []byte, chunkSize int, fn ChunkCallback) error {
if chunkSize <= 0 {
chunkSize = DefaultChunkSize
}
chunks := ChunkData(data, chunkSize)
for _, chunk := range chunks {
if err := fn(chunk); err != nil {
return err
}
}
return nil
}
// ===== 数据聚合（接收端） =====
// DataAccumulator 聚合从设备接收的二进制分块数据。
type DataAccumulator struct {
ReqID string
Kind string
MIME string
Total int
Got int
Chunks [][]byte
}
// NewDataAccumulator 创建数据聚合器。
func NewDataAccumulator(reqID, kind, mime string, total int) *DataAccumulator {
return &DataAccumulator{
ReqID: reqID,
Kind: kind,
MIME: mime,
Total: total,
Chunks: make([][]byte, 0),
}
}
// Append 追加一块数据。
func (da *DataAccumulator) Append(chunk []byte) {
da.Chunks = append(da.Chunks, chunk)
da.Got += len(chunk)
}
// Assemble 聚合所有分块为完整数据。
func (da *DataAccumulator) Assemble() []byte {
total := 0
for _, c := range da.Chunks {
total += len(c)
}
data := make([]byte, 0, total)
for _, c := range da.Chunks {
data = append(data, c...)
}
return data
}
// ExceededLimit 检查是否超出限制（声明的 2 倍或硬上限 64MB）。
func (da *DataAccumulator) ExceededLimit() bool {
limit := da.Total*2 + 1024
if limit < 64<<20 {
limit = 64 << 20
}
return da.Got > limit
}

483
internal/devicebridge/client/bridge.go Normal file
View File

@ -0,0 +1,483 @@
package client
import (
"encoding/json"
"fmt"
"log"
"os"
"runtime"
"sync"
"time"
)
// CmdHandler 是命令处理回调类型。
// 当收到 remotedevice 下发的 cmd 时调用，reqID 用于回执，command 是命令内容。
type CmdHandler func(reqID, command string)
// CmdResult 是命令执行结果回调（用于异步通知 GUI 层）。
type CmdResultHandler func(reqID, status, output, errMsg string)
// DataHandler 是二进制数据接收回调（如 TTS 音频）。
type DataHandler func(reqID, kind, mime string, data []byte)
// Bridge 是设备桥客户端核心结构体。
// 管理 WebSocket 连接、消息路由、心跳保活和命令分发。
type Bridge struct {
mu sync.RWMutex
gateway string
token string
deviceID string
name string
kind string
caps []string
info map[string]interface{}
ws *wsConn
stopCh chan struct{}
doneCh chan struct{}
started bool
// 回调
cmdHandler CmdHandler
resultHandler CmdResultHandler
dataHandler DataHandler
// 二进制数据聚合（服务端→设备，如 TTS 音频）
speechAccum *speechBuffer
// 心跳间隔
pingInterval time.Duration
}
// speechBuffer 聚合服务端分块推送的二进制数据。
type speechBuffer struct {
reqID string
kind string
mime string
total int
data []byte
}
// New 创建设备桥客户端。
// gateway: ws://host:port（可选 /api/v1/device/ws 路径）
// token: 接入令牌
// deviceID: 设备唯一标识
// name: 设备显示名称
// caps: 能力列表（如 ["status","cmdrun","screensee","computeruse"]）
// info: 额外设备信息（hostname, platform, arch 等），可为 nil
func New(gateway, token, deviceID, name string, caps []string, info map[string]interface{}) *Bridge {
if info == nil {
info = make(map[string]interface{})
}
// 填充默认信息
if _, ok := info["hostname"]; !ok {
hostname, _ := os.Hostname()
info["hostname"] = hostname
}
if _, ok := info["platform"]; !ok {
info["platform"] = runtime.GOOS
}
if _, ok := info["arch"]; !ok {
info["arch"] = runtime.GOARCH
}
if _, ok := info["cpus"]; !ok {
info["cpus"] = runtime.NumCPU()
}
return &Bridge{
gateway: gateway,
token: token,
deviceID: deviceID,
name: name,
kind: "computer",
caps: caps,
info: info,
stopCh: make(chan struct{}),
doneCh: make(chan struct{}),
pingInterval: 30 * time.Second,
}
}
// OnCmd 注册命令处理器。当收到 remotedevice 下发的 cmd 时调用。
func (b *Bridge) OnCmd(handler CmdHandler) {
b.mu.Lock()
defer b.mu.Unlock()
b.cmdHandler = handler
}
// OnResult 注册命令结果回调（用于异步通知）。
func (b *Bridge) OnResult(handler CmdResultHandler) {
b.mu.Lock()
defer b.mu.Unlock()
b.resultHandler = handler
}
// OnData 注册二进制数据接收回调（如 TTS 音频）。
func (b *Bridge) OnData(handler DataHandler) {
b.mu.Lock()
defer b.mu.Unlock()
b.dataHandler = handler
}
// SetPingInterval 设置心跳间隔（默认 30 秒）。
func (b *Bridge) SetPingInterval(d time.Duration) {
b.mu.Lock()
defer b.mu.Unlock()
b.pingInterval = d
}
// Start 启动设备桥连接。
// 会阻塞直到连接建立或超时失败。
func (b *Bridge) Start() error {
b.mu.Lock()
if b.started {
b.mu.Unlock()
return fmt.Errorf("devicebridge: already started")
}
b.started = true
b.mu.Unlock()
ws, err := dialWS(b.gateway, b.token, 10*time.Second)
if err != nil {
b.mu.Lock()
b.started = false
b.mu.Unlock()
return fmt.Errorf("devicebridge: dial: %w", err)
}
b.mu.Lock()
b.ws = ws
b.mu.Unlock()
// 发送 hello
b.sendJSON(map[string]interface{}{
"op": "hello",
"device": map[string]interface{}{
"device_id": b.deviceID,
"name": b.name,
"kind": b.kind,
"caps": b.caps,
"info": b.info,
},
})
// 发送 bind
b.sendJSON(map[string]interface{}{
"op": "bind",
"device_id": b.deviceID,
"token": b.token,
})
go b.readLoop()
go b.pingLoop()
return nil
}
// Stop 停止设备桥连接。
func (b *Bridge) Stop() {
b.mu.Lock()
defer b.mu.Unlock()
if !b.started {
return
}
select {
case <-b.stopCh:
return
default:
close(b.stopCh)
}
if b.ws != nil {
_ = b.ws.close()
b.ws = nil
}
}
// Wait 等待设备桥连接关闭。
func (b *Bridge) Wait() {
<-b.doneCh
}
// DeviceID 返回设备 ID。
func (b *Bridge) DeviceID() string {
b.mu.RLock()
defer b.mu.RUnlock()
return b.deviceID
}
// Connected 返回是否已连接。
func (b *Bridge) Connected() bool {
b.mu.RLock()
defer b.mu.RUnlock()
return b.ws != nil && !b.ws.closed
}
// ===== 发送消息 =====
// SendResult 发送命令执行结果。
func (b *Bridge) SendResult(reqID, status, output, errMsg string) {
msg := map[string]interface{}{
"op": "cmd_result",
"req_id": reqID,
"status": status,
"device_id": b.deviceID,
}
if output != "" {
msg["output"] = output
}
if errMsg != "" {
msg["error"] = errMsg
}
b.sendJSON(msg)
}
// SendDataStart 开始二进制数据传输（设备→网关，如录像回传）。
func (b *Bridge) SendDataStart(reqID, kind, mime string, total int) {
b.sendJSON(map[string]interface{}{
"op": "cmd_data_start",
"req_id": reqID,
"kind": kind,
"mime": mime,
"total": total,
"chunk_size": 8192,
})
}
// SendDataChunk 发送一块二进制数据。
func (b *Bridge) SendDataChunk(data []byte) error {
b.mu.RLock()
ws := b.ws
b.mu.RUnlock()
if ws == nil || ws.closed {
return fmt.Errorf("devicebridge: not connected")
}
return ws.writeBinary(data)
}
// SendDataEnd 结束二进制数据传输。
func (b *Bridge) SendDataEnd(reqID, status, errMsg string) {
msg := map[string]interface{}{
"op": "cmd_data_end",
"req_id": reqID,
"status": status,
}
if errMsg != "" {
msg["error"] = errMsg
}
b.sendJSON(msg)
}
// SendDataChunked 便捷方法：自动分块发送完整二进制数据。
func (b *Bridge) SendDataChunked(reqID, kind, mime string, data []byte) {
total := len(data)
b.SendDataStart(reqID, kind, mime, total)
const chunkSize = 8192
for off := 0; off < total; off += chunkSize {
end := off + chunkSize
if end > total {
end = total
}
if err := b.SendDataChunk(data[off:end]); err != nil {
b.SendDataEnd(reqID, "error", err.Error())
return
}
}
b.SendDataEnd(reqID, "ok", "")
}
// SendEvent 发送设备主动上报事件。
func (b *Bridge) SendEvent(eventType string, payload interface{}) {
b.sendJSON(map[string]interface{}{
"op": "event",
"device_id": b.deviceID,
"type": eventType,
"payload": payload,
})
}
// SendStatus 发送设备状态更新。
func (b *Bridge) SendStatus(status string) {
b.sendJSON(map[string]interface{}{
"op": "status",
"device_id": b.deviceID,
"status": status,
})
}
// ===== 内部方法 =====
func (b *Bridge) sendJSON(v interface{}) {
b.mu.RLock()
ws := b.ws
b.mu.RUnlock()
if ws == nil || ws.closed {
return
}
payload := mustJSON(v)
_ = ws.writeText(payload)
}
func (b *Bridge) readLoop() {
defer func() {
b.mu.Lock()
b.started = false
if b.ws != nil {
_ = b.ws.close()
b.ws = nil
}
b.mu.Unlock()
close(b.doneCh)
}()
for {
select {
case <-b.stopCh:
return
default:
}
// 设置读超时（2 倍 ping 间隔）
b.mu.RLock()
ws := b.ws
interval := b.pingInterval
b.mu.RUnlock()
if ws == nil {
return
}
ws.setDeadline(time.Now().Add(interval * 2))
payload, isClose, opcode, err := ws.readFrame()
if err != nil {
if err == errPing {
_ = ws.writePong()
continue
}
// 超时或其他错误，退出
return
}
if isClose {
return
}
if opcode == 0x2 {
// 二进制帧：处于聚合状态时追加
b.handleBinaryFrame(payload)
continue
}
var msg map[string]interface{}
if err := json.Unmarshal(payload, &msg); err != nil {
continue
}
b.handleMessage(msg)
}
}
func (b *Bridge) handleMessage(msg map[string]interface{}) {
op, _ := msg["op"].(string)
switch op {
case "cmd":
reqID, _ := msg["req_id"].(string)
command, _ := msg["command"].(string)
cmdType, _ := msg["cmd_type"].(string)
if reqID == "" || command == "" {
return
}
// 记录日志
log.Printf("[devicebridge] cmd req=%s type=%s cmd=%s", reqID, cmdType, truncateString(command, 60))
b.mu.RLock()
handler := b.cmdHandler
b.mu.RUnlock()
if handler != nil {
handler(reqID, command)
}
case "hello_ack", "bind_ack":
log.Printf("[devicebridge] %s device=%v", op, msg["device"])
case "cmd_speech_start":
reqID, _ := msg["req_id"].(string)
kind, _ := msg["kind"].(string)
mime, _ := msg["mime"].(string)
total := 0
if v, ok := msg["total"].(float64); ok {
total = int(v)
}
b.mu.Lock()
b.speechAccum = &speechBuffer{
reqID: reqID,
kind: kind,
mime: mime,
total: total,
}
b.mu.Unlock()
case "cmd_speech_end":
reqID, _ := msg["req_id"].(string)
b.mu.Lock()
acc := b.speechAccum
b.speechAccum = nil
b.mu.Unlock()
if acc == nil || acc.reqID != reqID {
return
}
data := acc.data
b.mu.RLock()
dh := b.dataHandler
b.mu.RUnlock()
if dh != nil {
dh(reqID, acc.kind, acc.mime, data)
}
default:
log.Printf("[devicebridge] unhandled op=%s", op)
}
}
func (b *Bridge) handleBinaryFrame(payload []byte) {
b.mu.Lock()
defer b.mu.Unlock()
if b.speechAccum == nil {
return
}
b.speechAccum.data = append(b.speechAccum.data, payload...)
// 防滥用：超出声明 total 的 2 倍或硬上限 64MB 时放弃
limit := b.speechAccum.total*2 + 1024
if limit < 64<<20 {
limit = 64 << 20
}
if len(b.speechAccum.data) > limit {
log.Printf("[devicebridge] speech data exceeded limit, dropped")
b.speechAccum = nil
}
}
func (b *Bridge) pingLoop() {
b.mu.RLock()
interval := b.pingInterval
b.mu.RUnlock()
ticker := time.NewTicker(interval)
defer ticker.Stop()
for {
select {
case <-b.stopCh:
return
case <-ticker.C:
b.mu.RLock()
ws := b.ws
b.mu.RUnlock()
if ws != nil && !ws.closed {
_ = ws.writeFrame(0x9, nil) // ping
}
}
}
}
func truncateString(s string, n int) string {
if len(s) <= n {
return s
}
return s[:n] + "..."
}

120
internal/devicebridge/client/cmdrouter.go Normal file
View File

@ -0,0 +1,120 @@
package client
import (
"encoding/json"
"fmt"
"strings"
"sync"
)
// CmdRouter 命令路由器，支持按命令前缀分发到不同 handler。
// 用于 CLI 和 GUI 根据能力类型注册不同的执行函数。
type CmdRouter struct {
mu sync.RWMutex
prefixes map[string]CmdHandler
default_ CmdHandler
}
// NewCmdRouter 创建命令路由器。
func NewCmdRouter() *CmdRouter {
return &CmdRouter{
prefixes: make(map[string]CmdHandler),
}
}
// Handle 注册匹配指定前缀的命令处理器。
// 例如 Handle("homeagent-", homeagentHandler) 会处理所有 homeagent-* 命令。
func (r *CmdRouter) Handle(prefix string, handler CmdHandler) {
r.mu.Lock()
defer r.mu.Unlock()
r.prefixes[prefix] = handler
}
// HandleDefault 注册默认命令处理器（无前缀匹配时使用）。
func (r *CmdRouter) HandleDefault(handler CmdHandler) {
r.mu.Lock()
defer r.mu.Unlock()
r.default_ = handler
}
// Dispatch 分发命令到匹配的处理器。
// 返回 true 表示已处理，false 表示无匹配。
func (r *CmdRouter) Dispatch(reqID, command string) bool {
r.mu.RLock()
defer r.mu.RUnlock()
// 先按前缀匹配
for prefix, handler := range r.prefixes {
if strings.HasPrefix(command, prefix) {
handler(reqID, command)
return true
}
}
// 无前缀匹配，使用默认
if r.default_ != nil {
r.default_(reqID, command)
return true
}
return false
}
// ===== 能力解析辅助 =====
// ParseHomeagentCmd 解析 homeagent-* 命令，返回能力名和参数。
// 例如 "homeagent-screensue 5 你好" → ("screensue", "5 你好")
// 也支持 "screensue 5 你好"（无前缀）
func ParseHomeagentCmd(command string) (capability, args string) {
cmd := strings.TrimSpace(command)
// 去掉 homeagent- 前缀
cmd = strings.TrimPrefix(cmd, "homeagent-")
parts := strings.SplitN(cmd, " ", 2)
capability = parts[0]
if len(parts) > 1 {
args = parts[1]
}
return
}
// ParseJSONCmd 解析 JSON 格式的命令参数。
// 例如 "computeruse {\"x\":100,\"y\":200,\"action\":\"click\"}"
// 返回动作名和参数 map。
func ParseJSONCmd(command string) (action string, params map[string]interface{}, err error) {
cmd := strings.TrimSpace(command)
// 去掉 homeagent- 前缀
cmd = strings.TrimPrefix(cmd, "homeagent-")
idx := strings.IndexByte(cmd, '{')
if idx < 0 {
action = cmd
return
}
action = strings.TrimSpace(cmd[:idx])
jsonStr := cmd[idx:]
if err = json.Unmarshal([]byte(jsonStr), &params); err != nil {
err = fmt.Errorf("parse json params: %w", err)
}
return
}
// BaseResult 构造基础命令结果。
func BaseResult(reqID, status, output, errMsg string) map[string]interface{} {
res := map[string]interface{}{
"op": "cmd_result",
"req_id": reqID,
"status": status,
}
if output != "" {
res["output"] = output
}
if errMsg != "" {
res["error"] = errMsg
}
return res
}
// ResultJSON 序列化结果 map 为 JSON。
func ResultJSON(res map[string]interface{}) string {
b, _ := json.Marshal(res)
return string(b)
}

106
internal/devicebridge/client/protocol.go Normal file
View File

@ -0,0 +1,106 @@
// Package client 提供设备桥客户端共享库，实现与 remotedevice 插件通信的完整协议。
// 编译为 C 共享库后，GUI (Electron) 可通过 FFI 调用；CLI (waiter) 可直接导入 Go 包。
package client
import "encoding/json"
// ===== 消息类型（与 remotedevice plugin 协议对齐） =====
// HelloMsg 设备登记消息
type HelloMsg struct {
Op string `json:"op"`
Device DeviceMeta `json:"device"`
}
// DeviceMeta 设备元信息
type DeviceMeta struct {
DeviceID string `json:"device_id"`
Name string `json:"name"`
Kind string `json:"kind"`
Caps []string `json:"caps"`
Info map[string]interface{} `json:"info,omitempty"`
}
// BindMsg 设备绑定消息
type BindMsg struct {
Op string `json:"op"`
DeviceID string `json:"device_id"`
Token string `json:"token"`
}
// CmdMsg 服务端下发的命令消息
type CmdMsg struct {
Op string `json:"op"`
ReqID string `json:"req_id"`
Command string `json:"command"`
CmdType string `json:"cmd_type"`
}
// CmdResult 命令执行结果
type CmdResult struct {
Op string `json:"op"`
ReqID string `json:"req_id"`
Status string `json:"status"`
Output string `json:"output,omitempty"`
Error string `json:"error,omitempty"`
DeviceID string `json:"device_id,omitempty"`
}
// DataStart 二进制数据传输开始（设备→网关）
type DataStart struct {
Op string `json:"op"`
ReqID string `json:"req_id"`
Kind string `json:"kind"`
MIME string `json:"mime"`
Total int `json:"total"`
ChunkSize int `json:"chunk_size,omitempty"`
}
// DataEnd 二进制数据传输结束
type DataEnd struct {
Op string `json:"op"`
ReqID string `json:"req_id"`
Status string `json:"status"`
Total int `json:"total,omitempty"`
Error string `json:"error,omitempty"`
}
// SpeechStart TTS 音频数据开始（网关→设备）
type SpeechStart struct {
Op string `json:"op"`
ReqID string `json:"req_id"`
Kind string `json:"kind"`
MIME string `json:"mime"`
Total int `json:"total"`
}
// SpeechEnd TTS 音频数据结束
type SpeechEnd struct {
Op string `json:"op"`
ReqID string `json:"req_id"`
}
// StatusMsg 设备状态上报
type StatusMsg struct {
Op string `json:"op"`
DeviceID string `json:"device_id"`
Status string `json:"status"`
}
// EventMsg 设备主动上报事件
type EventMsg struct {
Op string `json:"op"`
DeviceID string `json:"device_id,omitempty"`
Type string `json:"type"`
Payload interface{} `json:"payload,omitempty"`
}
// ===== 序列化辅助 =====
func mustJSON(v interface{}) []byte {
b, err := json.Marshal(v)
if err != nil {
return []byte("{}")
}
return b
}

360
internal/devicebridge/client/transport.go Normal file
View File

@ -0,0 +1,360 @@
package client
import (
"bufio"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/binary"
"fmt"
"io"
"net"
"net/url"
"strings"
"time"
)
const (
wsGUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
wsVersion = "13"
crlf = "\r\n"
)
// wsConn 封装一条 WebSocket 连接（客户端视角，帧带 mask）。
type wsConn struct {
conn net.Conn
br *bufio.Reader
bw *bufio.Writer
closed bool
}
// dialWS 发起 WS 客户端握手升级。
// 支持 ws:// 和 wss://（wss 暂未实现，若需要需加 TLS dial）。
func dialWS(rawURL, token string, timeout time.Duration) (*wsConn, error) {
u, err := url.Parse(rawURL)
if err != nil {
return nil, fmt.Errorf("devicebridge: invalid ws url %q: %w", rawURL, err)
}
host := u.Host
if u.Port() == "" {
if u.Scheme == "wss" {
host = host + ":443"
} else {
host = host + ":80"
}
}
path := u.Path
if u.RawQuery != "" {
path = path + "?" + u.RawQuery
}
if path == "" {
path = "/"
}
// 默认路径
if token != "" && strings.Index(path, "token=") < 0 {
if strings.ContainsRune(path, '?') {
path = path + "&token=" + urlEscape(token)
} else {
path = path + "?token=" + urlEscape(token)
}
}
dialer := net.Dialer{Timeout: timeout}
conn, err := dialer.Dial("tcp", host)
if err != nil {
return nil, fmt.Errorf("devicebridge: dial %s: %w", host, err)
}
key := wsKey()
var sb strings.Builder
sb.WriteString("GET " + path + " HTTP/1.1" + crlf)
sb.WriteString("Host: " + host + crlf)
sb.WriteString("Upgrade: websocket" + crlf)
sb.WriteString("Connection: Upgrade" + crlf)
sb.WriteString("Sec-WebSocket-Key: " + key + crlf)
sb.WriteString("Sec-WebSocket-Version: " + wsVersion + crlf + crlf)
if _, err := conn.Write([]byte(sb.String())); err != nil {
conn.Close()
return nil, fmt.Errorf("devicebridge: write upgrade: %w", err)
}
br := bufio.NewReader(conn)
var headerBuf strings.Builder
for {
line, err := br.ReadString('\n')
if err != nil {
conn.Close()
return nil, fmt.Errorf("devicebridge: read upgrade resp: %w", err)
}
headerBuf.WriteString(line)
if strings.Contains(headerBuf.String(), crlf+crlf) {
break
}
}
if !strings.Contains(headerBuf.String(), " 101 ") {
conn.Close()
return nil, fmt.Errorf("devicebridge: upgrade failed: %s", firstLine(headerBuf.String()))
}
return &wsConn{conn: conn, br: br, bw: bufio.NewWriter(conn)}, nil
}
// writeText 发送 WS 文本帧（0x1，带 mask）。
func (w *wsConn) writeText(payload []byte) error {
return w.writeFrame(0x1, payload)
}
// writeBinary 发送 WS 二进制帧（0x2，带 mask）。
func (w *wsConn) writeBinary(payload []byte) error {
return w.writeFrame(0x2, payload)
}
// writeFrame 发送一个 WS 帧（客户端 mask 模式）。
func (w *wsConn) writeFrame(opcode byte, payload []byte) error {
if w.closed {
return fmt.Errorf("devicebridge: connection closed")
}
length := len(payload)
// 帧头
hdrLen := 2
switch {
case length < 126:
// 1 byte length
case length <= 0xffff:
hdrLen += 2
default:
hdrLen += 8
}
hdrLen += 4 // mask key
hdr := make([]byte, hdrLen)
hdr[0] = 0x80 | opcode
switch {
case length < 126:
hdr[1] = 0x80 | byte(length)
case length <= 0xffff:
hdr[1] = 0x80 | 126
binary.BigEndian.PutUint16(hdr[2:4], uint16(length))
default:
hdr[1] = 0x80 | 127
binary.BigEndian.PutUint64(hdr[2:10], uint64(length))
}
// mask key
var maskKey [4]byte
rand.Read(maskKey[:])
copy(hdr[hdrLen-4:], maskKey[:])
// mask payload
masked := make([]byte, length)
for i := 0; i < length; i++ {
masked[i] = payload[i] ^ maskKey[i&3]
}
if _, err := w.bw.Write(hdr); err != nil {
return err
}
if _, err := w.bw.Write(masked); err != nil {
return err
}
return w.bw.Flush()
}
// readFrame 读取一个 WS 帧。返回 (payload, isClose, opcode, error)。
// 客户端收到的帧不带 mask。
func (w *wsConn) readFrame() ([]byte, bool, byte, error) {
if w.closed {
return nil, true, 0, fmt.Errorf("devicebridge: connection closed")
}
b0, err := w.br.ReadByte()
if err != nil {
return nil, true, 0, err
}
opcode := b0 & 0x0f
b1, err := w.br.ReadByte()
if err != nil {
return nil, true, 0, err
}
length := uint64(b1 & 0x7f)
if length == 126 {
var ext [2]byte
if _, err := io.ReadFull(w.br, ext[:]); err != nil {
return nil, true, opcode, err
}
length = uint64(binary.BigEndian.Uint16(ext[:]))
} else if length == 127 {
var ext [8]byte
if _, err := io.ReadFull(w.br, ext[:]); err != nil {
return nil, true, opcode, err
}
length = binary.BigEndian.Uint64(ext[:])
}
// 二进制帧允许更大（8MB），文本帧 1MB
maxFrame := uint64(1 << 20)
if opcode == 0x2 {
maxFrame = 8 << 20
}
if length > maxFrame {
return nil, true, opcode, fmt.Errorf("devicebridge: frame too large (%d bytes)", length)
}
payload := make([]byte, length)
if _, err := io.ReadFull(w.br, payload); err != nil {
return nil, true, opcode, err
}
switch opcode {
case 0x1, 0x2:
return payload, false, opcode, nil
case 0x8:
return nil, true, opcode, nil
case 0x9: // ping
return nil, false, opcode, errPing
case 0xa: // pong
return nil, false, opcode, nil
default:
return nil, false, opcode, fmt.Errorf("devicebridge: unsupported opcode %x", opcode)
}
}
// writePong 发送 pong 帧。
func (w *wsConn) writePong() error {
return w.writeFrame(0xa, nil)
}
// close 发送关闭帧并关闭连接。
func (w *wsConn) close() error {
w.closed = true
_ = w.writeFrame(0x8, nil)
return w.conn.Close()
}
// ===== 辅助函数 =====
var errPing = fmt.Errorf("ping")
func wsKey() string {
var b [16]byte
rand.Read(b[:])
return base64.StdEncoding.EncodeToString(b[:])
}
func urlEscape(s string) string {
var sb strings.Builder
const hex = "0123456789ABCDEF"
for i := 0; i < len(s); i++ {
c := s[i]
if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') ||
(c >= '0' && c <= '9') || c == '-' || c == '_' || c == '.' || c == '~' {
sb.WriteByte(c)
} else {
sb.WriteByte('%')
sb.WriteByte(hex[c>>4])
sb.WriteByte(hex[c&0xf])
}
}
return sb.String()
}
func firstLine(s string) string {
if i := strings.IndexByte(s, '\n'); i >= 0 {
return strings.TrimSpace(s[:i])
}
return strings.TrimSpace(s)
}
func wsAccept(key string) string {
h := sha256.Sum256([]byte(key + wsGUID))
return base64.StdEncoding.EncodeToString(h[:])
}
// readWSFrame 读取一个 WS 帧（从已有的 bufio.Reader，兼容非 wsConn 场景）。
func readWSFrame(br *bufio.Reader) ([]byte, bool, byte, error) {
b0, err := br.ReadByte()
if err != nil {
return nil, true, 0, err
}
opcode := b0 & 0x0f
b1, err := br.ReadByte()
if err != nil {
return nil, true, 0, err
}
length := uint64(b1 & 0x7f)
if length == 126 {
var ext [2]byte
if _, err := io.ReadFull(br, ext[:]); err != nil {
return nil, true, opcode, err
}
length = uint64(binary.BigEndian.Uint16(ext[:]))
} else if length == 127 {
var ext [8]byte
if _, err := io.ReadFull(br, ext[:]); err != nil {
return nil, true, opcode, err
}
length = binary.BigEndian.Uint64(ext[:])
}
maxFrame := uint64(1 << 20)
if opcode == 0x2 {
maxFrame = 8 << 20
}
if length > maxFrame {
return nil, true, opcode, fmt.Errorf("frame too large")
}
payload := make([]byte, length)
if _, err := io.ReadFull(br, payload); err != nil {
return nil, true, opcode, err
}
switch opcode {
case 0x1, 0x2:
return payload, false, opcode, nil
case 0x8:
return nil, true, opcode, nil
default:
return nil, false, opcode, nil
}
}
// writeWSFrame 发送一个 WS 帧（非 mask 模式，服务端用）。
func writeWSFrame(w io.Writer, opcode byte, payload []byte) error {
length := len(payload)
hdr := []byte{0x80 | opcode}
switch {
case length < 126:
hdr = append(hdr, byte(length))
case length <= 0xffff:
hdr = append(hdr, 126, 0, 0)
binary.BigEndian.PutUint16(hdr[len(hdr)-2:], uint16(length))
default:
hdr = append(hdr, 127, 0, 0, 0, 0, 0, 0, 0, 0)
binary.BigEndian.PutUint64(hdr[len(hdr)-8:], uint64(length))
}
if _, err := w.Write(hdr); err != nil {
return err
}
if _, err := w.Write(payload); err != nil {
return err
}
return nil
}
// ensureTimeout 设置连接读写超时。
func (w *wsConn) setDeadline(t time.Time) {
if w.conn != nil {
w.conn.SetDeadline(t)
}
}
// LocalAddr 返回本地地址。
func (w *wsConn) LocalAddr() net.Addr {
if w.conn != nil {
return w.conn.LocalAddr()
}
return nil
}
// RemoteAddr 返回远程地址。
func (w *wsConn) RemoteAddr() net.Addr {
if w.conn != nil {
return w.conn.RemoteAddr()
}
return nil
}