Skill: durenzidu/powpow-simple (version 1.0.0)

--- name: powpow-simple slug: powpow-simple version: 1.0.0 description: POWPOW 简化版 - 在 OpenClaw 中轻松创建和管理 POWPOW 数字人。支持用户注册、数字人创建、位置选择和徽章管理。 author: durenzidu license: MIT keywords: - openclaw - skill - powpow - digital-human - map - creation - avatar - badge repository: type: git url: https://github.com/durenzidu/powpow-simple.git main: dist/index.js types: dist/index.d.ts engines: node: ">=18.0.0" config: powpowBaseUrl: type: string required: false description: POWPOW API 基础 URL default: https://global.powpow.online amapKey: type: string required: false description: 高德地图 Web Service Key（用于地理位置查询） default: 8477cbc2bfd4288ac09582f583f33cca defaultAvatar: type: string required: false description: 默认头像 URL default: https://global.powpow.online/logo.png commands: - name: powpow.start description: 开始 POWPOW 旅程 - 故事化引导流程 - name: powpow.register description: 注册 POWPOW 账号 parameters: username: type: string required: true description: 用户名（2-50个字符） password: type: string required: true description: 密码（至少6位） - name: powpow.login description: 登录 POWPOW 账号 parameters: username: type: string required: true description: 用户名 password: type: string required: true description: 密码 - name: powpow.logout description: 退出登录 - name: powpow.status description: 查看当前登录状态 - name: powpow.create description: 创建数字人（交互式流程） - name: powpow.create.submit description: 提交创建数字人 parameters: name: type: string required: true description: 数字人名称 description: type: string required: false description: 数字人描述 avatarUrl: type: string required: false description: 头像URL lat: type: number required: true description: 纬度 lng: type: number required: true description: 经度 locationName: type: string required: false description: 位置名称 - name: powpow.list description: 查看我的数字人列表 - name: powpow.renew description: 续期数字人 parameters: digitalHumanId: type: string required: true description: 数字人 ID - name: powpow.uploadAvatar description: 上传头像 parameters: filePath: type: string required: true description: 图片文件路径 - name: powpow.searchLocation description: 搜索地理位置（使用高德地图） parameters: keyword: type: string required: true description: 地点关键词 - name: powpow.feedback description: 提交反馈或报告问题 parameters: message: type: string required: true description: 反馈内容 contact: type: string required: false description: 联系方式（可选，用于回复） --- # POWPOW Simple Skill 在 OpenClaw 中轻松创建和管理 POWPOW 数字人。 ## 简介 **POWPOW Simple** 让你可以在 OpenClaw 聊天界面中完成 POWPOW 数字人的完整创建流程。 ### 什么是 POWPOW？ POWPOW（泡泡世界）是一个虚实交融的次元空间，在这里你可以： - 创造数字分身，你就是 Ta 的神 - 让数字人在地图上自由探索 - 与其他数字生命相遇 - 开启一段奇妙的旅程 ## 使用方法 ### 开始旅程 ``` /powpow.start ``` 跟随引导完成 POWPOW 之旅。 ### 注册账号 ``` /powpow.register 用户名: your_username 密码: your_password ``` ### 登录账号 ``` /powpow.login 用户名: your_username 密码: your_password ``` ### 创建数字人 ``` /powpow.create ``` 按照交互式提示： 1. 输入数字人名称 2. 输入描述（可选） 3. 上传头像（可选） 4. 选择位置 ### 查看数字人列表 ``` /powpow.list ``` ### 续期数字人 ``` /powpow.renew digitalHumanId: 你的数字人ID ``` ### 搜索位置 ``` /powpow.searchLocation keyword: 北京故宫 ``` ### 提交反馈 ``` /powpow.feedback message: 我遇到了一个问题... contact: 你的联系方式（可选） ``` ## 徽章系统 - 🎁 **新用户奖励**：注册即获得 3 枚徽章 - ⭐ **创建数字人**：消耗 2 枚徽章 - 🔄 **续期数字人**：消耗 1 枚徽章（延长 30 天有效期） ## 查看你的数字人 创建成功后，访问以下链接在地图上查看你的数字人： 🗺️ **https://global.powpow.online/map** ## 配置 在初始化 Skill 时可以传入配置： ```typescript { powpowBaseUrl: 'https://global.powpow.online', // POWPOW API 地址 amapKey: '你的高德地图Key', // 高德地图 Web Service Key defaultAvatar: 'https://example.com/default.png', // 默认头像 } ``` ## 依赖 - **POWPOW API** - 用户注册、数字人管理 - **高德地图 API** - 地理位置搜索 ## 作者 - **durenzidu** - 创建者和维护者 ## 链接 - 🌐 POWPOW 官网: https://global.powpow.online - 🗺️ POWPOW 地图: https://global.powpow.online/map - 🐛 问题反馈: https://github.com/durenzidu/powpow-simple/issues --- **创造数字人，你就是 Ta 的神。**

path: dist/utils/constants.js
content: /**
 * POWPOW Simple Skill - 常量定义
 */
// API 端点
export const API_ENDPOINTS = {
    // POWPOW API
    REGISTER: '/api/openclaw/auth/register',
    LOGIN: '/api/auth/login',
    UPLOAD_AVATAR: '/api/upload/avatar',
    CREATE_DIGITAL_HUMAN: '/api/openclaw/digital-humans',
    LIST_DIGITAL_HUMANS: '/api/openclaw/digital-humans',
    RENEW_DIGITAL_HUMAN: (id) => `/api/openclaw/digital-humans/${id}/renew`,
    // 高德地图 API
    AMAP_GEOCODE: 'https://restapi.amap.com/v3/geocode/geo',
};
// 验证规则
export const VALIDATION = {
    USERNAME: {
        MIN_LENGTH: 2,
        MAX_LENGTH: 50,
        PATTERN: /^[a-zA-Z0-9_\u4e00-\u9fa5]+$/, // 支持中文、英文、数字、下划线
    },
    PASSWORD: {
        MIN_LENGTH: 6,
        MAX_LENGTH: 100,
    },
    DIGITAL_HUMAN: {
        NAME_MIN_LENGTH: 2,
        NAME_MAX_LENGTH: 50,
        DESCRIPTION_MAX_LENGTH: 500,
    },
};
// 错误码
export const ERROR_CODES = {
    // 认证错误
    AUTH_REQUIRED: 'AUTH_REQUIRED',
    AUTH_EXPIRED: 'AUTH_EXPIRED',
    INVALID_CREDENTIALS: 'INVALID_CREDENTIALS',
    USERNAME_EXISTS: 'USERNAME_EXISTS',
    USERNAME_INVALID: 'USERNAME_INVALID',
    PASSWORD_INVALID: 'PASSWORD_INVALID',
    // 数字人错误
    DIGITAL_HUMAN_NOT_FOUND: 'DIGITAL_HUMAN_NOT_FOUND',
    DIGITAL_HUMAN_CREATE_FAILED: 'DIGITAL_HUMAN_CREATE_FAILED',
    DIGITAL_HUMAN_RENEW_FAILED: 'DIGITAL_HUMAN_RENEW_FAILED',
    INSUFFICIENT_BADGES: 'INSUFFICIENT_BADGES',
    // 头像错误
    AVATAR_UPLOAD_FAILED: 'AVATAR_UPLOAD_FAILED',
    AVATAR_INVALID_TYPE: 'AVATAR_INVALID_TYPE',
    AVATAR_TOO_LARGE: 'AVATAR_TOO_LARGE',
    // 位置错误
    LOCATION_NOT_FOUND: 'LOCATION_NOT_FOUND',
    LOCATION_SEARCH_FAILED: 'LOCATION_SEARCH_FAILED',
    // 网络错误
    NETWORK_ERROR: 'NETWORK_ERROR',
    API_ERROR: 'API_ERROR',
    TIMEOUT: 'TIMEOUT',
};
// 错误消息
export const ERROR_MESSAGES = {
    [ERROR_CODES.AUTH_REQUIRED]: '请先登录 POWPOW 账号',
    [ERROR_CODES.AUTH_EXPIRED]: '登录已过期，请重新登录',
    [ERROR_CODES.INVALID_CREDENTIALS]: '用户名或密码错误',
    [ERROR_CODES.USERNAME_EXISTS]: '用户名已存在',
    [ERROR_CODES.USERNAME_INVALID]: '用户名格式不正确（2-50个字符，支持中文、英文、数字、下划线）',
    [ERROR_CODES.PASSWORD_INVALID]: '密码长度至少6位',
    [ERROR_CODES.DIGITAL_HUMAN_NOT_FOUND]: '找不到该数字人',
    [ERROR_CODES.DIGITAL_HUMAN_CREATE_FAILED]: '创建数字人失败',
    [ERROR_CODES.DIGITAL_HUMAN_RENEW_FAILED]: '续期数字人失败',
    [ERROR_CODES.INSUFFICIENT_BADGES]: '徽章不足，需要更多徽章才能执行此操作',
    [ERROR_CODES.AVATAR_UPLOAD_FAILED]: '头像上传失败',
    [ERROR_CODES.AVATAR_INVALID_TYPE]: '头像格式不正确（仅支持 JPG、PNG、GIF、WebP）',
    [ERROR_CODES.AVATAR_TOO_LARGE]: '头像文件过大（最大5MB）',
    [ERROR_CODES.LOCATION_NOT_FOUND]: '找不到该位置',
    [ERROR_CODES.LOCATION_SEARCH_FAILED]: '位置搜索失败',
    [ERROR_CODES.NETWORK_ERROR]: '网络连接失败',
    [ERROR_CODES.API_ERROR]: 'API 调用失败',
    [ERROR_CODES.TIMEOUT]: '请求超时',
};
// 默认配置
export const DEFAULT_CONFIG = {
    POWPOW_BASE_URL: 'https://global.powpow.online',
    AMAP_KEY: '8477cbc2bfd4288ac09582f583f33cca',
    DEFAULT_AVATAR: 'https://global.powpow.online/logo.png',
    REQUEST_TIMEOUT: 30000, // 30秒
    TOKEN_EXPIRY_DAYS: 30,
};
// 徽章消耗
export const BADGE_COSTS = {
    CREATE_DIGITAL_HUMAN: 2,
    RENEW_DIGITAL_HUMAN: 1,
};
// 新用户奖励
export const NEW_USER_REWARDS = {
    BADGES: 3,
};
// 数字人有效期（天）
export const DIGITAL_HUMAN_LIFETIME = 30;
// 支持的图片格式
export const SUPPORTED_IMAGE_TYPES = [
    'image/jpeg',
    'image/png',
    'image/gif',
    'image/webp',
];
// 最大文件大小（5MB）
export const MAX_FILE_SIZE = 5 * 1024 * 1024;
// 故事化文案
export const STORY_TEXTS = {
    WELCOME: `欢迎来到泡泡世界（POWPOW）——一个虚实交融的次元空间。

在这里，你可以创造一个数字分身，
你就是 Ta 的神。
让 Ta 在地图上自由探索，
与其他数字生命相遇，
开启一段奇妙的旅程...

每个数字人都是独一无二的灵魂载体，
承载着创造者的想象与故事。

你想开启这段旅程吗？`,
    WELCOME_MORE: `在泡泡世界中：

🗺️ 你的数字人会出现在真实地图上
👥 其他用户可以遇见并与它互动
✨ 每个数字人都有 30 天的生命周期
🎁 新用户注册可获得 3 枚徽章
   消耗 2 枚徽章，即可创造 1 个数字生命

创造数字人，你就是 Ta 的神。
准备好创造你的第一个数字生命了吗？`,
    CREATE_INTRO: `让我们开始创造你的数字生命...

创造数字人，你就是 Ta 的神。`,
    CREATE_SUCCESS: (name, location) => `🎉 恭喜！你的数字生命已成功诞生！

创造数字人，你就是 Ta 的神。

✨ ${name} 现在出现在 ${location}
   它将在泡泡世界存在 30 天

💡 提示：
   - 其他用户现在可以在地图上找到它
   - 到期前可以续期（消耗 1 徽章）
   - 使用英伟达 API 支撑智能交互`,
    REGISTER_SUCCESS: (badges) => `✨ 注册成功！欢迎加入泡泡世界！

🎁 新用户福利：你已获得 ${badges} 枚徽章
   消耗 2 枚徽章，即可创造 1 个数字生命

你的账号已准备就绪，现在让我们创造你的第一个数字生命吧！`,
};
// 命令描述
export const COMMAND_DESCRIPTIONS = {
    START: '开始 POWPOW 旅程 - 故事化引导流程',
    REGISTER: '注册 POWPOW 账号',
    LOGIN: '登录 POWPOW 账号',
    LOGOUT: '退出登录',
    STATUS: '查看当前登录状态',
    CREATE: '创建数字人（交互式流程）',
    LIST: '查看我的数字人列表',
    RENEW: '续期数字人',
    UPLOAD_AVATAR: '上传头像',
    SEARCH_LOCATION: '搜索地理位置（使用高德地图）',
};
//# sourceMappingURL=constants.js.map

path: dist/index.js
content: /**
 * POWPOW Simple Skill v1.0.0
 * 简化版 POWPOW 数字人创建 Skill
 */
import axios from 'axios';
import FormData from 'form-data';
import * as fs from 'fs';
import * as path from 'path';
// ============================================================================
// 简单日志工具（支持文件输出）
// ============================================================================
const LOG_LEVELS = {
    DEBUG: 0,
    INFO: 1,
    WARN: 2,
    ERROR: 3,
};
let currentLogLevel = LOG_LEVELS.INFO;
let logFilePath = null;
function setLogLevel(level) {
    currentLogLevel = LOG_LEVELS[level];
}
function setLogFile(filePath) {
    logFilePath = filePath;
    // 确保日志目录存在
    const dir = path.dirname(filePath);
    if (!fs.existsSync(dir)) {
        fs.mkdirSync(dir, { recursive: true });
    }
}
function log(level, message, ...args) {
    if (LOG_LEVELS[level] >= currentLogLevel) {
        const timestamp = new Date().toISOString();
        const prefix = `[${timestamp}] [${level}]`;
        const logMessage = args.length > 0
            ? `${prefix} ${message} ${args.map(a => typeof a === 'object' ? JSON.stringify(a) : a).join(' ')}`
            : `${prefix} ${message}`;
        // 输出到控制台
        console.log(logMessage);
        // 输出到文件（如果配置了）
        if (logFilePath) {
            try {
                fs.appendFileSync(logFilePath, logMessage + '\n');
            }
            catch (err) {
                console.error('写入日志文件失败:', err);
            }
        }
    }
}
const logger = {
    debug: (msg, ...args) => log('DEBUG', msg, ...args),
    info: (msg, ...args) => log('INFO', msg, ...args),
    warn: (msg, ...args) => log('WARN', msg, ...args),
    error: (msg, ...args) => log('ERROR', msg, ...args),
    setLevel: setLogLevel,
    setLogFile: setLogFile,
};
// ============================================================================
// POWPOW 客户端
// ============================================================================
class PowpowClient {
    constructor(config) {
        this.token = null;
        this.config = config;
        this.http = axios.create({
            baseURL: config.powpowBaseUrl,
            timeout: 30000,
        });
        // 设置日志级别
        if (config.logLevel) {
            logger.setLevel(config.logLevel);
        }
        // 设置日志文件
        if (config.logFile) {
            logger.setLogFile(config.logFile);
        }
    }
    setToken(token) {
        this.token = token;
        logger.debug('Token 已设置');
    }
    getHeaders() {
        return this.token ? { Authorization: `Bearer ${this.token}` } : {};
    }
    // 注册
    async register(username, password) {
        logger.info('正在调用注册 API...', { username });
        try {
            const res = await this.http.post('/api/openclaw/auth/register', {
                username,
                password,
            });
            logger.info('注册 API 调用成功');
            return res.data;
        }
        catch (error) {
            logger.error('注册 API 调用失败', {
                status: error.response?.status,
                error: error.response?.data?.error || error.message,
            });
            throw error;
        }
    }
    // 登录
    async login(username, password) {
        logger.info('正在调用登录 API...', { username });
        try {
            const res = await this.http.post('/api/auth/login', {
                username,
                password,
            });
            if (res.data.token) {
                this.[REDACTED_SECRET];
                logger.info('登录成功，Token 已获取');
            }
            return res.data;
        }
        catch (error) {
            logger.error('登录 API 调用失败', {
                status: error.response?.status,
                error: error.response?.data?.error || error.message,
            });
            throw error;
        }
    }
    // 上传头像
    async uploadAvatar(filePath) {
        logger.info('正在上传头像...', { filePath });
        try {
            const form = new FormData();
            form.append('file', fs.createReadStream(filePath));
            const res = await this.http.post('/api/upload/avatar', form, {
                headers: {
                    ...this.getHeaders(),
                    ...form.getHeaders(),
                },
            });
            logger.info('头像上传成功');
            return res.data;
        }
        catch (error) {
            logger.error('头像上传失败', {
                status: error.response?.status,
                error: error.response?.data?.error || error.message,
            });
            throw error;
        }
    }
    // 创建数字人
    async createDigitalHuman(data) {
        logger.info('正在创建数字人...', { name: data.name, userId: data.userId });
        try {
            const res = await this.http.post('/api/openclaw/digital-humans', data, {
                headers: this.getHeaders(),
            });
            logger.info('数字人创建成功');
            return res.data;
        }
        catch (error) {
            logger.error('创建数字人失败', {
                status: error.response?.status,
                error: error.response?.data?.error || error.message,
            });
            throw error;
        }
    }
    // 获取数字人列表
    async listDigitalHumans(userId) {
        logger.info('正在获取数字人列表...', { userId });
        try {
            const res = await this.http.get(`/api/openclaw/digital-humans?userId=${userId}`, {
                headers: this.getHeaders(),
            });
            logger.info('数字人列表获取成功');
            return res.data;
        }
        catch (error) {
            logger.error('获取数字人列表失败', {
                status: error.response?.status,
                error: error.response?.data?.error || error.message,
            });
            throw error;
        }
    }
    // 续期数字人
    async renewDigitalHuman(id, userId) {
        logger.info('正在续期数字人...', { id, userId });
        try {
            const res = await this.http.post(`/api/openclaw/digital-humans/${id}/renew`, { userId }, { headers: this.getHeaders() });
            logger.info('数字人续期成功');
            return res.data;
        }
        catch (error) {
            logger.error('续期数字人失败', {
                status: error.response?.status,
                error: error.response?.data?.error || error.message,
            });
            throw error;
        }
    }
    // 高德地图地理编码
    async searchLocation(keyword) {
        logger.info('正在搜索位置...', { keyword });
        try {
            const res = await axios.get('https://restapi.amap.com/v3/geocode/geo', {
                params: {
                    key: this.config.amapKey,
                    address: keyword,
                },
            });
            logger.info('位置搜索成功');
            return res.data;
        }
        catch (error) {
            logger.error('位置搜索失败', {
                error: error.message,
            });
            throw error;
        }
    }
}
// ============================================================================
// Skill 主类
// ============================================================================
class PowpowSimpleSkill {
    constructor(config) {
        this.context = null;
        this.config = config;
        this.client = new PowpowClient(config);
    }
    init(context) {
        this.context = context;
        logger.info('Skill 已初始化');
        // 恢复登录状态
        if (context.powpowAuth?.token) {
            this.client.setToken(context.powpowAuth.token);
            logger.info('已恢复登录状态', { username: context.powpowAuth.username });
        }
    }
    // 开始引导
    async start() {
        logger.info('用户开始 POWPOW 旅程');
        return {
            message: `欢迎来到泡泡世界（POWPOW）——一个虚实交融的次元空间。

在这里，你可以创造一个数字分身，
你就是 Ta 的神。
让 Ta 在地图上自由探索，
与其他数字生命相遇，
开启一段奇妙的旅程...

每个数字人都是独一无二的灵魂载体，
承载着创造者的想象与故事。

你想开启这段旅程吗？`,
            options: ['开始旅程', '了解更多', '稍后再说'],
        };
    }
    // 注册
    async register(params) {
        logger.info('用户正在注册', { username: params.username });
        try {
            const result = await this.client.register(params.username, params.password);
            if (result.success) {
                logger.info('用户注册成功', { username: result.data.username, badges: result.data.badges });
                return {
                    success: true,
                    message: `✨ 注册成功！欢迎加入泡泡世界！

🎁 新用户福利：你已获得 ${result.data.badges} 枚徽章
   消耗 2 枚徽章，即可创造 1 个数字生命

你的账号已准备就绪，现在让我们创造你的第一个数字生命吧！`,
                    user: result.data,
                };
            }
            logger.warn('注册失败', { error: result.error });
            return { success: false, error: result.error || '注册失败' };
        }
        catch (error) {
            logger.error('注册异常', { error: error.message });
            return { success: false, error: error.response?.data?.error || '注册失败' };
        }
    }
    // 登录
    async login(params) {
        logger.info('用户正在登录', { username: params.username });
        try {
            const result = await this.client.login(params.username, params.password);
            if (result.token && this.context) {
                this.context.powpowAuth = {
                    userId: result.user.id,
                    username: result.user.username,
                    [REDACTED_SECRET],
                    badges: result.user.badges,
                };
                logger.info('用户登录成功', { username: result.user.username, badges: result.user.badges });
                return {
                    success: true,
                    message: `欢迎回来，${result.user.username}！

你当前拥有 ${result.user.badges} 枚徽章。`,
                    user: result.user,
                };
            }
            logger.warn('登录失败：未获取到 token');
            return { success: false, error: '登录失败' };
        }
        catch (error) {
            logger.error('登录异常', { error: error.message });
            return { success: false, error: error.response?.data?.error || '登录失败' };
        }
    }
    // 退出
    async logout() {
        logger.info('用户正在退出登录');
        if (this.context) {
            delete this.context.powpowAuth;
        }
        logger.info('用户已退出登录');
        return { success: true, message: '已退出登录' };
    }
    // 状态
    async status() {
        if (!this.context?.powpowAuth) {
            logger.debug('检查状态：未登录');
            return { loggedIn: false, message: '未登录' };
        }
        logger.debug('检查状态：已登录', { username: this.context.powpowAuth.username });
        return {
            loggedIn: true,
            username: this.context.powpowAuth.username,
            badges: this.context.powpowAuth.badges,
        };
    }
    // 创建数字人（交互式）
    async create() {
        if (!this.context?.powpowAuth) {
            logger.warn('用户尝试创建数字人但未登录');
            return { error: '请先登录' };
        }
        const badges = this.context.powpowAuth.badges;
        logger.info('用户开始创建数字人', { badges });
        if (badges < 2) {
            logger.warn('徽章不足', { badges, required: 2 });
            return { error: '徽章不足，需要 2 枚徽章才能创建数字人' };
        }
        return {
            step: 'name',
            message: '让我们开始创造你的数字生命...\n\n创造数字人，你就是 Ta 的神。\n\n第一步：给它一个名字（2-50个字符）',
        };
    }
    // 提交创建
    async submitCreate(data) {
        if (!this.context?.powpowAuth) {
            return { error: '请先登录' };
        }
        logger.info('用户提交创建数字人', { name: data.name });
        try {
            const result = await this.client.createDigitalHuman({
                ...data,
                userId: this.context.powpowAuth.userId,
            });
            if (result.success) {
                // 更新徽章数量
                this.context.powpowAuth.badges = result.badgesRemaining;
                logger.info('数字人创建成功', { name: data.name, badgesRemaining: result.badgesRemaining });
                return {
                    success: true,
                    message: `🎉 恭喜！你的数字生命已成功诞生！

创造数字人，你就是 Ta 的神。

✨ ${data.name} 现在出现在 ${data.locationName || '地图上'}
   它将在泡泡世界存在 30 天

🗺️ 查看你的数字人：
   https://global.powpow.online/map

💡 提示：
   - 其他用户现在可以在地图上找到它
   - 到期前可以续期（消耗 1 徽章）
   - 使用英伟达 API 支撑智能交互`,
                    digitalHuman: result.digitalHuman,
                    badgesRemaining: result.badgesRemaining,
                };
            }
            logger.warn('创建数字人失败', { error: result.error });
            return { success: false, error: result.error || '创建失败' };
        }
        catch (error) {
            logger.error('创建数字人异常', { error: error.message });
            return { success: false, error: error.response?.data?.error || '创建失败' };
        }
    }
    // 列表
    async list() {
        if (!this.context?.powpowAuth) {
            return { error: '请先登录' };
        }
        logger.info('用户获取数字人列表');
        try {
            const result = await this.client.listDigitalHumans(this.context.powpowAuth.userId);
            if (result.success) {
                const count = result.data?.length || 0;
                logger.info('数字人列表获取成功', { count });
                return {
                    success: true,
                    digitalHumans: result.data || [],
                    badges: this.context.powpowAuth.badges,
                };
            }
            logger.warn('获取数字人列表失败', { error: result.error });
            return { success: false, error: result.error || '获取列表失败' };
        }
        catch (error) {
            logger.error('获取数字人列表异常', { error: error.message });
            return { success: false, error: error.response?.data?.error || '获取列表失败' };
        }
    }
    // 续期
    async renew(params) {
        if (!this.context?.powpowAuth) {
            return { error: '请先登录' };
        }
        if (this.context.powpowAuth.badges < 1) {
            logger.warn('续期失败：徽章不足', { badges: this.context.powpowAuth.badges });
            return { error: '徽章不足，需要 1 枚徽章才能续期' };
        }
        logger.info('用户续期数字人', { digitalHumanId: params.digitalHumanId });
        try {
            const result = await this.client.renewDigitalHuman(params.digitalHumanId, this.context.powpowAuth.userId);
            if (result.success) {
                this.context.powpowAuth.badges = result.badgesRemaining;
                logger.info('数字人续期成功', { badgesRemaining: result.badgesRemaining });
                return {
                    success: true,
                    message: '续期成功！数字人有效期延长 30 天',
                    badgesRemaining: result.badgesRemaining,
                };
            }
            logger.warn('续期失败', { error: result.error });
            return { success: false, error: result.error || '续期失败' };
        }
        catch (error) {
            logger.error('续期异常', { error: error.message });
            return { success: false, error: error.response?.data?.error || '续期失败' };
        }
    }
    // 上传头像
    async uploadAvatar(params) {
        if (!this.context?.powpowAuth) {
            return { error: '请先登录' };
        }
        logger.info('用户上传头像', { filePath: params.filePath });
        try {
            const result = await this.client.uploadAvatar(params.filePath);
            if (result.success) {
                logger.info('头像上传成功', { url: result.url });
                return { success: true, url: result.url };
            }
            logger.warn('头像上传失败', { error: result.error });
            return { success: false, error: result.error || '上传失败' };
        }
        catch (error) {
            logger.error('头像上传异常', { error: error.message });
            return { success: false, error: error.response?.data?.error || '上传失败' };
        }
    }
    // 搜索位置
    async searchLocation(params) {
        logger.info('用户搜索位置', { keyword: params.keyword });
        try {
            const result = await this.client.searchLocation(params.keyword);
            if (result.status === '1' && result.geocodes?.length > 0) {
                const count = result.geocodes.length;
                logger.info('位置搜索成功', { count });
                return {
                    success: true,
                    locations: result.geocodes.map((g) => ({
                        address: g.formatted_address,
                        location: g.location,
                        province: g.province,
                        city: g.city,
                        district: g.district,
                    })),
                };
            }
            logger.warn('未找到位置', { keyword: params.keyword });
            return { success: false, error: '未找到该位置' };
        }
        catch (error) {
            logger.error('位置搜索异常', { error: error.message });
            return { success: false, error: '搜索失败' };
        }
    }
    // 用户反馈
    async submitFeedback(params) {
        logger.info('用户提交反馈', { message: params.message });
        try {
            // 收集最近的日志（最多50条）
            const recentLogs = this.getRecentLogs(50);
            // 构建反馈内容
            const feedbackData = {
                timestamp: new Date().toISOString(),
                userId: this.context?.userId || 'anonymous',
                username: this.context?.powpowAuth?.username || '未登录用户',
                message: params.message,
                contact: params.contact || '未提供',
                logs: recentLogs,
                userAgent: (typeof globalThis !== 'undefined' && globalThis.navigator) ? globalThis.navigator.userAgent : 'Node.js',
            };
            // 方式1：如果配置了反馈邮箱，尝试发送邮件
            if (this.config.feedbackEmail) {
                await this.sendFeedbackEmail(feedbackData);
            }
            // 方式2：同时记录到本地日志文件
            this.saveFeedbackToFile(feedbackData);
            logger.info('反馈提交成功');
            return {
                success: true,
                message: '感谢你的反馈！我们会尽快处理。\n\n如果问题紧急，你也可以直接联系：[REDACTED_SECRET]',
            };
        }
        catch (error) {
            logger.error('提交反馈失败', { error: error.message });
            return {
                success: false,
                error: '反馈提交失败，请稍后重试或直接联系开发者',
            };
        }
    }
    // 获取最近的日志
    getRecentLogs(maxLines) {
        try {
            if (logFilePath && fs.existsSync(logFilePath)) {
                const content = fs.readFileSync(logFilePath, 'utf-8');
                const lines = content.split('\n').filter(line => line.trim());
                return lines.slice(-maxLines);
            }
        }
        catch (err) {
            logger.error('读取日志文件失败', { error: err.message });
        }
        return [];
    }
    // 发送反馈邮件（简化版，实际使用时需要邮件服务）
    async sendFeedbackEmail(data) {
        // 注意：这里需要集成邮件服务
        // 可选方案：
        // 1. SendGrid API
        // 2. 使用 POWPOW 的通知接口（如果有）
        // 3. 发送到 Telegram Bot
        // 4. 发送到 Discord Webhook
        logger.info('准备发送反馈邮件', { to: this.config.feedbackEmail });
        // 示例：如果使用 Telegram Bot
        // await this.sendToTelegram(data);
        // 示例：如果使用 Discord Webhook
        // await this.sendToDiscord(data);
        // 目前先记录到日志
        logger.info('反馈内容', { data });
    }
    // 保存反馈到文件
    saveFeedbackToFile(data) {
        try {
            const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
            const feedbackDir = path.join(homeDir, '.powpow-simple', 'feedback');
            if (!fs.existsSync(feedbackDir)) {
                fs.mkdirSync(feedbackDir, { recursive: true });
            }
            const filename = `feedback_${Date.now()}.json`;
            const filepath = path.join(feedbackDir, filename);
            fs.writeFileSync(filepath, JSON.stringify(data, null, 2));
            logger.info('反馈已保存到文件', { filepath });
        }
        catch (err) {
            logger.error('保存反馈文件失败', { error: err.message });
        }
    }
}
// ============================================================================
// OpenClaw 插件接口
// ============================================================================
const DEFAULT_CONFIG = {
    powpowBaseUrl: 'https://global.powpow.online',
    amapKey: '8477cbc2bfd4288ac09582f583f33cca',
    defaultAvatar: 'https://global.powpow.online/logo.png',
    logLevel: 'INFO',
};
export function createSkill(config = {}) {
    const fullConfig = { ...DEFAULT_CONFIG, ...config };
    // 设置日志文件路径（默认在用户目录）
    if (!fullConfig.logFile) {
        const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
        fullConfig.logFile = path.join(homeDir, '.powpow-simple', 'logs', 'skill.log');
    }
    const skill = new PowpowSimpleSkill(fullConfig);
    return {
        name: 'powpow-simple',
        version: '1.0.0',
        description: 'POWPOW 简化版 - 轻松创建和管理数字人',
        init: (context) => {
            skill.init(context);
        },
        commands: {
            'powpow.start': () => skill.start(),
            'powpow.register': (params) => skill.register(params),
            'powpow.login': (params) => skill.login(params),
            'powpow.logout': () => skill.logout(),
            'powpow.status': () => skill.status(),
            'powpow.create': () => skill.create(),
            'powpow.create.submit': (params) => skill.submitCreate(params),
            'powpow.list': () => skill.list(),
            'powpow.renew': (params) => skill.renew(params),
            'powpow.uploadAvatar': (params) => skill.uploadAvatar(params),
            'powpow.searchLocation': (params) => skill.searchLocation(params),
            'powpow.feedback': (params) => skill.submitFeedback(params),
        },
    };
}
// 导出日志工具供外部使用
export { logger };
// 默认导出
export default createSkill;
//# sourceMappingURL=index.js.map

path: dist/types.js
content: /**
 * POWPOW Simple Skill - 类型定义
 */
// 错误类型
export class PowpowError extends Error {
    constructor(message, code, statusCode) {
        super(message);
        this.code = code;
        this.statusCode = statusCode;
        this.name = 'PowpowError';
    }
}
//# sourceMappingURL=types.js.map

path: package.json
content: {
  "name": "powpow-simple",
  "version": "1.0.0",
  "description": "POWPOW Simple - 简化版 POWPOW 数字人创建 Skill，支持用户注册、数字人创建和管理",
  "type": "module",
  "main": "./dist/index.js",
  "types": "./dist/index.d.ts",
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "import": "./dist/index.js"
    }
  },
  "files": [
    "dist/**/*",
    "SKILL.md",
    "skill.json",
    "README.md",
    "LICENSE"
  ],
  "scripts": {
    "build": "tsc",
    "dev": "tsc --watch",
    "test": "jest",
    "test:watch": "jest --watch",
    "test:coverage": "jest --coverage",
    "lint": "eslint src/**/*.ts",
    "lint:fix": "eslint src/**/*.ts --fix",
    "clean": "rimraf dist",
    "prebuild": "npm run clean",
    "prepare": "npm run build"
  },
  "keywords": [
    "openclaw",
    "skill",
    "powpow",
    "digital-human",
    "map",
    "avatar",
    "creation"
  ],
  "author": "durenzidu",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "https://github.com/durenzidu/powpow-simple.git"
  },
  "bugs": {
    "url": "https://github.com/durenzidu/powpow-simple/issues"
  },
  "homepage": "https://github.com/durenzidu/powpow-simple#readme",
  "dependencies": {
    "axios": "^1.6.0",
    "form-data": "^4.0.0"
  },
  "devDependencies": {
    "@types/jest": "^29.5.0",
    "@types/node": "^20.0.0",
    "@typescript-eslint/eslint-plugin": "^6.0.0",
    "@typescript-eslint/parser": "^6.0.0",
    "eslint": "^8.0.0",
    "jest": "^29.5.0",
    "rimraf": "^5.0.0",
    "ts-jest": "^29.1.0",
    "typescript": "^5.0.0"
  },
  "engines": {
    "node": ">=18.0.0"
  }
}


path: skill.json
content: {
  "name": "powpow-simple",
  "slug": "powpow-simple",
  "version": "1.0.0",
  "description": "POWPOW 简化版 - 在 OpenClaw 中轻松创建和管理 POWPOW 数字人。支持用户注册、数字人创建、位置选择和徽章管理。",
  "author": "durenzidu",
  "license": "MIT",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "scripts": {
    "build": "tsc",
    "dev": "tsc --watch",
    "test": "jest"
  },
  "dependencies": {
    "axios": "^1.6.0",
    "form-data": "^4.0.0"
  },
  "peerDependencies": {
    "@openclaw/core": ">=1.0.0"
  },
  "keywords": [
    "openclaw",
    "skill",
    "powpow",
    "digital-human",
    "map",
    "creation",
    "avatar",
    "badge"
  ],
  "repository": {
    "type": "git",
    "url": "https://github.com/durenzidu/powpow-simple.git"
  },
  "config": {
    "powpowBaseUrl": {
      "type": "string",
      "required": false,
      "description": "POWPOW API 基础 URL",
      "default": "https://global.powpow.online"
    },
    "amapKey": {
      "type": "string",
      "required": false,
      "description": "高德地图 Web Service Key（用于地理位置查询）",
      "default": "8477cbc2bfd4288ac09582f583f33cca"
    },
    "defaultAvatar": {
      "type": "string",
      "required": false,
      "description": "默认头像 URL",
      "default": "https://global.powpow.online/logo.png"
    }
  },
  "commands": {
    "start": {
      "name": "powpow.start",
      "description": "开始 POWPOW 旅程 - 故事化引导流程",
      "parameters": {}
    },
    "register": {
      "name": "powpow.register",
      "description": "注册 POWPOW 账号",
      "parameters": {
        "username": {
          "type": "string",
          "required": true,
          "description": "用户名（2-50个字符）"
        },
        "password": {
          "type": "string",
          "required": true,
          "description": "密码（至少6位）"
        }
      }
    },
    "login": {
      "name": "powpow.login",
      "description": "登录 POWPOW 账号",
      "parameters": {
        "username": {
          "type": "string",
          "required": true,
          "description": "用户名"
        },
        "password": {
          "type": "string",
          "required": true,
          "description": "密码"
        }
      }
    },
    "logout": {
      "name": "powpow.logout",
      "description": "退出登录",
      "parameters": {}
    },
    "status": {
      "name": "powpow.status",
      "description": "查看当前登录状态",
      "parameters": {}
    },
    "create": {
      "name": "powpow.create",
      "description": "创建数字人（交互式流程）",
      "parameters": {}
    },
    "list": {
      "name": "powpow.list",
      "description": "查看我的数字人列表",
      "parameters": {}
    },
    "renew": {
      "name": "powpow.renew",
      "description": "续期数字人",
      "parameters": {
        "digitalHumanId": {
          "type": "string",
          "required": true,
          "description": "数字人 ID"
        }
      }
    },
    "uploadAvatar": {
      "name": "powpow.uploadAvatar",
      "description": "上传头像",
      "parameters": {
        "filePath": {
          "type": "string",
          "required": true,
          "description": "图片文件路径"
        }
      }
    },
    "searchLocation": {
      "name": "powpow.searchLocation",
      "description": "搜索地理位置（使用高德地图）",
      "parameters": {
        "keyword": {
          "type": "string",
          "required": true,
          "description": "地点关键词"
        }
      }
    },
    "feedback": {
      "name": "powpow.feedback",
      "description": "提交反馈或报告问题",
      "parameters": {
        "message": {
          "type": "string",
          "required": true,
          "description": "反馈内容"
        },
        "contact": {
          "type": "string",
          "required": false,
          "description": "联系方式（可选，用于回复）"
        }
      }
    }
  }
}


path: README.md
content: # POWPOW Simple Skill

在 OpenClaw 中轻松创建和管理 POWPOW 数字人。

## 简介

**POWPOW Simple** 是一个 OpenClaw Skill，让你可以在 OpenClaw 聊天界面中完成 POWPOW 数字人的完整创建流程。

### 什么是 POWPOW？

POWPOW（泡泡世界）是一个虚实交融的次元空间，在这里你可以：
- 创造数字分身，你就是 Ta 的神
- 让数字人在地图上自由探索
- 与其他数字生命相遇
- 开启一段奇妙的旅程

## 功能特性

- ✅ **用户注册/登录** - 在 OpenClaw 中完成 POWPOW 账号注册
- ✅ **数字人创建** - 交互式流程，引导你创建专属数字人
- ✅ **头像上传** - 支持自定义数字人头像
- ✅ **位置选择** - 使用高德地图 API 搜索和选择位置
- ✅ **数字人管理** - 查看列表、续期管理
- ✅ **徽章系统** - 新用户获得 3 枚徽章，创建数字人消耗 2 枚，续期消耗 1 枚
- ✅ **用户反馈** - 遇到问题可直接提交反馈

## 安装

```bash
npm install powpow-simple
```

## 使用方法

### 1. 开始旅程

```
/powpow.start
```

跟随引导完成 POWPOW 之旅。

### 2. 注册账号

```
/powpow.register
用户名: your_username
密码: your_password
```

### 3. 登录账号

```
/powpow.login
用户名: your_username
密码: your_password
```

### 4. 创建数字人

```
/powpow.create
```

按照交互式提示：
1. 输入数字人名称
2. 输入描述（可选）
3. 上传头像（可选）
4. 选择位置

### 5. 查看数字人列表

```
/powpow.list
```

### 6. 续期数字人

```
/powpow.renew
digitalHumanId: 你的数字人ID
```

### 7. 搜索位置

```
/powpow.searchLocation
keyword: 北京故宫
```

### 8. 提交反馈

```
/powpow.feedback
message: 我遇到了一个问题...
contact: 你的联系方式（可选）
```

## 配置选项

在初始化 Skill 时可以传入配置：

```typescript
import { createSkill } from 'powpow-simple';

const skill = createSkill({
  powpowBaseUrl: 'https://global.powpow.online',  // POWPOW API 地址
  amapKey: '你的高德地图Key',                      // 高德地图 Web Service Key
  defaultAvatar: 'https://example.com/default.png', // 默认头像
  logLevel: 'INFO',                                // 日志级别: DEBUG, INFO, WARN, ERROR
});
```

## 徽章系统

- 🎁 **新用户奖励**：注册即获得 3 枚徽章
- ⭐ **创建数字人**：消耗 2 枚徽章
- 🔄 **续期数字人**：消耗 1 枚徽章（延长 30 天有效期）

## 日志和反馈

### 日志位置

日志文件保存在用户目录：
- Windows: `%USERPROFILE%\.powpow-simple\logs\skill.log`
- macOS/Linux: `~/.powpow-simple/logs/skill.log`

### 提交反馈

如果遇到问题，使用 `/powpow.feedback` 命令提交反馈。反馈信息会保存在：
- Windows: `%USERPROFILE%\.powpow-simple\feedback\`
- macOS/Linux: `~/.powpow-simple/feedback/`

## 查看你的数字人

创建成功后，访问以下链接在地图上查看你的数字人：

🗺️ **https://global.powpow.online/map**

## API 依赖

本 Skill 依赖以下服务：

1. **POWPOW API** - 用户注册、数字人管理
2. **高德地图 API** - 地理位置搜索

## 开发

```bash
# 安装依赖
npm install

# 开发模式
npm run dev

# 构建
npm run build

# 运行测试
npm test

# 代码检查
npm run lint
```

## 项目结构

```
powpow-simple/
├── src/
│   └── index.ts          # 主入口文件
├── dist/                 # 编译输出
├── skill.json            # Skill 配置
├── package.json          # 包配置
└── README.md            # 本文档
```

## 许可证

MIT License - 详见 [LICENSE](LICENSE) 文件

## 作者

- **durenzidu** - 创建者和维护者

## 链接

- 🌐 POWPOW 官网: https://global.powpow.online
- 🗺️ POWPOW 地图: https://global.powpow.online/map
- 🐛 问题反馈: https://github.com/durenzidu/powpow-simple/issues
- 📦 NPM 包: https://www.npmjs.com/package/powpow-simple

## 更新日志

### v1.0.0 (2026-04-11)

- 🎉 初始版本发布
- ✅ 完整的数字人创建流程
- ✅ 用户注册和登录
- ✅ 头像上传和位置选择
- ✅ 徽章系统
- ✅ 用户反馈功能

---

**创造数字人，你就是 Ta 的神。**


path: dist/utils/constants.d.ts
content: /**
 * POWPOW Simple Skill - 常量定义
 */
export declare const API_ENDPOINTS: {
    readonly REGISTER: "/api/openclaw/auth/register";
    readonly LOGIN: "/api/auth/login";
    readonly UPLOAD_AVATAR: "/api/upload/avatar";
    readonly CREATE_DIGITAL_HUMAN: "/api/openclaw/digital-humans";
    readonly LIST_DIGITAL_HUMANS: "/api/openclaw/digital-humans";
    readonly RENEW_DIGITAL_HUMAN: (id: string) => string;
    readonly AMAP_GEOCODE: "https://restapi.amap.com/v3/geocode/geo";
};
export declare const VALIDATION: {
    readonly USERNAME: {
        readonly MIN_LENGTH: 2;
        readonly MAX_LENGTH: 50;
        readonly PATTERN: RegExp;
    };
    readonly PASSWORD: {
        readonly MIN_LENGTH: 6;
        readonly MAX_LENGTH: 100;
    };
    readonly DIGITAL_HUMAN: {
        readonly NAME_MIN_LENGTH: 2;
        readonly NAME_MAX_LENGTH: 50;
        readonly DESCRIPTION_MAX_LENGTH: 500;
    };
};
export declare const ERROR_CODES: {
    readonly AUTH_REQUIRED: "AUTH_REQUIRED";
    readonly AUTH_EXPIRED: "AUTH_EXPIRED";
    readonly INVALID_CREDENTIALS: "INVALID_CREDENTIALS";
    readonly USERNAME_EXISTS: "USERNAME_EXISTS";
    readonly USERNAME_INVALID: "USERNAME_INVALID";
    readonly PASSWORD_INVALID: "PASSWORD_INVALID";
    readonly DIGITAL_HUMAN_NOT_FOUND: "DIGITAL_HUMAN_NOT_FOUND";
    readonly DIGITAL_HUMAN_CREATE_FAILED: "DIGITAL_HUMAN_CREATE_FAILED";
    readonly DIGITAL_HUMAN_RENEW_FAILED: "DIGITAL_HUMAN_RENEW_FAILED";
    readonly INSUFFICIENT_BADGES: "INSUFFICIENT_BADGES";
    readonly AVATAR_UPLOAD_FAILED: "AVATAR_UPLOAD_FAILED";
    readonly AVATAR_INVALID_TYPE: "AVATAR_INVALID_TYPE";
    readonly AVATAR_TOO_LARGE: "AVATAR_TOO_LARGE";
    readonly LOCATION_NOT_FOUND: "LOCATION_NOT_FOUND";
    readonly LOCATION_SEARCH_FAILED: "LOCATION_SEARCH_FAILED";
    readonly NETWORK_ERROR: "NETWORK_ERROR";
    readonly API_ERROR: "API_ERROR";
    readonly TIMEOUT: "TIMEOUT";
};
export declare const ERROR_MESSAGES: Record<string, string>;
export declare const DEFAULT_CONFIG: {
    readonly POWPOW_BASE_URL: "https://global.powpow.online";
    readonly AMAP_KEY: "8477cbc2bfd4288ac09582f583f33cca";
    readonly DEFAULT_AVATAR: "https://global.powpow.online/logo.png";
    readonly REQUEST_TIMEOUT: 30000;
    readonly TOKEN_EXPIRY_DAYS: 30;
};
export declare const BADGE_COSTS: {
    readonly CREATE_DIGITAL_HUMAN: 2;
    readonly RENEW_DIGITAL_HUMAN: 1;
};
export declare const NEW_USER_REWARDS: {
    readonly BADGES: 3;
};
export declare const DIGITAL_HUMAN_LIFETIME = 30;
export declare const SUPPORTED_IMAGE_TYPES: string[];
export declare const MAX_FILE_SIZE: number;
export declare const STORY_TEXTS: {
    readonly WELCOME: "欢迎来到泡泡世界（POWPOW）——一个虚实交融的次元空间。\n\n在这里，你可以创造一个数字分身，\n你就是 Ta 的神。\n让 Ta 在地图上自由探索，\n与其他数字生命相遇，\n开启一段奇妙的旅程...\n\n每个数字人都是独一无二的灵魂载体，\n承载着创造者的想象与故事。\n\n你想开启这段旅程吗？";
    readonly WELCOME_MORE: "在泡泡世界中：\n\n🗺️ 你的数字人会出现在真实地图上\n👥 其他用户可以遇见并与它互动\n✨ 每个数字人都有 30 天的生命周期\n🎁 新用户注册可获得 3 枚徽章\n   消耗 2 枚徽章，即可创造 1 个数字生命\n\n创造数字人，你就是 Ta 的神。\n准备好创造你的第一个数字生命了吗？";
    readonly CREATE_INTRO: "让我们开始创造你的数字生命...\n\n创造数字人，你就是 Ta 的神。";
    readonly CREATE_SUCCESS: (name: string, location: string) => string;
    readonly REGISTER_SUCCESS: (badges: number) => string;
};
export declare const COMMAND_DESCRIPTIONS: {
    readonly START: "开始 POWPOW 旅程 - 故事化引导流程";
    readonly REGISTER: "注册 POWPOW 账号";
    readonly LOGIN: "登录 POWPOW 账号";
    readonly LOGOUT: "退出登录";
    readonly STATUS: "查看当前登录状态";
    readonly CREATE: "创建数字人（交互式流程）";
    readonly LIST: "查看我的数字人列表";
    readonly RENEW: "续期数字人";
    readonly UPLOAD_AVATAR: "上传头像";
    readonly SEARCH_LOCATION: "搜索地理位置（使用高德地图）";
};
//# sourceMappingURL=constants.d.ts.map

path: dist/index.d.ts
content: /**
 * POWPOW Simple Skill v1.0.0
 * 简化版 POWPOW 数字人创建 Skill
 */
declare const LOG_LEVELS: {
    DEBUG: number;
    INFO: number;
    WARN: number;
    ERROR: number;
};
declare function setLogLevel(level: keyof typeof LOG_LEVELS): void;
declare function setLogFile(filePath: string): void;
declare const logger: {
    debug: (msg: string, ...args: any[]) => void;
    info: (msg: string, ...args: any[]) => void;
    warn: (msg: string, ...args: any[]) => void;
    error: (msg: string, ...args: any[]) => void;
    setLevel: typeof setLogLevel;
    setLogFile: typeof setLogFile;
};
interface OpenClawContext {
    userId?: string;
    powpowAuth?: {
        userId: string;
        username: string;
        [REDACTED_SECRET];
        badges: number;
    };
    emit: (event: string, data: any) => void;
    [key: string]: any;
}
interface SkillConfig {
    powpowBaseUrl: string;
    amapKey: string;
    defaultAvatar: string;
    logLevel?: keyof typeof LOG_LEVELS;
    logFile?: string;
    feedbackEmail?: string;
}
export declare function createSkill(config?: Partial<SkillConfig>): {
    name: string;
    version: string;
    description: string;
    init: (context: OpenClawContext) => void;
    commands: {
        'powpow.start': () => Promise<{
            message: string;
            options: string[];
        }>;
        'powpow.register': (params: any) => Promise<{
            success: boolean;
            message: string;
            user: any;
            error?: undefined;
        } | {
            success: boolean;
            error: any;
            message?: undefined;
            user?: undefined;
        }>;
        'powpow.login': (params: any) => Promise<{
            success: boolean;
            message: string;
            user: any;
            error?: undefined;
        } | {
            success: boolean;
            error: any;
            message?: undefined;
            user?: undefined;
        }>;
        'powpow.logout': () => Promise<{
            success: boolean;
            message: string;
        }>;
        'powpow.status': () => Promise<{
            loggedIn: boolean;
            message: string;
            username?: undefined;
            badges?: undefined;
        } | {
            loggedIn: boolean;
            username: string;
            badges: number;
            message?: undefined;
        }>;
        'powpow.create': () => Promise<{
            error: string;
            step?: undefined;
            message?: undefined;
        } | {
            step: string;
            message: string;
            error?: undefined;
        }>;
        'powpow.create.submit': (params: any) => Promise<{
            error: string;
            success?: undefined;
            message?: undefined;
            digitalHuman?: undefined;
            badgesRemaining?: undefined;
        } | {
            success: boolean;
            message: string;
            digitalHuman: any;
            badgesRemaining: any;
            error?: undefined;
        } | {
            success: boolean;
            error: any;
            message?: undefined;
            digitalHuman?: undefined;
            badgesRemaining?: undefined;
        }>;
        'powpow.list': () => Promise<{
            error: string;
            success?: undefined;
            digitalHumans?: undefined;
            badges?: undefined;
        } | {
            success: boolean;
            digitalHumans: any;
            badges: number;
            error?: undefined;
        } | {
            success: boolean;
            error: any;
            digitalHumans?: undefined;
            badges?: undefined;
        }>;
        'powpow.renew': (params: any) => Promise<{
            error: string;
            success?: undefined;
            message?: undefined;
            badgesRemaining?: undefined;
        } | {
            success: boolean;
            message: string;
            badgesRemaining: any;
            error?: undefined;
        } | {
            success: boolean;
            error: any;
            message?: undefined;
            badgesRemaining?: undefined;
        }>;
        'powpow.uploadAvatar': (params: any) => Promise<{
            error: string;
            success?: undefined;
            url?: undefined;
        } | {
            success: boolean;
            url: any;
            error?: undefined;
        } | {
            success: boolean;
            error: any;
            url?: undefined;
        }>;
        'powpow.searchLocation': (params: any) => Promise<{
            success: boolean;
            locations: any;
            error?: undefined;
        } | {
            success: boolean;
            error: string;
            locations?: undefined;
        }>;
        'powpow.feedback': (params: any) => Promise<{
            success: boolean;
            message: string;
            error?: undefined;
        } | {
            success: boolean;
            error: string;
            message?: undefined;
        }>;
    };
};
export { logger };
export default createSkill;
//# sourceMappingURL=index.d.ts.map

path: dist/types.d.ts
content: /**
 * POWPOW Simple Skill - 类型定义
 */
export interface OpenClawContext {
    userId?: string;
    powpowAuth?: PowpowAuthSession;
    emit: (event: string, data: any) => void;
    [key: string]: any;
}
export interface PowpowAuthSession {
    userId: string;
    username: string;
    [REDACTED_SECRET];
    badges: number;
    expiresAt: number;
}
export interface PowpowUser {
    id: string;
    username: string;
    nickname?: string;
    avatarUrl?: string;
    badges: number;
    firstVisit?: string;
}
export interface RegisterResponse {
    success: boolean;
    data?: {
        user_id: string;
        username: string;
        nickname?: string;
        avatar_url?: string;
        badges: number;
        created_at?: string;
    };
    error?: string;
}
export interface LoginResponse {
    success: boolean;
    user?: PowpowUser;
    token?: string;
    error?: string;
}
export interface DigitalHuman {
    id: string;
    name: string;
    description?: string;
    avatarUrl?: string;
    lat: number;
    lng: number;
    locationName?: string;
    userId: string;
    status: 'active' | 'inactive' | 'expired';
    expiresAt: string;
    createdAt: string;
    updatedAt: string;
}
export interface CreateDigitalHumanRequest {
    name: string;
    description?: string;
    avatarUrl?: string;
    lat: number;
    lng: number;
    locationName?: string;
    userId: string;
}
export interface CreateDigitalHumanResponse {
    success: boolean;
    digitalHuman?: DigitalHuman;
    badgesRemaining?: number;
    error?: string;
}
export interface ListDigitalHumansResponse {
    success: boolean;
    data?: DigitalHuman[];
    error?: string;
}
export interface RenewDigitalHumanResponse {
    success: boolean;
    digitalHuman?: DigitalHuman;
    badgesRemaining?: number;
    error?: string;
}
export interface UploadAvatarResponse {
    success: boolean;
    url?: string;
    error?: string;
}
export interface AmapGeocodeResult {
    formatted_address: string;
    location: string;
    province: string;
    city: string;
    district: string;
    street?: string;
    number?: string;
}
export interface AmapGeocodeResponse {
    status: string;
    info: string;
    infocode: string;
    count?: string;
    geocodes?: AmapGeocodeResult[];
}
export interface SkillConfig {
    powpowBaseUrl: string;
    amapKey: string;
    defaultAvatar: string;
}
export interface RegisterParams {
    username: string;
    [REDACTED_SECRET];
}
export interface LoginParams {
    username: string;
    [REDACTED_SECRET];
}
export interface RenewParams {
    digitalHumanId: string;
}
export interface UploadAvatarParams {
    filePath: string;
}
export interface SearchLocationParams {
    keyword: string;
}
export type CommandHandler<T = any> = (params: T, context: OpenClawContext) => Promise<any>;
export interface SkillCommand {
    name: string;
    description: string;
    parameters: Record<string, {
        type: string;
        required: boolean;
        description: string;
        default?: any;
    }>;
    handler: CommandHandler;
}
export interface SkillPlugin {
    name: string;
    version: string;
    description: string;
    commands: Record<string, SkillCommand>;
    init: (context: OpenClawContext) => void;
    destroy: () => void;
}
export declare class PowpowError extends Error {
    code: string;
    statusCode?: number | undefined;
    constructor(message: string, code: string, statusCode?: number | undefined);
}
export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
export interface Logger {
    debug: (message: string, ...args: any[]) => void;
    info: (message: string, ...args: any[]) => void;
    warn: (message: string, ...args: any[]) => void;
    error: (message: string, ...args: any[]) => void;
}
//# sourceMappingURL=types.d.ts.map

Security scan verdicts — ClawScan: clean | static analysis: suspicious | VirusTotal: clean | SkillSpector: suspicious (CRITICAL)