@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/packages/benchmark/src/workspace.js

@@ -0,0 +1,128 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import process from 'node:process';
+import { execCommand, execShellCommand, linkPreparedNodeModules, pathExists } from './utils';
+const categoryWorkspaceInflight = new Map();
+const resolveWorktreeRoot = (workspaceFolder = process.cwd()) => resolve(workspaceFolder, '.ai/worktress/benchmark');
+const findGitRoot = async (workspaceFolder) => {
+    const result = await execCommand({
+        command: 'git',
+        args: ['rev-parse', '--show-toplevel'],
+        cwd: workspaceFolder
+    });
+    if (result.exitCode !== 0) {
+        throw new Error(result.stderr || 'Failed to resolve git root');
+    }
+    return result.stdout.trim();
+};
+const detachWorktree = async (gitRoot, worktreePath) => {
+    const result = await execCommand({
+        command: 'git',
+        args: ['worktree', 'remove', '--force', worktreePath],
+        cwd: gitRoot
+    });
+    const output = `${result.stdout}\n${result.stderr}`;
+    if (result.exitCode !== 0 && !output.includes('is not a working tree')) {
+        throw new Error(output.trim() || `Failed to remove worktree: ${worktreePath}`);
+    }
+};
+export const ensureCategoryWorkspace = async (input) => {
+    const workspaceFolder = input.workspaceFolder ?? process.cwd();
+    const lockKey = `${workspaceFolder}:${input.category}`;
+    const inflight = categoryWorkspaceInflight.get(lockKey);
+    if (inflight != null) {
+        return inflight;
+    }
+    const promise = (async () => {
+        const gitRoot = await findGitRoot(workspaceFolder);
+        const worktreeRoot = resolveWorktreeRoot(workspaceFolder);
+        const workspacePath = resolve(worktreeRoot, input.category);
+        const statePath = resolve(workspacePath, '.benchmark-state.json');
+        await mkdir(worktreeRoot, { recursive: true });
+        const currentState = await pathExists(statePath)
+            ? JSON.parse(await readFile(statePath, 'utf-8'))
+            : null;
+        const needsRecreate = !await pathExists(workspacePath) ||
+            currentState?.baseCommit !== input.baseCommit ||
+            currentState?.setupCommand !== input.setupCommand;
+        if (needsRecreate) {
+            if (await pathExists(workspacePath)) {
+                await detachWorktree(gitRoot, workspacePath);
+                await rm(workspacePath, { force: true, recursive: true });
+            }
+            const addResult = await execCommand({
+                command: 'git',
+                args: ['worktree', 'add', '--force', '--detach', workspacePath, input.baseCommit],
+                cwd: gitRoot
+            });
+            if (addResult.exitCode !== 0) {
+                throw new Error(addResult.stderr || `Failed to create worktree for ${input.category}`);
+            }
+            if (input.setupCommand.trim() !== '') {
+                const setupResult = await execShellCommand({
+                    command: input.setupCommand,
+                    cwd: workspacePath,
+                    timeoutMs: input.timeoutSec * 1000
+                });
+                if (setupResult.exitCode !== 0) {
+                    throw new Error(setupResult.stderr || setupResult.stdout || 'Failed to prepare category workspace');
+                }
+            }
+            await writeFile(statePath, `${JSON.stringify({
+                baseCommit: input.baseCommit,
+                setupCommand: input.setupCommand
+            }, null, 2)}\n`, 'utf-8');
+        }
+        return {
+            workspacePath,
+            gitRoot
+        };
+    })();
+    categoryWorkspaceInflight.set(lockKey, promise);
+    try {
+        return await promise;
+    }
+    finally {
+        categoryWorkspaceInflight.delete(lockKey);
+    }
+};
+export const createCaseWorkspace = async (input) => {
+    const categoryWorkspace = await ensureCategoryWorkspace(input);
+    const worktreeRoot = resolveWorktreeRoot(input.workspaceFolder ?? process.cwd());
+    const caseRoot = resolve(worktreeRoot, '.cases', input.category);
+    const caseWorkspacePath = resolve(caseRoot, `${input.title}-${input.runId}`);
+    await mkdir(caseRoot, { recursive: true });
+    if (await pathExists(caseWorkspacePath)) {
+        await detachWorktree(categoryWorkspace.gitRoot, caseWorkspacePath);
+        await rm(caseWorkspacePath, { force: true, recursive: true });
+    }
+    const addResult = await execCommand({
+        command: 'git',
+        args: ['worktree', 'add', '--force', '--detach', caseWorkspacePath, input.baseCommit],
+        cwd: categoryWorkspace.gitRoot
+    });
+    if (addResult.exitCode !== 0) {
+        throw new Error(addResult.stderr || `Failed to create case workspace for ${input.category}/${input.title}`);
+    }
+    await linkPreparedNodeModules(categoryWorkspace.workspacePath, caseWorkspacePath);
+    if (input.setupCommand.trim() !== '') {
+        const setupResult = await execShellCommand({
+            command: input.setupCommand,
+            cwd: caseWorkspacePath,
+            timeoutMs: input.timeoutSec * 1000
+        });
+        if (setupResult.exitCode !== 0) {
+            throw new Error(setupResult.stderr || setupResult.stdout || 'Failed to prepare case workspace');
+        }
+    }
+    return {
+        ...categoryWorkspace,
+        caseWorkspacePath
+    };
+};
+export const disposeCaseWorkspace = async (state) => {
+    await detachWorktree(state.gitRoot, state.caseWorkspacePath);
+    if (await pathExists(state.caseWorkspacePath)) {
+        await rm(state.caseWorkspacePath, { force: true, recursive: true });
+    }
+};

package/dist/packages/channels/lark/__tests__/lark-channel.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/packages/channels/lark/__tests__/lark-channel.test.js

@@ -0,0 +1,399 @@
+import { Buffer } from 'node:buffer';
+import { Readable } from 'node:stream';
+import { describe, expect, it, vi } from 'vitest';
+describe('larkChannelDefinition.connect', () => {
+    it('sends message using lark sdk', async () => {
+        vi.resetModules();
+        const create = vi.fn().mockResolvedValue({ code: 0, data: { message_id: 'om_sent' } });
+        const Client = vi.fn().mockImplementation(() => ({
+            im: {
+                message: {
+                    create
+                }
+            }
+        }));
+        vi.doMock('@larksuiteoapi/node-sdk', () => ({
+            Client,
+            Domain: { Feishu: 'Feishu' },
+            WSClient: vi.fn(),
+            EventDispatcher: vi.fn(),
+            withTenantToken: vi.fn()
+        }));
+        const { createChannelConnection } = await import('#~/connection.js');
+        const config = {
+            type: 'lark',
+            appId: 'app_id',
+            appSecret: 'app_secret'
+        };
+        const connection = await createChannelConnection(config);
+        await expect(connection.sendMessage({ text: 'hello', receiveId: 'oc_xxx', receiveIdType: 'chat_id' }))
+            .resolves
+            .toEqual({ messageId: 'om_sent' });
+        expect(Client).toHaveBeenCalledWith({
+            appId: 'app_id',
+            appSecret: 'app_secret',
+            domain: 'Feishu'
+        });
+        expect(create).toHaveBeenCalledWith({
+            params: { receive_id_type: 'chat_id' },
+            data: {
+                receive_id: 'oc_xxx',
+                msg_type: 'text',
+                content: JSON.stringify({ text: 'hello' })
+            }
+        });
+    });
+    it('pushes follow-up bubbles through the Lark API', async () => {
+        vi.resetModules();
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                code: 0,
+                msg: 'ok',
+                tenant_access_token: 't_xxx',
+                expire: 7200
+            })
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            status: 200,
+            json: async () => ({ code: 0, msg: 'success', data: {} })
+        });
+        const Client = vi.fn().mockImplementation(() => ({
+            im: {
+                message: {
+                    create: vi.fn()
+                }
+            }
+        }));
+        vi.doMock('@larksuiteoapi/node-sdk', () => ({
+            Client,
+            Domain: { Feishu: 'Feishu' },
+            WSClient: vi.fn(),
+            EventDispatcher: vi.fn(),
+            withTenantToken: vi.fn()
+        }));
+        vi.stubGlobal('fetch', fetchMock);
+        const { createChannelConnection } = await import('#~/connection.js');
+        const config = {
+            type: 'lark',
+            appId: 'app_id',
+            appSecret: 'app_secret'
+        };
+        const connection = await createChannelConnection(config);
+        await connection.pushFollowUps?.({
+            messageId: 'om_target',
+            followUps: [
+                { content: '/help --page=1' },
+                { content: '/help --page=2' }
+            ]
+        });
+        expect(fetchMock).toHaveBeenNthCalledWith(2, 'https://fsopen.bytedance.net/open-apis/im/v1/messages/om_target/push_follow_up', {
+            method: 'POST',
+            headers: {
+                Authorization: 'Bearer t_xxx',
+                'Content-Type': 'application/json; charset=utf-8'
+            },
+            body: JSON.stringify({
+                follow_ups: [
+                    { content: '/help --page=1', i18n_contents: undefined },
+                    { content: '/help --page=2', i18n_contents: undefined }
+                ]
+            })
+        });
+    });
+    it('starts websocket receiving with handlers', async () => {
+        vi.resetModules();
+        const wsStart = vi.fn();
+        const WSClient = vi.fn().mockImplementation(() => ({
+            start: wsStart
+        }));
+        class MockDispatcher {
+            handlers = {};
+            register(entries) {
+                this.handlers = { ...this.handlers, ...entries };
+                return this;
+            }
+        }
+        const EventDispatcher = vi.fn().mockImplementation(() => new MockDispatcher());
+        vi.doMock('@larksuiteoapi/node-sdk', () => ({
+            Client: vi.fn(),
+            Domain: { Feishu: 'Feishu' },
+            WSClient,
+            EventDispatcher,
+            withTenantToken: vi.fn()
+        }));
+        const { createChannelConnection } = await import('#~/connection.js');
+        const config = {
+            type: 'lark',
+            appId: 'app_id',
+            appSecret: 'app_secret'
+        };
+        const handler = vi.fn();
+        const connection = await createChannelConnection(config);
+        await connection.startReceiving?.({
+            handlers: {
+                message: handler
+            }
+        });
+        const dispatcher = EventDispatcher.mock.results[0]?.value;
+        await dispatcher?.handlers['im.message.receive_v1']?.({
+            event_type: 'im.message.receive_v1',
+            message: {
+                chat_id: 'oc_xxx',
+                chat_type: 'p2p',
+                content: JSON.stringify({ text: 'ping' }),
+                message_id: 'om_xxx'
+            },
+            sender: {
+                sender_id: {
+                    open_id: 'ou_xxx'
+                }
+            }
+        });
+        expect(wsStart).toHaveBeenCalledWith({
+            eventDispatcher: dispatcher
+        });
+        expect(handler).toHaveBeenCalledWith(expect.objectContaining({
+            channelType: 'lark',
+            sessionType: 'direct',
+            channelId: 'oc_xxx',
+            senderId: 'ou_xxx',
+            messageId: 'om_xxx',
+            text: '[ou_xxx]:\nping'
+        }));
+    });
+    it('formats mentions and strips url backticks', async () => {
+        vi.resetModules();
+        const wsStart = vi.fn();
+        const WSClient = vi.fn().mockImplementation(() => ({
+            start: wsStart
+        }));
+        class MockDispatcher {
+            handlers = {};
+            register(entries) {
+                this.handlers = { ...this.handlers, ...entries };
+                return this;
+            }
+        }
+        const EventDispatcher = vi.fn().mockImplementation(() => new MockDispatcher());
+        vi.doMock('@larksuiteoapi/node-sdk', () => ({
+            Client: vi.fn(),
+            Domain: { Feishu: 'Feishu' },
+            WSClient,
+            EventDispatcher,
+            withTenantToken: vi.fn()
+        }));
+        const { createChannelConnection } = await import('#~/connection.js');
+        const config = {
+            type: 'lark',
+            appId: 'app_id',
+            appSecret: 'app_secret'
+        };
+        const handler = vi.fn();
+        const connection = await createChannelConnection(config);
+        await connection.startReceiving?.({
+            handlers: {
+                message: handler
+            }
+        });
+        const dispatcher = EventDispatcher.mock.results[0]?.value;
+        await dispatcher?.handlers['im.message.receive_v1']?.({
+            event_type: 'im.message.receive_v1',
+            message: {
+                chat_id: 'oc_xxx',
+                chat_type: 'group',
+                content: JSON.stringify({
+                    text: '@_user_1 /reset @_user_2 hi `https://example.com/wiki/abc`'
+                }),
+                mentions: [
+                    {
+                        id: { open_id: 'ou_1' },
+                        key: '@_user_1',
+                        name: '二介'
+                    },
+                    {
+                        id: { open_id: 'ou_2' },
+                        key: '@_user_2',
+                        name: '奉自利'
+                    }
+                ],
+                message_id: 'om_xxx'
+            },
+            sender: {
+                sender_id: {
+                    open_id: 'ou_sender'
+                }
+            }
+        });
+        expect(wsStart).toHaveBeenCalled();
+        expect(handler).toHaveBeenCalledWith(expect.objectContaining({
+            text: '[ou_sender]:\n<at type="lark" user_id="ou_1">二介</at> /reset <at type="lark" user_id="ou_2">奉自利</at> hi https://example.com/wiki/abc'
+        }));
+    });
+    it('throws when lark sdk returns non-zero code', async () => {
+        vi.resetModules();
+        const create = vi.fn().mockResolvedValue({ code: 1001, msg: 'bad' });
+        const Client = vi.fn().mockImplementation(() => ({
+            im: {
+                message: {
+                    create
+                }
+            }
+        }));
+        vi.doMock('@larksuiteoapi/node-sdk', () => ({
+            Client,
+            Domain: { Feishu: 'Feishu' },
+            WSClient: vi.fn(),
+            EventDispatcher: vi.fn(),
+            withTenantToken: vi.fn()
+        }));
+        const { createChannelConnection } = await import('#~/connection.js');
+        const config = {
+            type: 'lark',
+            appId: 'app_id',
+            appSecret: 'app_secret'
+        };
+        const connection = await createChannelConnection(config);
+        await expect(connection.sendMessage({ text: 'hello', receiveId: 'oc_xxx', receiveIdType: 'chat_id' }))
+            .rejects
+            .toThrow('Lark message send failed: bad');
+    });
+    it('parses rich content and downloads images as base64', async () => {
+        vi.resetModules();
+        const wsStart = vi.fn();
+        const WSClient = vi.fn().mockImplementation(() => ({
+            start: wsStart
+        }));
+        class MockDispatcher {
+            handlers = {};
+            register(entries) {
+                this.handlers = { ...this.handlers, ...entries };
+                return this;
+            }
+        }
+        const EventDispatcher = vi.fn().mockImplementation(() => new MockDispatcher());
+        const imageGet = vi.fn().mockResolvedValue({
+            getReadableStream: () => Readable.from([Buffer.from('fake-png')]),
+            headers: { 'content-type': 'image/png' },
+            writeFile: vi.fn()
+        });
+        const Client = vi.fn().mockImplementation(() => ({
+            im: {
+                v1: {
+                    image: {
+                        get: imageGet
+                    }
+                }
+            }
+        }));
+        const withTenantToken = vi.fn().mockReturnValue({});
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                code: 0,
+                msg: 'ok',
+                tenant_access_token: 't_xxx',
+                expire: 7200
+            })
+        });
+        vi.doMock('@larksuiteoapi/node-sdk', () => ({
+            Client,
+            Domain: { Feishu: 'Feishu' },
+            WSClient,
+            EventDispatcher,
+            withTenantToken
+        }));
+        vi.stubGlobal('fetch', fetchMock);
+        const { createChannelConnection } = await import('#~/connection.js');
+        const config = {
+            type: 'lark',
+            appId: 'app_id',
+            appSecret: 'app_secret'
+        };
+        const handler = vi.fn();
+        const connection = await createChannelConnection(config);
+        await connection.startReceiving?.({
+            handlers: {
+                message: handler
+            }
+        });
+        const dispatcher = EventDispatcher.mock.results[0]?.value;
+        const imageKey = 'img_v3_02vo_8bd8c033-b6de-428a-a36c-d5927ad653bg';
+        await dispatcher?.handlers['im.message.receive_v1']?.({
+            event_type: 'im.message.receive_v1',
+            message: {
+                chat_id: 'oc_xxx',
+                chat_type: 'group',
+                content: JSON.stringify({
+                    title: '',
+                    content: [
+                        [
+                            [
+                                {
+                                    tag: 'at',
+                                    user_id: '@_user_1',
+                                    user_name: '二介',
+                                    style: []
+                                },
+                                {
+                                    tag: 'text',
+                                    text: ' 你好',
+                                    style: []
+                                }
+                            ],
+                            [
+                                {
+                                    tag: 'img',
+                                    image_key: imageKey,
+                                    width: 316,
+                                    height: 160
+                                }
+                            ]
+                        ]
+                    ]
+                }),
+                mentions: [
+                    {
+                        id: { open_id: 'ou_1' },
+                        key: '@_user_1',
+                        name: '二介'
+                    }
+                ],
+                message_id: 'om_xxx'
+            },
+            sender: {
+                sender_id: {
+                    open_id: 'ou_sender'
+                }
+            }
+        });
+        expect(fetchMock).toHaveBeenCalledWith('https://fsopen.bytedance.net/open-apis/auth/v3/tenant_access_token/internal', expect.objectContaining({
+            method: 'POST'
+        }));
+        expect(withTenantToken).toHaveBeenCalledWith('t_xxx');
+        expect(imageGet).toHaveBeenCalledWith({
+            path: { image_key: imageKey }
+        }, {});
+        expect(handler).toHaveBeenCalledWith(expect.objectContaining({
+            text: `[ou_sender]:\n<at type="lark" user_id="ou_1">二介</at> 你好\n<img image_key="${imageKey}" />`,
+            raw: expect.objectContaining({
+                contentItems: expect.any(Array),
+                images: expect.any(Array)
+            })
+        }));
+        const isRecord = (value) => typeof value === 'object' && value != null;
+        const call0 = handler.mock.calls[0]?.[0];
+        const raw = isRecord(call0) ? call0.raw : undefined;
+        const contentItems = isRecord(raw) ? raw.contentItems : undefined;
+        expect(Array.isArray(contentItems)).toBe(true);
+        if (Array.isArray(contentItems)) {
+            expect(contentItems.some(i => isRecord(i) &&
+                i.type === 'image' &&
+                typeof i.url === 'string' &&
+                i.url.startsWith('data:image/png;base64,'))).toBe(true);
+        }
+        vi.unstubAllGlobals();
+    });
+});

package/dist/packages/channels/lark/src/connection.d.ts

@@ -0,0 +1 @@
+export declare const createChannelConnection: import("@vibe-forge/core/channel").ChannelCreateFn<any, any>;