pelulu-cli 1.0.0

package/src/index.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * XiaoZhi Coding Agent — CLI Entry Point
+ * Usage: cd my-project && xcode
+ */
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { loadConfig, saveConfig } from './core/config.js';
+import { log, setDebug } from './core/logger.js';
+import { bus } from './core/event-bus.js';
+import { ToolRegistry } from './core/tool-registry.js';
+import { Sandbox } from './core/sandbox.js';
+import { SessionState } from './core/session.js';
+import { Stats } from './core/stats.js';
+import { buildSystemPrompt } from './core/system-prompt.js';
+import { buildContext } from './core/context.js';
+import { isDestructive, askConfirmation } from './core/confirm.js';
+import { runWizard } from './core/wizard.js';
+import { MqttClient } from './mcp/mqtt-client.js';
+import { WssEndpoint } from './mcp/wss-endpoint.js';
+import { PluginManager } from './plugins/manager.js';
+import { REPL } from './repl.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(__dirname, '..');
+
+const args = process.argv.slice(2);
+if (args.includes('--debug')) setDebug(true);
+if (args.includes('--wizard')) { /* force wizard */ }
+const LIST_TOOLS = args.includes('--list-tools');
+
+async function main() {
+  // 1. Load config + wizard
+  const config = await loadConfig(ROOT);
+
+  // 2. Auto-detect CWD as workspace (like Claude Code, Gemini CLI, etc.)
+  const cwd = process.cwd();
+  config.agent = { ...config.agent, workspace: cwd };
+  log('info', `Workspace: ${cwd}`);
+
+  if (!config._wizard_done || args.includes('--wizard')) {
+    await runWizard(ROOT);
+  }
+
+  // 3. Load tools
+  const registry = new ToolRegistry();
+  log('info', 'Loading tools...');
+  await registry.loadBuiltins();
+
+  // 4. Load plugins
+  const plugins = new PluginManager(registry);
+  await plugins.load();
+
+  if (LIST_TOOLS) {
+    const tools = registry.list();
+    console.log('\n🔧 Tools:\n');
+    for (const t of tools) console.log(`  ${t.name} — ${t.description} (${t.actions.join(', ')})`);
+    console.log(`\n  ${tools.length} tools, ${tools.reduce((s, t) => s + t.actions.length, 0)} actions\n`);
+    process.exit(0);
+  }
+
+  // 5. Initialize systems
+  const sandbox = new Sandbox();
+  const session = new SessionState();
+  const stats = new Stats();
+
+  // 6. Build context & system prompt
+  const context = await buildContext();
+  const systemPrompt = buildSystemPrompt(registry, config);
+  log('info', `Context: ${context.split('\n').length} lines`);
+
+  // 7. Connect to XiaoZhi
+  const mqtt = new MqttClient(config);
+
+  bus.on('activation:required', ({ code }) => {
+    console.log('');
+    console.log(`  ╔═════════════════════════════════════════════╗`);
+    console.log(`  ║  🔐 Kode Aktivasi: ${String(code).padEnd(25)}║`);
+    console.log(`  ║  🌐 https://xiaozhi.me                     ║`);
+    console.log(`  ╚═════════════════════════════════════════════╝`);
+    console.log('');
+  });
+
+  try {
+    log('info', 'Connecting to XiaoZhi...');
+    await mqtt.connect();
+  } catch (e) {
+    log('err', `Connection failed: ${e.message}`);
+    process.exit(1);
+  }
+
+  // 8. Register MCP tool handler
+  mqtt.registerToolHandler(
+    async (name, args) => {
+      const destructive = isDestructive(name, args);
+      if (destructive.destructive) {
+        const ok = await askConfirmation(name, args, destructive);
+        if (!ok) return { isError: true, content: [{ type: 'text', text: 'Cancelled by user' }] };
+      }
+      sandbox.validate(name, args);
+      const start = Date.now();
+      log('tool', `🔧 ${name} → ${args.action || '-'}`);
+      try {
+        const result = await registry.call(name, args);
+        stats.record(name, args.action, !result.isError, Date.now() - start);
+        session.addToolCall(name, args, result);
+        log('tool', result.isError ? `❌ ${result.content?.[0]?.text}` : `✅ OK`);
+        bus.emit('tool:called', { name, result, args });
+        return result;
+      } catch (e) {
+        stats.record(name, args.action, false, Date.now() - start, e.message);
+        throw e;
+      }
+    },
+    () => registry.toMcpTools()
+  );
+
+  // 9. Optional WSS endpoint
+  let wss = null;
+  if (config.mcp?.endpoint_url) {
+    wss = new WssEndpoint(config.mcp.endpoint_url, () => registry.toMcpTools(), async (name, args) => {
+      sandbox.validate(name, args);
+      return registry.call(name, args);
+    });
+    wss.start();
+  }
+
+  // 10. Track conversation
+  bus.on('user:text', (text) => session.addUserMessage(text));
+  bus.on('llm:text', (text) => session.addAiMessage(text));
+
+  // 11. Save config & start REPL
+  await saveConfig(ROOT, config);
+  const repl = new REPL(registry, mqtt, stats, session);
+  repl.start();
+
+  // Graceful shutdown
+  const shutdown = async () => {
+    log('info', 'Shutting down...');
+    console.log(stats.formatReport());
+    if (wss) wss.stop();
+    await registry.shutdown();
+    mqtt.disconnect();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch(e => { log('err', `Fatal: ${e.message}`); process.exit(1); });

package/src/mcp/activation.js

@@ -0,0 +1,54 @@
+/**
+ * Activation — XiaoZhi device activation flow
+ * Handles: code display, polling, timeout
+ */
+import https from 'https';
+import { log } from '../core/logger.js';
+import { bus } from '../core/event-bus.js';
+
+function httpPost(url, body, headers = {}) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(new URL(url), {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...headers },
+    }, (res) => {
+      let d = '';
+      res.on('data', c => d += c);
+      res.on('end', () => { try { resolve(JSON.parse(d)); } catch { resolve(d); } });
+    });
+    req.on('error', reject);
+    req.write(JSON.stringify(body));
+    req.end();
+  });
+}
+
+export async function fetchOtaConfig(otaUrl, deviceId, clientId) {
+  return httpPost(otaUrl, {
+    application: { version: '1.0.0' },
+    board: { type: 'linux', name: 'coding-agent', mac: deviceId },
+  }, { 'Device-Id': deviceId, 'Client-Id': clientId });
+}
+
+export async function handleActivation(data, otaUrl, deviceId, clientId) {
+  const a = data.activation;
+  if (!a?.code) return data.mqtt;
+
+  log('warn', `🔐 Activation required`);
+  log('info', `📋 Code: ${a.code}`);
+  log('info', `🌐 https://xiaozhi.me`);
+  bus.emit('activation:required', { code: a.code });
+
+  const timeout = a.timeout_ms || 120000;
+  const start = Date.now();
+
+  while (Date.now() - start < timeout) {
+    await new Promise(r => setTimeout(r, 5000));
+    log('info', '⏳ Checking activation...');
+    const poll = await fetchOtaConfig(otaUrl, deviceId, clientId);
+    if (!poll.activation?.code && poll.mqtt) {
+      log('ok', '✅ Activated!');
+      return poll.mqtt;
+    }
+  }
+  throw new Error('Activation timed out');
+}

package/src/mcp/mcp-handler.js

@@ -0,0 +1,92 @@
+/**
+ * McpHandler — MCP protocol message handler
+ * Handles: initialize, tools/list, tools/call, ping
+ */
+import { log, debug } from '../core/logger.js';
+
+const PROTOCOL_VERSION = '2024-11-05';
+
+export class McpHandler {
+  #toolsFn;
+  #toolHandler;
+  #nameMap = new Map();
+  #initialized = false;
+  #toolsReceived = false;
+
+  constructor() {}
+
+  setToolProvider(toolsFn) { this.#toolsFn = toolsFn; }
+  setToolCaller(handler) { this.#toolHandler = handler; }
+
+  get initialized() { return this.#initialized; }
+  get toolsReceived() { return this.#toolsReceived; }
+
+  reset() {
+    this.#initialized = false;
+    this.#toolsReceived = false;
+    this.#nameMap.clear();
+  }
+
+  /**
+   * Handle incoming MCP message, return response(s) to send
+   */
+  handleMessage(msg) {
+    const p = msg.payload;
+    if (!p) return [];
+
+    const responses = [];
+
+    if (p.method === 'initialize') {
+      responses.push({
+        type: 'mcp', payload: {
+          jsonrpc: '2.0', id: p.id,
+          result: {
+            protocolVersion: PROTOCOL_VERSION,
+            capabilities: { tools: {} },
+            serverInfo: { name: 'coding-agent', version: '1.0.0' },
+          },
+        },
+      });
+      log('mcp', 'Initialize OK');
+    }
+
+    if (p.method === 'notifications/initialized') {
+      this.#initialized = true;
+      log('mcp', 'Initialized ✓');
+    }
+
+    if (p.method === 'tools/list') {
+      this.#toolsReceived = true;
+      this.#nameMap.clear();
+      const tools = (this.#toolsFn?.() || []).map(t => {
+        const safeName = this._sanitize(t.name);
+        this.#nameMap.set(safeName, t.name);
+        return { name: safeName, description: t.description, inputSchema: t.inputSchema || { type: 'object', properties: {} } };
+      });
+      responses.push({ type: 'mcp', payload: { jsonrpc: '2.0', id: p.id, result: { tools } } });
+      log('mcp', `Sent ${tools.length} tools`);
+    }
+
+    if (p.method === 'tools/call') {
+      // Return a deferred response — caller must handle async
+      const requested = p.params?.name;
+      const name = this.#nameMap.get(requested) || requested;
+      return [{ type: 'tool_call', id: p.id, name, args: p.params?.arguments || {} }];
+    }
+
+    if (p.method === 'ping') {
+      responses.push({ type: 'mcp', payload: { jsonrpc: '2.0', id: p.id, result: {} } });
+    }
+
+    return responses;
+  }
+
+  async executeTool(name, args) {
+    if (!this.#toolHandler) throw new Error('No tool handler registered');
+    return this.#toolHandler(name, args);
+  }
+
+  _sanitize(name) {
+    return String(name).replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+  }
+}

package/src/mcp/message-sender.js

@@ -0,0 +1,147 @@
+/**
+ * MessageSender — handles sending messages to XiaoZhi with proper timing
+ * Ensures MCP handshake is complete before sending
+ * Waits for tool calls to finish before sending next message
+ * Retries on timeout
+ */
+import { log, debug } from '../core/logger.js';
+import { bus } from '../core/event-bus.js';
+
+export class MessageSender {
+  constructor(mqtt) {
+    this.mqtt = mqtt;
+    this.queue = [];
+    this.sending = false;
+    this.waitingForResponse = false;
+    this.lastToolCallTime = 0;
+    this.toolCallCount = 0;
+    this.responseTimeout = null;
+    this.retryCount = 0;
+    this.maxRetries = 2;
+    this.responseWaitMs = 60000; // Wait up to 60s for response
+    this.toolCooldownMs = 3000; // Wait 3s after last tool call
+
+    // Track tool calls
+    bus.on('tool:called', () => {
+      this.lastToolCallTime = Date.now();
+      this.toolCallCount++;
+    });
+  }
+
+  /**
+   * Send a message, waiting for MCP handshake if needed
+   */
+  async send(text, options = {}) {
+    const { timeout = 120000, waitForTools = true, retries = 2 } = options;
+
+    // Wait for MCP handshake
+    await this._waitForReady();
+
+    log('info', `📤 Sending: "${text.slice(0, 80)}..."`);
+    this.mqtt.sendText(text);
+
+    if (!waitForTools) return { sent: true };
+
+    // Wait for response
+    return this._waitForResponse(timeout, retries);
+  }
+
+  /**
+   * Send multiple messages sequentially
+   */
+  async sendSequence(messages, options = {}) {
+    const results = [];
+    for (let i = 0; i < messages.length; i++) {
+      log('info', `\n📨 [${i + 1}/${messages.length}]`);
+      const result = await this.send(messages[i], options);
+      results.push(result);
+      if (result.timeout && !options.continueOnTimeout) {
+        log('warn', `Timeout on message ${i + 1}, stopping sequence`);
+        break;
+      }
+      // Cool down between messages
+      if (i < messages.length - 1) {
+        await new Promise(r => setTimeout(r, 2000));
+      }
+    }
+    return results;
+  }
+
+  async _waitForReady() {
+    if (this.mqtt.mcp.toolsReceived) return;
+
+    log('info', '⏳ Waiting for MCP handshake...');
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('MCP handshake timeout')), 30000);
+      const check = setInterval(() => {
+        if (this.mqtt.mcp.toolsReceived) {
+          clearInterval(check);
+          clearTimeout(timeout);
+          log('ok', 'MCP ready');
+          resolve();
+        }
+      }, 500);
+    });
+  }
+
+  async _waitForResponse(timeoutMs, maxRetries) {
+    return new Promise((resolve) => {
+      const startTime = Date.now();
+      let toolCallsBefore = this.toolCallCount;
+      let lastActivity = Date.now();
+      let resolved = false;
+
+      // Track activity
+      const onTool = () => { lastActivity = Date.now(); };
+      const onLlm = () => { lastActivity = Date.now(); };
+      bus.on('tool:called', onTool);
+      bus.on('llm:text', onLlm);
+
+      const cleanup = () => {
+        bus.off('tool:called', onTool);
+        bus.off('llm:text', onLlm);
+        if (check) clearInterval(check);
+        if (timer) clearTimeout(timer);
+      };
+
+      // Timeout
+      const timer = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          cleanup();
+          const newCalls = this.toolCallCount - toolCallsBefore;
+          if (newCalls === 0 && maxRetries > 0) {
+            log('warn', '⏰ No response, retrying...');
+            cleanup();
+            resolve(this._retry(timeoutMs, maxRetries));
+          } else {
+            resolve({ timeout: true, toolCalls: newCalls });
+          }
+        }
+      }, timeoutMs);
+
+      // Check if done (no new activity for 8s after tool calls)
+      const check = setInterval(() => {
+        if (resolved) return;
+        const elapsed = Date.now() - startTime;
+        const quietFor = Date.now() - lastActivity;
+        const newCalls = this.toolCallCount - toolCallsBefore;
+
+        // If we got tool calls and been quiet for 8s, we're done
+        if (newCalls > 0 && quietFor > 8000) {
+          resolved = true;
+          cleanup();
+          resolve({ success: true, toolCalls: newCalls, elapsed });
+        }
+      }, 1000);
+    });
+  }
+
+  async _retry(timeoutMs, retriesLeft) {
+    this.retryCount++;
+    log('info', `🔄 Retry ${this.retryCount}...`);
+    await new Promise(r => setTimeout(r, 3000));
+    // Don't resend, just wait for response again
+    return this._waitForResponse(timeoutMs, retriesLeft - 1);
+  }
+}

package/src/mcp/mqtt-client.js

@@ -0,0 +1,160 @@
+/**
+ * MqttClient — XiaoZhi MQTT connection + MCP
+ * Uses MQTT library's built-in reconnect (reconnectPeriod: 5000)
+ */
+import mqtt from 'mqtt';
+import crypto from 'crypto';
+import { log, debug } from '../core/logger.js';
+import { bus } from '../core/event-bus.js';
+import { McpHandler } from './mcp-handler.js';
+import { fetchOtaConfig, handleActivation } from './activation.js';
+
+export class MqttClient {
+  constructor(config) {
+    this.config = config;
+    this.client = null;
+    this.connected = false;
+    this.sessionId = null;
+    this.deviceId = config.mqtt?.device_id || null;
+    this.clientId = config.mqtt?.client_id || null;
+    this.mqttCfg = null;
+    this.mcp = new McpHandler();
+    this._helloQueue = [];
+  }
+
+  async connect() {
+    if (!this.deviceId) this.deviceId = this._randomMac();
+    if (!this.clientId) this.clientId = crypto.randomUUID();
+    await this._persistIds();
+
+    log('info', 'Fetching device config...');
+    const data = await fetchOtaConfig(this.config.mqtt.ota_url, this.deviceId, this.clientId);
+    this.mqttCfg = await handleActivation(data, this.config.mqtt.ota_url, this.deviceId, this.clientId);
+    log('info', `MQTT: ${this.mqttCfg.endpoint}`);
+    return this._connectMqtt();
+  }
+
+  async _persistIds() {
+    if (this.config.mqtt?.device_id) return;
+    this.config.mqtt = { ...this.config.mqtt, device_id: this.deviceId, client_id: this.clientId };
+    try {
+      const { saveConfig } = await import('../core/config.js');
+      await saveConfig(this.config._root, this.config);
+      log('info', 'Device ID saved');
+    } catch (e) { debug(`Config save: ${e.message}`); }
+  }
+
+  _connectMqtt() {
+    return new Promise((resolve, reject) => {
+      this.client = mqtt.connect(`mqtts://${this.mqttCfg.endpoint}:8883`, {
+        clientId: this.mqttCfg.client_id,
+        username: this.mqttCfg.username,
+        password: this.mqttCfg.password,
+        keepalive: 240,
+        reconnectPeriod: 5000,
+        connectTimeout: 10000,
+        clean: true,
+      });
+
+      this.client.on('connect', () => {
+        this.connected = true;
+        log('ok', 'MQTT Connected');
+        this.client.subscribe('devices/p2p/#');
+        this._sendHello();
+        resolve();
+      });
+
+      this.client.on('message', (_, raw) => this._onMessage(raw));
+      this.client.on('error', e => { log('err', `MQTT: ${e.message}`); bus.emit('mqtt:error', e); });
+      this.client.on('close', () => {
+        this.connected = false;
+        this.sessionId = null;
+        this.mcp.reset();
+        this._helloQueue = [];
+        log('warn', 'MQTT Disconnected');
+      });
+      this.client.on('reconnect', () => log('info', 'MQTT Reconnecting...'));
+    });
+  }
+
+  _sendHello() {
+    this.client.publish(this.mqttCfg.publish_topic, JSON.stringify({
+      type: 'hello', version: 3, transport: 'udp',
+      features: { mcp: true },
+      audio_params: { format: 'opus', sample_rate: 16000, channels: 1, frame_duration: 60 },
+    }));
+  }
+
+  _onMessage(raw) {
+    let msg;
+    try { msg = JSON.parse(raw.toString()); } catch { return; }
+    if (msg.session_id) this.sessionId = msg.session_id;
+
+    if (msg.type === 'hello') {
+      if (!this.mcp.toolsReceived) { this._helloQueue.push(msg); return; }
+      this._onHello(msg);
+    } else if (msg.type === 'mcp') {
+      this._onMcp(msg);
+    } else {
+      this._onOther(msg);
+    }
+  }
+
+  _onHello(msg) {
+    this.sessionId = msg.session_id;
+    log('ok', `Session: ${this.sessionId}`);
+    bus.emit('ready');
+  }
+
+  _onMcp(msg) {
+    const responses = this.mcp.handleMessage(msg);
+    for (const r of responses) {
+      if (r.type === 'mcp') { this._send(r); }
+      else if (r.type === 'tool_call') {
+        log('tool', `🔧 ${r.name}`);
+        this.mcp.executeTool(r.name, r.args)
+          .then(result => { log('tool', result.isError ? '❌' : '✅'); this._send({ type: 'mcp', payload: { jsonrpc: '2.0', id: r.id, result } }); })
+          .catch(err => { this._send({ type: 'mcp', payload: { jsonrpc: '2.0', id: r.id, result: { content: [{ type: 'text', text: err.message }], isError: true } } }); });
+      }
+    }
+    if (this.mcp.toolsReceived && this._helloQueue.length) {
+      for (const h of this._helloQueue) this._onHello(h);
+      this._helloQueue = [];
+    }
+  }
+
+  _onOther(msg) {
+    if (msg.type === 'stt') { log('user', `🎤 "${msg.text}"`); bus.emit('stt', msg.text); }
+    if (msg.type === 'llm' && msg.text) { bus.emit('llm:text', msg.text); }
+    if (msg.type === 'tts' && msg.state === 'sentence_start' && msg.text) { bus.emit('tts:sentence', msg.text); }
+    if (msg.type === 'goodbye') { this.sessionId = null; this.mcp.reset(); this._helloQueue = []; }
+  }
+
+  _send(msg) {
+    if (!this.client || !this.mqttCfg) return;
+    if (this.sessionId) msg.session_id = this.sessionId;
+    this.client.publish(this.mqttCfg.publish_topic, JSON.stringify(msg));
+  }
+
+  sendText(text) {
+    this._send({ type: 'listen', state: 'detect', text });
+    log('user', `💬 "${text}"`);
+    bus.emit('user:text', text);
+  }
+
+  abort() { this._send({ type: 'abort' }); }
+
+  registerToolHandler(handler, toolsFn) {
+    this.mcp.setToolCaller(handler);
+    this.mcp.setToolProvider(toolsFn);
+  }
+
+  _randomMac() {
+    return Array.from(crypto.randomBytes(6)).map(b => b.toString(16).padStart(2, '0')).join(':').toUpperCase();
+  }
+
+  disconnect() {
+    if (this.client) { this.client.end(true); this.client = null; }
+    this.connected = false;
+  }
+}