vibe-coding-master 0.4.30 → 0.4.32

package/README.md

@@ -33,7 +33,7 @@ When Gate Review Gates are enabled for a task, or when a Gate Reviewer session a
 - VCM-managed root rules, role agents, repo-local VCM skills, Claude Code hooks, generated-context tools, and PR template.
 - Generated context for Rust and npm workspace module indexing plus public surface indexing.
 - Translation panel powered by the long-lived Translator session.
-- Mobile Gateway through Tencent iLink Bot API / Weixin DM, for talking to PM and managing tasks from Weixin.
+- Mobile Gateway through Tencent iLink / Weixin DM or Lark, for talking to PM and managing tasks from a phone.
 - Durable task state, role session state, handoff artifacts, and message history.
 
 ## Requirements
@@ -221,7 +221,7 @@ The left sidebar is intentionally compact and collapsible:
 - `Settings`: `Theme`, `Flow pause alert`, `Try alert`, `Messages`, and `Events`.
 - `Translation`: global conversation translation, auto-send, target language, output scope, file translation, bootstrap, memory update, session status, and Translator session access.
 - `Gate Review Gates`: global gate switches for architecture plan, validation adequacy, and final diff.
-- `Gateway`: Weixin iLink binding, Gateway on/off, Gateway translation, and QR login.
+- `Gateway`: Weixin iLink or Lark binding, Gateway on/off, Gateway translation, QR login, and Lark pairing.
 - `VCM Harness`: fixed-install status, bootstrap completion checks, and the bootstrap terminal when one is running.
 - `New Task`: one `task name` input.
 - `Tasks`: task list and task status.
@@ -238,11 +238,11 @@ When VCM is connected to an active task, the bottom of the sidebar shows a task
 
 ## Mobile Gateway
 
-VCM Gateway lets one Weixin DM identity bind to one desktop VCM instance. It is a mobile control surface for the current desktop VCM, not a remote terminal and not a group-chat bot.
+VCM Gateway lets one mobile chat identity bind to one desktop VCM instance. It supports Weixin iLink and Lark. It is a mobile control surface for the current desktop VCM, not a remote terminal and not a multi-user collaboration surface.
 
 Gateway rules:
 
-- DM only; group chat is not supported.
+- Weixin is DM only; Lark can receive group messages only when the bot is mentioned.
 - One phone identity binds to one desktop VCM instance.
 - The phone can manage projects and tasks available to that desktop VCM instance.
 - When the desktop UI has an active task selected, Gateway uses that task automatically.
@@ -273,7 +273,18 @@ Gateway state is stored locally under:
 
 The `Gateway` toggle is disabled until a QR login has produced a usable iLink token. After binding, VCM keeps receiving `/help`, `/start`, `/status`, `/projects`, and `/tasks` even when the toggle is off. Turning `Gateway` on, either from desktop or by sending `/start`, enables PM messages, task-changing commands, and PM reply push. `Reset Binding` clears the stored token and bound Weixin identity so the desktop VCM can bind again.
 
-When Gateway is turned on, VCM automatically turns off the browser `Flow pause alert` and disables `Try alert`. Gateway becomes the notification path, so the browser should not show blocking flow-pause dialogs while the user is managing the task from Weixin.
+### Bind Lark
+
+1. Create a Lark app with bot capability, message receive events, and WebSocket event delivery.
+2. Open the sidebar `Gateway` section and select `Lark`.
+3. Save the Lark App ID and App Secret.
+4. Click `Create Pairing Code`.
+5. Send `/bind CODE` to the Lark bot before the code expires.
+6. After binding succeeds, turn `Gateway` on in the sidebar.
+
+Lark credentials stay in local VCM state. The App Secret is not shown again in the UI. `Reset Binding` clears the bound Lark user/chat state while keeping the saved Lark app credentials.
+
+When Gateway is turned on, VCM automatically turns off the browser `Flow pause alert` and disables `Try alert`. Gateway becomes the notification path, so the browser should not show blocking flow-pause dialogs while the user is managing the task from the phone.
 
 ### Translation
 
@@ -281,17 +292,17 @@ The Gateway section has its own `Translation` toggle.
 
 When Gateway translation is on:
 
-- Chinese Weixin input is translated to English before being submitted to PM.
+- Mobile input is translated to English before being submitted to PM.
 - The prompt sent to PM includes only the translated English text with a `[VCM Gateway]` marker.
 - The original Chinese text is not included in the PM prompt.
-- PM replies are translated back to Chinese before VCM sends them to Weixin.
+- PM replies are translated before VCM sends them to the bound mobile chat.
 - If PM reply translation fails or times out, VCM sends a translation failure notice instead of the English source. The user can send `/retry` to retry the latest failed Gateway output translation.
 
-When Gateway translation is off, plain Weixin text is sent to PM as-is.
+When Gateway translation is off, plain mobile text is sent to PM as-is.
 
 ### Commands
 
-After Gateway is bound, send commands in the bound Weixin DM.
+After Gateway is bound, send commands in the bound mobile conversation.
 
 When `Gateway` is off, only these commands are accepted:
 
@@ -343,7 +354,7 @@ Typical mobile flow:
 
 - `/status`: shows Gateway, binding, translation, current project, current task, and last poll status.
 - `/status` also adopts the current desktop project/task when one is selected.
-- `/start`: turns Gateway on from the bound Weixin DM so full mobile task operations and PM messages are allowed. If the current task has a cached latest PM reply, `/start` includes it in the response.
+- `/start`: turns Gateway on from the bound mobile conversation so full mobile task operations and PM messages are allowed. If the current task has a cached latest PM reply, `/start` includes it in the response.
 - `/retry`: retries the latest failed Gateway output translation in the current VCM process.
 - `/projects`: lists the current/recent repositories known by the desktop VCM.
 - `/use-project <index-or-path>`: selects the Gateway's current project context.
@@ -366,12 +377,12 @@ Typical mobile flow:
 - If the QR dialog does not appear, refresh the page and click `Start QR Login` again.
 - If the QR status stays `wait`, confirm the login on the phone and click `Confirm` again.
 - If the QR code expires, start a new QR login.
-- If `Gateway` cannot be enabled, bind Weixin first.
-- If `/start` or read-only commands do not receive replies, check that the iLink token has not expired and the Weixin DM is the bound identity.
+- If `Gateway` cannot be enabled, bind Weixin or pair Lark first.
+- If `/start` or read-only commands do not receive replies, check that the selected channel is connected and the message comes from the bound identity.
 - If PM messages or task-changing commands are rejected, check that Gateway is on.
 - If plain text cannot be sent to PM, select a project and task first, and make sure the task's PM session is running and idle.
 - If PM replies are not pushed, check that Gateway is on and the PM session is producing normal Claude transcript output.
-- If PM reply translation fails, send `/retry` from the bound Weixin DM. Retry state is memory-only and is cleared when VCM restarts.
+- If PM reply translation fails, send `/retry` from the bound mobile conversation. Retry state is memory-only and is cleared when VCM restarts.
 
 ## Translation
 
@@ -393,7 +404,7 @@ The sidebar `Settings` section also stores the UI theme preference in this file.
 
 The same sidebar also has a `Flow pause alert` toggle. It is on by default and controls the local alert that fires when VCM detects that the current role flow has stopped advancing. Short flows use a weak reminder: the soft two-note chime plays 3 times, 1.4 seconds apart. Flows lasting 2 minutes or longer use a strong reminder: VCM shows an alert dialog and repeats the chime until the user confirms it. The alert sound reuses one browser audio context so repeated reminders remain reliable in stricter browsers such as Safari. Safari users may still need to manually set `Safari > Website Settings > Auto-Play > Allow All Auto-Play`; Chrome is recommended for the most reliable alert sound behavior. The `Try alert` button always triggers the strong reminder for testing.
 
-When Gateway is on, `Flow pause alert` is forced off because mobile notifications are delivered through Weixin and browser alerts can block normal workflow progress.
+When Gateway is on, `Flow pause alert` is forced off because mobile notifications are delivered through Gateway and browser alerts can block normal workflow progress.
 
 Translation behavior:
 

package/dist/backend/adapters/git-adapter.js

@@ -135,6 +135,28 @@ export function createGitAdapter(runner) {
             }
             return result.stdout;
         },
+        async getDiff(repoRoot, baseRef, headRef = null, paths = []) {
+            const result = await runGit(runner, repoRoot, [
+                "diff",
+                "--no-ext-diff",
+                "--binary",
+                "--src-prefix=a/",
+                "--dst-prefix=b/",
+                baseRef,
+                ...(headRef ? [headRef] : []),
+                "--",
+                ...paths
+            ]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_ERROR",
+                    message: "Unable to read Git diff.",
+                    statusCode: 400,
+                    hint: result.stderr
+                });
+            }
+            return result.stdout;
+        },
         async getCommitList(repoRoot, range) {
             const result = await runGit(runner, repoRoot, ["log", "--format=%H%x00%s%x00%cI%x1e", range]);
             if (result.exitCode !== 0) {

package/dist/backend/api/gateway-routes.js

@@ -8,6 +8,9 @@ export function registerGatewayRoutes(app, deps) {
     app.post("/api/gateway/qr/start", async () => {
         return deps.gatewayService.startQrLogin();
     });
+    app.post("/api/gateway/pairing-code", async () => {
+        return deps.gatewayService.createPairingCode();
+    });
     app.post("/api/gateway/qr/check", async (request) => {
         return deps.gatewayService.checkQrLogin(request.body);
     });

package/dist/backend/api/harness-routes.js

@@ -38,6 +38,13 @@ export function registerHarnessRoutes(app, deps) {
             commitSha: request.query.commit
         });
     });
+    app.get("/api/projects/harness/repository-diff/file", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
+        return deps.harnessService.getRepositoryFileDiff(task.worktreePath, {
+            baseRepoRoot: project.repoRoot,
+            path: request.query.path ?? ""
+        });
+    });
     app.post("/api/projects/harness/repository-diff/merge-to-current-branch", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
         return deps.harnessService.mergeRepositoryDiffToCurrentBranch(project.repoRoot, {

package/dist/backend/gateway/channels/lark-channel.js

@@ -0,0 +1,254 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_BASE_URL = "lark://open-platform";
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35_000;
+export function createLarkChannel(options = {}) {
+    let connection = null;
+    async function ensureConnection(input) {
+        const key = `${input.appId}:${input.appSecret}`;
+        if (connection?.key === key) {
+            return connection;
+        }
+        connection?.wsClient?.close({ force: true });
+        const Lark = await import("@larksuiteoapi/node-sdk");
+        const queue = [];
+        const waiters = [];
+        const state = {
+            key,
+            wsClient: null,
+            client: null,
+            queue,
+            waiters,
+            ready: Promise.resolve(),
+            error: null
+        };
+        const client = new Lark.Client({
+            appId: input.appId,
+            appSecret: input.appSecret,
+            domain: options.domain ?? "lark"
+        });
+        const dispatcher = new Lark.EventDispatcher({}).register({
+            "im.message.receive_v1": async (data) => {
+                for (const update of parseLarkMessageEvent(data)) {
+                    queue.push(update);
+                }
+                while (waiters.length > 0) {
+                    waiters.shift()?.();
+                }
+            }
+        });
+        const ready = new Promise((resolve, reject) => {
+            const wsClient = new Lark.WSClient({
+                appId: input.appId,
+                appSecret: input.appSecret,
+                domain: options.domain ?? "lark",
+                source: "vcm-gateway",
+                autoReconnect: true,
+                loggerLevel: options.loggerLevel,
+                onReady: () => resolve(),
+                onError: (error) => {
+                    state.error = error;
+                    reject(error);
+                    while (waiters.length > 0) {
+                        waiters.shift()?.();
+                    }
+                }
+            });
+            state.wsClient = wsClient;
+            state.client = client;
+            void wsClient.start({ eventDispatcher: dispatcher }).catch((error) => {
+                state.error = error;
+                reject(error);
+                while (waiters.length > 0) {
+                    waiters.shift()?.();
+                }
+            });
+        });
+        state.ready = ready;
+        connection = state;
+        return state;
+    }
+    return {
+        id: "lark",
+        label: "Lark",
+        defaultBaseUrl: DEFAULT_BASE_URL,
+        supportsQrLogin: false,
+        async getUpdates(input) {
+            const appId = input.account.appId?.trim();
+            const appSecret = input.account.appSecret?.trim();
+            if (!appId || !appSecret) {
+                throw new Error("Lark App ID and App Secret are required.");
+            }
+            const state = await ensureConnection({ appId, appSecret });
+            await state.ready;
+            if (state.error) {
+                throw state.error;
+            }
+            const timeoutMs = input.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+            const updates = await waitForUpdates(state, timeoutMs, input.signal);
+            if (input.signal?.aborted && connection === state) {
+                connection = null;
+            }
+            return {
+                cursor: new Date().toISOString(),
+                timeoutMs,
+                updates
+            };
+        },
+        async sendText(input) {
+            const appId = input.account.appId?.trim();
+            const appSecret = input.account.appSecret?.trim();
+            if (!appId || !appSecret) {
+                throw new Error("Lark App ID and App Secret are required.");
+            }
+            const state = await ensureConnection({ appId, appSecret });
+            await state.ready;
+            if (!state.client) {
+                throw new Error("Lark client is not initialized.");
+            }
+            const receiveId = input.chatId || input.account.homeChatId || input.toUserId;
+            const receiveIdType = input.chatId || input.account.homeChatId ? "chat_id" : "open_id";
+            if (!receiveId) {
+                throw new Error("Lark send target is missing.");
+            }
+            const result = await state.client.im.v1.message.create({
+                params: {
+                    receive_id_type: receiveIdType
+                },
+                data: {
+                    receive_id: receiveId,
+                    msg_type: "text",
+                    content: JSON.stringify({ text: input.text }),
+                    uuid: `vcm-gateway-${randomUUID()}`
+                }
+            });
+            return result?.data?.message_id ?? `vcm-gateway-${randomUUID()}`;
+        },
+        isSessionExpiredError() {
+            return false;
+        }
+    };
+}
+async function waitForUpdates(state, timeoutMs, signal) {
+    if (state.queue.length > 0) {
+        return state.queue.splice(0);
+    }
+    if (signal?.aborted) {
+        state.wsClient?.close({ force: true });
+        return [];
+    }
+    await new Promise((resolve) => {
+        let settled = false;
+        let timeout;
+        const finish = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            const index = state.waiters.indexOf(waiter);
+            if (index >= 0) {
+                state.waiters.splice(index, 1);
+            }
+            signal?.removeEventListener("abort", finish);
+            resolve();
+        };
+        const waiter = finish;
+        timeout = setTimeout(finish, timeoutMs);
+        state.waiters.push(waiter);
+        signal?.addEventListener("abort", finish, { once: true });
+    });
+    if (state.error) {
+        throw state.error;
+    }
+    if (signal?.aborted) {
+        state.wsClient?.close({ force: true });
+        return [];
+    }
+    return state.queue.splice(0);
+}
+function parseLarkMessageEvent(data) {
+    if (!isObject(data)) {
+        return [];
+    }
+    const event = isObject(data.event) ? data.event : data;
+    if (!isObject(event)) {
+        return [];
+    }
+    const message = isObject(event.message) ? event.message : {};
+    const sender = isObject(event.sender) ? event.sender : {};
+    const senderId = isObject(sender.sender_id) ? sender.sender_id : {};
+    const fromUserId = stringOrUndefined(senderId.open_id)
+        ?? stringOrUndefined(senderId.user_id)
+        ?? stringOrUndefined(senderId.union_id);
+    const messageId = stringOrUndefined(message.message_id);
+    const chatId = stringOrUndefined(message.chat_id);
+    const chatType = stringOrUndefined(message.chat_type);
+    const rawText = extractTextContent(message.content);
+    if (!fromUserId || !messageId || !rawText.trim()) {
+        return [];
+    }
+    const mentions = Array.isArray(message.mentions) ? message.mentions : [];
+    const isDirect = chatType === "p2p";
+    if (!isDirect && mentions.length === 0) {
+        return [];
+    }
+    const text = stripMentionTokens(rawText, mentions);
+    if (!text.trim()) {
+        return [];
+    }
+    const createdAt = normalizeLarkTimestamp(message.create_time);
+    return [{
+            messageId,
+            fromUserId,
+            chatId,
+            chatType: isDirect ? "dm" : "group",
+            text,
+            createdAt,
+            raw: data
+        }];
+}
+function extractTextContent(input) {
+    if (typeof input !== "string") {
+        return "";
+    }
+    try {
+        const parsed = JSON.parse(input);
+        if (isObject(parsed) && typeof parsed.text === "string") {
+            return parsed.text;
+        }
+    }
+    catch {
+        return input;
+    }
+    return input;
+}
+function stripMentionTokens(text, mentions) {
+    let out = text;
+    for (const mention of mentions) {
+        if (!isObject(mention)) {
+            continue;
+        }
+        const key = stringOrUndefined(mention.key);
+        if (key) {
+            out = out.replaceAll(key, "");
+        }
+    }
+    return out.replace(/<at\b[^>]*>.*?<\/at>/g, "").trim();
+}
+function normalizeLarkTimestamp(input) {
+    const raw = stringOrUndefined(input);
+    if (!raw) {
+        return undefined;
+    }
+    const timestamp = Number.parseInt(raw, 10);
+    if (!Number.isFinite(timestamp)) {
+        return undefined;
+    }
+    return new Date(timestamp).toISOString();
+}
+function stringOrUndefined(input) {
+    return typeof input === "string" && input.trim() ? input.trim() : undefined;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/backend/gateway/channels/weixin-ilink-channel.js

@@ -92,10 +92,14 @@ export function createWeixinIlinkChannel(options = {}) {
         });
     }
     return {
+        id: "weixin-ilink",
+        label: "Weixin iLink",
+        defaultBaseUrl: DEFAULT_BASE_URL,
+        supportsQrLogin: true,
         async startQrLogin(input) {
             const payload = await post({
                 requestBaseUrl: baseUrl,
-                endpoint: `ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(input.botType ?? DEFAULT_BOT_TYPE)}`,
+                endpoint: `ilink/bot/get_bot_qrcode?bot_type=${encodeURIComponent(DEFAULT_BOT_TYPE)}`,
                 body: {
                     local_token_list: input.localTokenList ?? []
                 },
@@ -134,7 +138,7 @@ export function createWeixinIlinkChannel(options = {}) {
             const payload = await post({
                 requestBaseUrl: input.account.baseUrl,
                 endpoint: "ilink/bot/getupdates",
-                token: input.account.token,
+                token: input.account.token ?? undefined,
                 timeoutMs: input.timeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS,
                 label: "getupdates",
                 signal: input.signal,
@@ -160,7 +164,7 @@ export function createWeixinIlinkChannel(options = {}) {
             const payload = await post({
                 requestBaseUrl: input.account.baseUrl,
                 endpoint: "ilink/bot/sendmessage",
-                token: input.account.token,
+                token: input.account.token ?? undefined,
                 label: "sendmessage",
                 body: {
                     msg: {
@@ -184,6 +188,9 @@ export function createWeixinIlinkChannel(options = {}) {
             });
             assertIlinkOk(payload, "sendmessage");
             return clientId;
+        },
+        isSessionExpiredError(error) {
+            return error instanceof Error && error.message.toLowerCase().includes("expired");
         }
     };
 }

package/dist/backend/gateway/gateway-channel.js

@@ -0,0 +1,16 @@
+export function createGatewayChannelRegistry(channels) {
+    if (channels.length === 0) {
+        throw new Error("At least one gateway channel must be registered.");
+    }
+    const byId = new Map();
+    for (const channel of channels) {
+        byId.set(channel.id, channel);
+    }
+    const defaultChannel = channels[0];
+    return {
+        defaultChannel,
+        get(channel) {
+            return byId.get(channel) ?? defaultChannel;
+        }
+    };
+}