rol-websocket-channel 1.4.2 → 1.4.8

package/dist/src/admin/methods/artifacts.js

@@ -1,642 +1,736 @@
-import { createHash } from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { ensureDir, pathExists, readJsonFile } from '../lib/fs.js';
-import { ensureInside } from '../lib/paths.js';
-import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
-const INLINE_CONTENT_LIMIT_BYTES = 10 * 1024 * 1024;
-const MIN_ARTIFACT_SIZE_BYTES = 1;
-const ARTIFACT_MANIFEST_FILE = 'artifacts.json';
-const IGNORE_EXTENSIONS = new Set(['.tmp', '.part', '.crdownload']);
-const IGNORE_FILE_NAMES = new Set(['.ds_store', 'thumbs.db', ARTIFACT_MANIFEST_FILE]);
-const IGNORE_DIRECTORY_NAMES = new Set([
-    '.git',
-    '.cache',
-    'cache',
-    'caches',
-    'tmp',
-    'temp',
-    'logs',
-    'log',
-    'node_modules',
-    'sessions',
-    'session',
-    'history'
-]);
-const CATEGORY_BY_EXTENSION = {
-    '.png': 'image',
-    '.jpg': 'image',
-    '.jpeg': 'image',
-    '.webp': 'image',
-    '.gif': 'image',
-    '.svg': 'image',
-    '.mp4': 'video',
-    '.mov': 'video',
-    '.webm': 'video',
-    '.avi': 'video',
-    '.mkv': 'video',
-    '.m4v': 'video',
-    '.pdf': 'document',
-    '.doc': 'document',
-    '.docx': 'document',
-    '.zip': 'archive',
-    '.7z': 'archive',
-    '.tar': 'archive',
-    '.gz': 'archive',
-    '.rar': 'archive'
-};
-const MIME_BY_EXTENSION = {
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.webp': 'image/webp',
-    '.gif': 'image/gif',
-    '.svg': 'image/svg+xml',
-    '.mp4': 'video/mp4',
-    '.mov': 'video/quicktime',
-    '.webm': 'video/webm',
-    '.avi': 'video/x-msvideo',
-    '.mkv': 'video/x-matroska',
-    '.m4v': 'video/x-m4v',
-    '.pdf': 'application/pdf',
-    '.doc': 'application/msword',
-    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    '.zip': 'application/zip',
-    '.7z': 'application/x-7z-compressed',
-    '.tar': 'application/x-tar',
-    '.gz': 'application/gzip',
-    '.rar': 'application/vnd.rar'
-};
-export const listArtifacts = async (params, context) => {
-    const objectParams = expectOptionalObject(params);
-    const refresh = objectParams.refresh !== false;
-    const manifest = refresh
-        ? await refreshArtifactManifest(context)
-        : await readOrRefreshArtifactManifest(context);
-    return {
-        scope: 'workspace',
-        count: manifest.items.length,
-        manifestPath: manifest.manifestPath,
-        workspaceRoot: manifest.workspacePaths.workspaceRoot,
-        items: manifest.items.map(artifactToJsonValue)
-    };
-};
-export const refreshArtifacts = async (params, context) => {
-    const objectParams = expectOptionalObject(params);
-    const manifest = await refreshArtifactManifest(context);
-    return {
-        ok: true,
-        scope: 'workspace',
-        count: manifest.items.length,
-        manifestPath: manifest.manifestPath,
-        workspaceRoot: manifest.workspacePaths.workspaceRoot,
-        items: manifest.items.map(artifactToJsonValue)
-    };
-};
-export const getArtifactContent = async (params, context) => {
-    const objectParams = expectObject(params);
-    const maxInlineBytes = normalizeMaxInlineBytes(objectParams.maxInlineBytes);
-    const artifact = await resolveArtifact(objectParams, context);
-    if (artifact.sizeBytes > maxInlineBytes) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Artifact is too large for inline transfer', {
-            artifactId: artifact.id,
-            sizeBytes: artifact.sizeBytes,
-            maxInlineBytes
-        });
-    }
-    const content = await fs.readFile(artifact.localPath);
-    return {
-        scope: 'workspace',
-        artifact: {
-            ...artifactToJsonValue(artifact),
-            contentBase64: content.toString('base64')
-        }
-    };
-};
-export const ensureArtifactUploaded = async (params, context) => {
-    const objectParams = expectObject(params);
-    const artifact = await resolveArtifact(objectParams, context);
-    if (artifact.storageStatus === 'uploaded' && artifact.fileUrl) {
-        return {
-            ok: true,
-            scope: 'workspace',
-            uploaded: false,
-            artifactId: artifact.id,
-            objectKey: artifact.objectKey ?? null,
-            downloadUrl: artifact.fileUrl,
-            item: artifactToJsonValue(artifact)
-        };
-    }
-    const endpointConfig = await resolveApiCoreBotEndpoint(context.openclawRoot, objectParams.baseUrl, objectParams.authToken);
-    const presignedPostBody = buildPresignedPostBody(objectParams.presignedPostBody, artifact);
-    const presignedResponse = await postJson(`${endpointConfig.baseUrl}/api-core-bot/front/s3/get-presigned-post`, presignedPostBody, endpointConfig.authToken);
-    const uploadTarget = resolvePresignedPostUploadTarget(presignedResponse);
-    await uploadArtifactToPresignedPost(uploadTarget, artifact);
-    const objectKey = uploadTarget.objectKey ?? artifact.objectKey ?? null;
-    const fileUrl = uploadTarget.fileUrl ?? artifact.fileUrl ?? buildPublicFileUrl(uploadTarget.uploadUrl, objectKey);
-    if (!fileUrl) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, 'Unable to determine uploaded artifact download URL', {
-            artifactId: artifact.id,
-            objectKey
-        });
-    }
-    const manifest = await readOrRefreshArtifactManifest(context);
-    const updated = await persistUploadedArtifact(manifest.manifestPath, manifest.items, artifact.id, {
-        objectKey,
-        fileUrl,
-        record: artifact.record
-    });
-    return {
-        ok: true,
-        scope: 'workspace',
-        uploaded: true,
-        artifactId: artifact.id,
-        objectKey,
-        downloadUrl: fileUrl,
-        item: artifactToJsonValue(updated)
-    };
-};
-export const getArtifactPresignedPost = async (params, context) => {
-    const objectParams = expectObject(params);
-    const body = isObject(objectParams.body) ? objectParams.body : null;
-    if (!body) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: body');
-    }
-    const endpointConfig = await resolveApiCoreBotEndpoint(context.openclawRoot, objectParams.baseUrl, objectParams.authToken);
-    const response = await postJson(`${endpointConfig.baseUrl}/api-core-bot/front/s3/get-presigned-post`, body, endpointConfig.authToken);
-    return {
-        ok: true,
-        endpoint: '/api-core-bot/front/s3/get-presigned-post',
-        data: response
-    };
-};
-export const createArtifactRecord = async (params, context) => {
-    const objectParams = expectObject(params);
-    const body = isObject(objectParams.body) ? objectParams.body : null;
-    if (!body) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: body');
-    }
-    const endpoint = expectString(objectParams.endpoint, 'endpoint');
-    if (!endpoint.startsWith('/api-core-bot/front/')) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'endpoint must start with /api-core-bot/front/');
-    }
-    const endpointConfig = await resolveApiCoreBotEndpoint(context.openclawRoot, objectParams.baseUrl, objectParams.authToken);
-    const response = await postJson(`${endpointConfig.baseUrl}${endpoint}`, body, endpointConfig.authToken);
-    return {
-        ok: true,
-        endpoint,
-        data: response
-    };
-};
-export const markArtifactUploaded = async (params, context) => {
-    const objectParams = expectObject(params);
-    const objectKey = optionalTrimmedString(objectParams.objectKey);
-    const fileUrl = optionalTrimmedString(objectParams.fileUrl);
-    if (!objectKey && !fileUrl) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'At least one of objectKey or fileUrl is required');
-    }
-    const manifest = await readOrRefreshArtifactManifest(context);
-    const artifact = findArtifact(manifest.items, objectParams);
-    if (!artifact) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Artifact not found', {
-            artifactId: objectParams.artifactId,
-            relativePath: objectParams.relativePath
-        });
-    }
-    const updated = await persistUploadedArtifact(manifest.manifestPath, manifest.items, artifact.id, {
-        objectKey: objectKey ?? artifact.objectKey ?? null,
-        fileUrl: fileUrl ?? artifact.fileUrl ?? null,
-        record: objectParams.record === undefined ? artifact.record : objectParams.record
-    });
-    return {
-        ok: true,
-        scope: 'workspace',
-        artifactId: artifact.id,
-        item: artifactToJsonValue(updated)
-    };
-};
-export function classifyArtifactCategory(fileName) {
-    const ext = path.extname(fileName).toLowerCase();
-    return CATEGORY_BY_EXTENSION[ext] ?? 'other';
-}
-export function shouldIgnoreArtifactFile(fileName) {
-    const normalized = fileName.trim().toLowerCase();
-    if (!normalized) {
-        return true;
-    }
-    if (normalized.startsWith('.')) {
-        return true;
-    }
-    if (IGNORE_FILE_NAMES.has(normalized)) {
-        return true;
-    }
-    const ext = path.extname(normalized);
-    return IGNORE_EXTENSIONS.has(ext);
-}
-async function refreshArtifactManifest(context) {
-    const workspacePaths = await ensureWorkspacePaths(context.openclawRoot);
-    const { workspaceRoot, manifestPath } = workspacePaths;
-    const existing = await readExistingManifest(manifestPath);
-    const existingByPath = new Map(existing.map((item) => [item.relativePath, item]));
-    const files = await collectArtifactFiles(workspaceRoot);
-    const items = [];
-    for (const fullPath of files) {
-        const stat = await fs.stat(fullPath);
-        if (!stat.isFile() || stat.size < MIN_ARTIFACT_SIZE_BYTES) {
-            continue;
-        }
-        const relativePath = path.relative(workspaceRoot, fullPath).replace(/\\/g, '/');
-        const existingItem = existingByPath.get(relativePath);
-        const fileName = path.basename(fullPath);
-        if (!shouldIncludeArtifactFile(fileName)) {
-            continue;
-        }
-        const ext = normalizeExtension(fileName);
-        const createdAt = normalizeTimestamp(stat.birthtime, stat.mtime);
-        const updatedAt = stat.mtime.toISOString();
-        items.push({
-            id: existingItem?.id ?? buildArtifactId(relativePath),
-            fileName,
-            relativePath,
-            localPath: fullPath,
-            category: classifyArtifactCategory(fileName),
-            mimeType: MIME_BY_EXTENSION[ext ?? ''] ?? 'application/octet-stream',
-            ext,
-            sizeBytes: stat.size,
-            storageStatus: existingItem?.storageStatus ?? 'local_only',
-            source: existingItem?.source ?? 'generated',
-            previewable: isPreviewableCategory(classifyArtifactCategory(fileName)),
-            createdAt: existingItem?.createdAt ?? createdAt,
-            updatedAt,
-            objectKey: existingItem?.objectKey ?? null,
-            fileUrl: existingItem?.fileUrl ?? null,
-            uploadedAt: existingItem?.uploadedAt ?? null,
-            record: existingItem?.record
-        });
-    }
-    items.sort((a, b) => a.fileName.localeCompare(b.fileName));
-    await writeArtifactManifest(manifestPath, items);
-    return { manifestPath, items, workspacePaths };
-}
-async function readOrRefreshArtifactManifest(context) {
-    const workspacePaths = await ensureWorkspacePaths(context.openclawRoot);
-    const { manifestPath } = workspacePaths;
-    if (!(await pathExists(manifestPath))) {
-        return await refreshArtifactManifest(context);
-    }
-    const items = await readExistingManifest(manifestPath);
-    return { manifestPath, items, workspacePaths };
-}
-async function readExistingManifest(manifestPath) {
-    if (!(await pathExists(manifestPath))) {
-        return [];
-    }
-    const parsed = await readJsonFile(manifestPath);
-    if (!Array.isArray(parsed)) {
-        return [];
-    }
-    const items = [];
-    for (const item of parsed) {
-        if (isArtifactRecord(item)) {
-            items.push(item);
-        }
-    }
-    return items;
-}
-async function writeArtifactManifest(manifestPath, items) {
-    await fs.writeFile(manifestPath, JSON.stringify(items.map((item) => artifactToJsonValue(item)), null, 2), 'utf8');
-}
-async function persistUploadedArtifact(manifestPath, items, artifactId, updates) {
-    const now = new Date().toISOString();
-    let updatedArtifact = null;
-    const updatedItems = items.map((item) => {
-        if (!isArtifactRecord(item) || item.id !== artifactId) {
-            return item;
-        }
-        updatedArtifact = {
-            ...item,
-            storageStatus: 'uploaded',
-            objectKey: updates.objectKey ?? item.objectKey ?? null,
-            fileUrl: updates.fileUrl ?? item.fileUrl ?? null,
-            uploadedAt: now,
-            updatedAt: now,
-            ...(updates.record === undefined ? {} : { record: updates.record })
-        };
-        return updatedArtifact;
-    });
-    await writeArtifactManifest(manifestPath, updatedItems);
-    if (!updatedArtifact) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, 'Artifact not found while persisting upload state', {
-            artifactId
-        });
-    }
-    return updatedArtifact;
-}
-async function collectArtifactFiles(rootDir) {
-    const files = [];
-    const entries = await fs.readdir(rootDir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.isDirectory() && shouldIgnoreArtifactDirectory(entry.name)) {
-            continue;
-        }
-        if (entry.isFile() && shouldIgnoreArtifactFile(entry.name)) {
-            continue;
-        }
-        const fullPath = path.join(rootDir, entry.name);
-        if (entry.isDirectory()) {
-            files.push(...await collectArtifactFiles(fullPath));
-            continue;
-        }
-        if (entry.isFile()) {
-            files.push(fullPath);
-        }
-    }
-    return files;
-}
-async function resolveArtifact(params, context) {
-    const manifest = await readOrRefreshArtifactManifest(context);
-    const artifact = findArtifact(manifest.items, params);
-    if (!artifact) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Artifact not found', {
-            artifactId: params.artifactId,
-            relativePath: params.relativePath
-        });
-    }
-    const checkedPath = ensureInside(manifest.workspacePaths.workspaceRoot, artifact.localPath);
-    if (!(await pathExists(checkedPath))) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Artifact file does not exist', {
-            localPath: checkedPath
-        });
-    }
-    return {
-        ...artifact,
-        localPath: checkedPath
-    };
-}
-function findArtifact(items, selector) {
-    const artifactId = optionalTrimmedString(selector.artifactId);
-    const relativePath = normalizeRelativePath(optionalTrimmedString(selector.relativePath));
-    if (!artifactId && !relativePath) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Either artifactId or relativePath is required');
-    }
-    return items.find((item) => {
-        if (artifactId && item.id === artifactId) {
-            return true;
-        }
-        return Boolean(relativePath && item.relativePath === relativePath);
-    }) ?? null;
-}
-function resolveWorkspaceRoot(openclawRoot) {
-    const workspaceRoot = path.join(openclawRoot, 'workspace');
-    return ensureInside(openclawRoot, workspaceRoot);
-}
-async function ensureWorkspacePaths(openclawRoot) {
-    const workspaceRoot = resolveWorkspaceRoot(openclawRoot);
-    const manifestPath = ensureInside(workspaceRoot, path.join(workspaceRoot, ARTIFACT_MANIFEST_FILE));
-    await ensureDir(workspaceRoot);
-    return {
-        workspaceRoot,
-        manifestPath
-    };
-}
-function buildArtifactId(relativePath) {
-    return `art_${createHash('sha1').update(relativePath).digest('hex').slice(0, 12)}`;
-}
-function normalizeExtension(fileName) {
-    const ext = path.extname(fileName).toLowerCase();
-    return ext || null;
-}
-function normalizeRelativePath(value) {
-    if (!value) {
-        return null;
-    }
-    return value.replace(/\\/g, '/').replace(/^\/+/, '');
-}
-function normalizeTimestamp(created, fallback) {
-    return Number.isNaN(created.getTime()) ? fallback.toISOString() : created.toISOString();
-}
-function normalizeMaxInlineBytes(value) {
-    if (value === undefined) {
-        return INLINE_CONTENT_LIMIT_BYTES;
-    }
-    if (!Number.isFinite(value) || value <= 0) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'maxInlineBytes must be a positive number');
-    }
-    return Math.floor(value);
-}
-function isPreviewableCategory(category) {
-    return category === 'image' || category === 'video' || category === 'document';
-}
-function shouldIgnoreArtifactDirectory(dirName) {
-    const normalized = dirName.trim().toLowerCase();
-    return !normalized || normalized.startsWith('.') || IGNORE_DIRECTORY_NAMES.has(normalized);
-}
-function shouldIncludeArtifactFile(fileName) {
-    if (shouldIgnoreArtifactFile(fileName)) {
-        return false;
-    }
-    return classifyArtifactCategory(fileName) !== 'other';
-}
-function isArtifactRecord(value) {
-    if (!value || Array.isArray(value) || typeof value !== 'object') {
-        return false;
-    }
-    const objectValue = value;
-    return (typeof objectValue.id === 'string' &&
-        typeof objectValue.fileName === 'string' &&
-        typeof objectValue.relativePath === 'string' &&
-        typeof objectValue.localPath === 'string');
-}
-function artifactToJsonValue(item) {
-    return {
-        id: item.id,
-        fileName: item.fileName,
-        relativePath: item.relativePath,
-        localPath: item.localPath,
-        category: item.category,
-        mimeType: item.mimeType,
-        ext: item.ext,
-        sizeBytes: item.sizeBytes,
-        storageStatus: item.storageStatus,
-        source: item.source,
-        previewable: item.previewable,
-        createdAt: item.createdAt,
-        updatedAt: item.updatedAt,
-        objectKey: item.objectKey ?? null,
-        fileUrl: item.fileUrl ?? null,
-        uploadedAt: item.uploadedAt ?? null,
-        record: item.record ?? null
-    };
-}
-function expectObject(value) {
-    if (!value || Array.isArray(value) || typeof value !== 'object') {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Params must be an object');
-    }
-    return value;
-}
-function expectOptionalObject(value) {
-    if (value === undefined) {
-        return {};
-    }
-    return expectObject(value);
-}
-function buildPresignedPostBody(providedBody, artifact) {
-    const body = isObject(providedBody) ? { ...providedBody } : {};
-    if (body.filename === undefined) {
-        body.filename = artifact.fileName;
-    }
-    return body;
-}
-function expectString(value, fieldName) {
-    if (typeof value !== 'string' || value.trim().length === 0) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Field '${fieldName}' must be a non-empty string`);
-    }
-    return value.trim();
-}
-function optionalTrimmedString(value) {
-    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
-}
-function isObject(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-async function resolveApiCoreBotEndpoint(openclawRoot, overrideBaseUrl, overrideAuthToken) {
-    const config = await readJsonFile(path.join(openclawRoot, 'openclaw.json'));
-    const pluginConfig = config.plugins?.entries?.['rol-websocket-channel']?.config?.apiCoreBot ?? {};
-    const baseUrl = (overrideBaseUrl && overrideBaseUrl.trim()) || pluginConfig.baseUrl;
-    if (!baseUrl || !baseUrl.trim()) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'apiCoreBot.baseUrl is not configured');
-    }
-    const authToken = (overrideAuthToken && overrideAuthToken.trim()) || pluginConfig.authToken;
-    return {
-        baseUrl: baseUrl.replace(/\/+$/, ''),
-        authToken
-    };
-}
-async function postJson(url, body, authToken) {
-    const headers = {
-        'Content-Type': 'application/json'
-    };
-    if (authToken && authToken.trim()) {
-        headers.Authorization = `Bearer ${authToken.trim()}`;
-    }
-    const response = await fetch(url, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(body)
-    });
-    const payload = await response.json().catch(async () => await response.text());
-    if (!response.ok) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, `Request failed: ${response.status}`, {
-            url,
-            status: response.status,
-            payload
-        });
-    }
-    if (isObject(payload) && payload.success === false) {
-        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, pickStringValue(payload, ['message', 'msg']) ?? 'Request failed', {
-            url,
-            payload
-        });
-    }
-    return payload;
-}
-function resolvePresignedPostUploadTarget(payload) {
-    for (const candidate of collectPresignedPostCandidates(payload)) {
-        const uploadUrl = pickStringValue(candidate, ['url', 'uploadUrl', 'postUrl', 'presignedPostUrl']);
-        const rawFields = candidate.fields ?? candidate.formData ?? candidate.form ?? candidate.params;
-        const fields = toStringRecord(rawFields);
-        if (!uploadUrl || !fields) {
-            continue;
-        }
-        return {
-            uploadUrl,
-            fields,
-            objectKey: pickStringValue(candidate, ['objectKey', 'fileKey', 'file_key', 'source_file_key', 'key']) ?? fields.key ?? null,
-            fileUrl: pickStringValue(candidate, ['fileUrl', 'file_url', 'downloadUrl', 'source_file_url', 'location']) ?? null
-        };
-    }
-    throw new JsonRpcException(JSON_RPC_ERRORS.internalError, 'Presigned post response is missing upload url or fields', { payload });
-}
-function collectPresignedPostCandidates(payload) {
-    const candidates = [];
-    const queue = [payload];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (!isObject(current)) {
-            continue;
-        }
-        candidates.push(current);
-        for (const key of ['data', 'result', 'presignedPost']) {
-            const nested = current[key];
-            if (isObject(nested)) {
-                queue.push(nested);
-            }
-        }
-    }
-    return candidates;
-}
-function pickStringValue(source, keys) {
-    for (const key of keys) {
-        const value = source[key];
-        if (typeof value === 'string' && value.trim().length > 0) {
-            return value.trim();
-        }
-    }
-    return null;
-}
-function toStringRecord(value) {
-    if (!isObject(value)) {
-        return null;
-    }
-    const result = {};
-    for (const [key, item] of Object.entries(value)) {
-        if (item === null) {
-            continue;
-        }
-        if (typeof item === 'string') {
-            result[key] = item;
-            continue;
-        }
-        if (typeof item === 'number' || typeof item === 'boolean') {
-            result[key] = String(item);
-            continue;
-        }
-        return null;
-    }
-    return result;
-}
-async function uploadArtifactToPresignedPost(target, artifact) {
-    const formData = new FormData();
-    for (const [key, value] of Object.entries(target.fields)) {
-        formData.append(key, value);
-    }
-    const content = await fs.readFile(artifact.localPath);
-    formData.append('file', new Blob([content], { type: artifact.mimeType }), artifact.fileName);
-    const response = await fetch(target.uploadUrl, {
-        method: 'POST',
-        body: formData
-    });
-    if (!response.ok) {
-        const payload = await response.text().catch(() => '');
-        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, `Artifact upload failed: ${response.status}`, {
-            url: target.uploadUrl,
-            status: response.status,
-            payload
-        });
-    }
-}
-function buildPublicFileUrl(uploadUrl, objectKey) {
-    if (!objectKey) {
-        return null;
-    }
-    try {
-        const url = new URL(uploadUrl);
-        url.pathname = `${url.pathname.replace(/\/+$/, '')}/${objectKey.replace(/^\/+/, '')}`;
-        url.search = '';
-        url.hash = '';
-        return url.toString();
-    }
-    catch {
-        return null;
-    }
-}
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir, pathExists, readJsonFile } from '../lib/fs.js';
+import { ensureInside } from '../lib/paths.js';
+import { JsonRpcException, JSON_RPC_ERRORS } from '../jsonrpc.js';
+const INLINE_CONTENT_LIMIT_BYTES = 10 * 1024 * 1024;
+const MIN_ARTIFACT_SIZE_BYTES = 1;
+const ARTIFACT_MANIFEST_FILE = 'artifacts.json';
+const MARKDOWN_SCAN_STATE_FILE = 'md-scan-state.json';
+const PLUGIN_WORKSPACE_STATE_DIR = path.join('.openclaw', 'rol-websocket-channel');
+const IGNORE_EXTENSIONS = new Set(['.tmp', '.part', '.crdownload']);
+const IGNORE_FILE_NAMES = new Set(['.ds_store', 'thumbs.db', ARTIFACT_MANIFEST_FILE]);
+const IGNORE_MARKDOWN_FILE_NAMES = new Set([
+    'agents.md',
+    'heartbeat.md',
+    'identity.md',
+    'memory.md',
+    'soul.md',
+    'tools.md',
+    'user.md'
+]);
+const IGNORE_DIRECTORY_NAMES = new Set([
+    '.git',
+    '.cache',
+    'cache',
+    'caches',
+    'tmp',
+    'temp',
+    'logs',
+    'log',
+    'node_modules',
+    'sessions',
+    'session',
+    'history'
+]);
+const CATEGORY_BY_EXTENSION = {
+    '.png': 'image',
+    '.jpg': 'image',
+    '.jpeg': 'image',
+    '.webp': 'image',
+    '.gif': 'image',
+    '.svg': 'image',
+    '.mp4': 'video',
+    '.mov': 'video',
+    '.webm': 'video',
+    '.avi': 'video',
+    '.mkv': 'video',
+    '.m4v': 'video',
+    '.pdf': 'document',
+    '.doc': 'document',
+    '.docx': 'document',
+    '.md': 'document',
+    '.zip': 'archive',
+    '.7z': 'archive',
+    '.tar': 'archive',
+    '.gz': 'archive',
+    '.rar': 'archive'
+};
+const MIME_BY_EXTENSION = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.mp4': 'video/mp4',
+    '.mov': 'video/quicktime',
+    '.webm': 'video/webm',
+    '.avi': 'video/x-msvideo',
+    '.mkv': 'video/x-matroska',
+    '.m4v': 'video/x-m4v',
+    '.pdf': 'application/pdf',
+    '.doc': 'application/msword',
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.md': 'text/markdown',
+    '.zip': 'application/zip',
+    '.7z': 'application/x-7z-compressed',
+    '.tar': 'application/x-tar',
+    '.gz': 'application/gzip',
+    '.rar': 'application/vnd.rar'
+};
+export const listArtifacts = async (params, context) => {
+    const objectParams = expectOptionalObject(params);
+    const refresh = objectParams.refresh !== false;
+    const manifest = refresh
+        ? await refreshArtifactManifest(context)
+        : await readOrRefreshArtifactManifest(context);
+    return {
+        scope: 'workspace',
+        count: manifest.items.length,
+        manifestPath: manifest.manifestPath,
+        workspaceRoot: manifest.workspacePaths.workspaceRoot,
+        items: manifest.items.map(artifactToJsonValue)
+    };
+};
+export const refreshArtifacts = async (params, context) => {
+    const objectParams = expectOptionalObject(params);
+    const manifest = await refreshArtifactManifest(context);
+    return {
+        ok: true,
+        scope: 'workspace',
+        count: manifest.items.length,
+        manifestPath: manifest.manifestPath,
+        workspaceRoot: manifest.workspacePaths.workspaceRoot,
+        items: manifest.items.map(artifactToJsonValue)
+    };
+};
+export const getArtifactContent = async (params, context) => {
+    const objectParams = expectObject(params);
+    const maxInlineBytes = normalizeMaxInlineBytes(objectParams.maxInlineBytes);
+    const artifact = await resolveArtifact(objectParams, context);
+    if (artifact.sizeBytes > maxInlineBytes) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Artifact is too large for inline transfer', {
+            artifactId: artifact.id,
+            sizeBytes: artifact.sizeBytes,
+            maxInlineBytes
+        });
+    }
+    const content = await fs.readFile(artifact.localPath);
+    return {
+        scope: 'workspace',
+        artifact: {
+            ...artifactToJsonValue(artifact),
+            contentBase64: content.toString('base64')
+        }
+    };
+};
+export const ensureArtifactUploaded = async (params, context) => {
+    const objectParams = expectObject(params);
+    const artifact = await resolveArtifact(objectParams, context);
+    if (artifact.storageStatus === 'uploaded' && artifact.fileUrl) {
+        return {
+            ok: true,
+            scope: 'workspace',
+            uploaded: false,
+            artifactId: artifact.id,
+            objectKey: artifact.objectKey ?? null,
+            downloadUrl: artifact.fileUrl,
+            item: artifactToJsonValue(artifact)
+        };
+    }
+    const endpointConfig = await resolveApiCoreBotEndpoint(context.openclawRoot, objectParams.baseUrl, objectParams.authToken);
+    const presignedPostBody = buildPresignedPostBody(objectParams.presignedPostBody, artifact);
+    const presignedResponse = await postJson(`${endpointConfig.baseUrl}/api-core-bot/front/s3/get-presigned-post`, presignedPostBody, endpointConfig.authToken);
+    const uploadTarget = resolvePresignedPostUploadTarget(presignedResponse);
+    await uploadArtifactToPresignedPost(uploadTarget, artifact);
+    const objectKey = uploadTarget.objectKey ?? artifact.objectKey ?? null;
+    const fileUrl = uploadTarget.fileUrl ?? artifact.fileUrl ?? buildPublicFileUrl(uploadTarget.uploadUrl, objectKey);
+    if (!fileUrl) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, 'Unable to determine uploaded artifact download URL', {
+            artifactId: artifact.id,
+            objectKey
+        });
+    }
+    const manifest = await readOrRefreshArtifactManifest(context);
+    const updated = await persistUploadedArtifact(manifest.manifestPath, manifest.items, artifact.id, {
+        objectKey,
+        fileUrl,
+        record: artifact.record
+    });
+    return {
+        ok: true,
+        scope: 'workspace',
+        uploaded: true,
+        artifactId: artifact.id,
+        objectKey,
+        downloadUrl: fileUrl,
+        item: artifactToJsonValue(updated)
+    };
+};
+export const getArtifactPresignedPost = async (params, context) => {
+    const objectParams = expectObject(params);
+    const body = isObject(objectParams.body) ? objectParams.body : null;
+    if (!body) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: body');
+    }
+    const endpointConfig = await resolveApiCoreBotEndpoint(context.openclawRoot, objectParams.baseUrl, objectParams.authToken);
+    const response = await postJson(`${endpointConfig.baseUrl}/api-core-bot/front/s3/get-presigned-post`, body, endpointConfig.authToken);
+    return {
+        ok: true,
+        endpoint: '/api-core-bot/front/s3/get-presigned-post',
+        data: response
+    };
+};
+export const createArtifactRecord = async (params, context) => {
+    const objectParams = expectObject(params);
+    const body = isObject(objectParams.body) ? objectParams.body : null;
+    if (!body) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Missing required parameter: body');
+    }
+    const endpoint = expectString(objectParams.endpoint, 'endpoint');
+    if (!endpoint.startsWith('/api-core-bot/front/')) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'endpoint must start with /api-core-bot/front/');
+    }
+    const endpointConfig = await resolveApiCoreBotEndpoint(context.openclawRoot, objectParams.baseUrl, objectParams.authToken);
+    const response = await postJson(`${endpointConfig.baseUrl}${endpoint}`, body, endpointConfig.authToken);
+    return {
+        ok: true,
+        endpoint,
+        data: response
+    };
+};
+export const markArtifactUploaded = async (params, context) => {
+    const objectParams = expectObject(params);
+    const objectKey = optionalTrimmedString(objectParams.objectKey);
+    const fileUrl = optionalTrimmedString(objectParams.fileUrl);
+    if (!objectKey && !fileUrl) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'At least one of objectKey or fileUrl is required');
+    }
+    const manifest = await readOrRefreshArtifactManifest(context);
+    const artifact = findArtifact(manifest.items, objectParams);
+    if (!artifact) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Artifact not found', {
+            artifactId: objectParams.artifactId,
+            relativePath: objectParams.relativePath
+        });
+    }
+    const updated = await persistUploadedArtifact(manifest.manifestPath, manifest.items, artifact.id, {
+        objectKey: objectKey ?? artifact.objectKey ?? null,
+        fileUrl: fileUrl ?? artifact.fileUrl ?? null,
+        record: objectParams.record === undefined ? artifact.record : objectParams.record
+    });
+    return {
+        ok: true,
+        scope: 'workspace',
+        artifactId: artifact.id,
+        item: artifactToJsonValue(updated)
+    };
+};
+export function classifyArtifactCategory(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    return CATEGORY_BY_EXTENSION[ext] ?? 'other';
+}
+export function shouldIgnoreArtifactFile(fileName) {
+    const normalized = fileName.trim().toLowerCase();
+    if (!normalized) {
+        return true;
+    }
+    if (normalized.startsWith('.')) {
+        return true;
+    }
+    if (IGNORE_FILE_NAMES.has(normalized)) {
+        return true;
+    }
+    const ext = path.extname(normalized);
+    return IGNORE_EXTENSIONS.has(ext);
+}
+async function refreshArtifactManifest(context) {
+    const workspacePaths = await ensureWorkspacePaths(context.openclawRoot);
+    const { workspaceRoot, manifestPath } = workspacePaths;
+    const existing = await readExistingManifest(manifestPath);
+    const existingByPath = new Map(existing.map((item) => [item.relativePath, item]));
+    const loadedMarkdownScanState = await readMarkdownScanState(workspacePaths.markdownScanStatePath);
+    const hadMarkdownScanState = loadedMarkdownScanState !== null;
+    const markdownScanState = loadedMarkdownScanState ?? createMarkdownScanState();
+    const files = await collectArtifactFiles(workspaceRoot);
+    const items = [];
+    for (const fullPath of files) {
+        const stat = await fs.stat(fullPath);
+        if (!stat.isFile() || stat.size < MIN_ARTIFACT_SIZE_BYTES) {
+            continue;
+        }
+        const relativePath = path.relative(workspaceRoot, fullPath).replace(/\\/g, '/');
+        const existingItem = existingByPath.get(relativePath);
+        const fileName = path.basename(fullPath);
+        const isMarkdown = isMarkdownArtifactFile(fileName);
+        if (isMarkdown) {
+            if (!shouldIncludeMarkdownArtifactFile(relativePath, fileName, stat, markdownScanState, hadMarkdownScanState)) {
+                continue;
+            }
+        }
+        else if (!shouldIncludeArtifactFile(fileName)) {
+            continue;
+        }
+        const ext = normalizeExtension(fileName);
+        const createdAt = normalizeTimestamp(stat.birthtime, stat.mtime);
+        const updatedAt = stat.mtime.toISOString();
+        items.push({
+            id: existingItem?.id ?? buildArtifactId(relativePath),
+            fileName,
+            relativePath,
+            localPath: fullPath,
+            category: classifyArtifactCategory(fileName),
+            mimeType: MIME_BY_EXTENSION[ext ?? ''] ?? 'application/octet-stream',
+            ext,
+            sizeBytes: stat.size,
+            storageStatus: existingItem?.storageStatus ?? 'local_only',
+            source: existingItem?.source ?? 'generated',
+            previewable: isPreviewableCategory(classifyArtifactCategory(fileName)),
+            createdAt: existingItem?.createdAt ?? createdAt,
+            updatedAt,
+            objectKey: existingItem?.objectKey ?? null,
+            fileUrl: existingItem?.fileUrl ?? null,
+            uploadedAt: existingItem?.uploadedAt ?? null,
+            record: existingItem?.record
+        });
+    }
+    items.sort((a, b) => a.fileName.localeCompare(b.fileName));
+    markdownScanState.lastScanAt = new Date().toISOString();
+    await writeMarkdownScanState(workspacePaths.markdownScanStatePath, markdownScanState);
+    await writeArtifactManifest(manifestPath, items);
+    return { manifestPath, items, workspacePaths };
+}
+async function readOrRefreshArtifactManifest(context) {
+    const workspacePaths = await ensureWorkspacePaths(context.openclawRoot);
+    const { manifestPath } = workspacePaths;
+    if (!(await pathExists(manifestPath))) {
+        return await refreshArtifactManifest(context);
+    }
+    const items = await readExistingManifest(manifestPath);
+    return { manifestPath, items, workspacePaths };
+}
+async function readExistingManifest(manifestPath) {
+    if (!(await pathExists(manifestPath))) {
+        return [];
+    }
+    const parsed = await readJsonFile(manifestPath);
+    if (!Array.isArray(parsed)) {
+        return [];
+    }
+    const items = [];
+    for (const item of parsed) {
+        if (isArtifactRecord(item)) {
+            items.push(item);
+        }
+    }
+    return items;
+}
+async function writeArtifactManifest(manifestPath, items) {
+    await fs.writeFile(manifestPath, JSON.stringify(items.map((item) => artifactToJsonValue(item)), null, 2), 'utf8');
+}
+async function readMarkdownScanState(statePath) {
+    if (!(await pathExists(statePath))) {
+        return null;
+    }
+    const parsed = await readJsonFile(statePath);
+    if (!isObject(parsed)) {
+        return null;
+    }
+    const files = {};
+    if (isObject(parsed.files)) {
+        for (const [relativePath, value] of Object.entries(parsed.files)) {
+            if (isMarkdownScanStateFile(value)) {
+                files[relativePath] = value;
+            }
+        }
+    }
+    return {
+        initializedAt: typeof parsed.initializedAt === 'string' ? parsed.initializedAt : new Date().toISOString(),
+        lastScanAt: typeof parsed.lastScanAt === 'string' ? parsed.lastScanAt : new Date().toISOString(),
+        files
+    };
+}
+async function writeMarkdownScanState(statePath, state) {
+    await ensureDir(path.dirname(statePath));
+    await fs.writeFile(statePath, JSON.stringify(state, null, 2), 'utf8');
+}
+async function persistUploadedArtifact(manifestPath, items, artifactId, updates) {
+    const now = new Date().toISOString();
+    let updatedArtifact = null;
+    const updatedItems = items.map((item) => {
+        if (!isArtifactRecord(item) || item.id !== artifactId) {
+            return item;
+        }
+        updatedArtifact = {
+            ...item,
+            storageStatus: 'uploaded',
+            objectKey: updates.objectKey ?? item.objectKey ?? null,
+            fileUrl: updates.fileUrl ?? item.fileUrl ?? null,
+            uploadedAt: now,
+            updatedAt: now,
+            ...(updates.record === undefined ? {} : { record: updates.record })
+        };
+        return updatedArtifact;
+    });
+    await writeArtifactManifest(manifestPath, updatedItems);
+    if (!updatedArtifact) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, 'Artifact not found while persisting upload state', {
+            artifactId
+        });
+    }
+    return updatedArtifact;
+}
+async function collectArtifactFiles(rootDir) {
+    const files = [];
+    const entries = await fs.readdir(rootDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && shouldIgnoreArtifactDirectory(entry.name)) {
+            continue;
+        }
+        if (entry.isFile() && shouldIgnoreArtifactFile(entry.name)) {
+            continue;
+        }
+        const fullPath = path.join(rootDir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...await collectArtifactFiles(fullPath));
+            continue;
+        }
+        if (entry.isFile()) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+async function resolveArtifact(params, context) {
+    const manifest = await readOrRefreshArtifactManifest(context);
+    const artifact = findArtifact(manifest.items, params);
+    if (!artifact) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Artifact not found', {
+            artifactId: params.artifactId,
+            relativePath: params.relativePath
+        });
+    }
+    const checkedPath = ensureInside(manifest.workspacePaths.workspaceRoot, artifact.localPath);
+    if (!(await pathExists(checkedPath))) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Artifact file does not exist', {
+            localPath: checkedPath
+        });
+    }
+    return {
+        ...artifact,
+        localPath: checkedPath
+    };
+}
+function findArtifact(items, selector) {
+    const artifactId = optionalTrimmedString(selector.artifactId);
+    const relativePath = normalizeRelativePath(optionalTrimmedString(selector.relativePath));
+    if (!artifactId && !relativePath) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Either artifactId or relativePath is required');
+    }
+    return items.find((item) => {
+        if (artifactId && item.id === artifactId) {
+            return true;
+        }
+        return Boolean(relativePath && item.relativePath === relativePath);
+    }) ?? null;
+}
+function resolveWorkspaceRoot(openclawRoot) {
+    const workspaceRoot = path.join(openclawRoot, 'workspace');
+    return ensureInside(openclawRoot, workspaceRoot);
+}
+async function ensureWorkspacePaths(openclawRoot) {
+    const workspaceRoot = resolveWorkspaceRoot(openclawRoot);
+    const manifestPath = ensureInside(workspaceRoot, path.join(workspaceRoot, ARTIFACT_MANIFEST_FILE));
+    const markdownScanStatePath = ensureInside(workspaceRoot, path.join(workspaceRoot, PLUGIN_WORKSPACE_STATE_DIR, MARKDOWN_SCAN_STATE_FILE));
+    await ensureDir(workspaceRoot);
+    return {
+        workspaceRoot,
+        manifestPath,
+        markdownScanStatePath
+    };
+}
+function createMarkdownScanState() {
+    const now = new Date().toISOString();
+    return {
+        initializedAt: now,
+        lastScanAt: now,
+        files: {}
+    };
+}
+function buildArtifactId(relativePath) {
+    return `art_${createHash('sha1').update(relativePath).digest('hex').slice(0, 12)}`;
+}
+function normalizeExtension(fileName) {
+    const ext = path.extname(fileName).toLowerCase();
+    return ext || null;
+}
+function isMarkdownArtifactFile(fileName) {
+    return path.extname(fileName).toLowerCase() === '.md';
+}
+function normalizeRelativePath(value) {
+    if (!value) {
+        return null;
+    }
+    return value.replace(/\\/g, '/').replace(/^\/+/, '');
+}
+function normalizeTimestamp(created, fallback) {
+    return Number.isNaN(created.getTime()) ? fallback.toISOString() : created.toISOString();
+}
+function normalizeMaxInlineBytes(value) {
+    if (value === undefined) {
+        return INLINE_CONTENT_LIMIT_BYTES;
+    }
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'maxInlineBytes must be a positive number');
+    }
+    return Math.floor(value);
+}
+function isPreviewableCategory(category) {
+    return category === 'image' || category === 'video' || category === 'document';
+}
+function shouldIgnoreArtifactDirectory(dirName) {
+    const normalized = dirName.trim().toLowerCase();
+    return !normalized || normalized.startsWith('.') || IGNORE_DIRECTORY_NAMES.has(normalized);
+}
+function shouldIncludeArtifactFile(fileName) {
+    if (shouldIgnoreArtifactFile(fileName)) {
+        return false;
+    }
+    return classifyArtifactCategory(fileName) !== 'other';
+}
+function shouldIncludeMarkdownArtifactFile(relativePath, fileName, stat, state, hadState) {
+    if (shouldIgnoreArtifactFile(fileName)) {
+        return false;
+    }
+    if (IGNORE_MARKDOWN_FILE_NAMES.has(fileName.trim().toLowerCase())) {
+        return false;
+    }
+    const existing = state.files[relativePath];
+    if (existing) {
+        existing.sizeBytes = stat.size;
+        existing.mtimeMs = stat.mtimeMs;
+        return !existing.baseline;
+    }
+    state.files[relativePath] = {
+        sizeBytes: stat.size,
+        mtimeMs: stat.mtimeMs,
+        firstSeenAt: new Date().toISOString(),
+        baseline: !hadState
+    };
+    return hadState;
+}
+function isMarkdownScanStateFile(value) {
+    if (!value || Array.isArray(value) || typeof value !== 'object') {
+        return false;
+    }
+    const objectValue = value;
+    return (typeof objectValue.sizeBytes === 'number' &&
+        typeof objectValue.mtimeMs === 'number' &&
+        typeof objectValue.firstSeenAt === 'string' &&
+        typeof objectValue.baseline === 'boolean');
+}
+function isArtifactRecord(value) {
+    if (!value || Array.isArray(value) || typeof value !== 'object') {
+        return false;
+    }
+    const objectValue = value;
+    return (typeof objectValue.id === 'string' &&
+        typeof objectValue.fileName === 'string' &&
+        typeof objectValue.relativePath === 'string' &&
+        typeof objectValue.localPath === 'string');
+}
+function artifactToJsonValue(item) {
+    return {
+        id: item.id,
+        fileName: item.fileName,
+        relativePath: item.relativePath,
+        localPath: item.localPath,
+        category: item.category,
+        mimeType: item.mimeType,
+        ext: item.ext,
+        sizeBytes: item.sizeBytes,
+        storageStatus: item.storageStatus,
+        source: item.source,
+        previewable: item.previewable,
+        createdAt: item.createdAt,
+        updatedAt: item.updatedAt,
+        objectKey: item.objectKey ?? null,
+        fileUrl: item.fileUrl ?? null,
+        uploadedAt: item.uploadedAt ?? null,
+        record: item.record ?? null
+    };
+}
+function expectObject(value) {
+    if (!value || Array.isArray(value) || typeof value !== 'object') {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'Params must be an object');
+    }
+    return value;
+}
+function expectOptionalObject(value) {
+    if (value === undefined) {
+        return {};
+    }
+    return expectObject(value);
+}
+function buildPresignedPostBody(providedBody, artifact) {
+    const body = isObject(providedBody) ? { ...providedBody } : {};
+    if (body.filename === undefined) {
+        body.filename = artifact.fileName;
+    }
+    return body;
+}
+function expectString(value, fieldName) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, `Field '${fieldName}' must be a non-empty string`);
+    }
+    return value.trim();
+}
+function optionalTrimmedString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+async function resolveApiCoreBotEndpoint(openclawRoot, overrideBaseUrl, overrideAuthToken) {
+    const config = await readJsonFile(path.join(openclawRoot, 'openclaw.json'));
+    const pluginConfig = config.plugins?.entries?.['rol-websocket-channel']?.config?.apiCoreBot ?? {};
+    const baseUrl = (overrideBaseUrl && overrideBaseUrl.trim()) || pluginConfig.baseUrl;
+    if (!baseUrl || !baseUrl.trim()) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.invalidParams, 'apiCoreBot.baseUrl is not configured');
+    }
+    const authToken = (overrideAuthToken && overrideAuthToken.trim()) || pluginConfig.authToken;
+    return {
+        baseUrl: baseUrl.replace(/\/+$/, ''),
+        authToken
+    };
+}
+async function postJson(url, body, authToken) {
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    if (authToken && authToken.trim()) {
+        headers.Authorization = `Bearer ${authToken.trim()}`;
+    }
+    const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body)
+    });
+    const payload = await response.json().catch(async () => await response.text());
+    if (!response.ok) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, `Request failed: ${response.status}`, {
+            url,
+            status: response.status,
+            payload
+        });
+    }
+    if (isObject(payload) && payload.success === false) {
+        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, pickStringValue(payload, ['message', 'msg']) ?? 'Request failed', {
+            url,
+            payload
+        });
+    }
+    return payload;
+}
+function resolvePresignedPostUploadTarget(payload) {
+    for (const candidate of collectPresignedPostCandidates(payload)) {
+        const uploadUrl = pickStringValue(candidate, ['url', 'uploadUrl', 'postUrl', 'presignedPostUrl']);
+        const rawFields = candidate.fields ?? candidate.formData ?? candidate.form ?? candidate.params;
+        const fields = toStringRecord(rawFields);
+        if (!uploadUrl || !fields) {
+            continue;
+        }
+        return {
+            uploadUrl,
+            fields,
+            objectKey: pickStringValue(candidate, ['objectKey', 'fileKey', 'file_key', 'source_file_key', 'key']) ?? fields.key ?? null,
+            fileUrl: pickStringValue(candidate, ['fileUrl', 'file_url', 'downloadUrl', 'source_file_url', 'location']) ?? null
+        };
+    }
+    throw new JsonRpcException(JSON_RPC_ERRORS.internalError, 'Presigned post response is missing upload url or fields', { payload });
+}
+function collectPresignedPostCandidates(payload) {
+    const candidates = [];
+    const queue = [payload];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!isObject(current)) {
+            continue;
+        }
+        candidates.push(current);
+        for (const key of ['data', 'result', 'presignedPost']) {
+            const nested = current[key];
+            if (isObject(nested)) {
+                queue.push(nested);
+            }
+        }
+    }
+    return candidates;
+}
+function pickStringValue(source, keys) {
+    for (const key of keys) {
+        const value = source[key];
+        if (typeof value === 'string' && value.trim().length > 0) {
+            return value.trim();
+        }
+    }
+    return null;
+}
+function toStringRecord(value) {
+    if (!isObject(value)) {
+        return null;
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (item === null) {
+            continue;
+        }
+        if (typeof item === 'string') {
+            result[key] = item;
+            continue;
+        }
+        if (typeof item === 'number' || typeof item === 'boolean') {
+            result[key] = String(item);
+            continue;
+        }
+        return null;
+    }
+    return result;
+}
+async function uploadArtifactToPresignedPost(target, artifact) {
+    const formData = new FormData();
+    for (const [key, value] of Object.entries(target.fields)) {
+        formData.append(key, value);
+    }
+    const content = await fs.readFile(artifact.localPath);
+    formData.append('file', new Blob([content], { type: artifact.mimeType }), artifact.fileName);
+    const response = await fetch(target.uploadUrl, {
+        method: 'POST',
+        body: formData
+    });
+    if (!response.ok) {
+        const payload = await response.text().catch(() => '');
+        throw new JsonRpcException(JSON_RPC_ERRORS.internalError, `Artifact upload failed: ${response.status}`, {
+            url: target.uploadUrl,
+            status: response.status,
+            payload
+        });
+    }
+}
+function buildPublicFileUrl(uploadUrl, objectKey) {
+    if (!objectKey) {
+        return null;
+    }
+    try {
+        const url = new URL(uploadUrl);
+        url.pathname = `${url.pathname.replace(/\/+$/, '')}/${objectKey.replace(/^\/+/, '')}`;
+        url.search = '';
+        url.hash = '';
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}