@artflo-ai/artflo-openclaw-plugin 0.0.1

package/dist/src/core/canvas/ws-trace.js

@@ -0,0 +1,42 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { resolvePluginLogDir, localTimestamp } from '../../paths.js';
+function sanitizeSegment(value) {
+    return value.replace(/[^a-zA-Z0-9._-]+/g, '_').slice(0, 80) || 'trace';
+}
+function redact(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => redact(item));
+    }
+    if (typeof value === 'object' && value !== null) {
+        const output = {};
+        for (const [key, child] of Object.entries(value)) {
+            if (key === 'access_token' ||
+                key === 'access-token' ||
+                key === 'accessToken' ||
+                key === 'apiKey' ||
+                key === 'X-API-Key') {
+                output[key] = '[REDACTED]';
+            }
+            else {
+                output[key] = redact(child);
+            }
+        }
+        return output;
+    }
+    return value;
+}
+export async function writeWsTrace(args) {
+    const timestamp = localTimestamp();
+    const baseDir = resolvePluginLogDir('ws-traffic-traces');
+    await mkdir(baseDir, { recursive: true });
+    const filePath = path.join(baseDir, `${timestamp}-${args.direction}-${sanitizeSegment(args.event)}${args.canvasId ? `-${sanitizeSegment(args.canvasId)}` : ''}.json`);
+    await writeFile(filePath, JSON.stringify({
+        createdAt: new Date().toISOString(),
+        direction: args.direction,
+        event: args.event,
+        canvasId: args.canvasId ?? null,
+        payload: redact(args.payload),
+    }, null, 2), 'utf8');
+    return filePath;
+}

package/dist/src/core/config/fetch-client-params.js

@@ -0,0 +1,20 @@
+/**
+ * Fetch appKey, vipAppId, vipGroup from the subscribe-client-params API.
+ * GET {webApiBaseUrl}/api/subscribe-client-params
+ */
+export async function fetchClientParams(webApiBaseUrl) {
+    const url = `${webApiBaseUrl.replace(/\/+$/, '')}/api/subscribe-client-params`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`fetchClientParams failed: HTTP ${response.status}`);
+    }
+    const body = (await response.json());
+    if (body.code !== 0 || !body.data) {
+        throw new Error(`fetchClientParams failed: code=${body.code}`);
+    }
+    return {
+        appKey: body.data.appKey || 'A40CB4D42E28F808',
+        vipAppId: body.data.appId || '7029803307044000000',
+        vipGroup: body.data.vipGroup || 'group_artflo',
+    };
+}

package/dist/src/core/config/fetch-vip-info.js

@@ -0,0 +1,30 @@
+/**
+ * Fetch user VIP / subscription status from the Artflo subscription API.
+ */
+export async function fetchVipInfo(config) {
+    const url = new URL(`${config.vipApiBaseUrl}/h5/user/vip_info_by_group.json`);
+    url.searchParams.set('app_id', config.vipAppId);
+    url.searchParams.set('vip_group', config.vipGroup);
+    const response = await fetch(url.toString(), {
+        method: 'GET',
+        headers: {
+            'X-API-Key': config.apiKey,
+            'app_id': config.vipAppId,
+            'country_code': config.countryCode,
+            'platform': '4',
+            'system_type': '2',
+        },
+    });
+    if (!response.ok) {
+        return { isVip: false, membershipLevel: 'Free', membershipName: 'Free' };
+    }
+    const body = (await response.json());
+    if (body.code !== 0 || !body.data) {
+        return { isVip: false, membershipLevel: 'Free', membershipName: 'Free' };
+    }
+    return {
+        isVip: body.data.is_vip === true || body.data.use_vip === true,
+        membershipLevel: body.data.membership?.level_name ?? 'Free',
+        membershipName: body.data.membership?.display_name ?? 'Free',
+    };
+}

package/dist/src/core/config/model-config-transformer.js

@@ -0,0 +1,104 @@
+/**
+ * Transform raw canvas_config from WebSocket join:success into an
+ * LLM-friendly summary that OpenClaw agents can use for planning.
+ *
+ * Adapted from artflo-agent-v2/src/workflow-agent/planning/model-config-transformer.ts
+ */
+// ---------------------------------------------------------------------------
+// Internal mappings
+// ---------------------------------------------------------------------------
+const CATEGORY_INFO = {
+    1: { name: 'Text2Image', description: '根据文本描述生成图片', configKey: 'text_to_image_model' },
+    2: { name: 'Image2Image', description: '基于输入图片和文本提示生成新图片', configKey: 'image_to_image_model' },
+    3: { name: 'Text2Video', description: '根据文本描述生成视频', configKey: 'text_to_video_model' },
+    4: { name: 'Image2Video', description: '基于输入图片生成视频', configKey: 'image_to_video_model' },
+    8: { name: 'Image23D', description: '从图片生成 3D 模型', configKey: 'image_to_3d_model' },
+};
+const MODEL_DESCRIPTIONS = {
+    PralineV2: '旗舰级画质，细节表现力极强，各种场景下均可选',
+    'GummyV4.5': '海报可选',
+    Gummy: '海报可选',
+    'GummyV3.1': '海报首选',
+    Truffle: '业界顶尖的艺术审美，电影级构图与质感，高质量艺术图片可选',
+    'FudgeV-Z': '高质量亚洲人像摄影可选',
+    Lollipop: '顶级的平面设计与排版能力，Logo设计首选，英文海报可选',
+};
+const OUTPUT_TOOL_DESCRIPTIONS = {
+    5: '移除图片背景，生成透明背景图',
+    6: '将视频转换为 GIF 动图',
+    10: '提升图片分辨率和清晰度',
+};
+// ---------------------------------------------------------------------------
+// Transform helpers
+// ---------------------------------------------------------------------------
+function transformModelItem(model, isVip) {
+    const available = !model.disable &&
+        (!model.subscribe_available ||
+            (model.subscribe_available && isVip) ||
+            model.is_free_limit);
+    const item = {
+        key: model.model_key,
+        name: model.model_name,
+        description: MODEL_DESCRIPTIONS[model.model_key] ?? '',
+        isDefault: model.is_default,
+        available,
+        requiresSubscription: model.subscribe_available,
+        isFreeLimit: model.is_free_limit,
+    };
+    if (model.support_ratio?.length)
+        item.supportedRatios = model.support_ratio;
+    if (model.support_resolution?.length)
+        item.supportedResolutions = model.support_resolution;
+    if (model.default_resolution)
+        item.defaultResolution = model.default_resolution;
+    if (model.support_duration?.length)
+        item.supportedDurations = model.support_duration;
+    if (model.support_image_count > 0)
+        item.maxImageCount = model.support_image_count;
+    if (model.video_sound_configs?.length) {
+        item.soundOptions = model.video_sound_configs.map((c) => c.key);
+    }
+    if (model.generate_3d_type_configs?.length) {
+        item.generate3dTypes = model.generate_3d_type_configs.map((c) => c.key);
+    }
+    return item;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export function transformCanvasConfig(config, isVip) {
+    const categories = [];
+    for (const [toolTypeStr, info] of Object.entries(CATEGORY_INFO)) {
+        const toolType = Number(toolTypeStr);
+        const models = config[info.configKey];
+        if (!Array.isArray(models) || models.length === 0)
+            continue;
+        const transformed = models.map((m) => transformModelItem(m, isVip));
+        if (transformed.some((m) => m.available)) {
+            categories.push({
+                name: info.name,
+                description: info.description,
+                toolType,
+                models: transformed,
+            });
+        }
+    }
+    const outputTools = [];
+    if (Array.isArray(config.output_tools)) {
+        for (const tool of config.output_tools) {
+            outputTools.push({
+                toolType: tool.tool_type,
+                name: tool.name,
+                description: OUTPUT_TOOL_DESCRIPTIONS[tool.tool_type] ?? tool.name,
+                isFreeLimit: tool.is_free_limit,
+            });
+        }
+    }
+    const promptRefineCategories = [];
+    if (Array.isArray(config.prompt_refine_category)) {
+        for (const cat of config.prompt_refine_category) {
+            promptRefineCategories.push({ key: cat.key, name: cat.name, model: cat.model });
+        }
+    }
+    return { categories, outputTools, promptRefineCategories };
+}

package/dist/src/core/executor/element-builders.js

@@ -0,0 +1,216 @@
+import { calculateSmartPositions } from '../layout/layout-service.js';
+export const CANVAS_NODE_TYPES = {
+    EDGE: 100000,
+    INPUT: 110000,
+    IMAGE: 110001,
+    VIDEO: 110004,
+    RESULT: 110005,
+    SELECTOR: 110006,
+    PROCESS: 130000,
+    REFINE: 130500,
+    CROP: 190000,
+};
+function cloneData(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+export function buildNodeElement(args) {
+    const { id, node, sourceNodeId, canvasElements, positionOverride, planId } = args;
+    let canvasType = CANVAS_NODE_TYPES.PROCESS;
+    const elementData = cloneData((node.data || {}));
+    switch (node.type) {
+        case 'input':
+            canvasType = CANVAS_NODE_TYPES.INPUT;
+            elementData.prompt = elementData.prompt || '';
+            // If sources contains URLs (from LLM plan), convert them to medias format.
+            // Input node medias is a key-value map: { "handle_id": { url, name, type, ... } }
+            if (Array.isArray(elementData.sources) &&
+                elementData.sources.length > 0 &&
+                typeof elementData.sources[0] === 'string' &&
+                elementData.sources[0].startsWith('http')) {
+                const sourceUrls = elementData.sources;
+                const mediasMap = {};
+                for (const url of sourceUrls) {
+                    const id = crypto.randomUUID();
+                    mediasMap[id] = {
+                        id,
+                        url,
+                        name: 'image',
+                        type: 'image',
+                        width: 1024,
+                        height: 1024,
+                    };
+                }
+                elementData.medias = mediasMap;
+                elementData.sources = 'image';
+            }
+            else {
+                elementData.medias = elementData.medias || {};
+                elementData.sources = elementData.sources || 'image';
+            }
+            break;
+        case 'process':
+            canvasType = CANVAS_NODE_TYPES.PROCESS;
+            elementData.tool_type = elementData.tool_type ?? 1;
+            elementData.status = elementData.status ?? 0;
+            elementData.show_execute = elementData.show_execute ?? true;
+            elementData.planning = false;
+            elementData.executed = false;
+            elementData.count = elementData.count ?? 1;
+            if (elementData.model && !elementData.current_model) {
+                elementData.current_model = elementData.model;
+                delete elementData.model;
+            }
+            elementData.output_type =
+                elementData.output_type ?? getOutputType(Number(elementData.tool_type ?? 1));
+            {
+                const toolType = Number(elementData.tool_type ?? 1);
+                const isVideoToolType = toolType === 3 || toolType === 4;
+                if (isVideoToolType) {
+                    const hasExplicitRatio = typeof elementData.ratio === 'string' &&
+                        elementData.ratio !== '' &&
+                        elementData.ratio !== 'auto';
+                    elementData.ratio = hasExplicitRatio ? elementData.ratio : '16:9';
+                    elementData.resolution = elementData.resolution ?? '1K';
+                }
+                else {
+                    elementData.ratio = elementData.ratio ?? 'auto';
+                    elementData.resolution = elementData.resolution ?? '2K';
+                }
+            }
+            if (sourceNodeId) {
+                const sourceElement = canvasElements.find((element) => element.id === sourceNodeId);
+                const sourceData = sourceElement?.data;
+                if (sourceElement?.type === CANVAS_NODE_TYPES.INPUT && typeof sourceData?.prompt === 'string') {
+                    elementData.prompt = sourceData.prompt;
+                }
+            }
+            if (!elementData.medias ||
+                (Array.isArray(elementData.medias) && elementData.medias.length === 0) ||
+                (typeof elementData.medias === 'object' &&
+                    !Array.isArray(elementData.medias) &&
+                    Object.keys(elementData.medias).length === 0)) {
+                let mediaType = 'image';
+                const toolType = Number(elementData.tool_type ?? 1);
+                if (toolType === 3 || toolType === 4) {
+                    mediaType = 'video';
+                }
+                else if (toolType === 8) {
+                    mediaType = '3d';
+                }
+                elementData.medias = [
+                    {
+                        id: crypto.randomUUID(),
+                        url: '',
+                        name: mediaType,
+                        type: mediaType,
+                        width: 1024,
+                        height: 1024,
+                    },
+                ];
+            }
+            break;
+        case 'refine':
+            canvasType = CANVAS_NODE_TYPES.REFINE;
+            elementData.status = elementData.status ?? 0;
+            elementData.show_execute = elementData.show_execute ?? true;
+            elementData.current_model =
+                elementData.model || elementData.current_model || 'gemini-2.5-flash-preview';
+            if (elementData.promptCategory) {
+                elementData.prompt_category = elementData.promptCategory;
+                delete elementData.promptCategory;
+            }
+            if (elementData.splitMode !== undefined) {
+                elementData.split_mode = elementData.splitMode;
+                delete elementData.splitMode;
+            }
+            if (elementData.customPrompt) {
+                elementData.custom_prompt = elementData.customPrompt;
+                delete elementData.customPrompt;
+            }
+            elementData.separator = elementData.separator ?? '#@';
+            break;
+        case 'selector':
+            canvasType = CANVAS_NODE_TYPES.SELECTOR;
+            elementData.medias = elementData.medias || {};
+            elementData.selectedId = elementData.selectedId || '';
+            break;
+        case 'crop':
+            canvasType = CANVAS_NODE_TYPES.CROP;
+            elementData.status = elementData.status ?? 0;
+            elementData.cropMode = elementData.cropMode ?? 5;
+            break;
+        case 'image':
+            canvasType = CANVAS_NODE_TYPES.IMAGE;
+            elementData.width = elementData.width ?? 512;
+            elementData.height = elementData.height ?? 512;
+            break;
+        case 'video':
+            canvasType = CANVAS_NODE_TYPES.VIDEO;
+            elementData.width = elementData.width ?? 512;
+            elementData.height = elementData.height ?? 512;
+            break;
+        case 'batch':
+            canvasType = CANVAS_NODE_TYPES.PROCESS;
+            elementData.tool_type = elementData.tool_type ?? 1;
+            break;
+    }
+    const layoutResult = positionOverride
+        ? null
+        : calculateSmartPositions({
+            canvasElements,
+            sourceNodeId,
+            nodeType: node.type === 'input'
+                ? 'input'
+                : node.type === 'selector' || node.type === 'image' || node.type === 'video'
+                    ? 'result'
+                    : 'process',
+            count: 1,
+        });
+    const position = positionOverride ||
+        layoutResult?.positions[0] || { x: 100, y: 100 };
+    return {
+        id,
+        type: canvasType,
+        index: 'a0',
+        position,
+        data: {
+            ...elementData,
+            plan_ref: typeof elementData.plan_ref === 'string' ? elementData.plan_ref : node.ref,
+            plan_type: typeof elementData.plan_type === 'string' ? elementData.plan_type : node.type,
+            ...(planId ? { plan_id: planId } : {}),
+        },
+        __layoutDebug: layoutResult
+            ? {
+                strategy: layoutResult.strategy,
+            }
+            : {
+                strategy: 'plan-flow-override',
+            },
+    };
+}
+function getOutputType(toolType) {
+    if (toolType === 3 || toolType === 4) {
+        return 1;
+    }
+    if (toolType === 8) {
+        return 3;
+    }
+    return 0;
+}
+export function buildEdgeElement(args) {
+    const { id, edge, sourceId, targetId } = args;
+    return {
+        id,
+        type: CANVAS_NODE_TYPES.EDGE,
+        index: 'a0',
+        source: sourceId,
+        sourceHandle: edge.fromHandle,
+        target: targetId,
+        targetHandle: edge.toHandle,
+        data: {
+            ref: edge.ref || `${edge.from}-${edge.to}`,
+            fromRef: edge.from,
+            toRef: edge.to,
+        },
+    };
+}