vibe-coding-master 0.4.31 → 0.4.33

package/README.md

@@ -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 or Lark binding, Gateway on/off, Gateway translation, QR login, and Lark pairing.
+- `Gateway`: Weixin iLink or Lark binding, Gateway on/off, Gateway translation, QR login/setup, 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.
@@ -275,14 +275,15 @@ The `Gateway` toggle is disabled until a QR login has produced a usable iLink to
 
 ### 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.
+1. Open the sidebar `Gateway` section and select `Lark`.
+2. Click `Start QR Setup`.
+3. Scan the QR code with Lark and approve bot creation.
+4. Click `Confirm` in the setup dialog.
+5. Click `Create Pairing Code`.
+6. Send `/bind CODE` to the Lark bot before the code expires.
+7. 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.
+Lark QR setup creates/configures the bot app and stores the resulting App ID/App Secret in local VCM state. The App Secret is not shown 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.
 
@@ -377,7 +378,7 @@ 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 or pair Lark first.
+- If `Gateway` cannot be enabled, bind Weixin or complete Lark QR setup and pairing 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.

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

@@ -14,6 +14,12 @@ export function registerGatewayRoutes(app, deps) {
     app.post("/api/gateway/qr/check", async (request) => {
         return deps.gatewayService.checkQrLogin(request.body);
     });
+    app.post("/api/gateway/lark-registration/start", async () => {
+        return deps.gatewayService.startLarkRegistration();
+    });
+    app.post("/api/gateway/lark-registration/check", async () => {
+        return deps.gatewayService.checkLarkRegistration();
+    });
     app.post("/api/gateway/binding/reset", async () => {
         return deps.gatewayService.resetBinding();
     });

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

@@ -4,7 +4,7 @@ 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}`;
+        const key = `${input.domain}:${input.appId}:${input.appSecret}`;
         if (connection?.key === key) {
             return connection;
         }
@@ -24,7 +24,7 @@ export function createLarkChannel(options = {}) {
         const client = new Lark.Client({
             appId: input.appId,
             appSecret: input.appSecret,
-            domain: options.domain ?? "lark"
+            domain: input.domain
         });
         const dispatcher = new Lark.EventDispatcher({}).register({
             "im.message.receive_v1": async (data) => {
@@ -40,7 +40,7 @@ export function createLarkChannel(options = {}) {
             const wsClient = new Lark.WSClient({
                 appId: input.appId,
                 appSecret: input.appSecret,
-                domain: options.domain ?? "lark",
+                domain: input.domain,
                 source: "vcm-gateway",
                 autoReconnect: true,
                 loggerLevel: options.loggerLevel,
@@ -75,10 +75,11 @@ export function createLarkChannel(options = {}) {
         async getUpdates(input) {
             const appId = input.account.appId?.trim();
             const appSecret = input.account.appSecret?.trim();
+            const domain = input.account.larkDomain ?? options.domain ?? "lark";
             if (!appId || !appSecret) {
                 throw new Error("Lark App ID and App Secret are required.");
             }
-            const state = await ensureConnection({ appId, appSecret });
+            const state = await ensureConnection({ appId, appSecret, domain });
             await state.ready;
             if (state.error) {
                 throw state.error;
@@ -97,10 +98,11 @@ export function createLarkChannel(options = {}) {
         async sendText(input) {
             const appId = input.account.appId?.trim();
             const appSecret = input.account.appSecret?.trim();
+            const domain = input.account.larkDomain ?? options.domain ?? "lark";
             if (!appId || !appSecret) {
                 throw new Error("Lark App ID and App Secret are required.");
             }
-            const state = await ensureConnection({ appId, appSecret });
+            const state = await ensureConnection({ appId, appSecret, domain });
             await state.ready;
             if (!state.client) {
                 throw new Error("Lark client is not initialized.");

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

@@ -0,0 +1,194 @@
+const ACCOUNTS_BASE_URLS = {
+    feishu: "https://accounts.feishu.cn",
+    lark: "https://accounts.larksuite.com"
+};
+const OPEN_BASE_URLS = {
+    feishu: "https://open.feishu.cn",
+    lark: "https://open.larksuite.com"
+};
+const REGISTRATION_PATH = "/oauth/v1/app/registration";
+const REQUEST_TIMEOUT_MS = 10_000;
+export function createLarkRegistrationClient(deps = {}) {
+    const fetchImpl = deps.fetch ?? fetch;
+    async function postRegistration(domain, body) {
+        const url = `${ACCOUNTS_BASE_URLS[domain]}${REGISTRATION_PATH}`;
+        const payload = await fetchJson(fetchImpl, url, {
+            method: "POST",
+            headers: {
+                "content-type": "application/x-www-form-urlencoded"
+            },
+            body: new URLSearchParams(body)
+        });
+        return payload;
+    }
+    return {
+        async init(domain) {
+            const payload = await postRegistration(domain, { action: "init" });
+            const methods = Array.isArray(payload.supported_auth_methods)
+                ? payload.supported_auth_methods.filter((value) => typeof value === "string")
+                : [];
+            if (!methods.includes("client_secret")) {
+                throw new Error(`Lark QR setup does not support client_secret auth. Supported methods: ${methods.join(", ") || "none"}.`);
+            }
+        },
+        async begin(domain) {
+            const payload = await postRegistration(domain, {
+                action: "begin",
+                archetype: "PersonalAgent",
+                auth_method: "client_secret",
+                request_user_info: "open_id"
+            });
+            const deviceCode = stringOrNull(payload.device_code);
+            if (!deviceCode) {
+                throw new Error("Lark QR setup did not return a device_code.");
+            }
+            const qrUrl = appendQrTrackingParams(stringOrNull(payload.verification_uri_complete) ?? "");
+            if (!qrUrl) {
+                throw new Error("Lark QR setup did not return a QR URL.");
+            }
+            return {
+                domain,
+                deviceCode,
+                qrUrl,
+                userCode: stringOrNull(payload.user_code),
+                intervalSeconds: positiveNumberOr(payload.interval, 5),
+                expiresInSeconds: positiveNumberOr(payload.expire_in, 600)
+            };
+        },
+        async poll(input) {
+            const payload = await postRegistration(input.domain, {
+                action: "poll",
+                device_code: input.deviceCode,
+                tp: "ob_app"
+            });
+            const userInfo = isObject(payload.user_info) ? payload.user_info : {};
+            const tenantBrand = stringOrNull(userInfo.tenant_brand);
+            const domain = tenantBrand === "lark" ? "lark" : input.domain;
+            const appId = stringOrNull(payload.client_id);
+            const appSecret = stringOrNull(payload.client_secret);
+            if (appId && appSecret) {
+                const bot = await probeBot(fetchImpl, {
+                    appId,
+                    appSecret,
+                    domain
+                });
+                return {
+                    status: "confirmed",
+                    appId,
+                    appSecret,
+                    domain,
+                    openId: stringOrNull(userInfo.open_id),
+                    botName: bot.botName,
+                    botOpenId: bot.botOpenId
+                };
+            }
+            const error = stringOrNull(payload.error);
+            if (error === "expired_token") {
+                return { status: "expired", message: "Lark QR setup expired. Start a new setup." };
+            }
+            if (error === "access_denied") {
+                return { status: "failed", message: "Lark QR setup was denied." };
+            }
+            return {
+                status: "wait",
+                message: error && error !== "authorization_pending" ? error : undefined
+            };
+        }
+    };
+}
+async function probeBot(fetchImpl, input) {
+    try {
+        const tokenPayload = await fetchJson(fetchImpl, `${OPEN_BASE_URLS[input.domain]}/open-apis/auth/v3/tenant_access_token/internal`, {
+            method: "POST",
+            headers: {
+                "content-type": "application/json"
+            },
+            body: JSON.stringify({
+                app_id: input.appId,
+                app_secret: input.appSecret
+            })
+        });
+        const accessToken = stringOrNull(tokenPayload.tenant_access_token);
+        if (!accessToken) {
+            return { botName: null, botOpenId: null };
+        }
+        const botPayload = await fetchJson(fetchImpl, `${OPEN_BASE_URLS[input.domain]}/open-apis/bot/v3/info`, {
+            headers: {
+                authorization: `Bearer ${accessToken}`,
+                "content-type": "application/json"
+            }
+        });
+        if (botPayload.code !== 0) {
+            return { botName: null, botOpenId: null };
+        }
+        const bot = isObject(botPayload.bot)
+            ? botPayload.bot
+            : isObject(botPayload.data) && isObject(botPayload.data.bot)
+                ? botPayload.data.bot
+                : {};
+        return {
+            botName: stringOrNull(bot.app_name) ?? stringOrNull(bot.bot_name),
+            botOpenId: stringOrNull(bot.open_id)
+        };
+    }
+    catch {
+        return { botName: null, botOpenId: null };
+    }
+}
+async function fetchJson(fetchImpl, url, init = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+    try {
+        const response = await fetchImpl(url, {
+            ...init,
+            signal: controller.signal
+        });
+        const text = await response.text();
+        if (!text) {
+            if (!response.ok) {
+                throw new Error(`${response.status} ${response.statusText}`);
+            }
+            return {};
+        }
+        const payload = JSON.parse(text);
+        if (!isObject(payload)) {
+            throw new Error("Lark setup response was not a JSON object.");
+        }
+        if (!response.ok && !payload.error) {
+            throw new Error(`${response.status} ${response.statusText}`);
+        }
+        return payload;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new Error("Lark QR setup request timed out.");
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function appendQrTrackingParams(value) {
+    if (!value) {
+        return "";
+    }
+    try {
+        const url = new URL(value);
+        url.searchParams.set("from", "vcm");
+        url.searchParams.set("tp", "vcm");
+        return url.toString();
+    }
+    catch {
+        return `${value}${value.includes("?") ? "&" : "?"}from=vcm&tp=vcm`;
+    }
+}
+function positiveNumberOr(input, fallback) {
+    return typeof input === "number" && Number.isFinite(input) && input > 0 ? input : fallback;
+}
+function stringOrNull(input) {
+    return typeof input === "string" && input.trim() ? input.trim() : null;
+}
+function isObject(input) {
+    return Boolean(input && typeof input === "object" && !Array.isArray(input));
+}

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

@@ -6,6 +6,7 @@ import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 import { parseAssistantContent, resolveExistingClaudeTranscriptPath } from "../services/claude-transcript-service.js";
 import { parseGatewayCommand } from "./gateway-command-parser.js";
+import { createLarkRegistrationClient } from "./channels/lark-registration.js";
 const QR_LOGIN_TTL_MS = 8 * 60 * 1000;
 const PAIRING_CODE_TTL_MS = 10 * 60 * 1000;
 const CLOSE_CONFIRM_TTL_MS = 10 * 60 * 1000;
@@ -24,10 +25,12 @@ const COMMANDS_ALLOWED_WHEN_DISABLED = new Set([
 ]);
 export function createGatewayService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
+    const larkRegistration = deps.larkRegistration ?? createLarkRegistrationClient();
     let pollAbort = null;
     let pollLoopPromise = null;
     let pollStartingPromise = null;
     let qrLogin = null;
+    let larkRegistrationState = null;
     let lastFailedTranslation = null;
     function isRunning() {
         return Boolean(pollAbort && !pollAbort.signal.aborted);
@@ -90,6 +93,7 @@ export function createGatewayService(deps) {
             token: settings.binding.token,
             appId: settings.binding.appId,
             appSecret: settings.binding.appSecret,
+            larkDomain: settings.binding.larkDomain,
             homeChatId: settings.binding.homeChatId
         };
     }
@@ -633,7 +637,7 @@ export function createGatewayService(deps) {
         const settings = await deps.settings.loadSettings();
         if (!toAccount(settings)) {
             return settings.channel === "lark"
-                ? "Gateway is not configured. Save Lark App ID and App Secret in desktop VCM first."
+                ? "Gateway is not configured. Complete Lark QR Setup in desktop VCM first."
                 : "Gateway is not bound. Start QR login from desktop VCM first.";
         }
         if (settings.enabled) {
@@ -758,7 +762,13 @@ export function createGatewayService(deps) {
             return deps.settings.expose(settings, isRunning());
         },
         async updateSettings(input) {
-            let settings = await deps.settings.updateSettings(input);
+            const updateInput = input.channel && input.baseUrl === undefined
+                ? {
+                    ...input,
+                    baseUrl: deps.channels.get(input.channel).defaultBaseUrl
+                }
+                : input;
+            let settings = await deps.settings.updateSettings(updateInput);
             if (settings.enabled) {
                 settings = await syncDesktopContext(settings);
             }
@@ -773,6 +783,8 @@ export function createGatewayService(deps) {
         async resetBinding() {
             await stopPolling();
             lastFailedTranslation = null;
+            qrLogin = null;
+            larkRegistrationState = null;
             const settings = await deps.settings.resetBinding();
             return deps.settings.expose(settings, isRunning());
         },
@@ -788,7 +800,7 @@ export function createGatewayService(deps) {
             if (!settings.binding.appId || !settings.binding.appSecret) {
                 throw new VcmError({
                     code: "GATEWAY_LARK_CONFIG_MISSING",
-                    message: "Save Lark App ID and App Secret before creating a pairing code.",
+                    message: "Complete Lark QR Setup before creating a pairing code.",
                     statusCode: 409
                 });
             }
@@ -893,6 +905,95 @@ export function createGatewayService(deps) {
                 loginUserId: result.loginUserId
             };
         },
+        async startLarkRegistration() {
+            await stopPolling();
+            const settings = await deps.settings.updateSettings({
+                channel: "lark",
+                baseUrl: deps.channels.get("lark").defaultBaseUrl
+            });
+            const domain = "lark";
+            await larkRegistration.init(domain);
+            const begin = await larkRegistration.begin(domain);
+            larkRegistrationState = {
+                domain: begin.domain,
+                deviceCode: begin.deviceCode,
+                qrUrl: begin.qrUrl,
+                userCode: begin.userCode,
+                intervalSeconds: begin.intervalSeconds,
+                expiresAt: new Date(Date.now() + begin.expiresInSeconds * 1000).toISOString()
+            };
+            return {
+                status: "wait",
+                qrUrl: begin.qrUrl,
+                userCode: begin.userCode,
+                intervalSeconds: begin.intervalSeconds,
+                expiresAt: larkRegistrationState.expiresAt
+            };
+        },
+        async checkLarkRegistration() {
+            if (!larkRegistrationState || Date.parse(larkRegistrationState.expiresAt) < Date.now()) {
+                larkRegistrationState = null;
+                return {
+                    status: "expired",
+                    message: "Lark QR setup expired. Start a new setup."
+                };
+            }
+            const result = await larkRegistration.poll({
+                domain: larkRegistrationState.domain,
+                deviceCode: larkRegistrationState.deviceCode
+            });
+            if (result.status !== "confirmed") {
+                if (result.status === "expired" || result.status === "failed") {
+                    larkRegistrationState = null;
+                }
+                return {
+                    status: result.status,
+                    message: result.message
+                };
+            }
+            if (!result.appId || !result.appSecret || !result.domain) {
+                larkRegistrationState = null;
+                return {
+                    status: "failed",
+                    message: "Lark QR setup completed without app credentials."
+                };
+            }
+            const current = await deps.settings.loadSettings();
+            const settings = await deps.settings.saveSettings({
+                ...current,
+                channel: "lark",
+                binding: {
+                    ...current.binding,
+                    appId: result.appId,
+                    appSecret: result.appSecret,
+                    larkDomain: result.domain,
+                    larkOpenId: result.openId ?? null,
+                    larkBotName: result.botName ?? null,
+                    larkBotOpenId: result.botOpenId ?? null,
+                    pairingCode: null,
+                    pairingCodeExpiresAt: null,
+                    getUpdatesBuf: ""
+                },
+                lastPollStatus: {
+                    state: "idle",
+                    checkedAt: now()
+                },
+                updatedAt: now()
+            });
+            larkRegistrationState = null;
+            await ensurePolling();
+            const status = deps.settings.expose(settings, isRunning());
+            return {
+                status: "confirmed",
+                appIdConfigured: Boolean(result.appId),
+                appSecretConfigured: Boolean(result.appSecret),
+                larkDomain: result.domain,
+                larkOpenId: result.openId ?? null,
+                larkBotName: result.botName ?? null,
+                larkBotOpenId: result.botOpenId ?? null,
+                gatewayStatus: status
+            };
+        },
         async handlePmStop(input) {
             if (input.session.role !== "project-manager") {
                 return;

package/dist/backend/gateway/gateway-settings-service.js

@@ -45,10 +45,7 @@ export function createGatewaySettingsService(deps) {
                     ...current.binding,
                     baseUrl: input.baseUrl !== undefined
                         ? normalizeBaseUrl(input.baseUrl, normalizeOptions.defaultBaseUrl)
-                        : current.binding.baseUrl,
-                    appId: input.larkAppId !== undefined ? normalizeNullableString(input.larkAppId) : current.binding.appId,
-                    appSecret: input.larkAppSecret !== undefined ? normalizeNullableString(input.larkAppSecret) : current.binding.appSecret,
-                    homeChatId: input.larkHomeChatId !== undefined ? normalizeNullableString(input.larkHomeChatId) : current.binding.homeChatId
+                        : current.binding.baseUrl
                 },
                 updatedAt: now()
             });
@@ -64,6 +61,10 @@ export function createGatewaySettingsService(deps) {
                     baseUrl: current.binding.baseUrl || normalizeOptions.defaultBaseUrl,
                     appId: current.binding.appId,
                     appSecret: current.binding.appSecret,
+                    larkDomain: current.binding.larkDomain,
+                    larkOpenId: current.binding.larkOpenId,
+                    larkBotName: current.binding.larkBotName,
+                    larkBotOpenId: current.binding.larkBotOpenId,
                     homeChatId: current.binding.homeChatId
                 },
                 dedupe: {
@@ -96,6 +97,10 @@ export function createGatewaySettingsService(deps) {
                     appId: settings.binding.appId,
                     appIdConfigured: Boolean(settings.binding.appId),
                     appSecretConfigured: Boolean(settings.binding.appSecret),
+                    larkDomain: settings.binding.larkDomain,
+                    larkOpenId: settings.binding.larkOpenId,
+                    larkBotName: settings.binding.larkBotName,
+                    larkBotOpenId: settings.binding.larkBotOpenId,
                     homeChatId: settings.binding.homeChatId,
                     pairingCodeExpiresAt: settings.binding.pairingCodeExpiresAt
                 },
@@ -142,6 +147,10 @@ export function normalizeSettings(input, timestamp, options = {
             token: normalizeNullableString(bindingInput.token),
             appId: normalizeNullableString(bindingInput.appId),
             appSecret: normalizeNullableString(bindingInput.appSecret),
+            larkDomain: normalizeLarkDomain(bindingInput.larkDomain),
+            larkOpenId: normalizeNullableString(bindingInput.larkOpenId),
+            larkBotName: normalizeNullableString(bindingInput.larkBotName),
+            larkBotOpenId: normalizeNullableString(bindingInput.larkBotOpenId),
             homeChatId: normalizeNullableString(bindingInput.homeChatId),
             pairingCode: normalizeNullableString(bindingInput.pairingCode),
             pairingCodeExpiresAt: normalizeNullableString(bindingInput.pairingCodeExpiresAt),
@@ -177,6 +186,10 @@ function createDefaultBinding(defaultBaseUrl = DEFAULT_BASE_URL) {
         token: null,
         appId: null,
         appSecret: null,
+        larkDomain: null,
+        larkOpenId: null,
+        larkBotName: null,
+        larkBotOpenId: null,
         homeChatId: null,
         pairingCode: null,
         pairingCodeExpiresAt: null,
@@ -188,6 +201,9 @@ function createDefaultBinding(defaultBaseUrl = DEFAULT_BASE_URL) {
 function normalizeGatewayChannel(input, fallback) {
     return input === "weixin-ilink" || input === "lark" ? input : fallback;
 }
+function normalizeLarkDomain(input) {
+    return input === "lark" || input === "feishu" ? input : null;
+}
 function normalizeCloseTaskConfirmation(input) {
     if (!isObject(input)) {
         return null;