lui-bridge 0.2.0

package/README.md

@@ -0,0 +1,79 @@
+# lui-bridge
+
+Connect AI agents to LUI Android devices. 78 phone tools, MCP protocol, bidirectional communication.
+
+## Install
+
+```bash
+npm install -g lui-bridge
+```
+
+## CLI
+
+```bash
+# Connect as an agent
+lui bridge connect --url ws://PHONE_IP:8765 --token TOKEN --agent claude-code --mode claude-code
+lui bridge connect --url ws://PHONE_IP:8765 --token TOKEN --agent hermes --mode hermes
+
+# List tools
+lui bridge tools --url ws://PHONE_IP:8765 --token TOKEN
+
+# Call a single tool
+lui bridge call --url ws://PHONE_IP:8765 --token TOKEN --tool battery
+lui bridge call --url ws://PHONE_IP:8765 --token TOKEN --tool toggle_flashlight --args '{"state":"on"}'
+
+# Check device
+lui bridge status --url ws://PHONE_IP:8765 --token TOKEN
+```
+
+## JavaScript API
+
+```javascript
+const { LuiBridge } = require('lui-bridge');
+
+const bridge = new LuiBridge('ws://PHONE_IP:8765', 'YOUR_TOKEN');
+await bridge.connect();
+
+// Call tools
+console.log(await bridge.callTool('battery'));
+console.log(await bridge.callTool('get_location'));
+console.log(await bridge.callTool('toggle_flashlight', { state: 'on' }));
+
+// Vision
+console.log(await bridge.callTool('take_photo'));     // Camera2 capture
+console.log(await bridge.callTool('analyze_image'));  // Describe last photo
+
+// Device info
+console.log(await bridge.getDeviceState());
+console.log(bridge.listTools());
+
+bridge.disconnect();
+```
+
+## Bidirectional Agent
+
+```javascript
+const { LuiBridge } = require('lui-bridge');
+
+const bridge = new LuiBridge('ws://PHONE_IP:8765', 'YOUR_TOKEN', {
+  agentName: 'my-bot',
+  onInstruction: async (instruction) => {
+    console.log(`Got: ${instruction}`);
+    return `Executed: ${instruction}`;
+  },
+  onEvent: (type, data) => {
+    if (type === 'notification_2fa') console.log(`2FA: ${data.code}`);
+    if (type === 'notification') console.log(`Notif: ${data.title}`);
+  }
+});
+
+await bridge.connect();
+// Phone user says: "patch me to my-bot" → direct chat
+// "@my-bot deploy" → one-off instruction
+```
+
+## Requirements
+
+- Node.js 16+
+- Phone running LUI with bridge enabled
+- Same Wi-Fi (or relay for remote)

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "lui-bridge",
+  "version": "0.2.0",
+  "description": "Connect AI agents to LUI Android devices — 78 tools, MCP protocol, bidirectional communication",
+  "main": "src/index.js",
+  "bin": {
+    "lui": "src/cli.js"
+  },
+  "scripts": {
+    "test": "node src/cli.js --help"
+  },
+  "keywords": ["android", "agent", "mcp", "bridge", "phone", "ai", "tool-use", "lui"],
+  "license": "GPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/obirije/LUI"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  }
+}

package/src/cli.js

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+
+/**
+ * LUI CLI — Connect agents to LUI devices.
+ *
+ * lui bridge connect --url ws://PHONE_IP:8765 --token TOKEN --agent NAME --mode MODE
+ * lui bridge tools   --url ws://PHONE_IP:8765 --token TOKEN
+ * lui bridge call    --url ws://PHONE_IP:8765 --token TOKEN --tool TOOL [--args JSON]
+ * lui bridge status  --url ws://PHONE_IP:8765 --token TOKEN
+ * lui relay start    [--port PORT]
+ */
+
+const { LuiBridge } = require('./index');
+const { execSync, spawn } = require('child_process');
+
+const args = process.argv.slice(2);
+
+function getArg(name, fallback = null) {
+  const idx = args.indexOf(`--${name}`);
+  if (idx >= 0 && idx + 1 < args.length) return args[idx + 1];
+  return fallback;
+}
+
+function hasArg(name) {
+  return args.includes(`--${name}`);
+}
+
+const command = args[0];
+const subcommand = args[1];
+
+async function main() {
+  if (hasArg('version')) {
+    console.log('lui-bridge 0.1.0');
+    return;
+  }
+
+  if (hasArg('help') || !command) {
+    console.log(`
+lui — Android agent bridge and relay
+
+Commands:
+  lui bridge connect  --url URL --token TOKEN [--agent NAME] [--mode MODE]
+  lui bridge tools    --url URL --token TOKEN
+  lui bridge call     --url URL --token TOKEN --tool TOOL [--args JSON]
+  lui bridge status   --url URL --token TOKEN
+  lui relay start     [--port PORT]
+
+Options:
+  --url     Bridge WebSocket URL (ws://PHONE_IP:8765)
+  --token   Auth token (from LUI notification)
+  --agent   Agent name (for connect mode)
+  --mode    Execution mode: echo, shell, hermes, claude-code (default: echo)
+  --tool    Tool name (for call mode)
+  --args    Tool arguments as JSON (for call mode)
+  --port    Relay server port (default: 9000)
+  --help    Show this help
+  --version Show version
+`);
+    return;
+  }
+
+  if (command === 'bridge') {
+    const url = getArg('url');
+    const token = getArg('token');
+
+    if (!url || !token) {
+      console.error('Required: --url and --token');
+      process.exit(1);
+    }
+
+    if (subcommand === 'connect') {
+      await bridgeConnect(url, token);
+    } else if (subcommand === 'tools') {
+      await bridgeTools(url, token);
+    } else if (subcommand === 'call') {
+      await bridgeCall(url, token);
+    } else if (subcommand === 'status') {
+      await bridgeStatus(url, token);
+    } else {
+      console.error(`Unknown bridge command: ${subcommand}`);
+      process.exit(1);
+    }
+  } else if (command === 'relay') {
+    if (subcommand === 'start') {
+      await relayStart();
+    } else {
+      console.error(`Unknown relay command: ${subcommand}`);
+      process.exit(1);
+    }
+  } else {
+    console.error(`Unknown command: ${command}. Use --help`);
+    process.exit(1);
+  }
+}
+
+async function bridgeConnect(url, token) {
+  const agentName = getArg('agent', 'node-agent');
+  const mode = getArg('mode', 'echo');
+  const executor = getExecutor(mode);
+
+  const bridge = new LuiBridge(url, token, {
+    agentName,
+    onInstruction: async (instruction) => {
+      console.log(`\n[→ ${agentName}] ${instruction}`);
+      const result = await executor(instruction);
+      console.log(`[← ${agentName}] ${result.slice(0, 120)}`);
+      return result;
+    },
+    onEvent: (type, data) => {
+      if (type === 'notification_2fa') {
+        console.log(`\n[2FA] Code: ${data.code} from ${data.app}`);
+      } else if (type === 'call_incoming' || type === 'call_missed') {
+        console.log(`\n[${type.toUpperCase()}] ${data.caller || '?'}`);
+      } else if (type === 'notification') {
+        console.log(`\n[NOTIF] ${data.title || ''}: ${(data.text || '').slice(0, 50)}`);
+      }
+    }
+  });
+
+  const toolCount = await bridge.connect();
+  const state = await bridge.getDeviceState();
+  console.log(`Connected to LUI as '${agentName}' — ${toolCount} tools, mode=${mode}`);
+  console.log(`Device: ${state.split('\n')[0]}`);
+  console.log(`\nOn LUI say: 'patch me to ${agentName}' or '@${agentName} do something'`);
+  console.log('Listening... (Ctrl+C to exit)\n');
+
+  process.on('SIGINT', () => {
+    bridge.disconnect();
+    console.log('\nDisconnected.');
+    process.exit(0);
+  });
+
+  // Keep alive
+  await new Promise(() => {});
+}
+
+async function bridgeTools(url, token) {
+  const bridge = new LuiBridge(url, token);
+  const count = await bridge.connect();
+  const tools = bridge.listToolsDetailed();
+  bridge.disconnect();
+
+  console.log(`${count} tools available:\n`);
+  for (const t of tools) {
+    const params = Object.keys(t.inputSchema?.properties || {}).join(', ');
+    console.log(`  ${t.name}(${params})`);
+    console.log(`    ${t.description}\n`);
+  }
+}
+
+async function bridgeCall(url, token) {
+  const tool = getArg('tool');
+  if (!tool) {
+    console.error('Required: --tool');
+    process.exit(1);
+  }
+
+  const argsJson = getArg('args', '{}');
+  let toolArgs;
+  try {
+    toolArgs = JSON.parse(argsJson);
+  } catch {
+    console.error('Invalid --args JSON');
+    process.exit(1);
+  }
+
+  const bridge = new LuiBridge(url, token);
+  await bridge.connect();
+  const result = await bridge.callTool(tool, toolArgs);
+  bridge.disconnect();
+  console.log(result);
+}
+
+async function bridgeStatus(url, token) {
+  const bridge = new LuiBridge(url, token);
+  try {
+    const count = await bridge.connect();
+    const state = await bridge.getDeviceState();
+    bridge.disconnect();
+    console.log(`Connected — ${count} tools\n`);
+    console.log(state);
+  } catch (err) {
+    console.error(`Failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+async function relayStart() {
+  const port = getArg('port', '9000');
+  console.log(`Starting LUI relay on port ${port}...`);
+  console.log('Note: The relay server requires Python. Use: lui relay start (Python CLI)');
+  console.log(`Or: python3 relay/relay_server.py (PORT=${port})`);
+  process.exit(1);
+}
+
+function getExecutor(mode) {
+  switch (mode) {
+    case 'shell':
+      return (instruction) => {
+        try {
+          const output = execSync(instruction, { timeout: 30000, encoding: 'utf-8', cwd: process.env.HOME });
+          return output.trim() || 'Done.';
+        } catch (err) {
+          return err.stderr?.trim() || err.message || 'Command failed.';
+        }
+      };
+    case 'hermes':
+      return (instruction) => {
+        try {
+          const output = execSync(`hermes chat -q "${instruction.replace(/"/g, '\\"')}" --yolo`, {
+            timeout: 120000, encoding: 'utf-8', env: { ...process.env, TERM: 'dumb', NO_COLOR: '1' }
+          });
+          // Strip ANSI and box drawing
+          const clean = output.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+            .replace(/[╭╮╰╯│─┃━┏┓┗┛┡┩┣┫╌╍⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/g, '')
+            .split('\n')
+            .map(l => l.trim())
+            .filter(l => l && !l.startsWith('Hermes Agent') && !l.includes('──────'))
+            .slice(-15)
+            .join('\n');
+          return clean || 'Hermes returned no output.';
+        } catch (err) {
+          return `Hermes error: ${err.message}`;
+        }
+      };
+    case 'claude-code':
+      return (instruction) => {
+        try {
+          const output = execSync(`claude --print --dangerously-skip-permissions "${instruction.replace(/"/g, '\\"')}"`, {
+            timeout: 120000, encoding: 'utf-8'
+          });
+          return output.replace(/\x1b\[[0-9;]*m/g, '').trim().slice(0, 1000) || 'Claude Code returned no output.';
+        } catch (err) {
+          return `Claude Code error: ${err.message}`;
+        }
+      };
+    default:
+      return (instruction) => `Received: ${instruction}`;
+  }
+}
+
+main().catch(err => {
+  console.error(err.message);
+  process.exit(1);
+});

package/src/index.js

@@ -0,0 +1,262 @@
+/**
+ * LUI Bridge — Connect AI agents to Android devices.
+ *
+ * Usage:
+ *   const { LuiBridge } = require('lui-bridge');
+ *
+ *   const bridge = new LuiBridge('ws://PHONE_IP:8765', 'YOUR_TOKEN');
+ *   await bridge.connect();
+ *   console.log(await bridge.callTool('battery'));
+ *   bridge.disconnect();
+ */
+
+const WebSocket = require('ws');
+
+class LuiBridge {
+  /**
+   * @param {string} url - WebSocket URL (e.g., ws://PHONE_IP:8765)
+   * @param {string} token - Bridge auth token
+   * @param {Object} [options]
+   * @param {string} [options.agentName] - Register as named agent for bidirectional comms
+   * @param {Function} [options.onInstruction] - async (instruction) => response string
+   * @param {Function} [options.onEvent] - (eventType, data) => void
+   */
+  constructor(url, token, options = {}) {
+    this.url = url;
+    this.token = token;
+    this.agentName = options.agentName || null;
+    this.onInstruction = options.onInstruction || null;
+    this.onEvent = options.onEvent || null;
+    this.ws = null;
+    this.connected = false;
+    this.tools = [];
+    this._requestId = 0;
+    this._pending = new Map();
+  }
+
+  /**
+   * Connect, authenticate, initialize MCP, optionally register as agent.
+   * @returns {Promise<number>} Number of available tools
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.ws = new WebSocket(this.url);
+
+      this.ws.on('error', (err) => {
+        if (!this.connected) reject(err);
+      });
+
+      this.ws.on('open', async () => {
+        try {
+          // Auth
+          this._send({ method: 'auth', params: { token: this.token } });
+          const auth = await this._readOne();
+          if (!auth?.result?.authenticated) {
+            throw new Error(`Auth failed: ${JSON.stringify(auth)}`);
+          }
+
+          // Initialize MCP
+          await this._call('initialize', {
+            protocolVersion: '2025-03-26',
+            clientInfo: { name: this.agentName || 'lui-node', version: '0.1.0' }
+          });
+
+          // Register as agent
+          if (this.agentName) {
+            this._send({
+              jsonrpc: '2.0', id: this._nextId(),
+              method: 'lui/register',
+              params: {
+                name: this.agentName,
+                description: `${this.agentName} agent`,
+                capabilities: []
+              }
+            });
+            await this._drain();
+          }
+
+          // Get tools
+          const toolsResp = await this._call('tools/list');
+          this.tools = toolsResp?.tools || [];
+
+          this.connected = true;
+          this._startListener();
+          resolve(this.tools.length);
+        } catch (err) {
+          reject(err);
+        }
+      });
+
+      this.ws.on('close', () => {
+        this.connected = false;
+      });
+    });
+  }
+
+  /** Disconnect from the bridge. */
+  disconnect() {
+    this.connected = false;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  /**
+   * Call a LUI tool.
+   * @param {string} name - Tool name
+   * @param {Object} [args] - Tool arguments
+   * @returns {Promise<string>} Result text
+   */
+  async callTool(name, args = {}) {
+    const resp = await this._call('tools/call', { name, arguments: args });
+    const content = resp?.content || [];
+    if (content.length > 0) {
+      const text = content[0].text || '';
+      if (resp.isError) throw new ToolError(text);
+      return text;
+    }
+    return '';
+  }
+
+  /**
+   * Get current device state.
+   * @returns {Promise<string>}
+   */
+  async getDeviceState() {
+    const resp = await this._call('resources/read', { uri: 'lui://device/state' });
+    const contents = resp?.contents || [];
+    return contents.length > 0 ? contents[0].text || '' : '';
+  }
+
+  /** @returns {string[]} Available tool names */
+  listTools() {
+    return this.tools.map(t => t.name);
+  }
+
+  /** @returns {Object[]} Full tool definitions */
+  listToolsDetailed() {
+    return this.tools;
+  }
+
+  /** @returns {Promise<boolean>} */
+  async ping() {
+    try {
+      await this._call('ping');
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // ── Internal ──
+
+  _nextId() {
+    return String(++this._requestId);
+  }
+
+  _send(msg) {
+    this.ws.send(JSON.stringify(msg));
+  }
+
+  _readOne() {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('Timeout')), 10000);
+      this.ws.once('message', (data) => {
+        clearTimeout(timeout);
+        resolve(JSON.parse(data.toString()));
+      });
+    });
+  }
+
+  async _drain() {
+    await new Promise(r => setTimeout(r, 500));
+    // Read and discard buffered messages
+    return new Promise((resolve) => {
+      const handler = () => {};
+      this.ws.on('message', handler);
+      setTimeout(() => {
+        this.ws.removeListener('message', handler);
+        resolve();
+      }, 300);
+    });
+  }
+
+  _call(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = this._nextId();
+      const msg = { jsonrpc: '2.0', id, method };
+      if (params) msg.params = params;
+
+      const timeout = setTimeout(() => {
+        this._pending.delete(id);
+        reject(new Error(`Timeout waiting for ${method}`));
+      }, 30000);
+
+      this._pending.set(id, { resolve, reject, timeout });
+      this._send(msg);
+
+      // If listener not running, read directly
+      if (!this._listening) {
+        const directHandler = (data) => {
+          const resp = JSON.parse(data.toString());
+          if (String(resp.id) === id) {
+            this.ws.removeListener('message', directHandler);
+            clearTimeout(timeout);
+            this._pending.delete(id);
+            resolve(resp.result || {});
+          }
+        };
+        this.ws.on('message', directHandler);
+      }
+    });
+  }
+
+  _startListener() {
+    this._listening = true;
+    this.ws.on('message', (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        const id = String(msg.id || '');
+
+        // Pending response
+        if (this._pending.has(id)) {
+          const p = this._pending.get(id);
+          clearTimeout(p.timeout);
+          this._pending.delete(id);
+          p.resolve(msg.result || {});
+          return;
+        }
+
+        // Instruction from user
+        if (msg.method === 'lui/instruction' && this.onInstruction) {
+          const instruction = msg.params?.instruction || '';
+          const instrId = msg.id || '';
+
+          Promise.resolve(this.onInstruction(instruction)).then((response) => {
+            this._send({
+              jsonrpc: '2.0', id: 'resp',
+              method: 'lui/response',
+              params: { instruction_id: String(instrId), result: String(response).slice(0, 1000) }
+            });
+          }).catch(() => {});
+        }
+
+        // Event
+        if (msg.method === 'notifications/lui/event' && this.onEvent) {
+          const event = msg.params || {};
+          this.onEvent(event.type, event.data || {});
+        }
+      } catch {}
+    });
+  }
+}
+
+class ToolError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'ToolError';
+  }
+}
+
+module.exports = { LuiBridge, ToolError };