@z-qinghui/migpt-claw 1.0.0

package/src/service.ts

@@ -0,0 +1,246 @@
+import { MiNA } from './mi/mina.js';
+import { MIoT } from './mi/miot.js';
+import { getMiService } from './mi/common.js';
+import { assert, sleep } from './utils/parse.js';
+import { Debugger } from './utils/debug.js';
+
+export interface MiServiceConfig {
+  /** 小米 ID（数字） */
+  userId?: string;
+  /** 密码 */
+  password?: string;
+  /** 登录凭证 */
+  passToken?: string;
+  /** 是否开启调试模式 */
+  debug?: boolean;
+  /** 网络请求超时时长（毫秒） */
+  timeout?: number;
+  /** 音箱控制方式：mina/miot */
+  speakerControl?: 'mina' | 'miot';
+}
+
+class _MiService {
+  MiNA?: MiNA;
+  MiOT?: MIoT;
+  private _initialized = false;
+  private _initializing = false;
+  private _speakerControl: 'mina' | 'miot' = 'mina';
+
+  /**
+   * 使用 MIoT 发送 TTS 播报
+   */
+  async playWithMiot(text: string): Promise<boolean> {
+    if (!this.MiOT) {
+      console.warn('⚠️ MIoT 服务不可用');
+      return false;
+    }
+    try {
+      // 使用 MIoT spec 调用 TTS 动作 (siid=5, aiid=1 是常见的 TTS 动作)
+      // 不同设备可能不同，需要根据设备 spec 调整
+      const result = await this.MiOT.doAction(5, 1, [text]);
+      return result;
+    } catch (e: any) {
+      console.error('❌ MIoT TTS 失败:', e?.message || e);
+      return false;
+    }
+  }
+
+  /**
+   * 使用 MiNA 发送 TTS 播报
+   */
+  async playWithMina(text: string): Promise<boolean> {
+    if (!this.MiNA) {
+      console.warn('⚠️ MiNA 服务不可用');
+      return false;
+    }
+    try {
+      const result = await this.MiNA.play({ text });
+      return result;
+    } catch (e: any) {
+      console.error('❌ MiNA TTS 失败:', e?.message || e);
+      return false;
+    }
+  }
+
+  /**
+   * 发送 TTS 播报（根据配置选择 MiNA 或 MIoT）
+   */
+  async play(text: string): Promise<boolean> {
+    if (this._speakerControl === 'miot') {
+      return this.playWithMiot(text);
+    } else {
+      return this.playWithMina(text);
+    }
+  }
+
+  /**
+   * 初始化服务
+   */
+  async init(config: MiServiceConfig & { 
+    announceOnStart?: boolean; 
+    startupMessage?: string; 
+  }, did: string): Promise<boolean> {
+    if (this._initialized) {
+      console.log('✅ MiService 已初始化，跳过');
+      return true;
+    }
+
+    if (this._initializing) {
+      // 等待初始化完成
+      let waitCount = 0;
+      while (this._initializing && waitCount < 30) {
+        await sleep(100);
+        waitCount++;
+      }
+      return this._initialized;
+    }
+
+    this._initializing = true;
+
+    try {
+      console.log('🚀 开始初始化 MiService...');
+      console.log('📋 配置信息:', {
+        did,
+        userId: config.userId,
+        hasPassword: !!config.password,
+        hasPassToken: !!config.passToken,
+        debug: config.debug,
+        timeout: config.timeout,
+        speakerControl:config.speakerControl
+      });
+
+      assert(!!did, '❌ Speaker 缺少 did 参数');
+      assert(
+        !!config.passToken || (!!config.userId && !!config.password),
+        '❌ Speaker 缺少 passToken 或 userId 和 password',
+      );
+
+      Debugger.debug = config.debug ?? false;
+      this._speakerControl = config.speakerControl ?? 'mina';
+
+      const serviceConfig = {
+        ...config,
+        did,
+        timeout: Math.max(1000, config.timeout ?? 5000),
+      };
+
+      console.log('🔌 正在连接 MiNA 服务...');
+      this.MiNA = (await getMiService({ ...serviceConfig, service: 'mina' })) as MiNA | undefined;
+      console.log('🔌 查询 MiNA 服务结果：', { mina: !!this.MiNA });
+
+      // MiOT 对于音箱设备是可选的，只记录警告不阻断
+      console.log('🔌 正在连接 MIoT 服务...');
+      this.MiOT = (await getMiService({ ...serviceConfig, service: 'miot' })) as MIoT | undefined;
+      console.log('🔌 查询 MIoT 服务结果：', { miot: !!this.MiOT });
+
+      // 对于音箱设备，MiNA 是必需的，MiOT 是可选的
+      assert(!!this.MiNA, '❌ 初始化 MiNA 服务失败');
+      if (!this.MiOT) {
+        console.warn('⚠️ MIoT 服务初始化失败，部分设备控制功能可能不可用');
+      }
+
+      if (Debugger.debug) {
+        const device: any = this.MiNA?.account?.device;
+        console.debug(
+          '🐛 设备信息：',
+          JSON.stringify(
+            {
+              name: device?.name,
+              desc: device?.desc,
+              model: device?.model,
+              rom: device?.extra?.fw_version,
+            },
+            null,
+            2,
+          ),
+        );
+      }
+
+      this._initialized = true;
+      console.log('✅ MiService 初始化成功');
+      console.log(`🔊 音箱控制方式：${this._speakerControl}`);
+
+      // 初始化成功后发送 TTS 播报（如果启用了启动播报）
+      const announceOnStart = config.announceOnStart ?? true;
+      if (announceOnStart) {
+        const startupMessage = config.startupMessage ?? '您的小龙虾已上线，随时为您服务';
+        try {
+          console.log('🔊 正在发送启动播报:', startupMessage);
+          await this.play(startupMessage);
+          console.log('✅ 启动播报发送成功');
+        } catch (e: any) {
+          console.warn('⚠️ 启动播报发送失败:', e?.message || e);
+        }
+      }
+
+      return true;
+    } catch (err: any) {
+      console.error('❌ 初始化失败:',{err:err,message: err.message});
+      return false;
+    } finally {
+      this._initializing = false;
+    }
+  }
+
+  /**
+   * 获取设备列表
+   */
+  async getDevices(config: MiServiceConfig): Promise<Array<{ did: string; name: string; model?: string }>> {
+    try {
+      // 临时初始化以获取设备列表
+      const tempService = await getMiService({ ...config, service: 'mina', relogin: false });
+      if (!tempService) {
+        return [];
+      }
+
+      const devices = await (tempService as MiNA).getDevices();
+      return (devices || []).map((d: any) => ({
+        did: d.name || d.alias || d.deviceID,
+        name: d.alias || d.name,
+        model: d.model,
+      }));
+    } catch (err) {
+      console.error('❌ 获取设备列表失败:', err);
+      return [];
+    }
+  }
+
+  /**
+   * 重新登录
+   */
+  async relogin(config: MiServiceConfig, did: string): Promise<boolean> {
+    this._initialized = false;
+    return this.init(config, did);
+  }
+
+  /**
+   * 唤醒小爱音箱（进入监听状态）
+   * 使用 MIoT spec 调用唤醒动作 (siid=5, aiid=3)
+   * 基于 mi-gpt 项目的实现
+   */
+  async wakeUp(): Promise<boolean> {
+    if (!this.MiOT) {
+      console.warn('⚠️ MIoT 服务不可用，无法唤醒音箱');
+      return false;
+    }
+    try {
+      const result = await this.MiOT.doAction(5, 3, []);
+      return result;
+    } catch (e: any) {
+      console.warn('⚠️ 唤醒音箱失败:', e?.message || e);
+      return false;
+    }
+  }
+
+  /**
+   * 退出监听状态（取消唤醒）
+   * 使用 MiNA 暂停使小爱退出监听
+   */
+  async unWakeUp(): Promise<void> {
+    if (this.MiNA) {
+      await this.MiNA.pause().catch(() => {});
+    }
+  }
+}
+
+export const MiService = new _MiService();

package/src/speaker.ts

@@ -0,0 +1,264 @@
+import { networkInterfaces } from 'node:os';
+import { MiService } from './service.js';
+import type { MiMoTTS } from './tts/mimo.js';
+
+/**
+ * 获取小爱音箱可访问的主机 IP
+ * 优先使用环境变量 MIMO_TTS_HOST_IP，否则自动检测
+ */
+function getHostLANIP(): string {
+  // 优先使用环境变量（适用于云服务器场景）
+  const envIP = process.env.MIMO_TTS_HOST_IP;
+  if (envIP) return envIP;
+
+  const nets = networkInterfaces();
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name] ?? []) {
+      if (net.internal || net.family !== 'IPv4') continue;
+      if (net.address.startsWith('172.17.')) continue;
+      if (
+        net.address.startsWith('192.168.') ||
+        net.address.startsWith('10.') ||
+        net.address.startsWith('172.16.') ||
+        net.address.startsWith('172.18.') ||
+        net.address.startsWith('172.19.') ||
+        net.address.startsWith('172.2') ||
+        net.address.startsWith('172.3')
+      ) {
+        return net.address;
+      }
+    }
+  }
+  for (const name of Object.keys(nets)) {
+    for (const net of nets[name] ?? []) {
+      if (!net.internal && net.family === 'IPv4') return net.address;
+    }
+  }
+  return '127.0.0.1';
+}
+
+export interface IPlayOptions {
+  text?: string;
+  url?: string;
+  duration?: number;
+}
+
+export interface IPlayResult {
+  success: boolean;
+  error?: string;
+  duration?: number;
+}
+
+class _MiSpeaker {
+  /** MiMo TTS 实例（延迟注入） */
+  private _mimoTTS: MiMoTTS | null = null;
+
+  /**
+   * 注入 MiMo TTS 提供者（自动清理旧实例，防止端口泄漏）
+   */
+  async setMiMoTTS(tts: MiMoTTS) {
+    // 清理旧实例，释放端口
+    if (this._mimoTTS) {
+      console.log('🔊 清理旧 MiMo TTS 实例...');
+      await this._mimoTTS.destroy().catch(() => {});
+    }
+    this._mimoTTS = tts;
+  }
+
+  /**
+   * 清理 MiMo TTS 资源（释放端口和临时文件）
+   */
+  async cleanupMiMoTTS() {
+    if (this._mimoTTS) {
+      console.log('🔊 清理 MiMo TTS 资源...');
+      await this._mimoTTS.destroy().catch(() => {});
+      this._mimoTTS = null;
+    }
+  }
+
+  /**
+   * 播放文字、音频链接
+   * 优先使用 MiMo TTS（如果已配置），否则回退到小米原生 TTS
+   */
+  async play(options: IPlayOptions): Promise<IPlayResult> {
+    const { text, url } = options;
+
+    console.log(`🔊 Speaker.play called: text=${text?.slice(0, 50)}..., url=${url}`);
+
+    if (!MiService.MiNA && !MiService.MiOT) {
+      console.error('❌ Speaker.play failed: MiNA/MiOT service not initialized');
+      return { success: false, error: 'MiNA/MiOT service not initialized' };
+    }
+
+    try {
+      let result: boolean;
+      if (url) {
+        // URL 播放只支持 MiNA
+        if (!MiService.MiNA) {
+          return { success: false, error: 'MiNA service not initialized for URL playback' };
+        }
+        console.log(`🔊 Playing URL: ${url}`);
+        result = await MiService.MiNA.play({ url });
+      } else if (text) {
+        // 优先使用 MiMo TTS
+        if (this._mimoTTS) {
+          console.log(`🔊 Using MiMo TTS for: ${text.slice(0, 30)}...`);
+          const ttsResult = await this._mimoTTS.synthesize(text);
+          if (ttsResult.success && ttsResult.url) {
+            await this._suppressBeforeCustomTTS();
+            const hostIP = getHostLANIP();
+            const externalUrl = ttsResult.url.replace(/0\.0\.0\.0|127\.0\.0\.1|localhost/g, hostIP);
+            console.log(`🔊 MiMo TTS 播放: ${externalUrl} (时长: ${ttsResult.duration?.toFixed(1)}s)`);
+            const duration = ttsResult.duration;  // 保存 duration
+            result = await MiService.MiNA!.play({ url: externalUrl });
+            console.log(`🔊 MiMo TTS play result: ${result}`);
+            // 无论播放是否成功，都返回 duration
+            return { success: result, duration };
+          } else {
+            console.warn('⚠️ MiMo TTS 失败，回退到原生 TTS:', ttsResult.error);
+            result = await MiService.play(text);
+          }
+        } else {
+          // 文字播报使用配置的播放方式
+          console.log(`🔊 Using native TTS for: ${text.slice(0, 30)}...`);
+          result = await MiService.play(text);
+        }
+      } else {
+        return { success: false, error: 'text or url is required' };
+      }
+
+      if (result) {
+        return { success: true, duration: options.duration };
+      } else {
+        return { success: false, error: 'Playback failed' };
+      }
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * 自定义 TTS 播放前的抑制处理
+   * 暂停当前播放，防止小爱将 TTS 音频误识别为用户语音指令
+   */
+  private async _suppressBeforeCustomTTS() {
+    if (MiService.MiNA) {
+      await MiService.MiNA.pause().catch(() => {});
+    }
+  }
+
+  /**
+   * 设置音量
+   */
+  async setVolume(volume: number): Promise<IPlayResult> {
+    if (!MiService.MiNA && !MiService.MiOT) {
+      return { success: false, error: 'MiNA/MiOT service not initialized' };
+    }
+
+    try {
+      // 音量控制只支持 MiNA
+      if (MiService.MiNA) {
+        const result = await MiService.MiNA.setVolume(volume);
+        if (result) {
+          return { success: true };
+        } else {
+          return { success: false, error: 'Failed to set volume' };
+        }
+      } else {
+        return { success: false, error: 'MiNA service required for volume control' };
+      }
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * 获取音量
+   */
+  async getVolume(): Promise<number | undefined> {
+    if (!MiService.MiNA) {
+      return undefined;
+    }
+
+    try {
+      return await MiService.MiNA.getVolume();
+    } catch {
+      return undefined;
+    }
+  }
+
+  /**
+   * 暂停播放
+   */
+  async pause(): Promise<IPlayResult> {
+    if (!MiService.MiNA && !MiService.MiOT) {
+      return { success: false, error: 'MiNA/MiOT service not initialized' };
+    }
+
+    try {
+      // 暂停只支持 MiNA
+      if (MiService.MiNA) {
+        const result = await MiService.MiNA.pause();
+        return { success: result };
+      } else {
+        return { success: false, error: 'MiNA service required for pause' };
+      }
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * 停止播放
+   */
+  async stop(): Promise<IPlayResult> {
+    if (!MiService.MiNA && !MiService.MiOT) {
+      return { success: false, error: 'MiNA/MiOT service not initialized' };
+    }
+
+    try {
+      // 停止只支持 MiNA
+      if (MiService.MiNA) {
+        const result = await MiService.MiNA.stop();
+        return { success: result };
+      } else {
+        return { success: false, error: 'MiNA service required for stop' };
+      }
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * 播放或暂停
+   */
+  async playOrPause(): Promise<IPlayResult> {
+    if (!MiService.MiNA && !MiService.MiOT) {
+      return { success: false, error: 'MiNA/MiOT service not initialized' };
+    }
+
+    try {
+      // 播放或暂停只支持 MiNA
+      if (MiService.MiNA) {
+        const result = await MiService.MiNA.playOrPause();
+        return { success: result };
+      } else {
+        return { success: false, error: 'MiNA service required for playOrPause' };
+      }
+    } catch (err: any) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  /**
+   * 中断小爱音箱的运行（重启设备）
+   * 注意：重启需要大约 1-2s 的时间，在此期间无法使用小爱音箱自带的 TTS 服务
+   */
+  async abortXiaoAI(): Promise<boolean> {
+    // 无法通过 MiOT 中断小爱运行
+    // 可以通过 MiOT 重启设备，但这会影响所有功能
+    return false;
+  }
+}
+
+export const MiSpeaker = new _MiSpeaker();