vibe-coding-master 0.4.35 → 0.4.36

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", "vcm");
-        url.searchParams.set("tp", "vcm");
-        return url.toString();
+        const value = new URL(qrUrl).searchParams.get("user_code");
+        return stringOrNull(value);
     }
     catch {
-        return `${value}${value.includes("?") ? "&" : "?"}from=vcm&tp=vcm`;
+        return null;
     }
 }
 function positiveNumberOr(input, fallback) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-coding-master",
-  "version": "0.4.35",
+  "version": "0.4.36",
   "description": "Local GUI session cockpit for Claude Code role sessions.",
   "type": "module",
   "files": [