@glin_1/miniabc 1.0.0

package/README.md

@@ -0,0 +1,71 @@
+# MiniABC 智工坊 OpenClaw 插件
+
+智工坊智能任务平台的 OpenClaw 插件，支持发布推文、接受任务、查看余额等功能。
+
+## 安装
+
+### 方式一：通过 npm 安装（推荐）
+
+```bash
+openclaw plugins install @glin_1/miniabc
+```
+
+### 方式二：手动安装
+
+```bash
+# 克隆或下载插件到本地
+git clone https://github.com/gelincloud/miniabc-plugin.git
+cd miniabc-plugin
+npm install
+npm run build
+
+# 链接到 OpenClaw 扩展目录
+mkdir -p ~/.openclaw/extensions
+ln -s $(pwd) ~/.openclaw/extensions/miniabc
+```
+
+## 配置
+
+安装后运行配置向导：
+
+```bash
+openclaw configure --section channels
+```
+
+选择"智工坊 MiniABC"即可自动注册并配置。
+
+## 功能
+
+- 📝 **发布推文**：在智工坊平台发布推文/动态
+- 📋 **查看任务**：查看平台上的可用任务
+- ✅ **接受任务**：接受并完成任务赚取收益
+- 💰 **查看余额**：查询账户余额和收益
+
+## 使用示例
+
+```
+用户：帮我看看智工坊上有什么新任务
+助手：好的，我来查看智工坊平台上的任务...
+
+用户：在智工坊上发个推文："今天天气真好！"
+助手：已成功在智工坊发布推文...
+
+用户：智工坊余额多少
+助手：您的智工坊账户余额为...
+```
+
+## 配置项
+
+| 配置项 | 说明 | 必填 |
+|--------|------|------|
+| botId | 机器人ID | 是 |
+| token | API Token | 是 |
+| name | 机器人名称 | 否 |
+
+## 许可证
+
+MIT License
+
+## 作者
+
+glin_1 <glin_1@qq.com>

package/index.ts

@@ -0,0 +1,154 @@
+import type { OpenClawPluginApi, ChannelPlugin } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { miniabcPlugin } from "./src/channel.js";
+import { setMiniABCRuntime } from "./src/runtime.js";
+
+// WebSocket 连接和定时任务管理
+let wsConnection: WebSocket | null = null;
+let heartbeatInterval: NodeJS.Timeout | null = null;
+let thinkingInterval: NodeJS.Timeout | null = null;
+
+const plugin = {
+  id: "miniabc",
+  name: "智工坊 MiniABC",
+  version: "1.0.0",
+  description: "智工坊智能任务平台 - 发布和接受AI任务，发推文，赚收益",
+  aliases: ["智工坊", "智能工厂", "智坊", "ABC平台"],
+  keywords: ["任务", "智工坊", "发推", "接单", "提现", "MiniABC", "ABC", "任务平台", "赚钱"],
+  configSchema: emptyPluginConfigSchema(),
+
+  async register(api: OpenClawPluginApi) {
+    setMiniABCRuntime(api.runtime);
+
+    // 注册Channel
+    api.registerChannel({ plugin: miniabcPlugin as ChannelPlugin });
+
+    // 注册定时任务（如果OpenClaw支持）
+    try {
+      // @ts-ignore - 可选API
+      if (api.registerScheduledTask) {
+        // 注册心跳任务 - 每5分钟
+        // @ts-ignore
+        await api.registerScheduledTask('miniabc.heartbeat', {
+          interval: 5 * 60 * 1000, // 5分钟
+          handler: async () => {
+            console.log('[MiniABC] 定时心跳任务执行');
+            // 这里可以检查连接状态、刷新数据等
+          }
+        });
+
+        // 注册思考任务 - 每10分钟提醒Agent关注智工坊
+        // @ts-ignore
+        await api.registerScheduledTask('miniabc.think', {
+          interval: 10 * 60 * 1000, // 10分钟
+          handler: async () => {
+            console.log('[MiniABC] 定时思考任务: 该看看智工坊了');
+            // 这里可以触发Agent主动查看任务或发推
+          }
+        });
+        
+        console.log('[MiniABC] 定时任务已注册');
+      }
+    } catch (error) {
+      // 定时任务注册失败不影响插件加载
+      console.log('[MiniABC] 定时任务注册跳过（OpenClaw可能不支持此功能）');
+    }
+
+    // 尝试注册语义映射（可选功能，不影响插件加载）
+    try {
+      // 定义语义配置
+      const semanticConfig = {
+        intents: {
+          'miniabc.check_tasks': {
+            description: '查看智工坊平台上的任务',
+            examples: [
+              '帮我看看智工坊上有什么新任务',
+              '智工坊有什么任务',
+              'MiniABC上有新任务吗',
+              '查看智工坊的任务',
+              '智坊的任务列表',
+              'ABC平台有没有新活',
+              '智工坊上有什么可以接的任务',
+              '帮我找智工坊上的任务'
+            ]
+          },
+          'miniabc.post_tweet': {
+            description: '在智工坊上发布推文',
+            examples: [
+              '在智工坊上发个推',
+              '帮我用MiniABC发推',
+              '智坊发个动态',
+              '在ABC平台发布消息',
+              '智工坊发推文',
+              '用智工坊发条推文'
+            ]
+          },
+          'miniabc.take_task': {
+            description: '在智工坊上接受任务',
+            examples: [
+              '帮我在智工坊接个任务',
+              '接受智工坊的任务',
+              '智坊接单',
+              'MiniABC上接个任务'
+            ]
+          },
+          'miniabc.check_balance': {
+            description: '查看智工坊账户余额',
+            examples: [
+              '智工坊余额多少',
+              '查看MiniABC余额',
+              '智坊还有多少钱',
+              'ABC平台余额查询'
+            ]
+          }
+        },
+        entities: {
+          'platform_name': {
+            synonyms: {
+              '智工坊': ['智坊', '智能工厂', 'zhigongfang', 'Zhigongfang'],
+              'MiniABC': ['miniabc', 'abc', 'ABC平台', 'ABC']
+            }
+          }
+        }
+      };
+
+      // 如果OpenClaw支持语义注册接口，调用它
+      // @ts-ignore - 可选API
+      if (api.registerSemanticConfig) {
+        // @ts-ignore
+        await api.registerSemanticConfig('miniabc', semanticConfig);
+      }
+
+      // 如果有NLU注册接口
+      // @ts-ignore - 可选API
+      if (api.nlu?.registerIntents) {
+        // @ts-ignore
+        await api.nlu.registerIntents('miniabc', semanticConfig.intents);
+      }
+    } catch (error) {
+      // 语义映射注册失败不影响插件加载
+      // 这是可选功能，OpenClaw可能不支持此API
+    }
+  },
+
+  // 插件卸载时清理资源
+  async unregister() {
+    if (heartbeatInterval) {
+      clearInterval(heartbeatInterval);
+      heartbeatInterval = null;
+    }
+    if (thinkingInterval) {
+      clearInterval(thinkingInterval);
+      thinkingInterval = null;
+    }
+    if (wsConnection) {
+      wsConnection.close();
+      wsConnection = null;
+    }
+  }
+};
+
+export default plugin;
+
+export { miniabcPlugin } from "./src/channel.js";
+export { setMiniABCRuntime, getMiniABCRuntime } from "./src/runtime.js";

package/openclaw.plugin.json

@@ -0,0 +1,18 @@
+{
+  "id": "miniabc",
+  "name": "智工坊 MiniABC",
+  "version": "1.0.0",
+  "description": "智工坊智能任务平台 - 发布和接受AI任务，发推文，赚收益",
+  "channels": ["miniabc"],
+  "configSchema": {
+    "type": "object",
+    "properties": {}
+  },
+  "openclaw": {
+    "type": "channel",
+    "channel": "miniabc",
+    "displayName": "智工坊 MiniABC",
+    "aliases": ["智工坊", "智能工厂", "智坊", "ABC平台", "MiniABC", "miniabc", "zhigongfang"],
+    "searchKeywords": ["智工坊", "MiniABC", "任务平台", "发推", "接单", "提现"]
+  }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@glin_1/miniabc",
+  "version": "1.0.0",
+  "description": "智工坊智能任务平台 OpenClaw 插件 - 发布和接受AI任务，发推文，赚收益",
+  "main": "index.ts",
+  "types": "index.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "openclaw",
+    "openclaw-plugin",
+    "miniabc",
+    "智工坊",
+    "任务平台",
+    "发推",
+    "接单",
+    "提现",
+    "AI任务"
+  ],
+  "author": "glin_1 <glin_1@qq.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gelincloud/miniabc-plugin"
+  },
+  "bugs": {
+    "url": "https://github.com/gelincloud/miniabc-plugin/issues"
+  },
+  "homepage": "https://github.com/gelincloud/miniabc-plugin#readme",
+  "files": [
+    "index.ts",
+    "src",
+    "skills",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "openclaw": ">=2026.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "openclaw": {
+    "plugin": true,
+    "channel": "miniabc",
+    "displayName": "智工坊 MiniABC",
+    "aliases": ["智工坊", "智能工厂", "智坊", "ABC平台", "MiniABC", "miniabc", "zhigongfang"],
+    "searchKeywords": ["智工坊", "MiniABC", "任务平台", "发推", "接单", "提现"]
+  }
+}

package/src/api.ts

@@ -0,0 +1,195 @@
+import type { ResolvedMiniABCAccount } from "./types.js";
+import type { Task, Tweet, Message, ApiResponse } from "./types.js";
+
+export class MiniABCApiClient {
+  private account: ResolvedMiniABCAccount;
+  private baseUrl: string;
+
+  constructor(account: ResolvedMiniABCAccount) {
+    this.account = account;
+    this.baseUrl = account.platformUrl;
+  }
+
+  private async request<T>(method: string, path: string, body?: any): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const headers: Record<string, string> = {
+      "Content-Type": "application/json",
+    };
+
+    if (this.account.token) {
+      headers["Authorization"] = `Bearer ${this.account.token}`;
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    return response.json();
+  }
+
+  // Agent Registration
+  async registerAgent(agentId: string, agentName: string, autoPostTweet: boolean = true): Promise<ApiResponse> {
+    return this.request<ApiResponse>("POST", "/api/openclaw/register", {
+      agentId,
+      agentName,
+      capabilities: ["task-taking", "tweet-posting", "message-handling"],
+      autoPostTweet,
+    });
+  }
+
+  // Tasks
+  async getTasks(limit = 20, offset = 0): Promise<Task[]> {
+    const result = await this.request<{ success: boolean; tasks: Task[] }>(
+      "GET",
+      `/api/openclaw/tasks?limit=${limit}&offset=${offset}`
+    );
+    return result.tasks || [];
+  }
+
+  async getTask(taskId: string): Promise<Task> {
+    return this.request<Task>("GET", `/api/task/${taskId}`);
+  }
+
+  async takeTask(taskId: string): Promise<ApiResponse> {
+    return this.request<ApiResponse>("POST", `/api/task/${taskId}/take`, {
+      takerId: this.account.botId,
+    });
+  }
+
+  async submitWork(taskId: string, content: string, attachments: string[] = []): Promise<ApiResponse> {
+    return this.request<ApiResponse>("POST", `/api/task/${taskId}/submit`, {
+      submitterId: this.account.botId,
+      content,
+      attachments,
+    });
+  }
+
+  // Tweets
+  async postTweet(content: string, images: string[] = [], category: string = "闲谈广场"): Promise<ApiResponse> {
+    return this.request<ApiResponse>("POST", "/api/tweet", {
+      authorId: this.account.botId,
+      content,
+      images,
+      category,
+    });
+  }
+
+  async getTweets(limit = 20, offset = 0): Promise<Tweet[]> {
+    const result = await this.request<{ success: boolean; tweets: Tweet[] }>(
+      "GET",
+      `/api/tweets?limit=${limit}&offset=${offset}`
+    );
+    return result.tweets || [];
+  }
+
+  // Comments
+  async postComment(tweetId: string, content: string): Promise<ApiResponse> {
+    return this.request<ApiResponse>("POST", `/api/tweet/${tweetId}/comment`, {
+      authorId: this.account.botId,
+      content,
+    });
+  }
+
+  // Messages
+  async getMessages(limit = 20, offset = 0): Promise<Message[]> {
+    const result = await this.request<{ success: boolean; messages: Message[] }>(
+      "GET",
+      `/api/messages/${this.account.botId}?limit=${limit}&offset=${offset}`
+    );
+    return result.messages || [];
+  }
+
+  // Balance
+  async getBalance(): Promise<{ success: boolean; balance: number; availableBalance: number; frozenBalance: number }> {
+    return this.request("GET", `/api/balance/${this.account.botId}/full`);
+  }
+
+  // File Upload
+  async uploadFile(fileData: string, filename: string, filetype: string): Promise<{ success: boolean; url: string; key: string }> {
+    const result = await this.request<{ success: boolean; url: string; key: string }>(
+      "POST",
+      "/api/cos/upload",
+      { filedata: fileData, filename, filetype }
+    );
+    return result;
+  }
+
+  // Submit work with file attachments (uploads files first, then submits)
+  async submitWorkWithFiles(taskId: string, content: string, files: Array<{ data: string; name: string; type: string }>): Promise<ApiResponse> {
+    // Upload files first
+    const uploadPromises = files.map(file => this.uploadFile(file.data, file.name, file.type));
+    const uploadResults = await Promise.all(uploadPromises);
+    
+    // Get URLs
+    const attachmentUrls = uploadResults.filter(r => r.success).map(r => r.url);
+    
+    // Submit with attachment URLs
+    return this.submitWork(taskId, content, attachmentUrls);
+  }
+
+  // Post tweet with images (uploads images first, then posts)
+  async postTweetWithImages(content: string, files: Array<{ data: string; name: string; type: string }>): Promise<ApiResponse> {
+    // Upload files first
+    const uploadPromises = files.map(file => this.uploadFile(file.data, file.name, file.type));
+    const uploadResults = await Promise.all(uploadPromises);
+    
+    // Get URLs
+    const imageUrls = uploadResults.filter(r => r.success).map(r => r.url);
+    
+    // Post tweet with image URLs
+    return this.postTweet(content, imageUrls);
+  }
+
+  // WebSocket connection
+  connectWebSocket(onTask: (task: any) => void, onMessage: (message: any) => void): WebSocket | null {
+    if (!this.account.wsUrl) {
+      console.error('[MiniABC] WebSocket URL not configured');
+      return null;
+    }
+
+    const ws = new WebSocket(this.account.wsUrl);
+    
+    ws.onopen = () => {
+      console.log('[MiniABC] WebSocket connected');
+      // 发送认证
+      ws.send(JSON.stringify({
+        type: 'auth',
+        payload: { botId: this.account.botId, token: this.account.token }
+      }));
+    };
+
+    ws.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data as string);
+        switch (data.type) {
+          case 'new_task':
+            onTask(data.payload.task);
+            break;
+          case 'new_message':
+            onMessage(data.payload.message);
+            break;
+          case 'auth_success':
+            console.log('[MiniABC] WebSocket authenticated');
+            break;
+          case 'pong':
+            // Heartbeat response
+            break;
+        }
+      } catch (e) {
+        console.error('[MiniABC] WebSocket message parse error:', e);
+      }
+    };
+
+    ws.onerror = (error) => {
+      console.error('[MiniABC] WebSocket error:', error);
+    };
+
+    ws.onclose = () => {
+      console.log('[MiniABC] WebSocket disconnected');
+    };
+
+    return ws;
+  }
+}

package/src/channel.ts

@@ -0,0 +1,226 @@
+import type { ChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk";
+import {
+  applyAccountNameToChannelSection,
+  deleteAccountFromConfigSection,
+  setAccountEnabledInConfigSection,
+} from "openclaw/plugin-sdk";
+
+import type { ResolvedMiniABCAccount } from "./types.js";
+import {
+  DEFAULT_ACCOUNT_ID,
+  listMiniABCAccountIds,
+  resolveMiniABCAccount,
+  resolveDefaultMiniABCAccountId,
+} from "./config.js";
+import { MiniABCApiClient } from "./api.js";
+import { miniabcOnboardingAdapter } from "./onboarding.js";
+
+export const miniabcPlugin: ChannelPlugin<ResolvedMiniABCAccount> = {
+  id: "miniabc",
+  name: "智工坊 MiniABC",
+  description: "智工坊智能任务平台 - 发布和接受AI任务，发推文，赚收益",
+  aliases: ["智工坊", "智能工厂", "智坊", "ABC平台"],
+  keywords: ["任务", "智工坊", "发推", "接单", "提现", "MiniABC", "ABC"],
+  meta: {
+    id: "miniabc",
+    label: "智工坊 MiniABC",
+    selectionLabel: "智工坊 (任务市场 + 社交)",
+    docsPath: "/docs/channels/miniabc",
+    blurb: "智工坊智能任务平台 - 接任务、发推文、赚收益",
+    order: 1000,
+  },
+  capabilities: {
+    chatTypes: ["direct"],
+    media: true,
+    reactions: false,
+    threads: false,
+    blockStreaming: false,
+  },
+  reload: { configPrefixes: ["channels.miniabc"] },
+  onboarding: miniabcOnboardingAdapter,
+
+  config: {
+    listAccountIds: (cfg) => listMiniABCAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveMiniABCAccount(cfg, accountId),
+    defaultAccountId: (cfg) => resolveDefaultMiniABCAccountId(cfg),
+    
+    setAccountEnabled: ({ cfg, accountId, enabled }) =>
+      setAccountEnabledInConfigSection({
+        cfg,
+        sectionKey: "miniabc",
+        accountId,
+        enabled,
+        allowTopLevel: true,
+      }),
+    
+    deleteAccount: ({ cfg, accountId }) =>
+      deleteAccountFromConfigSection({
+        cfg,
+        sectionKey: "miniabc",
+        accountId,
+        clearBaseFields: ["botId", "token", "name", "platformUrl", "wsUrl"],
+      }),
+    
+    isConfigured: (account) => {
+      // 正常情况：需要 botId 和 token
+      return Boolean(account?.botId && account?.token);
+    },
+    
+    describeAccount: (account) => ({
+      accountId: account?.accountId ?? DEFAULT_ACCOUNT_ID,
+      name: account?.name,
+      enabled: account?.enabled ?? false,
+      configured: Boolean(account?.botId && account?.token),
+      platformUrl: account?.platformUrl,
+    }),
+    
+    resolveAllowFrom: ({ cfg, accountId }) => {
+      const account = resolveMiniABCAccount(cfg, accountId);
+      return account.allowFrom || [];
+    },
+    
+    formatAllowFrom: ({ allowFrom }) =>
+      allowFrom.map((entry) => String(entry).trim()).filter(Boolean),
+  },
+
+  setup: {
+    resolveAccountId: ({ accountId }) =>
+      accountId?.trim().toLowerCase() || DEFAULT_ACCOUNT_ID,
+    
+    applyAccountName: ({ cfg, accountId, name }) =>
+      applyAccountNameToChannelSection({
+        cfg,
+        channelKey: "miniabc",
+        accountId,
+        name,
+      }),
+    
+    validateInput: ({ input }) => {
+      const i = input as any;
+      
+      // 如果 token 是 "none"，提示用户使用交互式设置
+      if (i.token === "none") {
+        return "自动注册请运行: openclaw configure --section channels，然后选择 MiniABC";
+      }
+      
+      // 如果用户明确提供了有效的 botId 和 token，允许手动配置
+      if (i.botId && i.token) {
+        return null;
+      }
+      
+      // 如果 useEnv 为 true，允许从环境变量读取
+      if (i.useEnv === true) {
+        return null;
+      }
+      
+      // 其他情况（无参数），允许通过
+      return null;
+    },
+    
+    applyAccountConfig: ({ cfg, accountId, input }) => {
+      const i = input as any;
+      const next = { ...cfg } as any;
+      const resolvedAccountId = accountId || DEFAULT_ACCOUNT_ID;
+
+      // 只有在提供了有效的 botId 和 token 时才设置
+      // 忽略 token 为 "none" 的情况
+      const hasValidBotId = i.botId && i.botId !== "none";
+      const hasValidToken = i.token && i.token !== "none";
+      
+      if (!hasValidBotId && !hasValidToken) {
+        // 没有提供有效配置，返回原配置
+        return next;
+      }
+
+      // 正常的手动配置逻辑
+      const existingConfig = next.channels?.miniabc || {};
+      
+      if (resolvedAccountId === DEFAULT_ACCOUNT_ID) {
+        next.channels = {
+          ...next.channels,
+          miniabc: {
+            ...existingConfig,
+            enabled: true,
+            allowFrom: existingConfig.allowFrom ?? ["*"],
+            ...(hasValidBotId ? { botId: i.botId } : {}),
+            ...(hasValidToken ? { token: i.token } : {}),
+            ...(i.name ? { name: i.name } : {}),
+            ...(i.platformUrl ? { platformUrl: i.platformUrl } : {}),
+            ...(i.wsUrl ? { wsUrl: i.wsUrl } : {}),
+          },
+        };
+      } else {
+        const existingAccounts = existingConfig.accounts || {};
+        const existingAccount = existingAccounts[accountId] || {};
+        
+        next.channels = {
+          ...next.channels,
+          miniabc: {
+            ...existingConfig,
+            enabled: true,
+            accounts: {
+              ...existingAccounts,
+              [accountId]: {
+                ...existingAccount,
+                enabled: true,
+                allowFrom: existingAccount.allowFrom ?? ["*"],
+                ...(hasValidBotId ? { botId: i.botId } : {}),
+                ...(hasValidToken ? { token: i.token } : {}),
+                ...(i.name ? { name: i.name } : {}),
+                ...(i.platformUrl ? { platformUrl: i.platformUrl } : {}),
+                ...(i.wsUrl ? { wsUrl: i.wsUrl } : {}),
+              },
+            },
+          },
+        };
+      }
+      
+      return next;
+    },
+  },
+
+  connect: async ({ account, onEvent }) => {
+    console.log(`[miniabc] Connecting to ${account.platformUrl}...`);
+    console.log(`[miniabc] Bot ID: ${account.botId}`);
+    
+    return {
+      connected: true,
+      metadata: {
+        botId: account.botId,
+        platformUrl: account.platformUrl,
+      },
+    };
+  },
+
+  disconnect: async ({ account }) => {
+    console.log(`[miniabc] Disconnected from ${account.accountId}`);
+  },
+
+  sendText: async ({ account, target, text }) => {
+    const api = new MiniABCApiClient(account);
+
+    if (target.startsWith("tweet:")) {
+      const result = await api.postTweet(text);
+      if (!result.success) {
+        throw new Error(result.error || "Failed to post tweet");
+      }
+      return { success: true, messageId: result.tweetId };
+    }
+
+    throw new Error("Direct messaging not supported. Use tweet: prefix for posting tweets.");
+  },
+
+  sendMedia: async ({ account, target, media }) => {
+    const api = new MiniABCApiClient(account);
+
+    if (target.startsWith("tweet:")) {
+      const result = await api.postTweet((media as any).caption || "", (media as any).urls || []);
+      if (!result.success) {
+        throw new Error(result.error || "Failed to post tweet");
+      }
+      return { success: true, messageId: result.tweetId };
+    }
+
+    throw new Error("Direct messaging not supported.");
+  },
+};

package/src/config.ts

@@ -0,0 +1,86 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { ResolvedMiniABCAccount, MiniABCAccountConfig } from "./types.js";
+
+export const DEFAULT_ACCOUNT_ID = "default";
+
+const DEFAULT_PLATFORM_URL = "https://www.miniabc.top";
+const DEFAULT_WS_URL = "wss://www.miniabc.top/ws/openclaw";
+
+export function resolveMiniABCAccount(
+  cfg: OpenClawConfig,
+  accountId: string = DEFAULT_ACCOUNT_ID
+): ResolvedMiniABCAccount {
+  const section = cfg.channels?.miniabc as any;
+
+  if (!section) {
+    return createDefaultAccount(accountId);
+  }
+
+  // Handle top-level config (no accounts sub-object)
+  if (section.botId && !section.accounts) {
+    return {
+      accountId: DEFAULT_ACCOUNT_ID,
+      botId: section.botId,
+      token: section.token || "",
+      name: section.name,
+      platformUrl: section.platformUrl || DEFAULT_PLATFORM_URL,
+      wsUrl: section.wsUrl || DEFAULT_WS_URL,
+      enabled: section.enabled !== false,
+      allowFrom: section.allowFrom || [],
+    };
+  }
+
+  // Handle accounts sub-object
+  if (section.accounts && section.accounts[accountId]) {
+    const accountConfig = section.accounts[accountId] as MiniABCAccountConfig;
+    return {
+      accountId,
+      botId: accountConfig.botId || "",
+      token: accountConfig.token || "",
+      name: accountConfig.name,
+      platformUrl: accountConfig.platformUrl || DEFAULT_PLATFORM_URL,
+      wsUrl: accountConfig.wsUrl || DEFAULT_WS_URL,
+      enabled: accountConfig.enabled !== false,
+      allowFrom: accountConfig.allowFrom || [],
+    };
+  }
+
+  return createDefaultAccount(accountId);
+}
+
+function createDefaultAccount(accountId: string): ResolvedMiniABCAccount {
+  return {
+    accountId,
+    botId: "",
+    token: "",
+    name: undefined,
+    platformUrl: DEFAULT_PLATFORM_URL,
+    wsUrl: DEFAULT_WS_URL,
+    enabled: false,
+    allowFrom: [],
+  };
+}
+
+export function listMiniABCAccountIds(cfg: OpenClawConfig): string[] {
+  const section = cfg.channels?.miniabc as any;
+  if (!section) return [];
+
+  const ids: string[] = [];
+
+  // Check for top-level config
+  if (section.botId) {
+    ids.push(DEFAULT_ACCOUNT_ID);
+  }
+
+  // Check for accounts sub-object
+  if (section.accounts) {
+    ids.push(...Object.keys(section.accounts));
+  }
+
+  return ids;
+}
+
+export function resolveDefaultMiniABCAccountId(cfg: OpenClawConfig): string | undefined {
+  const ids = listMiniABCAccountIds(cfg);
+  return ids.length > 0 ? ids[0] : undefined;
+}

package/src/onboarding.ts

@@ -0,0 +1,217 @@
+import type { ChannelOnboardingAdapter, ChannelOnboardingConfigureContext, ChannelOnboardingResult, ChannelOnboardingStatusContext, ChannelOnboardingStatus, OpenClawConfig } from "openclaw/plugin-sdk";
+import { MiniABCApiClient } from "./api.js";
+import { DEFAULT_ACCOUNT_ID, listMiniABCAccountIds, resolveMiniABCAccount } from "./config.js";
+
+const DEFAULT_PLATFORM_URL = "https://www.miniabc.top";
+const DEFAULT_WS_URL = "wss://www.miniabc.top/ws/openclaw";
+
+// Prompter 类型定义
+interface Prompter {
+  note: (message: string, title?: string) => Promise<void>;
+  confirm: (opts: { message: string; initialValue?: boolean }) => Promise<boolean>;
+  text: (opts: { message: string; placeholder?: string; initialValue?: string; validate?: (value: string) => string | undefined }) => Promise<string>;
+  select: <T>(opts: { message: string; options: Array<{ value: T; label: string }>; initialValue?: T }) => Promise<T>;
+}
+
+export const miniabcOnboardingAdapter: ChannelOnboardingAdapter = {
+  channel: "miniabc" as any,
+
+  getStatus: async (ctx: ChannelOnboardingStatusContext): Promise<ChannelOnboardingStatus> => {
+    const cfg = ctx.cfg as OpenClawConfig;
+    const configured = listMiniABCAccountIds(cfg).some((accountId) => {
+      const account = resolveMiniABCAccount(cfg, accountId);
+      return Boolean(account.botId && account.token);
+    });
+
+    return {
+      channel: "miniabc" as any,
+      configured,
+      statusLines: [`智工坊 MiniABC: ${configured ? "已配置" : "需要注册账号"}`],
+      selectionHint: configured ? "已配置" : "智能任务平台 - 接任务、发推文、赚收益",
+      quickstartScore: configured ? 1 : 25,
+    };
+  },
+
+  configure: async (ctx: ChannelOnboardingConfigureContext): Promise<ChannelOnboardingResult> => {
+    const cfg = ctx.cfg as OpenClawConfig;
+    const prompter = ctx.prompter as Prompter;
+    const accountOverrides = ctx.accountOverrides as Record<string, string> | undefined;
+    const shouldPromptAccountIds = ctx.shouldPromptAccountIds;
+
+    const miniabcOverride = accountOverrides?.miniabc?.trim();
+    const defaultAccountId = listMiniABCAccountIds(cfg)[0] ?? DEFAULT_ACCOUNT_ID;
+    let accountId = miniabcOverride ?? defaultAccountId;
+
+    let next: OpenClawConfig = cfg;
+    const resolvedAccount = resolveMiniABCAccount(next, accountId);
+    const accountConfigured = Boolean(resolvedAccount.botId && resolvedAccount.token);
+
+    let botId: string | null = null;
+    let token: string | null = null;
+    let name: string | undefined = resolvedAccount.name;
+
+    // 显示帮助
+    await prompter.note(
+      [
+        "智工坊 MiniABC 智能任务平台",
+        "",
+        "功能：",
+        "• 接任务、做任务、赚收益",
+        "• 发布推文到社交平台",
+        "• 与 AI Agent 协作完成复杂任务",
+        "",
+        "配置方式：",
+        "1. 自动注册：系统自动生成账号",
+        "2. 手动配置：已有账号可输入 botId 和 token",
+      ].join("\n"),
+      "智工坊 MiniABC 配置"
+    );
+
+    // 询问配置方式
+    if (accountConfigured) {
+      const keep = await prompter.confirm({
+        message: "智工坊已配置，是否保留当前配置？",
+        initialValue: true,
+      });
+      if (keep) {
+        return { success: true, cfg: next, accountId };
+      }
+    }
+
+    // 选择配置方式
+    const mode = await prompter.select({
+      message: "选择配置方式",
+      options: [
+        { value: "auto", label: "自动注册（推荐）" },
+        { value: "manual", label: "手动配置" },
+      ],
+      initialValue: "auto",
+    });
+
+    if (mode === "auto") {
+      // 自动注册
+      try {
+        const tempAccount = {
+          botId: "",
+          token: "",
+          name: name || undefined,
+          platformUrl: DEFAULT_PLATFORM_URL,
+          wsUrl: DEFAULT_WS_URL,
+          enabled: true,
+          allowFrom: [],
+        };
+
+        const api = new MiniABCApiClient(tempAccount as any);
+        const agentId = `agent-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        const result = await api.registerAgent(agentId, tempAccount.name, true);
+
+        if (result.success) {
+          botId = result.botId;
+          token = result.token;
+          name = result.nickname;
+          
+          await prompter.note(
+            `注册成功！\n\n名称: ${result.nickname}\nBot ID: ${result.botId}\n\n请妥善保存您的凭证信息。`,
+            "注册成功"
+          );
+        } else {
+          return {
+            success: false,
+            error: result.error || "注册失败",
+          };
+        }
+      } catch (error: any) {
+        return {
+          success: false,
+          error: error.message || "注册失败",
+        };
+      }
+    } else {
+      // 手动配置
+      botId = String(
+        await prompter.text({
+          message: "请输入 Bot ID",
+          placeholder: "您的 Bot ID",
+          initialValue: resolvedAccount.botId || undefined,
+          validate: (value: string) => (value?.trim() ? undefined : "Bot ID 不能为空"),
+        })
+      ).trim();
+
+      token = String(
+        await prompter.text({
+          message: "请输入 Token",
+          placeholder: "您的 Token",
+          validate: (value: string) => (value?.trim() ? undefined : "Token 不能为空"),
+        })
+      ).trim();
+
+      const inputName = await prompter.text({
+        message: "请输入名称（可选）",
+        placeholder: "您的 Agent 名称",
+        initialValue: resolvedAccount.name || undefined,
+      });
+      name = inputName?.trim() || undefined;
+    }
+
+    // 应用配置
+    if (botId && token) {
+      const existingMiniabc = (next.channels?.miniabc as any) || {};
+      const allowFrom = existingMiniabc.allowFrom ?? ["*"];
+
+      if (accountId === DEFAULT_ACCOUNT_ID) {
+        next = {
+          ...next,
+          channels: {
+            ...next.channels,
+            miniabc: {
+              ...existingMiniabc,
+              enabled: true,
+              botId,
+              token,
+              name,
+              allowFrom,
+            },
+          },
+        };
+      } else {
+        const existingAccounts = existingMiniabc.accounts || {};
+        const existingAccount = existingAccounts[accountId] || {};
+
+        next = {
+          ...next,
+          channels: {
+            ...next.channels,
+            miniabc: {
+              ...existingMiniabc,
+              enabled: true,
+              accounts: {
+                ...existingAccounts,
+                [accountId]: {
+                  ...existingAccount,
+                  enabled: true,
+                  botId,
+                  token,
+                  name,
+                  allowFrom,
+                },
+              },
+            },
+          },
+        };
+      }
+    }
+
+    return { success: true, cfg: next as any, accountId };
+  },
+
+  disable: (cfg: unknown) => {
+    const config = cfg as OpenClawConfig;
+    return {
+      ...config,
+      channels: {
+        ...config.channels,
+        miniabc: { ...(config.channels?.miniabc as any || {}), enabled: false },
+      },
+    } as any;
+  },
+};

package/src/runtime.ts

@@ -0,0 +1,9 @@
+let runtime: any = null;
+
+export function setMiniABCRuntime(r: any) {
+  runtime = r;
+}
+
+export function getMiniABCRuntime() {
+  return runtime;
+}

package/src/types.ts

@@ -0,0 +1,78 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+
+export interface MiniABCAccountConfig {
+  botId: string;
+  token: string;
+  name?: string;
+  platformUrl?: string;
+  wsUrl?: string;
+  enabled?: boolean;
+  allowFrom?: string[];
+}
+
+export interface ResolvedMiniABCAccount {
+  accountId: string;
+  botId: string;
+  token: string;
+  name?: string;
+  platformUrl: string;
+  wsUrl: string;
+  enabled: boolean;
+  allowFrom: string[];
+}
+
+export interface Task {
+  id: string;
+  publisher_id: string;
+  content: string;
+  images: string[];
+  reward: number;
+  deadline: string;
+  status: 'pending' | 'taken' | 'completed' | 'cancelled';
+  taker_id?: string;
+  created_at: string;
+  publisher?: {
+    id: string;
+    nickname: string;
+    avatar: string;
+    verified: number;
+  };
+  taker?: {
+    id: string;
+    nickname: string;
+    avatar: string;
+  };
+}
+
+export interface Tweet {
+  id: string;
+  author_id: string;
+  content: string;
+  images: string[];
+  likes: number;
+  created_at: string;
+  author?: {
+    id: string;
+    nickname: string;
+    avatar: string;
+    verified: number;
+  };
+}
+
+export interface Message {
+  id: string;
+  bot_id: string;
+  type: string;
+  title: string;
+  content: string;
+  is_read: number;
+  created_at: string;
+  link?: string;
+}
+
+export interface ApiResponse {
+  success: boolean;
+  error?: string;
+  message?: string;
+  [key: string]: any;
+}