@z-qinghui/migpt-claw 1.0.0

package/src/onboarding.ts

@@ -0,0 +1,136 @@
+import type { ChannelOnboardingAdapter } from 'openclaw/plugin-sdk';
+import { MiService } from './service.js';
+import type { MiServiceConfig } from './service.js';
+
+export const miGPTOnboardingAdapter: ChannelOnboardingAdapter = {
+  async selectAccount({ accounts }: { accounts: string[] }) {
+    if (accounts.length === 0) {
+      return { action: 'create' };
+    }
+    if (accounts.length === 1) {
+      return { action: 'use', accountId: accounts[0] };
+    }
+    return { action: 'select' };
+  },
+
+  async promptCredentials() {
+    // 这些方法由 OpenClaw 框架在运行时提供
+    const answers: any = {};
+
+    answers.userId = await (this as any).prompt.input({
+      message: '请输入你的小米 ID（数字，在小米账号「个人信息」-「小米 ID」查看）:',
+      validate: (v: string) => /^\d+$/.test(v) || '小米 ID 必须是数字',
+    });
+
+    const usePassToken = await (this as any).prompt.confirm({
+      message: '是否使用 passToken 登录？（推荐，可避免验证码）',
+      initial: false,
+    });
+
+    if (usePassToken) {
+      answers.passToken = await (this as any).prompt.password({
+        message: '请输入 passToken:',
+        validate: (v: string) => !!v || 'passToken 不能为空',
+      });
+    } else {
+      answers.password = await (this as any).prompt.password({
+        message: '请输入小米账号密码:',
+        validate: (v: string) => !!v || '密码不能为空',
+      });
+    }
+
+    answers.deviceName = await (this as any).prompt.input({
+      message: '请输入小爱音箱在米家中设置的名称（如：客厅音箱）:',
+      validate: (v: string) => !!v || '设备名称不能为空',
+    });
+
+    return answers;
+  },
+
+  async validateCredentials({ input }: { input: any }) {
+    const config: MiServiceConfig = {
+      userId: input.userId,
+      password: input.password,
+      passToken: input.passToken,
+      debug: true,
+    };
+
+    try {
+      const devices = await MiService.getDevices(config);
+      
+      if (devices.length === 0) {
+        return {
+          valid: false,
+          error: '未找到任何设备，请检查账号凭证是否正确',
+        };
+      }
+
+      const deviceName = input.deviceName;
+      const matchedDevice = devices.find(
+        (d) => d.name.toLowerCase() === deviceName.toLowerCase() || 
+               d.did.toLowerCase() === deviceName.toLowerCase()
+      );
+
+      if (!matchedDevice) {
+        const deviceList = devices.map((d) => d.name).join(', ');
+        return {
+          valid: false,
+          error: `未找到设备 "${deviceName}"。可用设备：${deviceList}`,
+        };
+      }
+
+      return {
+        valid: true,
+        data: {
+          did: matchedDevice.did,
+        },
+      };
+    } catch (err: any) {
+      return {
+        valid: false,
+        error: err.message || '验证失败',
+      };
+    }
+  },
+
+  applyConfig({ cfg, accountId, input, validatedData }: { cfg: any; accountId?: string; input: any; validatedData?: any }) {
+    const migptCfg = cfg.channels?.migpt ?? {};
+    
+    const accountConfig = {
+      userId: input.userId,
+      password: input.password,
+      passToken: input.passToken,
+      devices: [validatedData?.did || input.deviceName],
+      enabled: true,
+    };
+
+    const isDefault = !accountId || accountId === 'main';
+
+    if (isDefault) {
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          migpt: {
+            ...migptCfg,
+            ...accountConfig,
+          },
+        },
+      };
+    }
+
+    return {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        migpt: {
+          ...migptCfg,
+          accounts: {
+            ...migptCfg.accounts,
+            [accountId]: accountConfig,
+          },
+        },
+      },
+    };
+  },
+};

package/src/openclaw-plugin-sdk.d.ts

@@ -0,0 +1,185 @@
+// Type declarations for openclaw/plugin-sdk
+declare module 'openclaw/plugin-sdk/channel-core' {
+  export function defineSetupPluginEntry(plugin: any): any;
+}
+
+declare module 'openclaw/plugin-sdk' {
+  export const DEFAULT_ACCOUNT_ID: string;
+
+  export function emptyPluginConfigSchema(): any;
+
+  export interface PluginRuntime {
+    channel: {
+      activity: {
+        record: (opts: { channel: string; accountId: string; direction: 'inbound' | 'outbound' }) => void;
+      };
+      reply: {
+        finalizeInboundContext: (opts: {
+          Body: string;
+          BodyForAgent?: string;
+          RawBody?: string;
+          CommandBody?: string;
+          From: string;
+          To: string;
+          SessionKey: string;
+          AccountId: string;
+          ChatType: 'direct' | 'group';
+          SenderId: string;
+          SenderName?: string;
+          Provider: string;
+          Surface: string;
+          MessageSid: string;
+          Timestamp: number;
+          OriginatingChannel: string;
+          OriginatingTo: string;
+          CommandAuthorized?: boolean;
+          MediaPaths?: string[];
+          MediaPath?: string;
+          MediaTypes?: string[];
+          MediaType?: string;
+          MediaUrls?: string[];
+          MediaUrl?: string;
+          ImageMediaTypes?: string[];
+        }) => any;
+        dispatchReplyWithBufferedBlockDispatcher: (opts: {
+          ctx: any;
+          cfg: any;
+          dispatcherOptions?: {
+            responsePrefix?: string;
+            deliver?: (payload: { text?: string; mediaUrls?: string[]; mediaUrl?: string }, info: { kind: string }) => Promise<void>;
+          };
+        }) => Promise<void>;
+        resolveEffectiveMessagesConfig: (cfg: any, agentId?: string) => any;
+        resolveEnvelopeFormatOptions: (cfg: any) => any;
+        formatInboundEnvelope: (opts: {
+          Body: string;
+          BodyForAgent?: string;
+          From: string;
+          To: string;
+          SessionKey: string;
+          ChatType: 'direct' | 'group';
+          SenderId: string;
+          SenderName?: string;
+          Provider: string;
+          Surface: string;
+          MessageSid: string;
+          Timestamp: number;
+          OriginatingChannel: string;
+          envelopeOptions: any;
+        }) => string;
+      };
+      routing: {
+        resolveAgentRoute: (opts: {
+          from: string;
+          to: string;
+          sessionKey: string;
+          accountId: string;
+          chatType: 'direct' | 'group';
+          provider: string;
+        }) => any;
+      };
+    };
+  }
+
+  export interface OpenClawPluginApi {
+    runtime: PluginRuntime;
+    logger: any;
+    registerChannel(options: { plugin: any }): void;
+    registerTool(tool: any): void;
+    registerGatewayMethod(name: string, handler: any): void;
+    registerHttpRoute(handler: any): void;
+    registerCli(handler: any, options?: any): void;
+    registerCommand(command: any): void;
+    registerService(service: any): void;
+    registerContextEngine(id: string, factory: any): void;
+    registerHook(event: string, handler: any, options?: any): void;
+    registerProvider(provider: any): void;
+    on(event: string, handler: any, options?: any): void;
+  }
+  
+  export interface ChannelPlugin<T = any> {
+    id: string;
+    meta: {
+      id: string;
+      label: string;
+      selectionLabel: string;
+      docsPath?: string;
+      docsLabel?: string;
+      blurb: string;
+      aliases?: string[];
+      order?: number;
+    };
+    capabilities: {
+      chatTypes: string[];
+      polls?: boolean;
+      threads?: boolean;
+      media?: boolean;
+      reactions?: boolean;
+      edit?: boolean;
+      reply?: boolean;
+      blockStreaming?: boolean;
+    };
+    reload?: { configPrefixes: string[] };
+    onboarding?: ChannelOnboardingAdapter;
+    config: {
+      listAccountIds: (cfg: any) => string[];
+      resolveAccount: (cfg: any, accountId?: string) => T;
+      defaultAccountId: (cfg: any) => string;
+      setAccountEnabled: (opts: { cfg: any; accountId: string; enabled: boolean }) => any;
+      deleteAccount: (opts: { cfg: any; accountId: string }) => any;
+      isConfigured: (account: T) => boolean;
+      describeAccount: (account: T) => any;
+      resolveAllowFrom?: (opts: { cfg: any; accountId?: string }) => string[];
+      formatAllowFrom?: (opts: { allowFrom: Array<string | number> }) => string[];
+    };
+    setup?: {
+      resolveAccountId?: (opts: any) => string;
+      applyAccountConfig?: (opts: any) => any;
+      validateInput?: (opts: any) => string | null;
+      applyAccountName?: (opts: any) => any;
+    };
+    messaging?: {
+      normalizeTarget: (target: string) => { ok: boolean; to?: string; error?: string };
+      targetResolver: {
+        looksLikeId: (id: string) => boolean;
+        hint: string;
+      };
+    };
+    outbound: ChannelOutboundAdapter;
+    gateway?: {
+      startAccount: (ctx: any) => Promise<void>;
+      logoutAccount?: (opts: any) => Promise<any>;
+    };
+    status?: {
+      defaultRuntime: any;
+      buildChannelSummary?: (opts: any) => any;
+      probeAccount?: (opts: any) => Promise<any>;
+      buildAccountSnapshot?: (opts: any) => any;
+    };
+    pairing?: any;
+    security?: any;
+    groups?: any;
+    agentPrompt?: any;
+    directory?: any;
+  }
+  
+  export interface ChannelOutboundAdapter {
+    deliveryMode: string;
+    chunker?: (text: string, limit: number) => string[];
+    chunkerMode?: string;
+    textChunkLimit?: number;
+    sendText: (opts: { to: string; text: string; accountId?: string; cfg: any; replyToId?: string }) => Promise<any>;
+    sendMedia?: (opts: { to: string; text?: string; mediaUrl: string; accountId?: string; cfg: any; replyToId?: string }) => Promise<any>;
+  }
+  
+  export interface ChannelOnboardingAdapter {
+    selectAccount?: (opts: any) => Promise<any>;
+    promptCredentials?: () => Promise<any>;
+    validateCredentials?: (opts: any) => Promise<any>;
+    applyConfig?: (opts: any) => any;
+  }
+  
+  export interface OpenClawConfig {
+    channels?: Record<string, any>;
+  }
+}

package/src/outbound.ts

@@ -0,0 +1,137 @@
+import type { ChannelOutboundAdapter } from 'openclaw/plugin-sdk';
+import { MiService } from './service.js';
+import { MiSpeaker } from './speaker.js';
+import { resolveMiAccount } from './config.js';
+import type { ExtendedOpenClawConfig } from './types.js';
+
+/**
+ * 文本分块函数
+ */
+function chunkText(text: string, limit: number): string[] {
+  if (text.length <= limit) return [text];
+  
+  const chunks: string[] = [];
+  let remaining = text;
+  
+  while (remaining.length > 0) {
+    if (remaining.length <= limit) {
+      chunks.push(remaining);
+      break;
+    }
+    
+    // 尝试在换行处分割
+    let splitAt = remaining.lastIndexOf('\n', limit);
+    if (splitAt <= 0 || splitAt < limit * 0.5) {
+      // 没找到合适的换行，尝试在空格处分割
+      splitAt = remaining.lastIndexOf(' ', limit);
+    }
+    if (splitAt <= 0 || splitAt < limit * 0.5) {
+      // 还是没找到，强制在 limit 处分割
+      splitAt = limit;
+    }
+    
+    chunks.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).trimStart();
+  }
+  
+  return chunks;
+}
+
+export const miOutbound: ChannelOutboundAdapter = {
+  deliveryMode: 'direct',
+  chunker: chunkText,
+  chunkerMode: 'plain',
+  textChunkLimit: 200,
+  
+  sendText: async ({ to, text, accountId, cfg }) => {
+    const account = resolveMiAccount(cfg as unknown as ExtendedOpenClawConfig, accountId);
+    
+    if (!account.configured) {
+      return { 
+        channel: 'migpt', 
+        error: new Error('Account not configured') 
+      };
+    }
+
+    // 初始化服务
+    const initSuccess = await MiService.init(account.config, to);
+    if (!initSuccess) {
+      return { 
+        channel: 'migpt', 
+        error: new Error('Failed to initialize MiService') 
+      };
+    }
+
+    // 设置音量（如果配置了）
+    const volume = cfg.channels?.migpt?.volume;
+    if (volume && volume >= 6 && volume <= 100) {
+      await MiSpeaker.setVolume(volume);
+    }
+
+    // 分块发送（如果启用流式）
+    const streaming = cfg.channels?.migpt?.streaming ?? true;
+    const chunkLimit = cfg.channels?.migpt?.textChunkLimit ?? 200;
+    
+    if (streaming && text.length > chunkLimit) {
+      const chunks = chunkText(text, chunkLimit);
+      for (const chunk of chunks) {
+        const result = await MiSpeaker.play({ text: chunk });
+        if (!result.success) {
+          return { 
+            channel: 'migpt', 
+            error: new Error(result.error) 
+          };
+        }
+        // 小块之间短暂暂停，避免过于紧凑
+        await new Promise(resolve => setTimeout(resolve, 200));
+      }
+      return { channel: 'migpt', messageId: Date.now().toString() };
+    } else {
+      const result = await MiSpeaker.play({ text });
+      if (!result.success) {
+        return { 
+          channel: 'migpt', 
+          error: new Error(result.error) 
+        };
+      }
+      return { channel: 'migpt', messageId: Date.now().toString() };
+    }
+  },
+  
+  sendMedia: async ({ to, text, mediaUrl, accountId, cfg }) => {
+    const account = resolveMiAccount(cfg as unknown as ExtendedOpenClawConfig, accountId);
+    
+    if (!account.configured) {
+      return { 
+        channel: 'migpt', 
+        error: new Error('Account not configured') 
+      };
+    }
+
+    const initSuccess = await MiService.init(account.config, to);
+    if (!initSuccess) {
+      return { 
+        channel: 'migpt', 
+        error: new Error('Failed to initialize MiService') 
+      };
+    }
+
+    // 发送文本说明（如果有）
+    if (text?.trim()) {
+      await MiSpeaker.play({ text });
+    }
+
+    // 播放音频 URL
+    if (mediaUrl) {
+      const result = await MiSpeaker.play({ url: mediaUrl });
+      if (!result.success) {
+        return { 
+          channel: 'migpt', 
+          error: new Error(result.error) 
+        };
+      }
+    }
+
+    return { channel: 'migpt', messageId: Date.now().toString() };
+  },
+};

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setMiGPTRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getMiGPTRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error("MiGPT runtime not initialized");
+  }
+  return runtime;
+}