@z-qinghui/migpt-claw 1.0.0

package/src/tts/mimo.ts

@@ -0,0 +1,300 @@
+/**
+ * MiMo-V2.5-TT TTS Provider
+ *
+ * 使用小米 MiMo TTS API 生成语音，通过本地 HTTP 服务器提供给音箱播放。
+ * API 文档: https://mimo.mi.com/docs/zh-CN/quick-start/usage-guide/multimodal-understanding/speech-synthesis-v2.5
+ */
+import { createServer, type Server } from 'node:http';
+import { writeFile, mkdir, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+export interface MiMoTTSConfig {
+  /** MiMo API Key */
+  apiKey: string;
+  /** MiMo API Base URL，默认 https://api.xiaomimimo.com/v1 */
+  baseUrl?: string;
+  /** TTS 模型，默认 mimo-v2.5-tts */
+  model?: string;
+  /** 预设音色 ID，默认 mimo_default */
+  voice?: string;
+  /** 风格指令（放在 user role 中） */
+  style?: string;
+  /** 是否启用流式传输（减少首字延迟），默认 true */
+  stream?: boolean;
+  /** 本地服务器监听端口，0 = 自动分配 */
+  port?: number;
+  /** 本地服务器监听地址，默认 0.0.0.0 */
+  host?: string;
+}
+
+export class MiMoTTS {
+  private _server: Server | null = null;
+  private _serverUrl = '';
+  private _audioDir = '';
+  private _config: Required<MiMoTTSConfig>;
+  private _ready = false;
+
+  constructor(config: MiMoTTSConfig) {
+    this._config = {
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl ?? 'https://api.xiaomimimo.com/v1',
+      model: config.model ?? 'mimo-v2.5-tts',
+      voice: config.voice ?? 'mimo_default',
+      style: config.style ?? '',
+      stream: config.stream ?? true,
+      port: config.port ?? 0,
+      host: config.host ?? '0.0.0.0',
+    };
+  }
+
+  /**
+   * 初始化：创建临时目录 + 启动 HTTP 服务器
+   */
+  async init(): Promise<boolean> {
+    if (this._ready) return true;
+
+    try {
+      this._audioDir = join(tmpdir(), 'migpt-claw-tts', randomUUID());
+      await mkdir(this._audioDir, { recursive: true });
+
+      this._server = createServer((req, res) => {
+        const url = decodeURIComponent(req.url ?? '');
+        if (!url.startsWith('/audio/')) {
+          res.writeHead(404);
+          res.end('Not Found');
+          return;
+        }
+
+        const filePath = join(this._audioDir, url.replace('/audio/', ''));
+        serveWavFile(filePath, res).catch(() => {
+          res.writeHead(404);
+          res.end('Not Found');
+        });
+      });
+
+      await new Promise<void>((resolve, reject) => {
+        this._server!.listen(this._config.port, this._config.host, () => {
+          const addr = this._server!.address();
+          if (addr && typeof addr === 'object') {
+            this._serverUrl = `http://${addr.address === '::' ? 'localhost' : addr.address}:${addr.port}`;
+            this._ready = true;
+            resolve();
+          } else {
+            reject(new Error('Failed to get server address'));
+          }
+        });
+        this._server!.on('error', reject);
+      });
+
+      console.log(`✅ MiMo TTS 服务器已启动: ${this._serverUrl}`);
+      return true;
+    } catch (err: any) {
+      console.error('❌ MiMo TTS 初始化失败:', err.message);
+      return false;
+    }
+  }
+
+  /**
+   * 生成语音并返回可播放的 URL
+   */
+  async synthesize(text: string, options?: {
+    voice?: string;
+    style?: string;
+  }): Promise<{ url: string; success: boolean; error?: string; duration?: number }> {
+    if (!this._ready) {
+      const ok = await this.init();
+      if (!ok) return { url: '', success: false, error: 'TTS server not initialized' };
+    }
+
+    try {
+      // 构建请求
+      const messages: Array<{ role: string; content: string }> = [];
+
+      const style = options?.style ?? this._config.style;
+      if (style) {
+        messages.push({ role: 'user', content: style });
+      }
+
+      messages.push({ role: 'assistant', content: text });
+
+      const voice = options?.voice ?? this._config.voice;
+
+      const useStream = this._config.stream;
+
+      const body = {
+        model: this._config.model,
+        messages,
+        audio: { format: useStream ? 'pcm16' : 'wav', voice },
+        stream: useStream,
+      };
+
+      // 调用 MiMo API
+      const response = await fetch(`${this._config.baseUrl}/chat/completions`, {
+        method: 'POST',
+        headers: {
+          'api-key': this._config.apiKey,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!response.ok) {
+        const errText = await response.text().catch(() => 'unknown');
+        return { url: '', success: false, error: `MiMo API error ${response.status}: ${errText}` };
+      }
+
+      let audioBuffer: Buffer;
+
+      if (useStream) {
+        // 流式模式：收集所有 PCM16 chunk 并拼接为 WAV
+        const pcmChunks: Buffer[] = [];
+        const reader = response.body?.getReader();
+        if (!reader) {
+          return { url: '', success: false, error: 'Failed to read streaming response' };
+        }
+
+        const decoder = new TextDecoder();
+        let buffer = '';
+
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split('\n');
+          buffer = lines.pop() ?? '';
+
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith('data: ')) continue;
+            const jsonStr = trimmed.slice(6);
+            if (jsonStr === '[DONE]') continue;
+
+            try {
+              const chunk = JSON.parse(jsonStr);
+              const audioData = chunk?.choices?.[0]?.delta?.audio?.data;
+              if (audioData) {
+                pcmChunks.push(Buffer.from(audioData, 'base64'));
+              }
+            } catch {
+              // 忽略解析错误
+            }
+          }
+        }
+
+        if (pcmChunks.length === 0) {
+          return { url: '', success: false, error: 'No audio data in streaming response' };
+        }
+
+        // PCM16 → WAV（24kHz, mono, 16-bit）
+        const pcmData = Buffer.concat(pcmChunks);
+        audioBuffer = pcmToWav(pcmData, 24000, 1, 16);
+      } else {
+        // 非流式模式：直接从响应中获取 WAV
+        const data = await response.json() as any;
+        const audioBase64 = data?.choices?.[0]?.message?.audio?.data;
+
+        if (!audioBase64) {
+          return { url: '', success: false, error: 'No audio data in MiMo response' };
+        }
+
+        audioBuffer = Buffer.from(audioBase64, 'base64');
+      }
+
+      // 保存音频文件
+      const fileName = `${randomUUID()}.wav`;
+      const filePath = join(this._audioDir, fileName);
+      await writeFile(filePath, audioBuffer);
+
+      const url = `${this._serverUrl}/audio/${fileName}`;
+      
+      // 计算音频时长（秒）
+      // WAV: PCM 16-bit mono 24000 Hz
+      const headerSize = 44;
+      const sampleRate = 24000;
+      const bytesPerSample = 2;
+      const duration = (audioBuffer.length - headerSize) / (sampleRate * bytesPerSample);
+      
+      return { url, success: true, duration };
+    } catch (err: any) {
+      return { url: '', success: false, error: err.message };
+    }
+  }
+
+  /**
+   * 清理临时文件和关闭服务器
+   */
+  async destroy() {
+    if (this._server) {
+      await new Promise<void>((resolve) => {
+        this._server!.close(() => resolve());
+      });
+      this._server = null;
+    }
+    if (this._audioDir) {
+      await rm(this._audioDir, { recursive: true, force: true }).catch(() => {});
+    }
+    this._ready = false;
+  }
+
+  get ready() {
+    return this._ready;
+  }
+
+  get serverUrl() {
+    return this._serverUrl;
+  }
+}
+
+/**
+ * 将 WAV 文件作为 HTTP 响应返回
+ */
+async function serveWavFile(filePath: string, res: import('node:http').ServerResponse) {
+  const { readFile } = await import('node:fs/promises');
+  const data = await readFile(filePath);
+  res.writeHead(200, {
+    'Content-Type': 'audio/wav',
+    'Content-Length': data.length,
+    'Cache-Control': 'no-cache',
+  });
+  res.end(data);
+}
+
+/**
+ * PCM16 原始数据 → WAV 文件 Buffer
+ * @param pcmData PCM16 原始音频数据
+ * @param sampleRate 采样率（MiMo TTS 流式输出为 24000）
+ * @param channels 声道数（1 = mono）
+ * @param bitsPerSample 每样本位数（16）
+ */
+function pcmToWav(pcmData: Buffer, sampleRate: number, channels: number, bitsPerSample: number): Buffer {
+  const byteRate = sampleRate * channels * (bitsPerSample / 8);
+  const blockAlign = channels * (bitsPerSample / 8);
+  const dataSize = pcmData.length;
+  const headerSize = 44;
+  const buffer = Buffer.alloc(headerSize + dataSize);
+
+  // RIFF header
+  buffer.write('RIFF', 0);
+  buffer.writeUInt32LE(36 + dataSize, 4);
+  buffer.write('WAVE', 8);
+
+  // fmt sub-chunk
+  buffer.write('fmt ', 12);
+  buffer.writeUInt32LE(16, 16);           // sub-chunk size
+  buffer.writeUInt16LE(1, 20);            // PCM format
+  buffer.writeUInt16LE(channels, 22);
+  buffer.writeUInt32LE(sampleRate, 24);
+  buffer.writeUInt32LE(byteRate, 28);
+  buffer.writeUInt16LE(blockAlign, 32);
+  buffer.writeUInt16LE(bitsPerSample, 34);
+
+  // data sub-chunk
+  buffer.write('data', 36);
+  buffer.writeUInt32LE(dataSize, 40);
+  pcmData.copy(buffer, headerSize);
+
+  return buffer;
+}

package/src/types.ts

@@ -0,0 +1,34 @@
+// Re-export types from config.ts
+export type {
+  MiGPTConfig,
+  MiGPTAccountConfig,
+  ResolvedMiAccount,
+  ExtendedOpenClawConfig,
+} from './config.js';
+
+// Message types
+export interface IMessage {
+  id: string;
+  sender: 'user';
+  text: string;
+  timestamp: number;
+  deviceId: string;
+}
+
+// Device types
+export interface MiDevice {
+  did: string;
+  name: string;
+  model?: string;
+  mac?: string;
+}
+
+// Message event types
+export interface MiMessageEvent {
+  channel: 'migpt';
+  accountId: string;
+  from: string;
+  fromName: string;
+  text: string;
+  timestamp: number;
+}

package/src/utils/codec.ts

@@ -0,0 +1,206 @@
+import { jsonDecode } from './parse.js';
+import * as pako from 'pako';
+import { randomNoise, signNonce } from './hash.js';
+import { createHmac } from 'crypto';
+import { Debugger } from './debug.js';
+import type { MiPass } from '../mi/typing.js';
+
+/**
+ * 解析登录响应中的认证参数
+ * 参考 migpt-next 实现
+ */
+export function parseAuthPass(res: string): Partial<{
+  code: number;
+  description: string;
+  captchaUrl: string;
+  notificationUrl: string;
+} & MiPass> {
+  try {
+    // 如果传入的是 HttpResponse 对象，提取 data 字段
+    return (
+      jsonDecode(
+        res
+          .replace('&&&START&&&', '') // 去除前缀
+          .replace(/:(\d{9,})/g, ':"$1"'), // 把 userId 和 nonce 转成 string
+      ) ?? {}
+    );
+  } catch {
+    return {};
+  }
+}
+
+export function encodeQuery(data: Record<string, string | number | boolean | undefined>): string {
+  return Object.entries(data)
+    .map(
+      ([key, value]) =>
+        `${encodeURIComponent(key)}=${encodeURIComponent(value == null ? '' : value.toString())}`,
+    )
+    .join('&');
+}
+
+export function decodeQuery(str: string) {
+  const data: any = {};
+  if (!str) {
+    return data;
+  }
+  const ss: any = str.split('&');
+  for (let i = 0; i < ss.length; i++) {
+    const s = ss[i].split('=');
+    if (s.length != 2) {
+      continue;
+    }
+    const k = decodeURIComponent(s[0]);
+    let v: any = decodeURIComponent(s[1]);
+    if (/^\[{/.test(v)) {
+      try {
+        v = jsonDecode(v);
+      } catch {
+        // ignore
+      }
+    }
+    data[k] = v;
+  }
+  return data;
+}
+
+/**
+ * URL 编码对象为 form 格式
+ */
+export function encodeFormData(data: Record<string, any>): string {
+  return Object.entries(data)
+    .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`)
+    .join('&');
+}
+
+interface MIoTRequest {
+  data: string;
+  signature: string;
+  _nonce: string;
+}
+
+// RC4 实现（用于兼容旧版本和响应解密）
+class RC4 {
+  private i: number = 0;
+  private j: number = 0;
+  private S: Buffer;
+
+  constructor(key: Buffer) {
+    this.S = Buffer.alloc(256);
+    for (let idx = 0; idx < 256; idx++) {
+      this.S[idx] = idx;
+    }
+    let j = 0;
+    for (let idx = 0; idx < 256; idx++) {
+      j = (j + this.S[idx] + key[idx % key.length]) & 0xff;
+      [this.S[idx], this.S[j]] = [this.S[j], this.S[idx]];
+    }
+  }
+
+  update(data: Buffer): Buffer {
+    const result = Buffer.alloc(data.length);
+    for (let n = 0; n < data.length; n++) {
+      this.i = (this.i + 1) & 0xff;
+      this.j = (this.j + this.S[this.i]) & 0xff;
+      [this.S[this.i], this.S[this.j]] = [this.S[this.j], this.S[this.i]];
+      const K = this.S[(this.S[this.i] + this.S[this.j]) & 0xff];
+      result[n] = data[n] ^ K;
+    }
+    return result;
+  }
+}
+
+/**
+ * MIoT 签名算法 - 参考 MiService Python 实现
+ * 签名格式：uri&snonce&nonce&data=xxx
+ * 使用 HMAC-SHA256
+ * 注意：只签名，不加密数据！
+ */
+function signMIoT(uri: string, snonce: string, nonce: string, data: string): string {
+  const msg = `${uri}&${snonce}&${nonce}&data=${data}`;
+  const key = Buffer.from(snonce, 'base64');
+  return createHmac('sha256', key).update(msg).digest('base64');
+}
+
+/**
+ * MIoT 请求编码 - 参考 MiService sign_data
+ * 只签名，不加密数据
+ */
+export function encodeMIoT(uri: string, data: any, ssecurity: string): MIoTRequest {
+  const nonce = randomNoise();
+  const snonce = signNonce(ssecurity, nonce) as string;
+  // Python 的 json.dumps 默认格式：": " 和 ", "
+  // JavaScript 的 JSON.stringify 默认紧凑格式，需要手动替换
+  const json = JSON.stringify(data).replace(/:/g, ': ').replace(/,/g, ', ');
+
+  // HMAC-SHA256 签名
+  const signature = signMIoT(uri, snonce, nonce, json);
+
+  if (Debugger.debug) {
+    console.log('encodeMIoT 签名详情:', {
+      uri,
+      ssecurity: ssecurity.slice(0, 20) + '...',
+      nonce,
+      snonce,
+      json,
+      signature,
+      signMsg: `${uri}&${snonce}&${nonce}&data=${json}`,
+    });
+  }
+
+  return {
+    _nonce: nonce,
+    data: json,
+    signature: signature,
+  };
+}
+
+export function decodeMIoT(
+  ssecurity: string,
+  nonce: string,
+  data: string,
+  gzip?: boolean,
+): Promise<any | undefined> {
+  // 先尝试直接解析 JSON（MiService 响应是明文）
+  try {
+    const res = jsonDecode(data);
+    if (res) {
+      return Promise.resolve(res);
+    }
+  } catch {
+    // ignore
+  }
+  
+  // 如果直接解析失败，尝试 RC4 解密（兼容旧版本）
+  let decrypted: Buffer;
+  try {
+    const key = Buffer.from(signNonce(ssecurity, nonce), 'base64');
+    const rc4 = new RC4(key);
+    rc4.update(Buffer.alloc(1024));
+    decrypted = Buffer.from(rc4.update(Buffer.from(data, 'base64')));
+    // 如果 RC4 解密成功，尝试 gzip 解压
+    if (gzip) {
+      try {
+        decrypted = Buffer.from(pako.ungzip(decrypted));
+      } catch (err) {
+        // ignore gzip error
+      }
+    }
+  } catch {
+    // 如果不是 RC4 加密的数据，直接使用原始数据
+    decrypted = Buffer.from(data, 'base64');
+    // 如果需要 gzip 解压
+    if (gzip) {
+      try {
+        decrypted = Buffer.from(pako.ungzip(decrypted));
+      } catch (err) {
+        // ignore gzip error
+      }
+    }
+  }
+  
+  const res = jsonDecode(decrypted.toString());
+  if (!res) {
+    console.error('❌ decodeMIoT failed');
+  }
+  return Promise.resolve(res);
+}

package/src/utils/debug.ts

@@ -0,0 +1,16 @@
+/**
+ * 调试工具
+ */
+export class Debugger {
+  static debug = false;
+
+  static log(...args: any[]) {
+    if (this.debug) {
+      console.log('[MiGPT]', ...args);
+    }
+  }
+
+  static error(...args: any[]) {
+    console.error('[MiGPT]', ...args);
+  }
+}

package/src/utils/hash.ts

@@ -0,0 +1,104 @@
+import * as crypto from 'node:crypto';
+
+/**
+ * MD5 哈希
+ */
+export function md5(data: string | Buffer): string {
+  return crypto.createHash('md5').update(data).digest('hex');
+}
+
+/**
+ * SHA1 哈希
+ */
+export function sha1(data: string | Buffer): string {
+  return crypto.createHash('sha1').update(data).digest('base64');
+}
+
+/**
+ * SHA256 HMAC
+ */
+export function sha256(snonce: string, msg: string): string {
+  return crypto.createHmac('sha256', Buffer.from(snonce, 'base64')).update(msg).digest('base64');
+}
+
+/**
+ * 签名 nonce（用于 MIoT）
+ * 参考 migpt-next 实现
+ */
+export function signNonce(ssecurity: string, nonce: string): string {
+  const m = crypto.createHash('sha256');
+  m.update(ssecurity, 'base64');
+  m.update(nonce, 'base64');
+  return m.digest().toString('base64');
+}
+
+/**
+ * 生成 UUID
+ */
+export function uuid(): string {
+  return crypto.randomUUID();
+}
+
+/**
+ * 生成随机字符串
+ */
+export function randomString(len: number): string {
+  if (len < 1) return '';
+  const s = Math.random().toString(36).slice(2);
+  return s + randomString(len - s.length);
+}
+
+/**
+ * 生成随机噪声（用于 MIoT nonce）
+ * 参考 MiService Python 实现：urandom(8) + int(time.time() / 60).to_bytes(4, "big")
+ */
+export function randomNoise(): string {
+  const randomBytes = crypto.randomBytes(8);
+  const timeInMinutes = Math.floor(Date.now() / 1000 / 60);
+  // 使用 Uint32BE 写入 4 字节时间戳（大端序）
+  const timeBuffer = Buffer.alloc(4);
+  timeBuffer.writeUInt32BE(timeInMinutes >>> 0, 0);
+  return Buffer.concat([randomBytes, timeBuffer]).toString('base64');
+}
+
+/**
+ * RC4 加密
+ */
+export function rc4Encrypt(key: Buffer, data: Buffer): Buffer {
+  const ksa = (key: Buffer): number[] => {
+    const S = new Array(256);
+    for (let i = 0; i < 256; i++) {
+      S[i] = i;
+    }
+    let j = 0;
+    for (let i = 0; i < 256; i++) {
+      j = (j + S[i] + key[i % key.length]) & 0xff;
+      [S[i], S[j]] = [S[j], S[i]];
+    }
+    return S;
+  };
+
+  const prga = (S: number[], data: Buffer): Buffer => {
+    const result = Buffer.alloc(data.length);
+    let i = 0;
+    let j = 0;
+    for (let n = 0; n < data.length; n++) {
+      i = (i + 1) & 0xff;
+      j = (j + S[i]) & 0xff;
+      [S[i], S[j]] = [S[j], S[i]];
+      const K = S[(S[i] + S[j]) & 0xff];
+      result[n] = data[n] ^ K;
+    }
+    return result;
+  };
+
+  const S = ksa(key);
+  return prga(S, data);
+}
+
+/**
+ * RC4 解密（与加密相同）
+ */
+export function rc4Decrypt(key: Buffer, data: Buffer): Buffer {
+  return rc4Encrypt(key, data);
+}