@workclaw/openclaw-workclaw 1.0.18 → 1.0.19

package/dist/src/gateway/skills-list-handler.js

@@ -0,0 +1,233 @@
+/**
+ * Skills list handler - 处理 SKILLS_LIST 事件
+ * 从 OpenClaw 获取 skills 列表并通过回调返回
+ */
+import { readFileSync } from 'node:fs';
+import { execSync } from "child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync, readdirSync, statSync } from "node:fs";
+/**
+ * 处理 SKILLS_LIST 事件
+ * @param event - 事件数据
+ * @param baseUrl - 回调基础 URL
+ * @param token - 鉴权 token
+ * @param log 日志对象（可选）
+ * @param {Function} [log.info] - 信息日志函数
+ * @param {Function} [log.error] - 错误日志函数
+ */
+export async function handleSkillsListEvent(event, baseUrl, token, log) {
+    const agentId = Number(event.agentId);
+    const userId = Number(event.userId);
+    log?.info?.(`SkillsList: Handling SKILLS_LIST event for agentId: ${agentId}, userId: ${userId}`);
+    try {
+        // 从 OpenClaw 获取 skills 列表
+        const skills = await fetchSkillsFromOpenClaw(agentId, userId, log);
+        // 构建回调 payload
+        const callbackPayload = {
+            userId,
+            agentId,
+            dataList: skills,
+        };
+        // 发送回调
+        const callbackUrl = `${baseUrl.replace(/\/$/, '')}/open-apis/v1/claw/push/skills`;
+        await sendSkillsListCallback(callbackUrl, callbackPayload, token, log);
+        log?.info?.(`SkillsList: Successfully processed SKILLS_LIST event, sent ${skills.length} skills`);
+    }
+    catch (error) {
+        log?.error?.(`SkillsList: Failed to handle SKILLS_LIST event: ${String(error)}`);
+        throw error;
+    }
+}
+/**
+ * 从 OpenClaw 获取 skills 列表
+ * 包括全局技能和智能体工作区的专有技能
+ */
+async function fetchSkillsFromOpenClaw(agentId, _userId, log) {
+    log?.info?.(`SkillsList: Fetching skills from OpenClaw for agentId: ${agentId}`);
+    try {
+        // 使用 OpenClaw CLI 获取 skills 列表（全局技能）
+        const result = execSync("openclaw skills list", {
+            encoding: "utf-8",
+            timeout: 30000, // 30秒超时
+        });
+        // 解析输出
+        const globalSkills = parseSkillsListOutput(result);
+        // 检查智能体工作区中的专有技能
+        const agentWorkspaceSkills = await fetchAgentWorkspaceSkills(agentId, log);
+        // 合并技能列表，去重
+        const allSkills = mergeSkills(globalSkills, agentWorkspaceSkills);
+        log?.info?.(`SkillsList: Found ${allSkills.length} skills (${globalSkills.length} global, ${agentWorkspaceSkills.length} agent-specific)`);
+        return allSkills;
+    }
+    catch (error) {
+        log?.error?.(`SkillsList: Error fetching skills: ${String(error)}`);
+        // 如果获取失败，返回空列表
+        return [];
+    }
+}
+/**
+ * 获取智能体工作区中的专有技能
+ */
+async function fetchAgentWorkspaceSkills(agentId, log) {
+    const skills = [];
+    try {
+        // 智能体工作区路径
+        const agentWorkspace = join(homedir(), ".openclaw", "agents", `openclaw-workclaw-${agentId}`);
+        const skillsDir = join(agentWorkspace, "skills");
+        // 检查技能目录是否存在
+        if (!existsSync(skillsDir)) {
+            log?.info?.(`SkillsList: No skills directory found in agent workspace: ${skillsDir}`);
+            return skills;
+        }
+        // 读取技能目录中的子目录（每个子目录是一个技能）
+        const items = readdirSync(skillsDir);
+        for (const item of items) {
+            const itemPath = join(skillsDir, item);
+            const stat = statSync(itemPath);
+            // 如果是目录，检查里面的技能文件
+            if (stat.isDirectory()) {
+                const skillFiles = readdirSync(itemPath);
+                for (const skillFile of skillFiles) {
+                    if (skillFile.endsWith('.md') || skillFile.endsWith('.prose')) {
+                        const skillFilePath = join(itemPath, skillFile);
+                        const skill = parseSkillFile(skillFilePath, item, log);
+                        if (skill) {
+                            skills.push(skill);
+                        }
+                    }
+                }
+            }
+        }
+        log?.info?.(`SkillsList: Found ${skills.length} agent-specific skills in ${skillsDir}`);
+    }
+    catch (error) {
+        log?.error?.(`SkillsList: Error reading agent workspace skills: ${String(error)}`);
+    }
+    return skills;
+}
+/**
+ * 解析技能文件
+ */
+function parseSkillFile(filePath, skillName, log) {
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        // 提取描述（从文件内容中）
+        let description = 'Agent-specific skill';
+        const lines = content.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('# ')) {
+                description = line.substring(2).trim();
+                break;
+            }
+            else if (line.startsWith('summary:') || line.startsWith('Summary:')) {
+                description = line.substring(line.indexOf(':') + 1).trim();
+                break;
+            }
+        }
+        return {
+            typeStr: 'skill',
+            name: skillName,
+            description,
+        };
+    }
+    catch (error) {
+        log?.error?.(`SkillsList: Error parsing skill file ${filePath}: ${String(error)}`);
+        return null;
+    }
+}
+/**
+ * 合并技能列表，去重
+ */
+function mergeSkills(globalSkills, agentSkills) {
+    const skillMap = new Map();
+    // 先添加全局技能
+    for (const skill of globalSkills) {
+        skillMap.set(skill.name, skill);
+    }
+    // 再添加智能体专有技能（会覆盖同名的全局技能）
+    for (const skill of agentSkills) {
+        skillMap.set(skill.name, skill);
+    }
+    return Array.from(skillMap.values());
+}
+/**
+ * 解析 openclaw skills list 的输出
+ */
+function parseSkillsListOutput(output) {
+    const skills = [];
+    const lines = output.split('\n');
+    // 查找表格内容（从表头后开始）
+    let inTable = false;
+    let headerLine = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // 找到表头行（包含 Status | Skill | Description | Source）
+        if (line.includes('Status') && line.includes('Skill') && line.includes('Description')) {
+            headerLine = i;
+            inTable = true;
+            continue;
+        }
+        // 跳过分隔线
+        if (inTable && (line.startsWith('├') || line.startsWith('┌') || line.startsWith('└'))) {
+            continue;
+        }
+        // 解析表格行
+        if (inTable && line.startsWith('│') && i > headerLine + 1) {
+            const parsed = parseSkillsTableRow(line);
+            if (parsed) {
+                skills.push(parsed);
+            }
+        }
+        // 表格结束
+        if (inTable && line.startsWith('└')) {
+            break;
+        }
+    }
+    return skills;
+}
+/**
+ * 解析单行表格数据
+ */
+function parseSkillsTableRow(line) {
+    // 移除开头的 │ 和结尾的 │
+    const content = line.replace(/^│\s*/, '').replace(/\s*│$/, '');
+    // 按 │ 分割列
+    const columns = content.split('│').map(col => col.trim());
+    if (columns.length < 4) {
+        return null;
+    }
+    const status = columns[0];
+    const skillName = columns[1];
+    const description = columns[2];
+    // 只返回 ready 状态的 skills
+    if (!status.includes('✓') && !status.includes('ready')) {
+        return null;
+    }
+    // 提取 skill 名称（移除 emoji）
+    const cleanName = skillName.replace(/[\u{1F300}-\u{1F9FF}]/gu, '').trim();
+    return {
+        typeStr: 'skill',
+        name: cleanName,
+        description,
+    };
+}
+/**
+ * 发送 skills 列表回调
+ */
+async function sendSkillsListCallback(callbackUrl, payload, token, log) {
+    log?.info?.(`SkillsList: Sending callback to ${callbackUrl}`);
+    const response = await fetch(callbackUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => 'Unknown error');
+        throw new Error(`Callback failed: ${response.status} ${errorText}`);
+    }
+    log?.info?.(`SkillsList: Callback sent successfully`);
+}

package/dist/src/gateway/tools-list-handler.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Tools List 事件处理器
+ * 处理云端下发的 TOOLS_LIST EVENT 消息
+ * 从 OpenClaw 获取 tools 列表并通过 HTTP 回调返回
+ */
+export interface ToolsListEvent {
+    agentId: string | number;
+    userId: string | number;
+}
+export interface ToolItem {
+    typeStr: string;
+    name: string;
+    description: string;
+}
+export interface ToolsListCallbackPayload {
+    userId: number;
+    agentId: number;
+    dataList: ToolItem[];
+}
+/**
+ * 处理 TOOLS_LIST 事件
+ * @param event 事件数据
+ * @param baseUrl 回调基础 URL
+ * @param token 鉴权 token
+ * @param log 日志函数
+ */
+export declare function handleToolsListEvent(event: ToolsListEvent, baseUrl: string, token: string, log?: {
+    info?: (msg: string) => void;
+    error?: (msg: string) => void;
+}): Promise<void>;

package/dist/src/gateway/tools-list-handler.js

@@ -0,0 +1,101 @@
+/**
+ * Tools List 事件处理器
+ * 处理云端下发的 TOOLS_LIST EVENT 消息
+ * 从 OpenClaw 获取 tools 列表并通过 HTTP 回调返回
+ */
+import { fetch } from "undici";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+/**
+ * 处理 TOOLS_LIST 事件
+ * @param event 事件数据
+ * @param baseUrl 回调基础 URL
+ * @param token 鉴权 token
+ * @param log 日志函数
+ */
+export async function handleToolsListEvent(event, baseUrl, token, log) {
+    const agentId = Number(event.agentId);
+    const userId = Number(event.userId);
+    log?.info?.(`ToolsList: Handling TOOLS_LIST event for agentId: ${agentId}, userId: ${userId}`);
+    try {
+        // 从 OpenClaw 获取 tools 列表
+        const tools = await fetchToolsFromOpenClaw(agentId, userId, log);
+        // 构建回调 payload
+        const callbackPayload = {
+            userId,
+            agentId,
+            dataList: tools,
+        };
+        // 发送回调
+        const callbackUrl = `${baseUrl.replace(/\/$/, "")}/open-apis/v1/claw/push/tools`;
+        await sendToolsListCallback(callbackUrl, callbackPayload, token, log);
+        log?.info?.(`ToolsList: Successfully processed TOOLS_LIST event, sent ${tools.length} tools`);
+    }
+    catch (error) {
+        log?.error?.(`ToolsList: Failed to handle TOOLS_LIST event: ${String(error)}`);
+        throw error;
+    }
+}
+/**
+ * 从 OpenClaw 获取 tools 列表
+ * 根据 agent 的 tools.allow 配置决定返回哪些工具
+ */
+async function fetchToolsFromOpenClaw(agentId, userId, log) {
+    log?.info?.(`ToolsList: Fetching tools from OpenClaw for agentId: ${agentId}`);
+    // OpenClaw 所有内置工具列表
+    const allTools = [
+        { typeStr: "function", name: "web_search", description: "Search the web for information using Brave Search API." },
+        { typeStr: "function", name: "web_fetch", description: "Fetch and read content from a URL." },
+        { typeStr: "function", name: "sessions_list", description: "List all active agent sessions." },
+        { typeStr: "function", name: "sessions_history", description: "Get the history of a specific session." },
+        { typeStr: "function", name: "memory_search", description: "Search memory for past conversations and information." },
+        { typeStr: "function", name: "memory_get", description: "Get specific memory by ID." },
+        { typeStr: "function", name: "gateway", description: "Gateway control operations." },
+        { typeStr: "function", name: "exec", description: "Execute shell commands." },
+    ];
+    try {
+        // 读取 OpenClaw 配置文件
+        const configPath = path.join(homedir(), ".openclaw", "openclaw.json");
+        const configContent = await readFile(configPath, "utf-8");
+        const config = JSON.parse(configContent);
+        // 查找对应的 agent 配置
+        const agentConfig = config.agents?.list?.find((agent) => String(agent.id) === String(agentId) ||
+            agent.id === `openclaw-workclaw-${agentId}`);
+        // 获取 tools.allow 配置
+        const allowTools = agentConfig?.tools?.allow;
+        // 如果没有 allow 配置，或者 allow 是 ["*"]，返回所有工具
+        if (!allowTools || allowTools.length === 0 || allowTools.includes("*")) {
+            log?.info?.(`ToolsList: Agent has no allow restriction or allow=[*], returning all ${allTools.length} tools`);
+            return allTools;
+        }
+        // 如果有具体的 allow 列表，只返回列表中的工具
+        const filteredTools = allTools.filter(tool => allowTools.includes(tool.name));
+        log?.info?.(`ToolsList: Agent allow=${JSON.stringify(allowTools)}, returning ${filteredTools.length} tools`);
+        return filteredTools;
+    }
+    catch (error) {
+        log?.error?.(`ToolsList: Error reading agent config: ${String(error)}, returning all tools`);
+        // 如果读取配置失败，返回所有工具
+        return allTools;
+    }
+}
+/**
+ * 发送 tools 列表回调
+ */
+async function sendToolsListCallback(callbackUrl, payload, token, log) {
+    log?.info?.(`ToolsList: Sending callback to ${callbackUrl}`);
+    const response = await fetch(callbackUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${token}`,
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Callback failed: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    log?.info?.(`ToolsList: Callback sent successfully: ${response.status}`);
+}

package/dist/src/gateway/workclaw-gateway.d.ts

@@ -0,0 +1,14 @@
+import type { ResolvedWorkclawAccount } from "../types.js";
+export interface WorkclawGatewayOptions {
+    accountId: string;
+    account: ResolvedWorkclawAccount;
+    cfg: any;
+    log?: {
+        info?: (msg: string) => void;
+        warn?: (msg: string) => void;
+        error?: (msg: string) => void;
+        debug?: (msg: string) => void;
+    };
+}
+export declare function startWorkclawGateway(options: WorkclawGatewayOptions): Promise<void>;
+export declare function stopWorkclawGateway(accountId: string): void;

package/dist/src/gateway/workclaw-gateway.js

@@ -0,0 +1,223 @@
+import { getWorkclawWsConnection, clearWorkclawWsConnection, createLogger, setWorkclawLoggerFromContext, registerAccountContext, unregisterAccountContext, getAppKeyByAccountId, getAllDispatchersByAppKey, getDispatcherByAppKeyAndAccountId, getReconnectScheduler, setReconnectScheduler, clearReconnectScheduler, tryStartConnecting, finishConnecting, setWorkclawConnectionConfig, clearWorkclawConnectionConfig, } from "../runtime.js";
+import { buildAccountMap, resolveAccountByUserIdAndAgentId } from "../accounts.js";
+import { dispatchWorkclawMessage } from "./message-dispatcher.js";
+import { parseWorkClawMessage } from "./message-context.js";
+import { createReconnectScheduler } from "./reconnect.js";
+export async function startWorkclawGateway(options) {
+    const { accountId, account, cfg, log } = options;
+    const logger = createLogger("", log);
+    setWorkclawLoggerFromContext(logger);
+    const rawConfig = account.config;
+    const connectionMode = rawConfig.connectionMode || "websocket";
+    if (connectionMode !== "websocket") {
+        throw new Error(`Unsupported connectionMode: ${connectionMode}`);
+    }
+    await startSharedWebSocket(options);
+}
+/**
+ * 多个账号共享一个 WebSocket 连接
+ */
+async function startSharedWebSocket(options) {
+    const { accountId, account, cfg, log } = options;
+    const logger = createLogger("", log);
+    const rawConfig = account.config;
+    const baseConfig = {
+        baseUrl: rawConfig.baseUrl,
+        websocketUrl: rawConfig.websocketUrl,
+        appKey: rawConfig.appKey,
+        appSecret: rawConfig.appSecret,
+        localIp: rawConfig.localIp,
+        allowInsecureTls: rawConfig.allowInsecureTls,
+        requestTimeout: rawConfig.requestTimeout,
+    };
+    const accountConfig = {
+        agentId: rawConfig.agentId,
+        userId: rawConfig.userId,
+        openConversationId: rawConfig.openConversationId,
+    };
+    const appKey = baseConfig.appKey || accountId;
+    const appKeyRaw = baseConfig.appKey ?? "";
+    buildAccountMap(cfg);
+    logger.info(`Gateway start accountId=${accountId} appKey=${appKeyRaw ? `${appKeyRaw.slice(0, 8)}...` : "missing"} baseUrl=${baseConfig.baseUrl ?? ""} websocketUrl=${baseConfig.websocketUrl ?? ""}`);
+    // 注册账号上下文
+    const ctx = {
+        accountId,
+        account,
+        cfg,
+        baseConfig,
+        accountConfig,
+        log: logger,
+        scheduleReconnect: () => {
+            const scheduler = getReconnectScheduler(appKey);
+            scheduler?.scheduleReconnect();
+        },
+    };
+    registerAccountContext(appKey, accountId, ctx);
+    // 检查是否已存在该 appKey 的 WebSocket
+    const existingWs = getWorkclawWsConnection(appKey);
+    if (existingWs) {
+        logger.info(`Gateway using existing WebSocket for appKey=${appKey}`);
+        return;
+    }
+    // 尝试获取连接锁，防止竞态条件
+    const startResult = tryStartConnecting(appKey);
+    if (!startResult.isConnector) {
+        // 另一个账号正在连接（成功或失败中），等待共享的 connectingPromise
+        logger.info(`Gateway another account is connecting, waiting... appKey=${appKey}`);
+        const resultWs = await startResult.connectingPromise;
+        if (resultWs) {
+            logger.info(`Gateway connection established by another account, using it appKey=${appKey}`);
+            return;
+        }
+        // 连接失败（resultWs === null），当前账号作为新 connector 重试
+        logger.warn(`Gateway connection attempt failed, will create own connection appKey=${appKey}`);
+    }
+    else {
+        // 是 connector，创建连接
+        logger.info(`Gateway acquired connector lock, creating connection appKey=${appKey}`);
+    }
+    // 需要创建新的 WebSocket（只有获取到锁的账号才执行到这里）
+    const scheduler = createReconnectScheduler({
+        key: appKey,
+        config: baseConfig,
+        log: logger,
+        onMessage: (data) => {
+            handleSharedMessage(appKey, data, cfg, logger);
+        },
+        onClose: () => {
+            scheduler.scheduleReconnect();
+        },
+        // 旧代码在 setWorkclawWsConnection 后、ws.onopen 前就调用 finishConnecting，
+        // 这个回调模拟同样的时机：ws 已存入 runtime，通知所有等待者
+        onConnectingStarted: (ws) => {
+            finishConnecting(appKey, ws);
+        },
+    });
+    setReconnectScheduler(appKey, scheduler);
+    try {
+        await scheduler.connect();
+    }
+    catch (err) {
+        // 连接失败，通知所有等待者重试（不传 ws 表示失败）
+        finishConnecting(appKey);
+        throw err;
+    }
+    // Cache the connection config to prevent cfg mutation issues during message sends
+    // 每个账户都有自己的配置缓存
+    setWorkclawConnectionConfig(accountId, {
+        appKey: baseConfig.appKey ?? "",
+        appSecret: baseConfig.appSecret ?? "",
+        baseUrl: baseConfig.baseUrl,
+        websocketUrl: baseConfig.websocketUrl,
+        localIp: baseConfig.localIp,
+        allowInsecureTls: baseConfig.allowInsecureTls,
+        requestTimeout: baseConfig.requestTimeout,
+    });
+}
+/**
+ * 处理共享 WebSocket 消息
+ */
+function handleSharedMessage(appKey, data, cfg, logger) {
+    const parsed = parseWorkClawMessage(data, logger);
+    if (!parsed) {
+        logger.warn?.(`Gateway failed to parse message`);
+        return;
+    }
+    // ping/pong/disconnect 无需路由
+    if (parsed.type === "ping") {
+        const ws = getWorkclawWsConnection(appKey);
+        if (ws && ws.readyState === 1) { // OPEN
+            const pongResponse = {
+                code: 200,
+                message: "pong",
+                metadata: { contentType: "application/json" },
+                data: JSON.stringify(parsed.pongData),
+            };
+            ws.send(JSON.stringify(pongResponse));
+        }
+        return;
+    }
+    if (parsed.type === "disconnect") {
+        const ws = getWorkclawWsConnection(appKey);
+        ws?.close();
+        return;
+    }
+    // logger.info?.(`Gateway received message: ${data}`);
+    // 根据消息类型确定 userId 和 agentId
+    let userId = "";
+    let agentId = "";
+    if (parsed.type === "agent_message" && parsed.message) {
+        userId = String(parsed.message.userId || "");
+        agentId = String(parsed.message.agentId || "");
+    }
+    else if (parsed.type === "agent_created") {
+        // agent_created 触发新账号创建
+        const allDispatchers = getAllDispatchersByAppKey(appKey);
+        if (allDispatchers && allDispatchers.size > 0) {
+            const firstDispatcher = allDispatchers.values().next().value;
+            dispatchWorkclawMessage(data, firstDispatcher.ctx).catch((err) => {
+                logger.error?.(`Dispatch error: ${String(err)}`);
+            });
+        }
+        return;
+    }
+    else if (parsed.type === "agent_updated" || parsed.type === "agent_deleted") {
+        userId = String(parsed.eventData?.futureId || parsed.eventData?.userId || "");
+        agentId = String(parsed.eventData?.id || parsed.eventData?.agentId || "");
+    }
+    else if (parsed.type === "tools_list" || parsed.type === "skills_list" || parsed.type === "skills_event") {
+        userId = String(parsed.eventData?.userId || "");
+        agentId = String(parsed.eventData?.agentId || "");
+    }
+    else if (parsed.type === "init_agent") {
+        userId = String(parsed.eventData?.futureId || parsed.eventData?.userId || "");
+        agentId = String(parsed.eventData?.id || parsed.eventData?.agentId || "");
+        /**
+         * 在 init_agent 中，配置文件的agentId 为空,所有无法通过 resolveAccountByUserIdAndAgentId 查找账户
+         */
+        const accountId = "default";
+        const dispatcher = getDispatcherByAppKeyAndAccountId(appKey, accountId);
+        if (dispatcher) {
+            dispatchWorkclawMessage(data, dispatcher.ctx).catch((err) => {
+                logger.error?.(`Dispatch error: ${String(err)}`);
+            });
+        }
+        else {
+            logger.warn?.(`Gateway no dispatcher for accountId=${accountId}`);
+        }
+        return;
+    }
+    else {
+        // 未知消息类型，忽略
+        return;
+    }
+    const accountId = resolveAccountByUserIdAndAgentId(cfg, userId, agentId);
+    if (!accountId) {
+        logger.warn?.(`Gateway no account found for userId=${userId} agentId=${agentId}`);
+        return;
+    }
+    const dispatcher = getDispatcherByAppKeyAndAccountId(appKey, accountId);
+    if (dispatcher) {
+        dispatchWorkclawMessage(data, dispatcher.ctx).catch((err) => {
+            logger.error?.(`Dispatch error: ${String(err)}`);
+        });
+    }
+    else {
+        logger.warn?.(`Gateway no dispatcher for accountId=${accountId}`);
+    }
+}
+export function stopWorkclawGateway(accountId) {
+    const appKey = getAppKeyByAccountId(accountId);
+    if (!appKey)
+        return;
+    unregisterAccountContext(appKey, accountId);
+    if (getAllDispatchersByAppKey(appKey)?.size === 0) {
+        const ws = getWorkclawWsConnection(appKey);
+        ws?.close();
+        clearWorkclawWsConnection(appKey);
+        const scheduler = getReconnectScheduler(appKey);
+        scheduler?.stopReconnect();
+        clearReconnectScheduler(appKey);
+    }
+    clearWorkclawConnectionConfig(accountId);
+}

package/dist/src/media/upload.d.ts

@@ -0,0 +1,13 @@
+export declare function isLocalMediaSource(value: string): boolean;
+export declare function resolveLocalPath(input: string): string;
+export interface UploadLocalMediaParams {
+    uploadUrl: string;
+    filePath: string;
+    uploadFieldName?: string;
+    uploadHeaders?: Record<string, string>;
+    uploadFormFields?: Record<string, string | number | boolean>;
+    uploadResponseUrlPath?: string;
+    requestTimeout: number;
+    allowInsecureTls?: boolean;
+}
+export declare function uploadLocalMedia(params: UploadLocalMediaParams): Promise<string>;