vibe-coding-master 0.4.34 → 0.4.36

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/setup, and Lark pairing.
+- `Gateway`: Weixin iLink or Lark setup, Gateway on/off, Gateway translation, and QR login/setup.
 - `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,15 +238,16 @@ When VCM is connected to an active task, the bottom of the sidebar shows a task
 
 ## Mobile Gateway
 
-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.
+VCM Gateway lets mobile chat clients talk 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.
 
 Gateway rules:
 
 - 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.
+- Weixin binds one phone identity to one desktop VCM instance.
+- Lark accepts any DM or @mention from a chat that can reach the bot; the most recent active Lark chat becomes the PM reply target.
+- The active mobile chat 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.
-- After binding, VCM keeps a lightweight Gateway connection for `/start` and read-only commands even when the `Gateway` toggle is off.
+- After setup, VCM keeps a lightweight Gateway connection for `/start` and read-only commands even when the `Gateway` toggle is off.
 - VCM caches the latest PM reply for each task locally, so `/start` can immediately return the current task's latest PM status when available.
 - Plain text messages go only to the current task's `project-manager`.
 - Gateway never sends directly to `architect`, `coder`, or `reviewer`.
@@ -279,11 +280,10 @@ The `Gateway` toggle is disabled until a QR login has produced a usable iLink to
 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.
+5. Turn `Gateway` on in the sidebar.
+6. Send a DM to the bot, or @mention it from a group.
 
-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.
+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. Any Lark chat that can message the bot can control Gateway; VCM always treats the most recent active Lark chat as the PM reply target.
 
 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.
 
@@ -296,14 +296,14 @@ When Gateway translation is on:
 - 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 before VCM sends them to the bound mobile chat.
+- PM replies are translated before VCM sends them to the active 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 mobile text is sent to PM as-is.
 
 ### Commands
 
-After Gateway is bound, send commands in the bound mobile conversation.
+After Gateway is configured, send commands in the active mobile conversation.
 
 When `Gateway` is off, only these commands are accepted:
 
@@ -353,9 +353,9 @@ Typical mobile flow:
 
 ### Command Behavior
 
-- `/status`: shows Gateway, binding, translation, current project, current task, and last poll status.
+- `/status`: shows Gateway, active chat, 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 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.
+- `/start`: turns Gateway on from the active 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.
@@ -378,12 +378,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 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 `Gateway` cannot be enabled, bind Weixin or complete Lark QR setup first.
+- If `/start` or read-only commands do not receive replies, check that the selected channel is connected and that Lark messages are sent as DM or group @mentions.
 - 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 mobile conversation. Retry state is memory-only and is cleared when VCM restarts.
+- If PM reply translation fails, send `/retry` from the active mobile conversation. Retry state is memory-only and is cleared when VCM restarts.
 
 ## Translation
 

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

@@ -8,9 +8,6 @@ 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/gateway/channels/lark-channel.js

@@ -21,10 +21,11 @@ export function createLarkChannel(options = {}) {
             ready: Promise.resolve(),
             error: null
         };
+        const sdkDomain = input.domain === "lark" ? Lark.Domain.Lark : Lark.Domain.Feishu;
         const client = new Lark.Client({
             appId: input.appId,
             appSecret: input.appSecret,
-            domain: input.domain
+            domain: sdkDomain
         });
         const dispatcher = new Lark.EventDispatcher({}).register({
             "im.message.receive_v1": async (data) => {
@@ -40,7 +41,7 @@ export function createLarkChannel(options = {}) {
             const wsClient = new Lark.WSClient({
                 appId: input.appId,
                 appSecret: input.appSecret,
-                domain: input.domain,
+                domain: sdkDomain,
                 source: "vcm-gateway",
                 autoReconnect: true,
                 loggerLevel: options.loggerLevel,

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

@@ -1,115 +1,146 @@
-const ACCOUNTS_BASE_URLS = {
-    feishu: "https://accounts.feishu.cn",
-    lark: "https://accounts.larksuite.com"
+import { randomUUID } from "node:crypto";
+const ACCOUNTS_HOSTS = {
+    feishu: "accounts.feishu.cn",
+    lark: "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;
+const DEFAULT_REGISTRATION_EXPIRES_IN_SECONDS = 600;
+const DEFAULT_REGISTRATION_INTERVAL_SECONDS = 5;
 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)
+    let registerAppPromise = deps.registerApp ? Promise.resolve(deps.registerApp) : null;
+    let active = null;
+    async function getRegisterApp() {
+        registerAppPromise ??= import("@larksuiteoapi/node-sdk").then((sdk) => {
+            if (typeof sdk.registerApp !== "function") {
+                throw new Error("Lark SDK does not expose registerApp.");
+            }
+            return sdk.registerApp;
         });
-        return payload;
+        return registerAppPromise;
     }
     return {
-        async init(domain) {
-            const payload = await postRegistration(domain, { action: "init" });
-            const data = responseData(payload);
-            const methods = Array.isArray(data.supported_auth_methods)
-                ? data.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 init() {
+            await getRegisterApp();
         },
         async begin(domain) {
-            const payload = await postRegistration(domain, {
-                action: "begin",
-                archetype: "PersonalAgent",
-                auth_method: "client_secret",
-                request_user_info: "open_id"
+            active?.controller.abort();
+            const registerApp = await getRegisterApp();
+            const controller = new AbortController();
+            const id = `lark-registration-${Date.now()}-${randomUUID()}`;
+            const session = {
+                id,
+                domain,
+                controller,
+                expiresAtMs: Date.now() + DEFAULT_REGISTRATION_EXPIRES_IN_SECONDS * 1000,
+                qrUrl: "",
+                intervalSeconds: DEFAULT_REGISTRATION_INTERVAL_SECONDS,
+                result: null,
+                message: undefined,
+                promise: Promise.resolve()
+            };
+            active = session;
+            let qrReadySettled = false;
+            let resolveQrReady = () => undefined;
+            let rejectQrReady = () => undefined;
+            const qrReady = new Promise((resolve, reject) => {
+                resolveQrReady = resolve;
+                rejectQrReady = reject;
             });
-            const data = responseData(payload);
-            const deviceCode = stringOrNull(data.device_code);
-            if (!deviceCode) {
-                throw new Error("Lark QR setup did not return a device_code.");
-            }
-            const qrUrl = appendQrTrackingParams(stringOrNull(data.verification_uri_complete) ?? "");
-            if (!qrUrl) {
-                throw new Error("Lark QR setup did not return a QR URL.");
-            }
+            session.promise = (async () => {
+                try {
+                    const result = await registerApp({
+                        domain: ACCOUNTS_HOSTS[domain],
+                        larkDomain: ACCOUNTS_HOSTS.lark,
+                        source: "vcm",
+                        signal: controller.signal,
+                        onQRCodeReady(info) {
+                            const qrUrl = info.url;
+                            const expireIn = positiveNumberOr(info.expireIn, DEFAULT_REGISTRATION_EXPIRES_IN_SECONDS);
+                            session.qrUrl = qrUrl;
+                            session.expiresAtMs = Date.now() + expireIn * 1000;
+                            if (!qrReadySettled) {
+                                qrReadySettled = true;
+                                resolveQrReady({ url: qrUrl, expireIn });
+                            }
+                        },
+                        onStatusChange(info) {
+                            session.message = formatSdkStatus(info);
+                        }
+                    });
+                    const appId = stringOrNull(result.client_id);
+                    const appSecret = stringOrNull(result.client_secret);
+                    const resultDomain = result.user_info?.tenant_brand === "lark" ? "lark" : domain;
+                    if (!appId || !appSecret) {
+                        session.result = {
+                            status: "failed",
+                            message: "Lark QR setup completed without app credentials."
+                        };
+                        return;
+                    }
+                    const bot = await probeBot(fetchImpl, {
+                        appId,
+                        appSecret,
+                        domain: resultDomain
+                    });
+                    session.result = {
+                        status: "confirmed",
+                        appId,
+                        appSecret,
+                        domain: resultDomain,
+                        openId: stringOrNull(result.user_info?.open_id),
+                        botName: bot.botName,
+                        botOpenId: bot.botOpenId
+                    };
+                }
+                catch (error) {
+                    const mapped = mapSdkError(error);
+                    session.result = mapped;
+                    if (!qrReadySettled) {
+                        qrReadySettled = true;
+                        rejectQrReady(new Error(mapped.message ?? "Lark QR setup failed."));
+                    }
+                }
+            })();
+            const qrInfo = await qrReady;
             return {
                 domain,
-                deviceCode,
-                qrUrl,
-                userCode: stringOrNull(data.user_code),
-                intervalSeconds: positiveNumberOr(data.interval, 5),
-                expiresInSeconds: positiveNumberOr(data.expire_in, 600)
+                deviceCode: id,
+                qrUrl: qrInfo.url,
+                userCode: extractUserCode(qrInfo.url),
+                intervalSeconds: session.intervalSeconds,
+                expiresInSeconds: qrInfo.expireIn
             };
         },
         async poll(input) {
-            const payload = await postRegistration(input.domain, {
-                action: "poll",
-                device_code: input.deviceCode,
-                tp: "ob_app"
-            });
-            const data = responseData(payload);
-            const userInfo = isObject(data.user_info) ? data.user_info : {};
-            const tenantBrand = stringOrNull(userInfo.tenant_brand);
-            const domain = tenantBrand === "lark" ? "lark" : input.domain;
-            const appId = stringOrNull(data.client_id);
-            const appSecret = stringOrNull(data.client_secret);
-            if (appId && appSecret) {
-                const bot = await probeBot(fetchImpl, {
-                    appId,
-                    appSecret,
-                    domain
-                });
+            if (!active || active.id !== input.deviceCode) {
                 return {
-                    status: "confirmed",
-                    appId,
-                    appSecret,
-                    domain,
-                    openId: stringOrNull(userInfo.open_id),
-                    botName: bot.botName,
-                    botOpenId: bot.botOpenId
+                    status: "expired",
+                    message: "Lark QR setup session is no longer active. Start a new setup."
                 };
             }
-            const error = stringOrNull(data.error) ?? stringOrNull(payload.error);
-            if (error === "expired_token") {
-                return { status: "expired", message: "Lark QR setup expired. Start a new setup." };
+            if (active.result) {
+                return active.result;
             }
-            if (error === "access_denied") {
-                return { status: "failed", message: "Lark QR setup was denied." };
+            if (Date.now() > active.expiresAtMs) {
+                active.controller.abort();
+                active.result = {
+                    status: "expired",
+                    message: "Lark QR setup expired. Start a new setup."
+                };
+                return active.result;
             }
-            const errorDescription = stringOrNull(data.error_description)
-                ?? stringOrNull(payload.error_description)
-                ?? stringOrNull(data.message)
-                ?? stringOrNull(payload.message)
-                ?? stringOrNull(data.msg)
-                ?? stringOrNull(payload.msg);
             return {
                 status: "wait",
-                message: error && error !== "authorization_pending"
-                    ? [error, errorDescription].filter(Boolean).join(": ")
-                    : undefined
+                message: active.message
             };
         }
     };
 }
-function responseData(payload) {
-    return isObject(payload.data) ? payload.data : payload;
-}
 async function probeBot(fetchImpl, input) {
     try {
         const tokenPayload = await fetchJson(fetchImpl, `${OPEN_BASE_URLS[input.domain]}/open-apis/auth/v3/tenant_access_token/internal`, {
@@ -184,29 +215,53 @@ async function fetchJson(fetchImpl, url, init = {}) {
     }
 }
 function formatPayloadError(payload) {
-    const data = responseData(payload);
     const message = [
-        stringOrNull(data.error) ?? stringOrNull(payload.error),
-        stringOrNull(data.error_description) ?? stringOrNull(payload.error_description),
-        stringOrNull(data.message) ?? stringOrNull(payload.message),
-        stringOrNull(data.msg) ?? stringOrNull(payload.msg),
-        typeof data.code === "number" || typeof data.code === "string" ? `code ${data.code}` : null,
+        stringOrNull(payload.error),
+        stringOrNull(payload.error_description),
+        stringOrNull(payload.message),
+        stringOrNull(payload.msg),
         typeof payload.code === "number" || typeof payload.code === "string" ? `code ${payload.code}` : null
     ].filter(Boolean).join(": ");
     return message ? ` (${message})` : "";
 }
-function appendQrTrackingParams(value) {
-    if (!value) {
-        return "";
+function mapSdkError(error) {
+    const code = isObject(error) ? stringOrNull(error.code) : null;
+    const description = isObject(error) ? stringOrNull(error.description) : null;
+    if (code === "expired_token") {
+        return { status: "expired", message: "Lark QR setup expired. Start a new setup." };
+    }
+    if (code === "access_denied") {
+        return { status: "failed", message: "Lark QR setup was denied." };
     }
+    if (code === "abort") {
+        return { status: "failed", message: "Lark QR setup was cancelled." };
+    }
+    if (error instanceof Error) {
+        return { status: "failed", message: error.message };
+    }
+    return {
+        status: "failed",
+        message: description ?? (code ? `Lark QR setup failed: ${code}` : "Lark QR setup failed.")
+    };
+}
+function formatSdkStatus(info) {
+    if (info.status === "domain_switched") {
+        return "Detected a Lark tenant; continuing setup on the Lark domain.";
+    }
+    if (info.status === "slow_down") {
+        return info.interval
+            ? `Lark requested slower setup polling; retrying every ${info.interval} seconds.`
+            : "Lark requested slower setup polling.";
+    }
+    return undefined;
+}
+function extractUserCode(qrUrl) {
     try {
-        const url = new URL(value);
-        url.searchParams.set("from", "hermes");
-        url.searchParams.set("tp", "hermes");
-        return url.toString();
+        const value = new URL(qrUrl).searchParams.get("user_code");
+        return stringOrNull(value);
     }
     catch {
-        return `${value}${value.includes("?") ? "&" : "?"}from=hermes&tp=hermes`;
+        return null;
     }
 }
 function positiveNumberOr(input, fallback) {

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

@@ -1,4 +1,3 @@
-import { randomInt } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { CORE_VCM_ROLE_DEFINITIONS, GATE_REVIEWER_ROLE_DEFINITION, VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
@@ -8,7 +7,6 @@ import { parseAssistantContent, resolveExistingClaudeTranscriptPath } from "../s
 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;
 const POLL_ERROR_BACKOFF_MS = 2_000;
 const POLL_LONG_BACKOFF_MS = 30_000;
@@ -203,37 +201,10 @@ export function createGatewayService(deps) {
             });
             return;
         }
-        if (settings.channel === "lark" && !settings.binding.boundUserId) {
-            settings = await saveInboundMetadata(settings, update);
-            const pairing = parseLarkPairingCommand(update.text);
-            if (!pairing || !isValidPairingCode(settings, pairing)) {
-                await reply(settings, update.fromUserId, "Lark Gateway is not paired. Generate a pairing code in desktop VCM, then send /bind CODE here.");
-                await recordMessageStatus("inbound", "ignored", update.text, "lark gateway not paired");
-                return;
-            }
-            await deps.settings.saveSettings({
-                ...settings,
-                binding: {
-                    ...settings.binding,
-                    boundUserId: update.fromUserId,
-                    loginUserId: update.fromUserId,
-                    pairingCode: null,
-                    pairingCodeExpiresAt: null,
-                    chatIds: update.chatId
-                        ? {
-                            ...settings.binding.chatIds,
-                            [update.fromUserId]: update.chatId
-                        }
-                        : settings.binding.chatIds
-                },
-                updatedAt: now()
-            });
-            await reply(await deps.settings.loadSettings(), update.fromUserId, "Lark Gateway bound. Send /help for available commands.");
-            await recordMessageStatus("inbound", "ok", update.text, undefined, "bind");
-            return;
-        }
-        settings = await saveInboundMetadata(settings, update, { bindIfMissing: true });
-        if (settings.binding.boundUserId !== update.fromUserId) {
+        settings = await saveInboundMetadata(settings, update, {
+            bind: settings.channel === "lark" ? "always" : "if-missing"
+        });
+        if (settings.channel !== "lark" && settings.binding.boundUserId !== update.fromUserId) {
             await reply(settings, update.fromUserId, "This VCM gateway is already bound to another user.");
             await recordMessageStatus("inbound", "ignored", update.text, "unbound user");
             return;
@@ -268,11 +239,19 @@ export function createGatewayService(deps) {
         }
     }
     async function saveInboundMetadata(settings, update, options = {}) {
+        const bindMode = options.bind ?? "never";
         return deps.settings.saveSettings({
             ...settings,
             binding: {
                 ...settings.binding,
-                boundUserId: options.bindIfMissing ? settings.binding.boundUserId ?? update.fromUserId : settings.binding.boundUserId,
+                boundUserId: bindMode === "always"
+                    ? update.fromUserId
+                    : bindMode === "if-missing"
+                        ? settings.binding.boundUserId ?? update.fromUserId
+                        : settings.binding.boundUserId,
+                loginUserId: bindMode === "always"
+                    ? update.fromUserId
+                    : settings.binding.loginUserId,
                 contextTokens: update.contextToken
                     ? {
                         ...settings.binding.contextTokens,
@@ -732,24 +711,18 @@ export function createGatewayService(deps) {
     async function statusText(settings) {
         const synced = await syncDesktopContext(settings);
         const project = await deps.projectService.getCurrentProject();
+        const bindingLine = synced.channel === "lark"
+            ? `Active Lark chat: ${synced.binding.boundUserId ? "yes" : "none"}`
+            : `Binding: ${synced.binding.boundUserId ? "bound" : "not bound"}`;
         return [
             `Gateway: ${synced.enabled ? "on" : "off"}${isRunning() ? " / polling" : ""}`,
-            `Binding: ${synced.binding.boundUserId ? "bound" : "not bound"}`,
+            bindingLine,
             `Translation: ${synced.translationEnabled ? "on" : "off"}`,
             `Project: ${project?.repoRoot ?? synced.currentProjectId ?? "none"}`,
             `Task: ${synced.currentTaskSlug ?? "none"}`,
             `Last poll: ${synced.lastPollStatus.state}${synced.lastPollStatus.error ? ` (${synced.lastPollStatus.error})` : ""}`
         ].join("\n");
     }
-    function parseLarkPairingCommand(text) {
-        const match = text.trim().match(/^\/bind\s+([A-Z0-9]{6,12})$/i);
-        return match?.[1]?.toUpperCase() ?? null;
-    }
-    function isValidPairingCode(settings, code) {
-        const expected = settings.binding.pairingCode?.toUpperCase();
-        const expiresAt = settings.binding.pairingCodeExpiresAt;
-        return Boolean(expected && expected === code.toUpperCase() && expiresAt && Date.parse(expiresAt) > Date.now());
-    }
     return {
         async start() {
             await ensurePolling();
@@ -789,40 +762,6 @@ export function createGatewayService(deps) {
             const settings = await deps.settings.resetBinding();
             return deps.settings.expose(settings, isRunning());
         },
-        async createPairingCode() {
-            const settings = await deps.settings.loadSettings();
-            if (settings.channel !== "lark") {
-                throw new VcmError({
-                    code: "GATEWAY_PAIRING_UNSUPPORTED",
-                    message: "Pairing codes are only available for Lark Gateway.",
-                    statusCode: 409
-                });
-            }
-            if (!settings.binding.appId || !settings.binding.appSecret) {
-                throw new VcmError({
-                    code: "GATEWAY_LARK_CONFIG_MISSING",
-                    message: "Complete Lark QR Setup before creating a pairing code.",
-                    statusCode: 409
-                });
-            }
-            const code = randomPairingCode();
-            const expiresAt = new Date(Date.now() + PAIRING_CODE_TTL_MS).toISOString();
-            const nextSettings = await deps.settings.saveSettings({
-                ...settings,
-                binding: {
-                    ...settings.binding,
-                    pairingCode: code,
-                    pairingCodeExpiresAt: expiresAt
-                },
-                updatedAt: now()
-            });
-            await ensurePolling();
-            return {
-                code,
-                expiresAt,
-                status: deps.settings.expose(nextSettings, isRunning())
-            };
-        },
         async startQrLogin() {
             const settings = await deps.settings.loadSettings();
             const channel = resolveChannel(settings);
@@ -979,8 +918,6 @@ export function createGatewayService(deps) {
                     larkOpenId: result.openId ?? null,
                     larkBotName: result.botName ?? null,
                     larkBotOpenId: result.botOpenId ?? null,
-                    pairingCode: null,
-                    pairingCodeExpiresAt: null,
                     getUpdatesBuf: ""
                 },
                 lastPollStatus: {
@@ -1322,14 +1259,6 @@ function formatAheadBehind(project) {
     }
     return ahead > 0 ? `ahead ${ahead}` : `behind ${behind}`;
 }
-function randomPairingCode() {
-    const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-    let out = "";
-    for (let index = 0; index < 8; index += 1) {
-        out += alphabet[randomInt(alphabet.length)];
-    }
-    return out;
-}
 function sleep(ms, signal) {
     return new Promise((resolve) => {
         if (signal.aborted) {

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

@@ -101,8 +101,7 @@ export function createGatewaySettingsService(deps) {
                     larkOpenId: settings.binding.larkOpenId,
                     larkBotName: settings.binding.larkBotName,
                     larkBotOpenId: settings.binding.larkBotOpenId,
-                    homeChatId: settings.binding.homeChatId,
-                    pairingCodeExpiresAt: settings.binding.pairingCodeExpiresAt
+                    homeChatId: settings.binding.homeChatId
                 },
                 pendingConfirmations: settings.pendingConfirmations,
                 lastPollStatus: settings.lastPollStatus,
@@ -152,8 +151,6 @@ export function normalizeSettings(input, timestamp, options = {
             larkBotName: normalizeNullableString(bindingInput.larkBotName),
             larkBotOpenId: normalizeNullableString(bindingInput.larkBotOpenId),
             homeChatId: normalizeNullableString(bindingInput.homeChatId),
-            pairingCode: normalizeNullableString(bindingInput.pairingCode),
-            pairingCodeExpiresAt: normalizeNullableString(bindingInput.pairingCodeExpiresAt),
             getUpdatesBuf: typeof bindingInput.getUpdatesBuf === "string" ? bindingInput.getUpdatesBuf : "",
             contextTokens: isObject(bindingInput.contextTokens)
                 ? normalizeStringRecord(bindingInput.contextTokens)
@@ -191,8 +188,6 @@ function createDefaultBinding(defaultBaseUrl = DEFAULT_BASE_URL) {
         larkBotName: null,
         larkBotOpenId: null,
         homeChatId: null,
-        pairingCode: null,
-        pairingCodeExpiresAt: null,
         getUpdatesBuf: "",
         contextTokens: {},
         chatIds: {}