@kafca/agentdock 0.1.22 → 0.1.24

package/dist-electron/services/local-ai-core/src/channel/lark/registration.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LARK_APP_REGISTRATION_SETUP_PATH = exports.DEFAULT_LARK_QR_EXPIRES_IN = void 0;
+exports.getLarkAccountsBase = getLarkAccountsBase;
+exports.getLarkOpenBase = getLarkOpenBase;
+exports.requestAppRegistration = requestAppRegistration;
+exports.pollAppRegistration = pollAppRegistration;
+exports.DEFAULT_LARK_QR_EXPIRES_IN = 180;
+exports.LARK_APP_REGISTRATION_SETUP_PATH = '/page/openclaw';
+const LARK_APP_REGISTRATION_PATH = '/oauth/v1/app/registration';
+function getLarkAccountsBase(binding) {
+    return binding.brand === 'lark' ? 'https://accounts.larksuite.com' : 'https://accounts.feishu.cn';
+}
+function getLarkOpenBase(binding) {
+    return binding.brand === 'lark' ? 'https://open.larksuite.com' : 'https://open.feishu.cn';
+}
+async function requestAppRegistration(binding) {
+    return callAppRegistration(binding, {
+        action: 'begin',
+        archetype: 'PersonalAgent',
+        auth_method: 'client_secret',
+        request_user_info: 'open_id tenant_brand',
+    });
+}
+async function pollAppRegistration(binding, deviceCode) {
+    return callAppRegistration(binding, {
+        action: 'poll',
+        device_code: deviceCode,
+    });
+}
+async function callAppRegistration(binding, formValues) {
+    const form = new URLSearchParams();
+    for (const [key, value] of Object.entries(formValues)) {
+        form.set(key, value);
+    }
+    const response = await fetch(`${getLarkAccountsBase(binding)}${LARK_APP_REGISTRATION_PATH}`, {
+        method: 'POST',
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/x-www-form-urlencoded',
+        },
+        body: form.toString(),
+    });
+    const text = await response.text();
+    const parsed = text ? JSON.parse(text) : {};
+    if (!response.ok) {
+        throw new Error(`Lark app registration failed (${response.status}): ${String(parsed.error_description || parsed.error || text || response.statusText)}`);
+    }
+    return parsed;
+}

package/dist-electron/services/local-ai-core/src/channel/lark/runtime-state.js

@@ -0,0 +1,191 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLarkTurnState = createLarkTurnState;
+exports.foldToolResultForLark = foldToolResultForLark;
+exports.consumeLarkBridgeEvent = consumeLarkBridgeEvent;
+exports.renderLarkBridgeEventMessage = renderLarkBridgeEventMessage;
+exports.getLarkRenderedMessageId = getLarkRenderedMessageId;
+exports.setLarkRenderedMessageId = setLarkRenderedMessageId;
+function createLarkTurnState(sessionKey, sourceMessageId) {
+    const turn = {
+        sessionKey,
+        sourceMessageId,
+        awaitingPermission: false,
+        processing: false,
+        previewText: '',
+        finalText: '',
+        progressMessageIds: {},
+        thinkingSteps: [],
+        toolCalls: [],
+        statusLines: [],
+        buttonRows: [],
+        lastPatchedAt: 0,
+        lastPatchedAtByMessageId: {},
+    };
+    return turn;
+}
+function foldToolResultForLark(content) {
+    const normalized = String(content || '').trim();
+    if (!normalized.startsWith('🔧 '))
+        return normalized;
+    const parts = normalized.split(' - ');
+    if (parts.length <= 2)
+        return normalized;
+    return parts.slice(0, 2).join(' - ');
+}
+function consumeLarkBridgeEvent(turn, event, options) {
+    const content = foldToolResultForLark(String(event.content || '').trim());
+    if (event.type === 'typing_start') {
+        turn.messageId = undefined;
+        turn.finalMessageId = undefined;
+        turn.replyMessageId = undefined;
+        turn.progressMessageIds = {};
+        turn.processing = true;
+        turn.permissionMessageId = undefined;
+        turn.previewText = '';
+        turn.finalText = '';
+        turn.thinkingSteps = [];
+        turn.toolCalls = [];
+        turn.buttonRows = [];
+        turn.statusLines = [];
+        turn.lastPatchedAtByMessageId = {};
+        return;
+    }
+    if (event.type === 'typing_stop') {
+        turn.processing = false;
+        return;
+    }
+    if (event.type === 'preview_start' || event.type === 'update_message') {
+        turn.previewText = content;
+        return;
+    }
+    if (event.type === 'status') {
+        if (content) {
+            pushUniqueLarkTurnLine(turn.statusLines, content);
+        }
+        return;
+    }
+    if (event.type === 'buttons') {
+        turn.awaitingPermission = true;
+        turn.buttonRows = [];
+        if (options.mirrorPermissionStateInMainCard && content) {
+            pushUniqueLarkTurnLine(turn.statusLines, `等待确认: ${content}`);
+        }
+        return;
+    }
+    if (!content) {
+        return;
+    }
+    if (content.startsWith('💭 ')) {
+        pushUniqueLarkTurnLine(turn.thinkingSteps, content.slice(3).trim());
+        return;
+    }
+    if (content.startsWith('🔧 ')) {
+        pushUniqueLarkTurnLine(turn.toolCalls, content.slice(3).trim());
+        return;
+    }
+    if (content.startsWith('⏳ ') || content.startsWith('📤 ')) {
+        pushUniqueLarkTurnLine(turn.statusLines, content.slice(3).trim());
+        return;
+    }
+    turn.finalText = content;
+    turn.previewText = content;
+}
+function renderLarkBridgeEventMessage(turn, event) {
+    const content = foldToolResultForLark(String(event.content || '').trim());
+    if (event.type === 'preview_start' || event.type === 'update_message') {
+        if (content.startsWith('💭 ')) {
+            return renderProgressMessage(event.previewHandle || 'thinking-preview', content);
+        }
+        if (content.startsWith('🔧 ')) {
+            return renderProgressMessage(progressKey('tool', event), content);
+        }
+        return {
+            key: 'final',
+            text: content,
+            buttonRows: turn.buttonRows,
+            isFinal: true,
+            finalSource: 'stream',
+        };
+    }
+    if (event.type === 'status') {
+        return renderProgressMessage(progressKey('status', event), content.startsWith('⏳ ') ? content : `⏳ ${content}`);
+    }
+    if (event.type === 'reply') {
+        if (content.startsWith('💭 ')) {
+            return renderProgressMessage(progressKey('thinking', event), content);
+        }
+        if (content.startsWith('🔧 ')) {
+            return renderProgressMessage(progressKey('tool', event), content);
+        }
+        if (content.startsWith('⏳ ') || content.startsWith('📤 ')) {
+            return renderProgressMessage(progressKey('status', event), content);
+        }
+        return {
+            key: 'final',
+            text: content,
+            buttonRows: turn.buttonRows,
+            isFinal: true,
+            finalSource: 'reply',
+        };
+    }
+    if (event.type === 'typing_start' || event.type === 'typing_stop') {
+        return { key: 'noop', text: '', buttonRows: [], isFinal: false };
+    }
+    return {
+        key: 'noop',
+        text: '',
+        buttonRows: [],
+        isFinal: false,
+    };
+}
+function getLarkRenderedMessageId(turn, rendered) {
+    if (rendered.isFinal) {
+        if (rendered.finalSource === 'reply') {
+            return turn.replyMessageId;
+        }
+        return turn.finalMessageId || turn.messageId;
+    }
+    return turn.progressMessageIds[rendered.key];
+}
+function setLarkRenderedMessageId(turn, rendered, messageId) {
+    if (rendered.isFinal) {
+        if (rendered.finalSource === 'reply') {
+            turn.replyMessageId = messageId;
+            return;
+        }
+        turn.finalMessageId = messageId;
+        turn.messageId = messageId;
+        return;
+    }
+    turn.progressMessageIds[rendered.key] = messageId;
+}
+function renderProgressMessage(key, text) {
+    return {
+        key,
+        text,
+        buttonRows: [],
+        isFinal: false,
+    };
+}
+function progressKey(prefix, event) {
+    const stableId = String(event.messageId || event.previewHandle || '').trim();
+    if (stableId) {
+        return `${prefix}:${stableId}`;
+    }
+    const content = String(event.content || '').trim().replace(/\s+/g, ' ');
+    return `${prefix}:${content.slice(0, 120)}`;
+}
+function pushUniqueLarkTurnLine(target, value) {
+    const normalized = value.trim();
+    if (!normalized) {
+        return;
+    }
+    if (target[target.length - 1] === normalized) {
+        return;
+    }
+    target.push(normalized);
+    if (target.length > 6) {
+        target.splice(0, target.length - 6);
+    }
+}

package/dist-electron/services/local-ai-core/src/channel/lark/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist-electron/services/local-ai-core/src/channel/shared/content.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWrappedChannelContentParts = createWrappedChannelContentParts;
+exports.createChannelThreadMessageInput = createChannelThreadMessageInput;
+function createWrappedChannelContentParts(wrappedText, parts) {
+    const nonTextParts = Array.isArray(parts)
+        ? parts.filter((part) => part.type !== 'text')
+        : [];
+    return [
+        { type: 'text', text: wrappedText },
+        ...nonTextParts,
+    ];
+}
+function createChannelThreadMessageInput(wrappedText, parts) {
+    const hasNonTextPart = Array.isArray(parts) && parts.some((part) => part.type !== 'text');
+    if (!hasNonTextPart) {
+        return wrappedText;
+    }
+    return {
+        displayText: wrappedText,
+        contentParts: createWrappedChannelContentParts(wrappedText, parts),
+    };
+}

package/dist-electron/services/local-ai-core/src/channel/shared/plugin.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinChannelPlugin = createBuiltinChannelPlugin;
+function createBuiltinChannelPlugin(options) {
+    let runtime = null;
+    let unsubscribeBridgeEvents = null;
+    return {
+        manifest: options.manifest,
+        capabilities: {
+            channels: options.channels,
+        },
+        createRuntime(ctx) {
+            if (!runtime) {
+                const channel = options.createChannel(ctx);
+                runtime = { channel };
+                unsubscribeBridgeEvents = ctx.bus.on('platform.bridge.updated', (event) => {
+                    void channel.onBridgeEvent?.(event);
+                });
+            }
+            return runtime;
+        },
+        async start() {
+            await runtime?.channel.refreshBindings?.();
+        },
+        async stop() {
+            unsubscribeBridgeEvents?.();
+            unsubscribeBridgeEvents = null;
+            runtime?.channel.close?.();
+        },
+    };
+}

package/dist-electron/services/local-ai-core/src/channel/weixin/config.js

@@ -0,0 +1,125 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LONG_POLL_TIMEOUT_MS = exports.DEFAULT_CDN_BASE_URL = exports.DEFAULT_BASE_URL = void 0;
+exports.normalizeChannelInstanceId = normalizeChannelInstanceId;
+exports.channelPlatformKey = channelPlatformKey;
+exports.runtimeKey = runtimeKey;
+exports.getDefaultWeixinStateDir = getDefaultWeixinStateDir;
+exports.safeFilePart = safeFilePart;
+exports.getWeixinBufPath = getWeixinBufPath;
+exports.getWeixinCredentialsPath = getWeixinCredentialsPath;
+exports.loadWeixinCredentials = loadWeixinCredentials;
+exports.saveWeixinCredentials = saveWeixinCredentials;
+exports.loadWeixinBuf = loadWeixinBuf;
+exports.saveWeixinBuf = saveWeixinBuf;
+exports.collectWeixinWorkspaceBindings = collectWeixinWorkspaceBindings;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const desktop_js_1 = require("../../../../../shared/desktop.js");
+exports.DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com';
+exports.DEFAULT_CDN_BASE_URL = 'https://novac2c.cdn.weixin.qq.com/c2c';
+exports.LONG_POLL_TIMEOUT_MS = 35_000;
+function normalizeChannelInstanceId(value, fallback) {
+    const raw = String(value || '').trim();
+    const normalized = raw.replace(/[^a-zA-Z0-9._-]/g, '-').replace(/-+/g, '-').slice(0, 80);
+    return normalized || fallback;
+}
+function channelPlatformKey(platform, instanceId) {
+    return instanceId === 'default' ? platform : `${platform}:${instanceId}`;
+}
+function runtimeKey(workspaceId, instanceId) {
+    return `${workspaceId}::${instanceId}`;
+}
+function getDefaultWeixinStateDir() {
+    return node_path_1.default.join(process.cwd(), 'weixin-monitor');
+}
+function safeFilePart(value) {
+    return String(value || 'default').replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 80) || 'default';
+}
+function getWeixinBufPath(binding) {
+    return node_path_1.default.join(binding.stateDir, `${binding.accountId}.buf`);
+}
+function getWeixinCredentialsPath(workspaceId, stateDir, instanceId = 'default') {
+    const suffix = instanceId === 'default' ? '' : `.${safeFilePart(instanceId)}`;
+    return node_path_1.default.join(stateDir, `${safeFilePart(workspaceId)}${suffix}.credentials.json`);
+}
+function loadWeixinCredentials(workspaceId, stateDir, instanceId = 'default') {
+    try {
+        const raw = node_fs_1.default.readFileSync(getWeixinCredentialsPath(workspaceId, stateDir, instanceId), 'utf-8');
+        const parsed = JSON.parse(raw);
+        const token = String(parsed.token || '').trim();
+        if (!token)
+            return null;
+        return {
+            token,
+            baseUrl: parsed.baseUrl ? String(parsed.baseUrl) : undefined,
+            botId: parsed.botId ? String(parsed.botId) : undefined,
+            userId: parsed.userId ? String(parsed.userId) : undefined,
+            savedAt: parsed.savedAt ? String(parsed.savedAt) : new Date().toISOString(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function saveWeixinCredentials(binding, credentials) {
+    node_fs_1.default.mkdirSync(binding.stateDir, { recursive: true });
+    node_fs_1.default.writeFileSync(getWeixinCredentialsPath(binding.workspaceId, binding.stateDir, binding.instanceId), JSON.stringify(credentials, null, 2), 'utf-8');
+}
+function loadWeixinBuf(binding) {
+    try {
+        return node_fs_1.default.readFileSync(getWeixinBufPath(binding), 'utf-8');
+    }
+    catch {
+        return '';
+    }
+}
+function saveWeixinBuf(binding, buf) {
+    const dir = binding.stateDir;
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+    node_fs_1.default.writeFileSync(getWeixinBufPath(binding), buf, 'utf-8');
+}
+function collectWeixinWorkspaceBindings(config) {
+    const projects = Array.isArray(config?.projects) ? config.projects : [];
+    return projects.flatMap((project) => {
+        const platforms = Array.isArray(project.platforms) ? project.platforms : [];
+        return platforms
+            .map((platform) => ({
+            platformType: (0, desktop_js_1.normalizeDesktopPlatformType)(platform?.type),
+            options: platform?.options && typeof platform.options === 'object'
+                ? platform.options
+                : {},
+        }))
+            .filter((p) => p.platformType === 'weixin')
+            .map((p, index) => {
+            const instanceId = normalizeChannelInstanceId(p.options.instance_id || p.options.id, index === 0 ? 'default' : `weixin-${index + 1}`);
+            const stateDir = String(p.options.state_dir || getDefaultWeixinStateDir()).trim();
+            const credentials = loadWeixinCredentials(project.name, stateDir, instanceId);
+            const configuredToken = String(p.options.token || '').trim();
+            const configuredBaseUrl = String(p.options.base_url || '').trim();
+            const accountId = String(p.options.account_id || credentials?.botId || 'qr-login').trim();
+            return {
+                workspaceId: project.name,
+                instanceId,
+                displayName: String(p.options.name || p.options.display_name || `WeChat ${index + 1}`).trim(),
+                platformKey: channelPlatformKey('weixin', instanceId),
+                token: configuredToken || credentials?.token || '',
+                accountId,
+                baseUrl: configuredBaseUrl || credentials?.baseUrl || exports.DEFAULT_BASE_URL,
+                cdnBaseUrl: String(p.options.cdn_base_url || exports.DEFAULT_CDN_BASE_URL).trim(),
+                allowFrom: String(p.options.allow_from || '*').trim(),
+                routeTag: String(p.options.route_tag || '').trim(),
+                longPollTimeoutMs: Number(p.options.long_poll_timeout_ms || exports.LONG_POLL_TIMEOUT_MS) || exports.LONG_POLL_TIMEOUT_MS,
+                stateDir,
+                proxy: String(p.options.proxy || '').trim(),
+                proxyUsername: String(p.options.proxy_username || '').trim(),
+                proxyPassword: String(p.options.proxy_password || '').trim(),
+                enabled: true,
+                project,
+            };
+        });
+    });
+}